Reimplement the feature of support setting data file size limit

Signed-off-by: Benjamin Wang <benjamin.ahrtr@gmail.com>

Author: ahrtr

bolt_windows.go

@@ -68,19 +68,6 @@ func mmap(db *DB, sz int) error {
 	var sizelo, sizehi uint32
 
 	if !db.readOnly {
-		if db.MaxSize > 0 && sz > db.MaxSize {
-			// The max size only limits future writes; however, we don’t block opening
-			// and mapping the database if it already exceeds the limit.
-			fileSize, err := db.fileSize()
-			if err != nil {
-				return fmt.Errorf("could not check existing db file size: %s", err)
-			}
-
-			if sz > fileSize {
-				return errors.ErrMaxSizeReached
-			}
-		}
-
 		// Truncate the database to the size of the mmap.
 		if err := db.file.Truncate(int64(sz)); err != nil {
 			return fmt.Errorf("truncate: %s", err)

db.go

@@ -476,6 +476,23 @@ func (db *DB) mmap(minsz int) (err error) {
 		return err
 	}
 
+	if db.MaxSize > 0 && size > db.MaxSize {
+		// On Windows, the data file is expanded to the full mapped size during mmap,
+		// so we must reject any mmap size larger than the configured max size.
+		//
+		// On other platforms, mmap itself does not grow the file immediately, so the
+		// mapped size may exceed the max size temporarily. The file size limit is
+		// enforced later when the file actually grows.
+		//
+		// In practice, this check mainly applies when opening a database with a large
+		// InitialMmapSize. In all other cases, file growth is already guarded during
+		// page allocation.
+		if size > fileSize && runtime.GOOS == "windows" {
+			db.Logger().Errorf("[GOOS: %s, GOARCH: %s] maximum db size reached, size: %d, db.MaxSize: %d", runtime.GOOS, runtime.GOARCH, size, db.MaxSize)
+			return berrors.ErrMaxSizeReached
+		}
+	}
+
 	if db.Mlock {
 		// Unlock db memory
 		if err := db.munlock(fileSize); err != nil {
@@ -1165,6 +1182,26 @@ func (db *DB) allocate(txid common.Txid, count int) (*common.Page, error) {
 	// Resize mmap() if we're at the end.
 	p.SetId(db.rwtx.meta.Pgid())
 	var minsz = int((p.Id()+common.Pgid(count))+1) * db.pageSize
+	if db.MaxSize > 0 {
+		nextAllocSize := minsz
+		nextMmapSize, err := db.mmapSize(minsz)
+		if err != nil {
+			return nil, fmt.Errorf("mmap size calculation error: %w", err)
+		}
+		if runtime.GOOS == "windows" {
+			// nextAllocSize may not exactly match nextMmapSize.
+			// On Windows, this mismatch may cause the file size to slightly exceed maxSize,
+			// while it is harmless on other platforms.
+			nextAllocSize = nextMmapSize
+		} else {
+			// On non-Windows platforms, the database file is only grown explicitly in grow calls.
+			nextAllocSize = db.growSize(nextMmapSize, nextAllocSize)
+		}
+		if nextAllocSize > db.MaxSize {
+			db.Logger().Errorf("[GOOS: %s, GOARCH: %s] maximum db size reached, minSize: %d (allocSize: %d), db.MaxSize: %d", runtime.GOOS, runtime.GOARCH, minsz, nextAllocSize, db.MaxSize)
+			return nil, berrors.ErrMaxSizeReached
+		}
+	}
 	if minsz >= db.datasz {
 		if err := db.mmap(minsz); err != nil {
 			if err == berrors.ErrMaxSizeReached {
@@ -1195,18 +1232,7 @@ func (db *DB) grow(sz int) error {
 		return nil
 	}
 
-	// If the data is smaller than the alloc size then only allocate what's needed.
-	// Once it goes over the allocation size then allocate in chunks.
-	if db.datasz <= db.AllocSize {
-		sz = db.datasz
-	} else {
-		sz += db.AllocSize
-	}
-
-	if !db.readOnly && db.MaxSize > 0 && sz > db.MaxSize {
-		lg.Errorf("[GOOS: %s, GOARCH: %s] maximum db size reached, size: %d, db.MaxSize: %d", runtime.GOOS, runtime.GOARCH, sz, db.MaxSize)
-		return berrors.ErrMaxSizeReached
-	}
+	sz = db.growSize(db.datasz, sz)
 
 	// Truncate and fsync to ensure file size metadata is flushed.
 	// https://github.com/boltdb/bolt/issues/284
@@ -1234,6 +1260,16 @@ func (db *DB) grow(sz int) error {
 	return nil
 }
 
+func (db *DB) growSize(mmapSize, growSize int) int {
+	// If the data is smaller than the alloc size then only allocate what's needed.
+	// Once it goes over the allocation size then allocate in chunks.
+	if mmapSize <= db.AllocSize {
+		return mmapSize
+	} else {
+		return growSize + db.AllocSize
+	}
+}
+
 func (db *DB) IsReadOnly() bool {
 	return db.readOnly
 }
@@ -1333,7 +1369,7 @@ type Options struct {
 	// PageSize overrides the default OS page size.
 	PageSize int
 
-	// MaxSize sets the maximum size of the data file. <=0 means no maximum.
+	// MaxSize sets the maximum size of the data file. A value <= 0 means no limit.
 	MaxSize int
 
 	// NoSync sets the initial value of DB.NoSync. Normally this can just be

db_test.go

@@ -1688,7 +1688,7 @@ func TestDB_MaxSizeExceededDoesNotGrow(t *testing.T) {
 		maxSize         int // 0 means unset
 		// expected file size after re-open (0 means "same as baseSize")
 		wantSize    int64
-		wantOpenErr error // nil means open must succeed
+		wantOpenErr error
 	}{
 		{
 			// On Windows, mmap expands the file to the mapped size immediately.