diff --git a/boot_control_android.cc b/boot_control_android.cc
index 1fab85f..8ab73be 100644
--- a/boot_control_android.cc
+++ b/boot_control_android.cc
@@ -373,8 +373,8 @@
                            const PartitionMetadata& partition_metadata) {
   for (const auto& group : partition_metadata.groups) {
     for (const auto& partition : group.partitions) {
-      if (!dynamic_control->UnmapPartitionOnDeviceMapper(
-              partition.name + target_suffix, true /* wait */)) {
+      if (!dynamic_control->UnmapPartitionOnDeviceMapper(partition.name +
+                                                         target_suffix)) {
         return false;
       }
     }
diff --git a/boot_control_android_unittest.cc b/boot_control_android_unittest.cc
index 65c2381..94e195f 100644
--- a/boot_control_android_unittest.cc
+++ b/boot_control_android_unittest.cc
@@ -321,12 +321,12 @@
   // slot with each partition in |partitions|.
   void ExpectUnmap(const std::set<string>& partitions) {
     // Error when UnmapPartitionOnDeviceMapper is called on unknown arguments.
-    ON_CALL(dynamicControl(), UnmapPartitionOnDeviceMapper(_, _))
+    ON_CALL(dynamicControl(), UnmapPartitionOnDeviceMapper(_))
         .WillByDefault(Return(false));
 
     for (const auto& partition : partitions) {
-      EXPECT_CALL(dynamicControl(), UnmapPartitionOnDeviceMapper(partition, _))
-          .WillOnce(Invoke([this](auto partition, auto) {
+      EXPECT_CALL(dynamicControl(), UnmapPartitionOnDeviceMapper(partition))
+          .WillOnce(Invoke([this](auto partition) {
             mapped_devices_.erase(partition);
             return true;
           }));
@@ -531,7 +531,7 @@
                {T("system"), 2_GiB},
                {T("vendor"), 1_GiB}});
   // Should not try to unmap any target partition.
-  EXPECT_CALL(dynamicControl(), UnmapPartitionOnDeviceMapper(_, _)).Times(0);
+  EXPECT_CALL(dynamicControl(), UnmapPartitionOnDeviceMapper(_)).Times(0);
   // Should not store metadata to target slot.
   EXPECT_CALL(dynamicControl(),
               StoreMetadata(GetSuperDevice(target()), _, target()))
diff --git a/dynamic_partition_control_android.cc b/dynamic_partition_control_android.cc
index 40c2663..bfdd375 100644
--- a/dynamic_partition_control_android.cc
+++ b/dynamic_partition_control_android.cc
@@ -103,7 +103,7 @@
     // Note that for source partitions, if GetState() == ACTIVE, callers (e.g.
     // BootControlAndroid) should not call MapPartitionOnDeviceMapper, but
     // should directly call GetDmDevicePathByName.
-    if (!UnmapPartitionOnDeviceMapper(target_partition_name, true /* wait */)) {
+    if (!UnmapPartitionOnDeviceMapper(target_partition_name)) {
       LOG(ERROR) << target_partition_name
                  << " is mapped before the update, and it cannot be unmapped.";
       return false;
@@ -127,12 +127,10 @@
 }
 
 bool DynamicPartitionControlAndroid::UnmapPartitionOnDeviceMapper(
-    const std::string& target_partition_name, bool wait) {
+    const std::string& target_partition_name) {
   if (DeviceMapper::Instance().GetState(target_partition_name) !=
       DmDeviceState::INVALID) {
-    if (!DestroyLogicalPartition(
-            target_partition_name,
-            std::chrono::milliseconds(wait ? kMapTimeoutMillis : 0))) {
+    if (!DestroyLogicalPartition(target_partition_name)) {
       LOG(ERROR) << "Cannot unmap " << target_partition_name
                  << " from device mapper.";
       return false;
@@ -150,7 +148,7 @@
   std::set<std::string> mapped = mapped_devices_;
   LOG(INFO) << "Destroying [" << Join(mapped, ", ") << "] from device mapper";
   for (const auto& partition_name : mapped) {
-    ignore_result(UnmapPartitionOnDeviceMapper(partition_name, wait));
+    ignore_result(UnmapPartitionOnDeviceMapper(partition_name));
   }
 }
 
diff --git a/dynamic_partition_control_android.h b/dynamic_partition_control_android.h
index 1233b64..334f9bd 100644
--- a/dynamic_partition_control_android.h
+++ b/dynamic_partition_control_android.h
@@ -36,8 +36,8 @@
                                   uint32_t slot,
                                   bool force_writable,
                                   std::string* path) override;
-  bool UnmapPartitionOnDeviceMapper(const std::string& target_partition_name,
-                                    bool wait) override;
+  bool UnmapPartitionOnDeviceMapper(
+      const std::string& target_partition_name) override;
   void Cleanup() override;
   bool DeviceExists(const std::string& path) override;
   android::dm::DmDeviceState GetState(const std::string& name) override;
diff --git a/dynamic_partition_control_interface.h b/dynamic_partition_control_interface.h
index 86a0730..d4590f7 100644
--- a/dynamic_partition_control_interface.h
+++ b/dynamic_partition_control_interface.h
@@ -57,7 +57,7 @@
   // If |wait| is set, wait until the device is unmapped.
   // Returns true if unmapped successfully.
   virtual bool UnmapPartitionOnDeviceMapper(
-      const std::string& target_partition_name, bool wait) = 0;
+      const std::string& target_partition_name) = 0;
 
   // Do necessary cleanups before destroying the object.
   virtual void Cleanup() = 0;
diff --git a/mock_dynamic_partition_control.h b/mock_dynamic_partition_control.h
index 24aca06..cdfeecc 100644
--- a/mock_dynamic_partition_control.h
+++ b/mock_dynamic_partition_control.h
@@ -33,7 +33,7 @@
                     uint32_t,
                     bool,
                     std::string*));
-  MOCK_METHOD2(UnmapPartitionOnDeviceMapper, bool(const std::string&, bool));
+  MOCK_METHOD1(UnmapPartitionOnDeviceMapper, bool(const std::string&));
   MOCK_METHOD0(Cleanup, void());
   MOCK_METHOD1(DeviceExists, bool(const std::string&));
   MOCK_METHOD1(GetState, ::android::dm::DmDeviceState(const std::string&));