libgpiod: Add Rust bindings

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

Signed-off-by Viresh Kumar <[email protected]>

---
 .gitignore                            |  5 ++
 bindings/rust/libgpiod-sys/Cargo.toml | 15 ++++++
 bindings/rust/libgpiod-sys/build.rs   | 69 +++++++++++++++++++++++++++
 bindings/rust/libgpiod-sys/src/lib.rs | 20 ++++++++
 bindings/rust/libgpiod-sys/wrapper.h  |  2 +
 5 files changed, 111 insertions(+)
 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
 create mode 100644 bindings/rust/libgpiod-sys/wrapper.h

.gitignore +5 -0

index 58e1c5fc7e00..9541482d5efb 100644
@@ -33,3 +33,8 @@ stamp-h1
 # profiling
 *.gcda
 *.gcno
+
+# Added by cargo
+
+target
+Cargo.lock

bindings/rust/libgpiod-sys/Cargo.toml new file +15 -0

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"

bindings/rust/libgpiod-sys/build.rs new file +59 -0

new file mode 100644
index 000000000000..bbcd30f79d23
@@ -0,0 +1,69 @@
+#[cfg(feature = "generate")]
+extern crate bindgen;
+#[cfg(feature = "generate")]
+use std::env;
+#[cfg(feature = "generate")]
+use std::path::PathBuf;
+
+#[cfg(feature = "generate")]
+fn generate_bindings(files: &Vec<&str>) {
+    // Tell cargo to invalidate the built crate whenever following files change
+    println!("cargo:rerun-if-changed=wrapper.h");
+
+    for file in files {
+        println!("cargo:rerun-if-changed={}", file);
+    }
+
+    // The bindgen::Builder is the main entry point
+    // to bindgen, and lets you build up options for
+    // the resulting bindings.
+    let bindings = bindgen::Builder::default()
+        // The input header we would like to generate
+        // bindings for.
+        .header("wrapper.h")
+        // Tell cargo to invalidate the built crate whenever any of the
+        // included header files changed.
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks))
+        // Finish the builder and generate the bindings.
+        .generate()
+        // Unwrap the Result and panic on failure.
+        .expect("Unable to generate bindings");
+
+    // Write the bindings to the $OUT_DIR/bindings.rs file.
+    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
+    bindings
+        .write_to_file(out_path.join("bindings.rs"))
+        .expect("Couldn't write bindings!");
+}
+
+fn build_gpiod(files: Vec<&str>) {
+    // Tell Cargo that if the given file changes, to rerun this build script.
+    println!("cargo:rerun-if-changed=../../../lib/");
+
+    // Use the `cc` crate to build a C file and statically link it.
+    cc::Build::new()
+        .files(files)
+        .define("_GNU_SOURCE", None)
+        .define("GPIOD_VERSION_STR", "\"libgpio-sys\"")
+        .include("../../../include")
+        .compile("gpiod");
+}
+
+fn main() {
+    let files = vec![
+        "../../../lib/chip.c",
+        "../../../lib/chip-info.c",
+        "../../../lib/edge-event.c",
+        "../../../lib/info-event.c",
+        "../../../lib/internal.c",
+        "../../../lib/line-config.c",

bindings/rust/libgpiod-sys/src/lib.rs new file +2 -0

new file mode 100644
index 000000000000..3384863a567c
@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-2.0
+

bindings/rust/libgpiod-sys/src/lib.rs new file +8 -0

+mod bindings_raw {
+    #[cfg(feature = "generate")]
+    include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
+
+    #[cfg(not(feature = "generate"))]
+    include!("bindings.rs");
+}
+pub use bindings_raw::*;

bindings/rust/libgpiod-sys/wrapper.h new file +0 -0

new file mode 100644
index 000000000000..7bc1158b7d90

Quoted 13 lines · Viresh Kumar

bindings/rust/libgpiod-sys/build.rs new file +13 -0

+fn main() {
+    let files = vec![
+        "../../../lib/chip.c",
+        "../../../lib/chip-info.c",
+        "../../../lib/edge-event.c",
+        "../../../lib/info-event.c",
+        "../../../lib/internal.c",
+        "../../../lib/line-config.c",
+        "../../../lib/line-info.c",
+        "../../../lib/line-request.c",
+        "../../../lib/misc.c",
+        "../../../lib/request-config.c",
+    ];

bindings/rust/libgpiod-sys/build.rs line 69

Quoted 5 lines

bindings/rust/libgpiod-sys/build.rs new file +5 -0

+
+    #[cfg(feature = "generate")]
+    generate_bindings(&files);
+    build_gpiod(files);
+}

Shouldn't bindings wrap libgpiod and dynamically link against it rather than building and linking statically?

Quoted 12 lines

bindings/rust/libgpiod-sys/src/lib.rs new file +6 -0

new file mode 100644
index 000000000000..3384863a567c
@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#[allow(
+    clippy::all,
+    deref_nullptr,
+    dead_code,

bindings/rust/libgpiod-sys/src/lib.rs line 12

Quoted 6 lines

bindings/rust/libgpiod-sys/src/lib.rs new file +6 -0

+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    improper_ctypes
+)]
+

Are all these really necessary?

Builds mostly clean for me with just:

+ non_camel_case_types,
+ non_upper_case_globals,

Both non_snake_case and deref_nullptr are only required for tests.

The deref_nullptr masks several warnings like this:

warning: dereferencing a null pointer
--> src/bindings.rs:121:14

    |
121 |             &(*(::std::ptr::null::<max_align_t>())).__clang_max_align_nonce1 as *const _ as usize
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this code causes undefined behavior when executed
    |

= note: #[warn(deref_nullptr)] on by default

which is code generated by bindgen, which is a bit of a worry. It is only used for alignment tests, but you'd think they would disable the warning just around that code themselves.

Disabling deref_nullptr globally for all builds is at best poor form.

Perhaps only disable it for test builds, i.e.

#[cfg_attr(test, allow(deref_nullptr, non_snake_case))]

Quoted 13 lines

bindings/rust/libgpiod-sys/src/lib.rs new file +8 -0

+mod bindings_raw {
+    #[cfg(feature = "generate")]
+    include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
+
+    #[cfg(not(feature = "generate"))]
+    include!("bindings.rs");
+}
+pub use bindings_raw::*;

bindings/rust/libgpiod-sys/wrapper.h new file +0 -0

new file mode 100644
index 000000000000..7bc1158b7d90

bindings/rust/libgpiod-sys/wrapper.h line 2

Quoted 3 lines

bindings/rust/libgpiod-sys/wrapper.h new file +2 -0

@@ -0,0 +1,2 @@
+#include <string.h>
+#include "../../../include/gpiod.h"

The string.h is just to provide strlen() for the wrapper crate?? (but also pulls in the other string functions)
The wrapper crate already depends on libc - why not use libc::strlen() there and drop this include here?

And then wrapper.h becomes redundant - call bindgen on gpiod.h directly.

Quoted 14 lines · Kent Gibson

Quoted 13 lines · Viresh Kumar

bindings/rust/libgpiod-sys/build.rs new file +13 -0

+fn main() {
+    let files = vec![
+        "../../../lib/chip.c",
+        "../../../lib/chip-info.c",
+        "../../../lib/edge-event.c",
+        "../../../lib/info-event.c",
+        "../../../lib/internal.c",
+        "../../../lib/line-config.c",
+        "../../../lib/line-info.c",
+        "../../../lib/line-request.c",
+        "../../../lib/misc.c",
+        "../../../lib/request-config.c",
+    ];

Quoted 8 lines

bindings/rust/libgpiod-sys/build.rs line 69

Quoted 5 lines

bindings/rust/libgpiod-sys/build.rs new file +5 -0

+
+    #[cfg(feature = "generate")]
+    generate_bindings(&files);
+    build_gpiod(files);
+}

Shouldn't bindings wrap libgpiod and dynamically link against it rather than building and linking statically?

There are few problems I faced, because of which I had to do it this way.

- I couldn't find a way to do a "Make" for libgpiod from here and then link to the resultant library.

- libgpiod may not be automatically installed in the environment where the end user of these Rust APIs exists. So I had to build it.

- And then the API is changing a lot, maybe down the line once it is stable enough we can change this to something else.

Quoted 12 lines

Quoted 12 lines

bindings/rust/libgpiod-sys/src/lib.rs new file +6 -0

new file mode 100644
index 000000000000..3384863a567c
@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#[allow(
+    clippy::all,
+    deref_nullptr,
+    dead_code,

Quoted 8 lines

bindings/rust/libgpiod-sys/src/lib.rs line 12

Quoted 6 lines

bindings/rust/libgpiod-sys/src/lib.rs new file +6 -0

+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    improper_ctypes
+)]
+

Are all these really necessary?

Actually not, thanks for pointing this out.

Quoted 6 lines

Builds mostly clean for me with just:

+ non_camel_case_types,
+ non_upper_case_globals,

Both non_snake_case and deref_nullptr are only required for tests.

and if you want to run sanity checks with "fmt" or "clippy".

Quoted 14 lines

The deref_nullptr masks several warnings like this:

warning: dereferencing a null pointer
--> src/bindings.rs:121:14

    |
121 |             &(*(::std::ptr::null::<max_align_t>())).__clang_max_align_nonce1 as *const _ as usize
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this code causes undefined behavior when executed
    |

= note: #[warn(deref_nullptr)] on by default

which is code generated by bindgen, which is a bit of a worry. It is only used for alignment tests, but you'd think they would disable the warning just around that code themselves.

Quoted 1 line

Disabling deref_nullptr globally for all builds is at best poor form.

Even with this these will get disabled only for the code present in libgpiod-sys crate, file bindgen.rs (the automatically generated one). This won't cause the warnings to be skipped for the libgpiod rust wrappers in the libgpiod crate.

Quoted 3 lines

Perhaps only disable it for test builds, i.e.

