@@ -32,14 +32,14 @@ type copyBackend interface {

 // stateBackend includes functions to implement to provide container state lifecycle functionality.

 type stateBackend interface {

-	ContainerCreate(config types.ContainerCreateConfig) (container.CreateResponse, error)

+	ContainerCreate(ctx context.Context, config types.ContainerCreateConfig) (container.CreateResponse, error)

 	ContainerKill(name string, signal string) error

 	ContainerPause(name string) error

 	ContainerRename(oldName, newName string) error

 	ContainerResize(name string, height, width int) error

 	ContainerRestart(ctx context.Context, name string, options container.StopOptions) error

 	ContainerRm(name string, config *types.ContainerRmConfig) error

-	ContainerStart(name string, hostConfig *container.HostConfig, checkpoint string, checkpointDir string) error

+	ContainerStart(ctx context.Context, name string, hostConfig *container.HostConfig, checkpoint string, checkpointDir string) error

 	ContainerStop(ctx context.Context, name string, options container.StopOptions) error

 	ContainerUnpause(name string) error

 	ContainerUpdate(name string, hostConfig *container.HostConfig) (container.ContainerUpdateOKBody, error)

@@ -54,7 +54,7 @@ type monitorBackend interface {

 	ContainerStats(ctx context.Context, name string, config *backend.ContainerStatsConfig) error

 	ContainerTop(name string, psArgs string) (*container.ContainerTopOKBody, error)

-	Containers(config *types.ContainerListOptions) ([]*types.Container, error)

+	Containers(ctx context.Context, config *types.ContainerListOptions) ([]*types.Container, error)

 }

 // attachBackend includes function to implement to provide container attaching functionality.

@@ -68,7 +68,7 @@ type systemBackend interface {

 }

 type commitBackend interface {

-	CreateImageFromContainer(name string, config *backend.CreateImageConfig) (imageID string, err error)

+	CreateImageFromContainer(ctx context.Context, name string, config *backend.CreateImageConfig) (imageID string, err error)

 }

 // Backend is all the methods that need to be implemented to provide container specific functionality.

@@ -58,7 +58,7 @@ func (s *containerRouter) postCommit(ctx context.Context, w http.ResponseWriter,

 		Changes: r.Form["changes"],

 	}

-	imgID, err := s.backend.CreateImageFromContainer(r.Form.Get("container"), commitCfg)

+	imgID, err := s.backend.CreateImageFromContainer(ctx, r.Form.Get("container"), commitCfg)

 	if err != nil {

 		return err

 	}

@@ -91,7 +91,7 @@ func (s *containerRouter) getContainersJSON(ctx context.Context, w http.Response

 		config.Limit = limit

 	}

-	containers, err := s.backend.Containers(config)

+	containers, err := s.backend.Containers(ctx, config)

 	if err != nil {

 		return err

 	}

@@ -214,7 +214,7 @@ func (s *containerRouter) postContainersStart(ctx context.Context, w http.Respon

 	checkpoint := r.Form.Get("checkpoint")

 	checkpointDir := r.Form.Get("checkpoint-dir")

-	if err := s.backend.ContainerStart(vars["name"], hostConfig, checkpoint, checkpointDir); err != nil {

+	if err := s.backend.ContainerStart(ctx, vars["name"], hostConfig, checkpoint, checkpointDir); err != nil {

 		return err

 	}

@@ -578,7 +578,7 @@ func (s *containerRouter) postContainersCreate(ctx context.Context, w http.Respo

 		hostConfig.PidsLimit = nil

 	}

-	ccr, err := s.backend.ContainerCreate(types.ContainerCreateConfig{

+	ccr, err := s.backend.ContainerCreate(ctx, types.ContainerCreateConfig{

 		Name:             name,

 		Config:           config,

 		HostConfig:       hostConfig,

@@ -31,7 +31,7 @@ type imageBackend interface {

 type importExportBackend interface {

 	LoadImage(ctx context.Context, inTar io.ReadCloser, outStream io.Writer, quiet bool) error

-	ImportImage(src string, repository string, platform *specs.Platform, tag string, msg string, inConfig io.ReadCloser, outStream io.Writer, changes []string) error

+	ImportImage(ctx context.Context, src string, repository string, platform *specs.Platform, tag string, msg string, inConfig io.ReadCloser, outStream io.Writer, changes []string) error

 	ExportImage(ctx context.Context, names []string, outStream io.Writer) error

 }

@@ -68,7 +68,7 @@ func (ir *imageRouter) postImagesCreate(ctx context.Context, w http.ResponseWrit

 		progressErr = ir.backend.PullImage(ctx, img, tag, platform, metaHeaders, authConfig, output)

 	} else { // import

 		src := r.Form.Get("fromSrc")

-		progressErr = ir.backend.ImportImage(src, repo, platform, tag, message, r.Body, output, r.Form["changes"])

+		progressErr = ir.backend.ImportImage(ctx, src, repo, platform, tag, message, r.Body, output, r.Form["changes"])

 	}

 	if progressErr != nil {

 		if !output.Flushed() {

@@ -12,7 +12,7 @@ import (

 type Backend interface {

 	Init(req types.InitRequest) (string, error)

 	Join(req types.JoinRequest) error

-	Leave(force bool) error

+	Leave(ctx context.Context, force bool) error

 	Inspect() (types.Swarm, error)

 	Update(uint64, types.Spec, types.UpdateFlags) error

 	GetUnlockKey() (string, error)

@@ -56,7 +56,7 @@ func (sr *swarmRouter) leaveCluster(ctx context.Context, w http.ResponseWriter,

 	}

 	force := httputils.BoolValue(r, "force")

-	return sr.backend.Leave(force)

+	return sr.backend.Leave(ctx, force)

 }

 func (sr *swarmRouter) inspectCluster(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

@@ -60,13 +60,13 @@ type ExecBackend interface {

 	// ContainerAttachRaw attaches to container.

 	ContainerAttachRaw(cID string, stdin io.ReadCloser, stdout, stderr io.Writer, stream bool, attached chan struct{}) error

 	// ContainerCreateIgnoreImagesArgsEscaped creates a new Docker container and returns potential warnings

-	ContainerCreateIgnoreImagesArgsEscaped(config types.ContainerCreateConfig) (container.CreateResponse, error)

+	ContainerCreateIgnoreImagesArgsEscaped(ctx context.Context, config types.ContainerCreateConfig) (container.CreateResponse, error)

 	// ContainerRm removes a container specified by `id`.

 	ContainerRm(name string, config *types.ContainerRmConfig) error

 	// ContainerKill stops the container execution abruptly.

 	ContainerKill(containerID string, sig string) error

 	// ContainerStart starts a new container

-	ContainerStart(containerID string, hostConfig *container.HostConfig, checkpoint string, checkpointDir string) error

+	ContainerStart(ctx context.Context, containerID string, hostConfig *container.HostConfig, checkpoint string, checkpointDir string) error

 	// ContainerWait stops processing until the given container is stopped.

 	ContainerWait(ctx context.Context, name string, condition containerpkg.WaitCondition) (<-chan containerpkg.StateStatus, error)

 }

@@ -80,7 +80,7 @@ type Result struct {

 // ImageCacheBuilder represents a generator for stateful image cache.

 type ImageCacheBuilder interface {

 	// MakeImageCache creates a stateful image cache.

-	MakeImageCache(cacheFrom []string) ImageCache

+	MakeImageCache(ctx context.Context, cacheFrom []string) (ImageCache, error)

 }

 // ImageCache abstracts an image cache.

@@ -95,7 +95,7 @@ func (bm *BuildManager) Build(ctx context.Context, config backend.BuildConfig) (

 	if err != nil {

 		return nil, err

 	}

-	return b.build(source, dockerfile)

+	return b.build(ctx, source, dockerfile)

 }

 // builderOptions are the dependencies required by the builder

@@ -136,6 +136,11 @@ func newBuilder(clientCtx context.Context, options builderOptions) (*Builder, er

 		config = new(types.ImageBuildOptions)

 	}

+	imageProber, err := newImageProber(clientCtx, options.Backend, config.CacheFrom, config.NoCache)

+	if err != nil {

+		return nil, err

+	}

+

 	b := &Builder{

 		clientCtx:        clientCtx,

 		options:          config,

@@ -147,7 +152,7 @@ func newBuilder(clientCtx context.Context, options builderOptions) (*Builder, er

 		idMapping:        options.IDMapping,

 		imageSources:     newImageSources(clientCtx, options),

 		pathCache:        options.PathCache,

-		imageProber:      newImageProber(options.Backend, config.CacheFrom, config.NoCache),

+		imageProber:      imageProber,

 		containerManager: newContainerManager(options.Backend),

 	}

@@ -181,7 +186,7 @@ func buildLabelOptions(labels map[string]string, stages []instructions.Stage) {

 // Build runs the Dockerfile builder by parsing the Dockerfile and executing

 // the instructions from the file.

-func (b *Builder) build(source builder.Source, dockerfile *parser.Result) (*builder.Result, error) {

+func (b *Builder) build(ctx context.Context, source builder.Source, dockerfile *parser.Result) (*builder.Result, error) {

 	defer b.imageSources.Unmount()

 	stages, metaArgs, err := instructions.Parse(dockerfile.AST)

@@ -205,7 +210,7 @@ func (b *Builder) build(source builder.Source, dockerfile *parser.Result) (*buil

 	buildLabelOptions(b.options.Labels, stages)

 	dockerfile.PrintWarnings(b.Stderr)

-	dispatchState, err := b.dispatchDockerfileWithCancellation(stages, metaArgs, dockerfile.EscapeToken, source)

+	dispatchState, err := b.dispatchDockerfileWithCancellation(ctx, stages, metaArgs, dockerfile.EscapeToken, source)

 	if err != nil {

 		return nil, err

 	}

@@ -244,7 +249,7 @@ func printCommand(out io.Writer, currentCommandIndex int, totalCommands int, cmd

 	return currentCommandIndex + 1

 }

-func (b *Builder) dispatchDockerfileWithCancellation(parseResult []instructions.Stage, metaArgs []instructions.ArgCommand, escapeToken rune, source builder.Source) (*dispatchState, error) {

+func (b *Builder) dispatchDockerfileWithCancellation(ctx context.Context, parseResult []instructions.Stage, metaArgs []instructions.ArgCommand, escapeToken rune, source builder.Source) (*dispatchState, error) {

 	dispatchRequest := dispatchRequest{}

 	buildArgs := NewBuildArgs(b.options.BuildArgs)

 	totalCommands := len(metaArgs) + len(parseResult)

@@ -272,7 +277,7 @@ func (b *Builder) dispatchDockerfileWithCancellation(parseResult []instructions.

 		dispatchRequest = newDispatchRequest(b, escapeToken, source, buildArgs, stagesResults)

 		currentCommandIndex = printCommand(b.Stdout, currentCommandIndex, totalCommands, stage.SourceCode)

-		if err := initializeStage(dispatchRequest, &stage); err != nil {

+		if err := initializeStage(ctx, dispatchRequest, &stage); err != nil {

 			return nil, err

 		}

 		dispatchRequest.state.updateRunConfig()

@@ -290,7 +295,7 @@ func (b *Builder) dispatchDockerfileWithCancellation(parseResult []instructions.

 			currentCommandIndex = printCommand(b.Stdout, currentCommandIndex, totalCommands, cmd)

-			if err := dispatch(dispatchRequest, cmd); err != nil {

+			if err := dispatch(ctx, dispatchRequest, cmd); err != nil {

 				return nil, err

 			}

 			dispatchRequest.state.updateRunConfig()

@@ -317,7 +322,7 @@ func (b *Builder) dispatchDockerfileWithCancellation(parseResult []instructions.

 // coming from the query parameter of the same name.

 //

 // TODO: Remove?

-func BuildFromConfig(config *container.Config, changes []string, os string) (*container.Config, error) {

+func BuildFromConfig(ctx context.Context, config *container.Config, changes []string, os string) (*container.Config, error) {

 	if len(changes) == 0 {

 		return config, nil

 	}

@@ -327,7 +332,7 @@ func BuildFromConfig(config *container.Config, changes []string, os string) (*co

 		return nil, errdefs.InvalidParameter(err)

 	}

-	b, err := newBuilder(context.Background(), builderOptions{

+	b, err := newBuilder(ctx, builderOptions{

 		Options: &types.ImageBuildOptions{NoCache: true},

 	})

 	if err != nil {

@@ -360,7 +365,7 @@ func BuildFromConfig(config *container.Config, changes []string, os string) (*co

 	dispatchRequest.state.imageID = config.Image

 	dispatchRequest.state.operatingSystem = os

 	for _, cmd := range commands {

-		err := dispatch(dispatchRequest, cmd)

+		err := dispatch(ctx, dispatchRequest, cmd)

 		if err != nil {

 			return nil, errdefs.InvalidParameter(err)

 		}

@@ -28,8 +28,8 @@ func newContainerManager(docker builder.ExecBackend) *containerManager {

 }

 // Create a container

-func (c *containerManager) Create(runConfig *container.Config, hostConfig *container.HostConfig) (container.CreateResponse, error) {

-	container, err := c.backend.ContainerCreateIgnoreImagesArgsEscaped(types.ContainerCreateConfig{

+func (c *containerManager) Create(ctx context.Context, runConfig *container.Config, hostConfig *container.HostConfig) (container.CreateResponse, error) {

+	container, err := c.backend.ContainerCreateIgnoreImagesArgsEscaped(ctx, types.ContainerCreateConfig{

 		Config:     runConfig,

 		HostConfig: hostConfig,

 	})

@@ -69,7 +69,7 @@ func (c *containerManager) Run(ctx context.Context, cID string, stdout, stderr i

 		}

 	}()

-	if err := c.backend.ContainerStart(cID, nil, "", ""); err != nil {

+	if err := c.backend.ContainerStart(ctx, cID, nil, "", ""); err != nil {

 		close(finished)

 		logCancellationError(cancelErrCh, "error from ContainerStart: "+err.Error())

 		return err

@@ -9,6 +9,7 @@ package dockerfile // import "github.com/docker/docker/builder/dockerfile"

 import (

 	"bytes"

+	"context"

 	"fmt"

 	"runtime"

 	"sort"

@@ -35,7 +36,7 @@ import (

 //

 // Sets the environment variable foo to bar, also makes interpolation

 // in the dockerfile available from the next statement on via ${foo}.

-func dispatchEnv(d dispatchRequest, c *instructions.EnvCommand) error {

+func dispatchEnv(ctx context.Context, d dispatchRequest, c *instructions.EnvCommand) error {

 	runConfig := d.state.runConfig

 	commitMessage := bytes.NewBufferString("ENV")

 	for _, e := range c.Env {

@@ -57,21 +58,21 @@ func dispatchEnv(d dispatchRequest, c *instructions.EnvCommand) error {

 			runConfig.Env = append(runConfig.Env, newVar)

 		}

 	}

-	return d.builder.commit(d.state, commitMessage.String())

+	return d.builder.commit(ctx, d.state, commitMessage.String())

 }

 // MAINTAINER some text <maybe@an.email.address>

 //

 // Sets the maintainer metadata.

-func dispatchMaintainer(d dispatchRequest, c *instructions.MaintainerCommand) error {

+func dispatchMaintainer(ctx context.Context, d dispatchRequest, c *instructions.MaintainerCommand) error {

 	d.state.maintainer = c.Maintainer

-	return d.builder.commit(d.state, "MAINTAINER "+c.Maintainer)

+	return d.builder.commit(ctx, d.state, "MAINTAINER "+c.Maintainer)

 }

 // LABEL some json data describing the image

 //

 // Sets the Label variable foo to bar,

-func dispatchLabel(d dispatchRequest, c *instructions.LabelCommand) error {

+func dispatchLabel(ctx context.Context, d dispatchRequest, c *instructions.LabelCommand) error {

 	if d.state.runConfig.Labels == nil {

 		d.state.runConfig.Labels = make(map[string]string)

 	}

@@ -80,14 +81,14 @@ func dispatchLabel(d dispatchRequest, c *instructions.LabelCommand) error {

 		d.state.runConfig.Labels[v.Key] = v.Value

 		commitStr += " " + v.String()

 	}

-	return d.builder.commit(d.state, commitStr)

+	return d.builder.commit(ctx, d.state, commitStr)

 }

 // ADD foo /path

 //

 // Add the file 'foo' to '/path'. Tarball and Remote URL (http, https) handling

 // exist here. If you do not wish to have this automatic handling, use COPY.

-func dispatchAdd(d dispatchRequest, c *instructions.AddCommand) error {

+func dispatchAdd(ctx context.Context, d dispatchRequest, c *instructions.AddCommand) error {

 	if c.Chmod != "" {

 		return errors.New("the --chmod option requires BuildKit. Refer to https://docs.docker.com/go/buildkit/ to learn how to build images with BuildKit enabled")

 	}

@@ -102,13 +103,13 @@ func dispatchAdd(d dispatchRequest, c *instructions.AddCommand) error {

 	copyInstruction.chownStr = c.Chown

 	copyInstruction.allowLocalDecompression = true

-	return d.builder.performCopy(d, copyInstruction)

+	return d.builder.performCopy(ctx, d, copyInstruction)

 }

 // COPY foo /path

 //

 // Same as 'ADD' but without the tar and remote url handling.

-func dispatchCopy(d dispatchRequest, c *instructions.CopyCommand) error {

+func dispatchCopy(ctx context.Context, d dispatchRequest, c *instructions.CopyCommand) error {

 	if c.Chmod != "" {

 		return errors.New("the --chmod option requires BuildKit. Refer to https://docs.docker.com/go/buildkit/ to learn how to build images with BuildKit enabled")

 	}

@@ -130,7 +131,7 @@ func dispatchCopy(d dispatchRequest, c *instructions.CopyCommand) error {

 	if c.From != "" && copyInstruction.chownStr == "" {

 		copyInstruction.preserveOwnership = true

 	}

-	return d.builder.performCopy(d, copyInstruction)

+	return d.builder.performCopy(ctx, d, copyInstruction)

 }

 func (d *dispatchRequest) getImageMount(imageRefOrID string) (*imageMount, error) {

@@ -152,8 +153,11 @@ func (d *dispatchRequest) getImageMount(imageRefOrID string) (*imageMount, error

 }

 // FROM [--platform=platform] imagename[:tag | @digest] [AS build-stage-name]

-func initializeStage(d dispatchRequest, cmd *instructions.Stage) error {

-	d.builder.imageProber.Reset()

+func initializeStage(ctx context.Context, d dispatchRequest, cmd *instructions.Stage) error {

+	err := d.builder.imageProber.Reset(ctx)

+	if err != nil {

+		return err

+	}

 	var platform *specs.Platform

 	if v := cmd.Platform; v != "" {

@@ -180,12 +184,12 @@ func initializeStage(d dispatchRequest, cmd *instructions.Stage) error {

 	if len(state.runConfig.OnBuild) > 0 {

 		triggers := state.runConfig.OnBuild

 		state.runConfig.OnBuild = nil

-		return dispatchTriggeredOnBuild(d, triggers)

+		return dispatchTriggeredOnBuild(ctx, d, triggers)

 	}

 	return nil

 }

-func dispatchTriggeredOnBuild(d dispatchRequest, triggers []string) error {

+func dispatchTriggeredOnBuild(ctx context.Context, d dispatchRequest, triggers []string) error {

 	fmt.Fprintf(d.builder.Stdout, "# Executing %d build trigger", len(triggers))

 	if len(triggers) > 1 {

 		fmt.Fprint(d.builder.Stdout, "s")

@@ -208,7 +212,7 @@ func dispatchTriggeredOnBuild(d dispatchRequest, triggers []string) error {

 			}

 			return err

 		}

-		err = dispatch(d, cmd)

+		err = dispatch(ctx, d, cmd)

 		if err != nil {

 			return err

 		}

@@ -276,15 +280,15 @@ func (d *dispatchRequest) getFromImage(shlex *shell.Lex, basename string, platfo

 	return d.getImageOrStage(name, platform)

 }

-func dispatchOnbuild(d dispatchRequest, c *instructions.OnbuildCommand) error {

+func dispatchOnbuild(ctx context.Context, d dispatchRequest, c *instructions.OnbuildCommand) error {

 	d.state.runConfig.OnBuild = append(d.state.runConfig.OnBuild, c.Expression)

-	return d.builder.commit(d.state, "ONBUILD "+c.Expression)

+	return d.builder.commit(ctx, d.state, "ONBUILD "+c.Expression)

 }

 // WORKDIR /tmp

 //

 // Set the working directory for future RUN/CMD/etc statements.

-func dispatchWorkdir(d dispatchRequest, c *instructions.WorkdirCommand) error {

+func dispatchWorkdir(ctx context.Context, d dispatchRequest, c *instructions.WorkdirCommand) error {

 	runConfig := d.state.runConfig

 	var err error

 	runConfig.WorkingDir, err = normalizeWorkdir(d.state.operatingSystem, runConfig.WorkingDir, c.Path)

@@ -305,7 +309,7 @@ func dispatchWorkdir(d dispatchRequest, c *instructions.WorkdirCommand) error {

 	comment := "WORKDIR " + runConfig.WorkingDir

 	runConfigWithCommentCmd := copyRunConfig(runConfig, withCmdCommentString(comment, d.state.operatingSystem))

-	containerID, err := d.builder.probeAndCreate(d.state, runConfigWithCommentCmd)

+	containerID, err := d.builder.probeAndCreate(ctx, d.state, runConfigWithCommentCmd)

 	if err != nil || containerID == "" {

 		return err

 	}

@@ -326,7 +330,7 @@ func dispatchWorkdir(d dispatchRequest, c *instructions.WorkdirCommand) error {

 // RUN echo hi          # sh -c echo hi       (Linux and LCOW)

 // RUN echo hi          # cmd /S /C echo hi   (Windows)

 // RUN [ "echo", "hi" ] # echo hi

-func dispatchRun(d dispatchRequest, c *instructions.RunCommand) error {

+func dispatchRun(ctx context.Context, d dispatchRequest, c *instructions.RunCommand) error {

 	if !system.IsOSSupported(d.state.operatingSystem) {

 		return system.ErrNotSupportedOperatingSystem

 	}

@@ -360,7 +364,7 @@ func dispatchRun(d dispatchRequest, c *instructions.RunCommand) error {

 		withEntrypointOverride(saveCmd, strslice.StrSlice{""}),

 		withoutHealthcheck())

-	cID, err := d.builder.create(runConfig)

+	cID, err := d.builder.create(ctx, runConfig)

 	if err != nil {

 		return err

 	}

@@ -420,7 +424,7 @@ func prependEnvOnCmd(buildArgs *BuildArgs, buildArgVars []string, cmd strslice.S

 //

 // Set the default command to run in the container (which may be empty).

 // Argument handling is the same as RUN.

-func dispatchCmd(d dispatchRequest, c *instructions.CmdCommand) error {

+func dispatchCmd(ctx context.Context, d dispatchRequest, c *instructions.CmdCommand) error {

 	runConfig := d.state.runConfig

 	cmd, argsEscaped := resolveCmdLine(c.ShellDependantCmdLine, runConfig, d.state.operatingSystem, c.Name(), c.String())

@@ -436,7 +440,7 @@ func dispatchCmd(d dispatchRequest, c *instructions.CmdCommand) error {

 	runConfig.Cmd = cmd

 	runConfig.ArgsEscaped = argsEscaped

-	if err := d.builder.commit(d.state, fmt.Sprintf("CMD %q", cmd)); err != nil {

+	if err := d.builder.commit(ctx, d.state, fmt.Sprintf("CMD %q", cmd)); err != nil {

 		return err

 	}

 	if len(c.ShellDependantCmdLine.CmdLine) != 0 {

@@ -450,7 +454,7 @@ func dispatchCmd(d dispatchRequest, c *instructions.CmdCommand) error {

 //

 // Set the default healthcheck command to run in the container (which may be empty).

 // Argument handling is the same as RUN.

-func dispatchHealthcheck(d dispatchRequest, c *instructions.HealthCheckCommand) error {

+func dispatchHealthcheck(ctx context.Context, d dispatchRequest, c *instructions.HealthCheckCommand) error {

 	runConfig := d.state.runConfig

 	if runConfig.Healthcheck != nil {

 		oldCmd := runConfig.Healthcheck.Test

@@ -459,7 +463,7 @@ func dispatchHealthcheck(d dispatchRequest, c *instructions.HealthCheckCommand)

 		}

 	}

 	runConfig.Healthcheck = c.Health

-	return d.builder.commit(d.state, fmt.Sprintf("HEALTHCHECK %q", runConfig.Healthcheck))

+	return d.builder.commit(ctx, d.state, fmt.Sprintf("HEALTHCHECK %q", runConfig.Healthcheck))

 }

 // ENTRYPOINT /usr/sbin/nginx

@@ -469,7 +473,7 @@ func dispatchHealthcheck(d dispatchRequest, c *instructions.HealthCheckCommand)

 //

 // Handles command processing similar to CMD and RUN, only req.runConfig.Entrypoint

 // is initialized at newBuilder time instead of through argument parsing.

-func dispatchEntrypoint(d dispatchRequest, c *instructions.EntrypointCommand) error {

+func dispatchEntrypoint(ctx context.Context, d dispatchRequest, c *instructions.EntrypointCommand) error {

 	runConfig := d.state.runConfig

 	cmd, argsEscaped := resolveCmdLine(c.ShellDependantCmdLine, runConfig, d.state.operatingSystem, c.Name(), c.String())

@@ -491,14 +495,14 @@ func dispatchEntrypoint(d dispatchRequest, c *instructions.EntrypointCommand) er

 		runConfig.Cmd = nil

 	}

-	return d.builder.commit(d.state, fmt.Sprintf("ENTRYPOINT %q", runConfig.Entrypoint))

+	return d.builder.commit(ctx, d.state, fmt.Sprintf("ENTRYPOINT %q", runConfig.Entrypoint))

 }

 // EXPOSE 6667/tcp 7000/tcp

 //

 // Expose ports for links and port mappings. This all ends up in

 // req.runConfig.ExposedPorts for runconfig.

-func dispatchExpose(d dispatchRequest, c *instructions.ExposeCommand, envs []string) error {

+func dispatchExpose(ctx context.Context, d dispatchRequest, c *instructions.ExposeCommand, envs []string) error {

 	// custom multi word expansion

 	// expose $FOO with FOO="80 443" is expanded as EXPOSE [80,443]. This is the only command supporting word to words expansion

 	// so the word processing has been de-generalized

@@ -524,22 +528,22 @@ func dispatchExpose(d dispatchRequest, c *instructions.ExposeCommand, envs []str

 		d.state.runConfig.ExposedPorts[p] = struct{}{}

 	}

-	return d.builder.commit(d.state, "EXPOSE "+strings.Join(c.Ports, " "))

+	return d.builder.commit(ctx, d.state, "EXPOSE "+strings.Join(c.Ports, " "))

 }

 // USER foo

 //

 // Set the user to 'foo' for future commands and when running the

 // ENTRYPOINT/CMD at container run time.

-func dispatchUser(d dispatchRequest, c *instructions.UserCommand) error {

+func dispatchUser(ctx context.Context, d dispatchRequest, c *instructions.UserCommand) error {

 	d.state.runConfig.User = c.User

-	return d.builder.commit(d.state, fmt.Sprintf("USER %v", c.User))

+	return d.builder.commit(ctx, d.state, fmt.Sprintf("USER %v", c.User))

 }

 // VOLUME /foo

 //

 // Expose the volume /foo for use. Will also accept the JSON array form.

-func dispatchVolume(d dispatchRequest, c *instructions.VolumeCommand) error {

+func dispatchVolume(ctx context.Context, d dispatchRequest, c *instructions.VolumeCommand) error {

 	if d.state.runConfig.Volumes == nil {

 		d.state.runConfig.Volumes = map[string]struct{}{}

 	}

@@ -549,19 +553,19 @@ func dispatchVolume(d dispatchRequest, c *instructions.VolumeCommand) error {

 		}

 		d.state.runConfig.Volumes[v] = struct{}{}

 	}

-	return d.builder.commit(d.state, fmt.Sprintf("VOLUME %v", c.Volumes))

+	return d.builder.commit(ctx, d.state, fmt.Sprintf("VOLUME %v", c.Volumes))

 }

 // STOPSIGNAL signal

 //

 // Set the signal that will be used to kill the container.

-func dispatchStopSignal(d dispatchRequest, c *instructions.StopSignalCommand) error {

+func dispatchStopSignal(ctx context.Context, d dispatchRequest, c *instructions.StopSignalCommand) error {

 	_, err := signal.ParseSignal(c.Signal)

 	if err != nil {

 		return errdefs.InvalidParameter(err)

 	}

 	d.state.runConfig.StopSignal = c.Signal

-	return d.builder.commit(d.state, fmt.Sprintf("STOPSIGNAL %v", c.Signal))

+	return d.builder.commit(ctx, d.state, fmt.Sprintf("STOPSIGNAL %v", c.Signal))

 }

 // ARG name[=value]

@@ -569,7 +573,7 @@ func dispatchStopSignal(d dispatchRequest, c *instructions.StopSignalCommand) er

 // Adds the variable foo to the trusted list of variables that can be passed

 // to builder using the --build-arg flag for expansion/substitution or passing to 'run'.

 // Dockerfile author may optionally set a default value of this variable.

-func dispatchArg(d dispatchRequest, c *instructions.ArgCommand) error {

+func dispatchArg(ctx context.Context, d dispatchRequest, c *instructions.ArgCommand) error {

 	var commitStr strings.Builder

 	commitStr.WriteString("ARG ")

 	for i, arg := range c.Args {

@@ -584,13 +588,13 @@ func dispatchArg(d dispatchRequest, c *instructions.ArgCommand) error {

 		d.state.buildArgs.AddArg(arg.Key, arg.Value)

 	}

-	return d.builder.commit(d.state, commitStr.String())

+	return d.builder.commit(ctx, d.state, commitStr.String())

 }

 // SHELL powershell -command

 //

 // Set the non-default shell to use.

-func dispatchShell(d dispatchRequest, c *instructions.ShellCommand) error {

+func dispatchShell(ctx context.Context, d dispatchRequest, c *instructions.ShellCommand) error {

 	d.state.runConfig.Shell = c.Shell

-	return d.builder.commit(d.state, fmt.Sprintf("SHELL %v", d.state.runConfig.Shell))

+	return d.builder.commit(ctx, d.state, fmt.Sprintf("SHELL %v", d.state.runConfig.Shell))

 }

@@ -23,10 +23,15 @@ import (

 	is "gotest.tools/v3/assert/cmp"

 )

-func newBuilderWithMockBackend() *Builder {

+func newBuilderWithMockBackend(t *testing.T) *Builder {

+	t.Helper()

 	mockBackend := &MockBackend{}

 	opts := &types.ImageBuildOptions{}

 	ctx := context.Background()

+

+	imageProber, err := newImageProber(ctx, mockBackend, nil, false)

+	assert.NilError(t, err, "Could not create image prober")

+

 	b := &Builder{

 		options:       opts,

 		docker:        mockBackend,

@@ -37,14 +42,14 @@ func newBuilderWithMockBackend() *Builder {

 			Options: opts,

 			Backend: mockBackend,

 		}),

-		imageProber:      newImageProber(mockBackend, nil, false),

+		imageProber:      imageProber,

 		containerManager: newContainerManager(mockBackend),

 	}

 	return b

 }

 func TestEnv2Variables(t *testing.T) {

-	b := newBuilderWithMockBackend()

+	b := newBuilderWithMockBackend(t)

 	sb := newDispatchRequest(b, '\\', nil, NewBuildArgs(make(map[string]*string)), newStagesBuildResults())

 	envCommand := &instructions.EnvCommand{

 		Env: instructions.KeyValuePairs{

@@ -52,7 +57,7 @@ func TestEnv2Variables(t *testing.T) {

 			instructions.KeyValuePair{Key: "var2", Value: "val2"},

 		},

 	}

-	err := dispatch(sb, envCommand)

+	err := dispatch(context.TODO(), sb, envCommand)

 	assert.NilError(t, err)

 	expected := []string{

@@ -63,7 +68,7 @@ func TestEnv2Variables(t *testing.T) {

 }

 func TestEnvValueWithExistingRunConfigEnv(t *testing.T) {

-	b := newBuilderWithMockBackend()

+	b := newBuilderWithMockBackend(t)

 	sb := newDispatchRequest(b, '\\', nil, NewBuildArgs(make(map[string]*string)), newStagesBuildResults())

 	sb.state.runConfig.Env = []string{"var1=old", "var2=fromenv"}

 	envCommand := &instructions.EnvCommand{

@@ -71,7 +76,7 @@ func TestEnvValueWithExistingRunConfigEnv(t *testing.T) {

 			instructions.KeyValuePair{Key: "var1", Value: "val1"},

 		},

 	}

-	err := dispatch(sb, envCommand)

+	err := dispatch(context.TODO(), sb, envCommand)

 	assert.NilError(t, err)

 	expected := []string{

 		"var1=val1",

@@ -82,10 +87,10 @@ func TestEnvValueWithExistingRunConfigEnv(t *testing.T) {

 func TestMaintainer(t *testing.T) {

 	maintainerEntry := "Some Maintainer <maintainer@example.com>"

-	b := newBuilderWithMockBackend()

+	b := newBuilderWithMockBackend(t)

 	sb := newDispatchRequest(b, '\\', nil, NewBuildArgs(make(map[string]*string)), newStagesBuildResults())

 	cmd := &instructions.MaintainerCommand{Maintainer: maintainerEntry}

-	err := dispatch(sb, cmd)

+	err := dispatch(context.TODO(), sb, cmd)

 	assert.NilError(t, err)

 	assert.Check(t, is.Equal(maintainerEntry, sb.state.maintainer))

 }

@@ -94,14 +99,14 @@ func TestLabel(t *testing.T) {

 	labelName := "label"

 	labelValue := "value"

-	b := newBuilderWithMockBackend()

+	b := newBuilderWithMockBackend(t)

 	sb := newDispatchRequest(b, '\\', nil, NewBuildArgs(make(map[string]*string)), newStagesBuildResults())

 	cmd := &instructions.LabelCommand{

 		Labels: instructions.KeyValuePairs{

 			instructions.KeyValuePair{Key: labelName, Value: labelValue},

 		},

 	}

-	err := dispatch(sb, cmd)

+	err := dispatch(context.TODO(), sb, cmd)

 	assert.NilError(t, err)

 	assert.Assert(t, is.Contains(sb.state.runConfig.Labels, labelName))

@@ -109,12 +114,12 @@ func TestLabel(t *testing.T) {

 }

 func TestFromScratch(t *testing.T) {

-	b := newBuilderWithMockBackend()

+	b := newBuilderWithMockBackend(t)

 	sb := newDispatchRequest(b, '\\', nil, NewBuildArgs(make(map[string]*string)), newStagesBuildResults())

 	cmd := &instructions.Stage{

 		BaseName: "scratch",

 	}

-	err := initializeStage(sb, cmd)

+	err := initializeStage(context.TODO(), sb, cmd)

 	if runtime.GOOS == "windows" {

 		assert.Check(t, is.Error(err, "Windows does not support FROM scratch"))

@@ -135,7 +140,7 @@ func TestFromWithArg(t *testing.T) {

 		assert.Check(t, is.Equal("alpine"+tag, name))

 		return &mockImage{id: "expectedthisid"}, nil, nil

 	}

-	b := newBuilderWithMockBackend()

+	b := newBuilderWithMockBackend(t)

 	b.docker.(*MockBackend).getImageFunc = getImage

 	args := NewBuildArgs(make(map[string]*string))

@@ -151,7 +156,7 @@ func TestFromWithArg(t *testing.T) {

 	sb := newDispatchRequest(b, '\\', nil, args, newStagesBuildResults())

 	assert.NilError(t, err)

-	err = initializeStage(sb, cmd)

+	err = initializeStage(context.TODO(), sb, cmd)

 	assert.NilError(t, err)

 	assert.Check(t, is.Equal(expected, sb.state.imageID))

@@ -161,7 +166,7 @@ func TestFromWithArg(t *testing.T) {

 }

 func TestFromWithArgButBuildArgsNotGiven(t *testing.T) {

-	b := newBuilderWithMockBackend()

+	b := newBuilderWithMockBackend(t)

 	args := NewBuildArgs(make(map[string]*string))

 	metaArg := instructions.ArgCommand{}

@@ -172,7 +177,7 @@ func TestFromWithArgButBuildArgsNotGiven(t *testing.T) {

 	sb := newDispatchRequest(b, '\\', nil, args, newStagesBuildResults())

 	assert.NilError(t, err)

-	err = initializeStage(sb, cmd)

+	err = initializeStage(context.TODO(), sb, cmd)

 	assert.Error(t, err, "base name (${THETAG}) should not be blank")

 }

@@ -183,7 +188,7 @@ func TestFromWithUndefinedArg(t *testing.T) {

 		assert.Check(t, is.Equal("alpine", name))

 		return &mockImage{id: "expectedthisid"}, nil, nil

 	}

-	b := newBuilderWithMockBackend()

+	b := newBuilderWithMockBackend(t)

 	b.docker.(*MockBackend).getImageFunc = getImage

 	sb := newDispatchRequest(b, '\\', nil, NewBuildArgs(make(map[string]*string)), newStagesBuildResults())

@@ -192,41 +197,41 @@ func TestFromWithUndefinedArg(t *testing.T) {

 	cmd := &instructions.Stage{

 		BaseName: "alpine${THETAG}",

 	}

-	err := initializeStage(sb, cmd)

+	err := initializeStage(context.TODO(), sb, cmd)

 	assert.NilError(t, err)

 	assert.Check(t, is.Equal(expected, sb.state.imageID))

 }

 func TestFromMultiStageWithNamedStage(t *testing.T) {

-	b := newBuilderWithMockBackend()

+	b := newBuilderWithMockBackend(t)

 	firstFrom := &instructions.Stage{BaseName: "someimg", Name: "base"}

 	secondFrom := &instructions.Stage{BaseName: "base"}

 	previousResults := newStagesBuildResults()

 	firstSB := newDispatchRequest(b, '\\', nil, NewBuildArgs(make(map[string]*string)), previousResults)

 	secondSB := newDispatchRequest(b, '\\', nil, NewBuildArgs(make(map[string]*string)), previousResults)

-	err := initializeStage(firstSB, firstFrom)

+	err := initializeStage(context.TODO(), firstSB, firstFrom)

 	assert.NilError(t, err)

 	assert.Check(t, firstSB.state.hasFromImage())

 	previousResults.indexed["base"] = firstSB.state.runConfig

 	previousResults.flat = append(previousResults.flat, firstSB.state.runConfig)

-	err = initializeStage(secondSB, secondFrom)

+	err = initializeStage(context.TODO(), secondSB, secondFrom)

 	assert.NilError(t, err)

 	assert.Check(t, secondSB.state.hasFromImage())

 }

 func TestOnbuild(t *testing.T) {

-	b := newBuilderWithMockBackend()

+	b := newBuilderWithMockBackend(t)

 	sb := newDispatchRequest(b, '\\', nil, NewBuildArgs(make(map[string]*string)), newStagesBuildResults())

 	cmd := &instructions.OnbuildCommand{

 		Expression: "ADD . /app/src",

 	}

-	err := dispatch(sb, cmd)

+	err := dispatch(context.TODO(), sb, cmd)

 	assert.NilError(t, err)

 	assert.Check(t, is.Equal("ADD . /app/src", sb.state.runConfig.OnBuild[0]))

 }

 func TestWorkdir(t *testing.T) {

-	b := newBuilderWithMockBackend()

+	b := newBuilderWithMockBackend(t)

 	sb := newDispatchRequest(b, '`', nil, NewBuildArgs(make(map[string]*string)), newStagesBuildResults())

 	sb.state.baseImage = &mockImage{}

 	workingDir := "/app"

@@ -237,13 +242,13 @@ func TestWorkdir(t *testing.T) {

 		Path: workingDir,

 	}

-	err := dispatch(sb, cmd)

+	err := dispatch(context.TODO(), sb, cmd)

 	assert.NilError(t, err)

 	assert.Check(t, is.Equal(workingDir, sb.state.runConfig.WorkingDir))

 }

 func TestCmd(t *testing.T) {

-	b := newBuilderWithMockBackend()

+	b := newBuilderWithMockBackend(t)

 	sb := newDispatchRequest(b, '`', nil, NewBuildArgs(make(map[string]*string)), newStagesBuildResults())

 	sb.state.baseImage = &mockImage{}

 	command := "./executable"

@@ -254,7 +259,7 @@ func TestCmd(t *testing.T) {

 			PrependShell: true,

 		},

 	}

-	err := dispatch(sb, cmd)

+	err := dispatch(context.TODO(), sb, cmd)

 	assert.NilError(t, err)

 	var expectedCommand strslice.StrSlice

@@ -269,14 +274,14 @@ func TestCmd(t *testing.T) {

 }

 func TestHealthcheckNone(t *testing.T) {

-	b := newBuilderWithMockBackend()

+	b := newBuilderWithMockBackend(t)

 	sb := newDispatchRequest(b, '`', nil, NewBuildArgs(make(map[string]*string)), newStagesBuildResults())

 	cmd := &instructions.HealthCheckCommand{

 		Health: &container.HealthConfig{

 			Test: []string{"NONE"},

 		},

 	}

-	err := dispatch(sb, cmd)

+	err := dispatch(context.TODO(), sb, cmd)

 	assert.NilError(t, err)

 	assert.Assert(t, sb.state.runConfig.Healthcheck != nil)

@@ -284,7 +289,7 @@ func TestHealthcheckNone(t *testing.T) {

 }

 func TestHealthcheckCmd(t *testing.T) {

-	b := newBuilderWithMockBackend()

+	b := newBuilderWithMockBackend(t)

 	sb := newDispatchRequest(b, '`', nil, NewBuildArgs(make(map[string]*string)), newStagesBuildResults())

 	expectedTest := []string{"CMD-SHELL", "curl -f http://localhost/ || exit 1"}

 	cmd := &instructions.HealthCheckCommand{

@@ -292,7 +297,7 @@ func TestHealthcheckCmd(t *testing.T) {

 			Test: expectedTest,

 		},

 	}

-	err := dispatch(sb, cmd)

+	err := dispatch(context.TODO(), sb, cmd)

 	assert.NilError(t, err)

 	assert.Assert(t, sb.state.runConfig.Healthcheck != nil)

@@ -300,7 +305,7 @@ func TestHealthcheckCmd(t *testing.T) {

 }

 func TestEntrypoint(t *testing.T) {

-	b := newBuilderWithMockBackend()

+	b := newBuilderWithMockBackend(t)

 	sb := newDispatchRequest(b, '`', nil, NewBuildArgs(make(map[string]*string)), newStagesBuildResults())

 	sb.state.baseImage = &mockImage{}

 	entrypointCmd := "/usr/sbin/nginx"

@@ -311,7 +316,7 @@ func TestEntrypoint(t *testing.T) {

 			PrependShell: true,

 		},

 	}

-	err := dispatch(sb, cmd)

+	err := dispatch(context.TODO(), sb, cmd)

 	assert.NilError(t, err)

 	assert.Assert(t, sb.state.runConfig.Entrypoint != nil)

@@ -325,14 +330,14 @@ func TestEntrypoint(t *testing.T) {

 }

 func TestExpose(t *testing.T) {

-	b := newBuilderWithMockBackend()

+	b := newBuilderWithMockBackend(t)

 	sb := newDispatchRequest(b, '`', nil, NewBuildArgs(make(map[string]*string)), newStagesBuildResults())

 	exposedPort := "80"

 	cmd := &instructions.ExposeCommand{

 		Ports: []string{exposedPort},

 	}

-	err := dispatch(sb, cmd)

+	err := dispatch(context.TODO(), sb, cmd)

 	assert.NilError(t, err)

 	assert.Assert(t, sb.state.runConfig.ExposedPorts != nil)

@@ -344,19 +349,19 @@ func TestExpose(t *testing.T) {

 }

 func TestUser(t *testing.T) {

-	b := newBuilderWithMockBackend()

+	b := newBuilderWithMockBackend(t)

 	sb := newDispatchRequest(b, '`', nil, NewBuildArgs(make(map[string]*string)), newStagesBuildResults())

 	cmd := &instructions.UserCommand{

 		User: "test",

 	}

-	err := dispatch(sb, cmd)

+	err := dispatch(context.TODO(), sb, cmd)

 	assert.NilError(t, err)

 	assert.Check(t, is.Equal("test", sb.state.runConfig.User))

 }

 func TestVolume(t *testing.T) {

-	b := newBuilderWithMockBackend()

+	b := newBuilderWithMockBackend(t)

 	sb := newDispatchRequest(b, '`', nil, NewBuildArgs(make(map[string]*string)), newStagesBuildResults())

 	exposedVolume := "/foo"

@@ -364,7 +369,7 @@ func TestVolume(t *testing.T) {

 	cmd := &instructions.VolumeCommand{

 		Volumes: []string{exposedVolume},