// Offset and out size cannot be negative.
	if offset < 0 || length < 0 {
		return 0, errUnexpected
	}

	// Do we have enough blocks?
	if len(enBlocks) < dataBlocks {
		return 0, reedsolomon.ErrTooFewShards
	}

	// Do we have enough data?
	if int64(getDataBlockLen(enBlocks, dataBlocks)) < length {

        final int start = bufferIndex;
        for (int i = 0; i < this.unlocks.length; i++) {
            this.unlocks[i] = createLockRange();
            bufferIndex += this.unlocks[i].decode(buffer, bufferIndex, buffer.length);
        }

        for (int i = 0; i < this.locks.length; i++) {
            this.locks[i] = createLockRange();

        setField(unlock, "pid", 456);
        setField(unlock, "byteOffset", 300L);
        setField(unlock, "lengthInBytes", 400L);
        setField(cmd, "locks", new LockingAndXRange[] { lock });
        setField(cmd, "unlocks", new LockingAndXRange[] { unlock });
        setField(cmd, "largeFile", false);

        byte[] buffer = new byte[20];
        int len = cmd.writeParameterWordsWireFormat(buffer, 0);

  private OverflowAvoidingLockSupport() {}

  static void parkNanos(@Nullable Object blocker, long nanos) {
    // Even in the extremely unlikely event that a thread unblocks itself early after only 68 years,
    // this is indistinguishable from a spurious wakeup, which LockSupport allows.
    LockSupport.parkNanos(blocker, min(nanos, MAX_NANOSECONDS_THRESHOLD));
  }

        }

        @Test
        @DisplayName("Should calculate size correctly with no locks")
        void testSizeWithNoLocks() {
            Smb2Lock[] noLocks = new Smb2Lock[0];
            Smb2LockRequest req = new Smb2LockRequest(mockConfig, testFileId, noLocks);

            int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 24; // header + structure
            expectedSize = ((expectedSize + 7) / 8) * 8; // 8-byte alignment

			return false
		default:
			if lm.lock(id, source, isWriteLock) {
				return true
			}
			time.Sleep(time.Duration(r.Float64() * float64(lockRetryInterval)))
		}
	}
}

// Unlock unlocks the write lock.
//
// It is a run-time error if lm is not locked on entry to Unlock.
func (lm *LRWMutex) Unlock() {
	isWriteLock := true
	success := lm.unlock(isWriteLock)
	if !success {

	if msg.DeadlineMS == 0 || msg.DeadlineMS > uint32(4*c.clientPingInterval/time.Millisecond) {
		go func() {
			wg.Wait()
			m.checkRemoteAlive()
		}()
	}
	return &m
}

// handleInbound sends unblocks when we have delivered the message to the handler.
func (m *muxServer) handleInbound(c *Connection, inbound <-chan []byte, handlerIn chan<- []byte) {
	for {
		select {
		case <-m.ctx.Done():
			return

	if requests == nil {
		go m.handleOneWayStream(responseCh, responses)
		return &Stream{responses: responseCh, Requests: nil, ctx: m.ctx, cancel: m.cancelFn, muxID: m.MuxID}, nil
	}

	// Deliver responses and send unblocks back to the server.
	go m.handleTwowayResponses(responseCh, responses)
	go m.handleTwowayRequests(responses, requests)

		if globalIsDistErasure {
			// Top locks
			adminRouter.Methods(http.MethodGet).Path(adminVersion + "/top/locks").HandlerFunc(adminMiddleware(adminAPI.TopLocksHandler))
			// Force unlocks paths
			adminRouter.Methods(http.MethodPost).Path(adminVersion+"/force-unlock").
				Queries("paths", "{paths:.*}").HandlerFunc(adminMiddleware(adminAPI.ForceUnlockHandler))
		}

	// to indicate we haven't sufficiently unlocked lockers to avoid deadlocks.
	//
	// Caller may use this as an indication to call again.
	return !checkFailedUnlocks(*locks, tolerance)
}

// Unlock unlocks the write lock.
//
// It is a run-time error if dm is not locked on entry to Unlock.
func (dm *DRWMutex) Unlock(ctx context.Context) {
	dm.m.Lock()
	dm.cancelRefresh()
	dm.m.Unlock()