diff --git a/crypto/ext4crypt/Android.mk b/crypto/ext4crypt/Android.mk
old mode 100644
new mode 100755
index 0c6ef5b..c8283dd
--- a/crypto/ext4crypt/Android.mk
+++ b/crypto/ext4crypt/Android.mk
@@ -3,12 +3,18 @@
 include $(CLEAR_VARS)
 
 LOCAL_MODULE := libe4crypt
-LOCAL_MODULE_TAGS := eng optional
+LOCAL_MODULE_TAGS := optional
 LOCAL_CFLAGS :=
 LOCAL_SRC_FILES := Decrypt.cpp ScryptParameters.cpp Utils.cpp HashPassword.cpp ext4_crypt.cpp
 LOCAL_SHARED_LIBRARIES := libselinux libc libc++ libext4_utils libbase libcrypto libcutils libkeymaster_messages libhardware libprotobuf-cpp-lite
 LOCAL_STATIC_LIBRARIES := libscrypt_static
-LOCAL_C_INCLUDES := system/extras/ext4_utils system/extras/ext4_utils/include/ext4_utils external/scrypt/lib/crypto system/security/keystore hardware/libhardware/include/hardware system/security/softkeymaster/include/keymaster system/keymaster/include
+LOCAL_C_INCLUDES := system/extras/ext4_utils \
+    system/extras/ext4_utils/include/ext4_utils \
+    external/scrypt/lib/crypto \
+    system/security/keystore/include \
+    hardware/libhardware/include/hardware \
+    system/security/softkeymaster/include/keymaster \
+    system/keymaster/include
 
 ifneq ($(wildcard hardware/libhardware/include/hardware/keymaster0.h),)
     LOCAL_CFLAGS += -DTW_CRYPTO_HAVE_KEYMASTERX
@@ -17,6 +23,10 @@
 ifeq ($(shell test $(PLATFORM_SDK_VERSION) -ge 26; echo $$?),0)
     #8.0 or higher
     LOCAL_CFLAGS += -DHAVE_GATEKEEPER1
+    ifeq ($(shell test $(PLATFORM_SDK_VERSION) -ge 29; echo $$?),0)
+        LOCAL_SHARED_LIBRARIES += android.hardware.confirmationui@1.0
+        # LOCAL_CFLAGS += -DUSE_
+    endif
     LOCAL_SHARED_LIBRARIES += android.hardware.keymaster@3.0 libkeystore_binder libhidlbase libutils libbinder android.hardware.gatekeeper@1.0
     ifeq ($(shell test $(PLATFORM_SDK_VERSION) -ge 28; echo $$?),0)
         #9.0 rules
diff --git a/crypto/ext4crypt/Decrypt.cpp b/crypto/ext4crypt/Decrypt.cpp
old mode 100644
new mode 100755
index d8542dc..dcd390f
--- a/crypto/ext4crypt/Decrypt.cpp
+++ b/crypto/ext4crypt/Decrypt.cpp
@@ -52,10 +52,12 @@
 #include <sys/types.h>
 #include <fstream>
 
-#include <ext4_utils/ext4_crypt.h>
+#include "ext4_crypt.h"
 
 #ifdef USE_KEYSTORAGE_4
-#include <android/security/IKeystoreService.h>
+#include <android/hardware/confirmationui/1.0/types.h>
+#include <android/security/BnConfirmationPromptCallback.h>
+#include <android/security/keystore/IKeystoreService.h>
 #else
 #include <keystore/IKeystoreService.h>
 #include <keystore/authorization_set.h>
@@ -82,6 +84,10 @@
 
 #include <android-base/file.h>
 
+#ifdef USE_KEYSTORAGE_4
+using android::security::keystore::IKeystoreService;
+#endif
+
 // Store main DE raw ref / policy
 extern std::string de_raw_ref;
 extern std::map<userid_t, std::string> s_de_key_raw_refs;
@@ -551,7 +557,7 @@
 	// First get the keystore service
     sp<IBinder> binder = getKeystoreBinderRetry();
 #ifdef USE_KEYSTORAGE_4
-	sp<security::IKeystoreService> service = interface_cast<security::IKeystoreService>(binder);
+	sp<IKeystoreService> service = interface_cast<IKeystoreService>(binder);
 #else
 	sp<IKeystoreService> service = interface_cast<IKeystoreService>(binder);
 #endif
