WIP

Author: AlexPeshkoff

src/jrd/HazardPtr.h

@@ -681,9 +681,10 @@ namespace Jrd {
 	class CacheObject : public HazardObject
 	{
 	public:
-		virtual bool checkObject(thread_db* tdbb, Firebird::Arg::StatusVector&);
+		virtual bool checkObject(thread_db* tdbb, Firebird::Arg::StatusVector&) /*const*/;
 		virtual void afterUnlock(thread_db* tdbb);
-		virtual void lockedExcl [[noreturn]] (thread_db* tdbb);
+		virtual void lockedExcl [[noreturn]] (thread_db* tdbb) /*const*/;
+		virtual const char* c_name() const = 0;
 	};
 
 } // namespace Jrd

src/jrd/Relation.cpp

@@ -43,6 +43,24 @@ using namespace Firebird;
 
 /// jrd_rel
 
+jrd_rel::jrd_rel(MemoryPool& p)
+	: rel_pool(&p), rel_id(0), rel_current_fmt(0),
+	  rel_flags(REL_gc_lockneed), rel_current_format(nullptr),
+	  rel_name(p), rel_owner_name(p), rel_security_name(p),
+	  rel_formats(nullptr), rel_fields(nullptr),
+	  rel_view_rse(nullptr), rel_view_contexts(p),
+	  rel_file(nullptr), rel_gc_records(p),
+	  rel_sweep_count(0), rel_scan_count(0),
+	  rel_partners_lock(nullptr), rel_rescan_lock(nullptr),
+	  rel_gc_lock(nullptr), rel_index_locks(p), rel_index_blocks(nullptr),
+	  rel_pre_erase(nullptr), rel_post_erase(nullptr),
+	  rel_pre_modify(nullptr), rel_post_modify(nullptr),
+	  rel_pre_store(nullptr), rel_post_store(nullptr),
+	  rel_ss_definer(false), rel_pages_inst(nullptr),
+	  rel_pages_base(p), rel_pages_free(nullptr)
+{
+}
+
 bool jrd_rel::isReplicating(thread_db* tdbb)
 {
 	Database* const dbb = tdbb->getDatabase();
@@ -669,3 +687,7 @@ IndexLock::IndexLock(MemoryPool& p, thread_db* tdbb, jrd_rel* rel, USHORT id)
 	  idl_lock(p, tdbb, LCK_idx_exist, (rel->rel_id << 16) | id, rel)
 { }
 
+const char* IndexLock::c_name() const
+{
+	return "* unk *";
+}

src/jrd/Relation.h

@@ -84,7 +84,12 @@ class Trigger : public HazardObject
 	explicit Trigger(MemoryPool& p)
 		: blr(p),
 		  debugInfo(p),
+		  statement(nullptr),
 		  releaseInProgress(false),
+		  sysTrigger(false),
+		  type(0),
+		  flags(0),
+		  relation(nullptr),
 		  name(p),
 		  engine(p),
 		  entryPoint(p),
@@ -315,6 +320,10 @@ struct prim
 	vec<int>* prim_reference_ids;
 	vec<int>* prim_relations;
 	vec<int>* prim_indexes;
+
+	prim()
+		: prim_reference_ids(nullptr), prim_relations(nullptr), prim_indexes(nullptr)
+	{ }
 };
 
 
@@ -325,6 +334,10 @@ struct frgn
 	vec<int>* frgn_reference_ids;
 	vec<int>* frgn_relations;
 	vec<int>* frgn_indexes;
+
+	frgn()
+		: frgn_reference_ids(nullptr), frgn_relations(nullptr), frgn_indexes(nullptr)
+	{ }
 };
 
 
@@ -347,6 +360,7 @@ class IndexLock : public CacheObject
 	ExistenceLock		idl_lock;		// Lock block
 
 	bool hasData() { return true; }
+	const char* c_name() const override;
 };
 
 
@@ -425,7 +439,7 @@ class jrd_rel : public CacheObject
 		return &rel_pages_base;
 	}
 
-	const char* c_name()
+	const char* c_name() const override
 	{
 		return rel_name.c_str();
 	}
@@ -561,14 +575,6 @@ const ULONG REL_gc_lockneed				= 0x80000;	// gc lock should be acquired
 
 /// class jrd_rel
 
