Update dependencies

vendor/github.com/cockroachdb/pebble/vfs/disk_health.go

@@ -13,7 +13,6 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/cockroachdb/pebble/internal/invariants"
 	"github.com/cockroachdb/redact"
 )
 
@@ -135,7 +134,7 @@ type diskHealthCheckingFile struct {
 	//
 	// NB: this packing scheme is not persisted, and is therefore safe to adjust
 	// across process boundaries.
-	lastWritePacked uint64
+	lastWritePacked atomic.Uint64
 	createTime      time.Time
 }
 
@@ -174,7 +173,7 @@ func (d *diskHealthCheckingFile) startTicker() {
 				return
 
 			case <-ticker.C:
-				packed := atomic.LoadUint64(&d.lastWritePacked)
+				packed := d.lastWritePacked.Load()
 				if packed == 0 {
 					continue
 				}
@@ -287,20 +286,12 @@ func (d *diskHealthCheckingFile) timeDiskOp(opType OpType, writeSizeInBytes int6
 
 	delta := time.Since(d.createTime)
 	packed := pack(delta, writeSizeInBytes, opType)
-	if invariants.Enabled {
-		if !atomic.CompareAndSwapUint64(&d.lastWritePacked, 0, packed) {
-			panic("concurrent write operations detected on file")
-		}
-	} else {
-		atomic.StoreUint64(&d.lastWritePacked, packed)
+	if d.lastWritePacked.Swap(packed) != 0 {
+		panic("concurrent write operations detected on file")
 	}
 	defer func() {
-		if invariants.Enabled {
-			if !atomic.CompareAndSwapUint64(&d.lastWritePacked, packed, 0) {
-				panic("concurrent write operations detected on file")
-			}
-		} else {
-			atomic.StoreUint64(&d.lastWritePacked, 0)
+		if d.lastWritePacked.Swap(0) != packed {
+			panic("concurrent write operations detected on file")
 		}
 	}()
 	op()
@@ -383,9 +374,17 @@ func (i DiskSlowInfo) String() string {
 
 // SafeFormat implements redact.SafeFormatter.
 func (i DiskSlowInfo) SafeFormat(w redact.SafePrinter, _ rune) {
-	w.Printf("disk slowness detected: %s on file %s (%d bytes) has been ongoing for %0.1fs",
-		redact.Safe(i.OpType.String()), redact.Safe(filepath.Base(i.Path)),
-		redact.Safe(i.WriteSize), redact.Safe(i.Duration.Seconds()))
+	switch i.OpType {
+	// Operations for which i.WriteSize is meaningful.
+	case OpTypeWrite, OpTypeSyncTo, OpTypePreallocate:
+		w.Printf("disk slowness detected: %s on file %s (%d bytes) has been ongoing for %0.1fs",
+			redact.Safe(i.OpType.String()), redact.Safe(filepath.Base(i.Path)),
+			redact.Safe(i.WriteSize), redact.Safe(i.Duration.Seconds()))
+	default:
+		w.Printf("disk slowness detected: %s on file %s has been ongoing for %0.1fs",
+			redact.Safe(i.OpType.String()), redact.Safe(filepath.Base(i.Path)),
+			redact.Safe(i.Duration.Seconds()))
+	}
 }
 
 // diskHealthCheckingFS adds disk-health checking facilities to a VFS.
@@ -451,7 +450,7 @@ type diskHealthCheckingFS struct {
 type slot struct {
 	name       string
 	opType     OpType
-	startNanos int64
+	startNanos atomic.Int64
 }
 
 // diskHealthCheckingFS implements FS.
@@ -518,12 +517,12 @@ func (d *diskHealthCheckingFS) timeFilesystemOp(name string, opType OpType, op f
 
 		startNanos := time.Now().UnixNano()
 		for i := 0; i < len(d.mu.inflight); i++ {
-			if atomic.LoadInt64(&d.mu.inflight[i].startNanos) == 0 {
+			if d.mu.inflight[i].startNanos.Load() == 0 {
 				// This slot is not in use. Claim it.
 				s = d.mu.inflight[i]
 				s.name = name
 				s.opType = opType
-				atomic.StoreInt64(&s.startNanos, startNanos)
+				s.startNanos.Store(startNanos)
 				break
 			}
 		}
@@ -534,10 +533,10 @@ func (d *diskHealthCheckingFS) timeFilesystemOp(name string, opType OpType, op f
 		// incur an allocation.
 		if s == nil {
 			s = &slot{
-				name:       name,
-				opType:     opType,
-				startNanos: startNanos,
+				name:   name,
+				opType: opType,
 			}
+			s.startNanos.Store(startNanos)
 			d.mu.inflight = append(d.mu.inflight, s)
 		}
 	}()
@@ -545,7 +544,7 @@ func (d *diskHealthCheckingFS) timeFilesystemOp(name string, opType OpType, op f
 	op()
 
 	// Signal completion by zeroing the start time.
-	atomic.StoreInt64(&s.startNanos, 0)
+	s.startNanos.Store(0)
 }
 
 // startTickerLocked starts a new goroutine with a ticker to monitor disk
@@ -556,7 +555,12 @@ func (d *diskHealthCheckingFS) startTickerLocked() {
 	go func() {
 		ticker := time.NewTicker(d.tickInterval)
 		defer ticker.Stop()
-		var exceededSlots []slot
+		type exceededSlot struct {
+			name       string
+			opType     OpType
+			startNanos int64
+		}
+		var exceededSlots []exceededSlot
 
 		for {
 			select {
@@ -567,14 +571,15 @@ func (d *diskHealthCheckingFS) startTickerLocked() {
 				d.mu.Lock()
 				now := time.Now()
 				for i := range d.mu.inflight {
-					nanos := atomic.LoadInt64(&d.mu.inflight[i].startNanos)
+					nanos := d.mu.inflight[i].startNanos.Load()
 					if nanos != 0 && time.Unix(0, nanos).Add(d.diskSlowThreshold).Before(now) {
 						// diskSlowThreshold was exceeded. Copy this inflightOp into
 						// exceededSlots and call d.onSlowDisk after dropping the mutex.
-						var inflightOp slot
-						inflightOp.name = d.mu.inflight[i].name
-						inflightOp.opType = d.mu.inflight[i].opType
-						inflightOp.startNanos = nanos
+						inflightOp := exceededSlot{
+							name:       d.mu.inflight[i].name,
+							opType:     d.mu.inflight[i].opType,
+							startNanos: nanos,
+						}
 						exceededSlots = append(exceededSlots, inflightOp)
 					}
 				}
@@ -690,7 +695,7 @@ func (d *diskHealthCheckingFS) Open(name string, opts ...OpenOption) (File, erro
 
 // OpenReadWrite implements the FS interface.
 func (d *diskHealthCheckingFS) OpenReadWrite(name string, opts ...OpenOption) (File, error) {
-	return d.fs.Open(name, opts...)
+	return d.fs.OpenReadWrite(name, opts...)
 }
 
 // OpenDir implements the FS interface.

vendor/github.com/cockroachdb/pebble/vfs/disk_usage_openbsd.go

@@ -0,0 +1,26 @@
+// Copyright 2023 The LevelDB-Go and Pebble Authors. All rights reserved. Use
+// of this source code is governed by a BSD-style license that can be found in
+// the LICENSE file.
+
+//go:build openbsd
+// +build openbsd
+
+package vfs
+
+import "golang.org/x/sys/unix"
+
+func (defaultFS) GetDiskUsage(path string) (DiskUsage, error) {
+	stat := unix.Statfs_t{}
+	if err := unix.Statfs(path, &stat); err != nil {
+		return DiskUsage{}, err
+	}
+
+	freeBytes := uint64(stat.F_bsize) * uint64(stat.F_bfree)
+	availBytes := uint64(stat.F_bsize) * uint64(stat.F_bavail)
+	totalBytes := uint64(stat.F_bsize) * uint64(stat.F_blocks)
+	return DiskUsage{
+		AvailBytes: availBytes,
+		TotalBytes: totalBytes,
+		UsedBytes:  totalBytes - freeBytes,
+	}, nil
+}

vendor/github.com/cockroachdb/pebble/vfs/disk_usage_unix.go

@@ -2,8 +2,8 @@
 // of this source code is governed by a BSD-style license that can be found in
 // the LICENSE file.
 
-//go:build darwin || openbsd || dragonfly || freebsd
-// +build darwin openbsd dragonfly freebsd
+//go:build darwin || dragonfly || freebsd
+// +build darwin dragonfly freebsd
 
 package vfs
 

vendor/github.com/cockroachdb/pebble/vfs/logging_fs.go

@@ -5,6 +5,7 @@
 package vfs
 
 import (
+	"fmt"
 	"io"
 	"os"
 )
@@ -38,7 +39,15 @@ func (fs *loggingFS) Create(name string) (File, error) {
 }
 
 func (fs *loggingFS) Open(name string, opts ...OpenOption) (File, error) {
-	fs.logFn("open: %s", name)
+	var optsStr string
+	if len(opts) > 0 {
+		optsStr = " (options:"
+		for i := range opts {
+			optsStr += fmt.Sprintf(" %T", opts[i])
+		}
+		optsStr += ")"
+	}
+	fs.logFn("open: %s%s", name, optsStr)
 	f, err := fs.FS.Open(name, opts...)
 	if err != nil {
 		return nil, err

vendor/github.com/cockroachdb/pebble/vfs/mem_fs.go

@@ -14,6 +14,7 @@ import (
 	"strings"
 	"sync"
 	"sync/atomic"
+	"syscall"
 	"time"
 
 	"github.com/cockroachdb/errors"
@@ -63,7 +64,8 @@ func NewStrictMem() *MemFS {
 // NewMemFile returns a memory-backed File implementation. The memory-backed
 // file takes ownership of data.
 func NewMemFile(data []byte) File {
-	n := &memNode{refs: 1}
+	n := &memNode{}
+	n.refs.Store(1)
 	n.mu.data = data
 	n.mu.modTime = time.Now()
 	return &memFile{
@@ -77,6 +79,11 @@ type MemFS struct {
 	mu   sync.Mutex
 	root *memNode
 
+	// lockFiles holds a map of open file locks. Presence in this map indicates
+	// a file lock is currently held. Keys are strings holding the path of the
+	// locked file. The stored value is untyped and  unused; only presence of
+	// the key within the map is significant.
+	lockedFiles sync.Map
 	strict      bool
 	ignoreSyncs bool
 	// Windows has peculiar semantics with respect to hard links and deleting
@@ -217,7 +224,7 @@ func (y *MemFS) Create(fullname string) (File, error) {
 	if err != nil {
 		return nil, err
 	}
-	atomic.AddInt32(&ret.n.refs, 1)
+	ret.n.refs.Add(1)
 	return ret, nil
 }
 
@@ -295,7 +302,7 @@ func (y *MemFS) open(fullname string, openForWrite bool) (File, error) {
 			Err:  oserror.ErrNotExist,
 		}
 	}
-	atomic.AddInt32(&ret.n.refs, 1)
+	ret.n.refs.Add(1)
 	return ret, nil
 }
 
@@ -335,7 +342,7 @@ func (y *MemFS) Remove(fullname string) error {
 				// Windows semantics. This ensures that we don't regress in the
 				// ordering of operations and try to remove a file while it is
 				// still open.
-				if n := atomic.LoadInt32(&child.refs); n > 0 {
+				if n := child.refs.Load(); n > 0 {
 					return oserror.ErrInvalid
 				}
 			}
@@ -456,9 +463,31 @@ func (y *MemFS) MkdirAll(dirname string, perm os.FileMode) error {
 // Lock implements FS.Lock.
 func (y *MemFS) Lock(fullname string) (io.Closer, error) {
 	// FS.Lock excludes other processes, but other processes cannot see this
-	// process' memory. We translate Lock into Create so that have the normal
-	// detection of non-existent directory paths.
-	return y.Create(fullname)
+	// process' memory. However some uses (eg, Cockroach tests) may open and
+	// close the same MemFS-backed database multiple times. We want mutual
+	// exclusion in this case too. See cockroachdb/cockroach#110645.
+	_, loaded := y.lockedFiles.Swap(fullname, nil /* the value itself is insignificant */)
+	if loaded {
+		// This file lock has already been acquired. On unix, this results in
+		// either EACCES or EAGAIN so we mimic.
+		return nil, syscall.EAGAIN
+	}
+	// Otherwise, we successfully acquired the lock. Locks are visible in the
+	// parent directory listing, and they also must be created under an existent
+	// directory. Create the path so that we have the normal detection of
+	// non-existent directory paths, and make the lock visible when listing
+	// directory entries.
+	f, err := y.Create(fullname)
+	if err != nil {
+		// "Release" the lock since we failed.
+		y.lockedFiles.Delete(fullname)
+		return nil, err
+	}
+	return &memFileLock{
+		y:        y,
+		f:        f,
+		fullname: fullname,
+	}, nil
 }
 
 // List implements FS.List.
@@ -525,7 +554,7 @@ func (*MemFS) GetDiskUsage(string) (DiskUsage, error) {
 type memNode struct {
 	name  string
 	isDir bool
-	refs  int32
+	refs  atomic.Int32
 
 	// Mutable state.
 	// - For a file: data, syncedDate, modTime: A file is only being mutated by a single goroutine,
@@ -641,7 +670,7 @@ type memFile struct {
 var _ File = (*memFile)(nil)
 
 func (f *memFile) Close() error {
-	if n := atomic.AddInt32(&f.n.refs, -1); n < 0 {
+	if n := f.n.refs.Add(-1); n < 0 {
 		panic(fmt.Sprintf("pebble: close of unopened file: %d", n))
 	}
 	f.n = nil
@@ -786,3 +815,18 @@ func (f *memFile) Fd() uintptr {
 func (f *memFile) Flush() error {
 	return nil
 }
+
+type memFileLock struct {
+	y        *MemFS
+	f        File
+	fullname string
+}
+
+func (l *memFileLock) Close() error {
+	if l.y == nil {
+		return nil
+	}
+	l.y.lockedFiles.Delete(l.fullname)
+	l.y = nil
+	return l.f.Close()
+}

vendor/github.com/cockroachdb/pebble/vfs/syncing_file.go

@@ -26,16 +26,14 @@ type syncingFile struct {
 	noSyncOnClose   bool
 	bytesPerSync    int64
 	preallocateSize int64
-	atomic          struct {
-		// The offset at which dirty data has been written.
-		offset int64
-		// The offset at which data has been synced. Note that if SyncFileRange is
-		// being used, the periodic syncing of data during writing will only ever
-		// sync up to offset-1MB. This is done to avoid rewriting the tail of the
-		// file multiple times, but has the side effect of ensuring that Close will
-		// sync the file's metadata.
-		syncOffset int64
-	}
+	// The offset at which dirty data has been written.
+	offset atomic.Int64
+	// The offset at which data has been synced. Note that if SyncFileRange is
+	// being used, the periodic syncing of data during writing will only ever
+	// sync up to offset-1MB. This is done to avoid rewriting the tail of the
+	// file multiple times, but has the side effect of ensuring that Close will
+	// sync the file's metadata.
+	syncOffset         atomic.Int64
 	preallocatedBlocks int64
 }
 
@@ -54,13 +52,13 @@ func NewSyncingFile(f File, opts SyncingFileOptions) File {
 	}
 	// Ensure a file that is opened and then closed will be synced, even if no
 	// data has been written to it.
-	s.atomic.syncOffset = -1
+	s.syncOffset.Store(-1)
 	return s
 }
 
 // NB: syncingFile.Write is unsafe for concurrent use!
 func (f *syncingFile) Write(p []byte) (n int, err error) {
-	_ = f.preallocate(atomic.LoadInt64(&f.atomic.offset))
+	_ = f.preallocate(f.offset.Load())
 
 	n, err = f.File.Write(p)
 	if err != nil {
@@ -68,7 +66,7 @@ func (f *syncingFile) Write(p []byte) (n int, err error) {
 	}
 	// The offset is updated atomically so that it can be accessed safely from
 	// Sync.
-	atomic.AddInt64(&f.atomic.offset, int64(n))
+	f.offset.Add(int64(n))
 	if err := f.maybeSync(); err != nil {
 		return 0, err
 	}
@@ -93,11 +91,11 @@ func (f *syncingFile) preallocate(offset int64) error {
 
 func (f *syncingFile) ratchetSyncOffset(offset int64) {
 	for {
-		syncOffset := atomic.LoadInt64(&f.atomic.syncOffset)
+		syncOffset := f.syncOffset.Load()
 		if syncOffset >= offset {
 			return
 		}
-		if atomic.CompareAndSwapInt64(&f.atomic.syncOffset, syncOffset, offset) {
+		if f.syncOffset.CompareAndSwap(syncOffset, offset) {
 			return
 		}
 	}
@@ -109,7 +107,7 @@ func (f *syncingFile) Sync() error {
 	// offset, we still need to call the underlying file's sync for persistence
 	// guarantees which are not provided by SyncTo (or by sync_file_range on
 	// Linux).
-	f.ratchetSyncOffset(atomic.LoadInt64(&f.atomic.offset))
+	f.ratchetSyncOffset(f.offset.Load())
 	return f.SyncData()
 }
 
@@ -127,7 +125,7 @@ func (f *syncingFile) maybeSync() error {
 	//   Xfs does neighbor page flushing outside of the specified ranges. We
 	//   need to make sure sync range is far from the write offset.
 	const syncRangeBuffer = 1 << 20 // 1 MB
-	offset := atomic.LoadInt64(&f.atomic.offset)
+	offset := f.offset.Load()
 	if offset <= syncRangeBuffer {
 		return nil
 	}
@@ -135,7 +133,7 @@ func (f *syncingFile) maybeSync() error {
 	const syncRangeAlignment = 4 << 10 // 4 KB
 	syncToOffset := offset - syncRangeBuffer
 	syncToOffset -= syncToOffset % syncRangeAlignment
-	syncOffset := atomic.LoadInt64(&f.atomic.syncOffset)
+	syncOffset := f.syncOffset.Load()
 	if syncToOffset < 0 || (syncToOffset-syncOffset) < f.bytesPerSync {
 		return nil
 	}
@@ -167,7 +165,7 @@ func (f *syncingFile) Close() error {
 	// caller has not called Sync since the last write, syncOffset is guaranteed
 	// to be less than atomic.offset. This ensures we fall into the below
 	// conditional and perform a full sync to durably persist the file.
-	if off := atomic.LoadInt64(&f.atomic.offset); off > atomic.LoadInt64(&f.atomic.syncOffset) {
+	if off := f.offset.Load(); off > f.syncOffset.Load() {
 		// There's still remaining dirty data.
 
 		if f.noSyncOnClose {