diff --git a/crypto/ext4crypt/Keymaster.cpp b/crypto/ext4crypt/Keymaster.cpp
index ec80ab5..3c21aa2 100644
--- a/crypto/ext4crypt/Keymaster.cpp
+++ b/crypto/ext4crypt/Keymaster.cpp
@@ -130,14 +130,14 @@
         auto error =
             mDevice->update(mOpHandle, nullptr, &inputBlob, &inputConsumed, nullptr, &outputBlob);
         if (error != KM_ERROR_OK) {
-            LOG(ERROR) << "update failed, code " << error << "\n";
+            LOG(ERROR) << "update failed, code " << error;
             mDevice = nullptr;
             return false;
         }
         output->append(reinterpret_cast<const char*>(outputBlob.data), outputBlob.data_length);
         free(const_cast<uint8_t*>(outputBlob.data));
         if (inputConsumed > toRead) {
-            LOG(ERROR) << "update reported too much input consumed\n";
+            LOG(ERROR) << "update reported too much input consumed";
             mDevice = nullptr;
             return false;
         }
@@ -150,7 +150,7 @@
     auto error = mDevice->finish(mOpHandle, nullptr, nullptr, nullptr, nullptr);
     mDevice = nullptr;
     if (error != KM_ERROR_OK) {
-        LOG(ERROR) << "finish failed, code " << error << "\n";
+        LOG(ERROR) << "finish failed, code " << error;
         return false;
     }
     return true;
@@ -161,7 +161,7 @@
     auto error = mDevice->finish(mOpHandle, nullptr, nullptr, nullptr, &outputBlob);
     mDevice = nullptr;
     if (error != KM_ERROR_OK) {
-        LOG(ERROR) << "finish failed, code " << error << "\n";
+        LOG(ERROR) << "finish failed, code " << error;
         return false;
     }
     output->assign(reinterpret_cast<const char*>(outputBlob.data), outputBlob.data_length);
@@ -174,14 +174,14 @@
     const hw_module_t* module;
     int ret = hw_get_module_by_class(KEYSTORE_HARDWARE_MODULE_ID, NULL, &module);
     if (ret != 0) {
-        LOG(ERROR) << "hw_get_module_by_class returned " << ret << "\n";
+        LOG(ERROR) << "hw_get_module_by_class returned " << ret;
         return;
     }
     if (module->module_api_version == KEYMASTER_MODULE_API_VERSION_1_0) {
         keymaster1_device_t* device;
         ret = keymaster1_open(module, &device);
         if (ret != 0) {
-            LOG(ERROR) << "keymaster1_open returned " << ret << "\n";
+            LOG(ERROR) << "keymaster1_open returned " << ret;
             return;
         }
         mDevice = std::make_shared<Keymaster1Device>(device);
@@ -189,12 +189,12 @@
         keymaster2_device_t* device;
         ret = keymaster2_open(module, &device);
         if (ret != 0) {
-            LOG(ERROR) << "keymaster2_open returned " << ret << "\n";
+            LOG(ERROR) << "keymaster2_open returned " << ret;
             return;
         }
         mDevice = std::make_shared<Keymaster2Device>(device);
     } else {
-        LOG(ERROR) << "module_api_version is " << module->module_api_version << "\n";
+        LOG(ERROR) << "module_api_version is " << module->module_api_version;
         return;
     }
 }
@@ -203,7 +203,7 @@
     keymaster_key_blob_t keyBlob;
     auto error = mDevice->generate_key(&inParams, &keyBlob);
     if (error != KM_ERROR_OK) {
-        LOG(ERROR) << "generate_key failed, code " << error << "\n";
+        LOG(ERROR) << "generate_key failed, code " << error;
         return false;
     }
     key->assign(reinterpret_cast<const char*>(keyBlob.key_material), keyBlob.key_material_size);
@@ -215,7 +215,7 @@
     keymaster_key_blob_t keyBlob{reinterpret_cast<const uint8_t*>(key.data()), key.size()};
     auto error = mDevice->delete_key(&keyBlob);
     if (error != KM_ERROR_OK) {
-        LOG(ERROR) << "delete_key failed, code " << error << "\n";
+        LOG(ERROR) << "delete_key failed, code " << error;
         return false;
     }
     return true;
