diff --git a/authfs/src/fusefs.rs b/authfs/src/fusefs.rs
index 64b340a..ab75dac 100644
--- a/authfs/src/fusefs.rs
+++ b/authfs/src/fusefs.rs
@@ -669,6 +669,7 @@
         mode: u32,
         _flags: u32,
         umask: u32,
+        _security_ctx: Option<&CStr>,
     ) -> io::Result<(Entry, Option<Self::Handle>, FuseOpenOptions)> {
         let new_inode = self.create_new_entry_with_ref_count(
             parent,
@@ -852,6 +853,7 @@
         name: &CStr,
         mode: u32,
         umask: u32,
+        _security_ctx: Option<&CStr>,
     ) -> io::Result<Entry> {
         let new_inode = self.create_new_entry_with_ref_count(
             parent,
diff --git a/microdroid/payload/Android.bp b/microdroid/payload/Android.bp
index 8225875..4814a64 100644
--- a/microdroid/payload/Android.bp
+++ b/microdroid/payload/Android.bp
@@ -31,7 +31,6 @@
     protos: ["metadata.proto"],
     source_stem: "microdroid_metadata",
     host_supported: true,
-    use_protobuf3: true,
     apex_available: [
         "com.android.virt",
     ],
diff --git a/microdroid_manager/src/vm_secret.rs b/microdroid_manager/src/vm_secret.rs
index df5d318..89c27c9 100644
--- a/microdroid_manager/src/vm_secret.rs
+++ b/microdroid_manager/src/vm_secret.rs
@@ -161,7 +161,7 @@
     _dice_chain: &OwnedDiceArtifacts,
 ) -> Result<()> {
     // Start a new secretkeeper session!
-    let session = SkSession::new(secretkeeper).map_err(anyhow_err)?;
+    let mut session = SkSession::new(secretkeeper).map_err(anyhow_err)?;
     let store_request = StoreSecretRequest {
         id: Id(id),
         secret: Secret(*secret),
@@ -188,7 +188,7 @@
     _dice_chain: &OwnedDiceArtifacts,
 ) -> Result<[u8; SECRET_SIZE]> {
     // Start a new secretkeeper session!
-    let session = SkSession::new(secretkeeper).map_err(anyhow_err)?;
+    let mut session = SkSession::new(secretkeeper).map_err(anyhow_err)?;
     let get_request = GetSecretRequest {
         id: Id(id),
         // TODO(b/291233371): Construct policy out of dice_chain.
