libgpiod: Add Rust bindings

Hello,

Here is another version of rust bindings for libgpiod v2.0, based of the next/libgpiod-2.0 + the HTE patch from Bartosz [1].

Pushed here:

https://github.com/vireshk/libgpiod master

[I have pushed v5 and v4 there too, in case someone wants to look at the changes].

V5->V6:
- Updates according to the new line-settings interface.
- New file, line_settings.rs.
- Renamed 'enum Setting' as 'SettingVal' to avoid conflicting names, as we also have 'struct Settings' now.
- Support for HTE clock type.
- Implement 'Eq' for public structure/enums (reported by build).
- Remove 'SettingKindMap' and 'SettingMap' as they aren't required anymore.
- Updated tests based on new interface.

V4->V5:
- Arrange as workspace with crates for libgpiod-sys, libgpiod, gpiosim.
- Use static libgpiod and libgpiosim libraries instead of rebuilding again.
- Arrange in modules instead of flattened approach.
- New enums like Setting and SettingKind and new types based on them SettingMap and SettingKindMap.
- New property independent helpers for line_config, like set_prop_default().
- Improved tests/examples, new example for gpiowatch.
- Add pre-built bindings for gpiosim too.
- Many other changes.

V3->V4:
- Rebased on top of new changes, and made changes accordingly.
- Added rust integration tests with gpiosim.
- Found a kernel bug with tests, sent a patch for that to LKML.

V2->V3:
- Remove naming redundancy, users just need to do this now
use libgpiod:{Chip, Direction, LineConfig} now (Bartosz);
- Fix lifetime issues between event-buffer and edge-event modules, the event buffer is released after the last edge-event reference is dropped (Bartosz).
- Allow edge-event to be copied, and freed later (Bartosz).
- Add two separate rust crates, sys and wrapper (Gerard).
- Null-terminate the strings passed to libgpiod (Wedson).
- Drop unnecessary checks to validate string returned from chip:name/label/path.
- Fix SAFETY comments (Wedson).
- Drop unnecessary clone() instances (Bartosz).