@@ -229,7 +229,7 @@
     keymaster_key_param_set_t outParams_set;
     auto error = mDevice->begin(purpose, &keyBlob, &inParams, &outParams_set, &mOpHandle);
     if (error != KM_ERROR_OK) {
-        LOG(ERROR) << "begin failed, code " << error << "\n";
+        LOG(ERROR) << "begin failed, code " << error;
         return KeymasterOperation(nullptr, mOpHandle);
     }
     outParams->Clear();
@@ -244,7 +244,7 @@
     keymaster_operation_handle_t mOpHandle;
     auto error = mDevice->begin(purpose, &keyBlob, &inParams, nullptr, &mOpHandle);
     if (error != KM_ERROR_OK) {
-        LOG(ERROR) << "begin failed, code " << error << "\n";
+        LOG(ERROR) << "begin failed, code " << error;
         return KeymasterOperation(nullptr, mOpHandle);
     }
     return KeymasterOperation(mDevice, mOpHandle);
diff --git a/crypto/ext4crypt/Keymaster3.cpp b/crypto/ext4crypt/Keymaster3.cpp
index f8774f2..7862044 100644
--- a/crypto/ext4crypt/Keymaster3.cpp
+++ b/crypto/ext4crypt/Keymaster3.cpp
@@ -56,17 +56,17 @@
         auto inputBlob = blob2hidlVec(reinterpret_cast<const uint8_t*>(&*it), toRead);
         auto error = mDevice->update(mOpHandle, hidl_vec<KeyParameter>(), inputBlob, hidlCB);
         if (!error.isOk()) {
-            LOG(ERROR) << "update failed: " << error.description() << "\n";
+            LOG(ERROR) << "update failed: " << error.description();
             mDevice = nullptr;
             return false;
         }
         if (km_error != ErrorCode::OK) {
-            LOG(ERROR) << "update failed, code " << int32_t(km_error) << "\n";
+            LOG(ERROR) << "update failed, code " << int32_t(km_error);
             mDevice = nullptr;
             return false;
         }
         if (inputConsumed > toRead) {
-            LOG(ERROR) << "update reported too much input consumed\n";
+            LOG(ERROR) << "update reported too much input consumed";
             mDevice = nullptr;
             return false;
         }
@@ -88,11 +88,11 @@
             hidl_vec<uint8_t>(), hidlCb);
     mDevice = nullptr;
     if (!error.isOk()) {
-        LOG(ERROR) << "finish failed: " << error.description() << "\n";
+        LOG(ERROR) << "finish failed: " << error.description();
         return false;
     }
     if (km_error != ErrorCode::OK) {
-        LOG(ERROR) << "finish failed, code " << int32_t(km_error) << "\n";
+        LOG(ERROR) << "finish failed, code " << int32_t(km_error);
         return false;
     }
     return true;
@@ -114,27 +114,27 @@
 
     auto error = mDevice->generateKey(inParams.hidl_data(), hidlCb);
     if (!error.isOk()) {
-        LOG(ERROR) << "generate_key failed: " << error.description() << "\n";
+        LOG(ERROR) << "generate_key failed: " << error.description();
         return false;
     }
     if (km_error != ErrorCode::OK) {
-        LOG(ERROR) << "generate_key failed, code " << int32_t(km_error) << "\n";
+        LOG(ERROR) << "generate_key failed, code " << int32_t(km_error);
         return false;
     }
     return true;
 }*/
 
 bool Keymaster::deleteKey(const std::string& key) {
-	LOG(ERROR) << "NOT deleting key in TWRP\n";
+	LOG(ERROR) << "NOT deleting key in TWRP";
 	return false;
     /*auto keyBlob = blob2hidlVec(key);
     auto error = mDevice->deleteKey(keyBlob);
     if (!error.isOk()) {
-        LOG(ERROR) << "delete_key failed: " << error.description() << "\n";
+        LOG(ERROR) << "delete_key failed: " << error.description();
         return false;
     }
     if (ErrorCode(error) != ErrorCode::OK) {
-        LOG(ERROR) << "delete_key failed, code " << uint32_t(ErrorCode(error)) << "\n";
+        LOG(ERROR) << "delete_key failed, code " << uint32_t(ErrorCode(error));
         return false;
     }
     return true;*/
@@ -153,11 +153,11 @@
     };
     auto error = mDevice->upgradeKey(oldKeyBlob, inParams.hidl_data(), hidlCb);
     if (!error.isOk()) {
-        LOG(ERROR) << "upgrade_key failed: " << error.description() << "\n";
+        LOG(ERROR) << "upgrade_key failed: " << error.description();
         return false;
     }
     if (km_error != ErrorCode::OK) {
-        LOG(ERROR) << "upgrade_key failed, code " << int32_t(km_error) << "\n";
+        LOG(ERROR) << "upgrade_key failed, code " << int32_t(km_error);
         return false;
     }
     return true;
