system_api: Add copy of ChromeOS's system_api

Adds a script that copies the bindings we need upstream. We cannot
use the original repository, as it's part of the large platform2 git
repository, and the original build.rs depends on ChromeOS tooling to
generate these bindings.

So instead, this change adds a script that can be called from a
chromiumos checkout of crosvm to update the upstream bindings.

This allows us to enable certain features that talk to ChromeOS
dbus services. They won't be functional upstream, but at least we
can compile and test the code.

To make things more consistent, we no longer replace the crate
with the ChromeOS version when building for ChromeOS.

BUG=b:244618505
TEST=presubmit

Change-Id: I504cbf6d12b0cb50d9935f5e49b7fa72b692d45c
Reviewed-on: https://chromium-review.googlesource.com/c/crosvm/crosvm/+/3919814
Reviewed-by: Daniel Verkamp <dverkamp@chromium.org>

Cargo.lock

@@ -1688,6 +1688,10 @@ dependencies = [
 [[package]]
 name = "system_api"
 version = "0.1.0"
+dependencies = [
+ "dbus",
+ "protobuf",
+]
 
 [[package]]
 name = "tempfile"

Cargo.toml

@@ -78,6 +78,7 @@ members = [
     "resources",
     "rutabaga_gfx",
     "serde_keyvalue",
+    "system_api",
     "tpm2",
     "tpm2-sys",
     "tracing",
@@ -262,6 +263,5 @@ data_model = { path = "common/data_model" }
 libcras = { path = "libcras_stub" } # ignored by ebuild
 p9 = { path = "common/p9" } # ignored by ebuild
 sync = { path = "common/sync" }
-system_api = { path = "system_api_stub" } # ignored by ebuild
 wire_format_derive = { path = "common/p9/wire_format_derive" } # ignored by ebuild
 minijail = { path = "third_party/minijail/rust/minijail" } # ignored by ebuild

devices/Cargo.toml

@@ -66,7 +66,7 @@ serde_json = "1"
 serde_keyvalue = { path = "../serde_keyvalue", features = ["argh_derive"] }
 smallvec = "1.6.1"
 sync = { path = "../common/sync" }
-system_api = { version = "*", optional = true }
+system_api = { path = "../system_api", optional = true }
 thiserror = "1.0.20"
 tpm2 = { path = "../tpm2", optional = true }
 tracing = { path = "../tracing" }

system_api/Cargo.toml

@@ -6,3 +6,7 @@ edition = "2021"
 
 [lib]
 path = "src/system_api.rs"
+
+[target.'cfg(unix)'.dependencies]
+dbus = "0.9"
+protobuf = "2.24"

system_api/README.md

@@ -0,0 +1,15 @@
+# Crosvm version of ChromeOS's system_api
+
+system_api is used by ChromeOS to interact with other system services and mainly contains
+automatically generated bindings for dbus services and proto types.
+
+The ground truth for this crate is in the ChromeOS codebase at [platform2/system_api].
+
+To allow us to build ChromeOS features in upstream crosvm, we need to copy a subset of the generated
+files into this repository. The `update_bindings.sh` script can be used to update them.
+
+Note: Originally, the ChromeOS build would replace this crate with the ChromeOS
+[platform2/system_api] crate. This is no longer the case and crosvm will always be built against the
+version in this directory.
+
+[platform2/system_api]: https://source.chromium.org/chromiumos/chromiumos/codesearch/+/main:src/platform2/system_api/

system_api/src/bindings/client/org_chromium_userdataauth.rs

@@ -0,0 +1,473 @@
+// This code was autogenerated with `dbus-codegen-rust -s -m None`, see https://github.com/diwic/dbus-rs
+use dbus as dbus;
+#[allow(unused_imports)]
+use dbus::arg;
+use dbus::blocking;
+
+pub trait OrgChromiumUserDataAuthInterface {
+    fn is_mounted(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn unmount(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn mount(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn remove(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn list_keys(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn get_key_data(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn check_key(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn add_key(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn remove_key(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn mass_remove_keys(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn migrate_key(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn start_fingerprint_auth_session(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn end_fingerprint_auth_session(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn get_web_authn_secret(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn get_web_authn_secret_hash(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn get_hibernate_secret(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn start_migrate_to_dircrypto(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn needs_dircrypto_migration(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn get_supported_key_policies(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn get_account_disk_usage(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn start_auth_session(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn add_credentials(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn update_credential(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn authenticate_auth_session(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn invalidate_auth_session(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn extend_auth_session(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn get_auth_session_status(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn create_persistent_user(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn authenticate_auth_factor(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn prepare_guest_vault(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn prepare_ephemeral_vault(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn prepare_persistent_vault(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn prepare_vault_for_migration(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn add_auth_factor(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn update_auth_factor(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn remove_auth_factor(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn list_auth_factors(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn prepare_async_auth_factor(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn get_recovery_request(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn reset_application_container(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+}
+
+#[derive(Debug)]
+pub struct OrgChromiumUserDataAuthInterfaceDircryptoMigrationProgress {
+    pub status: Vec<u8>,
+}
+
+impl arg::AppendAll for OrgChromiumUserDataAuthInterfaceDircryptoMigrationProgress {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.status, i);
+    }
+}
+
+impl arg::ReadAll for OrgChromiumUserDataAuthInterfaceDircryptoMigrationProgress {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(OrgChromiumUserDataAuthInterfaceDircryptoMigrationProgress {
+            status: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for OrgChromiumUserDataAuthInterfaceDircryptoMigrationProgress {
+    const NAME: &'static str = "DircryptoMigrationProgress";
+    const INTERFACE: &'static str = "org.chromium.UserDataAuthInterface";
+}
+
+#[derive(Debug)]
+pub struct OrgChromiumUserDataAuthInterfaceLowDiskSpace {
+    pub status: Vec<u8>,
+}
+
+impl arg::AppendAll for OrgChromiumUserDataAuthInterfaceLowDiskSpace {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.status, i);
+    }
+}
+
+impl arg::ReadAll for OrgChromiumUserDataAuthInterfaceLowDiskSpace {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(OrgChromiumUserDataAuthInterfaceLowDiskSpace {
+            status: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for OrgChromiumUserDataAuthInterfaceLowDiskSpace {
+    const NAME: &'static str = "LowDiskSpace";
+    const INTERFACE: &'static str = "org.chromium.UserDataAuthInterface";
+}
+
+impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target=T>> OrgChromiumUserDataAuthInterface for blocking::Proxy<'a, C> {
+
+    fn is_mounted(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "IsMounted", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn unmount(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "Unmount", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn mount(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "Mount", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn remove(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "Remove", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn list_keys(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "ListKeys", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn get_key_data(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "GetKeyData", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn check_key(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "CheckKey", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn add_key(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "AddKey", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn remove_key(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "RemoveKey", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn mass_remove_keys(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "MassRemoveKeys", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn migrate_key(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "MigrateKey", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn start_fingerprint_auth_session(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "StartFingerprintAuthSession", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn end_fingerprint_auth_session(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "EndFingerprintAuthSession", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn get_web_authn_secret(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "GetWebAuthnSecret", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn get_web_authn_secret_hash(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "GetWebAuthnSecretHash", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn get_hibernate_secret(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "GetHibernateSecret", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn start_migrate_to_dircrypto(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "StartMigrateToDircrypto", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn needs_dircrypto_migration(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "NeedsDircryptoMigration", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn get_supported_key_policies(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "GetSupportedKeyPolicies", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn get_account_disk_usage(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "GetAccountDiskUsage", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn start_auth_session(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "StartAuthSession", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn add_credentials(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "AddCredentials", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn update_credential(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "UpdateCredential", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn authenticate_auth_session(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "AuthenticateAuthSession", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn invalidate_auth_session(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "InvalidateAuthSession", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn extend_auth_session(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "ExtendAuthSession", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn get_auth_session_status(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "GetAuthSessionStatus", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn create_persistent_user(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "CreatePersistentUser", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn authenticate_auth_factor(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "AuthenticateAuthFactor", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn prepare_guest_vault(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "PrepareGuestVault", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn prepare_ephemeral_vault(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "PrepareEphemeralVault", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn prepare_persistent_vault(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "PreparePersistentVault", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn prepare_vault_for_migration(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "PrepareVaultForMigration", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn add_auth_factor(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "AddAuthFactor", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn update_auth_factor(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "UpdateAuthFactor", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn remove_auth_factor(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "RemoveAuthFactor", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn list_auth_factors(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "ListAuthFactors", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn prepare_async_auth_factor(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "PrepareAsyncAuthFactor", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn get_recovery_request(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "GetRecoveryRequest", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn reset_application_container(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.UserDataAuthInterface", "ResetApplicationContainer", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+}
+
+pub trait OrgChromiumArcQuota {
+    fn get_arc_disk_features(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn get_current_space_for_arc_uid(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn get_current_space_for_arc_gid(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn get_current_space_for_arc_project_id(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn set_media_rwdata_file_project_id(&self, fd: arg::OwnedFd, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn set_media_rwdata_file_project_inheritance_flag(&self, fd: arg::OwnedFd, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+}
+
+impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target=T>> OrgChromiumArcQuota for blocking::Proxy<'a, C> {
+
+    fn get_arc_disk_features(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.ArcQuota", "GetArcDiskFeatures", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn get_current_space_for_arc_uid(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.ArcQuota", "GetCurrentSpaceForArcUid", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn get_current_space_for_arc_gid(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.ArcQuota", "GetCurrentSpaceForArcGid", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn get_current_space_for_arc_project_id(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.ArcQuota", "GetCurrentSpaceForArcProjectId", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn set_media_rwdata_file_project_id(&self, fd: arg::OwnedFd, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.ArcQuota", "SetMediaRWDataFileProjectId", (fd, request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn set_media_rwdata_file_project_inheritance_flag(&self, fd: arg::OwnedFd, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.ArcQuota", "SetMediaRWDataFileProjectInheritanceFlag", (fd, request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+}
+
+pub trait OrgChromiumCryptohomePkcs11Interface {
+    fn pkcs11_is_tpm_token_ready(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn pkcs11_get_tpm_token_info(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn pkcs11_terminate(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn pkcs11_restore_tpm_tokens(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+}
+
+impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target=T>> OrgChromiumCryptohomePkcs11Interface for blocking::Proxy<'a, C> {
+
+    fn pkcs11_is_tpm_token_ready(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.CryptohomePkcs11Interface", "Pkcs11IsTpmTokenReady", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn pkcs11_get_tpm_token_info(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.CryptohomePkcs11Interface", "Pkcs11GetTpmTokenInfo", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn pkcs11_terminate(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.CryptohomePkcs11Interface", "Pkcs11Terminate", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn pkcs11_restore_tpm_tokens(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.CryptohomePkcs11Interface", "Pkcs11RestoreTpmTokens", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+}
+
+pub trait OrgChromiumInstallAttributesInterface {
+    fn install_attributes_get(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn install_attributes_set(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn install_attributes_finalize(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn install_attributes_get_status(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn get_firmware_management_parameters(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn remove_firmware_management_parameters(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn set_firmware_management_parameters(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+}
+
+impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target=T>> OrgChromiumInstallAttributesInterface for blocking::Proxy<'a, C> {
+
+    fn install_attributes_get(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.InstallAttributesInterface", "InstallAttributesGet", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn install_attributes_set(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.InstallAttributesInterface", "InstallAttributesSet", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn install_attributes_finalize(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.InstallAttributesInterface", "InstallAttributesFinalize", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn install_attributes_get_status(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.InstallAttributesInterface", "InstallAttributesGetStatus", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn get_firmware_management_parameters(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.InstallAttributesInterface", "GetFirmwareManagementParameters", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn remove_firmware_management_parameters(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.InstallAttributesInterface", "RemoveFirmwareManagementParameters", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn set_firmware_management_parameters(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.InstallAttributesInterface", "SetFirmwareManagementParameters", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+}
+
+pub trait OrgChromiumCryptohomeMiscInterface {
+    fn get_system_salt(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn update_current_user_activity_timestamp(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn get_sanitized_username(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn get_login_status(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn get_status_string(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn lock_to_single_user_mount_until_reboot(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn get_rsu_device_id(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+    fn check_health(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+}
+
+impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target=T>> OrgChromiumCryptohomeMiscInterface for blocking::Proxy<'a, C> {
+
+    fn get_system_salt(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.CryptohomeMiscInterface", "GetSystemSalt", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn update_current_user_activity_timestamp(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.CryptohomeMiscInterface", "UpdateCurrentUserActivityTimestamp", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn get_sanitized_username(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.CryptohomeMiscInterface", "GetSanitizedUsername", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn get_login_status(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.CryptohomeMiscInterface", "GetLoginStatus", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn get_status_string(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.CryptohomeMiscInterface", "GetStatusString", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn lock_to_single_user_mount_until_reboot(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.CryptohomeMiscInterface", "LockToSingleUserMountUntilReboot", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn get_rsu_device_id(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.CryptohomeMiscInterface", "GetRsuDeviceId", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+
+    fn check_health(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.CryptohomeMiscInterface", "CheckHealth", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+}

system_api/src/bindings/client/org_chromium_vtpm.rs

@@ -0,0 +1,17 @@
+// This code was autogenerated with `dbus-codegen-rust -s -m None`, see https://github.com/diwic/dbus-rs
+use dbus as dbus;
+#[allow(unused_imports)]
+use dbus::arg;
+use dbus::blocking;
+
+pub trait OrgChromiumVtpm {
+    fn send_command(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error>;
+}
+
+impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target=T>> OrgChromiumVtpm for blocking::Proxy<'a, C> {
+
+    fn send_command(&self, request: Vec<u8>) -> Result<Vec<u8>, dbus::Error> {
+        self.method_call("org.chromium.Vtpm", "SendCommand", (request, ))
+            .and_then(|r: (Vec<u8>, )| Ok(r.0, ))
+    }
+}

system_api/src/bindings/include_modules.rs

@@ -0,0 +1,6 @@
+#[allow(unused_imports)]
+#[allow(clippy::all)]
+pub mod client {
+  pub mod org_chromium_userdataauth;
+  pub use org_chromium_userdataauth::*;
+}

system_api/src/protos/include_protos.rs

@@ -2,4 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// This space intentionally left blank.
+pub mod UserDataAuth;
+pub mod auth_factor;
+pub mod fido;
+pub mod key;
+pub mod rpc;

system_api/src/protos/vtpm_interface.rs

@@ -0,0 +1,316 @@
+// This file is generated by rust-protobuf 2.27.1. Do not edit
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(box_pointers)]
+#![allow(dead_code)]
+#![allow(missing_docs)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(non_upper_case_globals)]
+#![allow(trivial_casts)]
+#![allow(unused_imports)]
+#![allow(unused_results)]
+//! Generated file from `vtpm_interface.proto`
+
+/// Generated files are compatible only with the same version
+/// of protobuf runtime.
+// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_27_1;
+
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct SendCommandRequest {
+    // message fields
+    command: ::protobuf::SingularField<::std::vec::Vec<u8>>,
+    // special fields
+    pub unknown_fields: ::protobuf::UnknownFields,
+    pub cached_size: ::protobuf::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a SendCommandRequest {
+    fn default() -> &'a SendCommandRequest {
+        <SendCommandRequest as ::protobuf::Message>::default_instance()
+    }
+}
+
+impl SendCommandRequest {
+    pub fn new() -> SendCommandRequest {
+        ::std::default::Default::default()
+    }
+
+    // optional bytes command = 1;
+
+
+    pub fn get_command(&self) -> &[u8] {
+        match self.command.as_ref() {
+            Some(v) => &v,
+            None => &[],
+        }
+    }
+    pub fn clear_command(&mut self) {
+        self.command.clear();
+    }
+
+    pub fn has_command(&self) -> bool {
+        self.command.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_command(&mut self, v: ::std::vec::Vec<u8>) {
+        self.command = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_command(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.command.is_none() {
+            self.command.set_default();
+        }
+        self.command.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_command(&mut self) -> ::std::vec::Vec<u8> {
+        self.command.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+}
+
+impl ::protobuf::Message for SendCommandRequest {
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+        while !is.eof()? {
+            let (field_number, wire_type) = is.read_tag_unpack()?;
+            match field_number {
+                1 => {
+                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.command)?;
+                },
+                _ => {
+                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u32 {
+        let mut my_size = 0;
+        if let Some(ref v) = self.command.as_ref() {
+            my_size += ::protobuf::rt::bytes_size(1, &v);
+        }
+        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        self.cached_size.set(my_size);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+        if let Some(ref v) = self.command.as_ref() {
+            os.write_bytes(1, &v)?;
+        }
+        os.write_unknown_fields(self.get_unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn get_cached_size(&self) -> u32 {
+        self.cached_size.get()
+    }
+
+    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+        &self.unknown_fields
+    }
+
+    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+        &mut self.unknown_fields
+    }
+
+    fn as_any(&self) -> &dyn (::std::any::Any) {
+        self as &dyn (::std::any::Any)
+    }
+    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
+        self as &mut dyn (::std::any::Any)
+    }
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+        self
+    }
+
+    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+        Self::descriptor_static()
+    }
+
+    fn new() -> SendCommandRequest {
+        SendCommandRequest::new()
+    }
+
+    fn default_instance() -> &'static SendCommandRequest {
+        static instance: ::protobuf::rt::LazyV2<SendCommandRequest> = ::protobuf::rt::LazyV2::INIT;
+        instance.get(SendCommandRequest::new)
+    }
+}
+
+impl ::protobuf::Clear for SendCommandRequest {
+    fn clear(&mut self) {
+        self.command.clear();
+        self.unknown_fields.clear();
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for SendCommandRequest {
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
+    }
+}
+
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct SendCommandResponse {
+    // message fields
+    response: ::protobuf::SingularField<::std::vec::Vec<u8>>,
+    // special fields
+    pub unknown_fields: ::protobuf::UnknownFields,
+    pub cached_size: ::protobuf::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a SendCommandResponse {
+    fn default() -> &'a SendCommandResponse {
+        <SendCommandResponse as ::protobuf::Message>::default_instance()
+    }
+}
+
+impl SendCommandResponse {
+    pub fn new() -> SendCommandResponse {
+        ::std::default::Default::default()
+    }
+
+    // optional bytes response = 1;
+
+
+    pub fn get_response(&self) -> &[u8] {
+        match self.response.as_ref() {
+            Some(v) => &v,
+            None => &[],
+        }
+    }
+    pub fn clear_response(&mut self) {
+        self.response.clear();
+    }
+
+    pub fn has_response(&self) -> bool {
+        self.response.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_response(&mut self, v: ::std::vec::Vec<u8>) {
+        self.response = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_response(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.response.is_none() {
+            self.response.set_default();
+        }
+        self.response.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_response(&mut self) -> ::std::vec::Vec<u8> {
+        self.response.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+}
+
+impl ::protobuf::Message for SendCommandResponse {
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+        while !is.eof()? {
+            let (field_number, wire_type) = is.read_tag_unpack()?;
+            match field_number {
+                1 => {
+                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.response)?;
+                },
+                _ => {
+                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u32 {
+        let mut my_size = 0;
+        if let Some(ref v) = self.response.as_ref() {
+            my_size += ::protobuf::rt::bytes_size(1, &v);
+        }
+        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        self.cached_size.set(my_size);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+        if let Some(ref v) = self.response.as_ref() {
+            os.write_bytes(1, &v)?;
+        }
+        os.write_unknown_fields(self.get_unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn get_cached_size(&self) -> u32 {
+        self.cached_size.get()
+    }
+
+    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+        &self.unknown_fields
+    }
+
+    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+        &mut self.unknown_fields
+    }
+
+    fn as_any(&self) -> &dyn (::std::any::Any) {
+        self as &dyn (::std::any::Any)
+    }
+    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
+        self as &mut dyn (::std::any::Any)
+    }
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+        self
+    }
+
+    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+        Self::descriptor_static()
+    }
+
+    fn new() -> SendCommandResponse {
+        SendCommandResponse::new()
+    }
+
+    fn default_instance() -> &'static SendCommandResponse {
+        static instance: ::protobuf::rt::LazyV2<SendCommandResponse> = ::protobuf::rt::LazyV2::INIT;
+        instance.get(SendCommandResponse::new)
+    }
+}
+
+impl ::protobuf::Clear for SendCommandResponse {
+    fn clear(&mut self) {
+        self.response.clear();
+        self.unknown_fields.clear();
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for SendCommandResponse {
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
+    }
+}

system_api/src/system_api.rs

@@ -0,0 +1,8 @@
+// Copyright 2022 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#![cfg(unix)]
+
+include!("bindings/include_modules.rs");
+include!("protos/include_protos.rs");

system_api/update_bindings.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+# Copyright 2022 The ChromiumOS Authors
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+STUB_DIR=$(dirname "$0")
+SYSTEM_API_DIR="$HOME/chromiumos/src/platform2/system_api"
+
+if ! [ -e "$SYSTEM_API_DIR" ]; then
+    echo "This script must be run from a ChromeOS checkout and inside cros_sdk."
+fi
+
+# The system_api build.rs will generate bindings in $SYSTEM_API_DIR/src
+(cd "$SYSTEM_API_DIR" && cargo build)
+
+FILES=(
+    "src/bindings/client/org_chromium_userdataauth.rs"
+    "src/bindings/client/org_chromium_vtpm.rs"
+    "src/protos/auth_factor.rs"
+    "src/protos/fido.rs"
+    "src/protos/key.rs"
+    "src/protos/rpc.rs"
+    "src/protos/UserDataAuth.rs"
+    "src/protos/vtpm_interface.rs"
+)
+
+for FILE in "${FILES[@]}"; do
+    TARGET_DIR=$(dirname "$STUB_DIR/$FILE")
+    mkdir -p "$TARGET_DIR"
+    cp "$SYSTEM_API_DIR/$FILE" "$TARGET_DIR"
+done

system_api_stub/README.md

@@ -1,11 +0,0 @@
-# Stub crate for system_api
-
-system_api is used by ChromeOS to interact with other system services.
-
-In ChromeOS builds, the `chromeos` cargo feature is enabled and this crate is replaced with the
-actual [system_api] implementation.
-
-On other platforms, the feature flag will remain disabled and this crate is used to satisfy cargo
-dependencies on system_api.
-
-[system_api]: https://source.chromium.org/chromiumos/chromiumos/codesearch/+/main:src/platform2/system_api/

tools/health-check

@@ -195,12 +195,14 @@ CHECKS: List[Check] = [
             "hypervisor/src/whpx/whpx_sys/*.h",
             "third_party/vmm_vhost/*",
             "net_sys/src/lib.rs",
+            "system_api/src/bindings/*",
         ],
         python_tools=True,
     ),
     Check(
         check_rust_format,
         files=["**.rs"],
+        exclude=["system_api/src/bindings/*"],
         can_fix=True,
     ),
     Check(