Avoid races in mapping clear delivery init/fini under high load

(cherry picked from commit ed126e2)

Author: AlexPeshkoff

src/jrd/Mapping.cpp

@@ -612,14 +612,17 @@ class MappingIpc FB_FINAL : public Firebird::IpcObject
 
 	void shutdown()
 	{
+		if (!sharedMemory)
+			return;
+		MutexLockGuard gLocal(initMutex, FB_FUNCTION);
 		if (!sharedMemory)
 			return;
 
 		{
 			Guard gShared(this);
-			MappingHeader* sMem = sharedMemory->getHeader();
 
-			startupSemaphore.tryEnter(5);
+			MappingHeader* sMem = sharedMemory->getHeader();
+			fb_assert(sMem->process[process].id);
 			sMem->process[process].flags &= ~MappingHeader::FLAG_ACTIVE;
 			(void)  // Ignore errors in cleanup
 				sharedMemory->eventPost(&sMem->process[process].notifyEvent);
@@ -723,32 +726,37 @@ class MappingIpc FB_FINAL : public Firebird::IpcObject
 		if (sharedMemory)
 			return;
 
-		Arg::StatusVector statusVector;
+		AutoSharedMemory tempSharedMemory;
 		try
 		{
-			sharedMemory.reset(FB_NEW_POOL(*getDefaultMemoryPool())
+			tempSharedMemory.reset(FB_NEW_POOL(*getDefaultMemoryPool())
 				SharedMemory<MappingHeader>("fb_user_mapping", DEFAULT_SIZE, this));
 		}
 		catch (const Exception& ex)
 		{
-			iscLogException("MappingIpc: Cannot initialize the shared memory region", ex);
+			StaticStatusVector s;
+			ex.stuffException(s);
+			if (!fb_utils::containsErrorCode(s.begin(), isc_instance_conflict))
+				iscLogException("MappingIpc: Cannot initialize the shared memory region", ex);
 			throw;
 		}
-		fb_assert(sharedMemory->getHeader()->mhb_header_version == MemoryHeader::HEADER_VERSION);
-		fb_assert(sharedMemory->getHeader()->mhb_version == MAPPING_VERSION);
+		fb_assert(tempSharedMemory->getHeader()->mhb_header_version == MemoryHeader::HEADER_VERSION);
+		fb_assert(tempSharedMemory->getHeader()->mhb_version == MAPPING_VERSION);
 
-		Guard gShared(this);
+		Guard gShared(tempSharedMemory);
 
-		MappingHeader* sMem = sharedMemory->getHeader();
+		MappingHeader* sMem = tempSharedMemory->getHeader();
 
 		for (process = 0; process < sMem->processes; ++process)
 		{
 			if (!(sMem->process[process].flags & MappingHeader::FLAG_ACTIVE))
 				break;
+
 			if (!ISC_check_process_existence(sMem->process[process].id))
 			{
-				sharedMemory->eventFini(&sMem->process[process].notifyEvent);
-				sharedMemory->eventFini(&sMem->process[process].callbackEvent);
+				tempSharedMemory->eventFini(&sMem->process[process].notifyEvent);
+				tempSharedMemory->eventFini(&sMem->process[process].callbackEvent);
+
 				break;
 			}
 		}
@@ -765,6 +773,8 @@ class MappingIpc FB_FINAL : public Firebird::IpcObject
 
 		sMem->process[process].id = processId;
 		sMem->process[process].flags = MappingHeader::FLAG_ACTIVE;
+		sharedMemory.reset(tempSharedMemory.release());
+
 		if (sharedMemory->eventInit(&sMem->process[process].notifyEvent) != FB_SUCCESS)
 		{
 			(Arg::Gds(isc_random) << "Error initializing notifyEvent in mapping shared memory").raise();
@@ -783,6 +793,7 @@ class MappingIpc FB_FINAL : public Firebird::IpcObject
 			sMem->process[process].flags &= ~MappingHeader::FLAG_ACTIVE;
 			throw;
 		}
+		startupSemaphore.enter();
 	}
 
 	void exceptionHandler(const Exception& ex, ThreadFinishSync<MappingIpc*>::ThreadRoutine*)
@@ -864,34 +875,44 @@ class MappingIpc FB_FINAL : public Firebird::IpcObject
 
 	class Guard;
 	friend class Guard;
+	typedef SharedMemory<MappingHeader> MappingSharedMemory;
+	typedef AutoPtr<MappingSharedMemory> AutoSharedMemory;
 
 	class Guard
 	{
 	public:
 		explicit Guard(MappingIpc* ptr)
+			: data(ptr->sharedMemory)
+		{
+			fb_assert(data);
+			data->mutexLock();
+		}
+
+		explicit Guard(MappingSharedMemory* ptr)
 			: data(ptr)
 		{
-			data->sharedMemory->mutexLock();
+			fb_assert(data);
+			data->mutexLock();
 		}
 
 		~Guard()
 		{
-			data->sharedMemory->mutexUnlock();
+			data->mutexUnlock();
 		}
 
 	private:
 		Guard(const Guard&);
 		Guard& operator=(const Guard&);
 
-		MappingIpc* const data;
+		MappingSharedMemory* const data;
 	};
 
 	static void clearDelivery(MappingIpc* mapping)
 	{
 		mapping->clearDeliveryThread();
 	}
 
-	AutoPtr<SharedMemory<MappingHeader> > sharedMemory;
+	AutoSharedMemory sharedMemory;
 	Mutex initMutex;
 	const SLONG processId;
 	unsigned process;