@@ -181,11 +181,11 @@
 
     auto error = mDevice->begin(purpose, keyBlob, inParams.hidl_data(), hidlCb);
     if (!error.isOk()) {
-        LOG(ERROR) << "begin failed: " << error.description() << "\n";
+        LOG(ERROR) << "begin failed: " << error.description();
         return KeymasterOperation(ErrorCode::UNKNOWN_ERROR);
     }
     if (km_error != ErrorCode::OK) {
-        LOG(ERROR) << "begin failed, code " << int32_t(km_error) << "\n";
+        LOG(ERROR) << "begin failed, code " << int32_t(km_error);
         return KeymasterOperation(km_error);
     }
     return KeymasterOperation(mDevice, mOpHandle);
@@ -207,7 +207,7 @@
 int keymaster_compatibility_cryptfs_scrypt() {
     Keymaster dev;
     if (!dev) {
-        LOG(ERROR) << "Failed to initiate keymaster session\n";
+        LOG(ERROR) << "Failed to initiate keymaster session";
         return -1;
     }
     return dev.isSecure();
@@ -224,11 +224,11 @@
     Keymaster dev;
     std::string key;
     if (!dev) {
-        LOG(ERROR) << "Failed to initiate keymaster session\n";
+        LOG(ERROR) << "Failed to initiate keymaster session";
         return -1;
     }
     if (!key_buffer || !key_out_size) {
-        LOG(ERROR) << __FILE__ << ":" << __LINE__ << ":Invalid argument\n";
+        LOG(ERROR) << __FILE__ << ":" << __LINE__ << ":Invalid argument";
         return -1;
     }
     if (key_out_size) {
@@ -276,11 +276,11 @@
 {
     Keymaster dev;
     if (!dev) {
-        LOG(ERROR) << "Failed to initiate keymaster session\n";
+        LOG(ERROR) << "Failed to initiate keymaster session";
         return -1;
     }
     if (!key_blob || !object || !signature_buffer || !signature_buffer_size) {
-        LOG(ERROR) << __FILE__ << ":" << __LINE__ << ":Invalid argument\n";
+        LOG(ERROR) << __FILE__ << ":" << __LINE__ << ":Invalid argument";
         return -1;
     }
 
@@ -303,7 +303,7 @@
             std::string newKey;
             bool ret = dev.upgradeKey(key, paramBuilder, &newKey);
             if(ret == false) {
-                LOG(ERROR) << "Error upgradeKey: \n";
+                LOG(ERROR) << "Error upgradeKey: ";
                 return -1;
             }
 
@@ -312,7 +312,7 @@
             }
 
             if (key_buffer_size < newKey.size()) {
-                LOG(ERROR) << "key buffer size is too small\n";
+                LOG(ERROR) << "key buffer size is too small";
                 return -1;
             }
 
@@ -322,24 +322,24 @@
     }
 
     if (op.errorCode() != ErrorCode::OK) {
-        LOG(ERROR) << "Error starting keymaster signature transaction: " << int32_t(op.errorCode()) << "\n";
+        LOG(ERROR) << "Error starting keymaster signature transaction: " << int32_t(op.errorCode());
         return -1;
     }
 
     if (!op.updateCompletely(input, &output)) {
         LOG(ERROR) << "Error sending data to keymaster signature transaction: "
-                   << uint32_t(op.errorCode()) << "\n";
+                   << uint32_t(op.errorCode());
         return -1;
     }
 
     if (!op.finish(&output)) {
-        LOG(ERROR) << "Error finalizing keymaster signature transaction: " << int32_t(op.errorCode()) << "\n";
+        LOG(ERROR) << "Error finalizing keymaster signature transaction: " << int32_t(op.errorCode());
         return -1;
     }
 
     *signature_buffer = reinterpret_cast<uint8_t*>(malloc(output.size()));
     if (*signature_buffer == nullptr) {
-        LOG(ERROR) << "Error allocation buffer for keymaster signature\n";
+        LOG(ERROR) << "Error allocation buffer for keymaster signature";
         return -1;
     }
     *signature_buffer_size = output.size();
diff --git a/crypto/ext4crypt/ext4_crypt.h b/crypto/ext4crypt/ext4_crypt.h
new file mode 100644
index 0000000..d410ccf
--- /dev/null
+++ b/crypto/ext4crypt/ext4_crypt.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _EXT4_CRYPT_H_
+#define _EXT4_CRYPT_H_
+
+#include <sys/cdefs.h>
+#include <stdbool.h>
+#include <cutils/multiuser.h>
+
+__BEGIN_DECLS
+
+bool e4crypt_is_native();
+
+int e4crypt_policy_ensure(const char *directory, const char *policy,
+                          size_t policy_length,
+                          const char *contents_encryption_mode,
+                          const char *filenames_encryption_mode);
+
+static const char* e4crypt_unencrypted_folder = "/unencrypted";
+static const char* e4crypt_key_ref = "/unencrypted/ref";
+static const char* e4crypt_key_mode = "/unencrypted/mode";
+
+__END_DECLS
+
+#endif // _EXT4_CRYPT_H_
diff --git a/crypto/fde/Android.mk b/crypto/fde/Android.mk
index aafd7a0..fcdd564 100644
--- a/crypto/fde/Android.mk
+++ b/crypto/fde/Android.mk
@@ -3,7 +3,7 @@
 include $(CLEAR_VARS)
 
 LOCAL_MODULE := libcryptfsfde
-LOCAL_MODULE_TAGS := eng optional
+LOCAL_MODULE_TAGS := optional
 LOCAL_SRC_FILES := cryptfs.cpp
 LOCAL_SHARED_LIBRARIES := libcrypto libhardware libcutils libstdc++
 LOCAL_STATIC_LIBRARIES := libscrypttwrp_static
diff --git a/crypto/fde/cryptfs.cpp b/crypto/fde/cryptfs.cpp
index 5b8757c..8352296 100644
--- a/crypto/fde/cryptfs.cpp
+++ b/crypto/fde/cryptfs.cpp
@@ -256,7 +256,7 @@
 
     if (should_use_keymaster()) {
         if (scrypt_keymaster(passwd, salt, newpw, (void*)ftr)) {
-            SLOGE("scrypt failed\n");
+            SLOGE("scrypt failed");
         } else {
             rc = 0;
         }
@@ -293,7 +293,7 @@
         ++crypt_ftr->failed_decrypt_count;
 
         if (ascii_passwd_updated) {
-            SLOGI("Ascii password was updated\n");
+            SLOGI("Ascii password was updated");
         } else {
             /* Code in else part would execute only once:
              * When device is upgraded from L->M release.
@@ -305,14 +305,14 @@
             if (crypt_ftr->crypt_type == CRYPT_TYPE_DEFAULT) {
                 new_passwd = (char*)malloc(strlen(DEFAULT_HEX_PASSWORD) + 1);
                 if (new_passwd == NULL) {
-                    SLOGE("System out of memory. Password verification  incomplete\n");
+                    SLOGE("System out of memory. Password verification  incomplete");
                     goto out;
                 }
                 strlcpy(new_passwd, DEFAULT_HEX_PASSWORD, strlen(DEFAULT_HEX_PASSWORD) + 1);
             } else {
                 new_passwd = (char*)malloc(strlen(passwd) * 2 + 1);
                 if (new_passwd == NULL) {
-                    SLOGE("System out of memory. Password verification  incomplete\n");
+                    SLOGE("System out of memory. Password verification  incomplete");
                     goto out;
                 }
                 convert_key_to_hex_ascii_for_upgrade((const unsigned char*)passwd,
@@ -322,7 +322,7 @@
                                        (char*) crypt_ftr->crypto_type_name);
             if (key_index >=0) {
                 crypt_ftr->failed_decrypt_count = 0;
-                SLOGI("Hex password verified...will try to update with Ascii value\n");
+                SLOGI("Hex password verified...will try to update with Ascii value");
                 /* Before updating password, tie that with keymaster to tie with ROT */
 
                 if (get_keymaster_hw_fde_passwd(passwd, newpw,
@@ -336,9 +336,9 @@
 
                 if (passwd_updated >= 0) {
                     crypt_ftr->flags |= CRYPT_ASCII_PASSWORD_UPDATED;
-                    SLOGI("Ascii password recorded and updated\n");
+                    SLOGI("Ascii password recorded and updated");
                 } else {
-                    SLOGI("Passwd verified, could not update...Will try next time\n");
+                    SLOGI("Passwd verified, could not update...Will try next time");
                 }
             } else {
                 ++crypt_ftr->failed_decrypt_count;
@@ -412,10 +412,10 @@
             // so) because we really should be using a proper deterministic
             // RSA padding function, such as PKCS1.
             memcpy(to_sign + 1, object, min((size_t)RSA_KEY_SIZE_BYTES - 1, object_size));
-            SLOGI("Signing safely-padded object\n");
+            SLOGI("Signing safely-padded object");
             break;
         default:
-            SLOGE("Unknown KDF type %d\n", ftr->kdf_type);
+            SLOGE("Unknown KDF type %d", ftr->kdf_type);
             return -1;
     }
 
@@ -549,7 +549,7 @@
             return -1;
         }
         /*if (put_crypt_ftr_and_key(ftr) != 0) {
-            SLOGE("Failed to write upgraded key to disk\n");
+            SLOGE("Failed to write upgraded key to disk");
         }*/
         SLOGD("Key upgraded successfully\n");
         return 0;
@@ -930,8 +930,8 @@
            crypt_ftr->crypto_type_name, master_key_ascii,
            real_blk_name, extra_params);
 
-  SLOGI("target_type = %s\n", tgt->target_type);
-  SLOGI("real_blk_name = %s, extra_params = %s\n", real_blk_name, extra_params);
+  SLOGI("target_type = %s", tgt->target_type);
+  SLOGI("real_blk_name = %s, extra_params = %s", real_blk_name, extra_params);
 #else
   convert_key_to_hex_ascii(master_key, crypt_ftr->keysize, master_key_ascii);
   strlcpy(tgt->target_type, "crypt", DM_MAX_TYPE_NAME);
@@ -1205,13 +1205,13 @@
                        INTERMEDIATE_BUF_SIZE);
 
     if (rc) {
-        SLOGE("scrypt failed\n");
+        SLOGE("scrypt failed");
         return -1;
     }
 
     if (keymaster_sign_object(ftr, ikey, INTERMEDIATE_BUF_SIZE,
                               &signature, &signature_size)) {
-        SLOGE("Keymaster signing failed\n");
+        SLOGE("Keymaster signing failed");
         return -1;
     }
 
@@ -1220,7 +1220,7 @@
     free(signature);
 
     if (rc) {
-        SLOGE("scrypt failed\n");
+        SLOGE("scrypt failed");
         return -1;
     }
 
@@ -1242,7 +1242,7 @@
   /* Turn the password into an intermediate key and IV that can decrypt the
      master key */
   if (kdf(passwd, salt, ikey, kdf_params)) {
-    SLOGE("kdf failed\n");
+    SLOGE("kdf failed");
     return -1;
   }
 
@@ -1308,7 +1308,7 @@
                                  decrypted_master_key, kdf, kdf_params,
                                  intermediate_key, intermediate_key_size);
     if (ret != 0) {
-        SLOGW("failure decrypting master key\n");
+        SLOGW("failure decrypting master key");
     }
 
     return ret;