#[cfg_attr(test, allow(deref_nullptr, non_snake_case))]

I also run following normally:

cargo fmt --all -- --check; cargo clippy --workspace --bins --examples --benches --all-features -- -D warnings

to do sanity checks, etc. And this will also generate warnings, not just tests.

Quoted 13 lines

Quoted 13 lines

bindings/rust/libgpiod-sys/src/lib.rs new file +8 -0

+mod bindings_raw {
+    #[cfg(feature = "generate")]
+    include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
+
+    #[cfg(not(feature = "generate"))]
+    include!("bindings.rs");
+}
+pub use bindings_raw::*;

bindings/rust/libgpiod-sys/wrapper.h new file +0 -0

new file mode 100644
index 000000000000..7bc1158b7d90

Quoted 8 lines

bindings/rust/libgpiod-sys/wrapper.h line 2

Quoted 3 lines

bindings/rust/libgpiod-sys/wrapper.h new file +2 -0

@@ -0,0 +1,2 @@
+#include <string.h>
+#include "../../../include/gpiod.h"

The string.h is just to provide strlen() for the wrapper crate?? (but also pulls in the other string functions)
The wrapper crate already depends on libc - why not use libc::strlen() there and drop this include here?

Right, done.

Quoted 1 line

And then wrapper.h becomes redundant - call bindgen on gpiod.h directly.

Rust documentation specifically suggests wrapper.h to be created [1], maybe it it is better to just keep it, even if we have a single entry in there.

Sure, it is a problem, but static isn't the solution.
You should be able to get the appropriate paths from autoconf, but I would refer you to Bart on that.

By "all builds" I meant build/tests/fmt/clippy etc of this module, not others.

My concern being that a subsequent bindgen may introduce a problem into the generated code that the allows would hide. So try to keep them restricted to the problem at hand as much as possible.

#[cfg_attr(any(test,fmt,clippy), allow(deref_nullptr, non_snake_case))] ?

Specifically the tutoral says:
"The wrapper.h file will include all the various headers containing declarations of structs and functions we would like bindings for."

If you do need to bundle several headers then fair enough, but I don't see any benefit in this case - gpiod.h contains all that.

The tutorial is probably written that way so it is easy for them to refer to the general "wrapper.h", but there is nothing in bindgen that requires it.

Quoted 32 lines · Viresh Kumar

Quoted 14 lines · Kent Gibson

Quoted 13 lines · Viresh Kumar

bindings/rust/libgpiod-sys/build.rs new file +13 -0

+fn main() {
+    let files = vec![
+        "../../../lib/chip.c",
+        "../../../lib/chip-info.c",
+        "../../../lib/edge-event.c",
+        "../../../lib/info-event.c",
+        "../../../lib/internal.c",
+        "../../../lib/line-config.c",
+        "../../../lib/line-info.c",
+        "../../../lib/line-request.c",
+        "../../../lib/misc.c",
+        "../../../lib/request-config.c",
+    ];

Quoted 8 lines

bindings/rust/libgpiod-sys/build.rs line 69

Quoted 5 lines

bindings/rust/libgpiod-sys/build.rs new file +5 -0

+
+    #[cfg(feature = "generate")]
+    generate_bindings(&files);
+    build_gpiod(files);
+}

Shouldn't bindings wrap libgpiod and dynamically link against it rather than building and linking statically?

There are few problems I faced, because of which I had to do it this way.

- I couldn't find a way to do a "Make" for libgpiod from here and then link to the resultant library.

- libgpiod may not be automatically installed in the environment where the end user of these Rust APIs exists. So I had to build it.

Quoted 3 lines

- And then the API is changing a lot, maybe down the line once it is stable enough we can change this to something else.

Sure, it is a problem, but static isn't the solution.
You should be able to get the appropriate paths from autoconf, but I would refer you to Bart on that.

Quoted 33 lines · Kent Gibson

Quoted 32 lines · Viresh Kumar

Quoted 14 lines · Kent Gibson

Quoted 13 lines · Viresh Kumar

bindings/rust/libgpiod-sys/build.rs new file +13 -0

+fn main() {
+    let files = vec![
+        "../../../lib/chip.c",
+        "../../../lib/chip-info.c",
+        "../../../lib/edge-event.c",
+        "../../../lib/info-event.c",
+        "../../../lib/internal.c",
+        "../../../lib/line-config.c",
+        "../../../lib/line-info.c",
+        "../../../lib/line-request.c",
+        "../../../lib/misc.c",
+        "../../../lib/request-config.c",
+    ];

Quoted 8 lines

bindings/rust/libgpiod-sys/build.rs line 69

Quoted 5 lines

bindings/rust/libgpiod-sys/build.rs new file +5 -0

+
+    #[cfg(feature = "generate")]
+    generate_bindings(&files);
+    build_gpiod(files);
+}

Shouldn't bindings wrap libgpiod and dynamically link against it rather than building and linking statically?

There are few problems I faced, because of which I had to do it this way.

- I couldn't find a way to do a "Make" for libgpiod from here and then link to the resultant library.

- libgpiod may not be automatically installed in the environment where the end user of these Rust APIs exists. So I had to build it.

Quoted 7 lines

Quoted 3 lines

- And then the API is changing a lot, maybe down the line once it is stable enough we can change this to something else.

Sure, it is a problem, but static isn't the solution.
You should be able to get the appropriate paths from autoconf, but I would refer you to Bart on that.

I am still looking for some help on how to link this dynamically.

FWIW, the problem is that the user crates, like vhost-device, will mention libgpiod as a dependency crate and likely won't have libgpiod installed in environment. So build.rs here needs to do some magic so the definitions are all available to the users.

The Rust bindings themselves should be building against the local build tree, so well known relative paths.

For users, require they have libgpiod installed and use pkg_config to locate it?

Is that what you mean?

Else, how do other Rust crates wrapping dynamic C libraries do it?

Quoted 2 lines · Kent Gibson

The Rust bindings themselves should be building against the local build tree, so well known relative paths.

Right, when we build everything with "make" we better use the already built library. I agree.

Quoted 4 lines

For users, require they have libgpiod installed and use pkg_config to locate it?

Is that what you mean?

Since we need the latest APIs, we can't trust the packages provided by distributions for now. i.e. "apt-get install libgpiod-dev" won't install the latest stuff we need.

The only other option to get it working in environments like rust-vmm-containers (which tests the vhost-device crate currently) is to build / install libgpiod first. As I have understood, people don't really like it there (Maintainers of rust-vmm-containers) as this will have further dependencies and require more tools.

I even tried to generate the libgpiod-sys bindings on the fly first, but it required more tooling and there were issues with Musl build specifically. They suggested to use prebuild bindings as a solution, which I have now.

What about we have two separate features:

- "default" one will be used with "make" and will use prebuild library.

- "generate" one will be used by user crates and we will build the files there like it is done now.

Quoted 1 line

Else, how do other Rust crates wrapping dynamic C libraries do it?

I think for standard libraries that are stable, the -sys crates just contain the pre-built bindings and wrappers and expect the library to be already installed.

Signature · 1 line

viresh

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

Signed-off-by Viresh Kumar <[email protected]>

---
 bindings/rust/libgpiod-sys/README.md       |   10 +
 bindings/rust/libgpiod-sys/src/bindings.rs | 1920 ++++++++++++++++++++
 2 files changed, 1930 insertions(+)
 create mode 100644 bindings/rust/libgpiod-sys/README.md
 create mode 100644 bindings/rust/libgpiod-sys/src/bindings.rs

bindings/rust/libgpiod-sys/README.md new file +0 -0

new file mode 100644
index 000000000000..ea037d6d7803

bindings/rust/libgpiod-sys/README.md line 10

Quoted 6 lines · Viresh Kumar

bindings/rust/libgpiod-sys/README.md new file +6 -0

+## 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. Commit changes in `src/bindings.rs`

Those instructions do not force the regeneration of the bindings.

I assume the rust build system is being clever and determining nothing has changed and short circuiting, but I would like to regnerate them to be sure. How do I do that?

How is the --features approach better than just bindgen -o src/bindings.rs ../../../include/gpiod.h ?

Why not build this all the time rather than hiding it behind a feature?

bindings/rust/libgpiod-sys/src/bindings.rs line 2

Quoted 8 lines

bindings/rust/libgpiod-sys/src/bindings.rs new file +2 -0

new file mode 100644
index 000000000000..930eb894f66f
@@ -0,0 +1,1920 @@
+/* automatically generated by rust-bindgen 0.59.2 */
+

Yet the Cargo.toml specifies 0.59.1.
So you didn't generate this with the instructions above then?

Having said that, I can confirm that

bindgen -o src/bindings.rs wrapper.h

with the appropriate bindgen, regenerates the pre-generated file.

Quoted 9 lines · Kent Gibson

bindings/rust/libgpiod-sys/README.md line 10

Quoted 6 lines · Viresh Kumar

bindings/rust/libgpiod-sys/README.md new file +6 -0

+## 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. Commit changes in `src/bindings.rs`

Those instructions do not force the regeneration of the bindings.

It does, just that the new file that got generated lands somewhere like this:

target/debug/build/libgpiod-sys-769f98853e1c0550/out/bindings.rs

and the end user crate will use this instead of the one in src/.

Quoted 13 lines · Viresh Kumar

Quoted 9 lines · Kent Gibson

Review

Quoted 6 lines · Viresh Kumar

(quoted diff) +6 -0

+## 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. Commit changes in `src/bindings.rs`

Those instructions do not force the regeneration of the bindings.

It does, just that the new file that got generated lands somewhere like this:

Quoted 4 lines

target/debug/build/libgpiod-sys-769f98853e1c0550/out/bindings.rs

and the end user crate will use this instead of the one in src/.

But the instructions don't mention any of that, and the implication is that src/bindings.rs will be regenerated.

Quoted 14 lines · Kent Gibson

Quoted 13 lines · Viresh Kumar

