func (s *Server) runPodSandbox(ctx context.Context, req *types.RunPodSandboxRequest) (resp *types.RunPodSandboxResponse, retErr error) {...  if _, err := s.ReservePodName(sbox.ID(), sbox.Name()); err != nil {    cachedID, resourceErr := s.getResourceOrWait(ctx, sbox.Name(), "sandbox")    if resourceErr == nil {      return &types.RunPodSandboxResponse{PodSandboxID: cachedID}, nil    }    return nil, errors.Wrapf(err, resourceErr.Error())  }...  if isContextError(ctx.Err()) {    if err := s.resourceStore.Put(sbox.Name(), sb, resourceCleaner); err != nil {      log.Errorf(ctx, "runSandbox: failed to save progress of sandbox %s: %v", sbox.ID(), err)    }    log.Infof(ctx, "runSandbox: context was either canceled or the deadline was exceeded: %v", ctx.Err())    return nil, ctx.Err()  }  sb.SetCreated()...}
func (s *Server) getResourceOrWait(ctx context.Context, name, resourceType string) (string, error) {  const resourceCreationWaitTime = time.Minute * 4
  if cachedID := s.resourceStore.Get(name); cachedID != "" {    log.Infof(ctx, "Found %s %s with ID %s in resource cache; using it", resourceType, name, cachedID)    return cachedID, nil  }  watcher := s.resourceStore.WatcherForResource(name)  if watcher == nil {    return "", errors.Errorf("error attempting to watch for %s %s: no longer found", resourceType, name)  }  log.Infof(ctx, "Creation of %s %s not yet finished. Waiting up to %v for it to finish", resourceType, name, resourceCreationWaitTime)  var err error  select {  // We should wait as long as we can (within reason), thus stalling the kubelet's sync loop.  // This will prevent "name is reserved" errors popping up every two seconds.  case <-ctx.Done():    err = ctx.Err()  // This is probably overly cautious, but it doesn't hurt to have a way to terminate  // independent of the kubelet's signal.  case <-time.After(resourceCreationWaitTime):    err = errors.Errorf("waited too long for request to timeout or %s %s to be created", resourceType, name)  // If the resource becomes available while we're watching for it, we still need to error on this request.  // When we pull the resource from the cache after waiting, we won't run the cleanup funcs.  // However, we don't know how long we've been making the kubelet wait for the request, and the request could time outt  // after we stop paying attention. This would cause CRI-O to attempt to send back a resource that the kubelet  // will not receive, causing a resource leak.  case <-watcher:    err = errors.Errorf("the requested %s %s is now ready and will be provided to the kubelet on next retry", resourceType, name)  }
  return "", errors.Wrap(err, "Kubelet may be retrying requests that are timing out in CRI-O due to system load")}

type ResourceStore struct {  resources map[string]*Resource  timeout   time.Duration  closeChan chan struct{}  closed    bool  sync.Mutex}
type Resource struct {  resource IdentifiableCreatable  cleaner  *ResourceCleaner  watchers []chan struct{}  stale    bool  name     string}
type IdentifiableCreatable interface {  ID() string  SetCreated()}
func (rc *ResourceStore) cleanupStaleResources() {...}
func (rc *ResourceStore) Get(name string) string {...}
func (rc *ResourceStore) Put(name string, resource IdentifiableCreatable, cleaner *ResourceCleaner) error {...}
func (rc *ResourceStore) WatcherForResource(name string) chan struct{} {...}

# Location for CRI-O to lay down the temporary version file.# It is used to check if crio wipe should wipe containers, which should# always happen on a node rebootversion_file = "/var/run/crio/version"
# Location for CRI-O to lay down the persistent version file.# It is used to check if crio wipe should wipe images, which should# only happen when CRI-O has been upgradedversion_file_persist = "/var/lib/crio/version"
# Location for CRI-O to lay down the clean shutdown file.# It is used to check whether crio had time to sync before shutting down.# If not found, crio wipe will clear the storage directory.clean_shutdown_file = "/var/lib/crio/clean.shutdown"

cmd/main.go:244    if config.CleanShutdownFile != "" {      // clear out the shutdown file      if err := os.Remove(config.CleanShutdownFile); err != nil {        // not a fatal error, as it could have been cleaned up        logrus.Error(err)      }
      // Write "$CleanShutdownFile".supported to show crio-wipe that      // we should be wiping if the CleanShutdownFile wasn't found.      // This protects us from wiping after an upgrade from a version that don't support      // CleanShutdownFile.      f, err := os.Create(config.CleanShutdownSupportedFileName())      if err != nil {        logrus.Errorf("Writing clean shutdown supported file: %v", err)      }      f.Close()
      // and sync the changes to disk      if err := utils.SyncParent(config.CleanShutdownFile); err != nil {        logrus.Errorf("failed to sync parent directory of clean shutdown file: %v", err)      }    }    server/server.go:277// Shutdown attempts to shut down the server's storage cleanlyfunc (s *Server) Shutdown(ctx context.Context) error {    ...
  if s.config.CleanShutdownFile != "" {    // then, we write the CleanShutdownFile    // we do this after the sync, to ensure ordering.    // Otherwise, we may run into situations where the CleanShutdownFile    // is written before storage, causing us to think a corrupted storage    // is not so.    f, err := os.Create(s.config.CleanShutdownFile)    if err != nil {      return errors.Wrapf(err, "failed to write file to indicate a clean shutdown")    }    f.Close()
    // finally, attempt to sync the newly created file to disk.    // It's still possible we crash after Create but before this Sync,    // which will lead us to think storage wasn't synced.    // However, that's much less likely than if we don't have a second Sync,    // and less risky than if we don't Sync after the Create    if err := utils.SyncParent(s.config.CleanShutdownFile); err != nil {      return errors.Wrapf(err, "failed to sync clean shutdown file")    }  }
  ...}

server/server.go:495func (s *Server) wipeIfAppropriate(ctx context.Context) {  if !s.config.InternalWipe {    return  }  // First, check if the node was rebooted.  // We know this happened because the VersionFile (which lives in a tmpfs)  // will not be there.  shouldWipeContainers, err := version.ShouldCrioWipe(s.config.VersionFile)  if err != nil {    log.Warnf(ctx, "error encountered when checking whether cri-o should wipe containers: %v", err)  }
  // there are two locations we check before wiping:  // one in a temporary directory. This is to check whether the node has rebooted.  // if so, we should remove containers  // another is needed in a persistent directory. This is to check whether we've upgraded  // if we've upgraded, we should wipe images  shouldWipeImages, err := version.ShouldCrioWipe(s.config.VersionFilePersist)  if err != nil {    log.Warnf(ctx, "error encountered when checking whether cri-o should wipe images: %v", err)  }
  shouldWipeContainers = shouldWipeContainers || shouldWipeImages
  // First, save the images we should be wiping  // We won't remember if we wipe all the containers first  var imagesToWipe []string  if shouldWipeImages {    containers, err := s.ContainerServer.ListContainers()    if err != nil {      log.Warnf(ctx, "Failed to list containers: %v", err)    }    for _, c := range containers {      imagesToWipe = append(imagesToWipe, c.ImageRef())    }  }
  wipeResourceCleaner := resourcestore.NewResourceCleaner()  if shouldWipeContainers {    for _, sb := range s.ContainerServer.ListSandboxes() {      sb := sb      cleanupFunc := func() error {        if err := s.stopPodSandbox(ctx, sb); err != nil {          return err        }        return s.removePodSandbox(ctx, sb)      }      if err := cleanupFunc(); err != nil {        log.Warnf(ctx, "Failed to cleanup pod %s (will retry): %v", sb.ID(), err)        wipeResourceCleaner.Add(ctx, "stop and remove pod sandbox", cleanupFunc)      }    }  }
  go func() {    if err := wipeResourceCleaner.Cleanup(); err != nil {      log.Errorf(ctx, "Cleanup during server startup failed: %v", err)    }  }()
  // Note: some of these will fail if some aspect of the pod cleanup failed as well,  // but this is best-effort anyway, as the Kubelet will eventually cleanup images when  // disk usage gets too high.  if shouldWipeImages {    for _, img := range imagesToWipe {      if err := s.removeImage(ctx, img); err != nil {        log.Warnf(ctx, "failed to remove image %s: %v", img, err)      }    }  }}