V1->V2:
- Added examples (I tested everything except gpiomon.rs, didn't have right hardware/mock device to test).
- Build rust bindings as part of Make, update documentation.

Thanks.

--
Viresh

[1] https://lore.kernel.org/all/[email protected]/

Viresh Kumar (8):
libgpiod: Add libgpiod-sys rust crate
libgpiod-sys: Add pre generated rust bindings
libgpiod: Add rust wrapper crate
libgpiod: Add rust examples
libgpiod: Add gpiosim rust crate
gpiosim: Add pre generated rust bindings
libgpiod: Add rust tests
libgpiod: Integrate building of rust bindings with make

 .gitignore                                    |    5 +
 README                                        |    8 +-
 TODO                                          |    8 -
 bindings/Makefile.am                          |    6 +
 bindings/rust/Cargo.toml                      |    7 +
 bindings/rust/Makefile.am                     |   18 +
 bindings/rust/gpiosim/Cargo.toml              |   18 +
 bindings/rust/gpiosim/README.md               |   11 +
 bindings/rust/gpiosim/build.rs                |   43 +
 bindings/rust/gpiosim/src/bindings.rs         |  180 +++
 bindings/rust/gpiosim/src/lib.rs              |   25 +
 bindings/rust/gpiosim/src/sim.rs              |  323 +++++
 bindings/rust/libgpiod-sys/Cargo.toml         |   15 +
 bindings/rust/libgpiod-sys/README.md          |   11 +
 bindings/rust/libgpiod-sys/build.rs           |   41 +
 bindings/rust/libgpiod-sys/src/bindings.rs    | 1173 +++++++++++++++++
 bindings/rust/libgpiod-sys/src/lib.rs         |   13 +
 bindings/rust/libgpiod/Cargo.toml             |   16 +
 bindings/rust/libgpiod/examples/gpiodetect.rs |   30 +
 bindings/rust/libgpiod/examples/gpiofind.rs   |   35 +
 bindings/rust/libgpiod/examples/gpioget.rs    |   42 +
 bindings/rust/libgpiod/examples/gpioinfo.rs   |   95 ++
 bindings/rust/libgpiod/examples/gpiomon.rs    |   73 +
 bindings/rust/libgpiod/examples/gpioset.rs    |   60 +
 bindings/rust/libgpiod/examples/gpiowatch.rs  |   54 +
 bindings/rust/libgpiod/src/chip.rs            |  253 ++++
 bindings/rust/libgpiod/src/edge_event.rs      |  102 ++
 bindings/rust/libgpiod/src/event_buffer.rs    |   90 ++
 bindings/rust/libgpiod/src/info_event.rs      |   68 +
 bindings/rust/libgpiod/src/lib.rs             |  471 +++++++
 bindings/rust/libgpiod/src/line_config.rs     |  118 ++
 bindings/rust/libgpiod/src/line_info.rs       |  180 +++
 bindings/rust/libgpiod/src/line_request.rs    |  246 ++++
 bindings/rust/libgpiod/src/line_settings.rs   |  277 ++++
 bindings/rust/libgpiod/src/request_config.rs  |   96 ++
 bindings/rust/libgpiod/tests/chip.rs          |   97 ++
 bindings/rust/libgpiod/tests/common/config.rs |  134 ++
 bindings/rust/libgpiod/tests/common/mod.rs    |   10 +
 bindings/rust/libgpiod/tests/edge_event.rs    |  294 +++++
 bindings/rust/libgpiod/tests/info_event.rs    |  125 ++
 bindings/rust/libgpiod/tests/line_config.rs   |  105 ++
 bindings/rust/libgpiod/tests/line_info.rs     |  279 ++++
 bindings/rust/libgpiod/tests/line_request.rs  |  519 ++++++++
 bindings/rust/libgpiod/tests/line_settings.rs |  226 ++++
 .../rust/libgpiod/tests/request_config.rs     |   38 +
 configure.ac                                  |   16 +
 46 files changed, 6043 insertions(+), 11 deletions(-)
 create mode 100644 bindings/rust/Cargo.toml
 create mode 100644 bindings/rust/Makefile.am
 create mode 100644 bindings/rust/gpiosim/Cargo.toml
 create mode 100644 bindings/rust/gpiosim/README.md
 create mode 100644 bindings/rust/gpiosim/build.rs
 create mode 100644 bindings/rust/gpiosim/src/bindings.rs
 create mode 100644 bindings/rust/gpiosim/src/lib.rs
 create mode 100644 bindings/rust/gpiosim/src/sim.rs
 create mode 100644 bindings/rust/libgpiod-sys/Cargo.toml
 create mode 100644 bindings/rust/libgpiod-sys/README.md
 create mode 100644 bindings/rust/libgpiod-sys/build.rs
 create mode 100644 bindings/rust/libgpiod-sys/src/bindings.rs
 create mode 100644 bindings/rust/libgpiod-sys/src/lib.rs
 create mode 100644 bindings/rust/libgpiod/Cargo.toml
 create mode 100644 bindings/rust/libgpiod/examples/gpiodetect.rs
 create mode 100644 bindings/rust/libgpiod/examples/gpiofind.rs
 create mode 100644 bindings/rust/libgpiod/examples/gpioget.rs
 create mode 100644 bindings/rust/libgpiod/examples/gpioinfo.rs
 create mode 100644 bindings/rust/libgpiod/examples/gpiomon.rs
 create mode 100644 bindings/rust/libgpiod/examples/gpioset.rs
 create mode 100644 bindings/rust/libgpiod/examples/gpiowatch.rs
 create mode 100644 bindings/rust/libgpiod/src/chip.rs
 create mode 100644 bindings/rust/libgpiod/src/edge_event.rs
 create mode 100644 bindings/rust/libgpiod/src/event_buffer.rs
 create mode 100644 bindings/rust/libgpiod/src/info_event.rs
 create mode 100644 bindings/rust/libgpiod/src/lib.rs
 create mode 100644 bindings/rust/libgpiod/src/line_config.rs
 create mode 100644 bindings/rust/libgpiod/src/line_info.rs
 create mode 100644 bindings/rust/libgpiod/src/line_request.rs
 create mode 100644 bindings/rust/libgpiod/src/line_settings.rs
 create mode 100644 bindings/rust/libgpiod/src/request_config.rs
 create mode 100644 bindings/rust/libgpiod/tests/chip.rs
 create mode 100644 bindings/rust/libgpiod/tests/common/config.rs
 create mode 100644 bindings/rust/libgpiod/tests/common/mod.rs
 create mode 100644 bindings/rust/libgpiod/tests/edge_event.rs
 create mode 100644 bindings/rust/libgpiod/tests/info_event.rs
 create mode 100644 bindings/rust/libgpiod/tests/line_config.rs
 create mode 100644 bindings/rust/libgpiod/tests/line_info.rs
 create mode 100644 bindings/rust/libgpiod/tests/line_request.rs
 create mode 100644 bindings/rust/libgpiod/tests/line_settings.rs
 create mode 100644 bindings/rust/libgpiod/tests/request_config.rs

2.31.1.272.g89b43f80a514

This adds libgpiod-sys rust crate, which provides FFI (foreign function interface) bindings for libgpiod APIs.

---
 .gitignore                            |  5 ++++
 bindings/rust/Cargo.toml              |  5 ++++
 bindings/rust/libgpiod-sys/Cargo.toml | 15 ++++++++++
 bindings/rust/libgpiod-sys/build.rs   | 41 +++++++++++++++++++++++++++
 bindings/rust/libgpiod-sys/src/lib.rs | 13 +++++++++
 5 files changed, 79 insertions(+)
 create mode 100644 bindings/rust/Cargo.toml
 create mode 100644 bindings/rust/libgpiod-sys/Cargo.toml
 create mode 100644 bindings/rust/libgpiod-sys/build.rs
 create mode 100644 bindings/rust/libgpiod-sys/src/lib.rs

index 6c08415b390d..9f2fcf440c5d 100644
@@ -35,3 +35,8 @@ stamp-h1
 # profiling
 *.gcda
 *.gcno
+
+# Added by cargo
+
+target
+Cargo.lock

new file mode 100644
index 000000000000..d0b3a3c88ff1
@@ -0,0 +1,5 @@
+[workspace]
+
+members = [
+    "libgpiod-sys",
+]

new file mode 100644
index 000000000000..77f82719d269
@@ -0,0 +1,15 @@
+[package]
+name = "libgpiod-sys"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+
+[features]
+generate = [ "bindgen" ]
+
+[build-dependencies]
+bindgen = { version = "0.59.1", optional = true }
+cc = "1.0.46"

new file mode 100644
index 000000000000..1ca355b5f5ac
@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#[allow(non_camel_case_types, non_upper_case_globals)]
+#[cfg_attr(test, allow(deref_nullptr, non_snake_case))]
+
+mod bindings_raw {
+    #[cfg(feature = "generate")]
+    include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
+
+    #[cfg(not(feature = "generate"))]
+    include!("bindings.rs");
+}
+pub use bindings_raw::*;

2.31.1.272.g89b43f80a514

This adds a copy of pre generated bindings and adds the suggested way of updating those in README.

---
 bindings/rust/libgpiod-sys/README.md       |   11 +
 bindings/rust/libgpiod-sys/src/bindings.rs | 1173 ++++++++++++++++++++
 2 files changed, 1184 insertions(+)
 create mode 100644 bindings/rust/libgpiod-sys/README.md
 create mode 100644 bindings/rust/libgpiod-sys/src/bindings.rs

new file mode 100644
index 000000000000..ecf75b31c41e
@@ -0,0 +1,11 @@
+# Generated libgpiod-sys Rust FFI bindings
+Automatically generated Rust FFI bindings via
+	[bindgen](https://github.com/rust-lang/rust-bindgen).
+
+## Updating bindings
+1. Clone the source from
+	<https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/>
+2. run `cd libgpiod/bindings/rust/libgpiod-sys/`
+2. run `cargo build --features generate`
+3. Copy the bindings 'cp ../target/debug/build/libgpiod-sys-###/out/bindings.rs src/bindings.rs'
+4. Commit changes in `src/bindings.rs`

2.31.1.272.g89b43f80a514

Add rust wrapper crate, around the libpiod-sys crate added earlier, to provide a convenient interface for the users.

---
 bindings/rust/Cargo.toml                     |   1 +
 bindings/rust/libgpiod/Cargo.toml            |  13 +
 bindings/rust/libgpiod/src/chip.rs           | 253 ++++++++++
 bindings/rust/libgpiod/src/edge_event.rs     | 102 ++++
 bindings/rust/libgpiod/src/event_buffer.rs   |  90 ++++
 bindings/rust/libgpiod/src/info_event.rs     |  68 +++
 bindings/rust/libgpiod/src/lib.rs            | 471 +++++++++++++++++++
 bindings/rust/libgpiod/src/line_config.rs    | 118 +++++
 bindings/rust/libgpiod/src/line_info.rs      | 180 +++++++
 bindings/rust/libgpiod/src/line_request.rs   | 246 ++++++++++
 bindings/rust/libgpiod/src/line_settings.rs  | 277 +++++++++++
 bindings/rust/libgpiod/src/request_config.rs |  96 ++++
 12 files changed, 1915 insertions(+)
 create mode 100644 bindings/rust/libgpiod/Cargo.toml
 create mode 100644 bindings/rust/libgpiod/src/chip.rs
 create mode 100644 bindings/rust/libgpiod/src/edge_event.rs
 create mode 100644 bindings/rust/libgpiod/src/event_buffer.rs
 create mode 100644 bindings/rust/libgpiod/src/info_event.rs
 create mode 100644 bindings/rust/libgpiod/src/lib.rs
 create mode 100644 bindings/rust/libgpiod/src/line_config.rs
 create mode 100644 bindings/rust/libgpiod/src/line_info.rs
 create mode 100644 bindings/rust/libgpiod/src/line_request.rs
 create mode 100644 bindings/rust/libgpiod/src/line_settings.rs
 create mode 100644 bindings/rust/libgpiod/src/request_config.rs

index d0b3a3c88ff1..1e57ef2c0002 100644
@@ -2,4 +2,5 @@
 
 members = [
     "libgpiod-sys",
+    "libgpiod"
 ]

new file mode 100644
index 000000000000..f25242abb153
@@ -0,0 +1,13 @@
+[package]
+name = "libgpiod"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+intmap = "2.0.0"
+libc = ">=0.2.39"
+libgpiod-sys = { path = "../libgpiod-sys" }
+thiserror = "1.0"
+vmm-sys-util = "=0.10.0"

2.31.1.272.g89b43f80a514

Hey Viresh!

Thanks for being patient with me. :)

I obviously cannot give a comprehensive review of Rust code as you know it much better than I do but there's one thing that bothers me at first glance. Please see below.

[snip]

[snip]

Hi Bartosz,

I should thank you for being patient with me :)