Quoted 9 lines · Kent Gibson

Review

Quoted 6 lines · Viresh Kumar

(quoted diff) +6 -0

+## 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. Commit changes in `src/bindings.rs`

Those instructions do not force the regeneration of the bindings.

It does, just that the new file that got generated lands somewhere like this:

Quoted 7 lines

Quoted 4 lines

target/debug/build/libgpiod-sys-769f98853e1c0550/out/bindings.rs

and the end user crate will use this instead of the one in src/.

But the instructions don't mention any of that, and the implication is that src/bindings.rs will be regenerated.

Something like this is okay ?

bindings/rust/libgpiod-sys/README.md +0 -0

index ea037d6d7803..7d4583519e87 100644

Add support to generate gpiosim bindings.

Signed-off-by Viresh Kumar <[email protected]>

---
 bindings/rust/libgpiod-sys/Cargo.toml        |  1 +
 bindings/rust/libgpiod-sys/build.rs          | 19 +++++++++++++++++--
 bindings/rust/libgpiod-sys/gpiosim_wrapper.h |  1 +
 3 files changed, 19 insertions(+), 2 deletions(-)
 create mode 100644 bindings/rust/libgpiod-sys/gpiosim_wrapper.h

bindings/rust/libgpiod-sys/Cargo.toml +0 -0

index 77f82719d269..73b6761d16dd 100644

bindings/rust/libgpiod-sys/Cargo.toml +0 -0

 [build-dependencies]
 bindgen = { version = "0.59.1", optional = true }

bindings/rust/libgpiod-sys/build.rs +17 -2

index bbcd30f79d23..147daaf6b1da 100644
@@ -14,13 +14,25 @@ fn generate_bindings(files: &Vec<&str>) {
         println!("cargo:rerun-if-changed={}", file);
     }
 
+    if cfg!(feature = "gpiosim") {
+        println!("cargo:rerun-if-changed=gpiosim_wrapper.h");
+    }
+
     // The bindgen::Builder is the main entry point
     // to bindgen, and lets you build up options for
     // the resulting bindings.
-    let bindings = bindgen::Builder::default()
+    let mut builder = bindgen::Builder::default()
         // The input header we would like to generate
         // bindings for.
-        .header("wrapper.h")
+        .header("wrapper.h");
+
+    if cfg!(feature = "gpiosim") {
+        builder = builder.header("gpiosim_wrapper.h");
+        println!("cargo:rustc-link-lib=kmod");
+        println!("cargo:rustc-link-lib=mount");
+    }
+
+    let bindings = builder
         // Tell cargo to invalidate the built crate whenever any of the
         // included header files changed.
         .parse_callbacks(Box::new(bindgen::CargoCallbacks))

@@ -46,6 +58,7 @@ fn build_gpiod(files: Vec<&str>) {
         .define("_GNU_SOURCE", None)
         .define("GPIOD_VERSION_STR", "\"libgpio-sys\"")
         .include("../../../include")
+        .include("/usr/include/libmount")
         .compile("gpiod");
 }
 

@@ -61,6 +74,8 @@ fn main() {
         "../../../lib/line-request.c",
         "../../../lib/misc.c",
         "../../../lib/request-config.c",
+        #[cfg(feature = "gpiosim")]
+        "../../../tests/gpiosim/gpiosim.c",
     ];
 
     #[cfg(feature = "generate")]

bindings/rust/libgpiod-sys/gpiosim_wrapper.h new file +0 -0

new file mode 100644
index 000000000000..47dc12a87917

Quoted 16 lines · Viresh Kumar

Add support to generate gpiosim bindings.

Signed-off-by Viresh Kumar <[email protected]>

---
 bindings/rust/libgpiod-sys/Cargo.toml        |  1 +
 bindings/rust/libgpiod-sys/build.rs          | 19 +++++++++++++++++--
 bindings/rust/libgpiod-sys/gpiosim_wrapper.h |  1 +
 3 files changed, 19 insertions(+), 2 deletions(-)
 create mode 100644 bindings/rust/libgpiod-sys/gpiosim_wrapper.h

bindings/rust/libgpiod-sys/Cargo.toml +0 -0

index 77f82719d269..73b6761d16dd 100644
@@ -9,6 +9,7 @@ edition = "2018"
 

bindings/rust/libgpiod-sys/Cargo.toml edition = "2018" · line 13

Quoted 4 lines

bindings/rust/libgpiod-sys/Cargo.toml +1 -0

 [features]
 generate = [ "bindgen" ]
+gpiosim = [ "generate", "bindgen" ]
 

Should gpiosim be a feature or a separate library/crate?

I would expect it to be a separate crate and for libgpiod to have a dev-dependency on it (it is only required for tests, right?).

bindings/rust/libgpiod-sys/gpiosim_wrapper.h line 1

Quoted 8 lines

bindings/rust/libgpiod-sys/gpiosim_wrapper.h new file +1 -0

new file mode 100644
index 000000000000..47dc12a87917
@@ -0,0 +1 @@
+#include "../../../tests/gpiosim/gpiosim.h"

Why bother with this wrapper - just bindgen that header directly?

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

Signed-off-by Viresh Kumar <[email protected]>

---
 bindings/rust/Cargo.toml            |  12 +
 bindings/rust/src/chip.rs           | 179 ++++++++++
 bindings/rust/src/chip_info.rs      |  69 ++++
 bindings/rust/src/edge_event.rs     | 105 ++++++
 bindings/rust/src/event_buffer.rs   |  88 +++++
 bindings/rust/src/info_event.rs     |  68 ++++
 bindings/rust/src/lib.rs            | 317 ++++++++++++++++++
 bindings/rust/src/line_config.rs    | 493 ++++++++++++++++++++++++++++
 bindings/rust/src/line_info.rs      | 189 +++++++++++
 bindings/rust/src/line_request.rs   | 248 ++++++++++++++
 bindings/rust/src/request_config.rs | 122 +++++++
 11 files changed, 1890 insertions(+)
 create mode 100644 bindings/rust/Cargo.toml
 create mode 100644 bindings/rust/src/chip.rs
 create mode 100644 bindings/rust/src/chip_info.rs
 create mode 100644 bindings/rust/src/edge_event.rs
 create mode 100644 bindings/rust/src/event_buffer.rs
 create mode 100644 bindings/rust/src/info_event.rs
 create mode 100644 bindings/rust/src/lib.rs
 create mode 100644 bindings/rust/src/line_config.rs
 create mode 100644 bindings/rust/src/line_info.rs
 create mode 100644 bindings/rust/src/line_request.rs
 create mode 100644 bindings/rust/src/request_config.rs

bindings/rust/Cargo.toml new file +0 -0

new file mode 100644
index 000000000000..d5d81486fa2f

bindings/rust/Cargo.toml new file +7 -0

+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+libc = ">=0.2.39"
+libgpiod-sys = { path = "libgpiod-sys" }
+thiserror = "1.0"
+vmm-sys-util = "=0.9.0"

bindings/rust/src/chip.rs new file +49 -0

