Fixed a number of issues with drop GTT

Author: AlexPeshkoff

src/dsql/DdlNodes.epp

@@ -11401,13 +11401,6 @@ void DropRelationNode::execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch
 		if (dbb->dbb_garbage_collector)
 			dbb->dbb_garbage_collector->removeRelation(rel->getId());
 
-		if (relation->isTemporary())
-		{
-			// release pages, allocated for current GTT instance
-			AutoSetRestoreFlag<ULONG> tmpSpace(&tdbb->tdbb_flags, TDBB_use_db_page_space, false);
-			relation->delPages(tdbb);
-		}
-
 		RelationPages* const relPages = relation->getBasePages();
 		if (relPages->rel_pages)
 			DPM_mark_relation(tdbb, relation);

src/jrd/Attachment.cpp

@@ -410,9 +410,6 @@ void Jrd::Attachment::resetSession(thread_db* tdbb, jrd_tra** traHandle)
 		bool err = false;
 		for (const jrd_tra* tra = att_transactions; tra; tra = tra->tra_next)
 		{
-			if (tra == att_meta_transaction)
-				continue;
-
 			n++;
 			if (tra != oldTran && !(tra->tra_flags & TRA_prepared))
 				err = true;
@@ -977,6 +974,9 @@ void Attachment::createMetaTransaction(thread_db* tdbb)
 			LCK_release(tdbb, att_meta_transaction->tra_lock);
 			att_meta_transaction->tra_lock = nullptr;
 		}
+
+		att_meta_transaction->unlinkFromAttachment();
+		att_meta_transaction->tra_flags |= TRA_meta;
 	}
 }
 

src/jrd/Database.cpp

@@ -824,7 +824,8 @@ namespace Jrd
 		dbb_compatibility_index(~0U),
 		dbb_dic(*p),
 		dbb_mdc(FB_NEW_POOL(*p) MetadataCache(*p)),
-		dbb_user_ids(*p)
+		dbb_user_ids(*p),
+		dbb_del_pages(*p)
 	{
 		dbb_pools.add(p);
 
@@ -895,5 +896,57 @@ namespace Jrd
 		return result;
 	}
 
+	void Database::markForDelete(RelationPermanent* relation)
+	{
+		MutexLockGuard g(dbb_del_pages_mutex, FB_FUNCTION);
+
+#ifdef DEV_BUILD
+		FB_SIZE_T dummy;
+		bool rc = dbb_del_pages.findEx([relation](const DelPagesMarker& item)->int
+			{
+				return std::greater{}(item.relation, relation);
+			},
+		dummy);
+		fb_assert(!rc);
+#endif
+
+		dbb_del_pages.add({dbb_next_transaction, relation});
+	}
+
+	void Database::clearDeleteMark(RelationPermanent* relation)
+	{
+		MutexLockGuard g(dbb_del_pages_mutex, FB_FUNCTION);
+
+		FB_SIZE_T pos;
+		bool found = dbb_del_pages.findEx([relation](const DelPagesMarker& item)->int
+			{
+				return std::greater{}(item.relation, relation);
+			},
+		pos);
+		fb_assert(found);
+
+		if (found)
+			dbb_del_pages.remove(pos);
+	}
+
+	void Database::deleteTempPages(thread_db* tdbb, TraNumber oldestActive)
+	{
+		// check for data presence is safe even w/o mutex locked
+		// normally there is no data in array
+		if (!dbb_del_pages.hasData())
+			return;
+
+		MutexLockGuard g(dbb_del_pages_mutex, FB_FUNCTION);
+		while (dbb_del_pages.hasData() && dbb_del_pages[0].tran < oldestActive)
+		{
+			auto* relation = dbb_del_pages[0].relation;
+			dbb_del_pages.remove(0u);
+
+			MutexUnlockGuard checkout(dbb_del_pages_mutex, FB_FUNCTION);
+			printf("deleteTempPages for relation %s\n", relation->getName().toQuotedString().c_str());
+			relation->freePages(tdbb);
+		}
+	}
+
 
 } // namespace