@@ -1332,13 +1332,6 @@
 
   int key_index = 0;
   if(is_hw_disk_encryption((char*)crypt_ftr->crypto_type_name)) {
-    if (crypt_ftr->flags & CRYPT_FORCE_COMPLETE) {
-       if (decrypt_master_key(passwd, decrypted_master_key, crypt_ftr, 0, 0)) {
-           printf("Failed to decrypt master key\n");
-           rc = -1;
-           goto errout;
-       }
-    }
     key_index = verify_and_update_hw_fde_passwd(passwd, crypt_ftr);
     if (key_index < 0) {
       rc = -1;
@@ -1349,7 +1342,7 @@
 #ifndef CONFIG_HW_DISK_ENCRYPT_PERF
         if (create_crypto_blk_dev(crypt_ftr, (unsigned char*)&key_index,
                             real_blkdev, crypto_blkdev, label, 0)) {
-          SLOGE("Error creating decrypted block device\n");
+          SLOGE("Error creating decrypted block device");
           rc = -1;
           goto errout;
         }
@@ -1357,7 +1350,7 @@
       } else {
         if (create_crypto_blk_dev(crypt_ftr, decrypted_master_key,
                             real_blkdev, crypto_blkdev, label, 0)) {
-          SLOGE("Error creating decrypted block device\n");
+          SLOGE("Error creating decrypted block device");
           rc = -1;
           goto errout;
         }
@@ -1403,7 +1396,7 @@
   //char real_blkdev[MAXPATHLEN];
   char tmp_mount_point[64];
   unsigned int orig_failed_decrypt_count;
-  int rc = 0;
+  int rc;
   int use_keymaster = 0;
   unsigned char* intermediate_key = 0;
   size_t intermediate_key_size = 0;
@@ -1446,7 +1439,7 @@
   if (rc == 0 && memcmp(scrypted_intermediate_key,
                         crypt_ftr->scrypted_intermediate_key,
                         sizeof(scrypted_intermediate_key)) == 0) {
-    SLOGI("Password matches\n");
+    SLOGI("Password matches");
     rc = 0;
   } else {
     /* Try mounting the file system anyway, just in case the problem's with
@@ -1461,7 +1454,7 @@
       rc = -1;
     } else {
       /* Success! */
-      SLOGI("Password did not match but decrypted drive mounted - continue\n");
+      SLOGI("Password did not match but decrypted drive mounted - continue");
       umount(tmp_mount_point);
       rc = 0;
     }
@@ -1501,7 +1494,7 @@
         const unsigned char* key, int keysize, char* out_crypto_blkdev) {
     int fd = open(real_blkdev, O_RDONLY|O_CLOEXEC);
     if (fd == -1) {
-        SLOGE("Failed to open %s: %s\n", real_blkdev, strerror(errno));
+        SLOGE("Failed to open %s: %s", real_blkdev, strerror(errno));
         return -1;
     }
 
@@ -1510,7 +1503,7 @@
     close(fd);
 
     if (nr_sec == 0) {
-        SLOGE("Failed to get size of %s: %s\n", real_blkdev, strerror(errno));
+        SLOGE("Failed to get size of %s: %s", real_blkdev, strerror(errno));
         return -1;
     }
 
@@ -1542,12 +1535,12 @@
     property_get("ro.crypto.state", encrypted_state, "");
     if ( master_key_saved || strcmp(encrypted_state, "encrypted") ) {
         SLOGE("encrypted fs already validated or not running with encryption,"
-              " aborting\n");
+              " aborting");
         return -1;
     }
 
     if (get_crypt_ftr_and_key(crypt_ftr)) {
-        SLOGE("Error getting crypt footer and key\n");
+        SLOGE("Error getting crypt footer and key");
         return -1;
     }
 
@@ -1558,11 +1551,11 @@
 int cryptfs_check_passwd_hw(const char* passwd)
 {
     struct crypt_mnt_ftr crypt_ftr;
-    int rc = 0;
+    int rc;
     unsigned char master_key[KEY_LEN_BYTES];
     /* get key */
     if (get_crypt_ftr_and_key(&crypt_ftr)) {
-        SLOGE("Error getting crypt footer and key\n");
+        SLOGE("Error getting crypt footer and key");
         return -1;
     }
 
@@ -1576,7 +1569,7 @@
          */
         rc = cryptfs_get_master_key(&crypt_ftr, passwd, master_key);
         if (rc) {
-            SLOGE("password doesn't match\n");
+            SLOGE("password doesn't match");
             return rc;
         }
 
@@ -1584,7 +1577,7 @@
             DATA_MNT_POINT, CRYPTO_BLOCK_DEVICE);
 
         if (rc) {
-            SLOGE("Default password did not match on reboot encryption\n");
+            SLOGE("Default password did not match on reboot encryption");
             return rc;
         }
     } else {
@@ -1600,7 +1593,7 @@
 int cryptfs_check_passwd(const char *passwd)
 {
     /*if (e4crypt_is_native()) {
-        SLOGE("cryptfs_check_passwd not valid for file encryption\n");
+        SLOGE("cryptfs_check_passwd not valid for file encryption");
         return -1;
     }*/
 
@@ -1609,7 +1602,7 @@
 
     rc = check_unmounted_and_get_ftr(&crypt_ftr);
     if (rc) {
-        SLOGE("Could not get footer\n");
+        SLOGE("Could not get footer");
         return rc;
     }
 
@@ -1622,7 +1615,7 @@
                                  DATA_MNT_POINT, CRYPTO_BLOCK_DEVICE);
 
     if (rc) {
-        SLOGE("Password did not match\n");
+        SLOGE("Password did not match");
         return rc;
     }
 
@@ -1635,7 +1628,7 @@
         rc = test_mount_encrypted_fs(&crypt_ftr, DEFAULT_PASSWORD,
                                      DATA_MNT_POINT, CRYPTO_BLOCK_DEVICE);
         if (rc) {
-            SLOGE("Default password did not match on reboot encryption\n");
+            SLOGE("Default password did not match on reboot encryption");
             return rc;
         }
     }