-inline jrd_rel::jrd_rel(MemoryPool& p)
-	: rel_pool(&p), rel_flags(REL_gc_lockneed),
-	  rel_name(p), rel_owner_name(p), rel_security_name(p),
-	  rel_view_contexts(p), rel_gc_records(p), rel_index_locks(p),
-	  rel_ss_definer(false), rel_pages_base(p)
-{
-}
-
 inline bool jrd_rel::isSystem() const
 {
 	return rel_flags & REL_system;

src/jrd/Routine.h

@@ -41,7 +41,7 @@ namespace Jrd
 	class Parameter;
 	class UserId;
 
-	class Routine : public Firebird::PermanentStorage, public HazardObject
+	class Routine : public Firebird::PermanentStorage, public CacheObject
 	{
 	protected:
 		explicit Routine(MemoryPool& p)
@@ -102,7 +102,7 @@ namespace Jrd
 
 		const QualifiedName& getName() const { return name; }
 		void setName(const QualifiedName& value) { name = value; }
-		const char* c_name() const { return name.c_str(); }
+		const char* c_name() const override { return name.c_str(); }
 
 		const MetaName& getSecurityName() const { return securityName; }
 		void setSecurityName(const MetaName& value) { securityName = value; }

src/jrd/cmp.cpp

@@ -317,45 +317,6 @@ void CMP_post_access(thread_db* tdbb,
 }
 
 
-/*void CMP_post_resource(	ResourceList* rsc_ptr, void* obj, Resource::rsc_s type, USHORT id)
-{
-/**************************************
- *
- *	C M P _ p o s t _ r e s o u r c e
- *
- **************************************
- *
- * Functional description
- *	Post a resource usage to the compiler scratch block.
- *
- **************************************
-	// Initialize resource block
-	Resource resource(type, id, NULL, NULL, NULL);
-	switch (type)
-	{
-	case Resource::rsc_relation:
-	case Resource::rsc_index:
-		resource.rsc_rel = (jrd_rel*) obj;
-		break;
-	case Resource::rsc_procedure:
-	case Resource::rsc_function:
-		resource.rsc_routine = (Routine*) obj;
-		break;
-	case Resource::rsc_collation:
-		resource.rsc_coll = (Collation*) obj;
-		break;
-	default:
-		BUGCHECK(220);			// msg 220 unknown resource
-		break;
-	}
-
-	// Add it into list if not present already
-	FB_SIZE_T pos;
-	if (!rsc_ptr->find(resource, pos))
-		rsc_ptr->insert(pos, resource);
-}
-*/
-
 void CMP_release(thread_db* tdbb, Request* request)
 {
 /**************************************

src/jrd/dfw.epp

@@ -4562,7 +4562,7 @@ static bool delete_index(thread_db* tdbb, SSHORT phase, DeferredWork* work, jrd_
 	case 0:
 		index = relation->getIndexLock(tdbb, id);
 		if (index)
-			index->idl_lock.releaseLock(tdbb);
+			index->idl_lock.unlock(tdbb);
 		return false;
 
 	case 1:
@@ -4647,33 +4647,30 @@ static bool delete_index(thread_db* tdbb, SSHORT phase, DeferredWork* work, jrd_
 		{
 			// if we are here that means we got exclLock() on step 3
 			fb_assert(index->idl_lock.hasExclLock(tdbb));
-			//if (index->idl_lock.hasExLock(tdbb))
-			{
-				// Release index existence lock and memory.
-				fb_assert(relation->rel_index_locks.load(tdbb, index->idl_id) == index);
 
-				HazardPtr<IndexLock> arrVal = index;
-				if (!relation->rel_index_locks.replace(tdbb, index->idl_id, arrVal, nullptr))
-					ERR_post(Arg::Gds(isc_random) << "Index block gone unexpestedly");
-				fb_assert(!arrVal);
-				index->idl_lock.releaseLock(tdbb);
-				index->delayedDelete(tdbb);
+			// Release index existence lock and memory.
+			fb_assert(relation->rel_index_locks.load(tdbb, index->idl_id) == index);
 
-				// Release index refresh lock and memory.
+			HazardPtr<IndexLock> arrVal = index;
+			if (!relation->rel_index_locks.replace(tdbb, index->idl_id, arrVal, nullptr))
+				ERR_post(Arg::Gds(isc_random) << "Index block gone unexpestedly");
+			fb_assert(!arrVal);
+			index->idl_lock.releaseLock(tdbb, ExistenceLock::ReleaseMethod::DropObject);
+			index->delayedDelete(tdbb);
 
-				for (IndexBlock** iptr = &relation->rel_index_blocks; *iptr; iptr = &(*iptr)->idb_next)
+			// Release index refresh lock and memory.
+			for (IndexBlock** iptr = &relation->rel_index_blocks; *iptr; iptr = &(*iptr)->idb_next)
+			{
+				if ((*iptr)->idb_id == id)
 				{
-					if ((*iptr)->idb_id == id)
-					{
-						IndexBlock* index_block = *iptr;
-						*iptr = index_block->idb_next;
+					IndexBlock* index_block = *iptr;
+					*iptr = index_block->idb_next;
 
-						// Lock was released in IDX_delete_index().
+					// Lock was released in IDX_delete_index().
 
-						delete index_block->idb_lock;
-						delete index_block;
-						break;
-					}
+					delete index_block->idb_lock;
+					delete index_block;
+					break;
 				}
 			}
 		}
@@ -4932,7 +4929,9 @@ static bool delete_relation(thread_db* tdbb, SSHORT phase, DeferredWork* work, j
 		END_FOR
 
 		// Release relation locks
-		relation->rel_existence_lock->releaseLock(tdbb);
+		if (relation->rel_existence_lock) {
+			relation->rel_existence_lock->releaseLock(tdbb, ExistenceLock::ReleaseMethod::DropObject);
+		}
 		if (relation->rel_partners_lock) {
 			LCK_release(tdbb, relation->rel_partners_lock);
 		}

src/jrd/exe.h

@@ -219,9 +219,9 @@ class ResourceList
 
 	void releaseResources(thread_db* tdbb);
 
-	void inc_int_use_count();
-	void zero_int_use_count();
-	void markUndeletable();
+//	void inc_int_use_count();
+//	void zero_int_use_count();
+//	void markUndeletable();
 
 	Resource* get(FB_SIZE_T n)
 	{
@@ -233,6 +233,9 @@ class ResourceList
 		FB_SIZE_T pos;
 		Resource temp(type);
 		list.find(temp, pos);
+
+		if (pos == list.getCount())
+			return list.end();
 		return &list[pos];
 	}
 

src/jrd/idx.cpp

@@ -651,7 +651,7 @@ void IDX_delete_indices(thread_db* tdbb, jrd_rel* relation, RelationPages* relPa
 		{
 			HazardPtr<IndexLock> idx_lock = relation->getIndexLock(tdbb, i);
 			if (idx_lock)
-				idx_lock->idl_lock.releaseLock(tdbb);
+				idx_lock->idl_lock.releaseLock(tdbb, ExistenceLock::ReleaseMethod::Normal);
 		}
 	}
 

src/jrd/lck.cpp

@@ -1678,7 +1678,7 @@ bool ExistenceLock::exclLock(thread_db* tdbb)
 	return true;
 }
 
-SSHORT getLockWait(thread_db* tdbb)
+SSHORT ExistenceLock::getLockWait(thread_db* tdbb)
 {
 	jrd_tra* transaction = tdbb->getTransaction();
 	return transaction ? transaction->getLockWait() : 0;
@@ -1718,3 +1718,56 @@ void ExistenceLock::unlock(thread_db* tdbb)
 		flags &= ~(blocking | unlocking | locked);
 	}
 }
+
+void ExistenceLock::incrementError [[noreturn]] ()
+{
+	const char* objTypeName = "unknown object";
+	switch(lck->lck_type)
+	{
+	case LCK_rel_exist:
+		objTypeName = "relation";
+		break;
+	case LCK_idx_exist:
+		objTypeName = "index";
+		break;
+	case LCK_prc_exist:
+		objTypeName = "procedure";
+		break;
+	case LCK_tt_exist:
+		objTypeName = "collation";
+		break;
+	case LCK_fun_exist:
+		objTypeName = "function";
+		break;
+	default:
+		fb_assert(false);
+		break;
+	}
+
+	fatal_exception::raiseFmt("Can not use %s %s which is going to be dropped in regular request",
+		objTypeName, object->c_name());
+}
+
+void ExistenceLock::releaseLock(thread_db* tdbb, ReleaseMethod rm)
+{
+	Firebird::MutexLockGuard g(mutex, FB_FUNCTION);
+	switch (rm)
+	{
+	case ReleaseMethod::Normal:
+		if ((flags |= blocking) & locked)
+			leave245(tdbb);
+		else if (hasExclLock(tdbb))
+			unlock(tdbb);
+		else
+			fb_assert(false);
+		break;
+
+	case ReleaseMethod::DropObject:
+		fb_assert(hasExclLock(tdbb));
+		// fall through
+
+	case ReleaseMethod::CloseCache:
+		LCK_release(tdbb, lck);
+		break;
+	}
+}

src/jrd/lck.h

@@ -207,6 +207,8 @@ class ExistenceLock
 		lck->setKey(key);
 	}
 
+	enum class ReleaseMethod {Normal, DropObject, CloseCache};
+
 	Resource::State inc(thread_db* tdbb)
 	{
 		unsigned fl = ++flags;
@@ -247,7 +249,7 @@ class ExistenceLock
 #endif
 	void unlock(thread_db* tdbb);							// Release exclusive lock
 
-	void releaseLock(thread_db* tdbb);						// Release all locks
+	void releaseLock(thread_db* tdbb, ReleaseMethod rm);	// Release any lock
 
 private:
 	static int ast(void* self)