Successfully created security.fdb

Author: AlexPeshkoff

src/common/classes/alloc.cpp

@@ -2183,6 +2183,8 @@ MemPool::~MemPool(void)
 	}
 
 #ifdef MEM_DEBUG
+	fb_assert(!child);
+
 	if (parent)
 	{
 		MutexLockGuard unlinkGuard(parent->mutex, FB_FUNCTION);

src/jrd/HazardPtr.h

@@ -471,14 +471,14 @@ namespace Jrd {
 	template <class Object, unsigned SUBARRAY_SHIFT = 8>
 	class HazardArray : public Firebird::PermanentStorage
 	{
-	private:
+	public:
 		static const unsigned SUBARRAY_SIZE = 1 << SUBARRAY_SHIFT;
 		static const unsigned SUBARRAY_MASK = SUBARRAY_SIZE - 1;
 
 		typedef std::atomic<Object*> SubArrayElement;
 		typedef std::atomic<SubArrayElement*> ArrayElement;
+		typedef SharedReadVector<ArrayElement, 4> Storage;
 
-	public:
 		explicit HazardArray(MemoryPool& pool)
 			: Firebird::PermanentStorage(pool),
 			  m_objects(getPool())
@@ -533,6 +533,11 @@ namespace Jrd {
 			return m_objects.readAccessor(par)->getCount() << SUBARRAY_SHIFT;
 		}
 
+		static FB_SIZE_T getCount(const HazardPtr<typename Storage::Generation>& v)
+		{
+			return v->getCount() << SUBARRAY_SHIFT;
+		}
+
 		void grow(thread_db* tdbb, FB_SIZE_T reqSize)
 		{
 			fb_assert(reqSize > 0);
@@ -594,9 +599,9 @@ namespace Jrd {
 		template <class DDS>
 		bool load(DDS* par, FB_SIZE_T id, HazardPtr<Object>& val) const
 		{
-			if (id < getCount(par))
+			auto a = m_objects.readAccessor(par);
+			if (id < getCount(a))
 			{
-				auto a = m_objects.readAccessor(par);
 				SubArrayElement* sub = a->value(id >> SUBARRAY_SHIFT).load(std::memory_order_acquire);
 				if (sub)
 				{
@@ -613,11 +618,20 @@ namespace Jrd {
 		HazardPtr<Object> load(DDS* par, FB_SIZE_T id) const
 		{
 			HazardPtr<Object> val;
-			load(par, id, val);
+			if (!load(par, id, val))
+				val.clear();
 			return val;
 		}
 
-		class iterator
+		template <class DDS>
+		HazardPtr<typename Storage::Generation> readAccessor(DDS* par) const
+		{
+			return m_objects.readAccessor(par);
+		}
+
+		class Snapshot;
+
+		class Iterator
 		{
 		public:
 			HazardPtr<Object> operator*()
@@ -630,27 +644,21 @@ namespace Jrd {
 				return get();
 			}
 
-			iterator& operator++()
-			{
-				++index;
-				return *this;
-			}
-
-			iterator& operator--()
+			Iterator& operator++()
 			{
-				--index;
+				index = snap->locateData(index + 1);
 				return *this;
 			}
 
-			bool operator==(const iterator& itr) const
+			bool operator==(const Iterator& itr) const
 			{
-				fb_assert(array == itr.array);
+				fb_assert(snap == itr.snap);
 				return index == itr.index;
 			}
 
-			bool operator!=(const iterator& itr) const
+			bool operator!=(const Iterator& itr) const
 			{
-				fb_assert(array == itr.array);
+				fb_assert(snap == itr.snap);
 				return index != itr.index;
 			}
 
@@ -660,33 +668,90 @@ namespace Jrd {
 
 		public:
 			enum class Location {Begin, End};
-			iterator(const HazardArray* a, Location loc = Location::Begin)
-				: array(a),
+			Iterator(const Snapshot* s, Location loc)
+				: snap(s),
 				  hd(HazardPtr<Object>::getHazardDelayed()),
-				  index(loc == Location::Begin ? 0 : array->getCount(hd))
+				  index(loc == Location::Begin ? snap->locateData(0) :
+				  	snap->data->getCount() << SUBARRAY_SHIFT)
 			{ }
 
 			HazardPtr<Object> get()
 			{
 				HazardPtr<Object> rc(hd);
-				array->load(hd, index, rc);
+				if (!snap->load(index, rc))
+					rc.clear();
 				return rc;
 			}
 
 		private:
-			const HazardArray* array;
+			const Snapshot* snap;
 			HazardDelayedDelete* hd;
 			FB_SIZE_T index;
 		};
 
-		iterator begin() const
+		class Snapshot
 		{
-			return iterator(this);
-		}
+		private:
+			void* operator new(size_t);
+			void* operator new[](size_t);
+
+		public:
+			Snapshot(const HazardArray* array)
+				: hd(HazardPtr<Object>::getHazardDelayed()),
+				  data(array->readAccessor(hd))
+			{ }
+
+			Iterator begin() const
+			{
+				return Iterator(this, Iterator::Location::Begin);
+			}
+
+			Iterator end() const
+			{
+				return Iterator(this, Iterator::Location::End);
+			}
+
+			FB_SIZE_T locateData(FB_SIZE_T index) const
+			{
+				for (FB_SIZE_T i = index >> SUBARRAY_SHIFT; i < data->getCount(); ++i, index = 0)
+				{
+					SubArrayElement* const sub = data->value(i).load(std::memory_order_acquire);
+					if (!sub)
+						continue;
+
+					for (FB_SIZE_T j = index & SUBARRAY_MASK; j < SUBARRAY_SIZE; ++j)
+					{
+						auto p = sub[j].load(std::memory_order_acquire);
+						if (p && p->hasData())
+							return (i << SUBARRAY_SHIFT) + j;
+					}
+				}
+				return data->getCount() << SUBARRAY_SHIFT;
+			}
+
+			bool load(FB_SIZE_T id, HazardPtr<Object>& val) const
+			{
+				if (id < (data->getCount() << SUBARRAY_SHIFT))
+				{
+					SubArrayElement* sub = data->value(id >> SUBARRAY_SHIFT).load(std::memory_order_acquire);
+					if (sub)
+					{
+						val.set(sub[id & SUBARRAY_MASK]);
+						if (val && val->hasData())
+							return true;
+					}
+				}
+
+				return false;
+			}
+
+			HazardDelayedDelete* hd;
+			HazardPtr<typename Storage::Generation> data;
+		};
 
-		iterator end() const
+		Snapshot snapshot() const
 		{
-			return iterator(this, iterator::Location::End);
+			return Snapshot(this);
 		}
 
 	private:

src/jrd/Relation.h

@@ -68,7 +68,7 @@ class Trigger : public HazardObject
 
 	bool hasData() const
 	{
-		return name.hasData();
+		return name.hasData() || sysTrigger;
 	}
 
 	Key getKey() const
@@ -480,8 +480,8 @@ class jrd_rel : public CacheObject
 
 	void fillPagesSnapshot(RelPagesSnapshot&, const bool AttachmentOnly = false);
 
-	bool checkObject(thread_db* tdbb, Firebird::Arg::StatusVector&);
-	void afterUnlock(thread_db* tdbb);
+	bool checkObject(thread_db* tdbb, Firebird::Arg::StatusVector&) override;
+	void afterUnlock(thread_db* tdbb) override;
 
 private:
 	typedef Firebird::SortedArray<

src/jrd/Statement.cpp

@@ -154,6 +154,15 @@ Statement* Statement::makeStatement(thread_db* tdbb, CompilerScratch* csb, bool
 	Database* const dbb = tdbb->getDatabase();
 	fb_assert(dbb);
 
+	MemoryPool* defPool = tdbb->getDefaultPool();
+	for (FB_SIZE_T i = 1; i < dbb->dbb_pools.getCount(); ++i)
+	{
+		if (dbb->dbb_pools[i] == defPool)
+			goto found;
+	}
+	fb_assert(!"wrong pool in makeStatement");
+found:
+
 	Request* const old_request = tdbb->getRequest();
 	tdbb->setRequest(NULL);
 
@@ -349,11 +358,11 @@ Request* Statement::getRequest(thread_db* tdbb, USHORT level)
 
 	requests.grow(level + 1);
 
-	MemoryStats* const parentStats = (flags & FLAG_INTERNAL) ?
-		&dbb->dbb_memory_stats : &attachment->att_memory_stats;
+//	MemoryStats* const parentStats = (flags & FLAG_INTERNAL) ?
+//		&dbb->dbb_memory_stats : &attachment->att_memory_stats;
 
 	// Create the request.
-	Request* const request = FB_NEW_POOL(*pool) Request(attachment, this, parentStats);
+	Request* const request = FB_NEW_POOL(*pool) Request(attachment, this, &dbb->dbb_memory_stats);
 
 	if (level == 0)
 		pool->setStatsGroup(request->req_memory_stats);
@@ -559,17 +568,25 @@ void Statement::release(thread_db* tdbb)
 
 	const auto attachment = tdbb->getAttachment();
 
-	FB_SIZE_T pos;
-	if (attachment->att_statements.find(this, pos))
-		attachment->att_statements.remove(pos);
-	else
-		fb_assert(false);
+	if (attachment)
+	{
+		// !!!!!!!!!!!!!!!!  need to walk all attachments in database
+		// or change att_statements to dbb_statements
+		FB_SIZE_T pos;
+		if (attachment->att_statements.find(this, pos))
+			attachment->att_statements.remove(pos);
+		else
+			fb_assert(false);
+	}
 
 	sqlText = NULL;
 
 	// Sub statement pool is the same of the main statement, so don't delete it.
 	if (!parentStatement)
-		attachment->deletePool(pool);
+	{
+		Database* dbb = tdbb->getDatabase();
+		dbb->deletePool(pool);
+	}
 }
 
 // Returns a formatted textual plan for all RseNode's in the specified request

src/jrd/cmp.cpp

@@ -149,11 +149,11 @@ Statement* CMP_compile(thread_db* tdbb, const UCHAR* blr, ULONG blrLength, bool
 	Statement* statement = nullptr;
 
 	SET_TDBB(tdbb);
-	const auto att = tdbb->getAttachment();
+	const auto dbb = tdbb->getDatabase();
 
 	// 26.09.2002 Nickolay Samofatov: default memory pool will become statement pool
 	// and will be freed by CMP_release
-	const auto newPool = att->createPool();
+	const auto newPool = dbb->createPool();
 
 	try
 	{
@@ -193,7 +193,7 @@ Statement* CMP_compile(thread_db* tdbb, const UCHAR* blr, ULONG blrLength, bool
 		if (statement)
 			statement->release(tdbb);
 		else
-			att->deletePool(newPool);
+			dbb->deletePool(newPool);
 		ERR_punt();
 	}
 

src/jrd/exe.cpp

@@ -566,7 +566,7 @@ void EXE_execute_ddl_triggers(thread_db* tdbb, jrd_tra* transaction, bool preTri
 			TrigVectorPtr triggersPtr = &triggers;
 			unsigned n = 0;
 
-			for (auto t : **cachedTriggers)
+			for (auto t : cachedTriggers->load()->snapshot())
 			{
 				if ((t->type & (1LL << action)) &&
 					((preTriggers && (t->type & 0x1) == 0) || (!preTriggers && (t->type & 0x1) == 0x1)))
@@ -1155,7 +1155,7 @@ void EXE_execute_triggers(thread_db* tdbb,
 
 	try
 	{
-		for (TrigVector::iterator ptr = vector.load()->begin(); ptr != vector.load()->end(); ++ptr)
+		for (auto ptr : vector.load()->snapshot())
 		{
 			ptr->compile(tdbb);
 
@@ -1929,8 +1929,8 @@ void ResourceList::releaseResources(thread_db* tdbb, jrd_tra* transaction)
 					if (transaction)
 						EXT_tra_detach(r.rsc_rel->rel_file, transaction);
 				}
+				r.rsc_state = Resource::State::Locked;
 			}
-			r.rsc_state = Resource::State::Locked;
 
 			if (r.rsc_state == Resource::State::Posted ||
 				r.rsc_state == Resource::State::Registered ||

src/jrd/intl.cpp

@@ -359,23 +359,21 @@ HazardPtr<Collation> CharSetContainer::lookupCollation(thread_db* tdbb, USHORT t
 			}
 		}
 
-		Collation* coll = Collation::createInstance(*dbb->dbb_permanent, tt_id, tt, info.attributes, charset);
-		coll->name = info.collationName;
+		Collation* collation = Collation::createInstance(*dbb->dbb_permanent, tt_id, tt, info.attributes, charset);
+		collation->name = info.collationName;
 
 		// we don't need a lock in the charset
 		if (id != 0)
 		{
-			coll->existenceLock = CharSetContainer::createCollationLock(tdbb, tt_id, coll);
+			collation->existenceLock = CharSetContainer::createCollationLock(tdbb, tt_id, collation);
 
-			fb_assert(coll->useCount == 0);
-			fb_assert(!coll->obsolete);
+			fb_assert(collation->useCount == 0);
+			fb_assert(!collation->obsolete);
 		}
 
-		charset_collations.store(tdbb, id, coll);
-
 		if (id != 0)
 		{
-			LCK_lock(tdbb, coll->existenceLock, LCK_SR, LCK_WAIT);
+			LCK_lock(tdbb, collation->existenceLock, LCK_SR, LCK_WAIT);
 
 			// as we just obtained SR lock for new collation instance
 			// we could safely delete obsolete instance
@@ -385,6 +383,8 @@ HazardPtr<Collation> CharSetContainer::lookupCollation(thread_db* tdbb, USHORT t
 		//
 		// We did not delete "to_delete" when id == 0. Why??????????????????
 		//
+
+		coll = charset_collations.store(tdbb, id, collation);
 	}
 	else
 	{
@@ -447,7 +447,7 @@ static INTL_BOOL lookup_texttype(texttype* tt, const SubtypeInfo* info)
 
 void Jrd::MetadataCache::releaseIntlObjects(thread_db* tdbb)
 {
-	for (auto cs : mdc_charsets)
+	for (auto cs : mdc_charsets.snapshot())
 	{
 		if (cs)
 			cs->release(tdbb);