inet.af/netstack@v0.0.0-20220214151720-7585b01ddccf/sync/mutex_unsafe.go (about)

     1  // Copyright 2019 The gVisor Authors.
     2  //
     3  // Use of this source code is governed by a BSD-style
     4  // license that can be found in the LICENSE file.
     5  
     6  //go:build go1.13 && !go1.19
     7  // +build go1.13,!go1.19
     8  
     9  // When updating the build constraint (above), check that syncMutex matches the
    10  // standard library sync.Mutex definition.
    11  
    12  package sync
    13  
    14  import (
    15  	"sync"
    16  	"sync/atomic"
    17  	"unsafe"
    18  )
    19  
    20  // CrossGoroutineMutex is equivalent to Mutex, but it need not be unlocked by a
    21  // the same goroutine that locked the mutex.
    22  type CrossGoroutineMutex struct {
    23  	sync.Mutex
    24  }
    25  
    26  type syncMutex struct {
    27  	state int32
    28  	sema  uint32
    29  }
    30  
    31  func (m *CrossGoroutineMutex) state() *int32 {
    32  	return &(*syncMutex)(unsafe.Pointer(&m.Mutex)).state
    33  }
    34  
    35  // Lock locks the underlying Mutex.
    36  // +checklocksignore
    37  func (m *CrossGoroutineMutex) Lock() {
    38  	m.Mutex.Lock()
    39  }
    40  
    41  // Unlock unlocks the underlying Mutex.
    42  // +checklocksignore
    43  func (m *CrossGoroutineMutex) Unlock() {
    44  	m.Mutex.Unlock()
    45  }
    46  
    47  const (
    48  	mutexUnlocked = 0
    49  	mutexLocked   = 1
    50  )
    51  
    52  // TryLock tries to acquire the mutex. It returns true if it succeeds and false
    53  // otherwise. TryLock does not block.
    54  func (m *CrossGoroutineMutex) TryLock() bool {
    55  	if atomic.CompareAndSwapInt32(m.state(), mutexUnlocked, mutexLocked) {
    56  		if RaceEnabled {
    57  			RaceAcquire(unsafe.Pointer(&m.Mutex))
    58  		}
    59  		return true
    60  	}
    61  	return false
    62  }
    63  
    64  // Mutex is a mutual exclusion lock. The zero value for a Mutex is an unlocked
    65  // mutex.
    66  //
    67  // A Mutex must not be copied after first use.
    68  //
    69  // A Mutex must be unlocked by the same goroutine that locked it. This
    70  // invariant is enforced with the 'checklocks' build tag.
    71  type Mutex struct {
    72  	m CrossGoroutineMutex
    73  }
    74  
    75  // Lock locks m. If the lock is already in use, the calling goroutine blocks
    76  // until the mutex is available.
    77  // +checklocksignore
    78  func (m *Mutex) Lock() {
    79  	noteLock(unsafe.Pointer(m))
    80  	m.m.Lock()
    81  }
    82  
    83  // Unlock unlocks m.
    84  //
    85  // Preconditions:
    86  // * m is locked.
    87  // * m was locked by this goroutine.
    88  // +checklocksignore
    89  func (m *Mutex) Unlock() {
    90  	noteUnlock(unsafe.Pointer(m))
    91  	m.m.Unlock()
    92  }
    93  
    94  // TryLock tries to acquire the mutex. It returns true if it succeeds and false
    95  // otherwise. TryLock does not block.
    96  // +checklocksignore
    97  func (m *Mutex) TryLock() bool {
    98  	// Note lock first to enforce proper locking even if unsuccessful.
    99  	noteLock(unsafe.Pointer(m))
   100  	locked := m.m.TryLock()
   101  	if !locked {
   102  		noteUnlock(unsafe.Pointer(m))
   103  	}
   104  	return locked
   105  }