ODS14: header page refactoring

src/common/classes/DbImplementation.cpp

@@ -146,7 +146,8 @@ const UCHAR backEndianess[FB_NELEM(hardware)] =
 namespace Firebird {
 
 DbImplementation::DbImplementation(const Ods::header_page* h)
-	: di_cpu(h->hdr_cpu), di_os(h->hdr_os), di_cc(h->hdr_cc), di_flags(h->hdr_compatibility_flags)
+	: di_cpu(h->hdr_db_impl.hdr_cpu), di_os(h->hdr_db_impl.hdr_os),
+	  di_cc(h->hdr_db_impl.hdr_cc), di_flags(h->hdr_db_impl.hdr_compat)
 {
 }
 
@@ -196,10 +197,10 @@ bool DbImplementation::compatible(const DbImplementation& v) const
 
 void DbImplementation::store(Ods::header_page* h) const
 {
-	h->hdr_cpu = di_cpu;
-	h->hdr_os = di_os;
-	h->hdr_cc = di_cc;
-	h->hdr_compatibility_flags = di_flags;
+	h->hdr_db_impl.hdr_cpu = di_cpu;
+	h->hdr_db_impl.hdr_os = di_os;
+	h->hdr_db_impl.hdr_cc = di_cc;
+	h->hdr_db_impl.hdr_compat = di_flags;
 }
 
 void DbImplementation::stuff(UCHAR** info) const
@@ -224,7 +225,7 @@ DbImplementation DbImplementation::fromBackwardCompatibleByte(UCHAR bcImpl)
 	{
 		for (UCHAR hw = 0; hw < FB_NELEM(hardware); ++hw)
 		{
-			USHORT ind = USHORT(os) * FB_NELEM(hardware) + USHORT(hw);
+			const USHORT ind = USHORT(os) * FB_NELEM(hardware) + USHORT(hw);
 			if (backwardTable[ind] == bcImpl)
 			{
 				return DbImplementation(hw, os, 0xFF, backEndianess[hw] ? EndianBig : EndianLittle);

src/common/classes/DbImplementation.h

@@ -38,10 +38,13 @@ class DbImplementation
 {
 public:
 	explicit DbImplementation(const Ods::header_page* h);
-	DbImplementation (UCHAR p_cpu, UCHAR p_os, UCHAR p_cc, UCHAR p_flags)
+
+	DbImplementation(UCHAR p_cpu, UCHAR p_os, UCHAR p_cc, UCHAR p_flags)
 		: di_cpu(p_cpu), di_os(p_os), di_cc(p_cc), di_flags(p_flags)
 	{ }
-	~DbImplementation() { }
+
+	~DbImplementation()
+	{ }
 
 private:
 	UCHAR di_cpu, di_os, di_cc, di_flags;

src/jrd/CryptoManager.cpp

@@ -54,10 +54,11 @@
 
 using namespace Firebird;
 
-namespace {
+namespace
+{
 	THREAD_ENTRY_DECLARE cryptThreadStatic(THREAD_ENTRY_PARAM p)
 	{
-		Jrd::CryptoManager* cryptoManager = (Jrd::CryptoManager*) p;
+		const auto cryptoManager = (Jrd::CryptoManager*) p;
 		cryptoManager->cryptThread();
 
 		return 0;
@@ -68,12 +69,12 @@ namespace {
 	const UCHAR CRYPT_CHANGE = LCK_PW;
 	const UCHAR CRYPT_INIT = LCK_EX;
 
-	const int MAX_PLUGIN_NAME_LEN = 31;
+	constexpr int MAX_PLUGIN_NAME_LEN = sizeof(Ods::header_page::hdr_crypt_plugin) - 1;
 }
 
 
-namespace Jrd {
-
+namespace Jrd
+{
 	class Header
 	{
 	protected:
@@ -553,10 +554,10 @@ namespace Jrd {
 
 		const bool newCryptState = plugName.hasData();
 
-		int bak_state = Ods::hdr_nbak_unknown;
+		auto backupState = Ods::hdr_nbak_unknown;
 		{	// scope
 			BackupManager::StateReadGuard stateGuard(tdbb);
-			bak_state = dbb.dbb_backup_manager->getState();
+			backupState = dbb.dbb_backup_manager->getState();
 		}
 
 		{	// window scope
@@ -574,7 +575,7 @@ namespace Jrd {
 				(Arg::Gds(isc_cp_already_crypted)).raise();
 			}
 
-			if (bak_state != Ods::hdr_nbak_normal)
+			if (backupState != Ods::hdr_nbak_normal)
 			{
 				(Arg::Gds(isc_wish_list) << Arg::Gds(isc_random) <<
 					"Cannot crypt: please wait for nbackup completion").raise();
@@ -625,9 +626,9 @@ namespace Jrd {
 
 	void CryptoManager::changeCryptState(thread_db* tdbb, const string& plugName)
 	{
-		if (plugName.length() > 31)
+		if (plugName.length() > MAX_PLUGIN_NAME_LEN)
 		{
-			(Arg::Gds(isc_cp_name_too_long) << Arg::Num(31)).raise();
+			(Arg::Gds(isc_cp_name_too_long) << Arg::Num(MAX_PLUGIN_NAME_LEN)).raise();
 		}
 
 		const bool newCryptState = plugName.hasData();
@@ -656,8 +657,8 @@ namespace Jrd {
 
 			// Nbak's lock was taken in prepareChangeCryptState()
 			// If it was invalidated it's enough reason not to continue now
-			int bak_state = dbb.dbb_backup_manager->getState();
-			if (bak_state != Ods::hdr_nbak_normal)
+			auto backupState = dbb.dbb_backup_manager->getState();
+			if (backupState != Ods::hdr_nbak_normal)
 			{
 				(Arg::Gds(isc_wish_list) << Arg::Gds(isc_random) <<
 					"Cannot crypt: please wait for nbackup completion").raise();
@@ -669,7 +670,7 @@ namespace Jrd {
 				(Arg::Gds(isc_cp_process_active)).raise();
 			}
 
-			bool headerCryptState = hdr->hdr_flags & Ods::hdr_encrypted;
+			const bool headerCryptState = hdr->hdr_flags & Ods::hdr_encrypted;
 			if (headerCryptState == newCryptState)
 			{
 				(Arg::Gds(isc_cp_already_crypted)).raise();
@@ -1085,13 +1086,13 @@ namespace Jrd {
 							JRD_reschedule(tdbb);
 
 							// nbackup state check
-							int bak_state = Ods::hdr_nbak_unknown;
+							auto backupState = Ods::hdr_nbak_unknown;
 							{	// scope
 								BackupManager::StateReadGuard stateGuard(tdbb);
-								bak_state = dbb.dbb_backup_manager->getState();
+								backupState = dbb.dbb_backup_manager->getState();
 							}
 
-							if (bak_state != Ods::hdr_nbak_normal)
+							if (backupState != Ods::hdr_nbak_normal)
 							{
 								EngineCheckout checkout(tdbb, FB_FUNCTION);
 								Thread::sleep(10);

src/jrd/Database.cpp

@@ -252,7 +252,7 @@ namespace Jrd
 		while (true)
 		{
 			AtomicCounter::counter_type old = dbb_flags;
-			if ((old & (DBB_sweep_in_progress | DBB_sweep_starting)) || (dbb_ast_flags & DBB_shutdown))
+			if ((old & (DBB_sweep_in_progress | DBB_sweep_starting)) || isShutdown())
 			{
 				dbb_thread_mutex.leave();
 				return false;

src/jrd/Database.h

@@ -237,12 +237,9 @@ const ULONG DBB_shared					= 0x100000L;	// Database object is shared among conne
 const ULONG DBB_blocking			= 0x1L;		// Exclusive mode is blocking
 const ULONG DBB_get_shadows			= 0x2L;		// Signal received to check for new shadows
 const ULONG DBB_assert_locks		= 0x4L;		// Locks are to be asserted
-const ULONG DBB_shutdown			= 0x8L;		// Database is shutdown
-const ULONG DBB_shut_attach			= 0x10L;	// no new attachments accepted
-const ULONG DBB_shut_tran			= 0x20L;	// no new transactions accepted
-const ULONG DBB_shut_force			= 0x40L;	// forced shutdown in progress
-const ULONG DBB_shutdown_full		= 0x80L;	// Database fully shut down
-const ULONG DBB_shutdown_single		= 0x100L;	// Database is in single-user maintenance mode
+const ULONG DBB_shut_attach			= 0x8L;		// No new attachments accepted
+const ULONG DBB_shut_tran			= 0x10L;	// No new transactions accepted
+const ULONG DBB_shut_force			= 0x20L;	// Forced shutdown in progress
 
 class Database : public pool_alloc<type_dbb>
 {
@@ -472,6 +469,7 @@ class Database : public pool_alloc<type_dbb>
 	Firebird::RWLock		dbb_ast_lock;		// avoids delivering AST to going away database
 	Firebird::AtomicCounter dbb_ast_flags;		// flags modified at AST level
 	Firebird::AtomicCounter dbb_flags;
+	std::atomic<shut_mode_t> dbb_shutdown_mode;		// shutdown mode
 	USHORT dbb_ods_version;				// major ODS version number
 	USHORT dbb_minor_version;			// minor ODS version number
 	USHORT dbb_page_size;				// page size
@@ -540,7 +538,7 @@ class Database : public pool_alloc<type_dbb>
 	Lock* dbb_repl_lock;				// replication state lock
 	Firebird::SyncObject dbb_repl_sync;
 	FB_UINT64 dbb_repl_sequence;		// replication sequence
-	ReplicaMode dbb_replica_mode;		// replica access mode
+	std::atomic<ReplicaMode> dbb_replica_mode;		// replica access mode
 
 	unsigned dbb_compatibility_index;	// datatype backward compatibility level
 	Dictionary dbb_dic;					// metanames dictionary
@@ -576,14 +574,24 @@ class Database : public pool_alloc<type_dbb>
 
 	void registerModule(Module&);
 
+	bool isShutdown() const
+	{
+		return (dbb_shutdown_mode.load(std::memory_order_relaxed) != shut_mode_online);
+	}
+
+	bool isShutdown(shut_mode_t mode) const
+	{
+		return (dbb_shutdown_mode.load(std::memory_order_relaxed) == mode);
+	}
+
 	bool isReplica() const
 	{
-		return (dbb_replica_mode != REPLICA_NONE);
+		return (dbb_replica_mode.load(std::memory_order_relaxed) != REPLICA_NONE);
 	}
 
 	bool isReplica(ReplicaMode mode) const
 	{
-		return (dbb_replica_mode == mode);
+		return (dbb_replica_mode.load(std::memory_order_relaxed) == mode);
 	}
 
 	USHORT getEncodedOdsVersion() const
@@ -605,6 +613,7 @@ class Database : public pool_alloc<type_dbb>
 		dbb_modules(*p),
 		dbb_extManager(nullptr),
 		dbb_flags(shared ? DBB_shared : 0),
+		dbb_shutdown_mode(shut_mode_online),
 		dbb_filename(*p),
 		dbb_database_name(*p),
 #ifdef HAVE_ID_BY_NAME

src/jrd/Monitoring.cpp

@@ -837,9 +837,9 @@ void Monitoring::putDatabase(thread_db* tdbb, SnapshotData::DumpRecord& record)
 	record.reset(rel_mon_database);
 
 	// Determine the backup state
-	int backup_state = backup_state_unknown;
+	int backupState = backup_state_unknown;
 
-	BackupManager* const bm = dbb->dbb_backup_manager;
+	const auto bm = dbb->dbb_backup_manager;
 
 	if (bm && !bm->isShutDown())
 	{
@@ -848,14 +848,16 @@ void Monitoring::putDatabase(thread_db* tdbb, SnapshotData::DumpRecord& record)
 		switch (bm->getState())
 		{
 		case Ods::hdr_nbak_normal:
-			backup_state = backup_state_normal;
+			backupState = backup_state_normal;
 			break;
 		case Ods::hdr_nbak_stalled:
-			backup_state = backup_state_stalled;
+			backupState = backup_state_stalled;
 			break;
 		case Ods::hdr_nbak_merge:
-			backup_state = backup_state_merge;
+			backupState = backup_state_merge;
 			break;
+		default:
+			fb_assert(false);
 		}
 	}
 
@@ -886,18 +888,8 @@ void Monitoring::putDatabase(thread_db* tdbb, SnapshotData::DumpRecord& record)
 	// SQL dialect
 	temp = (dbb->dbb_flags & DBB_DB_SQL_dialect_3) ? 3 : 1;
 	record.storeInteger(f_mon_db_dialect, temp);
-
 	// shutdown mode
-	if (dbb->dbb_ast_flags & DBB_shutdown_full)
-		temp = shut_mode_full;
-	else if (dbb->dbb_ast_flags & DBB_shutdown_single)
-		temp = shut_mode_single;
-	else if (dbb->dbb_ast_flags & DBB_shutdown)
-		temp = shut_mode_multi;
-	else
-		temp = shut_mode_online;
-	record.storeInteger(f_mon_db_shut_mode, temp);
-
+	record.storeInteger(f_mon_db_shut_mode, dbb->dbb_shutdown_mode);
 	// sweep interval
 	record.storeInteger(f_mon_db_sweep_int, dbb->dbb_sweep_interval);
 	// read only flag
@@ -914,7 +906,7 @@ void Monitoring::putDatabase(thread_db* tdbb, SnapshotData::DumpRecord& record)
 	// database size
 	record.storeInteger(f_mon_db_pages, PageSpace::actAlloc(dbb));
 	// database backup state
-	record.storeInteger(f_mon_db_backup_state, backup_state);
+	record.storeInteger(f_mon_db_backup_state, backupState);
 
 	// crypt thread status
 	if (dbb->dbb_crypto_manager)

src/jrd/SysFunction.cpp

@@ -4611,13 +4611,13 @@ dsc* evlGetContext(thread_db* tdbb, const SysFunction*, const NestValueArray& ar
 		}
 		else if (nameStr == REPLICA_MODE)
 		{
-			if (dbb->dbb_replica_mode == REPLICA_READ_ONLY)
+			if (dbb->isReplica(REPLICA_READ_ONLY))
 				resultStr = RO_VALUE;
-			else if (dbb->dbb_replica_mode == REPLICA_READ_WRITE)
+			else if (dbb->isReplica(REPLICA_READ_WRITE))
 				resultStr = RW_VALUE;
 			else
 			{
-				fb_assert(dbb->dbb_replica_mode == REPLICA_NONE);
+				fb_assert(!dbb->isReplica());
 				return NULL;
 			}
 		}
@@ -4997,8 +4997,8 @@ dsc* evlGetTranCN(thread_db* tdbb, const SysFunction* function, const NestValueA
 	if ((traNum > traMax) && !(dbb->dbb_flags & DBB_shared))
 	{
 		WIN window(HEADER_PAGE_NUMBER);
-		const Ods::header_page* header = (Ods::header_page*) CCH_FETCH(tdbb, &window, LCK_read, pag_header);
-		traMax = Ods::getNT(header);
+		const auto header = (const Ods::header_page*) CCH_FETCH(tdbb, &window, LCK_read, pag_header);
+		traMax = header->hdr_next_transaction;
 		CCH_RELEASE(tdbb, &window);
 	}