I thought that is required if the user is concerned that the buffer will be overwritten by a new event, hence make a copy. Is that understanding correct? I didn't use it here for that reason, but it can be useful to the user expecting a lot of events.

No.

This is where Rust's memory safety comes in. If you see the design of the 'structure Event', it saves a reference to the 'struct BufferInternal'. The drop() implementation of BufferInternal calls:
gpiod_edge_event_buffer_free(), but it won't get called unless all the references to it have gone out of scope. So untill the time user is still using any of the events, the buffer won't get freed. So we will never have invalid reference issue here.

So here in Rust, you clone() normally to make a copy, but the standard clone() declaration can't have an error returned and so I had to name it event_clone().

--
Viresh

Yes, that's one of the use-cases. Copy an event from a buffer before reading more into it.

You've got to help me out here, just looking at the code doesn't make things clear for me.

Am I right to understand that each Event holds a reference to the BufferInternal object and it will only be destroyed when the last event is dropped? If we read new events into the buffer, does that create a new BufferInternal? Is that efficient? Aren't we allocating memory for each new BufferInternal at every read?

Bart

Just to clarify, Buffer is just a wrapper over BufferInternal, you can think of them as the same entity for simplicity.

Yes. But the buffer variable itself too holds a reference to the Buffer. Even if all the events are dropped, the buffer won't get free unless the buffer variable gets dropped too.

No. It uses the existing buffer only, that we created using Buffer::new().

No, we reuse the same buffer for all the reads.

If you see the gpiomon.rs example, it shows how this is being done. The buffer (and internal buffer too) is created only once in line 42:

let buffer = edge::event::Buffer::new(1)?;

This allocates the memory for buffer only once, after that we continue reading from the same buffer.

The BufferInternal structure is enclosed within an Arc<> instance, which is "Atomically Reference Counted", very much like kref_get/put in kernel.

Unless the last reference is dropped, it stays.

Hope I was able to clarify this here.

So what happens if I do this:

let buf = edge::event::Buffer::new(10)?;
let request = chip.request_lines(&rconfig, &lconfig)?; let count = request.read_edge_events(&buffer)?; let event = buffer.event(0);
let count = request.read_edge_events(&buffer)?; println!("line: {}", event.line_offset());

?

Here is what happens at each call for easier understanding:

buf1 = gpiod_edge_event_buffer_new()

gpiod_chip_request_lines()

gpiod_line_request_read_edge_event(buf1)

event1 = gpiod_edge_event_buffer_get_event(buf1, 0)

gpiod_line_request_read_edge_event(buf1)

gpiod_edge_event_get_line_offset(event1)

We will allocate a single buffer (buf1) and the event (event1) will be a reference onto its first event entry in the buffer. It will print offset value from the second read_edge_events() here instead of first, as it was just a reference to the first event. And for such a use case, the user should do

event = buffer.event(0).event_clone();

viresh

Ok, so this is not correct. The doc for
gpiod_edge_event_buffer_get_event() says:

* @return Pointer to an event stored in the buffer. The lifetime of the
* event is tied to the buffer object. Users must not free the event
* returned by this function.

We make no guarantees that the address returned by gpiod_edge_event_buffer_get_event() will still be valid after a call to gpiod_line_request_read_edge_event(). In fact the doc for the latter says:

* @note Any exising events in the buffer are overwritten. This is not an
* append operation.

So we're being clear that after a call to gpiod_line_request_read_edge_event(), all previously returned edge event pointers are invalid unless the objects to which they point were explicitly copied.

Current implementation does indeed work like what you describe but that behavior is not "contractually" guaranteed and can change even between minor releases.

In C++ if you do:

const edge_event& ev = buffer.get_event(0);
request.read_edge_event(buffer);
std::cout << ev << std::endl;

You risk a segfault.

My understanding is that Rust should not allow a crash in this situation by design.

Bart

Hmm, so what exactly do we want to do here then ?

- Don't allow events to be referenced ? i.e. make event_clone() the default behavior ?

- Don't allow read_edge_event() to be called twice for a buffer ? that will be inefficient though.

- Somehow guarantee that reference to all the events are dropped before issuing read_edge_event() again, else make it fail ? I am not sure how straight forward that can be though.

viresh

God no, that would be wasteful.

Not good either.

In C++ the preferred way is to do buffer.get_event(0) which will return a constant reference. If you store that reference as const edge_event& ev = buffer.get_event(0) and reuse it after rereading into that buffer and the program crashes - that's on you. In most cases you should just do buffer.get_event(0).line_offset() etc. If you do:

edge_event event = buffer.get_event(0);

You'll copy the event and it will survive the overwriting of the buffer.

I'm a Rust beginner but my understanding is that the whole idea of the language design is to *not* allow a situation where the program can crash. It should be detected at build-time. We must not rely on "contracts" defined by documentation.

Is there a way to invalidate a reference in Rust? Have a small (cheap) object in the buffer which the event references and which would get dropped when reading into the buffer?

Bart

As I expected for both of them :)

Right, same happens here.

If everything was written in Rust, then this problem won't occur for sure. But in this case part of the code is available via FFI (foreign function interface) and they guarantees are a bit limited there and depend on what the FFI guarantees.

I am not sure. There are locks, but then they have a cost.

Miguel, any suggestions ?

Bartosz, just as an FYI I am out on vacation until end of next week and won't have access to a workstation. I can still reply via Gmail (html) from my phone though.

viresh

I'm not talking about locking, this should be left to the user of the module.

Can we force-drop an object still referenced by other objects in Rust? This is what I had in mind - a small, dummy, cheap object inside the buffer that's created when reading into the buffer. Each even would reference it and then Rust would not allow us to drop it as long as there are references to it. Does it make sense? Is that possible?

Nah, just take the time off and rest. BTW, I'm starting at linaro next week. :)

Bart

Yeah, I get that.

No, AFAICT.

We can call drop(x) on an object, but as long as an reference to it is out there, we won't end up calling the actualy drop() routine for the object.

I don't think so.

Excellent, welcome buddy :)

--
Viresh

Miguel: Could you give us advice on how to proceed with this?

Bart

No, Rust will explicitly prevent you from dropping referenced objects.

But is this the sort of thing you mean:

use std::process::ExitCode;

#[derive(Clone)]
struct Event {
pub id: u8
}

struct Events {
b: Vec<Event>
}

impl Events {
    pub fn get(&self, idx: usize) -> Option<&Event> {
        self.b.get(idx)
    }
}