new file mode 100644
index 000000000000..50b5d6102f96
@@ -0,0 +1,179 @@
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+//
+// Copyright 2022 Linaro Ltd. All Rights Reserved.
+//     Viresh Kumar <[email protected]>
+
+use std::os::raw::c_char;
+use std::sync::Arc;
+use std::time::Duration;
+use std::{slice, str};
+
+use vmm_sys_util::errno::Error as IoError;
+
+use super::{
+    bindings, chip_info::ChipInfo, Error, InfoEvent, LineConfig, LineInfo, LineRequest,
+    RequestConfig, Result,
+};
+
+/// GPIO chip
+///
+/// A GPIO chip object is associated with an open file descriptor to the GPIO
+/// character device. It exposes basic information about the chip and allows
+/// callers to retrieve information about each line, watch lines for state
+/// changes and make line requests.
+pub(crate) struct ChipInternal {
+    chip: *mut bindings::gpiod_chip,
+}
+
+impl ChipInternal {
+    /// Find a chip by path.
+    pub(crate) fn open(path: &str) -> Result<Self> {
+        // Null-terminate the string
+        let path = path.to_owned() + "\0";
+
+        let chip = unsafe { bindings::gpiod_chip_open(path.as_ptr() as *const c_char) };
+        if chip.is_null() {
+            return Err(Error::OperationFailed("Gpio Chip open", IoError::last()));
+        }
+
+        Ok(Self { chip })
+    }
+
+    /// Private helper, Returns gpiod_chip
+    pub(crate) fn chip(&self) -> *mut bindings::gpiod_chip {
+        self.chip
+    }
+}
+
+impl Drop for ChipInternal {
+    /// Close the chip and release all associated resources.

bindings/rust/src/chip.rs new file +4 -0

+impl Chip {
+    /// Find a chip by path.
+    pub fn open(path: &str) -> Result<Self> {
+        let ichip = Arc::new(ChipInternal::open(path)?);

bindings/rust/src/chip.rs new file +30 -0

+
+        // SAFETY: The string is guaranteed to be valid here.
+        str::from_utf8(unsafe {
+            slice::from_raw_parts(path as *const u8, bindings::strlen(path) as usize)
+        })
+        .map_err(Error::InvalidString)
+    }
+
+    /// Get information about the chip.
+    pub fn info(&self) -> Result<ChipInfo> {
+        ChipInfo::new(self.ichip.clone())
+    }
+
+    /// Get a snapshot of information about the line.
+    pub fn line_info(&self, offset: u32) -> Result<LineInfo> {
+        LineInfo::new(self.ichip.clone(), offset, false)
+    }
+
+    /// Get the current snapshot of information about the line at given offset
+    /// and optionally start watching it for future changes.
+    pub fn watch_line_info(&self, offset: u32) -> Result<LineInfo> {
+        LineInfo::new(self.ichip.clone(), offset, true)
+    }
+
+    /// Get the file descriptor associated with the chip.
+    ///
+    /// The returned file descriptor must not be closed by the caller, else other methods for the
+    /// `struct Chip` may fail.
+    pub fn get_fd(&self) -> Result<u32> {
+        let fd = unsafe { bindings::gpiod_chip_get_fd(self.ichip.chip()) };

bindings/rust/src/chip.rs new file +4 -0

+        let ret = unsafe {
+            bindings::gpiod_chip_wait_info_event(self.ichip.chip(), timeout.as_nanos() as i64)
+        };
+

bindings/rust/src/chip.rs new file +29 -0

+        // Null-terminate the string
+        let name = name.to_owned() + "\0";
+
+        let ret = unsafe {
+            bindings::gpiod_chip_get_line_offset_from_name(
+                self.ichip.chip(),
+                name.as_ptr() as *const c_char,
+            )
+        };
+
+        if ret == -1 {
+            Err(Error::OperationFailed(
+                "Gpio Chip find-line",
+                IoError::last(),
+            ))
+        } else {
+            Ok(ret as u32)
+        }
+    }
+
+    /// Request a set of lines for exclusive usage.
+    pub fn request_lines(
+        &self,
+        rconfig: &RequestConfig,
+        lconfig: &LineConfig,
+    ) -> Result<LineRequest> {
+        LineRequest::new(&self.ichip, rconfig, lconfig)
+    }
+}

bindings/rust/src/chip_info.rs new file +7 -0

new file mode 100644
index 000000000000..950368b54c6f
@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+//
+// Copyright 2022 Linaro Ltd. All Rights Reserved.
+//     Viresh Kumar <[email protected]>
+
+use std::sync::Arc;
+use std::{slice, str};

bindings/rust/src/chip_info.rs new file +10 -0

+impl ChipInfo {
+    /// Find a GPIO chip by path.
+    pub(crate) fn new(chip: Arc<ChipInternal>) -> Result<Self> {
+        let info = unsafe { bindings::gpiod_chip_get_info(chip.chip()) };
+        if info.is_null() {
+            return Err(Error::OperationFailed(
+                "Gpio Chip get info",
+                IoError::last(),
+            ));
+        }

bindings/rust/src/chip_info.rs new file +32 -0

+        // SAFETY: The string is guaranteed to be valid here.
+        str::from_utf8(unsafe {
+            slice::from_raw_parts(name as *const u8, bindings::strlen(name) as usize)
+        })
+        .map_err(Error::InvalidString)
+    }
+
+    /// Get the GPIO chip label as represented in the kernel.
+    pub(crate) fn label(&self) -> Result<&str> {
+        // SAFETY: The string returned by libgpiod is guaranteed to live as long
+        // as the `struct Chip`.
+        let label = unsafe { bindings::gpiod_chip_info_get_label(self.info) };
+
+        // SAFETY: The string is guaranteed to be valid here.
+        str::from_utf8(unsafe {
+            slice::from_raw_parts(label as *const u8, bindings::strlen(label) as usize)
+        })
+        .map_err(Error::InvalidString)
+    }
+
+    /// Get the number of GPIO lines exposed by the chip.
+    pub(crate) fn num_lines(&self) -> u32 {
+        unsafe { bindings::gpiod_chip_info_get_num_lines(self.info) as u32 }
+    }
+}
+
+impl Drop for ChipInfo {
+    /// Close the GPIO chip info and release all associated resources.
+    fn drop(&mut self) {
+        unsafe { bindings::gpiod_chip_info_free(self.info) }
+    }
+}

bindings/rust/src/edge_event.rs new file +24 -0

new file mode 100644
index 000000000000..89bda58709d2
@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+//
+// 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 IoError;
+
+use super::{bindings, EdgeEventBufferInternal, Error, LineEdgeEvent, Result};
+
+/// Line edge events handling
+///
+/// An edge event object contains information about a single line edge event.
+/// It contains the event type, timestamp and the offset of the line on which
+/// the event occurred as well as two sequence numbers (global for all lines
+/// in the associated request and local for this line only).
+///
+/// Edge events are stored into an edge-event buffer object to improve
+/// performance and to limit the number of memory allocations when a large
+/// number of events are being read.
+
+pub struct EdgeEvent {

bindings/rust/src/edge_event.rs new file +19 -0

+    ) -> Result<Self> {
+        let event = unsafe { bindings::gpiod_edge_event_buffer_get_event(ibuffer.buffer(), index) };
+        if event.is_null() {
+            return Err(Error::OperationFailed(
+                "Gpio EdgeEvent buffer-get-event",
+                IoError::last(),
+            ));
+        }
+
+        if copy {
+            let event = unsafe { bindings::gpiod_edge_event_copy(event) };
+            if event.is_null() {
+                return Err(Error::OperationFailed(
+                    "Gpio EdgeEvent copy",
+                    IoError::last(),
+                ));
+            }
+
+            Ok(Self {

bindings/rust/src/edge_event.rs new file +42 -0

+
+    /// Get the event type.
+    pub fn get_event_type(&self) -> Result<LineEdgeEvent> {
+        LineEdgeEvent::new(unsafe { bindings::gpiod_edge_event_get_event_type(self.event) } as u32)
+    }
+
+    /// Get the timestamp of the event.
+    pub fn get_timestamp(&self) -> Duration {
+        Duration::from_nanos(unsafe { bindings::gpiod_edge_event_get_timestamp_ns(self.event) })
+    }
+
+    /// Get the offset of the line on which the event was triggered.
+    pub fn get_line_offset(&self) -> u32 {
+        unsafe { bindings::gpiod_edge_event_get_line_offset(self.event) }
+    }
+
+    /// Get the global sequence number of the event.
+    ///
+    /// Returns sequence number of the event relative to all lines in the
+    /// associated line request.
+    pub fn get_global_seqno(&self) -> u64 {
+        unsafe { bindings::gpiod_edge_event_get_global_seqno(self.event) }
+    }
+
+    /// Get the event sequence number specific to concerned line.
+    ///
+    /// Returns sequence number of the event relative to the line within the
+    /// lifetime of the associated line request.
+    pub fn get_line_seqno(&self) -> u64 {
+        unsafe { bindings::gpiod_edge_event_get_line_seqno(self.event) }
+    }
+}
+
+impl Drop for EdgeEvent {
+    /// Free the edge event.
+    fn drop(&mut self) {
+        // Free the event only if a copy is made
+        if self.ibuffer.is_none() {
+            unsafe { bindings::gpiod_edge_event_free(self.event) };
+        }
+    }
+}

bindings/rust/src/event_buffer.rs new file +13 -0

new file mode 100644
index 000000000000..bb568a80e09c
@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+//
+// Copyright 2022 Linaro Ltd. All Rights Reserved.
+//     Viresh Kumar <[email protected]>
+
+use std::os::raw::c_ulong;
+use std::sync::Arc;
+
+use vmm_sys_util::errno::Error as IoError;
+
+use super::{bindings, EdgeEvent, Error, Result};
+
+/// Line edge events buffer

bindings/rust/src/event_buffer.rs new file +39 -0

+        let buffer = unsafe { bindings::gpiod_edge_event_buffer_new(capacity as c_ulong) };
+        if buffer.is_null() {
+            return Err(Error::OperationFailed(
+                "Gpio EdgeEventBuffer new",
+                IoError::last(),
+            ));
+        }
+
+        Ok(Self { buffer })
+    }
+
+    /// Private helper, Returns gpiod_edge_event_buffer
+    pub(crate) fn buffer(&self) -> *mut bindings::gpiod_edge_event_buffer {
+        self.buffer
+    }
+}
+
+impl Drop for EdgeEventBufferInternal {
+    /// Free the edge event buffer and release all associated resources.
+    fn drop(&mut self) {
+        unsafe { bindings::gpiod_edge_event_buffer_free(self.buffer) };
+    }
+}
+
+/// Line edge events buffer
+pub struct EdgeEventBuffer {
+    ibuffer: Arc<EdgeEventBufferInternal>,
+}
+
+impl EdgeEventBuffer {
+    /// Create a new edge event buffer.
+    ///
+    /// If capacity equals 0, it will be set to a default value of 64. If
+    /// capacity is larger than 1024, it will be limited to 1024.
+    pub fn new(capacity: u32) -> Result<Self> {
+        Ok(Self {
+            ibuffer: Arc::new(EdgeEventBufferInternal::new(capacity)?),
+        })
+    }

bindings/rust/src/event_buffer.rs new file +4 -0

+    pub fn get_num_events(&self) -> u32 {
+        unsafe { bindings::gpiod_edge_event_buffer_get_num_events(self.buffer()) as u32 }
+    }
+}

bindings/rust/src/info_event.rs new file +68 -0

new file mode 100644
index 000000000000..ffba23f350be
@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+//
+// Copyright 2022 Linaro Ltd. All Rights Reserved.
+//     Viresh Kumar <[email protected]>
+
+use std::convert::TryFrom;
+use std::sync::Arc;
+use std::time::Duration;
+
+use vmm_sys_util::errno::Error as IoError;
+
+use super::{bindings, ChipInternal, Error, Event, LineInfo, Result};
+
+/// Line status watch events
+///
+/// Accessors for the info event objects allowing to monitor changes in GPIO
+/// line state.
+///
+/// Callers can be notified about changes in line's state using the interfaces
+/// exposed by GPIO chips. Each info event contains information about the event
+/// itself (timestamp, type) as well as a snapshot of line's state in the form
+/// of a line-info object.
+
+pub struct InfoEvent {
+    event: *mut bindings::gpiod_info_event,
+}
+
+impl InfoEvent {
+    /// Get a single chip's line's status change event.
+    pub(crate) fn new(ichip: &Arc<ChipInternal>) -> Result<Self> {
+        let event = unsafe { bindings::gpiod_chip_read_info_event(ichip.chip()) };
+        if event.is_null() {
+            return Err(Error::OperationFailed(
+                "Gpio InfoEvent event-read",
+                IoError::last(),
+            ));
+        }
+
+        Ok(Self { event })
+    }
+
+    /// Private helper, Returns gpiod_info_event
+    pub(crate) fn event(&self) -> *mut bindings::gpiod_info_event {
+        self.event
+    }
+
+    /// Get the event type of the status change event.
+    pub fn get_event_type(&self) -> Result<Event> {
+        Event::new(unsafe { bindings::gpiod_info_event_get_event_type(self.event) } as u32)
+    }
+
+    /// Get the timestamp of the event, read from the monotonic clock.
+    pub fn get_timestamp(&self) -> Duration {
+        Duration::from_nanos(unsafe { bindings::gpiod_info_event_get_timestamp_ns(self.event) })
+    }
+
+    /// Get the line-info object associated with the event.
+    pub fn line_info(&self) -> Result<LineInfo> {
+        LineInfo::try_from(self)
+    }
+}
+
+impl Drop for InfoEvent {
+    /// Free the info event object and release all associated resources.
+    fn drop(&mut self) {
+        unsafe { bindings::gpiod_info_event_free(self.event) }
+    }
+}

bindings/rust/src/lib.rs new file +16 -0

new file mode 100644
index 000000000000..2f2ac515d353
@@ -0,0 +1,317 @@
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+//
+// Rust wrappers for GPIOD APIs
+//
+// Copyright 2022 Linaro Ltd. All Rights Reserved.
+//     Viresh Kumar <[email protected]>
+
+//! libgpiod public API
+//!
+//! This is the complete documentation of the public Rust API made available to
+//! users of libgpiod.
+//!
+//! The API is logically split into several parts such as: GPIO chip & line
+//! operators, GPIO events handling etc.
+
+mod chip;

bindings/rust/src/lib.rs new file +6 -0

+
+pub use crate::chip::*;
+pub use crate::edge_event::*;
+pub use crate::event_buffer::*;
+pub use crate::info_event::*;
+pub use crate::line_config::*;

bindings/rust/src/lib.rs new file +35 -0

+}
+
+/// Direction settings.
+pub enum Direction {
+    /// Request the line(s), but don't change direction.
+    AsIs,
+    /// Direction is input - for reading the value of an externally driven GPIO line.
+    Input,
+    /// Direction is output - for driving the GPIO line.
+    Output,
+}
+
+impl Direction {
+    fn new(dir: u32) -> Result<Self> {
+        match dir {
+            bindings::GPIOD_LINE_DIRECTION_AS_IS => Ok(Direction::AsIs),
+            bindings::GPIOD_LINE_DIRECTION_INPUT => Ok(Direction::Input),
+            bindings::GPIOD_LINE_DIRECTION_OUTPUT => Ok(Direction::Output),
+            _ => Err(Error::InvalidValue("direction", dir)),
+        }
+    }
+
+    fn gpiod_direction(&self) -> u32 {
+        match self {
+            Direction::AsIs => bindings::GPIOD_LINE_DIRECTION_AS_IS,
+            Direction::Input => bindings::GPIOD_LINE_DIRECTION_INPUT,
+            Direction::Output => bindings::GPIOD_LINE_DIRECTION_OUTPUT,
+        }
+    }
+}
+
+/// Internal bias settings.
+pub enum Bias {
+    /// Don't change the bias setting when applying line config.
+    AsIs,

bindings/rust/src/lib.rs new file +54 -0

+impl Bias {
+    fn new(bias: u32) -> Result<Self> {
+        match bias {
+            bindings::GPIOD_LINE_BIAS_AS_IS => Ok(Bias::AsIs),
+            bindings::GPIOD_LINE_BIAS_UNKNOWN => Ok(Bias::Unknown),
+            bindings::GPIOD_LINE_BIAS_DISABLED => Ok(Bias::Disabled),
+            bindings::GPIOD_LINE_BIAS_PULL_UP => Ok(Bias::PullUp),
+            bindings::GPIOD_LINE_BIAS_PULL_DOWN => Ok(Bias::PullDown),
+            _ => Err(Error::InvalidValue("bias", bias)),
+        }
+    }
+
+    fn gpiod_bias(&self) -> u32 {
+        match self {
+            Bias::AsIs => bindings::GPIOD_LINE_BIAS_AS_IS,
+            Bias::Unknown => bindings::GPIOD_LINE_BIAS_UNKNOWN,
+            Bias::Disabled => bindings::GPIOD_LINE_BIAS_DISABLED,
+            Bias::PullUp => bindings::GPIOD_LINE_BIAS_PULL_UP,
+            Bias::PullDown => bindings::GPIOD_LINE_BIAS_PULL_DOWN,
+        }
+    }
+}
+
+/// Drive settings.
+pub enum Drive {
+    /// Drive setting is push-pull.
+    PushPull,
+    /// Line output is open-drain.
+    OpenDrain,
+    /// Line output is open-source.
+    OpenSource,
+}
+
+impl Drive {
+    fn new(drive: u32) -> Result<Self> {
+        match drive {
+            bindings::GPIOD_LINE_DRIVE_PUSH_PULL => Ok(Drive::PushPull),
+            bindings::GPIOD_LINE_DRIVE_OPEN_DRAIN => Ok(Drive::OpenDrain),
+            bindings::GPIOD_LINE_DRIVE_OPEN_SOURCE => Ok(Drive::OpenSource),
+            _ => Err(Error::InvalidValue("drive", drive)),
+        }
+    }
+
+    fn gpiod_drive(&self) -> u32 {
+        match self {
+            Drive::PushPull => bindings::GPIOD_LINE_DRIVE_PUSH_PULL,
+            Drive::OpenDrain => bindings::GPIOD_LINE_DRIVE_OPEN_DRAIN,
+            Drive::OpenSource => bindings::GPIOD_LINE_DRIVE_OPEN_SOURCE,
+        }
+    }
+}
+
+/// Edge detection settings.
+pub enum Edge {

bindings/rust/src/lib.rs new file +13 -0

+impl Edge {
+    fn new(edge: u32) -> Result<Self> {
+        match edge {
+            bindings::GPIOD_LINE_EDGE_NONE => Ok(Edge::None),
+            bindings::GPIOD_LINE_EDGE_RISING => Ok(Edge::Rising),
+            bindings::GPIOD_LINE_EDGE_FALLING => Ok(Edge::Falling),
+            bindings::GPIOD_LINE_EDGE_BOTH => Ok(Edge::Both),
+            _ => Err(Error::InvalidValue("edge", edge)),
+        }
+    }
+
+    fn gpiod_edge(&self) -> u32 {
+        match self {

bindings/rust/src/lib.rs new file +58 -0

+    /// Line direction.
+    Direction,
+    /// Edge detection.
+    EdgeDetection,
+    /// Bias.
+    Bias,
+    /// Drive.
+    Drive,
+    /// Active-low setting.
+    ActiveLow,
+    /// Debounce period.
+    DebouncePeriodUs,
+    /// Event clock type.
+    EventClock,
+    /// Output value.
+    OutputValue,
+}
+
+impl Config {
+    fn new(config: u32) -> Result<Self> {
+        match config {
+            bindings::GPIOD_LINE_CONFIG_PROP_DIRECTION => Ok(Config::Direction),
+            bindings::GPIOD_LINE_CONFIG_PROP_EDGE_DETECTION => Ok(Config::EdgeDetection),
+            bindings::GPIOD_LINE_CONFIG_PROP_BIAS => Ok(Config::Bias),
+            bindings::GPIOD_LINE_CONFIG_PROP_DRIVE => Ok(Config::Drive),
+            bindings::GPIOD_LINE_CONFIG_PROP_ACTIVE_LOW => Ok(Config::ActiveLow),
+            bindings::GPIOD_LINE_CONFIG_PROP_DEBOUNCE_PERIOD_US => Ok(Config::DebouncePeriodUs),
+            bindings::GPIOD_LINE_CONFIG_PROP_EVENT_CLOCK => Ok(Config::EventClock),
+            bindings::GPIOD_LINE_CONFIG_PROP_OUTPUT_VALUE => Ok(Config::OutputValue),
+            _ => Err(Error::InvalidValue("config", config)),
+        }
+    }
+}
+
+/// Event clock settings.
+pub enum EventClock {
+    /// Line uses the monotonic clock for edge event timestamps.
+    Monotonic,
+    /// Line uses the realtime clock for edge event timestamps.
+    Realtime,
+}
+
+impl EventClock {
+    fn new(clock: u32) -> Result<Self> {
+        match clock {
+            bindings::GPIOD_LINE_EVENT_CLOCK_MONOTONIC => Ok(EventClock::Monotonic),
+            bindings::GPIOD_LINE_EVENT_CLOCK_REALTIME => Ok(EventClock::Realtime),
+            _ => Err(Error::InvalidValue("event clock", clock)),
+        }
+    }
+
+    fn gpiod_clock(&self) -> u32 {
+        match self {
+            EventClock::Monotonic => bindings::GPIOD_LINE_EVENT_CLOCK_MONOTONIC,
+            EventClock::Realtime => bindings::GPIOD_LINE_EVENT_CLOCK_REALTIME,
+        }
+    }
+}

bindings/rust/src/lib.rs new file +11 -0

+
+impl Event {
+    fn new(event: u32) -> Result<Self> {
+        match event {
+            bindings::GPIOD_INFO_EVENT_LINE_REQUESTED => Ok(Event::LineRequested),
+            bindings::GPIOD_INFO_EVENT_LINE_RELEASED => Ok(Event::LineReleased),
+            bindings::GPIOD_INFO_EVENT_LINE_CONFIG_CHANGED => Ok(Event::LineConfigChanged),
+            _ => Err(Error::InvalidValue("event", event)),
+        }
+    }
+}

bindings/rust/src/lib.rs new file +13 -0

+impl LineEdgeEvent {
+    fn new(event: u32) -> Result<Self> {
+        match event {
+            bindings::GPIOD_EDGE_EVENT_RISING_EDGE => Ok(LineEdgeEvent::Rising),
+            bindings::GPIOD_EDGE_EVENT_FALLING_EDGE => Ok(LineEdgeEvent::Falling),
+            _ => Err(Error::InvalidValue("edge event", event)),
+        }
+    }
+}
+
+/// Various libgpiod-related functions.
+
+/// Check if the file pointed to by path is a GPIO chip character device.

bindings/rust/src/lib.rs new file +15 -0

+/// Get the API version of the library as a human-readable string.
+pub fn gpiod_version_string() -> Result<&'static str> {
+    // SAFETY: The string returned by libgpiod is guaranteed to live forever.
+    let version = unsafe { bindings::gpiod_version_string() };
+
+    if version.is_null() {
+        return Err(Error::NameNotFound("GPIO library version"));
+    }
+
+    // SAFETY: The string is guaranteed to be valid here.
+    str::from_utf8(unsafe {
+        slice::from_raw_parts(version as *const u8, bindings::strlen(version) as usize)
+    })
+    .map_err(Error::InvalidString)
+}

bindings/rust/src/line_config.rs new file +23 -0

new file mode 100644
index 000000000000..0fc8d0b736a3
@@ -0,0 +1,493 @@
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+//
+// Copyright 2022 Linaro Ltd. All Rights Reserved.
+//     Viresh Kumar <[email protected]>
+
+use libc::EINVAL;
+use std::os::raw::c_ulong;
+use std::time::Duration;
+
+use vmm_sys_util::errno::Error as IoError;
+
+use super::{bindings, Bias, Config, Direction, Drive, Edge, Error, EventClock, Result};
+
+/// Line configuration objects.
+///
+/// The line-config object contains the configuration for lines that can be
+/// used in two cases:
+///  - when making a line request
+///  - when reconfiguring a set of already requested lines.
+///
+/// A new line-config object is instantiated with a set of sane defaults
+/// for all supported configuration settings. Those defaults can be modified by
+/// the caller. Default values can be overridden by applying different values

bindings/rust/src/line_config.rs new file +249 -0

+/// The mutators don't return errors. If the set of options is too complex to
+/// be translated into kernel uAPI structures then an error will be returned at
+/// the time of the request or reconfiguration. If an invalid value was passed
+/// to any of the mutators then the default value will be silently used instead.
+///
+/// Operating on lines in struct LineConfig has no immediate effect on real
+/// GPIOs, it only manipulates the config object in memory.  Those changes are
+/// only applied to the hardware at the time of the request or reconfiguration.
+///
+/// Overrides for lines that don't end up being requested are silently ignored
+/// both in LineRequest::new() as well as in LineRequest::reconfigure_lines().
+///
+/// In cases where all requested lines are using the one configuration, the
+/// line overrides can be entirely ignored when preparing the configuration.
+
+pub struct LineConfig {
+    config: *mut bindings::gpiod_line_config,
+}
+
+impl LineConfig {
+    /// Create a new line config object.
+    pub fn new() -> Result<Self> {
+        let config = unsafe { bindings::gpiod_line_config_new() };
+
+        if config.is_null() {
+            return Err(Error::OperationFailed(
+                "Gpio LineConfig new",
+                IoError::last(),
+            ));
+        }
+
+        Ok(Self { config })
+    }
+
+    /// Private helper, Returns gpiod_line_config
+    pub(crate) fn config(&self) -> *mut bindings::gpiod_line_config {
+        self.config
+    }
+
+    /// Resets the entire configuration stored in the object. This is useful if
+    /// the user wants to reuse the object without reallocating it.
+    pub fn reset(&mut self) {
+        unsafe { bindings::gpiod_line_config_reset(self.config) }
+    }
+
+    /// Set the default line direction.
+    pub fn set_direction_default(&mut self, direction: Direction) {
+        unsafe {
+            bindings::gpiod_line_config_set_direction_default(
+                self.config,
+                direction.gpiod_direction() as i32,
+            )
+        }
+    }
+
+    /// Set the direction for a line.
+    pub fn set_direction_override(&mut self, direction: Direction, offset: u32) {
+        unsafe {
+            bindings::gpiod_line_config_set_direction_override(
+                self.config,
+                direction.gpiod_direction() as i32,
+                offset,
+            )
+        }
+    }
+
+    /// Clear the direction for a line.
+    pub fn clear_direction_override(&mut self, offset: u32) {
+        unsafe { bindings::gpiod_line_config_clear_direction_override(self.config, offset) }
+    }
+
+    /// Check if the direction is overridden for a line.
+    pub fn direction_is_overridden(&self, offset: u32) -> bool {
+        unsafe { bindings::gpiod_line_config_direction_is_overridden(self.config, offset) }
+    }
+
+    /// Get the default direction setting.
+    pub fn get_direction_default(&self) -> Result<Direction> {
+        Direction::new(
+            unsafe { bindings::gpiod_line_config_get_direction_default(self.config) } as u32,
+        )
+    }
+
+    /// Get the direction of a given line.
+    ///
+    /// Direction setting for the line if the config object were used in a request.
+    pub fn get_direction_offset(&self, offset: u32) -> Result<Direction> {
+        Direction::new(unsafe {
+            bindings::gpiod_line_config_get_direction_offset(self.config, offset)
+        } as u32)
+    }
+
+    /// Set the default edge event detection setting.
+    pub fn set_edge_detection_default(&mut self, edge: Edge) {
+        unsafe {
+            bindings::gpiod_line_config_set_edge_detection_default(
+                self.config,
+                edge.gpiod_edge() as i32,
+            )
+        }
+    }
+
+    /// Set the edge event detection for a single line.
+    pub fn set_edge_detection_override(&mut self, edge: Edge, offset: u32) {
+        unsafe {
+            bindings::gpiod_line_config_set_edge_detection_override(
+                self.config,
+                edge.gpiod_edge() as i32,
+                offset,
+            )
+        }
+    }
+
+    /// Clear the edge event detection for a single line.
+    pub fn clear_edge_detection_override(&mut self, offset: u32) {
+        unsafe { bindings::gpiod_line_config_clear_edge_detection_override(self.config, offset) }
+    }
+
+    /// Check if the edge event detection is overridden for a line.
+    pub fn edge_detection_is_overridden(&self, offset: u32) -> bool {
+        unsafe { bindings::gpiod_line_config_edge_detection_is_overridden(self.config, offset) }
+    }
+
+    /// Get the default edge event detection setting.
+    pub fn get_edge_detection_default(&self) -> Result<Edge> {
+        Edge::new(
+            unsafe { bindings::gpiod_line_config_get_edge_detection_default(self.config) } as u32,
+        )
+    }
+
+    /// Get the edge event detection setting for a given line.
+    ///
+    /// Edge event detection setting for the line if the config object were used in a request.
+    pub fn get_edge_detection_offset(&self, offset: u32) -> Result<Edge> {
+        Edge::new(unsafe {
+            bindings::gpiod_line_config_get_edge_detection_offset(self.config, offset)
+        } as u32)
+    }
+
+    /// Set the default bias setting.
+    pub fn set_bias_default(&mut self, bias: Bias) {
+        unsafe {
+            bindings::gpiod_line_config_set_bias_default(self.config, bias.gpiod_bias() as i32)
+        }
+    }
+
+    /// Set the bias for a single line.
+    pub fn set_bias_override(&mut self, bias: Bias, offset: u32) {
+        unsafe {
+            bindings::gpiod_line_config_set_bias_override(
+                self.config,
+                bias.gpiod_bias() as i32,
+                offset,
+            )
+        }
+    }
+
+    /// Clear the bias for a single line.
+    pub fn clear_bias_override(&mut self, offset: u32) {
+        unsafe { bindings::gpiod_line_config_clear_bias_override(self.config, offset) }
+    }
+
+    /// Check if the bias is overridden for a line.
+    pub fn bias_is_overridden(&self, offset: u32) -> bool {
+        unsafe { bindings::gpiod_line_config_bias_is_overridden(self.config, offset) }
+    }
+
+    /// Get the default bias setting.
+    pub fn get_bias_default(&self) -> Result<Bias> {
+        Bias::new(unsafe { bindings::gpiod_line_config_get_bias_default(self.config) } as u32)
+    }
+
+    /// Get the bias setting for a given line.
+    ///
+    /// Bias setting used for the line if the config object were used in a request.
+    pub fn get_bias_offset(&self, offset: u32) -> Result<Bias> {
+        Bias::new(
+            unsafe { bindings::gpiod_line_config_get_bias_offset(self.config, offset) } as u32,
+        )
+    }
+
+    /// Set the default drive setting.
+    pub fn set_drive_default(&mut self, drive: Drive) {
+        unsafe {
+            bindings::gpiod_line_config_set_drive_default(self.config, drive.gpiod_drive() as i32)
+        }
+    }
+
+    /// Set the drive for a single line.
+    pub fn set_drive_override(&mut self, drive: Drive, offset: u32) {
+        unsafe {
+            bindings::gpiod_line_config_set_drive_override(
+                self.config,
+                drive.gpiod_drive() as i32,
+                offset,
+            )
+        }
+    }
+
+    /// clear the drive for a single line.
+    pub fn clear_drive_override(&mut self, offset: u32) {
+        unsafe { bindings::gpiod_line_config_clear_drive_override(self.config, offset) }
+    }
+
+    /// Check if the drive is overridden for a line.
+    pub fn drive_is_overridden(&self, offset: u32) -> bool {
+        unsafe { bindings::gpiod_line_config_drive_is_overridden(self.config, offset) }
+    }
+
+    /// Get the default drive setting.
+    pub fn get_drive_default(&self) -> Result<Drive> {
+        Drive::new(unsafe { bindings::gpiod_line_config_get_drive_default(self.config) } as u32)
+    }
+
+    /// Get the drive setting for a given line.
+    ///
+    /// The offset of the line for which to read the drive setting. Drive setting for the line if
+    /// the config object were used in a request.
+    pub fn get_drive_offset(&self, offset: u32) -> Result<Drive> {
+        Drive::new(
+            unsafe { bindings::gpiod_line_config_get_drive_offset(self.config, offset) } as u32,
+        )
+    }
+
+    /// Set default active-low setting.
+    pub fn set_active_low_default(&mut self, active_low: bool) {
+        unsafe { bindings::gpiod_line_config_set_active_low_default(self.config, active_low) }
+    }
+
+    /// Set active-low setting for a single line.
+    pub fn set_active_low_override(&mut self, active_low: bool, offset: u32) {
+        unsafe {
+            bindings::gpiod_line_config_set_active_low_override(self.config, active_low, offset)
+        }
+    }
+
+    /// Clear a single line's active-low setting.
+    pub fn clear_active_low_override(&mut self, offset: u32) {
+        unsafe { bindings::gpiod_line_config_clear_active_low_override(self.config, offset) }
+    }
+
+    /// Check if the active-low is overridden for a line.
+    pub fn active_low_is_overridden(&mut self, offset: u32) -> bool {
+        unsafe { bindings::gpiod_line_config_active_low_is_overridden(self.config, offset) }
+    }
+
+    /// Check the default active-low setting.
+    pub fn get_active_low_default(&self) -> bool {
+        unsafe { bindings::gpiod_line_config_get_active_low_default(self.config) }

bindings/rust/src/line_config.rs new file +91 -0

+    pub fn set_debounce_period_default(&mut self, period: Duration) {
+        unsafe {
+            bindings::gpiod_line_config_set_debounce_period_us_default(
+                self.config,
+                period.as_micros() as u64,
+            )
+        }
+    }
+
+    /// Set the debounce period for a single line.
+    pub fn set_debounce_period_override(&mut self, period: Duration, offset: u32) {
+        unsafe {
+            bindings::gpiod_line_config_set_debounce_period_us_override(
+                self.config,
+                period.as_micros() as u64,
+                offset,
+            )
+        }
+    }
+
+    /// Clear the debounce period for a single line.
+    pub fn clear_debounce_period_override(&mut self, offset: u32) {
+        unsafe {
+            bindings::gpiod_line_config_clear_debounce_period_us_override(self.config, offset)
+        }
+    }
+
+    /// Check if the debounce period setting is overridden.
+    pub fn debounce_period_is_overridden(&self, offset: u32) -> bool {
+        unsafe { bindings::gpiod_line_config_debounce_period_us_is_overridden(self.config, offset) }
+    }
+
+    /// Get the default debounce period.
+    pub fn get_debounce_period_default(&self) -> Result<Duration> {
+        Ok(Duration::from_micros(unsafe {
+            bindings::gpiod_line_config_get_debounce_period_us_default(self.config)
+        }))
+    }
+
+    /// Get the debounce period for a given line.
+    ///
+    /// Debounce period for the line if the config object were used in a request, 0 if debouncing
+    /// is disabled.
+    pub fn get_debounce_period_offset(&self, offset: u32) -> Result<Duration> {
+        Ok(Duration::from_micros(unsafe {
+            bindings::gpiod_line_config_get_debounce_period_us_offset(self.config, offset)
+        }))
+    }
+
+    /// Set the default event clock setting.
+    pub fn set_event_clock_default(&mut self, clock: EventClock) {
+        unsafe {
+            bindings::gpiod_line_config_set_event_clock_default(
+                self.config,
+                clock.gpiod_clock() as i32,
+            )
+        }
+    }
+
+    /// Set the event clock for a single line.
+    pub fn set_event_clock_override(&mut self, clock: EventClock, offset: u32) {
+        unsafe {
+            bindings::gpiod_line_config_set_event_clock_override(
+                self.config,
+                clock.gpiod_clock() as i32,
+                offset,
+            )
+        }
+    }
+
+    /// Clear the event clock for a single line.
+    pub fn clear_event_clock_override(&mut self, offset: u32) {
+        unsafe { bindings::gpiod_line_config_clear_event_clock_override(self.config, offset) }
+    }
+
+    /// Check if the event clock is overridden for a line.
+    pub fn event_clock_is_overridden(&mut self, offset: u32) -> bool {
+        unsafe { bindings::gpiod_line_config_event_clock_is_overridden(self.config, offset) }
+    }
+
+    /// Get the default event clock setting.
+    pub fn get_event_clock_default(&self) -> Result<EventClock> {
+        EventClock::new(
+            unsafe { bindings::gpiod_line_config_get_event_clock_default(self.config) } as u32,
+        )
+    }
+
+    /// Get the event clock setting for a given line.
+    ///
+    /// Event clock setting for the line if the config object were used in a request.
+    pub fn get_event_clock_offset(&self, offset: u32) -> Result<EventClock> {

bindings/rust/src/line_config.rs new file +100 -0

+    /// Set the output value for a line.
+    pub fn set_output_value_override(&mut self, value: u32, offset: u32) {
+        unsafe {
+            bindings::gpiod_line_config_set_output_value_override(self.config, value as i32, offset)
+        }
+    }
+
+    /// Set the output values for a set of lines.
+    pub fn set_output_values(&mut self, offsets: &[u32], values: &[i32]) -> Result<()> {
+        if offsets.len() != values.len() {
+            return Err(Error::OperationFailed(
+                "Gpio LineConfig array size mismatch",
+                IoError::new(EINVAL),
+            ));
+        }
+
+        unsafe {
+            bindings::gpiod_line_config_set_output_values(
+                self.config,
+                values.len() as c_ulong,
+                offsets.as_ptr(),
+                values.as_ptr(),
+            );
+        }
+
+        Ok(())
+    }
+
+    /// Clear the output value for a line.
+    pub fn clear_output_value_override(&mut self, offset: u32) {
+        unsafe { bindings::gpiod_line_config_clear_output_value_override(self.config, offset) }
+    }
+
+    /// Check if the output value is overridden for a line.
+    pub fn output_value_is_overridden(&self, offset: u32) -> bool {
+        unsafe { bindings::gpiod_line_config_output_value_is_overridden(self.config, offset) }
+    }
+
+    /// Get the default output value, 0 or 1.
+    pub fn get_output_value_default(&self) -> Result<u32> {
+        let value = unsafe { bindings::gpiod_line_config_get_output_value_default(self.config) };
+
+        if value != 0 && value != 1 {
+            Err(Error::OperationFailed(
+                "Gpio LineConfig get-output-value",
+                IoError::last(),
+            ))
+        } else {
+            Ok(value as u32)
+        }
+    }
+
+    /// Get the output value configured for a given line, 0 or 1.
+    pub fn get_output_value_offset(&self, offset: u32) -> Result<u32> {
+        let value =
+            unsafe { bindings::gpiod_line_config_get_output_value_offset(self.config, offset) };
+
+        if value != 0 && value != 1 {
+            Err(Error::OperationFailed(
+                "Gpio LineConfig get-output-value",
+                IoError::last(),
+            ))
+        } else {
+            Ok(value as u32)
+        }
+    }
+
+    /// Get the list of overridden offsets and the corresponding types of overridden settings.
+    pub fn get_overrides(&self) -> Result<Vec<(u32, Config)>> {
+        let num = unsafe { bindings::gpiod_line_config_get_num_overrides(self.config) } as usize;
+        if num == 0 {
+            return Ok(Vec::new());
+        }
+
+        let mut overrides = Vec::new();
+        let mut offset = vec![0_u32; num];
+        let mut props = vec![0_i32; num];
+
+        unsafe {
+            bindings::gpiod_line_config_get_overrides(
+                self.config,
+                offset.as_mut_ptr(),
+                props.as_mut_ptr(),
+            )
+        };
+
+        for i in 0..num {
+            overrides.push((offset[i], Config::new(props[i] as u32)?));
+        }
+
+        Ok(overrides)
+    }
+}
+
+impl Drop for LineConfig {
+    /// Free the line config object and release all associated resources.
+    fn drop(&mut self) {
+        unsafe { bindings::gpiod_line_config_free(self.config) }
+    }
+}

bindings/rust/src/line_info.rs new file +19 -0

new file mode 100644
index 000000000000..70b6bd6a84bb
@@ -0,0 +1,189 @@
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+//
+// Copyright 2022 Linaro Ltd. All Rights Reserved.
+//     Viresh Kumar <[email protected]>
+
+use std::convert::TryFrom;
+use std::sync::Arc;
+use std::time::Duration;
+use std::{slice, str};
+
+use vmm_sys_util::errno::Error as IoError;
+
+use super::{
+    bindings, Bias, ChipInternal, Direction, Drive, Edge, Error, EventClock, InfoEvent, Result,
+};
+
+/// Line info
+///
+/// Exposes functions for retrieving kernel information about both requested and

bindings/rust/src/line_info.rs new file +15 -0

+}
+
+impl LineInfo {
+    /// Get a snapshot of information about the line and optionally start watching it for changes.
+    pub(crate) fn new(ichip: Arc<ChipInternal>, offset: u32, watch: bool) -> Result<Self> {
+        let info = if watch {
+            unsafe { bindings::gpiod_chip_watch_line_info(ichip.chip(), offset) }
+        } else {
+            unsafe { bindings::gpiod_chip_get_line_info(ichip.chip(), offset) }
+        };
+
+        if info.is_null() {
+            return Err(Error::OperationFailed(
+                "Gpio LineInfo line-info",
+                IoError::last(),

bindings/rust/src/line_info.rs new file +85 -0

+    /// Get the offset of the line within the GPIO chip.
+    ///
+    /// The offset uniquely identifies the line on the chip. The combination of the chip and offset
+    /// uniquely identifies the line within the system.
+
+    pub fn get_offset(&self) -> u32 {
+        unsafe { bindings::gpiod_line_info_get_offset(self.info) }
+    }
+
+    /// Get GPIO line's name.
+    pub fn get_name(&self) -> Result<&str> {
+        // SAFETY: The string returned by libgpiod is guaranteed to live as long
+        // as the `struct LineInfo`.
+        let name = unsafe { bindings::gpiod_line_info_get_name(self.info) };
+        if name.is_null() {
+            return Err(Error::NameNotFound("GPIO line's name"));
+        }
+
+        // SAFETY: The string is guaranteed to be valid here.
+        str::from_utf8(unsafe {
+            slice::from_raw_parts(name as *const u8, bindings::strlen(name) as usize)
+        })
+        .map_err(Error::InvalidString)
+    }
+
+    /// Returns True if the line is in use, false otherwise.
+    ///
+    /// The user space can't know exactly why a line is busy. It may have been
+    /// requested by another process or hogged by the kernel. It only matters that
+    /// the line is used and we can't request it.
+    pub fn is_used(&self) -> bool {
+        unsafe { bindings::gpiod_line_info_is_used(self.info) }
+    }
+
+    /// Get the GPIO line's consumer name.
+    pub fn get_consumer(&self) -> Result<&str> {
+        // SAFETY: The string returned by libgpiod is guaranteed to live as long
+        // as the `struct LineInfo`.
+        let name = unsafe { bindings::gpiod_line_info_get_consumer(self.info) };
+        if name.is_null() {
+            return Err(Error::NameNotFound("GPIO line's consumer name"));
+        }
+
+        // SAFETY: The string is guaranteed to be valid here.
+        str::from_utf8(unsafe {
+            slice::from_raw_parts(name as *const u8, bindings::strlen(name) as usize)
+        })
+        .map_err(Error::InvalidString)
+    }
+
+    /// Get the GPIO line's direction.
+    pub fn get_direction(&self) -> Result<Direction> {
+        Direction::new(unsafe { bindings::gpiod_line_info_get_direction(self.info) } as u32)
+    }
+
+    /// Returns true if the line is "active-low", false otherwise.
+    pub fn is_active_low(&self) -> bool {
+        unsafe { bindings::gpiod_line_info_is_active_low(self.info) }
+    }
+
+    /// Get the GPIO line's bias setting.
+    pub fn get_bias(&self) -> Result<Bias> {
+        Bias::new(unsafe { bindings::gpiod_line_info_get_bias(self.info) } as u32)
+    }
+
+    /// Get the GPIO line's drive setting.
+    pub fn get_drive(&self) -> Result<Drive> {
+        Drive::new(unsafe { bindings::gpiod_line_info_get_drive(self.info) } as u32)
+    }
+
+    /// Get the current edge detection setting of the line.
+    pub fn get_edge_detection(&self) -> Result<Edge> {
+        Edge::new(unsafe { bindings::gpiod_line_info_get_edge_detection(self.info) } as u32)
+    }
+
+    /// Get the current event clock setting used for edge event timestamps.
+    pub fn get_event_clock(&self) -> Result<EventClock> {
+        EventClock::new(unsafe { bindings::gpiod_line_info_get_event_clock(self.info) } as u32)
+    }
+
+    /// Returns true if the line is debounced (either by hardware or by the
+    /// kernel software debouncer), false otherwise.
+    pub fn is_debounced(&self) -> bool {
+        unsafe { bindings::gpiod_line_info_is_debounced(self.info) }
+    }

bindings/rust/src/line_info.rs new file +16 -0

+    type Error = Error;
+
+    /// Get the Line info object associated with a event.
+    fn try_from(event: &InfoEvent) -> Result<Self> {
+        let info = unsafe { bindings::gpiod_info_event_get_line_info(event.event()) };
+        if info.is_null() {
+            return Err(Error::OperationFailed(
+                "Gpio LineInfo try-from",
+                IoError::last(),
+            ));
+        }
+
+        Ok(Self {
+            info,
+            ichip: None,
+            free: false,

bindings/rust/src/line_info.rs new file +4 -0

+            unsafe { bindings::gpiod_line_info_free(self.info) }
+        }
+    }
+}

bindings/rust/src/line_request.rs new file +68 -0

new file mode 100644
index 000000000000..bb338e72671d
@@ -0,0 +1,248 @@
+// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
+//
+// Copyright 2022 Linaro Ltd. All Rights Reserved.
+//     Viresh Kumar <[email protected]>
+
+use libc::EINVAL;
+use std::os::raw::c_ulong;
+use std::sync::Arc;
+use std::time::Duration;
+
+use vmm_sys_util::errno::Error as IoError;
+
+use super::{bindings, ChipInternal, EdgeEventBuffer, Error, LineConfig, RequestConfig, Result};
+
+/// Line request operations
+///
+/// Allows interaction with a set of requested lines.
+pub struct LineRequest {
+    request: *mut bindings::gpiod_line_request,
+}
+
+impl LineRequest {
+    /// Request a set of lines for exclusive usage.
+    pub(crate) fn new(
+        ichip: &Arc<ChipInternal>,
+        rconfig: &RequestConfig,
+        lconfig: &LineConfig,
+    ) -> Result<Self> {
+        let request = unsafe {
+            bindings::gpiod_chip_request_lines(ichip.chip(), rconfig.config(), lconfig.config())
+        };
+
+        if request.is_null() {
+            return Err(Error::OperationFailed(
+                "Gpio LineRequest request-lines",
+                IoError::last(),
+            ));
+        }
+
+        Ok(Self { request })
+    }
+
+    /// Get the number of lines in the request.
+    pub fn get_num_lines(&self) -> u32 {
+        unsafe { bindings::gpiod_line_request_get_num_lines(self.request) as u32 }
+    }
+
+    /// Get the offsets of lines in the request.
+    pub fn get_offsets(&self) -> Vec<u32> {
+        let mut offsets = vec![0; self.get_num_lines() as usize];
+
+        unsafe { bindings::gpiod_line_request_get_offsets(self.request, offsets.as_mut_ptr()) };
+        offsets
+    }
+
+    /// Get the value (0 or 1) of a single line associated with the request.
+    pub fn get_value(&self, offset: u32) -> Result<u32> {
+        let value = unsafe { bindings::gpiod_line_request_get_value(self.request, offset) };
+
+        if value != 0 && value != 1 {
+            Err(Error::OperationFailed(
+                "Gpio LineRequest get-value",
+                IoError::last(),
+            ))
+        } else {
+            Ok(value as u32)
+        }
+    }

bindings/rust/src/line_request.rs new file +18 -0

+        let ret = unsafe {
+            bindings::gpiod_line_request_get_values_subset(
+                self.request,
+                offsets.len() as c_ulong,
+                offsets.as_ptr(),
+                values.as_mut_ptr(),
+            )
+        };
+
+        if ret == -1 {
+            Err(Error::OperationFailed(
+                "Gpio LineRequest get-values-subset",
+                IoError::last(),
+            ))
+        } else {
+            Ok(())
+        }
+    }

bindings/rust/src/line_request.rs new file +103 -0

+        let ret =
+            unsafe { bindings::gpiod_line_request_get_values(self.request, values.as_mut_ptr()) };
+
+        if ret == -1 {
+            Err(Error::OperationFailed(
+                "Gpio LineRequest get-values",
+                IoError::last(),
+            ))
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Set the value of a single line associated with the request.
+    pub fn set_value(&self, offset: u32, value: i32) -> Result<()> {
+        let ret = unsafe { bindings::gpiod_line_request_set_value(self.request, offset, !!value) };
+
+        if ret == -1 {
+            Err(Error::OperationFailed(
+                "Gpio LineRequest set-value",
+                IoError::last(),
+            ))
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Get values of a subset of lines associated with the request.
+    pub fn set_values_subset(&self, offsets: &[u32], values: &[i32]) -> Result<()> {
+        if offsets.len() != values.len() {
+            return Err(Error::OperationFailed(
+                "Gpio LineRequest array size mismatch",
+                IoError::new(EINVAL),
+            ));
+        }
+
+        let ret = unsafe {
+            bindings::gpiod_line_request_set_values_subset(
+                self.request,
+                offsets.len() as c_ulong,
+                offsets.as_ptr(),
+                values.as_ptr(),
+            )
+        };
+
+        if ret == -1 {
+            Err(Error::OperationFailed(
+                "Gpio LineRequest set-values-subset",
+                IoError::last(),
+            ))
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Get values of all lines associated with the request.
+    pub fn set_values(&self, values: &[i32]) -> Result<()> {
+        if values.len() != self.get_num_lines() as usize {
+            return Err(Error::OperationFailed(
+                "Gpio LineRequest array size mismatch",
+                IoError::new(EINVAL),
+            ));
+        }
+
+        let ret = unsafe { bindings::gpiod_line_request_set_values(self.request, values.as_ptr()) };
+
+        if ret == -1 {
+            Err(Error::OperationFailed(
+                "Gpio LineRequest set-values",
+                IoError::last(),
+            ))
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Update the configuration of lines associated with the line request.
+    pub fn reconfigure_lines(&self, lconfig: &LineConfig) -> Result<()> {
+        let ret = unsafe {
+            bindings::gpiod_line_request_reconfigure_lines(self.request, lconfig.config())
+        };
+
+        if ret == -1 {
+            Err(Error::OperationFailed(
+                "Gpio LineRequest reconfigure-lines",
+                IoError::last(),
+            ))
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Get the file descriptor associated with the line request.
+    pub fn get_fd(&self) -> u32 {
+        unsafe { bindings::gpiod_line_request_get_fd(self.request) as u32 }
+    }
+
+    /// Wait for edge events on any of the lines associated with the request.
+    pub fn wait_edge_event(&self, timeout: Duration) -> Result<()> {
+        let ret = unsafe {
+            bindings::gpiod_line_request_wait_edge_event(self.request, timeout.as_nanos() as i64)
+        };
+