@@ -1652,17 +1645,17 @@
 
     property_get("ro.crypto.state", encrypted_state, "");
     if (strcmp(encrypted_state, "encrypted") ) {
-        SLOGE("device not encrypted, aborting\n");
+        SLOGE("device not encrypted, aborting");
         return -2;
     }
 
     if (!master_key_saved) {
-        SLOGE("encrypted fs not yet mounted, aborting\n");
+        SLOGE("encrypted fs not yet mounted, aborting");
         return -1;
     }
 
     if (!saved_mount_point) {
-        SLOGE("encrypted fs failed to save mount point, aborting\n");
+        SLOGE("encrypted fs failed to save mount point, aborting");
         return -1;
     }
 
@@ -1742,7 +1735,7 @@
                             &intermediate_key_size);
 
     if (rc) {
-        SLOGE("Can't calculate intermediate key\n");
+        SLOGE("Can't calculate intermediate key");
         return rc;
     }
 
@@ -1760,7 +1753,7 @@
     free(intermediate_key);
 
     if (rc) {
-        SLOGE("Can't scrypt intermediate key\n");
+        SLOGE("Can't scrypt intermediate key");
         return rc;
     }
 
diff --git a/crypto/vold_decrypt/Android.mk b/crypto/vold_decrypt/Android.mk
index 860e61f..8d60911 100644
--- a/crypto/vold_decrypt/Android.mk
+++ b/crypto/vold_decrypt/Android.mk
@@ -39,7 +39,7 @@
 
         include $(CLEAR_VARS)
         LOCAL_MODULE := init.recovery.vold_decrypt.rc