struct Buffer {
    count: u8,
    events: Option<Events>,
}

impl Buffer {
    
    pub fn read(&mut self) -> Result<&Events, ()> {
        self.count += 1;
        self.events = Some(Events{b: vec![Event{id: self.count}]});
        self.events.as_ref().ok_or(())
    }
}

fn main() -> Result<ExitCode, ()>{
    let mut b = Buffer{count: 0, events:None};
    let mut ee = b.read()?;
    let e = ee.get(0);
    println!("{:?}", e.unwrap().id);
    let cloned_e = e.unwrap().clone();
    drop(e); // <-- comment out to try to create a dangling event reference
    ee = b.read()?;
    let e = ee.get(0); // <-- comment out to try to create a dangling event reference
    println!("{:?}", cloned_e.id);
    println!("{:?}", e.unwrap().id);
    Ok(ExitCode::from(42))
}

That is a skeletal proof of concept - the small, dummy, cheap object is the Vec in Events. Is that cheap enough? You might be able to replace that with something cheaper, but Events needs to be able to pull an Event reference from somewhere (from the borrow checker's PoV) so it made this demo simpler.

Comment out the two lines to try to carry e across the buffer read(). The compiler will not allow it, as e already borrows from b.

In an actual implementation Event would wrap the C event, and Events.get() would get the event pointer for the Event and return that as a reference. The Event clone would call into C, rather than being derived as it is here.

Key points: Buffer has to own the Events snapshot that is returned by reference by read(). The return by reference creates a borrow on the Buffer. The read() requires a &mut to prevent the Buffer being read while there are any borrows outstanding.
The Events returns individual events by reference to create a borrow on the Events to prevent it (and the Buffer) being dropped or modified. The Event clone returns a concrete event that does not have a borrow of the Events or Buffer.

There may well be better ways to do this, and you would really want to do some benchmarking to compare it with the immediate clone option - it may well be worse, but hopefully it at least demonstrates the semantics you are after.

Cheers,
Kent.

More precisely, it needs to avoid UB (which is defined similarly as in C++, and of course UB may lead to a crash if one is lucky).

From your C++ example above:

    const edge_event& ev = buffer.get_event(0);
    request.read_edge_event(buffer);
    std::cout << ev << std::endl;

It looks like a container whose elements get invalidated, so read_edge_event could require an exclusive reference to buffer in Rust, that way you cannot keep borrows to its elements like ev if you want to call it. But of course this requires tying the lifetime of the events to that of the buffer.

Cheers,
Miguel

What about the below code changes on top of V6 ?

Changes:
- Removed BufferInternal.
- Event contains a reference to the Buffer now, with lifetime.
- read_edge_event() expects a mutable reference to buffer, to make it exclusive, i.e. disallow any previous Event references to exist at compilation itself.

index ce583916a2e3..f5426459d779 100644
@@ -3,12 +3,11 @@
 // Copyright 2022 Linaro Ltd. All Rights Reserved.
 //     Viresh Kumar <[email protected]>
 
-use std::sync::Arc;
 use std::time::Duration;
 
 use vmm_sys_util::errno::Error as Errno;
 
-use super::{edge::event::BufferInternal, gpiod, EdgeKind, Error, Offset, OperationType, Result};
+use super::{edge::event::Buffer, gpiod, EdgeKind, Error, Offset, OperationType, Result};
 
 /// Line edge events handling
 ///

@@ -22,15 +21,15 @@ use super::{edge::event::BufferInternal, gpiod, EdgeKind, Error, Offset, Operati
 /// number of events are being read.
 
 #[derive(Debug, Eq, PartialEq)]
-pub struct Event {
-    ibuffer: Option<Arc<BufferInternal>>,
+pub struct Event<'b> {
+    buffer: Option<&'b Buffer>,
     event: *mut gpiod::gpiod_edge_event,
 }
 
-impl Event {
+impl<'b> Event<'b> {
     /// Get an event stored in the buffer.
-    pub(crate) fn new(ibuffer: &Arc<BufferInternal>, index: u64) -> Result<Self> {
-        let event = unsafe { gpiod::gpiod_edge_event_buffer_get_event(ibuffer.buffer(), index) };
+    pub(crate) fn new(buffer: &'b Buffer, index: u64) -> Result<Self> {
+        let event = unsafe { gpiod::gpiod_edge_event_buffer_get_event(buffer.buffer(), index) };
         if event.is_null() {
             return Err(Error::OperationFailed(
                 OperationType::EdgeEventBufferGetEvent,

@@ -39,7 +38,7 @@ impl Event {
         }
 
         Ok(Self {
-            ibuffer: Some(ibuffer.clone()),
+            buffer: Some(buffer),
             event,
         })
     }

@@ -54,7 +53,7 @@ impl Event {
         }
 
         Ok(Self {
-            ibuffer: None,
+            buffer: None,
             event,
         })
     }

@@ -91,11 +90,11 @@ impl Event {
     }
 }
 
-impl Drop for Event {
+impl<'b> Drop for Event<'b> {
     /// Free the edge event.
     fn drop(&mut self) {
         // Free the event only if a copy is made
-        if self.ibuffer.is_none() {
+        if self.buffer.is_none() {
             unsafe { gpiod::gpiod_edge_event_free(self.event) };
         }
     }

index 617efaa34d58..e4ff951aef29 100644
@@ -218,7 +218,7 @@ impl Request {
     /// Get a number of edge events from a line request.
     ///
     /// This function will block if no event was queued for the line.
-    pub fn read_edge_events(&self, buffer: &edge::event::Buffer) -> Result<u32> {
+    pub fn read_edge_events(&self, buffer: &mut edge::event::Buffer) -> Result<u32> {
         let ret = unsafe {
             gpiod::gpiod_line_request_read_edge_event(
                 self.request,

And here is an example where we get compilation error on the commented line:

fn main() -> Result<()> {
    let mut lsettings = line::Settings::new()?;
    let lconfig = line::Config::new()?;
    let offsets = vec![1, 2];

    lsettings.set_prop(&[SettingVal::EdgeDetection(Some(Edge::Both))])?;
    lconfig.add_line_settings(&offsets, lsettings)?;

    let path = "/dev/gpiochip0".to_string();
    let chip = Chip::open(&path)?;

    let rconfig = request::Config::new()?;

    let mut buffer = edge::event::Buffer::new(2)?;
    let request = chip.request_lines(&rconfig, &lconfig)?;

    loop {
        match request.wait_edge_event(None) {
            Err(x) => {
                println!("{:?}", x);
                return Err(Error::InvalidArguments);
            }

            Ok(false) => {
                // This shouldn't happen as the call is blocking.
                panic!();
            }
            Ok(true) => (),
        }

        request.read_edge_events(&mut buffer)?;
        let event0 = buffer.event(0)?;
        let event1 = buffer.event(1)?;

        println!("{:?}", (event0.line_offset(), event1.line_offset()));
        drop(event0);

        // This fails to compile
        // request.read_edge_events(&mut buffer)?;

        drop(event1);
        // This compiles fine
        request.read_edge_events(&mut buffer)?;
    }
}

viresh

Can you clone the event to detach it from the buffer? Or are you now forced to drop the event before reading more?

Cheers,
Kent.

I thought we can always do:

event.event_clone() to get a copy, which won't have a reference to the Buffer. This is how it is defined:

    pub fn event_clone(&self) -> Result<Self> {
        let event = unsafe { gpiod::gpiod_edge_event_copy(self.event) };
        if event.is_null() {
            return Err(Error::OperationFailed(
                OperationType::EdgeEventCopy,
                Errno::last(),
            ));
        }

        Ok(Self {
            buffer: None,
            event,
        })
    }

But when I try to do this in the earlier example:

@@ -40,10 +40,12 @@ fn main() -> Result<()> {
         let event1 = buffer.event(1)?;

         println!("{:?}", (event0.line_offset(), event1.line_offset()));
+        let event0_copy = event0.event_clone()?;
         drop(event0);
         // This fails to compile
         // request.read_edge_events(&mut buffer)?;
         drop(event1);
         request.read_edge_events(&mut buffer)?;
+        drop(event0_copy);
     }

}

compilation fails :(

error[E0502]: cannot borrow buffer as mutable because it is also borrowed as immutable
--> libgpiod/examples/gpiobufferevent.rs:48:34

   |
39 |         let event0 = buffer.event(0)?;
   |                      --------------- immutable borrow occurs here
...
48 |         request.read_edge_events(&mut buffer)?;
   |                                  ^^^^^^^^^^^ mutable borrow occurs here
49 |         drop(event0_copy);
   |              ----------- immutable borrow later used here

And I am not sure why, as the reference isn't used anymore in this case to the event0.

viresh

This works though:

index 613a800584e3..e16a1a39b22c 100644
@@ -40,10 +40,12 @@ fn main() -> Result<()> {
         let event1 = buffer.event(1)?;
 
         println!("{:?}", (event0.line_offset(), event1.line_offset()));
+        let event0_copy = edge::Event::event_clone(&event0)?;
         drop(event0);
         // This fails to compile
         // request.read_edge_events(&mut buffer)?;
         drop(event1);
         request.read_edge_events(&mut buffer)?;
+        drop(event0_copy);
     }
 }

index f5426459d779..12c0fd73f778 100644
@@ -43,8 +43,8 @@ impl<'b> Event<'b> {
         })
     }
 
-    pub fn event_clone(&self) -> Result<Self> {
-        let event = unsafe { gpiod::gpiod_edge_event_copy(self.event) };
+    pub fn event_clone(event: &Event) -> Result<Self> {
+        let event = unsafe { gpiod::gpiod_edge_event_copy(event.event) };
         if event.is_null() {
             return Err(Error::OperationFailed(
                 OperationType::EdgeEventCopy,

viresh

Bartosz, should I send a V7 now with these changes ? I hope everything is settled ?

viresh

Maybe also add chained mutators everywhere? To be able to do settings.set_direction().set_edge() etc.?

And I would still love a thorough API review from someone who actually knows rust too. :(

But I will play some more with v7 so do send it.

Bartosz

Based on Kent's suggestion earlier, what I have implemented is set_prop(), to which one can pass all settings and it will apply them in a loop.

    pub fn set_prop(&mut self, values: &[SettingVal]) -> Result<()> {
        for value in values {
            match value {
                SettingVal::Direction(val) => self.set_direction(*val)?,
                SettingVal::EdgeDetection(val) => self.set_edge_detection(*val)?,
                SettingVal::Bias(val) => self.set_bias(*val)?,
                SettingVal::Drive(val) => self.set_drive(*val)?,
                SettingVal::ActiveLow(val) => self.set_active_low(*val),
                SettingVal::DebouncePeriod(val) => self.set_debounce_period(*val),
                SettingVal::EventClock(val) => self.set_event_clock(*val)?,
                SettingVal::OutputValue(val) => self.set_output_value(*val)?,
            }
        }

        Ok(())
    }

I think that replaces the need of nested ones ? And if we want to add those later, we can always come back and add them. But I am not sure it would be required.

Well, Kent did a very good job earlier. I am not sure if he has extra cycles to review this once again, though not a lot has changed since last time.

Great.

viresh

I cannot find Kent's comment on that - what was the reasoning behind this?

Yeah sorry Kent, I forgot we're at v6 already and you did review the previous iterations. :)

Bart

The comment was:

Add a Setting enum that has a variant for each setting. Then you only need 3 mutators total.
And the user can define configs as a list of Settings. So perhaps the mutators should accept &[Setting]. And &[offsets] rather than just offset.

Similarly, gets can be consolidated into:

get_prop_offset(self, offset, SettingKind) -> Result<Setting>

and
get_prop_default(self, SettingKind) -> Result<Setting>

(simplified signatures)

Prior to the line_settings change there was a veritable forest of mutators, so the idea was to consolidate them where possible, cos in Rust you can. But behind the scenes the implementation is just fanning them out again, so I'm not sure I see the benefit if that is the case.

If the mutators for each field still exist they may as well be pub.

And they should return Result<&mut Self> so they can be chained, as you suggest.

Wrt the values param (which I would prefer was called props), the idea was that the config could be built and passed around as pure Rust objects. The set_prop() applied that list to the C line config, at the time using one of the default/offset/subset mutators. So it decoupled the settings from the scope they were to be applied to. Not such an issue now - the scope is always line.
Might still be useful, might not.

My review was of v4. Things have changed a bit since then. And I agree with your original point - it would be good to get a review from someone that actually uses Rust in anger - I only toy with it.

Cheers,
Kent.

Is this fine now ? Rebased over v7.

index 2c3090132ea5..be50b5b41c5a 100644
@@ -70,18 +70,18 @@ impl Settings {
     }
 
     /// Set line prop setting.
-    pub fn set_prop(&mut self, values: &[SettingVal]) -> Result<()> {
-        for value in values {
-            match value {
-                SettingVal::Direction(val) => self.set_direction(*val)?,
-                SettingVal::EdgeDetection(val) => self.set_edge_detection(*val)?,
-                SettingVal::Bias(val) => self.set_bias(*val)?,
-                SettingVal::Drive(val) => self.set_drive(*val)?,
-                SettingVal::ActiveLow(val) => self.set_active_low(*val),
-                SettingVal::DebouncePeriod(val) => self.set_debounce_period(*val),
-                SettingVal::EventClock(val) => self.set_event_clock(*val)?,
-                SettingVal::OutputValue(val) => self.set_output_value(*val)?,
-            }
+    pub fn set_prop(&mut self, props: &[SettingVal]) -> Result<()> {
+        for property in props {
+            match property {
+                SettingVal::Direction(prop) => self.set_direction(*prop)?,
+                SettingVal::EdgeDetection(prop) => self.set_edge_detection(*prop)?,
+                SettingVal::Bias(prop) => self.set_bias(*prop)?,
+                SettingVal::Drive(prop) => self.set_drive(*prop)?,
+                SettingVal::ActiveLow(prop) => self.set_active_low(*prop),
+                SettingVal::DebouncePeriod(prop) => self.set_debounce_period(*prop),
+                SettingVal::EventClock(prop) => self.set_event_clock(*prop)?,
+                SettingVal::OutputValue(prop) => self.set_output_value(*prop)?,
+            };
         }
 
         Ok(())

@@ -102,7 +102,7 @@ impl Settings {
     }
 
     /// Set the line direction.
-    fn set_direction(&mut self, direction: Direction) -> Result<()> {
+    pub fn set_direction(&mut self, direction: Direction) -> Result<&mut Self> {
         let ret = unsafe {
             gpiod::gpiod_line_settings_set_direction(
                 self.settings,

@@ -116,17 +116,17 @@ impl Settings {
                 Errno::last(),
             ))
         } else {
-            Ok(())
+            Ok(self)
         }
     }
 
     /// Get the direction setting.
-    fn direction(&self) -> Result<Direction> {
+    pub fn direction(&self) -> Result<Direction> {
         Direction::new(unsafe { gpiod::gpiod_line_settings_get_direction(self.settings) } as u32)
     }
 
     /// Set the edge event detection setting.
-    fn set_edge_detection(&mut self, edge: Option<Edge>) -> Result<()> {
+    pub fn set_edge_detection(&mut self, edge: Option<Edge>) -> Result<&mut Self> {
         let ret = unsafe {
             gpiod::gpiod_line_settings_set_edge_detection(
                 self.settings,

@@ -140,17 +140,17 @@ impl Settings {
                 Errno::last(),
             ))
         } else {
-            Ok(())
+            Ok(self)
         }
     }
 
     /// Get the edge event detection setting.
-    fn edge_detection(&self) -> Result<Option<Edge>> {
+    pub fn edge_detection(&self) -> Result<Option<Edge>> {
         Edge::new(unsafe { gpiod::gpiod_line_settings_get_edge_detection(self.settings) } as u32)
     }
 
     /// Set the bias setting.
-    fn set_bias(&mut self, bias: Option<Bias>) -> Result<()> {
+    pub fn set_bias(&mut self, bias: Option<Bias>) -> Result<&mut Self> {
         let ret = unsafe {
             gpiod::gpiod_line_settings_set_bias(self.settings, Bias::gpiod_bias(bias) as i32)
         };

@@ -161,17 +161,17 @@ impl Settings {
                 Errno::last(),
             ))
         } else {
-            Ok(())
+            Ok(self)
         }
     }
 
     /// Get the bias setting.
-    fn bias(&self) -> Result<Option<Bias>> {
+    pub fn bias(&self) -> Result<Option<Bias>> {
         Bias::new(unsafe { gpiod::gpiod_line_settings_get_bias(self.settings) } as u32)
     }
 
     /// Set the drive setting.
-    fn set_drive(&mut self, drive: Drive) -> Result<()> {
+    pub fn set_drive(&mut self, drive: Drive) -> Result<&mut Self> {
         let ret = unsafe {
             gpiod::gpiod_line_settings_set_drive(self.settings, drive.gpiod_drive() as i32)
         };

@@ -182,44 +182,49 @@ impl Settings {
                 Errno::last(),
             ))
         } else {
-            Ok(())
+            Ok(self)
         }
     }
 
     /// Get the drive setting.
-    fn drive(&self) -> Result<Drive> {
+    pub fn drive(&self) -> Result<Drive> {
         Drive::new(unsafe { gpiod::gpiod_line_settings_get_drive(self.settings) } as u32)
     }
 
     /// Set active-low setting.
-    fn set_active_low(&mut self, active_low: bool) {
-        unsafe { gpiod::gpiod_line_settings_set_active_low(self.settings, active_low) }
+    pub fn set_active_low(&mut self, active_low: bool) -> &mut Self {
+        unsafe {
+            gpiod::gpiod_line_settings_set_active_low(self.settings, active_low);
+        }
+        self
     }
 
     /// Check the active-low setting.
-    fn active_low(&self) -> bool {
+    pub fn active_low(&self) -> bool {
         unsafe { gpiod::gpiod_line_settings_get_active_low(self.settings) }
     }
 
     /// Set the debounce period setting.
-    fn set_debounce_period(&mut self, period: Duration) {
+    pub fn set_debounce_period(&mut self, period: Duration) -> &mut Self {
         unsafe {
             gpiod::gpiod_line_settings_set_debounce_period_us(
                 self.settings,
                 period.as_micros() as u64,
-            )
+            );
         }
+
+        self
     }
 
     /// Get the debounce period.
-    fn debounce_period(&self) -> Result<Duration> {
+    pub fn debounce_period(&self) -> Result<Duration> {
         Ok(Duration::from_micros(unsafe {
             gpiod::gpiod_line_settings_get_debounce_period_us(self.settings)
         }))
     }
 
     /// Set the event clock setting.
-    fn set_event_clock(&mut self, clock: EventClock) -> Result<()> {
+    pub fn set_event_clock(&mut self, clock: EventClock) -> Result<&mut Self> {
         let ret = unsafe {
             gpiod::gpiod_line_settings_set_event_clock(self.settings, clock.gpiod_clock() as i32)
         };

@@ -230,17 +235,17 @@ impl Settings {
                 Errno::last(),
             ))
         } else {
-            Ok(())
+            Ok(self)
         }
     }
 
     /// Get the event clock setting.
-    fn event_clock(&self) -> Result<EventClock> {
+    pub fn event_clock(&self) -> Result<EventClock> {
         EventClock::new(unsafe { gpiod::gpiod_line_settings_get_event_clock(self.settings) } as u32)
     }
 
     /// Set the output value setting.
-    fn set_output_value(&mut self, value: Value) -> Result<()> {
+    pub fn set_output_value(&mut self, value: Value) -> Result<&mut Self> {
         let ret =
             unsafe { gpiod::gpiod_line_settings_set_output_value(self.settings, value.value()) };
 

@@ -250,12 +255,12 @@ impl Settings {
                 Errno::last(),
             ))
         } else {
-            Ok(())
+            Ok(self)
         }
     }
 
     /// Get the output value, 0 or 1.
-    fn output_value(&self) -> Result<Value> {
+    pub fn output_value(&self) -> Result<Value> {
         let value = unsafe { gpiod::gpiod_line_settings_get_output_value(self.settings) };
 
         if value != 0 && value != 1 {

viresh

Ahh yes.

index be50b5b41c5a..92e8928517f7 100644
@@ -70,7 +70,7 @@ impl Settings {
     }
 
     /// Set line prop setting.
-    pub fn set_prop(&mut self, props: &[SettingVal]) -> Result<()> {
+    pub fn set_prop(&mut self, props: &[SettingVal]) -> Result<&mut Self> {
         for property in props {
             match property {
                 SettingVal::Direction(prop) => self.set_direction(*prop)?,

@@ -84,7 +84,7 @@ impl Settings {
             };
         }
 
-        Ok(())
+        Ok(self)
     }
 
     /// Get the line prop setting.

viresh

Add examples for the usage of the rust bindings, quite similar to the ones in cxx bindings.

---
 bindings/rust/libgpiod/examples/gpiodetect.rs | 30 ++++++
 bindings/rust/libgpiod/examples/gpiofind.rs   | 35 +++++++
 bindings/rust/libgpiod/examples/gpioget.rs    | 42 ++++++++
 bindings/rust/libgpiod/examples/gpioinfo.rs   | 95 +++++++++++++++++++
 bindings/rust/libgpiod/examples/gpiomon.rs    | 73 ++++++++++++++
 bindings/rust/libgpiod/examples/gpioset.rs    | 60 ++++++++++++
 bindings/rust/libgpiod/examples/gpiowatch.rs  | 54 +++++++++++
 7 files changed, 389 insertions(+)
 create mode 100644 bindings/rust/libgpiod/examples/gpiodetect.rs
 create mode 100644 bindings/rust/libgpiod/examples/gpiofind.rs
 create mode 100644 bindings/rust/libgpiod/examples/gpioget.rs
 create mode 100644 bindings/rust/libgpiod/examples/gpioinfo.rs
 create mode 100644 bindings/rust/libgpiod/examples/gpiomon.rs
 create mode 100644 bindings/rust/libgpiod/examples/gpioset.rs
 create mode 100644 bindings/rust/libgpiod/examples/gpiowatch.rs

new file mode 100644
index 000000000000..f24ac72e2d48
@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+//
+// Copyright 2022 Linaro Ltd. All Rights Reserved.
+//     Viresh Kumar <[email protected]>
+//
+// Simplified Rust implementation of gpiodetect tool.
+
+use std::env;
+use std::path::Path;
+
+use libgpiod::{gpiochip_devices, Error, Result};
+
+fn main() -> Result<()> {
+    let args: Vec<String> = env::args().collect();
+    if args.len() > 1 {
+        println!("Usage: {}", args[0]);
+        return Err(Error::InvalidArguments);
+    }
+
+    for chip in gpiochip_devices(&Path::new("/dev"))? {
+        println!(
+            "{} [{}] ({})",
+            chip.name()?,
+            chip.label()?,
+            chip.num_lines(),
+        );
+    }
+
+    Ok(())
+}

new file mode 100644
index 000000000000..07e886bc3896
@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+//
+// Copyright 2022 Linaro Ltd. All Rights Reserved.
+//     Viresh Kumar <[email protected]>
+//
+// Simplified Rust implementation of gpiofind tool.
+
+use std::env;
+use std::path::Path;
+
+use libgpiod::{gpiochip_devices, Error, Result};
+
+fn main() -> Result<()> {
+    let args: Vec<String> = env::args().collect();
+    if args.len() != 2 {
+        println!("Usage: {} <line-name>", args[0]);
+        return Err(Error::InvalidArguments);
+    }
+
+    for chip in gpiochip_devices(&Path::new("/dev"))? {
+        let offset = chip.line_offset_from_name(&args[1]);
+        if offset.is_ok() {
+            println!(
+                "Line {} found: Chip: {}, offset: {}",
+                args[1],
+                chip.name()?,
+                offset?
+            );
+            return Ok(());
+        }
+    }
+
+    println!("Failed to find line: {}", args[1]);
+    Ok(())
+}

2.31.1.272.g89b43f80a514

This adds gpiosim rust crate, which provides helpers to emulate GPIO chips.

---
 bindings/rust/Cargo.toml         |   3 +-
 bindings/rust/gpiosim/Cargo.toml |  18 ++
 bindings/rust/gpiosim/build.rs   |  43 ++++
 bindings/rust/gpiosim/src/lib.rs |  25 +++
 bindings/rust/gpiosim/src/sim.rs | 323 +++++++++++++++++++++++++++++++
 5 files changed, 411 insertions(+), 1 deletion(-)
 create mode 100644 bindings/rust/gpiosim/Cargo.toml
 create mode 100644 bindings/rust/gpiosim/build.rs
 create mode 100644 bindings/rust/gpiosim/src/lib.rs
 create mode 100644 bindings/rust/gpiosim/src/sim.rs

index 1e57ef2c0002..8721bc610b86 100644
@@ -2,5 +2,6 @@
 
 members = [
     "libgpiod-sys",
-    "libgpiod"
+    "libgpiod",
+    "gpiosim"
 ]

new file mode 100644
index 000000000000..d6b4cc34339b
@@ -0,0 +1,18 @@
+[package]
+name = "gpiosim"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+libc = ">=0.2.39"
+libgpiod = { path = "../libgpiod" }
+vmm-sys-util = "=0.10.0"
+
+[features]
+generate = [ "bindgen" ]
+
+[build-dependencies]
+bindgen = { version = "0.59.1", optional = true }
+cc = "1.0.46"

new file mode 100644
index 000000000000..94d0ddb38e0f
@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#[allow(non_camel_case_types, non_upper_case_globals)]
+#[cfg_attr(test, allow(deref_nullptr, non_snake_case))]
+#[allow(dead_code)]
+mod bindings_raw {
+    #[cfg(feature = "generate")]
+    include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
+
+    #[cfg(not(feature = "generate"))]
+    include!("bindings.rs");
+}
+
+use bindings_raw::*;
+
+pub use bindings_raw::{
+    GPIOSIM_HOG_DIR_INPUT, GPIOSIM_HOG_DIR_OUTPUT_HIGH, GPIOSIM_HOG_DIR_OUTPUT_LOW,
+    GPIOSIM_PULL_DOWN, GPIOSIM_PULL_UP, GPIOSIM_VALUE_ACTIVE, GPIOSIM_VALUE_INACTIVE,
+};
+
+#[allow(dead_code)]
+mod sim;
+
+#[allow(unused_imports)]
+pub use sim::*;

2.31.1.272.g89b43f80a514

This adds a copy of pre generated bindings and adds the suggested way of updating those in README.

---
 bindings/rust/gpiosim/README.md       |  11 ++
 bindings/rust/gpiosim/src/bindings.rs | 180 ++++++++++++++++++++++++++
 2 files changed, 191 insertions(+)
 create mode 100644 bindings/rust/gpiosim/README.md
 create mode 100644 bindings/rust/gpiosim/src/bindings.rs

new file mode 100644
index 000000000000..acb84543dbdc
@@ -0,0 +1,11 @@
+# Generated gpiosim Rust FFI bindings
+Automatically generated Rust FFI bindings via
+	[bindgen](https://github.com/rust-lang/rust-bindgen).
+
+## Updating bindings
+1. Clone the source from
+	<https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/>
+2. run `cd libgpiod/bindings/rust/gpiosim/`
+2. run `cargo build --features generate`
+3. Copy the bindings 'cp ../target/debug/build/gpiosim-###/out/bindings.rs src/bindings.rs'
+4. Commit changes in `src/bindings.rs`

2.31.1.272.g89b43f80a514

Add tests for the rust bindings, quite similar to the ones in cxx bindings.

---
 bindings/rust/libgpiod/Cargo.toml             |   3 +
 bindings/rust/libgpiod/tests/chip.rs          |  97 ++++
 bindings/rust/libgpiod/tests/common/config.rs | 134 +++++
 bindings/rust/libgpiod/tests/common/mod.rs    |  10 +
 bindings/rust/libgpiod/tests/edge_event.rs    | 294 ++++++++++
 bindings/rust/libgpiod/tests/info_event.rs    | 125 +++++
 bindings/rust/libgpiod/tests/line_config.rs   | 105 ++++
 bindings/rust/libgpiod/tests/line_info.rs     | 279 ++++++++++
 bindings/rust/libgpiod/tests/line_request.rs  | 519 ++++++++++++++++++
 bindings/rust/libgpiod/tests/line_settings.rs | 226 ++++++++
 .../rust/libgpiod/tests/request_config.rs     |  38 ++
 11 files changed, 1830 insertions(+)
 create mode 100644 bindings/rust/libgpiod/tests/chip.rs
 create mode 100644 bindings/rust/libgpiod/tests/common/config.rs
 create mode 100644 bindings/rust/libgpiod/tests/common/mod.rs
 create mode 100644 bindings/rust/libgpiod/tests/edge_event.rs
 create mode 100644 bindings/rust/libgpiod/tests/info_event.rs
 create mode 100644 bindings/rust/libgpiod/tests/line_config.rs
 create mode 100644 bindings/rust/libgpiod/tests/line_info.rs
 create mode 100644 bindings/rust/libgpiod/tests/line_request.rs
 create mode 100644 bindings/rust/libgpiod/tests/line_settings.rs
 create mode 100644 bindings/rust/libgpiod/tests/request_config.rs

index f25242abb153..8abcaacdee67 100644
@@ -11,3 +11,6 @@ libc = ">=0.2.39"
 libgpiod-sys = { path = "../libgpiod-sys" }
 thiserror = "1.0"
 vmm-sys-util = "=0.10.0"
+
+[dev-dependencies]
+gpiosim = { path = "../gpiosim" }

new file mode 100644
index 000000000000..8904f7121b4c
@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+//
+// Copyright 2022 Linaro Ltd. All Rights Reserved.
+//     Viresh Kumar <[email protected]>
+
+#[allow(dead_code)]
+mod config;
+
+#[allow(unused_imports)]
+pub(crate) use config::*;

new file mode 100644
index 000000000000..d9892ee99101
@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+//
+// Copyright 2022 Linaro Ltd. All Rights Reserved.
+//     Viresh Kumar <[email protected]>
+
+mod common;
+
+mod request_config {
+    use vmm_sys_util::errno::Error as Errno;
+
+    use libgpiod::{request, Error as ChipError, OperationType};
+
+    mod verify {
+        use super::*;
+
+        #[test]
+        fn default() {
+            let rconfig = request::Config::new().unwrap();
+
+            assert_eq!(rconfig.event_buffer_size(), 0);
+            assert_eq!(
+                rconfig.consumer().unwrap_err(),
+                ChipError::OperationFailed(OperationType::RequestConfigGetConsumer, Errno::new(0))
+            );
+        }
+
+        #[test]
+        fn initialized() {
+            const CONSUMER: &str = "foobar";
+            let rconfig = request::Config::new().unwrap();
+            rconfig.set_consumer(CONSUMER);
+            rconfig.set_event_buffer_size(64);
+
+            assert_eq!(rconfig.event_buffer_size(), 64);
+            assert_eq!(rconfig.consumer().unwrap(), CONSUMER);
+        }
+    }
+}

2.31.1.272.g89b43f80a514

Lets make build rust bindings as well.

---
 README                    |  8 +++++---
 TODO                      |  8 --------
 bindings/Makefile.am      |  6 ++++++
 bindings/rust/Makefile.am | 18 ++++++++++++++++++
 configure.ac              | 16 ++++++++++++++++
 5 files changed, 45 insertions(+), 11 deletions(-)
 create mode 100644 bindings/rust/Makefile.am

index 814a0f161fd2..68b5d69f9b66 100644
@@ -119,9 +119,9 @@ TOOLS
 BINDINGS
 --------
 
-High-level, object-oriented bindings for C++ and python3 are provided. They
-can be enabled by passing --enable-bindings-cxx and --enable-bindings-python
-arguments respectively to configure.
+High-level, object-oriented bindings for C++, python3 and Rust are provided.
+They can be enabled by passing --enable-bindings-cxx, --enable-bindings-python
+and --enable-bindings-rust arguments respectively to configure.
 
 C++ bindings require C++11 support and autoconf-archive collection if building
 from git.

@@ -132,6 +132,8 @@ the PYTHON_CPPFLAGS and PYTHON_LIBS variables in order to point the build
 system to the correct locations. During native builds, the configure script
 can auto-detect the location of the development files.
 
+Rust bindings require cargo support.
+
 TESTING
 -------
 

index 8bb4d8f3ad56..cf4fd7b4a962 100644
@@ -28,14 +28,6 @@ and is partially functional.
 
 ----------
 
-* implement rust bindings
-
-With Rust gaining popularity as a low-level system's language and the
-possibility of it making its way into the linux kernel, it's probably time to
-provide Rust bindings to libgpiod as part of the project.
-
-----------
-
 * implement a simple daemon for controlling GPIOs in C together with a client
   program
 

index 8f8c762f254f..004ae23dbc58 100644
@@ -14,3 +14,9 @@ if WITH_BINDINGS_PYTHON
 SUBDIRS += python
 
 endif
+
+if WITH_BINDINGS_RUST
+
+SUBDIRS += rust
+
+endif

new file mode 100644
index 000000000000..79a52bc691ae
@@ -0,0 +1,18 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+# SPDX-FileCopyrightText: 2022 Viresh Kumar <[email protected]>
+
+command = cargo build --release --lib
+
+if WITH_TESTS
+command += --tests
+endif
+
+if WITH_EXAMPLES
+command += --examples
+endif
+
+all:
+	$(command)
+
+clean:
+	cargo clean

index 6ac1d8ed8a40..37cfdb3644f7 100644
@@ -212,6 +212,21 @@ then
 		[AC_SUBST(PYTHON_LIBS, [`$PYTHON-config --libs`])])
 fi
 
+AC_ARG_ENABLE([bindings-rust],
+	[AS_HELP_STRING([--enable-bindings-rust],[enable rust bindings [default=no]])],
+	[if test "x$enableval" = xyes; then with_bindings_rust=true; fi],
+	[with_bindings_rust=false])
+AM_CONDITIONAL([WITH_BINDINGS_RUST], [test "x$with_bindings_rust" = xtrue])
+
+if test "x$with_bindings_rust" = xtrue
+then
+	AC_CHECK_PROG([has_cargo], [cargo], [true], [false])
+	if test "x$has_cargo" = xfalse
+	then
+		AC_MSG_ERROR([cargo not found - needed for rust bindings])
+	fi
+fi
+
 AC_CHECK_PROG([has_doxygen], [doxygen], [true], [false])
 AM_CONDITIONAL([HAS_DOXYGEN], [test "x$has_doxygen" = xtrue])
 if test "x$has_doxygen" = xfalse

@@ -246,6 +261,7 @@ AC_CONFIG_FILES([Makefile
 		 bindings/python/Makefile
 		 bindings/python/examples/Makefile
 		 bindings/python/tests/Makefile
+		 bindings/rust/Makefile
 		 man/Makefile])
 
 AC_OUTPUT

2.31.1.272.g89b43f80a514

Pushed current version as v6, master is used for something else currently.

viresh