// Attempt all calls.
	_, err = lkClient.RLock(context.Background(), dsync.LockArgs{})
	if err == nil {
		t.Fatal("Expected for Rlock to fail")
	}

	_, err = lkClient.Lock(context.Background(), dsync.LockArgs{})
	if err == nil {
		t.Fatal("Expected for Lock to fail")
	}

	_, err = lkClient.RUnlock(context.Background(), dsync.LockArgs{})
	if err == nil {
		t.Fatal("Expected for RUnlock to fail")
	}

Brian Sonnenberg <******@****.***> 1716576125 -0700

    }

    def "lock manager is notified while holding an exclusive lock when another lock manager in same process requires lock with mode #lockMode"() {
        given:
        def file = tmpDir.file("lock-file.bin")
        def action = Mock(Consumer)

        def lock = createLock(Exclusive, file, manager, action)

        when:
        def lock2 = createLock(lockMode, file, manager2)

        then:

	return atomic.Loaduintptr(&l.key) > locked
}

func lock(l *mutex) {
	lockWithRank(l, getLockRank(l))
}

func lock2(l *mutex) {
	gp := getg()
	if gp.m.locks < 0 {
		throw("runtime·lock: lock count")
	}
	gp.m.locks++

	// Speculative grab for lock.
	if atomic.Casuintptr(&l.key, 0, locked) {
		return
	}
	semacreate(gp.m)

	timer := &lockTimer{lock: l}
	timer.begin()

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package cmd

import (
	"errors"
)

var (
	errLockConflict       = errors.New("lock conflict")
	errLockNotInitialized = errors.New("lock not initialized")
	errLockNotFound       = errors.New("lock not found")

Yuri Schimke <******@****.***> 1690028931 +0100

package cmd

import (
	"context"
	"os"
	"reflect"
	"sync"
	"testing"

	"github.com/minio/minio/internal/dsync"
)

// Helper function to create a lock server for testing
func createLockTestServer(ctx context.Context, t *testing.T) (string, *lockRESTServer, string) {
	obj, fsDir, err := prepareFS(ctx)
	if err != nil {
		t.Fatal(err)
	}

)

func mutexContended(l *mutex) bool {
	return false
}

func lock(l *mutex) {
	lockWithRank(l, getLockRank(l))
}

func lock2(l *mutex) {
	if l.key == mutex_locked {
		// js/wasm is single-threaded so we should never
		// observe this.
		throw("self deadlock")
	}
	gp := getg()
	if gp.m.locks < 0 {
		throw("lock count")
	}
	gp.m.locks++
	l.key = mutex_locked
}

func unlock(l *mutex) {

	"k8s.io/apimachinery/pkg/util/wait"
)

type locker struct {
	lock16 *os.File
	lock14 *net.UnixListener
}

func (l *locker) Close() error {
	errList := []error{}
	if l.lock16 != nil {
		if err := l.lock16.Close(); err != nil {
			errList = append(errList, err)
		}
	}
	if l.lock14 != nil {
		if err := l.lock14.Close(); err != nil {
			errList = append(errList, err)
		}
	}

    return impl.get(numStripes);
  }

  // a place to put the locks in sizeOfPopulatedStriped so they don't get GC'd before we measure
  final List<Lock> locks = new ArrayList<>(numStripes);

  @Footprint
  Object sizeOfPopulatedStriped() {
    locks.clear();
    Striped<Lock> striped = impl.get(numStripes);
    for (int i : stripes) {
      locks.add(striped.getAt(i));
    }
    return striped;
  }