@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/internal/poll/fd_windows.go

@@ -11,7 +11,6 @@ import (
 	"io"
 	"runtime"
 	"sync"
-	"sync/atomic"
 	"syscall"
 	"unicode/utf16"
 	"unicode/utf8"
@@ -23,36 +22,41 @@ var (
 	ioSync  uint64
 )
 
-// This package uses the SetFileCompletionNotificationModes Windows
-// API to skip calling GetQueuedCompletionStatus if an IO operation
-// completes synchronously. There is a known bug where
-// SetFileCompletionNotificationModes crashes on some systems (see
-// https://support.microsoft.com/kb/2568167 for details).
-
-var socketCanUseSetFileCompletionNotificationModes bool // determines is SetFileCompletionNotificationModes is present and sockets can safely use it
-
-// checkSetFileCompletionNotificationModes verifies that
-// SetFileCompletionNotificationModes Windows API is present
-// on the system and is safe to use.
+// ifsHandlesOnly returns true if the system only has IFS handles for TCP sockets.
 // See https://support.microsoft.com/kb/2568167 for details.
-func checkSetFileCompletionNotificationModes() {
-	err := syscall.LoadSetFileCompletionNotificationModes()
-	if err != nil {
-		return
-	}
+var ifsHandlesOnly = sync.OnceValue(func() bool {
 	protos := [2]int32{syscall.IPPROTO_TCP, 0}
 	var buf [32]syscall.WSAProtocolInfo
 	len := uint32(unsafe.Sizeof(buf))
 	n, err := syscall.WSAEnumProtocols(&protos[0], &buf[0], &len)
 	if err != nil {
-		return
+		return false
 	}
-	for i := int32(0); i < n; i++ {
+	for i := range n {
 		if buf[i].ServiceFlags1&syscall.XP1_IFS_HANDLES == 0 {
-			return
+			return false
 		}
 	}
-	socketCanUseSetFileCompletionNotificationModes = true
+	return true
+})
+
+// canSkipCompletionPortOnSuccess returns true if we use FILE_SKIP_COMPLETION_PORT_ON_SUCCESS for the given handle.
+// See https://support.microsoft.com/kb/2568167 for details.
+func canSkipCompletionPortOnSuccess(h syscall.Handle, isSocket bool) bool {
+	if !isSocket {
+		// Non-socket handles can use SetFileCompletionNotificationModes without problems.
+		return true
+	}
+	if ifsHandlesOnly() {
+		// If the system only has IFS handles for TCP sockets, then there is nothing else to check.
+		return true
+	}
+	var info syscall.WSAProtocolInfo
+	size := int32(unsafe.Sizeof(info))
+	if syscall.Getsockopt(h, syscall.SOL_SOCKET, windows.SO_PROTOCOL_INFOW, (*byte)(unsafe.Pointer(&info)), &size) != nil {
+		return false
+	}
+	return info.ServiceFlags1&syscall.XP1_IFS_HANDLES != 0
 }
 
 // InitWSA initiates the use of the Winsock DLL by the current process.
@@ -64,7 +68,6 @@ var InitWSA = sync.OnceFunc(func() {
 	if e != nil {
 		initErr = e
 	}
-	checkSetFileCompletionNotificationModes()
 })
 
 // operation contains superset of data necessary to perform all async IO.
@@ -78,6 +81,11 @@ type operation struct {
 	mode       int32
 }
 
+func (o *operation) setOffset(off int64) {
+	o.o.OffsetHigh = uint32(off >> 32)
+	o.o.Offset = uint32(off)
+}
+
 func (fd *FD) overlapped(o *operation) *syscall.Overlapped {
 	if fd.isBlocking {
 		// Don't return the overlapped object if the file handle
@@ -153,7 +161,6 @@ func newWSAMsg(p []byte, oob []byte, flags int, rsa *wsaRsa) *windows.WSAMsg {
 	// The returned object can't be allocated in the stack because it is accessed asynchronously
 	// by Windows in between several system calls. If the stack frame is moved while that happens,
 	// then Windows may access invalid memory.
-	// TODO(qmuntal): investigate using runtime.Pinner keeping this path allocation-free.
 
 	// Use a pool to reuse allocations.
 	msg := wsaMsgPool.Get().(*windows.WSAMsg)
@@ -212,12 +219,10 @@ var operationPool = sync.Pool{
 	},
 }
 
-// waitIO waits for the IO operation o to complete.
+// waitIO waits for the IO operation to complete,
+// handling cancellation if necessary.
 func (fd *FD) waitIO(o *operation) error {
-	if fd.isBlocking {
-		panic("can't wait on blocking operations")
-	}
-	if !fd.pollable() {
+	if o.o.HEvent != 0 {
 		// The overlapped handle is not added to the runtime poller,
 		// the only way to wait for the IO to complete is block until
 		// the overlapped event is signaled.
@@ -227,50 +232,33 @@ func (fd *FD) waitIO(o *operation) error {
 	// Wait for our request to complete.
 	err := fd.pd.wait(int(o.mode), fd.isFile)
 	switch err {
-	case nil, ErrNetClosing, ErrFileClosing, ErrDeadlineExceeded:
-		// No other error is expected.
+	case nil:
+		// IO completed successfully.
+	case ErrNetClosing, ErrFileClosing, ErrDeadlineExceeded:
+		// IO interrupted by "close" or "timeout", cancel our request.
+		// ERROR_NOT_FOUND can be returned when the request succeded
+		// between the time wait returned and CancelIoEx was executed.
+		if err := syscall.CancelIoEx(fd.Sysfd, &o.o); err != nil && err != syscall.ERROR_NOT_FOUND {
+			// TODO(brainman): maybe do something else, but panic.
+			panic(err)
+		}
+		fd.pd.waitCanceled(int(o.mode))
 	default:
+		// No other error is expected.
 		panic("unexpected runtime.netpoll error: " + err.Error())
 	}
 	return err
 }
 
-// cancelIO cancels the IO operation o and waits for it to complete.
-func (fd *FD) cancelIO(o *operation) {
-	if !fd.pollable() {
-		return
-	}
-	// Cancel our request.
-	err := syscall.CancelIoEx(fd.Sysfd, &o.o)
-	// Assuming ERROR_NOT_FOUND is returned, if IO is completed.
-	if err != nil && err != syscall.ERROR_NOT_FOUND {
-		// TODO(brainman): maybe do something else, but panic.
-		panic(err)
-	}
-	fd.pd.waitCanceled(int(o.mode))
-}
-
-// pin pins ptr for the duration of the IO operation.
-// If fd is in blocking mode, pin does nothing.
-func (fd *FD) pin(mode int, ptr any) {
-	if fd.isBlocking {
-		return
-	}
-	if mode == 'r' {
-		fd.readPinner.Pin(ptr)
-	} else {
-		fd.writePinner.Pin(ptr)
-	}
-}
-
 // execIO executes a single IO operation o.
 // It supports both synchronous and asynchronous IO.
-func (fd *FD) execIO(mode int, submit func(o *operation) (uint32, error)) (int, error) {
-	if mode == 'r' {
-		defer fd.readPinner.Unpin()
-	} else {
-		defer fd.writePinner.Unpin()
-	}
+// pinPtrs is a list of pointers that will be pinned to a fixed location in memory
+// during the lifetime of the operation.
+func (fd *FD) execIO(
+	mode int,
+	submit func(o *operation) (uint32, error),
+	pinPtrs ...any,
+) (int, error) {
 	// Notify runtime netpoll about starting IO.
 	err := fd.pd.prepare(mode, fd.isFile)
 	if err != nil {
@@ -279,42 +267,47 @@ func (fd *FD) execIO(mode int, submit func(o *operation) (uint32, error)) (int,
 	o := operationPool.Get().(*operation)
 	defer operationPool.Put(o)
 	*o = operation{
-		o: syscall.Overlapped{
-			OffsetHigh: uint32(fd.offset >> 32),
-			Offset:     uint32(fd.offset),
-		},
 		runtimeCtx: fd.pd.runtimeCtx,
 		mode:       int32(mode),
 	}
-	// Start IO.
-	if !fd.isBlocking && !fd.pollable() {
-		// If the handle is opened for overlapped IO but we can't
-		// use the runtime poller, then we need to use an
-		// event to wait for the IO to complete.
-		h, err := windows.CreateEvent(nil, 0, 0, nil)
-		if err != nil {
-			// This shouldn't happen when all CreateEvent arguments are zero.
-			panic(err)
+	o.setOffset(fd.offset)
+	if !fd.isBlocking {
+		var pinner *runtime.Pinner
+		if mode == 'r' {
+			pinner = &fd.readPinner
+		} else {
+			pinner = &fd.writePinner
+		}
+		defer pinner.Unpin()
+
+		pinner.Pin(o)
+		for _, ptr := range pinPtrs {
+			pinner.Pin(ptr)
+		}
+
+		if !fd.associated {
+			// If the handle is opened for overlapped IO but we can't
+			// use the runtime poller, then we need to use an
+			// event to wait for the IO to complete.
+			h, err := windows.CreateEvent(nil, 0, 0, nil)
+			if err != nil {
+				// This shouldn't happen when all CreateEvent arguments are zero.
+				panic(err)
+			}
+			// Set the low bit so that the external IOCP doesn't receive the completion packet.
+			o.o.HEvent = h | 1
+			defer syscall.CloseHandle(h)
 		}
-		// Set the low bit so that the external IOCP doesn't receive the completion packet.
-		o.o.HEvent = h | 1
-		defer syscall.CloseHandle(h)
 	}
-	fd.pin(mode, o)
+	// Start IO.
 	qty, err := submit(o)
 	var waitErr error
 	// Blocking operations shouldn't return ERROR_IO_PENDING.
 	// Continue without waiting if that happens.
-	if !fd.isBlocking && (err == syscall.ERROR_IO_PENDING || (err == nil && !fd.skipSyncNotif)) {
+	if !fd.isBlocking && (err == syscall.ERROR_IO_PENDING || (err == nil && fd.waitOnSuccess)) {
 		// IO started asynchronously or completed synchronously but
 		// a sync notification is required. Wait for it to complete.
 		waitErr = fd.waitIO(o)
-		if waitErr != nil {
-			// IO interrupted by "close" or "timeout".
-			fd.cancelIO(o)
-			// We issued a cancellation request, but the IO operation may still succeeded
-			// before the cancellation request runs.
-		}
 		if fd.isFile {
 			err = windows.GetOverlappedResult(fd.Sysfd, &o.o, &qty, false)
 		} else {
@@ -372,7 +365,9 @@ type FD struct {
 	// Semaphore signaled when file is closed.
 	csema uint32
 
-	skipSyncNotif bool
+	// Don't wait from completion port notifications for successful
+	// operations that complete synchronously.
+	waitOnSuccess bool
 
 	// Whether this is a streaming descriptor, as opposed to a
 	// packet-based descriptor like a UDP socket.
@@ -395,7 +390,8 @@ type FD struct {
 	// Whether FILE_FLAG_OVERLAPPED was not set when opening the file.
 	isBlocking bool
 
-	disassociated atomic.Bool
+	// Whether the handle is currently associated with the IOCP.
+	associated bool
 
 	// readPinner and writePinner are automatically unpinned
 	// before execIO returns.
@@ -422,13 +418,7 @@ func (fd *FD) setOffset(off int64) {
 
 // addOffset adds the given offset to the current offset.
 func (fd *FD) addOffset(off int) {
-	fd.setOffset(fd.offset + int64(off))
-}
-
-// pollable should be used instead of fd.pd.pollable(),
-// as it is aware of the disassociated state.
-func (fd *FD) pollable() bool {
-	return fd.pd.pollable() && !fd.disassociated.Load()
+	fd.offset += int64(off)
 }
 
 // fileKind describes the kind of file.
@@ -439,7 +429,6 @@ const (
 	kindFile
 	kindConsole
 	kindPipe
-	kindFileNet
 )
 
 // Init initializes the FD. The Sysfd field should already be set.
@@ -460,8 +449,6 @@ func (fd *FD) Init(net string, pollable bool) error {
 		fd.kind = kindConsole
 	case "pipe":
 		fd.kind = kindPipe
-	case "file+net":
-		fd.kind = kindFileNet
 	default:
 		// We don't actually care about the various network types.
 		fd.kind = kindNet
@@ -473,6 +460,12 @@ func (fd *FD) Init(net string, pollable bool) error {
 		return nil
 	}
 
+	// The default behavior of the Windows I/O manager is to queue a completion
+	// port entry for successful operations that complete synchronously when
+	// the handle is opened for overlapped I/O. We will try to disable that
+	// behavior below, as it requires an extra syscall.
+	fd.waitOnSuccess = true
+
 	if fd.KeepFileCompletionModes {
 		// Query the existing skip-success mode so we don't wait for a
 		// suppressed completion or skip waiting for an expected one.
@@ -483,10 +476,10 @@ func (fd *FD) Init(net string, pollable bool) error {
 			// packet on success nor skipping it is safe. Leave the handle
 			// unassociated and use explicit events for pending I/O instead.
 			// Inline success needs no wait, and deadlines are unavailable.
-			fd.skipSyncNotif = true
+			fd.waitOnSuccess = false
 			return nil
 		}
-		fd.skipSyncNotif = info.Flags&syscall.FILE_SKIP_COMPLETION_PORT_ON_SUCCESS != 0
+		fd.waitOnSuccess = info.Flags&syscall.FILE_SKIP_COMPLETION_PORT_ON_SUCCESS == 0
 	}
 
 	// It is safe to add overlapped handles that also perform I/O
@@ -496,26 +489,42 @@ func (fd *FD) Init(net string, pollable bool) error {
 	if err != nil {
 		return err
 	}
-	if !fd.KeepFileCompletionModes && (fd.kind != kindNet || socketCanUseSetFileCompletionNotificationModes) {
-		// Non-socket handles can use SetFileCompletionNotificationModes without problems.
-		err := syscall.SetFileCompletionNotificationModes(fd.Sysfd,
-			syscall.FILE_SKIP_SET_EVENT_ON_HANDLE|syscall.FILE_SKIP_COMPLETION_PORT_ON_SUCCESS,
-		)
-		fd.skipSyncNotif = err == nil
+	fd.associated = true
+
+	if !fd.KeepFileCompletionModes {
+		// FILE_SKIP_SET_EVENT_ON_HANDLE is always safe to use. We don't use that feature
+		// and it adds some overhead to the Windows I/O manager.
+		// See https://devblogs.microsoft.com/oldnewthing/20200221-00/?p=103466.
+		modes := uint8(syscall.FILE_SKIP_SET_EVENT_ON_HANDLE)
+		if canSkipCompletionPortOnSuccess(fd.Sysfd, fd.kind == kindNet) {
+			modes |= syscall.FILE_SKIP_COMPLETION_PORT_ON_SUCCESS
+		}
+		if syscall.SetFileCompletionNotificationModes(fd.Sysfd, modes) == nil {
+			if modes&syscall.FILE_SKIP_COMPLETION_PORT_ON_SUCCESS != 0 {
+				fd.waitOnSuccess = false
+			}
+		}
 	}
 	return nil
 }
 
 // DisassociateIOCP disassociates the file handle from the IOCP.
 // The disassociate operation will not succeed if there is any
-// in-progress IO operation on the file handle.
+// in-progress I/O operation on the file handle.
 func (fd *FD) DisassociateIOCP() error {
-	if err := fd.incref(); err != nil {
+	// There is a small race window between execIO checking fd.disassociated and
+	// DisassociateIOCP setting it. NtSetInformationFile will fail anyway if
+	// there is any in-progress I/O operation, so just take a read-write lock
+	// to ensure there is no in-progress I/O and fail early if we can't get the lock.
+	if ok, err := fd.tryReadWriteLock(); err != nil || !ok {
+		if err == nil {
+			err = errors.New("can't disassociate the handle while there is in-progress I/O")
+		}
 		return err
 	}
-	defer fd.decref()
+	defer fd.readWriteUnlock()
 
-	if fd.isBlocking || !fd.pollable() {
+	if !fd.associated {
 		// Nothing to disassociate.
 		return nil
 	}
@@ -524,7 +533,8 @@ func (fd *FD) DisassociateIOCP() error {
 	if err := windows.NtSetInformationFile(fd.Sysfd, &windows.IO_STATUS_BLOCK{}, unsafe.Pointer(&info), uint32(unsafe.Sizeof(info)), windows.FileReplaceCompletionInformation); err != nil {
 		return err
 	}
-	fd.disassociated.Store(true)
+	// tryReadWriteLock means we have exclusive access to fd.
+	fd.associated = false
 	// Don't call fd.pd.close(), it would be too racy.
 	// There is no harm on leaving fd.pd open until Close is called.
 	return nil
@@ -539,7 +549,7 @@ func (fd *FD) destroy() error {
 	fd.pd.close()
 	var err error
 	switch fd.kind {
-	case kindNet, kindFileNet:
+	case kindNet:
 		// The net package uses the CloseFunc variable for testing.
 		err = CloseFunc(fd.Sysfd)
 	default:
@@ -574,6 +584,13 @@ func (fd *FD) Close() error {
 // See golang.org/issue/26923.
 const maxRW = 1 << 30 // 1GB is large enough and keeps subsequent reads aligned
 
+func pinPtrsFromBuf(buf []byte) []any {
+	if len(buf) == 0 {
+		return nil
+	}
+	return []any{unsafe.SliceData(buf)}
+}
+
 // Read implements io.Reader.
 func (fd *FD) Read(buf []byte) (int, error) {
 	if fd.kind == kindFile {
@@ -588,10 +605,6 @@ func (fd *FD) Read(buf []byte) (int, error) {
 		defer fd.readUnlock()
 	}
 
-	if len(buf) > 0 {
-		fd.pin('r', &buf[0])
-	}
-
 	if len(buf) > maxRW {
 		buf = buf[:maxRW]
 	}
@@ -605,7 +618,7 @@ func (fd *FD) Read(buf []byte) (int, error) {
 		n, err = fd.execIO('r', func(o *operation) (qty uint32, err error) {
 			err = syscall.ReadFile(fd.Sysfd, buf, &qty, fd.overlapped(o))
 			return qty, err
-		})
+		}, pinPtrsFromBuf(buf)...)
 		fd.addOffset(n)
 		switch err {
 		case syscall.ERROR_HANDLE_EOF:
@@ -621,7 +634,7 @@ func (fd *FD) Read(buf []byte) (int, error) {
 			var flags uint32
 			err = syscall.WSARecv(fd.Sysfd, newWsaBuf(buf), 1, &qty, &flags, &o.o, nil)
 			return qty, err
-		})
+		}, pinPtrsFromBuf(buf)...)
 		if race.Enabled {
 			race.Acquire(unsafe.Pointer(&ioSync))
 		}
@@ -718,35 +731,28 @@ func (fd *FD) Pread(buf []byte, off int64) (int, error) {
 	}
 	defer fd.readWriteUnlock()
 
-	if len(buf) > 0 {
-		fd.pin('r', &buf[0])
-	}
-
 	if len(buf) > maxRW {
 		buf = buf[:maxRW]
 	}
 
-	if fd.isBlocking {
-		curoffset, err := syscall.Seek(fd.Sysfd, 0, io.SeekCurrent)
-		if err != nil {
-			return 0, err
-		}
-		defer syscall.Seek(fd.Sysfd, curoffset, io.SeekStart)
-		defer fd.setOffset(curoffset)
-	} else {
+	n, err := fd.execIO('r', func(o *operation) (qty uint32, err error) {
 		// Overlapped handles don't have the file pointer updated
 		// when performing I/O operations, so there is no need to
 		// call Seek to reset the file pointer.
 		// Also, some overlapped file handles don't support seeking.
 		// See https://go.dev/issues/74951.
-		curoffset := fd.offset
-		defer fd.setOffset(curoffset)
-	}
-	fd.setOffset(off)
-	n, err := fd.execIO('r', func(o *operation) (qty uint32, err error) {
+		if fd.isBlocking {
+			curoffset, err := syscall.Seek(fd.Sysfd, 0, io.SeekCurrent)
+			if err != nil {
+				return 0, err
+			}
+			defer syscall.Seek(fd.Sysfd, curoffset, io.SeekStart)
+		}
+		o.setOffset(off)
+
 		err = syscall.ReadFile(fd.Sysfd, buf, &qty, &o.o)
 		return qty, err
-	})
+	}, pinPtrsFromBuf(buf)...)
 	if err == syscall.ERROR_HANDLE_EOF {
 		err = io.EOF
 	}
@@ -769,15 +775,13 @@ func (fd *FD) ReadFrom(buf []byte) (int, syscall.Sockaddr, error) {
 	}
 	defer fd.readUnlock()
 
-	fd.pin('r', &buf[0])
-
 	rsa := newWSARsa()
 	defer wsaRsaPool.Put(rsa)
 	n, err := fd.execIO('r', func(o *operation) (qty uint32, err error) {
 		var flags uint32
 		err = syscall.WSARecvFrom(fd.Sysfd, newWsaBuf(buf), 1, &qty, &flags, &rsa.name, &rsa.namelen, &o.o, nil)
 		return qty, err
-	})
+	}, unsafe.SliceData(buf), rsa)
 	err = fd.eofError(n, err)
 	if err != nil {
 		return n, nil, err
@@ -799,15 +803,13 @@ func (fd *FD) ReadFromInet4(buf []byte, sa4 *syscall.SockaddrInet4) (int, error)
 	}
 	defer fd.readUnlock()
 
-	fd.pin('r', &buf[0])
-
 	rsa := newWSARsa()
 	defer wsaRsaPool.Put(rsa)
 	n, err := fd.execIO('r', func(o *operation) (qty uint32, err error) {
 		var flags uint32
 		err = syscall.WSARecvFrom(fd.Sysfd, newWsaBuf(buf), 1, &qty, &flags, &rsa.name, &rsa.namelen, &o.o, nil)
 		return qty, err
-	})
+	}, unsafe.SliceData(buf), rsa)
 	err = fd.eofError(n, err)
 	if err != nil {
 		return n, err
@@ -829,15 +831,13 @@ func (fd *FD) ReadFromInet6(buf []byte, sa6 *syscall.SockaddrInet6) (int, error)
 	}
 	defer fd.readUnlock()
 
-	fd.pin('r', &buf[0])
-
 	rsa := newWSARsa()
 	defer wsaRsaPool.Put(rsa)
 	n, err := fd.execIO('r', func(o *operation) (qty uint32, err error) {
 		var flags uint32
 		err = syscall.WSARecvFrom(fd.Sysfd, newWsaBuf(buf), 1, &qty, &flags, &rsa.name, &rsa.namelen, &o.o, nil)
 		return qty, err
-	})
+	}, unsafe.SliceData(buf), rsa)
 	err = fd.eofError(n, err)
 	if err != nil {
 		return n, err
@@ -860,9 +860,6 @@ func (fd *FD) Write(buf []byte) (int, error) {
 		defer fd.writeUnlock()
 	}
 
-	if len(buf) > 0 {
-		fd.pin('w', &buf[0])
-	}
 	var ntotal int
 	for {
 		max := len(buf)
@@ -879,7 +876,7 @@ func (fd *FD) Write(buf []byte) (int, error) {
 			n, err = fd.execIO('w', func(o *operation) (qty uint32, err error) {
 				err = syscall.WriteFile(fd.Sysfd, b, &qty, fd.overlapped(o))
 				return qty, err
-			})
+			}, pinPtrsFromBuf(b)...)
 			fd.addOffset(n)
 		case kindNet:
 			if race.Enabled {
@@ -888,7 +885,7 @@ func (fd *FD) Write(buf []byte) (int, error) {
 			n, err = fd.execIO('w', func(o *operation) (qty uint32, err error) {
 				err = syscall.WSASend(fd.Sysfd, newWsaBuf(b), 1, &qty, 0, &o.o, nil)
 				return qty, err
-			})
+			}, pinPtrsFromBuf(b)...)
 		}
 		ntotal += n
 		if ntotal == len(buf) || err != nil {
@@ -955,38 +952,31 @@ func (fd *FD) Pwrite(buf []byte, off int64) (int, error) {
 	}
 	defer fd.readWriteUnlock()
 
-	if len(buf) > 0 {
-		fd.pin('w', &buf[0])
-	}
-
-	if fd.isBlocking {
-		curoffset, err := syscall.Seek(fd.Sysfd, 0, io.SeekCurrent)
-		if err != nil {
-			return 0, err
-		}
-		defer syscall.Seek(fd.Sysfd, curoffset, io.SeekStart)
-		defer fd.setOffset(curoffset)
-	} else {
-		// Overlapped handles don't have the file pointer updated
-		// when performing I/O operations, so there is no need to
-		// call Seek to reset the file pointer.
-		// Also, some overlapped file handles don't support seeking.
-		// See https://go.dev/issues/74951.
-		curoffset := fd.offset
-		defer fd.setOffset(curoffset)
-	}
-
 	var ntotal int
 	for {
 		max := len(buf)
 		if max-ntotal > maxRW {
 			max = ntotal + maxRW
 		}
-		fd.setOffset(off + int64(ntotal))
+		b := buf[ntotal:max]
 		n, err := fd.execIO('w', func(o *operation) (qty uint32, err error) {
-			err = syscall.WriteFile(fd.Sysfd, buf[ntotal:max], &qty, &o.o)
+			// Overlapped handles don't have the file pointer updated
+			// when performing I/O operations, so there is no need to
+			// call Seek to reset the file pointer.
+			// Also, some overlapped file handles don't support seeking.
+			// See https://go.dev/issues/74951.
+			if fd.isBlocking {
+				curoffset, err := syscall.Seek(fd.Sysfd, 0, io.SeekCurrent)
+				if err != nil {
+					return 0, err
+				}
+				defer syscall.Seek(fd.Sysfd, curoffset, io.SeekStart)
+			}
+			o.setOffset(off + int64(ntotal))
+
+			err = syscall.WriteFile(fd.Sysfd, b, &qty, &o.o)
 			return qty, err
-		})
+		}, pinPtrsFromBuf(b)...)
 		if n > 0 {
 			ntotal += n
 		}
@@ -1038,8 +1028,6 @@ func (fd *FD) WriteTo(buf []byte, sa syscall.Sockaddr) (int, error) {
 		return n, err
 	}
 
-	fd.pin('w', &buf[0])
-
 	ntotal := 0
 	for len(buf) > 0 {
 		b := buf
@@ -1049,7 +1037,7 @@ func (fd *FD) WriteTo(buf []byte, sa syscall.Sockaddr) (int, error) {
 		n, err := fd.execIO('w', func(o *operation) (qty uint32, err error) {
 			err = syscall.WSASendto(fd.Sysfd, newWsaBuf(b), 1, &qty, 0, sa, &o.o, nil)
 			return qty, err
-		})
+		}, unsafe.SliceData(b))
 		ntotal += int(n)
 		if err != nil {
 			return ntotal, err
@@ -1075,8 +1063,6 @@ func (fd *FD) WriteToInet4(buf []byte, sa4 *syscall.SockaddrInet4) (int, error)
 		return n, err
 	}
 
-	fd.pin('w', &buf[0])
-
 	ntotal := 0
 	for len(buf) > 0 {
 		b := buf
@@ -1086,7 +1072,7 @@ func (fd *FD) WriteToInet4(buf []byte, sa4 *syscall.SockaddrInet4) (int, error)
 		n, err := fd.execIO('w', func(o *operation) (qty uint32, err error) {
 			err = windows.WSASendtoInet4(fd.Sysfd, newWsaBuf(b), 1, &qty, 0, sa4, &o.o, nil)
 			return qty, err
-		})
+		}, unsafe.SliceData(b))
 		ntotal += int(n)
 		if err != nil {
 			return ntotal, err
@@ -1112,8 +1098,6 @@ func (fd *FD) WriteToInet6(buf []byte, sa6 *syscall.SockaddrInet6) (int, error)
 		return n, err
 	}
 
-	fd.pin('w', &buf[0])
-
 	ntotal := 0
 	for len(buf) > 0 {
 		b := buf
@@ -1123,7 +1107,7 @@ func (fd *FD) WriteToInet6(buf []byte, sa6 *syscall.SockaddrInet6) (int, error)
 		n, err := fd.execIO('w', func(o *operation) (qty uint32, err error) {
 			err = windows.WSASendtoInet6(fd.Sysfd, newWsaBuf(b), 1, &qty, 0, sa6, &o.o, nil)
 			return qty, err
-		})
+		}, unsafe.SliceData(b))
 		ntotal += int(n)
 		if err != nil {
 			return ntotal, err
@@ -1409,7 +1393,7 @@ func (fd *FD) ReadMsg(p []byte, oob []byte, flags int) (int, int, int, syscall.S
 	n, err := fd.execIO('r', func(o *operation) (qty uint32, err error) {
 		err = windows.WSARecvMsg(fd.Sysfd, msg, &qty, &o.o, nil)
 		return qty, err
-	})
+	}, rsa, msg)
 	err = fd.eofError(n, err)
 	var sa syscall.Sockaddr
 	if err == nil {
@@ -1436,7 +1420,7 @@ func (fd *FD) ReadMsgInet4(p []byte, oob []byte, flags int, sa4 *syscall.Sockadd
 	n, err := fd.execIO('r', func(o *operation) (qty uint32, err error) {
 		err = windows.WSARecvMsg(fd.Sysfd, msg, &qty, &o.o, nil)
 		return qty, err
-	})
+	}, rsa, msg)
 	err = fd.eofError(n, err)
 	if err == nil {
 		rawToSockaddrInet4(msg.Name, sa4)
@@ -1462,7 +1446,7 @@ func (fd *FD) ReadMsgInet6(p []byte, oob []byte, flags int, sa6 *syscall.Sockadd
 	n, err := fd.execIO('r', func(o *operation) (qty uint32, err error) {
 		err = windows.WSARecvMsg(fd.Sysfd, msg, &qty, &o.o, nil)
 		return qty, err
-	})
+	}, rsa, msg)
 	err = fd.eofError(n, err)
 	if err == nil {
 		rawToSockaddrInet6(msg.Name, sa6)
@@ -1496,7 +1480,7 @@ func (fd *FD) WriteMsg(p []byte, oob []byte, sa syscall.Sockaddr) (int, int, err
 	n, err := fd.execIO('w', func(o *operation) (qty uint32, err error) {
 		err = windows.WSASendMsg(fd.Sysfd, msg, 0, nil, &o.o, nil)
 		return qty, err
-	})
+	}, rsa, msg)
 	return n, int(msg.Control.Len), err
 }
 
@@ -1522,7 +1506,7 @@ func (fd *FD) WriteMsgInet4(p []byte, oob []byte, sa *syscall.SockaddrInet4) (in
 	n, err := fd.execIO('w', func(o *operation) (qty uint32, err error) {
 		err = windows.WSASendMsg(fd.Sysfd, msg, 0, nil, &o.o, nil)
 		return qty, err
-	})
+	}, rsa, msg)
 	return n, int(msg.Control.Len), err
 }
 
@@ -1548,7 +1532,7 @@ func (fd *FD) WriteMsgInet6(p []byte, oob []byte, sa *syscall.SockaddrInet6) (in
 	n, err := fd.execIO('w', func(o *operation) (qty uint32, err error) {
 		err = windows.WSASendMsg(fd.Sysfd, msg, 0, nil, &o.o, nil)
 		return qty, err
-	})
+	}, rsa, msg)
 	return n, int(msg.Control.Len), err
 }