* @return the handle info or null if not found
     */
    public HandleInfo getHandleByGuid(HandleGuid guid) {
        lock.readLock().lock();
        try {
            return guidToHandle.get(guid);
        } finally {
            lock.readLock().unlock();
        }
    }

    /**
     * Get handle information by path
     * @param path the file path

    Object key = new Object();
    Lock readLock = striped.get(key).readLock();
    WeakReference<Object> garbage = createGarbage();
    GcFinalization.awaitClear(garbage);
    Lock writeLock = striped.get(key).writeLock();
    readLock.lock();
    try {
      assertFalse(writeLock.tryLock());
    } finally {
      readLock.unlock();
    }
  }

    Object key = new Object();
    Lock readLock = striped.get(key).readLock();
    WeakReference<Object> garbage = createGarbage();
    GcFinalization.awaitClear(garbage);
    Lock writeLock = striped.get(key).writeLock();
    readLock.lock();
    try {
      assertFalse(writeLock.tryLock());
    } finally {
      readLock.unlock();
    }
  }

		if err == nil {
			dm.IOStats = madmin.DiskIOStats{
				ReadIOs:        st.ReadIOs,
				ReadMerges:     st.ReadMerges,
				ReadSectors:    st.ReadSectors,
				ReadTicks:      st.ReadTicks,
				WriteIOs:       st.WriteIOs,
				WriteMerges:    st.WriteMerges,
				WriteSectors:   st.WriteSectors,
				WriteTicks:     st.WriteTicks,
				CurrentIOs:     st.CurrentIOs,

    
    public List<FileInfo> getChildren() {
        lock.readLock().lock();
        try {
            lastAccessTime = System.currentTimeMillis();
            return new ArrayList<>(children.values());
        } finally {
            lock.readLock().unlock();
        }
    }
    
    public FileInfo getChild(String name) {
        lock.readLock().lock();
        try {

@asynccontextmanager
async def contextmanager_in_threadpool(
    cm: AbstractContextManager[_T],
) -> AsyncGenerator[_T, None]:
    # blocking __exit__ from running waiting on a free thread
    # can create race conditions/deadlocks if the context manager itself
    # has its own internal pool (e.g. a database connection pool)
    # to avoid this we let __exit__ run without a capacity limit

	Name       string
	Rotational *bool
	NRRequests uint64
}

// IOStats contains stats of a single drive
type IOStats struct {
	ReadIOs        uint64
	ReadMerges     uint64
	ReadSectors    uint64
	ReadTicks      uint64
	WriteIOs       uint64
	WriteMerges    uint64
	WriteSectors   uint64
	WriteTicks     uint64
	CurrentIOs     uint64
	TotalTicks     uint64
	ReqTicks       uint64
	DiscardIOs     uint64

	}
	// refer https://www.kernel.org/doc/Documentation/block/stat.txt
	iostats = IOStats{
		ReadIOs:      stats[0],
		ReadMerges:   stats[1],
		ReadSectors:  stats[2],
		ReadTicks:    stats[3],
		WriteIOs:     stats[4],
		WriteMerges:  stats[5],
		WriteSectors: stats[6],
		WriteTicks:   stats[7],
		CurrentIOs:   stats[8],
		TotalTicks:   stats[9],
		ReqTicks:     stats[10],
	}

   * setFuture(cancelledFuture)}.
   *
   * <p>Beware of completing a future while holding a lock. Its listeners may do slow work or
   * acquire other locks, risking deadlocks.
   */
  @CanIgnoreReturnValue
  @Override
  public boolean cancel(boolean mayInterruptIfRunning) {
    @RetainedLocalRef Object localValue = value();
    boolean rValue = false;

   * each call to this method may claim and hold a thread for an arbitrary length of time. Use of
   * bounded executors or other executors that may fail to execute a task promptly may result in
   * deadlocks.
   *
   * <p>Prefer to create {@code ListenableFuture} instances with {@link SettableFuture}, {@link
   * MoreExecutors#listeningDecorator( java.util.concurrent.ExecutorService)}, {@link