mirror of
https://github.com/autc04/Retro68.git
synced 2024-09-08 20:55:01 +00:00
185 lines
4.7 KiB
Go
185 lines
4.7 KiB
Go
// Copyright 2013 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package net
|
|
|
|
import "sync/atomic"
|
|
|
|
// fdMutex is a specialized synchronization primitive
|
|
// that manages lifetime of an fd and serializes access
|
|
// to Read and Write methods on netFD.
|
|
type fdMutex struct {
|
|
state uint64
|
|
rsema uint32
|
|
wsema uint32
|
|
}
|
|
|
|
// fdMutex.state is organized as follows:
|
|
// 1 bit - whether netFD is closed, if set all subsequent lock operations will fail.
|
|
// 1 bit - lock for read operations.
|
|
// 1 bit - lock for write operations.
|
|
// 20 bits - total number of references (read+write+misc).
|
|
// 20 bits - number of outstanding read waiters.
|
|
// 20 bits - number of outstanding write waiters.
|
|
const (
|
|
mutexClosed = 1 << 0
|
|
mutexRLock = 1 << 1
|
|
mutexWLock = 1 << 2
|
|
mutexRef = 1 << 3
|
|
mutexRefMask = (1<<20 - 1) << 3
|
|
mutexRWait = 1 << 23
|
|
mutexRMask = (1<<20 - 1) << 23
|
|
mutexWWait = 1 << 43
|
|
mutexWMask = (1<<20 - 1) << 43
|
|
)
|
|
|
|
// Read operations must do RWLock(true)/RWUnlock(true).
|
|
// Write operations must do RWLock(false)/RWUnlock(false).
|
|
// Misc operations must do Incref/Decref. Misc operations include functions like
|
|
// setsockopt and setDeadline. They need to use Incref/Decref to ensure that
|
|
// they operate on the correct fd in presence of a concurrent Close call
|
|
// (otherwise fd can be closed under their feet).
|
|
// Close operation must do IncrefAndClose/Decref.
|
|
|
|
// RWLock/Incref return whether fd is open.
|
|
// RWUnlock/Decref return whether fd is closed and there are no remaining references.
|
|
|
|
func (mu *fdMutex) Incref() bool {
|
|
for {
|
|
old := atomic.LoadUint64(&mu.state)
|
|
if old&mutexClosed != 0 {
|
|
return false
|
|
}
|
|
new := old + mutexRef
|
|
if new&mutexRefMask == 0 {
|
|
panic("net: inconsistent fdMutex")
|
|
}
|
|
if atomic.CompareAndSwapUint64(&mu.state, old, new) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
|
|
func (mu *fdMutex) IncrefAndClose() bool {
|
|
for {
|
|
old := atomic.LoadUint64(&mu.state)
|
|
if old&mutexClosed != 0 {
|
|
return false
|
|
}
|
|
// Mark as closed and acquire a reference.
|
|
new := (old | mutexClosed) + mutexRef
|
|
if new&mutexRefMask == 0 {
|
|
panic("net: inconsistent fdMutex")
|
|
}
|
|
// Remove all read and write waiters.
|
|
new &^= mutexRMask | mutexWMask
|
|
if atomic.CompareAndSwapUint64(&mu.state, old, new) {
|
|
// Wake all read and write waiters,
|
|
// they will observe closed flag after wakeup.
|
|
for old&mutexRMask != 0 {
|
|
old -= mutexRWait
|
|
runtime_Semrelease(&mu.rsema)
|
|
}
|
|
for old&mutexWMask != 0 {
|
|
old -= mutexWWait
|
|
runtime_Semrelease(&mu.wsema)
|
|
}
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
|
|
func (mu *fdMutex) Decref() bool {
|
|
for {
|
|
old := atomic.LoadUint64(&mu.state)
|
|
if old&mutexRefMask == 0 {
|
|
panic("net: inconsistent fdMutex")
|
|
}
|
|
new := old - mutexRef
|
|
if atomic.CompareAndSwapUint64(&mu.state, old, new) {
|
|
return new&(mutexClosed|mutexRefMask) == mutexClosed
|
|
}
|
|
}
|
|
}
|
|
|
|
func (mu *fdMutex) RWLock(read bool) bool {
|
|
var mutexBit, mutexWait, mutexMask uint64
|
|
var mutexSema *uint32
|
|
if read {
|
|
mutexBit = mutexRLock
|
|
mutexWait = mutexRWait
|
|
mutexMask = mutexRMask
|
|
mutexSema = &mu.rsema
|
|
} else {
|
|
mutexBit = mutexWLock
|
|
mutexWait = mutexWWait
|
|
mutexMask = mutexWMask
|
|
mutexSema = &mu.wsema
|
|
}
|
|
for {
|
|
old := atomic.LoadUint64(&mu.state)
|
|
if old&mutexClosed != 0 {
|
|
return false
|
|
}
|
|
var new uint64
|
|
if old&mutexBit == 0 {
|
|
// Lock is free, acquire it.
|
|
new = (old | mutexBit) + mutexRef
|
|
if new&mutexRefMask == 0 {
|
|
panic("net: inconsistent fdMutex")
|
|
}
|
|
} else {
|
|
// Wait for lock.
|
|
new = old + mutexWait
|
|
if new&mutexMask == 0 {
|
|
panic("net: inconsistent fdMutex")
|
|
}
|
|
}
|
|
if atomic.CompareAndSwapUint64(&mu.state, old, new) {
|
|
if old&mutexBit == 0 {
|
|
return true
|
|
}
|
|
runtime_Semacquire(mutexSema)
|
|
// The signaller has subtracted mutexWait.
|
|
}
|
|
}
|
|
}
|
|
|
|
func (mu *fdMutex) RWUnlock(read bool) bool {
|
|
var mutexBit, mutexWait, mutexMask uint64
|
|
var mutexSema *uint32
|
|
if read {
|
|
mutexBit = mutexRLock
|
|
mutexWait = mutexRWait
|
|
mutexMask = mutexRMask
|
|
mutexSema = &mu.rsema
|
|
} else {
|
|
mutexBit = mutexWLock
|
|
mutexWait = mutexWWait
|
|
mutexMask = mutexWMask
|
|
mutexSema = &mu.wsema
|
|
}
|
|
for {
|
|
old := atomic.LoadUint64(&mu.state)
|
|
if old&mutexBit == 0 || old&mutexRefMask == 0 {
|
|
panic("net: inconsistent fdMutex")
|
|
}
|
|
// Drop lock, drop reference and wake read waiter if present.
|
|
new := (old &^ mutexBit) - mutexRef
|
|
if old&mutexMask != 0 {
|
|
new -= mutexWait
|
|
}
|
|
if atomic.CompareAndSwapUint64(&mu.state, old, new) {
|
|
if old&mutexMask != 0 {
|
|
runtime_Semrelease(mutexSema)
|
|
}
|
|
return new&(mutexClosed|mutexRefMask) == mutexClosed
|
|
}
|
|
}
|
|
}
|
|
|
|
// Implemented in runtime package.
|
|
func runtime_Semacquire(sema *uint32)
|
|
func runtime_Semrelease(sema *uint32)
|