-        LOCAL_MODULE_TAGS := eng
+        LOCAL_MODULE_TAGS := optional
         LOCAL_MODULE_CLASS := RECOVERY_EXECUTABLES
 
         # Cannot send to TARGET_RECOVERY_ROOT_OUT since build system wipes init*.rc
@@ -75,7 +75,7 @@
 
         include $(CLEAR_VARS)
         LOCAL_MODULE := libvolddecrypt
-        LOCAL_MODULE_TAGS := eng optional
+        LOCAL_MODULE_TAGS := optional
         LOCAL_CFLAGS := -Wall
         ifeq ($(shell test $(PLATFORM_SDK_VERSION) -lt 23; echo $$?),0)
             LOCAL_C_INCLUDES += external/stlport/stlport bionic bionic/libstdc++/include
@@ -115,7 +115,7 @@
             include $(CLEAR_VARS)
             LOCAL_MODULE := vdc_pie
             LOCAL_SRC_FILES := vdc_pie.cpp
-            LOCAL_MODULE_TAGS := eng
+            LOCAL_MODULE_TAGS := optional
             LOCAL_MODULE_CLASS := RECOVERY_EXECUTABLES
             LOCAL_MODULE_PATH := $(TARGET_RECOVERY_ROOT_OUT)/sbin
             LOCAL_CLANG := true