fix backup backup clean source extern file status

src/rootserver/ob_backup_data_clean.cpp

@@ -2625,6 +2625,106 @@ int ObBackupDataClean::mark_backup_set_info_inner_table_deleting(const share::Ob
   return ret;
 }
 
+int ObBackupDataClean::get_source_backup_set_file_info(const uint64_t tenant_id, const int64_t incarnation,
+    const ObBackupSetId &backup_set_id, ObBackupSetFileInfo &backup_set_file_info, bool &is_need_modify)
+{
+  int ret = OB_SUCCESS;
+  int64_t src_copy_id = 0;  // src backup dest copy_id=0
+  bool for_update = false;
+  char backup_dest_str[OB_MAX_BACKUP_DEST_LENGTH] = "";
+  is_need_modify = false;
+  backup_set_file_info.reset();
+  if (!is_inited_) {
+    ret = OB_NOT_INIT;
+    LOG_WARN("backup data clean do not init", K(ret));
+  } else if (OB_FAIL(ObBackupSetFilesOperator::get_tenant_backup_set_file_info(tenant_id,
+                 backup_set_id.backup_set_id_,
+                 incarnation,
+                 src_copy_id,
+                 for_update,
+                 *sql_proxy_,
+                 backup_set_file_info))) {
+    LOG_WARN("failed to get tenant backup set file info", K(ret), K(backup_set_id));
+  } else if (OB_FAIL(GCONF.backup_dest.copy(backup_dest_str, sizeof(backup_dest_str)))) {
+    LOG_WARN("failed to get configure backup dest", K(ret));
+  } else if (0 != strcmp(backup_dest_str, backup_set_file_info.backup_dest_.ptr())) {
+    LOG_INFO("the source backup destination of the backup backup are not equal to the configured backup destination");
+  } else {
+    is_need_modify = true;
+  }
+
+  return ret;
+}
+
+int ObBackupDataClean::get_source_backup_dest_from_piece_file(const common::ObIArray<ObBackupPieceInfoKey> &piece_keys,
+    ObClusterBackupDest &cluster_backup_dest, bool &is_need_modify)
+{
+  int ret = OB_SUCCESS;
+  bool for_update = false;
+  int64_t src_copy_id = 0;
+  char backup_dest_str[OB_MAX_BACKUP_DEST_LENGTH] = "";
+  is_need_modify = false;
+  cluster_backup_dest.reset();
+  if (!is_inited_) {
+    ret = OB_NOT_INIT;
+    LOG_WARN("backup data clean do not init", K(ret));
+  } else if (piece_keys.empty()) {
+    // do nothing
+  } else {
+    ObBackupPieceInfo piece_info;
+    ObBackupDest backup_dest;
+    ObLogArchiveBackupInfoMgr log_archive_info_mgr;
+    const share::ObBackupPieceInfoKey &piece_key = piece_keys.at(0);
+    if (OB_FAIL(log_archive_info_mgr.get_backup_piece(
+            *sql_proxy_, for_update, piece_key.tenant_id_, piece_key.backup_piece_id_, src_copy_id, piece_info))) {
+      LOG_WARN("failed to get piece file info", K(ret), K(piece_key));
+    } else if (OB_FAIL(GCONF.backup_dest.copy(backup_dest_str, sizeof(backup_dest_str)))) {
+      LOG_WARN("failed to get backup dest", K(ret));
+    } else if (0 != strcmp(backup_dest_str, piece_info.backup_dest_.ptr())) {
+      LOG_INFO("backup_dest of backup_set is not current backup dest");
+    } else if (OB_FAIL(backup_dest.set(backup_dest_str))) {
+      LOG_WARN("failed to set backup dest", K(ret));
+    } else if (OB_FAIL(cluster_backup_dest.set(backup_dest, piece_key.incarnation_))) {
+      LOG_WARN("failed to set cluster backup dest", K(ret));
+    } else {
+      is_need_modify = true;
+    }
+  }
+
+  return ret;
+}
+
+// mark the status of the external file at the source destination of the backup backup as deleting
+int ObBackupDataClean::mark_extern_source_backup_set_info_of_backup_backup(const uint64_t tenant_id,
+    const int64_t incarnation, const ObBackupSetFileInfo &backup_set_file_info,
+    const ObArray<ObBackupSetIdPair> &backup_set_id_pairs, const bool is_deleting)
+{
+  int ret = OB_SUCCESS;
+  ObClusterBackupDest src_cluster_backup_dest;
+  ObBackupDest src_backup_dest;
+  ObExternBackupSetFileInfoMgr src_extern_backup_set_file_info_mgr;
+  if (!is_inited_) {
+    ret = OB_NOT_INIT;
+    LOG_WARN("backup data clean do not init", K(ret));
+  } else if (OB_FAIL(src_backup_dest.set(backup_set_file_info.backup_dest_.ptr()))) {
+    LOG_WARN("failed to set backup dest", K(ret));
+  } else if (OB_FAIL(src_cluster_backup_dest.set(src_backup_dest, incarnation))) {
+    LOG_WARN("failed to set cluster backup dest", K(ret), K(src_backup_dest));
+  } else if (OB_FAIL(src_extern_backup_set_file_info_mgr.init(
+                 tenant_id, src_cluster_backup_dest, true /* is_backup_backup */, *backup_lease_service_))) {
+    LOG_WARN("failed to init extern backup set file info", K(ret), K(src_cluster_backup_dest));
+  } else {
+    if (is_deleting &&
+        OB_FAIL(src_extern_backup_set_file_info_mgr.mark_backup_set_file_deleting(backup_set_id_pairs))) {
+      LOG_WARN("failed to mark backup set file deleting", K(ret));
+    } else if (!is_deleting &&
+               OB_FAIL(src_extern_backup_set_file_info_mgr.mark_backup_set_file_deleted(backup_set_id_pairs))) {
+      LOG_WARN("failed to mark backup set file deleted", K(ret));
+    }
+  }
+  return ret;
+}
+
 int ObBackupDataClean::mark_extern_backup_set_info_deleting(const share::ObBackupCleanInfo &clean_info,
     const ObBackupDataCleanElement &clean_element, const common::ObIArray<ObBackupSetId> &backup_set_ids)
 {
@@ -2637,11 +2737,16 @@ int ObBackupDataClean::mark_extern_backup_set_info_deleting(const share::ObBacku
   ObExternBackupSetFileInfoMgr extern_backup_set_file_info_mgr;
   ObClusterBackupDest cluster_backup_dest;
   ObBackupSetIdPair backup_set_id_pair;
+  const bool is_backup_backup = clean_info.copy_id_ > 0 || clean_info.is_delete_obsolete_backup_backup();
+  bool src_backup_dest_unknown = true;
+  bool is_need_modify = false;  // the status of the external file at the source destination of the backup backup
+  ObBackupSetFileInfo backup_set_file_info;
 
   if (!is_inited_) {
     ret = OB_NOT_INIT;
     LOG_WARN("backup data clean do not init", K(ret));
   } else if (backup_set_ids.empty()) {
+    // do nothing
   } else if (OB_FAIL(cluster_backup_dest.set(backup_dest, incarnation))) {
     LOG_WARN("failed to set cluster backup dest", K(ret), K(backup_dest));
   } else {
@@ -2658,6 +2763,15 @@ int ObBackupDataClean::mark_extern_backup_set_info_deleting(const share::ObBacku
           LOG_WARN("failed to push backup set id into array", K(ret), K(backup_set_id_pair));
         }
       }
+
+      if (src_backup_dest_unknown && OB_SUCC(ret) && is_backup_backup) {
+        if (OB_FAIL(get_source_backup_set_file_info(
+                tenant_id, incarnation, backup_set_id, backup_set_file_info, is_need_modify))) {
+          LOG_WARN("failed to get source backup set file info", K(ret), K(backup_set_id));
+        } else {
+          src_backup_dest_unknown = false;
+        }
+      }
     }
 
     if (OB_SUCC(ret)) {
@@ -2668,15 +2782,20 @@ int ObBackupDataClean::mark_extern_backup_set_info_deleting(const share::ObBacku
       }
     }
 
-    if (OB_SUCC(ret)) {
-      const bool is_backup_backup = clean_info.copy_id_ > 0 || clean_info.is_delete_obsolete_backup_backup();
-      if (OB_FAIL(extern_backup_set_file_info_mgr.init(
-              tenant_id, cluster_backup_dest, is_backup_backup, *backup_lease_service_))) {
-        LOG_WARN("failed to init extern backup set file info", K(ret), K(clean_info));
-      } else if (OB_FAIL(extern_backup_set_file_info_mgr.mark_backup_set_file_deleting(backup_set_id_pairs))) {
-        LOG_WARN("failed to mark backup set file deleting", K(ret), K(clean_info));
+    if (OB_SUCC(ret) && is_backup_backup && is_need_modify) {
+      if (OB_FAIL(mark_extern_source_backup_set_info_of_backup_backup(
+              tenant_id, incarnation, backup_set_file_info, backup_set_id_pairs, true /* is_deleting*/))) {
+        LOG_WARN("failed to mark source backup set file info deleting", K(ret), K(clean_info));
       }
     }
+
+    if (OB_FAIL(ret)) {
+    } else if (OB_FAIL(extern_backup_set_file_info_mgr.init(
+                   tenant_id, cluster_backup_dest, is_backup_backup, *backup_lease_service_))) {
+      LOG_WARN("failed to init extern backup set file info", K(ret), K(clean_info));
+    } else if (OB_FAIL(extern_backup_set_file_info_mgr.mark_backup_set_file_deleting(backup_set_id_pairs))) {
+      LOG_WARN("failed to mark backup set file deleting", K(ret), K(clean_info));
+    }
   }
   return ret;
 }
@@ -2809,6 +2928,9 @@ int ObBackupDataClean::mark_extern_log_archive_info_deleting(const share::ObBack
   const int64_t incarnation = clean_element.incarnation_;
   const ObBackupDest &backup_dest = clean_element.backup_dest_;
   ObClusterBackupDest cluster_backup_dest;
+  const bool is_backup_backup = clean_info.copy_id_ > 0 || clean_info.is_delete_obsolete_backup_backup();
+  ObClusterBackupDest src_cluster_backup_dest;
+  bool is_need_modify = false;  // the status of the external file at the source destination of the backup backup
 
   if (!is_inited_) {
     ret = OB_NOT_INIT;
@@ -2823,16 +2945,27 @@ int ObBackupDataClean::mark_extern_log_archive_info_deleting(const share::ObBack
       }
     }
 
-    if (OB_SUCC(ret)) {
-      const bool is_backup_backup = clean_info.copy_id_ > 0 || clean_info.is_delete_obsolete_backup_backup();
-      if (OB_FAIL(log_info_mgr.mark_extern_log_archive_backup_info_deleted(
-              cluster_backup_dest, tenant_id, round_ids, *backup_lease_service_))) {
-        LOG_WARN("failed to mark extern log archive backup info deleted", K(ret), K(cluster_backup_dest));
-      } else if (OB_FAIL(log_info_mgr.mark_extern_backup_piece_deleting(
-                     cluster_backup_dest, tenant_id, backup_piece_keys, is_backup_backup, *backup_lease_service_))) {
-        LOG_WARN("failed to mark extern backup piece deleting", K(ret), K(cluster_backup_dest));
+    if (OB_FAIL(ret)) {
+    } else if (OB_FAIL(log_info_mgr.mark_extern_log_archive_backup_info_deleted(
+                   cluster_backup_dest, tenant_id, round_ids, *backup_lease_service_))) {
+      LOG_WARN("failed to mark extern log archive backup info deleted", K(ret), K(cluster_backup_dest));
+    } else if (is_backup_backup) {
+      if (OB_FAIL(get_source_backup_dest_from_piece_file(backup_piece_keys, src_cluster_backup_dest, is_need_modify))) {
+        LOG_WARN("failed to get source backup piece file info", K(ret));
+      } else if (is_need_modify && OB_FAIL(log_info_mgr.mark_extern_backup_piece_deleting(src_cluster_backup_dest,
+                                       tenant_id,
+                                       backup_piece_keys,
+                                       is_backup_backup,
+                                       *backup_lease_service_))) {
+        LOG_WARN("failed to mark source extern backup piece deleting", K(ret));
       }
     }
+
+    if (OB_SUCC(ret) &&
+        OB_FAIL(log_info_mgr.mark_extern_backup_piece_deleting(
+            cluster_backup_dest, tenant_id, backup_piece_keys, is_backup_backup, *backup_lease_service_))) {
+      LOG_WARN("failed to mark extern backup piece deleting", K(ret), K(cluster_backup_dest));
+    }
   }
   return ret;
 }
@@ -3389,29 +3522,18 @@ int ObBackupDataClean::mark_extern_backup_set_file_info_deleted(const share::ObB
   ObClusterBackupDest current_backup_dest;
   const bool is_backup_backup = clean_info.copy_id_ > 0 || clean_info.is_delete_obsolete_backup_backup();
   ObArray<ObBackupSetIdPair> backup_set_id_pairs;
-  ObClusterBackupDest conf_backup_dest;
-  ObClusterBackupDest conf_backup_backup_dest;
-  const bool is_update_timestamp = clean_element.backup_dest_option_.auto_touch_reserved_backup_;
-  bool can_delete_file = false;
   ObBackupPath path;
-  bool is_all_deleted = false;
   ObBackupSetIdPair backup_set_id_pair;
+  bool src_backup_dest_unknown = true;
+  bool is_need_modify = false;  // the status of the external file at the source destination of the backup backup
+  ObBackupSetFileInfo backup_set_file_info;
 
   if (!is_inited_) {
     ret = OB_NOT_INIT;
     LOG_WARN("backup data clean do not init", K(ret));
   } else if (OB_FAIL(current_backup_dest.set(clean_element.backup_dest_, clean_element.incarnation_))) {
     LOG_WARN("failed to set backup dest", K(ret), K(clean_element));
-  } else if (backup_dest_.is_valid() && OB_FAIL(conf_backup_dest.set(backup_dest_, clean_element.incarnation_))) {
-    LOG_WARN("failed to set backup dest", K(ret), K(clean_element));
-  } else if (is_backup_backup) {
-    if (backup_backup_dest_.is_valid() &&
-        OB_FAIL(conf_backup_backup_dest.set(backup_backup_dest_, clean_element.incarnation_))) {
-      LOG_WARN("failed to set backup dest", K(ret), K(clean_element));
-    }
-  }
-
-  if (OB_SUCC(ret)) {
+  } else {
     for (int64_t i = 0; OB_SUCC(ret) && i < backup_set_ids.count(); ++i) {
       const ObBackupSetId &backup_set_id = backup_set_ids.at(i);
       backup_set_id_pair.reset();
@@ -3425,6 +3547,28 @@ int ObBackupDataClean::mark_extern_backup_set_file_info_deleted(const share::ObB
           LOG_WARN("failed to push backup set id pair into array", K(ret), K(backup_set_id_pair));
         }
       }
+
+      if (src_backup_dest_unknown && OB_SUCC(ret) && is_backup_backup) {
+        if (OB_FAIL(get_source_backup_set_file_info(clean_info.tenant_id_,
+                clean_element.incarnation_,
+                backup_set_id,
+                backup_set_file_info,
+                is_need_modify))) {
+          LOG_WARN("failed to get source backup set file info", K(ret), K(backup_set_id));
+        } else {
+          src_backup_dest_unknown = false;
+        }
+      }
+    }
+  }
+
+  if (OB_SUCC(ret) && is_backup_backup && is_need_modify) {
+    if (OB_FAIL(mark_extern_source_backup_set_info_of_backup_backup(clean_info.tenant_id_,
+            clean_element.incarnation_,
+            backup_set_file_info,
+            backup_set_id_pairs,
+            false /* is_deleting*/))) {
+      LOG_WARN("failed to mark source backup set file info deleted", K(ret), K(clean_info));
     }
   }
 
@@ -3432,34 +3576,8 @@ int ObBackupDataClean::mark_extern_backup_set_file_info_deleted(const share::ObB
   } else if (OB_FAIL(extern_backup_set_file_info_mgr.init(
                  clean_info.tenant_id_, current_backup_dest, is_backup_backup, *backup_lease_service_))) {
     LOG_WARN("failed to init extern backup info mgr", K(ret), K(current_backup_dest), K(clean_info));
-  } else if (OB_FAIL(
-                 extern_backup_set_file_info_mgr.mark_backup_set_file_deleted(backup_set_id_pairs, is_all_deleted))) {
+  } else if (OB_FAIL(extern_backup_set_file_info_mgr.mark_backup_set_file_deleted(backup_set_id_pairs))) {
     LOG_WARN("failed to delete marked backup info", K(ret), K(clean_element));
-  } else if (!is_all_deleted) {
-    can_delete_file = false;
-  } else if (!conf_backup_dest.is_valid()) {
-    can_delete_file = true;
-  } else if (OB_FAIL(
-                 extern_backup_set_file_info_mgr.get_backup_path(conf_backup_dest, false /*is_backup_backup*/, path))) {
-    LOG_WARN("failed to get backup path", K(ret), K(conf_backup_dest));
-  } else if (OB_FAIL(check_can_delete_extern_info_file(
-                 clean_info.tenant_id_, current_backup_dest, is_backup_backup, path, can_delete_file))) {
-    LOG_WARN("failed to check can delete extern info file", K(ret), K(clean_info));
-  }
-
-  if (OB_FAIL(ret)) {
-  } else if (!can_delete_file) {
-    if (!is_update_timestamp) {
-      // do nothing
-    } else if (OB_FAIL(extern_backup_set_file_info_mgr.update_backup_set_file_timestamp())) {
-      LOG_WARN("failed to update backup set file timestamp", K(ret));
-    }
-  } else {
-    if (is_update_timestamp) {
-      // do nothing
-    } else if (OB_FAIL(extern_backup_set_file_info_mgr.delete_backup_set_file())) {
-      LOG_WARN("failed to delete backup set file info", K(ret));
-    }
   }
   return ret;
 }
@@ -3470,64 +3588,33 @@ int ObBackupDataClean::mark_extern_backup_piece_file_info_deleted(const share::O
   int ret = OB_SUCCESS;
   ObLogArchiveBackupInfoMgr log_archive_info_mgr;
   ObClusterBackupDest current_backup_dest;
+  ObClusterBackupDest src_cluster_backup_dest;
   const bool is_backup_backup = clean_info.copy_id_ > 0 || clean_info.is_delete_obsolete_backup_backup();
-  ObClusterBackupDest conf_backup_dest;
-  ObClusterBackupDest conf_backup_backup_dest;
-  const bool is_update_timestamp = clean_element.backup_dest_option_.auto_touch_reserved_backup_;
-  bool is_all_deleted = false;
-  bool can_delete_file = false;
-  ObBackupPath path;
+  bool is_need_modify = false;  // the status of the external file at the source destination of the backup backup
 
   if (!is_inited_) {
     ret = OB_NOT_INIT;
     LOG_WARN("backup data clean do not init", K(ret));
   } else if (OB_FAIL(current_backup_dest.set(clean_element.backup_dest_, clean_element.incarnation_))) {
     LOG_WARN("failed to set backup dest", K(ret), K(clean_element));
-  } else if (backup_dest_.is_valid() && OB_FAIL(conf_backup_dest.set(backup_dest_, clean_element.incarnation_))) {
-    LOG_WARN("failed to set backup dest", K(ret), K(backup_backup_dest_));
   } else if (is_backup_backup) {
-    if (OB_FAIL(backup_backup_dest_.is_valid() &&
-                conf_backup_backup_dest.set(backup_backup_dest_, clean_element.incarnation_))) {
-      LOG_WARN("failed to set backup dest", K(ret), K(backup_backup_dest_));
+    if (OB_FAIL(get_source_backup_dest_from_piece_file(backup_piece_keys, src_cluster_backup_dest, is_need_modify))) {
+      LOG_WARN("failed to get source backup piece file info", K(ret));
+    } else if (is_need_modify && OB_FAIL(log_archive_info_mgr.mark_extern_backup_piece_deleted(src_cluster_backup_dest,
+                                     clean_info.tenant_id_,
+                                     backup_piece_keys,
+                                     is_backup_backup,
+                                     *backup_lease_service_))) {
+      LOG_WARN("failed to mark source extern backup piece deleted", K(ret), K(clean_info), K(src_cluster_backup_dest));
     }
   }
 
-  if (OB_FAIL(ret)) {
-  } else if (OB_FAIL(log_archive_info_mgr.mark_extern_backup_piece_deleted(current_backup_dest,
-                 clean_info.tenant_id_,
-                 backup_piece_keys,
-                 is_backup_backup,
-                 is_all_deleted,
-                 *backup_lease_service_))) {
+  if (OB_SUCC(ret) &&
+      OB_FAIL(log_archive_info_mgr.mark_extern_backup_piece_deleted(
+          current_backup_dest, clean_info.tenant_id_, backup_piece_keys, is_backup_backup, *backup_lease_service_))) {
     LOG_WARN("failed to mark extern backup piece deleted", K(ret), K(clean_info), K(current_backup_dest));
-  } else if (!is_all_deleted) {
-    can_delete_file = false;
-  } else if (!conf_backup_dest.is_valid()) {
-    can_delete_file = true;
-  } else if (OB_FAIL(log_archive_info_mgr.get_external_backup_piece_path(
-                 conf_backup_dest, clean_info.tenant_id_, false /*is_backup_backup*/, path))) {
-    LOG_WARN("failed to get external backup piece path", K(ret), K(conf_backup_dest));
-  } else if (OB_FAIL(check_can_delete_extern_info_file(
-                 clean_info.tenant_id_, current_backup_dest, is_backup_backup, path, can_delete_file))) {
-    LOG_WARN("failed to check can delete extern info file", K(ret), K(clean_info));
   }
 
-  if (OB_FAIL(ret)) {
-  } else if (!can_delete_file) {
-    if (!is_update_timestamp) {
-      // do nothing
-    } else if (OB_FAIL(log_archive_info_mgr.update_extern_backup_piece_file_timestamp(
-                   current_backup_dest, clean_info.tenant_id_, is_backup_backup))) {
-      LOG_WARN("failed to update piece file timestamp", K(ret));
-    }
-  } else {
-    if (is_update_timestamp) {
-      // do nothing
-    } else if (OB_FAIL(log_archive_info_mgr.delete_extern_backup_piece_file(
-                   current_backup_dest, clean_info.tenant_id_, is_backup_backup, *backup_lease_service_))) {
-      LOG_WARN("failed to delete extern backup piece file", K(ret));
-    }
-  }
   return ret;
 }
 

src/rootserver/ob_backup_data_clean.h

@@ -258,6 +258,13 @@ private:
   int get_backup_clean_info(
       const uint64_t tenant_id, common::ObISQLClient &sql_proxy, share::ObBackupCleanInfo &clean_info);
   int get_backup_clean_info(const uint64_t tenant_id, share::ObBackupCleanInfo &clean_info);
+  int get_source_backup_set_file_info(const uint64_t tenant_id, const int64_t incarnation,
+      const ObBackupSetId &backup_set_id, ObBackupSetFileInfo &backup_set_file_info, bool &is_need_modify);
+  int get_source_backup_dest_from_piece_file(const common::ObIArray<ObBackupPieceInfoKey> &piece_keys,
+      ObClusterBackupDest &cluster_backup_dest, bool &is_need_modify);
+  int mark_extern_source_backup_set_info_of_backup_backup(const uint64_t tenant_id, const int64_t incarnation,
+      const ObBackupSetFileInfo &backup_set_file_info, const ObArray<ObBackupSetIdPair> &backup_set_id_pairs,
+      const bool is_deleting);
 
   void cleanup_prepared_infos();
   int check_need_cleanup_prepared_infos(const share::ObBackupCleanInfo &sys_backup_info, bool &need_clean);

src/share/backup/ob_extern_backup_info_mgr.cpp

@@ -3013,10 +3013,9 @@ int ObExternBackupSetFileInfoMgr::mark_backup_set_file_deleting(
 }
 
 int ObExternBackupSetFileInfoMgr::mark_backup_set_file_deleted(
-    const common::ObIArray<share::ObBackupSetIdPair>& backup_set_id_pairs, bool& is_all_deleted)
+    const common::ObIArray<share::ObBackupSetIdPair> &backup_set_id_pairs)
 {
   int ret = OB_SUCCESS;
-  is_all_deleted = false;
 
   if (!is_inited_) {
     ret = OB_NOT_INIT;
@@ -3032,8 +3031,6 @@ int ObExternBackupSetFileInfoMgr::mark_backup_set_file_deleted(
     if (OB_SUCC(ret)) {
       if (OB_FAIL(upload_backup_set_file_info())) {
         LOG_WARN("failed to upload backup set file info", K(ret));
-      } else {
-        is_all_deleted = backup_set_file_infos_.is_all_extern_backup_set_file_infos_deleted();
       }
     }
   }

src/share/backup/ob_extern_backup_info_mgr.h

@@ -435,9 +435,8 @@ public:
   }
   int upload_backup_set_file_info();
   // TODO(muwei.ym) need clean or touch backup set file
-  int mark_backup_set_file_deleting(const common::ObIArray<ObBackupSetIdPair>& backup_set_id_pairs);
-  int mark_backup_set_file_deleted(
-      const common::ObIArray<share::ObBackupSetIdPair>& backup_set_id_pairs, bool& is_all_deleted);
+  int mark_backup_set_file_deleting(const common::ObIArray<ObBackupSetIdPair> &backup_set_id_pairs);
+  int mark_backup_set_file_deleted(const common::ObIArray<share::ObBackupSetIdPair> &backup_set_id_pairs);
   bool is_all_extern_backup_set_file_infos_deleted() const
   {
     return backup_set_file_infos_.is_all_extern_backup_set_file_infos_deleted();

src/share/backup/ob_log_archive_backup_info_mgr.cpp

@@ -3798,13 +3798,12 @@ int ObLogArchiveBackupInfoMgr::mark_extern_backup_piece_deleting(const ObCluster
 
 int ObLogArchiveBackupInfoMgr::mark_extern_backup_piece_deleted(const ObClusterBackupDest &current_backup_dest,
     const uint64_t tenant_id, const common::ObIArray<share::ObBackupPieceInfoKey> &piece_keys,
-    const bool is_backup_backup, bool &is_all_deleted, share::ObIBackupLeaseService &backup_lease_service)
+    const bool is_backup_backup, share::ObIBackupLeaseService &backup_lease_service)
 {
   int ret = OB_SUCCESS;
   ObExternalBackupPieceInfo external_info;
   ObBackupPath path;
   ObBackupFileSpinLock lock;
-  is_all_deleted = false;
 
   if (OB_FAIL(get_external_backup_piece_path_(current_backup_dest, tenant_id, is_backup_backup, path))) {
     LOG_WARN("failed to get cluster clog backup piece path", K(ret), K(current_backup_dest));
@@ -3820,8 +3819,6 @@ int ObLogArchiveBackupInfoMgr::mark_extern_backup_piece_deleted(const ObClusterB
   } else if (OB_FAIL(inner_write_extern_log_archive_backup_piece_info_(
                  path, current_backup_dest.get_storage_info(), external_info, backup_lease_service))) {
     LOG_WARN("failed to write_extern_log_archive_backup_info", K(ret), K(external_info));
-  } else {
-    is_all_deleted = external_info.is_all_piece_info_deleted();
   }
 
   return ret;

src/share/backup/ob_log_archive_backup_info_mgr.h

@@ -222,7 +222,7 @@ public:
       share::ObIBackupLeaseService &backup_lease_service);
   int mark_extern_backup_piece_deleted(const ObClusterBackupDest &current_backup_dest, const uint64_t tenant_id,
       const common::ObIArray<share::ObBackupPieceInfoKey> &piece_keys, const bool is_backup_backup,
-      bool &is_all_deleted, share::ObIBackupLeaseService &backup_lease_service);
+      share::ObIBackupLeaseService &backup_lease_service);
   int get_extern_backup_info_path(
       const ObClusterBackupDest &cluster_backup_dest, const uint64_t tenant_id, share::ObBackupPath &path);
   int get_external_backup_piece_path(const ObClusterBackupDest &cluster_backup_dest, const uint64_t tenant_id,