gc tablet of creating abort when ls offline

src/storage/ls/ob_ls_tablet_service.cpp

@@ -173,6 +173,8 @@ int ObLSTabletService::offline()
     LOG_WARN("not inited", K(ret), K_(is_inited));
   } else if (OB_FAIL(offline_build_tablet_without_memtable_())) {
     LOG_WARN("failed to offline build tablet without memtable", K(ret));
+  } else if (OB_FAIL(offline_gc_tablet_for_create_or_transfer_in_abort_())) {
+    LOG_WARN("failed to offline_gc_tablet_for_create_or_transfer_in_abort", K(ret));
   } else if (OB_FAIL(offline_destroy_memtable_and_mds_table_())) {
     LOG_WARN("failed to offline destroy memtable and mds table", K(ret));
   } else {
@@ -6569,6 +6571,69 @@ int ObLSTabletService::check_tablet_no_active_memtable(const ObIArray<ObTabletID
   return ret;
 }
 
+int ObLSTabletService::offline_gc_tablet_for_create_or_transfer_in_abort_()
+{
+  int ret = OB_SUCCESS;
+  LOG_INFO("start offline_gc_tablet_for_create_or_transfer_in_abort", K(ls_->get_ls_id()));
+  ObTabletIDArray deleted_tablets;
+  ObLSTabletIterator tablet_iter(ObMDSGetTabletMode::READ_WITHOUT_CHECK);
+  bool tablet_status_is_written = false;
+  ObTabletCreateDeleteMdsUserData data;
+  bool is_finish = false;
+  // get deleted_tablets
+  if (OB_FAIL(build_tablet_iter(tablet_iter))) {
+    LOG_WARN("failed to build ls tablet iter", KR(ret), KPC(this));
+  } else {
+    ObTabletHandle tablet_handle;
+    ObTablet *tablet = NULL;
+    while (OB_SUCC(ret)) {
+      if (OB_FAIL(tablet_iter.get_next_tablet(tablet_handle))) {
+        if (OB_ITER_END == ret) {
+          ret = OB_SUCCESS;
+          break;
+        } else {
+          LOG_WARN("failed to get tablet", KR(ret), KPC(this), K(tablet_handle));
+        }
+      } else if (OB_UNLIKELY(!tablet_handle.is_valid())) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_WARN("invalid tablet handle", KR(ret), KPC(this), K(tablet_handle));
+      } else if (OB_ISNULL(tablet = tablet_handle.get_obj())) {
+        ret = OB_ERR_UNEXPECTED;
+        LOG_WARN("tablet is NULL", KR(ret));
+      } else if (tablet->is_ls_inner_tablet()) {
+        // skip ls inner tablet
+      } else if (tablet->is_empty_shell()) {
+        // skip empty shell
+      } else if (OB_FAIL(tablet->check_tablet_status_written(tablet_status_is_written))) {
+        LOG_WARN("failed to check mds written", KR(ret), KPC(tablet));
+      } else if (OB_FAIL(tablet->ObITabletMdsInterface::get_latest_tablet_status(data, is_finish))) {
+        if (OB_EMPTY_RESULT == ret) {
+          ret = OB_SUCCESS;
+          if (tablet_status_is_written) {
+            if (OB_FAIL(deleted_tablets.push_back(tablet->get_tablet_id()))) {
+              LOG_WARN("failed to push_back", KR(ret));
+            } else {
+              LOG_INFO("tablet need be gc", KPC(tablet));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // gc deleted_tablets
+  if (OB_SUCC(ret)) {
+    for (int64_t i = 0; OB_SUCC(ret) && i < deleted_tablets.count(); ++i) {
+      const ObTabletID tablet_id = deleted_tablets.at(i);
+      if (OB_FAIL(inner_remove_tablet(ls_->get_ls_id(), tablet_id))) {
+        LOG_WARN("failed to remove tablet", K(ret), K(tablet_id));
+      } else {
+        LOG_INFO("gc tablet finish", K(ret), K(tablet_id));
+      }
+    }
+  }
+  return ret;
+}
 
 } // namespace storage
 } // namespace oceanbase

src/storage/ls/ob_ls_tablet_service.h

@@ -557,6 +557,7 @@ private:
       ObTabletHandle &handle);
   int delete_all_tablets();
   int offline_build_tablet_without_memtable_();
+  int offline_gc_tablet_for_create_or_transfer_in_abort_();
   int offline_destroy_memtable_and_mds_table_();
 private:
   static int check_real_leader_for_4377_(const ObLSID ls_id);

src/storage/meta_mem/ob_tablet_pointer.cpp

@@ -523,6 +523,11 @@ void ObTabletPointer::set_tablet_status_written()
   mds_table_handler_.set_tablet_status_written();
 }
 
+void ObTabletPointer::reset_tablet_status_written()
+{
+  mds_table_handler_.reset_tablet_status_written();
+}
+
 bool ObTabletPointer::is_tablet_status_written() const
 {
   return mds_table_handler_.is_tablet_status_written();
@@ -537,6 +542,7 @@ int ObTabletPointer::release_memtable_and_mds_table_for_ls_offline(const ObTable
 {
   int ret = OB_SUCCESS;
   mds::MdsTableHandle mds_table;
+  reset_tablet_status_written();
   if (tablet_id.is_ls_inner_tablet()) {
     LOG_INFO("skip inner tablet", K(tablet_id));
   } else if (OB_FAIL(protected_memtable_mgr_handle_.reset())) {

src/storage/meta_mem/ob_tablet_pointer.h

@@ -116,6 +116,7 @@ public:
   // interfaces forward to mds_table_handler_
   void mark_mds_table_deleted();
   void set_tablet_status_written();
+  void reset_tablet_status_written();
   bool is_tablet_status_written() const;
   int try_release_mds_nodes_below(const share::SCN &scn);
   int try_gc_mds_table();

src/storage/multi_data_source/mds_table_handler.h

@@ -42,6 +42,7 @@ public:
   int try_release_nodes_below(const share::SCN &scn);
   void reset() { this->~ObMdsTableHandler(); }
   void set_tablet_status_written() { ATOMIC_CAS(&(is_written_), false, true); }
+  void reset_tablet_status_written() { ATOMIC_STORE(&(is_written_), false); }
   void mark_removed_from_t3m(ObTabletPointer *pointer);
   bool is_tablet_status_written() const { return ATOMIC_LOAD(&(is_written_)); }
   TO_STRING_KV(K_(mds_table_handle));
@@ -68,4 +69,4 @@ private:
 }
 }
 }
-#endif
+#endif