}
	store.runlock()

	if len(missingPolicies) > 0 {
		m := make(map[string]PolicyDoc)
		for _, policy := range missingPolicies {
			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
			_ = store.loadPolicyDoc(ctx, policy, m)
			cancel()
		}

		cache := store.lock()
		for policy, p := range m {
			cache.iamPolicyDocsMap[policy] = p
		}
		store.unlock()

		Healing:          false,
	}

	mrfCheck := make(chan FileInfo)
	defer xioutil.SafeClose(mrfCheck)

	var rw sync.Mutex

	// Ask for all disks first;
	go func() {
		ctx, cancel := context.WithCancel(ctx)
		defer cancel()

		wg := sync.WaitGroup{}
		for i, disk := range disks {
			if disk == nil {
				done <- false
				continue
			}
			if !disk.IsOnline() {
				done <- false
				continue

TEST(CAPI, Status) {
  TF_Status* s = TF_NewStatus();
  EXPECT_EQ(TF_OK, TF_GetCode(s));
  EXPECT_EQ(string(), TF_Message(s));
  TF_SetStatus(s, TF_CANCELLED, "cancel");
  EXPECT_EQ(TF_CANCELLED, TF_GetCode(s));
  EXPECT_EQ(string("cancel"), TF_Message(s));
  TF_DeleteStatus(s);
}

void Deallocator(void* data, size_t, void* arg) {
  tensorflow::cpu_allocator()->DeallocateRaw(data);

		immediatePurgeQueue = 1
	}

	ctx, cancel := context.WithCancel(GlobalContext)

	s = &xlStorage{
		drivePath:            ep.Path,
		endpoint:             ep,
		globalSync:           globalFSOSync,
		diskInfoCache:        cachevalue.New[DiskInfo](),
		immediatePurge:       make(chan string, immediatePurgeQueue),
		immediatePurgeCancel: cancel,
	}

	defer func() {
		if cleanUp && err == nil {

        }

        try {
            if ( log.isTraceEnabled() ) {
                log.trace("Sending " + request);
            }
            if ( request.isCancel() ) {
                doSend0(request);
                return null;
            }
            else if ( request instanceof SmbComTransaction ) {

PLkotlinx/coroutines/JobCancellationException;->fillInStackTrace()Ljava/lang/Throwable;
PLkotlinx/coroutines/JobImpl;->getOnCancelComplete$kotlinx_coroutines_core()Z
PLkotlinx/coroutines/JobKt;->cancel$default(Lkotlin/coroutines/CoroutineContext;Ljava/util/concurrent/CancellationException;ILjava/lang/Object;)V
PLkotlinx/coroutines/JobSupport$Finishing;-><init>(Lkotlinx/coroutines/NodeList;ZLjava/lang/Throwable;)V

pkg mime/quotedprintable, type Writer struct, Binary bool
pkg net, type Dialer struct, FallbackDelay time.Duration
pkg net, type OpError struct, Source Addr
pkg net/http, type Request struct, Cancel <-chan struct
pkg net/http/fcgi, var ErrConnClosed error
pkg net/http/fcgi, var ErrRequestAborted error
pkg net/http/pprof, func Trace(http.ResponseWriter, *http.Request)

        set(newValue);
      } else {
        // The pending load was removed. Delay notifications until loading completes.
        oldValue = unset();
      }

      // TODO(fry): could also cancel loading if we had a handle on its future
    }

    public ListenableFuture<V> loadFuture(K key, CacheLoader<? super K, V> loader) {
      try {
        stopwatch.start();

pkg syscall (freebsd-riscv64), const FLUSHO = 8388608 #53466
pkg syscall (freebsd-riscv64), const FLUSHO ideal-int #53466
pkg syscall (freebsd-riscv64), const F_CANCEL = 5 #53466
pkg syscall (freebsd-riscv64), const F_CANCEL ideal-int #53466
pkg syscall (freebsd-riscv64), const F_DUP2FD = 10 #53466
pkg syscall (freebsd-riscv64), const F_DUP2FD ideal-int #53466

pkg syscall (freebsd-arm64), const EXTB ideal-int
pkg syscall (freebsd-arm64), const EXTPROC = 2048
pkg syscall (freebsd-arm64), const EXTPROC ideal-int
pkg syscall (freebsd-arm64), const F_CANCEL = 5
pkg syscall (freebsd-arm64), const F_CANCEL ideal-int
pkg syscall (freebsd-arm64), const F_DUP2FD = 10
pkg syscall (freebsd-arm64), const F_DUP2FD ideal-int
pkg syscall (freebsd-arm64), const F_DUP2FD_CLOEXEC = 18