src/jrd/Database.h

@@ -96,6 +96,7 @@ class CryptoManager;
 class KeywordsMap;
 class MetadataCache;
 class ExtEngineManager;
+class RelationPermanent;
 
 // Flags to indicate normal internal requests vs. dyn internal requests
 // IRQ_REQUESTS & DYN_REQUESTS are depecated
@@ -292,6 +293,17 @@ class Database : public pool_alloc<type_dbb>
 		bool active;
 	};
 
+	struct DelPagesMarker
+	{
+		TraNumber			tran;
+		RelationPermanent*	relation;
+
+		static TraNumber generate(const DelPagesMarker& item)
+		{
+			return item.tran;
+		}
+	};
+
 	static Database* create(Firebird::IPluginConfig* pConf, bool shared)
 	{
 		Firebird::MemoryStats temp_stats;
@@ -459,6 +471,10 @@ class Database : public pool_alloc<type_dbb>
 	Firebird::GenericMap<Firebird::Pair<Firebird::Left<
 		Firebird::MetaString, UserId*> > > dbb_user_ids;	// set of used UserIds
 
+	Firebird::SortedArray<DelPagesMarker, Firebird::EmptyStorage<DelPagesMarker>,
+		TraNumber, DelPagesMarker> dbb_del_pages;
+	Firebird::Mutex  dbb_del_pages_mutex;
+
 public:
 	// returns true if primary file is located on raw device
 	bool onRawDevice() const;
@@ -469,6 +485,11 @@ class Database : public pool_alloc<type_dbb>
 	// returns the minimum IO block size
 	ULONG getIOBlockSize() const;
 
+	// control temporary pages cleanup
+	void markForDelete(RelationPermanent* relation);
+	void clearDeleteMark(RelationPermanent* relation);
+	void deleteTempPages(thread_db* tdbb, TraNumber oldestActive);
+
 #ifdef DEV_BUILD
 	// returns true if main lock is in exclusive state
 	bool locked() const

src/jrd/Relation.cpp

@@ -293,7 +293,7 @@ RelationPages* RelationPermanent::getPagesInternal(thread_db* tdbb, TraNumber tr
 	else
 		inst_id = PAG_attachment_id(tdbb);
 
-	MutexLockGuard relPerm(rel_pages_mutex, FB_FUNCTION);
+	MutexLockGuard g(rel_pages_mutex, FB_FUNCTION);
 
 	if (!rel_pages_inst)
 		rel_pages_inst = FB_NEW_POOL(getPool()) RelationPagesInstances(getPool());
@@ -409,31 +409,59 @@ bool RelationPermanent::delPages(thread_db* tdbb, TraNumber tran, RelationPages*
 		pages);
 #endif
 
-	FB_SIZE_T pos;
+	{ // mutex scope
+		MutexLockGuard g(rel_pages_mutex, FB_FUNCTION);
+
+		FB_SIZE_T pos;
 #ifdef DEV_BUILD
-	const bool found =
+		const bool found =
 #endif
-		rel_pages_inst->find(pages->rel_instance_id, pos);
-	fb_assert(found && ((*rel_pages_inst)[pos] == pages) );
+			rel_pages_inst->find(pages->rel_instance_id, pos);
+		fb_assert(found && ((*rel_pages_inst)[pos] == pages) );
 
-	rel_pages_inst->remove(pos);
+		rel_pages_inst->remove(pos);
+	}
 
 	if (pages->rel_index_root)
 		IDX_delete_indices(tdbb, this, pages, false);
 
 	if (pages->rel_pages)
 		DPM_delete_relation_pages(tdbb, this, pages);
 
+	MutexLockGuard g(rel_pages_mutex, FB_FUNCTION);
+
 	pages->free(rel_pages_free);
 	return true;
 }
 
+void RelationPermanent::freePages(thread_db* tdbb)
+{
+	if (!rel_pages_inst)
+		return;
+
+	// no need in rel_pages_mutex - it's cleanup after DROP TABLE
+	while (rel_pages_inst->hasData())
+	{
+		auto* pages = rel_pages_inst->pop();
+
+		if (pages->rel_index_root)
+			IDX_delete_indices(tdbb, this, pages, false);
+
+		if (pages->rel_pages)
+			DPM_delete_relation_pages(tdbb, this, pages);
+
+		pages->free(rel_pages_free);
+	}
+}
+
 void RelationPermanent::retainPages(thread_db* tdbb, TraNumber oldNumber, TraNumber newNumber)
 {
 	fb_assert(rel_flags & REL_temp_tran);
 	fb_assert(oldNumber != 0);
 	fb_assert(newNumber != 0);
 
+	MutexLockGuard g(rel_pages_mutex, FB_FUNCTION);
+
 	if (!rel_pages_inst)
 		return;
 
@@ -450,6 +478,24 @@ void RelationPermanent::retainPages(thread_db* tdbb, TraNumber oldNumber, TraNum
 	rel_pages_inst->add(pages);
 }
 
+void RelationPermanent::dropTempPages(thread_db* tdbb)
+{
+	if (rel_flags & REL_temp_gtt)
+	{
+		Database* dbb = tdbb->getDatabase();
+		dbb->markForDelete(this);
+	}
+}
+
+void RelationPermanent::clearDropMarker(thread_db* tdbb)
+{
+	if (rel_flags & REL_temp_gtt)
+	{
+		Database* dbb = tdbb->getDatabase();
+		dbb->clearDeleteMark(this);
+	}
+}
+
 void RelationPermanent::getRelLockKey(thread_db* tdbb, UCHAR* key)
 {
 	const ULONG val = getId();
@@ -474,6 +520,8 @@ void RelationPermanent::cleanUp() noexcept
 
 void RelationPermanent::fillPagesSnapshot(RelPagesSnapshot& snapshot, const bool attachmentOnly)
 {
+	MutexLockGuard g(rel_pages_mutex, FB_FUNCTION);
+
 	if (rel_pages_inst)
 	{
 		for (FB_SIZE_T i = 0; i < rel_pages_inst->getCount(); i++)

src/jrd/Relation.h

@@ -898,6 +898,7 @@ class RelationPermanent : public Firebird::PermanentStorage
 
 	RelationPages* getPages(thread_db* tdbb, TraNumber tran = MAX_TRA_NUMBER, bool allocPages = true);
 	bool	delPages(thread_db* tdbb, TraNumber tran = MAX_TRA_NUMBER, RelationPages* aPages = NULL);
+	void	freePages(thread_db* tdbb);
 	void	retainPages(thread_db* tdbb, TraNumber oldNumber, TraNumber newNumber);
 	void	cleanUp() noexcept;
 	void	fillPagesSnapshot(RelPagesSnapshot&, const bool AttachmentOnly = false);
@@ -960,6 +961,10 @@ class RelationPermanent : public Firebird::PermanentStorage
 	// Relation must be updated on next use or commit
 	static Cached::Relation* newVersion(thread_db* tdbb, const QualifiedName& name);
 
+	// Relation is in process of remove - mark it with current transaction
+	void dropTempPages(thread_db* tdbb);
+	void clearDropMarker(thread_db* tdbb);
+
 	// Lists of FK partners should be updated on next update
 	void checkPartners(thread_db* tdbb);
 
@@ -996,7 +1001,7 @@ class RelationPermanent : public Firebird::PermanentStorage
 	ForeignRefs*	rel_foreign_refs = nullptr;		// foreign references to other relations' primary keys
 
 private:
-	Firebird::Mutex			rel_pages_mutex;
+	Firebird::Mutex	rel_pages_mutex;	// protects rel_pages_inst and rel_pages_free
 
 	typedef Firebird::SortedArray<
 				RelationPages*,

src/jrd/dfw.epp

@@ -3606,6 +3606,7 @@ static bool delete_relation(thread_db* tdbb, SSHORT phase, DeferredWork* work, j
 			auto* relation = MetadataCache::getPerm<Cached::Relation>(tdbb, work->dfw_id, CacheFlag::ERASED);
 			if (relation)
 			{
+				relation->clearDropMarker(tdbb);
 				if (relation->isDropped())
 					relation->rollback(tdbb);
 			}
@@ -3652,16 +3653,29 @@ static bool delete_relation(thread_db* tdbb, SSHORT phase, DeferredWork* work, j
 
 	case 2:
 	case 3:
+		return true;
+
 	case 4:
+		{
+			auto* relation = MetadataCache::getPerm<Cached::Relation>(tdbb, work->dfw_id, CacheFlag::ERASED);
+			if (!relation)
+				return false;
+
+			relation->dropTempPages(tdbb);
+		}
+		return true;
+
 	case 5:
 	case 6:
 		return true;
 
 	case 7:
 		{
 			auto* relation = MetadataCache::getPerm<Cached::Relation>(tdbb, work->dfw_id, CacheFlag::ERASED);
-			if (relation)
-				relation->commit(tdbb);
+			if (!relation)
+				return false;
+
+			relation->commit(tdbb);
 		}
 		break;
 	}

src/jrd/jrd.cpp

@@ -8352,7 +8352,6 @@ void Attachment::purgeTransactions(thread_db* tdbb, const bool force_flag)
  *
  **************************************/
 	jrd_tra* const trans_dbk = att_dbkey_trans;
-	auto* const trans_meta = att_meta_transaction;
 
 	if (force_flag)
 	{
@@ -8366,7 +8365,7 @@ void Attachment::purgeTransactions(thread_db* tdbb, const bool force_flag)
 	for (jrd_tra* transaction = att_transactions; transaction; transaction = next)
 	{
 		next = transaction->tra_next;
-		if (transaction != trans_dbk && transaction != trans_meta)
+		if (transaction != trans_dbk)
 		{
 			if (transaction->tra_flags & TRA_prepared)
 			{

src/jrd/tra.cpp

@@ -2391,6 +2391,9 @@ static int limbo_transaction(thread_db* tdbb, TraNumber id)
 
 void jrd_tra::unlinkFromAttachment()
 {
+	if (tra_flags & TRA_meta)
+		return;						// Unlinked on creation
+
 	for (jrd_tra** ptr = &tra_attachment->att_transactions; *ptr; ptr = &(*ptr)->tra_next)
 	{
 		if (*ptr == this)
@@ -3771,9 +3774,11 @@ static void transaction_start(thread_db* tdbb, jrd_tra* trans)
 			dbb->dbb_oldest_transaction, dbb->dbb_oldest_snapshot);
 
 		// Plumb remove really old objects from metadata cache
-
 		dbb->dbb_mdc->checkCleanup(tdbb, oldest);
 
+		// Also remove really old temporary pages of dropped relations
+		dbb->deleteTempPages(tdbb, trans->tra_oldest_active);
+
 		// If the transaction block is getting out of hand, force a sweep
 
 		if (dbb->dbb_sweep_interval &&

src/jrd/tra.h

@@ -449,6 +449,7 @@ inline constexpr ULONG TRA_replicating			= 0x100000L;	// transaction is allowed
 inline constexpr ULONG TRA_no_blob_check		= 0x200000L;	// disable blob access checking
 inline constexpr ULONG TRA_auto_release_temp_blobid = 0x400000L;// remove temp ids of materialized user blobs from tra_blobs
 inline constexpr ULONG TRA_deps_to_disk			= 0x800000L;	// store dependencies to RDB$DEPENDENCIES
+inline constexpr ULONG TRA_meta					= 0x1000000L;	// transaction is used to load metadata
 
 // flags derived from TPB, see also transaction_options() at tra.cpp
 inline constexpr ULONG TRA_OPTIONS_MASK = (TRA_degree3 | TRA_readonly | TRA_ignore_limbo | TRA_read_committed |