diff --git a/src/command/backup/backup.c b/src/command/backup/backup.c
index ffaba65694..94806ae5a3 100644
--- a/src/command/backup/backup.c
+++ b/src/command/backup/backup.c
@@ -67,6 +67,7 @@ typedef struct BackupData
     unsigned int version;                                           // PostgreSQL version
     unsigned int walSegmentSize;                                    // PostgreSQL wal segment size
     PgPageSize pageSize;                                            // PostgreSQL page size
+    unsigned int segmentPageTotal;                                  // PostgreSQL total pages in a relation segment
 } BackupData;
 
 static BackupData *
@@ -133,6 +134,7 @@ backupInit(const InfoBackup *const infoBackup)
     result->version = pgControl.version;
     result->walSegmentSize = pgControl.walSegmentSize;
     result->pageSize = pgControl.pageSize;
+    result->segmentPageTotal = pgControl.segmentPageTotal;
 
     // Validate pg_control info against the stanza
     if (result->version != infoPg.version || pgControl.systemId != infoPg.systemId)
diff --git a/src/command/backup/file.c.inc b/src/command/backup/file.c.inc
index ec1fe887d6..ca8db64fe7 100644
--- a/src/command/backup/file.c.inc
+++ b/src/command/backup/file.c.inc
@@ -151,7 +151,7 @@ static List *
 backupFile(
     const String *const repoFile, const uint64_t bundleId, const bool bundleRaw, const unsigned int blockIncrReference,
     const CompressType repoFileCompressType, const int repoFileCompressLevel, const CipherSpec *const cipherSpecBackup,
-    const String *const pgVersionForce, const PgPageSize pageSize, const List *const fileList)
+    const String *const pgVersionForce, const PgPageSize pageSize, const unsigned int segmentPageTotal, const List *const fileList)
 {
     FUNCTION_LOG_BEGIN(logLevelDebug);
         FUNCTION_LOG_PARAM(STRING, repoFile);                       // Repo file
@@ -162,6 +162,7 @@ backupFile(
         FUNCTION_LOG_PARAM(INT, repoFileCompressLevel);             // Compression level for repo file
         FUNCTION_LOG_PARAM(CIPHER_SPEC, cipherSpecBackup);          // Cipher spec to encrypt the backup file
         FUNCTION_LOG_PARAM(ENUM, pageSize);                         // Page size
+        FUNCTION_LOG_PARAM(UINT, segmentPageTotal);                 // Total pages in a relation segment
         FUNCTION_LOG_PARAM(STRING, pgVersionForce);                 // Force pg version
         FUNCTION_LOG_PARAM(LIST, fileList);                         // List of files to backup
     FUNCTION_LOG_END();
@@ -170,6 +171,7 @@ backupFile(
     ASSERT(cipherSpecBackup != NULL);
     ASSERT(fileList != NULL && !lstEmpty(fileList));
     ASSERT(pgPageSizeValid(pageSize));
+    ASSERT(segmentPageTotal > 0);
 
     // Backup file results
     List *const result = lstNewP(sizeof(BackupFileResult));
@@ -356,8 +358,8 @@ backupFile(
                         ioFilterGroupAdd(
                             ioReadFilterGroup(readIo),
                             pageChecksumNew(
-                                segmentNumber(file->pgFile), PG_SEGMENT_SIZE_DEFAULT / pageSize, pageSize,
-                                file->pgFilePageHeaderCheck, storagePathP(storagePg(), file->pgFile)));
+                                segmentNumber(file->pgFile), segmentPageTotal, pageSize, file->pgFilePageHeaderCheck,
+                                storagePathP(storagePg(), file->pgFile)));
                     }
 
                     // Compress filter
diff --git a/src/command/backup/pageChecksum.c b/src/command/backup/pageChecksum.c
index 653bf160fc..75cdd97627 100644
--- a/src/command/backup/pageChecksum.c
+++ b/src/command/backup/pageChecksum.c
@@ -238,7 +238,7 @@ pageChecksumNew(
     FUNCTION_LOG_END();
 
     ASSERT(pgPageSizeValid(pageSize));
-    ASSERT(segmentPageTotal > 0 && segmentPageTotal % pageSize == 0);
+    ASSERT(segmentPageTotal > 0);
 
     OBJ_NEW_BEGIN(PageChecksum, .childQty = MEM_CONTEXT_QTY_MAX)
     {
diff --git a/src/command/backup/process.c.inc b/src/command/backup/process.c.inc
index e58e3db4e6..0feababa36 100644
--- a/src/command/backup/process.c.inc
+++ b/src/command/backup/process.c.inc
@@ -340,6 +340,7 @@ typedef struct BackupJobData
     RegExp *standbyExp;                                             // Identify files that may be copied from the standby
     const CipherSpec *const cipherSpecBackup;                       // Cipher spec used to encrypt files in the backup
     const PgPageSize pageSize;                                      // Page size
+    const unsigned int segmentPageTotal;                            // Total pages in a relation segment
     const CompressType compressType;                                // Backup compression type
     const int compressLevel;                                        // Compress level if backup is compressed
     const bool delta;                                               // Is this a checksum delta backup?
@@ -692,6 +693,7 @@ backupJobCallback(void *const data, const unsigned int clientIdx)
                     pckWriteI32P(param, jobData->compressLevel);
                     cipherSpecPack(param, jobData->cipherSpecBackup);
                     pckWriteU32P(param, jobData->pageSize);
+                    pckWriteU32P(param, jobData->segmentPageTotal);
                     pckWriteStrP(param, cfgOptionStrNull(cfgOptPgVersionForce));
                 }
 
@@ -806,6 +808,7 @@ backupProcess(const BackupData *const backupData, Manifest *const manifest, cons
             .compressLevel = cfgOptionInt(cfgOptCompressLevel),
             .cipherSpecBackup = manifestCipherSpec(manifest),
             .pageSize = backupData->pageSize,
+            .segmentPageTotal = backupData->segmentPageTotal,
             .delta = cfgOptionBool(cfgOptDelta),
             .bundle = cfgOptionBool(cfgOptRepoBundle),
             .bundleId = 1,
diff --git a/src/command/backup/protocol.c b/src/command/backup/protocol.c
index 88c0ed8489..235fdab94d 100644
--- a/src/command/backup/protocol.c
+++ b/src/command/backup/protocol.c
@@ -117,6 +117,7 @@ backupFileProtocol(PackRead *const param)
         const int repoFileCompressLevel = pckReadI32P(param);
         const CipherSpec *const cipherSpecBackup = cipherSpecNewPack(param);
         const PgPageSize pageSize = pckReadU32P(param);
+        const unsigned int segmentPageTotal = pckReadU32P(param);
         const String *const pgVersionForce = pckReadStrP(param);
 
         // Build the file list
@@ -163,7 +164,7 @@ backupFileProtocol(PackRead *const param)
         // Backup file
         const List *const resultList = backupFile(
             repoFile, bundleId, bundleRaw, blockIncrReference, repoFileCompressType, repoFileCompressLevel, cipherSpecBackup,
-            pgVersionForce, pageSize, fileList);
+            pgVersionForce, pageSize, segmentPageTotal, fileList);
 
         // Return result
         PackWrite *const data = protocolServerResultData(result);
diff --git a/src/postgres/interface.c b/src/postgres/interface.c
index 1bead8d27b..070ad0ea14 100644
--- a/src/postgres/interface.c
+++ b/src/postgres/interface.c
@@ -52,6 +52,11 @@ concurrent reads and writes so retries are required.
 #define PG_CONTROL_SIZE                                             8192
 #define PG_CONTROL_DATA_SIZE                                        512
 
+/***********************************************************************************************************************************
+Maximum pages in a relation segment
+***********************************************************************************************************************************/
+#define PG_SEGMENT_PAGE_TOTAL_MAX                                   2147483647
+
 /***********************************************************************************************************************************
 PostgreSQL interface definitions
 
@@ -317,6 +322,15 @@ pgControlFromBuffer(const Buffer *const controlFile, const String *const pgVersi
     // Check the page size
     pgPageSizeCheck(result.pageSize);
 
+    // Check the relation segment size
+    if (result.segmentPageTotal == 0 || result.segmentPageTotal > PG_SEGMENT_PAGE_TOTAL_MAX)
+    {
+        THROW_FMT(
+            FormatError,
+            "relation segment size is %u pages but must be between 1 and " STRINGIFY(PG_SEGMENT_PAGE_TOTAL_MAX) " inclusive",
+            result.segmentPageTotal);
+    }
+
     // Check the checksum version
     if (result.pageChecksumVersion > PG_DATA_CHECKSUM_VERSION)
     {
diff --git a/src/postgres/interface.h b/src/postgres/interface.h
index 9ec94b11e0..3674e5dd1c 100644
--- a/src/postgres/interface.h
+++ b/src/postgres/interface.h
@@ -73,13 +73,6 @@ typedef enum
     pgPageSize32 = 32 * 1024,
 } PgPageSize;
 
-/***********************************************************************************************************************************
-Define default segment size and pages per segment
-
-Segment size can only be changed at compile time and is not known to be well-tested, so only the default segment size is supported.
-***********************************************************************************************************************************/
-#define PG_SEGMENT_SIZE_DEFAULT                                     ((unsigned int)(1 * 1024 * 1024 * 1024))
-
 /***********************************************************************************************************************************
 WAL header size. It doesn't seem worth tracking the exact size of the WAL header across versions of PostgreSQL so just set it to
 something far larger needed but <= the minimum read size on just about any system.
@@ -104,6 +97,7 @@ typedef struct PgControl
     uint32_t timeline;                                              // Current timeline
 
     PgPageSize pageSize;
+    unsigned int segmentPageTotal;                                  // Total pages in a relation segment
     unsigned int walSegmentSize;
 
     unsigned int pageChecksumVersion;                               // Page checksum version (0 if no checksum, 1 if checksum)
diff --git a/src/postgres/interface/version.intern.h b/src/postgres/interface/version.intern.h
index 84f1f9fe5b..1280d1b845 100644
--- a/src/postgres/interface/version.intern.h
+++ b/src/postgres/interface/version.intern.h
@@ -84,6 +84,7 @@ Read the version specific pg_control into a general data structure
             .checkpoint = ((const ControlFileData *)controlFile)->checkPoint,                                                      \
             .timeline = ((const ControlFileData *)controlFile)->checkPointCopy.ThisTimeLineID,                                     \
             .pageSize = ((const ControlFileData *)controlFile)->blcksz,                                                            \
+            .segmentPageTotal = ((const ControlFileData *)controlFile)->relseg_size,                                               \
             .walSegmentSize = ((const ControlFileData *)controlFile)->xlog_seg_size,                                               \
             .pageChecksumVersion = ((const ControlFileData *)controlFile)->data_checksum_version,                                  \
         };                                                                                                                         \
diff --git a/test/src/harness/postgres.c b/test/src/harness/postgres.c
index b7acfc7e47..48939dc7f4 100644
--- a/test/src/harness/postgres.c
+++ b/test/src/harness/postgres.c
@@ -88,6 +88,9 @@ hrnPgControlToBuffer(unsigned int controlVersion, const unsigned int crc, PgCont
 
     // Set defaults if values are not passed
     pgControl.pageSize = pgControl.pageSize == 0 ? pgPageSize8 : pgControl.pageSize;
+    pgControl.segmentPageTotal =
+        pgControl.segmentPageTotal == UINT_MAX ?
+            0 : (pgControl.segmentPageTotal == 0 ? HRN_PG_SEGMENT_SIZE_DEFAULT / pgControl.pageSize : pgControl.segmentPageTotal);
     pgControl.walSegmentSize =
         pgControl.walSegmentSize == UINT_MAX ?
             0 : (pgControl.walSegmentSize == 0 ? HRN_PG_WAL_SEGMENT_SIZE_DEFAULT : pgControl.walSegmentSize);
diff --git a/test/src/harness/postgres.h b/test/src/harness/postgres.h
index 3fcc81ee9e..09b60738ce 100644
--- a/test/src/harness/postgres.h
+++ b/test/src/harness/postgres.h
@@ -19,6 +19,11 @@ Default wal segment size
 ***********************************************************************************************************************************/
 #define HRN_PG_WAL_SEGMENT_SIZE_DEFAULT                             ((unsigned int)(16 * 1024 * 1024))
 
+/***********************************************************************************************************************************
+Default relation segment size
+***********************************************************************************************************************************/
+#define HRN_PG_SEGMENT_SIZE_DEFAULT                                 ((unsigned int)(1024 * 1024 * 1024))
+
 /***********************************************************************************************************************************
 System id constants by version
 
diff --git a/test/src/harness/postgres/version.intern.h b/test/src/harness/postgres/version.intern.h
index c71a28f5a1..4a85f226e5 100644
--- a/test/src/harness/postgres/version.intern.h
+++ b/test/src/harness/postgres/version.intern.h
@@ -29,6 +29,7 @@ Create a pg_control file
                 .ThisTimeLineID = pgControl.timeline,                                                                              \
             },                                                                                                                     \
             .blcksz = pgControl.pageSize,                                                                                          \
+            .relseg_size = pgControl.segmentPageTotal,                                                                             \
             .xlog_seg_size = pgControl.walSegmentSize,                                                                             \
             .data_checksum_version = pgControl.pageChecksumVersion,                                                                \
         };                                                                                                                         \
diff --git a/test/src/module/command/backupTest.c b/test/src/module/command/backupTest.c
index e7d7ca54a8..c80f39c9b9 100644
--- a/test/src/module/command/backupTest.c
+++ b/test/src/module/command/backupTest.c
@@ -670,7 +670,7 @@ testRun(void)
     // *****************************************************************************************************************************
     if (testBegin("PageChecksum"))
     {
-        #define PG_SEGMENT_PAGE_DEFAULT                             (PG_SEGMENT_SIZE_DEFAULT / pgPageSize8)
+        #define PG_SEGMENT_PAGE_DEFAULT                             (HRN_PG_SEGMENT_SIZE_DEFAULT / pgPageSize8)
 
         // -------------------------------------------------------------------------------------------------------------------------
         TEST_TITLE("segment page default");
@@ -2068,8 +2068,8 @@ testRun(void)
             "P00   INFO: new backup label = [FULL-1]\n"
             "P00   INFO: full backup size = 8KB, file total = 2",
             TEST_64BIT() ?
-                (TEST_BIG_ENDIAN() ? "a73da1cfddf849880b4f6f0f4209ce71043f2ac1" : "807d4464138ef085e41844a9f488f067b3d46d46") :
-                "c09a7f1d2ff6131ec467e18b781970a86efd4e5b");
+                (TEST_BIG_ENDIAN() ? "884c00e2f6fcfc2c73364a285175483783a7cace" : "7583cfcf2d4c882b248898162a17a19929ed6f61") :
+                "5cf90a168630adb21cd2352036e2be3af86d7474");
 
         // Make pg no longer appear to be running
         HRN_STORAGE_REMOVE(storagePgWrite(), PG_FILE_POSTMTRPID, .errorOnMissing = true);
@@ -3048,7 +3048,8 @@ testRun(void)
 
         {
             // Update pg_control
-            HRN_PG_CONTROL_PUT(storagePgWrite(), PG_VERSION_11, .pageChecksumVersion = 1, .walSegmentSize = 1024 * 1024);
+            HRN_PG_CONTROL_PUT(
+                storagePgWrite(), PG_VERSION_11, .pageChecksumVersion = 1, .segmentPageTotal = 8, .walSegmentSize = 1024 * 1024);
 
             // Update version
             HRN_STORAGE_PUT_Z(storagePgWrite(), PG_FILE_PGVERSION, PG_VERSION_11_Z, .timeModified = backupTimeStart);
@@ -3123,17 +3124,19 @@ testRun(void)
 
             HRN_STORAGE_PUT(storagePgWrite(), PG_PATH_BASE "/1/3", relation, .timeModified = backupTimeStart);
 
-            // File with bad page checksum
+            // File with bad page checksum in the second relation segment
+            HRN_STORAGE_REMOVE(storagePgWrite(), "base/1/4", .errorOnMissing = true);
+
             relation = bufNew(pgPageSize8 * 3);
             memset(bufPtr(relation), 0, bufSize(relation));
             *(PageHeaderData *)(bufPtr(relation) + (pgPageSize8 * 0x00)) = (PageHeaderData){.pd_upper = 0x00};
             *(PageHeaderData *)(bufPtr(relation) + (pgPageSize8 * 0x01)) = (PageHeaderData){.pd_upper = 0x08};
             *(PageHeaderData *)(bufPtr(relation) + (pgPageSize8 * 0x02)) = (PageHeaderData){.pd_upper = 0xFF};
             ((PageHeaderData *)(bufPtr(relation) + (pgPageSize8 * 0x02)))->pd_checksum = pgPageChecksum(
-                bufPtr(relation) + (pgPageSize8 * 0x02), 2, pgPageSize8);
+                bufPtr(relation) + (pgPageSize8 * 0x02), 10, pgPageSize8);
             bufUsedSet(relation, bufSize(relation));
 
-            HRN_STORAGE_PUT(storagePgWrite(), PG_PATH_BASE "/1/4", relation, .timeModified = backupTimeStart);
+            HRN_STORAGE_PUT(storagePgWrite(), PG_PATH_BASE "/1/4.1", relation, .timeModified = backupTimeStart);
 
             // Add a tablespace
             HRN_STORAGE_PATH_CREATE(storagePgWrite(), PG_PATH_PGTBLSPC);
@@ -3166,8 +3169,8 @@ testRun(void)
                 "P00   INFO: check archive for segment 0000000105DB5DE000000000\n"
                 "P01 DETAIL: backup file " TEST_PATH "/pg1/base/1/3 (40KB, [PCT]) checksum [SHA1]\n"
                 "P00   WARN: invalid page checksums found in file " TEST_PATH "/pg1/base/1/3 at pages 0, 2-4\n"
-                "P01 DETAIL: backup file " TEST_PATH "/pg1/base/1/4 (24KB, [PCT]) checksum [SHA1]\n"
-                "P00   WARN: invalid page checksum found in file " TEST_PATH "/pg1/base/1/4 at page 1\n"
+                "P01 DETAIL: backup file " TEST_PATH "/pg1/base/1/4.1 (24KB, [PCT]) checksum [SHA1]\n"
+                "P00   WARN: invalid page checksum found in file " TEST_PATH "/pg1/base/1/4.1 at page 9\n"
                 "P01 DETAIL: backup file " TEST_PATH "/pg1/base/1/1 (16KB, [PCT]) checksum [SHA1]\n"
                 "P01 DETAIL: backup file " TEST_PATH "/pg1/base/1/2 (8.5KB, [PCT]) checksum [SHA1]\n"
                 "P00   WARN: page misalignment in file " TEST_PATH "/pg1/base/1/2: file size 8704 is not divisible by page size"
@@ -3195,7 +3198,7 @@ testRun(void)
                 "pg_data/base/1/1.gz {s=16384, ckp=t}\n"
                 "pg_data/base/1/2.gz {s=8704, ckp=t}\n"
                 "pg_data/base/1/3.gz {s=40960, ckp=[0,[2,4]]}\n"
-                "pg_data/base/1/4.gz {s=24576, ckp=[1]}\n"
+                "pg_data/base/1/4.1.gz {s=24576, ckp=[9]}\n"
                 "pg_data/global/pg_control.gz {s=8192}\n"
                 "pg_data/pg_tblspc/\n"
                 "pg_data/pg_wal/0000000105DB5DE000000000.gz {s=1048576, ts=+2}\n"
@@ -3213,7 +3216,7 @@ testRun(void)
 
             // Remove test files but base/1/3 (with its invalid page checksums) for the following test
             HRN_STORAGE_REMOVE(storagePgWrite(), "base/1/2", .errorOnMissing = true);
-            HRN_STORAGE_REMOVE(storagePgWrite(), "base/1/4", .errorOnMissing = true);
+            HRN_STORAGE_REMOVE(storagePgWrite(), "base/1/4.1", .errorOnMissing = true);
         }
 
         // -------------------------------------------------------------------------------------------------------------------------
diff --git a/test/src/module/postgres/interfaceTest.c b/test/src/module/postgres/interfaceTest.c
index cefa6f9e21..3db39fcda2 100644
--- a/test/src/module/postgres/interfaceTest.c
+++ b/test/src/module/postgres/interfaceTest.c
@@ -94,7 +94,7 @@ testRun(void)
             "HINT: calculated 0x%x but expected value is 0xfadefade\n"
             "HINT: is pg_control corrupt?\n"
             "HINT: does pg_control have a different layout than expected?",
-            (uint32_t)(TEST_BIG_ENDIAN() ? 0x4e206eeb : (TEST_64BIT() ? 0x4ad387b2 : 0x3ca3a1ec)));
+            (uint32_t)(TEST_BIG_ENDIAN() ? 0xb0421e53 : (TEST_64BIT() ? 0x7bf250ff : 0x0d8276a1)));
 
         // -------------------------------------------------------------------------------------------------------------------------
         TEST_TITLE("invalid CRC on force control version");
@@ -108,12 +108,12 @@ testRun(void)
             "HINT: checksum values may be misleading due to forced version scan\n"
             "HINT: is pg_control corrupt?\n"
             "HINT: does pg_control have a different layout than expected?",
-            (uint32_t)(TEST_BIG_ENDIAN() ? 0x27dc2b85 : (TEST_64BIT() ? 0xa9264d94 : 0xb371302a)));
+            (uint32_t)(TEST_BIG_ENDIAN() ? 0x07653056 : (TEST_64BIT() ? 0xadb340b4 : 0xd9c9d3d5)));
 
         // -------------------------------------------------------------------------------------------------------------------------
         HRN_PG_CONTROL_PUT(
             storageTest, PG_VERSION_11, .systemId = 0xFACEFACE, .checkpoint = 0xEEFFEEFFAABBAABB, .timeline = 47,
-            .walSegmentSize = 1024 * 1024);
+            .segmentPageTotal = INT_MAX, .walSegmentSize = 1024 * 1024);
 
         PgControl info = {0};
         TEST_ASSIGN(info, pgControlFromFile(storageTest, NULL), "get control info v11");
@@ -122,6 +122,7 @@ testRun(void)
         TEST_RESULT_UINT(info.catalogVersion, 201809051, "   check catalog version");
         TEST_RESULT_UINT(info.checkpoint, 0xEEFFEEFFAABBAABB, "check checkpoint");
         TEST_RESULT_UINT(info.timeline, 47, "check timeline");
+        TEST_RESULT_UINT(info.segmentPageTotal, INT_MAX, "check segment page total");
 
         // -------------------------------------------------------------------------------------------------------------------------
         HRN_PG_CONTROL_PUT(storageTest, PG_VERSION_11, .walSegmentSize = UINT_MAX); // UINT_MAX forces size to 0
@@ -155,6 +156,19 @@ testRun(void)
             pgControlFromFile(storageTest, NULL), FormatError,
             "page size is 65536 but only 1024, 2048, 4096, 8192, 16384, and 32768 are supported");
 
+        // -------------------------------------------------------------------------------------------------------------------------
+        HRN_PG_CONTROL_PUT(storageTest, PG_VERSION_11, .segmentPageTotal = UINT_MAX); // UINT_MAX forces size to 0
+
+        TEST_ERROR(
+            pgControlFromFile(storageTest, NULL), FormatError,
+            "relation segment size is 0 pages but must be between 1 and 2147483647 inclusive");
+
+        HRN_PG_CONTROL_PUT(storageTest, PG_VERSION_11, .segmentPageTotal = (unsigned int)INT_MAX + 1);
+
+        TEST_ERROR(
+            pgControlFromFile(storageTest, NULL), FormatError,
+            "relation segment size is 2147483648 pages but must be between 1 and 2147483647 inclusive");
+
         // -------------------------------------------------------------------------------------------------------------------------
         HRN_PG_CONTROL_PUT(storageTest, PG_VERSION_11, .pageChecksumVersion = 2);
 
