Is it possible to generate bindings for DriverKit?

[theoparis]

I wanted to see if I could use PCIDriverKit on a macos system from Rust code - I do know that the headers provided by driverkit are made for C++ with inheritance so I'm not entirely sure how it would work on the rust end. However attempting to use aarch64-apple-driverkit (which is supported by clang) in rust with a custom target spec json gives:

  process didn't exit successfully: `/Volumes/Gigatop/usr/src/driverkit-rs/target/debug/build/bindings-77c1520b02a5e059/build-script-build` (exit status: 101)
  --- stderr
  thread 'main' panicked at /Users/theo/.cargo/registry/src/index.crates.io-6f17d22bba15001f/bindgen-0.70.1/ir/context.rs:561:15:
  libclang error; possible causes include:
  - Invalid flag syntax
  - Unrecognized flags
  - Invalid flag arguments

// build.rs
use bindgen::Builder;
use std::{env, path::PathBuf, process::Command};

fn main() {
	let sysroot = Command::new("xcrun")
		.arg("--show-sdk-path")
		.stdout(std::process::Stdio::piped())
		.output()
		.unwrap();

	let bindings = Builder::default()
		.header("wrapper.h")
		.clang_arg("--target=aarch64-apple-driverkit")
		.clang_arg(format!(
			"-isysroot{}",
			String::from_utf8(sysroot.stdout).unwrap().trim()
		))
		.clang_arg("-x")
		.clang_arg("objcpp")
		.generate()
		.expect("Unable to generate bindings");

	let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
	bindings
		.write_to_file(out_path.join("bindings.rs"))
		.expect("Couldn't write bindings!");
}

// wrapper.h
#include <Availability.h>
#include <DriverKit/IOLib.h>
#include <DriverKit/IOService.h>
#include <DriverKit/IOUserClient.h>
#include <PCIDriverKit/IOPCIDevice.h>

Is there a better way to do this with pure rust code? I haven't been able to find anything that already exists on this unfortunately.

[boydjohnson]

bindgen --no-derive-debug wrapper.h -- --target=arm64-apple-driverkit -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/DriverKit.platform/Developer/SDKs/DriverKit.sdk -x c++ > driverkit.rs.   

This generated bindings that compiled for me. No guarantee about usability.

The things that I noticed that weren't right were the objcpp when it is a c++ api, wrong sysroot, and the arm64-apple-driverkit for aarch64-apple-driverkit.

Try this for your build.rs

use bindgen::Builder;
use std::{env, path::PathBuf, process::Command};

fn main() {
    // let sysroot = Command::new("xcrun")
    // 	.arg("--show-sdk-path")
    // 	.stdout(std::process::Stdio::piped())
    // 	.output()
    // 	.unwrap();

    let bindings = Builder::default()
        .derive_debug(false)
        .derive_default(false)
        .header("wrapper.h")
        .clang_arg("--target=arm64-apple-driverkit")
        .clang_arg("-isysroot/Applications/Xcode.app/Contents/Developer/Platforms/DriverKit.platform/Developer/SDKs/DriverKit.sdk")
        .clang_arg("-x")
        .clang_arg("c++")
        .clang_arg("-std=c++17")
        .generate()
        .unwrap();

    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
    bindings
        .write_to_file(out_path.join("bindings.rs"))
        .expect("Couldn't write bindings!");
}

Good luck.

[madsmtm]

I think even if you manage to get the bindings generated, I doubt your custom target spec is gonna work, there are places in rustc that needs to know the exact Apple OS, so rustc really needs upstream support for that to work.

(Feel free to tag me if you end up filing an issue in rustc for adding support for DriverKit).

[madsmtm]

Also, I'm not sure of the difference between the Clang targets myself, but are you sure you need arm64-apple-driverkit, and can't just use arm64-apple-macos? The DriverKit headers seem to be available in the macOS SDK?

[madsmtm]

Nvmd, PCIDriverKit is only available in the DriverKit SDK