Repository: kubernetes/minikube
Pull request #10919 (2021-03-25 00:57:05)

site: spelling 
correct a wrong word


Patch:
diff --git a/cmd/minikube/cmd/image.go b/cmd/minikube/cmd/image.go
index de3e80e38..3186c7120 100644
--- a/cmd/minikube/cmd/image.go
+++ b/cmd/minikube/cmd/image.go
@@ -17,16 +17,10 @@ limitations under the License.
 package cmd
 
 import (
-	"io"
-	"io/ioutil"
-	"os"
-	"strings"
-
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"k8s.io/minikube/pkg/minikube/config"
 	"k8s.io/minikube/pkg/minikube/exit"
-	"k8s.io/minikube/pkg/minikube/image"
 	"k8s.io/minikube/pkg/minikube/machine"
 	"k8s.io/minikube/pkg/minikube/reason"
 )
@@ -38,33 +32,11 @@ var imageCmd = &cobra.Command{
 	Long:  "Load a local image into minikube",
 }
 
-var (
-	imgDaemon bool
-	imgRemote bool
-)
-
-func saveFile(r io.Reader) (string, error) {
-	tmp, err := ioutil.TempFile("", "build.*.tar")
-	if err != nil {
-		return "", err
-	}
-	_, err = io.Copy(tmp, r)
-	if err != nil {
-		return "", err
-	}
-	err = tmp.Close()
-	if err != nil {
-		return "", err
-	}
-	return tmp.Name(), nil
-}
-
 // loadImageCmd represents the image load command
 var loadImageCmd = &cobra.Command{
-	Use:     "load IMAGE | ARCHIVE | -",
-	Short:   "Load a image into minikube",
-	Long:    "Load a image into minikube",
-	Example: "minikube image load image\nminikube image load image.tar",
+	Use:   "load",
+	Short: "Load a local image into minikube",
+	Long:  "Load a local image into minikube",
 	Run: func(cmd *cobra.Command, args []string) {
 		if len(args) == 0 {
 			exit.Message(reason.Usage, "Please provide an image in your local daemon to load into minikube via <minikube image load IMAGE_NAME>")
@@ -74,59 +46,13 @@ var loadImageCmd = &cobra.Command{
 		if err != nil {
 			exit.Error(reason.Usage, "loading profile", err)
 		}
-
-		var local bool
-		if imgRemote || imgDaemon {
-			local = false
-		} else {
-			for _, img := range args {
-				if img == "-" { // stdin
-					local = true
-					imgDaemon = false
-					imgRemote = false
-				} else if strings.HasPrefix(img, "/") || strings.HasPrefix(img, ".") {
-					local = true
-					imgDaemon = false
-					imgRemote = false
-				} else if _, err := os.Stat(img); err == nil {
-					local = true
-					imgDaemon = false
-					imgRemote = false
-				}
-			}
-
-			if !local {
-				imgDaemon = true
-				imgRemote = true
-			}
-		}
-
-		if args[0] == "-" {
-			tmp, err := saveFile(os.Stdin)
-			if err != nil {
-				exit.Error(reason.GuestImageLoad, "Failed to save stdin", err)
-			}
-			args = []string{tmp}
-		}
-
-		if imgDaemon || imgRemote {
-			image.UseDaemon(imgDaemon)
-			image.UseRemote(imgRemote)
-			if err := machine.CacheAndLoadImages(args, []*config.Profile{profile}); err != nil {
-				exit.Error(reason.GuestImageLoad, "Failed to load image", err)
-			}
-		} else if local {
-			// Load images from local files, without doing any caching or checks in container runtime
-			// This is similar to tarball.Image but it is done by the container runtime in the cluster.
-			if err := machine.DoLoadImages(args, []*config.Profile{profile}, ""); err != nil {
-				exit.Error(reason.GuestImageLoad, "Failed to load image", err)
-			}
+		img := args[0]
+		if err := machine.CacheAndLoadImages([]string{img}, []*config.Profile{profile}); err != nil {
+			exit.Error(reason.GuestImageLoad, "Failed to load image", err)
 		}
 	},
 }
 
 func init() {
 	imageCmd.AddCommand(loadImageCmd)
-	loadImageCmd.Flags().BoolVar(&imgDaemon, "daemon", false, "Cache image from docker daemon")
-	loadImageCmd.Flags().BoolVar(&imgRemote, "remote", false, "Cache image from remote registry")
 }
diff --git a/cmd/minikube/cmd/status.go b/cmd/minikube/cmd/status.go
index dd651e159..710990297 100644
--- a/cmd/minikube/cmd/status.go
+++ b/cmd/minikube/cmd/status.go
@@ -136,7 +136,7 @@ type Status struct {
 	APIServer  string
 	Kubeconfig string
 	Worker     bool
-	TimeToStop string `json:",omitempty"`
+	TimeToStop string
 	DockerEnv  string `json:",omitempty"`
 	PodManEnv  string `json:",omitempty"`
 }
@@ -146,7 +146,7 @@ type ClusterState struct {
 	BaseState
 
 	BinaryVersion string
-	TimeToStop    string `json:",omitempty"`
+	TimeToStop    string
 	Components    map[string]BaseState
 	Nodes         []NodeState
 }
@@ -185,9 +185,7 @@ host: {{.Host}}
 kubelet: {{.Kubelet}}
 apiserver: {{.APIServer}}
 kubeconfig: {{.Kubeconfig}}
-{{- if .TimeToStop }}
 timeToStop: {{.TimeToStop}}
-{{- end }}
 {{- if .DockerEnv }}
 docker-env: {{.DockerEnv}}
 {{- end }}
@@ -321,6 +319,7 @@ func nodeStatus(api libmachine.API, cc config.ClusterConfig, n config.Node) (*St
 		Kubelet:    Nonexistent,
 		Kubeconfig: Nonexistent,
 		Worker:     !controlPlane,
+		TimeToStop: Nonexistent,
 	}
 
 	hs, err := machine.Status(api, name)
diff --git a/hack/jenkins/common.sh b/hack/jenkins/common.sh
index feb09d8a1..1d3bc108e 100755
--- a/hack/jenkins/common.sh
+++ b/hack/jenkins/common.sh
@@ -375,7 +375,7 @@ touch "${HTML_OUT}"
 touch "${SUMMARY_OUT}"
 gopogh_status=$(gopogh -in "${JSON_OUT}" -out_html "${HTML_OUT}" -out_summary "${SUMMARY_OUT}" -name "${JOB_NAME}" -pr "${MINIKUBE_LOCATION}" -repo github.com/kubernetes/minikube/  -details "${COMMIT}") || true
 fail_num=$(echo $gopogh_status | jq '.NumberOfFail')
-test_num=$(echo $gopogh_status | jq '.NumberOfTests')
+test_num=$(echo $gopogh_status | jq '.NumberOfTests')       
 pessimistic_status="${fail_num} / ${test_num} failures"
 description="completed with ${status} in ${elapsed} minute(s)."
 if [ "$status" = "failure" ]; then
@@ -445,7 +445,7 @@ function retry_github_status() {
     echo "HTTP code ${code}! Retrying in ${timeout} .."
     sleep "${timeout}"
     attempt=$(( attempt + 1 ))
-    timeout=$(( timeout * 5 ))
+    timeout=$(( timeout * 5 )) 
   done
 }
 
diff --git a/hack/jenkins/installers/check_install_docker.sh b/hack/jenkins/installers/check_install_docker.sh
index 23acba730..cf2e5e9de 100755
--- a/hack/jenkins/installers/check_install_docker.sh
+++ b/hack/jenkins/installers/check_install_docker.sh
@@ -16,8 +16,6 @@
 
 set -eux -o pipefail
 
-ARCH=${ARCH:=amd64}
-
 if [[ "$OSTYPE" == "darwin"* ]]; then
   echo "detected darwin, exiting"
   exit 0
@@ -30,5 +28,5 @@ rm get-docker.sh
 sudo adduser jenkins docker || true
 
 echo "Installing latest kubectl"
-curl -LO "https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/${ARCH}/kubectl"
+curl -LO "https://storage.googleapis.com/kubernetes-release/release/`curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt`/bin/linux/amd64/kubectl"
 sudo install ./kubectl /usr/local/bin/kubectl
diff --git a/hack/jenkins/installers/check_install_golang.sh b/hack/jenkins/installers/check_install_golang.sh
index b01ef8595..40cb0feaf 100755
--- a/hack/jenkins/installers/check_install_golang.sh
+++ b/hack/jenkins/installers/check_install_golang.sh
@@ -25,8 +25,6 @@ fi
 VERSION_TO_INSTALL=${1}
 INSTALL_PATH=${2}
 
-ARCH=${ARCH:=amd64}
-
 # installs or updates golang if right version doesn't exists
 function check_and_install_golang() {
   if ! go version &>/dev/null; then
@@ -61,7 +59,7 @@ function install_golang() {
   fi
   # using sudo because previously installed versions might have been installed by a different user.
   # as it was the case on jenkins VM.
-  sudo curl -qL -O "https://storage.googleapis.com/golang/go${1}.${INSTALLOS}-${ARCH}.tar.gz" &&
+  sudo curl -qL -O "https://storage.googleapis.com/golang/go${1}.${INSTALLOS}-amd64.tar.gz" &&
     sudo tar -xf go${1}.${INSTALLOS}-amd64.tar.gz &&
     sudo rm -rf "${2}/go" &&
     sudo mv go "${2}/" && sudo chown -R $(whoami): ${2}/go
diff --git a/hack/jenkins/minikube_set_pending.sh b/hack/jenkins/minikube_set_pending.sh
index 923d58cd0..63c50dd60 100755
--- a/hack/jenkins/minikube_set_pending.sh
+++ b/hack/jenkins/minikube_set_pending.sh
@@ -43,9 +43,6 @@ jobs=(
      'KVM_Linux_crio'
      'none_Linux'
      'Docker_Linux'
-     'Docker_Linux_docker_arm64'
-     'Docker_Linux_containerd_arm64'
-     'Docker_Linux_crio_arm64'
      'Docker_Linux_containerd'
      'Docker_Linux_crio'
      # 'Docker_macOS'
diff --git a/hack/jenkins/upload_integration_report.sh b/hack/jenkins/upload_integration_report.sh
deleted file mode 100644
index a96cd1ab8..000000000
--- a/hack/jenkins/upload_integration_report.sh
+++ /dev/null
@@ -1,52 +0,0 @@
-#!/bin/bash
-
-# Copyright 2021 The Kubernetes Authors All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-# This script uploads the test reports to the GCS bucket
-
-# The script expects the following env variables:
-# OS_ARCH: The operating system and the architecture separated by a hyphen '-' (e.g. darwin-amd64, linux-amd64, windows-amd64)
-# VM_DRIVER: the driver to use for the test
-# CONTAINER_RUNTIME: the container runtime to use for the test
-# EXTRA_START_ARGS: additional flags to pass into minikube start
-# EXTRA_TEST_ARGS: additional flags to pass into go test
-# JOB_NAME: the name of the logfile and check name to update on github
-
-
-# upload results to GCS
-JOB_GCS_BUCKET="minikube-builds/logs/${MINIKUBE_LOCATION}/${COMMIT:0:7}/${UPSTREAM_JOB}"
-
-ARTIFACTS=artifacts/test_reports
-
-ls -l artifacts
-ls -l artifacts/test_reports
-
-TEST_OUT="$ARTIFACTS/out.txt"
-echo ">> uploading ${TEST_OUT} to gs://${JOB_GCS_BUCKET}.txt"
-gsutil -qm cp "${TEST_OUT}" "gs://${JOB_GCS_BUCKET}.txt" || true
-
-JSON_OUT="$ARTIFACTS/out.json"
-echo ">> uploading ${JSON_OUT}"
-gsutil -qm cp "${JSON_OUT}" "gs://${JOB_GCS_BUCKET}.json" || true
-
-HTML_OUT="$ARTIFACTS/out.html"
-echo ">> uploading ${HTML_OUT}"
-gsutil -qm cp "${HTML_OUT}" "gs://${JOB_GCS_BUCKET}.html" || true
-
-SUMMARY_OUT="$ARTIFACTS/summary.txt"
-echo ">> uploading ${SUMMARY_OUT}"
-gsutil -qm cp "${SUMMARY_OUT}" "gs://${JOB_GCS_BUCKET}_summary.json" || true
-#
diff --git a/pkg/drivers/kic/oci/network_create.go b/pkg/drivers/kic/oci/network_create.go
index 1b671ee75..2766044e0 100644
--- a/pkg/drivers/kic/oci/network_create.go
+++ b/pkg/drivers/kic/oci/network_create.go
@@ -35,6 +35,9 @@ import (
 // it is one octet more than the one used by KVM to avoid possible conflict
 const firstSubnetAddr = "192.168.49.0"
 
+// big enough for a cluster of 254 nodes
+const defaultSubnetMask = 24
+
 // name of the default bridge network, used to lookup the MTU (see #9528)
 const dockerDefaultBridge = "bridge"
 
@@ -68,42 +71,30 @@ func CreateNetwork(ociBin string, networkName string) (net.IP, error) {
 	if err != nil {
 		klog.Warningf("failed to get mtu information from the %s's default network %q: %v", ociBin, defaultBridgeName, err)
 	}
-
-	// retry up to 5 times to create container network
-	for attempts, subnetAddr := 0, firstSubnetAddr; attempts < 5; attempts++ {
-		// Rather than iterate through all of the valid subnets, give up at 20 to avoid a lengthy user delay for something that is unlikely to work.
-		// will be like 192.168.49.0/24,..., 192.168.220.0/24 (in increment steps of 9)
-		var subnet *network.Parameters
-		subnet, err = network.FreeSubnet(subnetAddr, 9, 20)
-		if err != nil {
-			klog.Errorf("failed to find free subnet for %s network %s after %d attempts: %v", ociBin, networkName, 20, err)
-			return nil, fmt.Errorf("un-retryable: %w", err)
-		}
-		info.gateway, err = tryCreateDockerNetwork(ociBin, subnet, info.mtu, networkName)
-		if err == nil {
-			klog.Infof("%s network %s %s created", ociBin, networkName, subnet.CIDR)
-			return info.gateway, nil
-		}
-		// don't retry if error is not adddress is taken
-		if !(errors.Is(err, ErrNetworkSubnetTaken) || errors.Is(err, ErrNetworkGatewayTaken)) {
-			klog.Errorf("error while trying to create %s network %s %s: %v", ociBin, networkName, subnet.CIDR, err)
-			return nil, fmt.Errorf("un-retryable: %w", err)
-		}
-		klog.Warningf("failed to create %s network %s %s, will retry: %v", ociBin, networkName, subnet.CIDR, err)
-		subnetAddr = subnet.IP
+	// Rather than iterate through all of the valid subnets, give up at 20 to avoid a lengthy user delay for something that is unlikely to work.
+	// will be like 192.168.49.0/24 ,...,192.168.239.0/24
+	subnet, err := network.FreeSubnet(firstSubnetAddr, 10, 20)
+	if err != nil {
+		klog.Errorf("error while trying to create network: %v", err)
+		return nil, errors.Wrap(err, "un-retryable")
+	}
+	info.gateway, err = tryCreateDockerNetwork(ociBin, subnet.IP, defaultSubnetMask, info.mtu, networkName)
+	if err != nil {
+		return info.gateway, fmt.Errorf("failed to create network after 20 attempts")
 	}
-	return info.gateway, fmt.Errorf("failed to create %s network %s: %w", ociBin, networkName, err)
+	return info.gateway, nil
 }
 
-func tryCreateDockerNetwork(ociBin string, subnet *network.Parameters, mtu int, name string) (net.IP, error) {
-	gateway := net.ParseIP(subnet.Gateway)
-	klog.Infof("attempt to create %s network %s %s with gateway %s and MTU of %d ...", ociBin, name, subnet.CIDR, subnet.Gateway, mtu)
+func tryCreateDockerNetwork(ociBin string, subnetAddr string, subnetMask int, mtu int, name string) (net.IP, error) {
+	gateway := net.ParseIP(subnetAddr)
+	gateway.To4()[3]++ // first ip for gateway
+	klog.Infof("attempt to create network %s/%d with subnet: %s and gateway %s and MTU of %d ...", subnetAddr, subnetMask, name, gateway, mtu)
 	args := []string{
 		"network",
 		"create",
 		"--driver=bridge",
-		fmt.Sprintf("--subnet=%s", subnet.CIDR),
-		fmt.Sprintf("--gateway=%s", subnet.Gateway),
+		fmt.Sprintf("--subnet=%s", fmt.Sprintf("%s/%d", subnetAddr, subnetMask)),
+		fmt.Sprintf("--gateway=%s", gateway),
 	}
 	if ociBin == Docker {
 		// options documentation https://docs.docker.com/engine/reference/commandline/network_create/#bridge-driver-options
@@ -134,7 +125,7 @@ func tryCreateDockerNetwork(ociBin string, subnet *network.Parameters, mtu int,
 		if strings.Contains(rr.Output(), "is being used by a network interface") {
 			return nil, ErrNetworkGatewayTaken
 		}
-		return nil, fmt.Errorf("create %s network %s %s with gateway %s and MTU of %d: %w", ociBin, name, subnet.CIDR, subnet.Gateway, mtu, err)
+		return nil, errors.Wrapf(err, "create network %s", fmt.Sprintf("%s %s/%d", name, subnetAddr, subnetMask))
 	}
 	return gateway, nil
 }
diff --git a/pkg/drivers/kvm/network.go b/pkg/drivers/kvm/network.go
index 52cf8286d..6254d2f10 100644
--- a/pkg/drivers/kvm/network.go
+++ b/pkg/drivers/kvm/network.go
@@ -149,62 +149,61 @@ func (d *Driver) createNetwork() error {
 	// It is assumed that the libvirt/kvm installation has already created this network
 	netd, err := conn.LookupNetworkByName(d.Network)
 	if err != nil {
-		return errors.Wrapf(err, "%s KVM network doesn't exist", d.Network)
-	}
-	log.Debugf("found existing %s KVM network", d.Network)
-	if netd != nil {
-		_ = netd.Free()
+		return errors.Wrapf(err, "network %s doesn't exist", d.Network)
 	}
+	defer func() { _ = netd.Free() }()
 
 	// network: private
 	// Only create the private network if it does not already exist
 	netp, err := conn.LookupNetworkByName(d.PrivateNetwork)
-	defer func() {
-		if netp != nil {
-			_ = netp.Free()
-		}
-	}()
-	if err == nil {
-		log.Debugf("found existing private KVM network %s", d.PrivateNetwork)
-		return nil
-	}
-
-	// retry up to 5 times to create kvm network
-	for attempts, subnetAddr := 0, firstSubnetAddr; attempts < 5; attempts++ {
-		// Rather than iterate through all of the valid subnets, give up at 20 to avoid a lengthy user delay for something that is unlikely to work.
-		// will be like 192.168.39.0/24,..., 192.168.248.0/24 (in increment steps of 11)
-		var subnet *network.Parameters
-		subnet, err = network.FreeSubnet(subnetAddr, 11, 20)
+	if err != nil {
+		subnet, err := network.FreeSubnet(firstSubnetAddr, 10, 20)
 		if err != nil {
-			log.Debugf("failed to find free subnet for private KVM network %s after %d attempts: %v", d.PrivateNetwork, 20, err)
-			return fmt.Errorf("un-retryable: %w", err)
+			log.Debugf("error while trying to create network: %v", err)
+			return errors.Wrap(err, "un-retryable")
 		}
-		// create the XML for the private network from our networkTmpl
 		tryNet := kvmNetwork{
 			Name:       d.PrivateNetwork,
 			Parameters: *subnet,
 		}
+
+		// create the XML for the private network from our networkTmpl
 		tmpl := template.Must(template.New("network").Parse(networkTmpl))
 		var networkXML bytes.Buffer
-		if err = tmpl.Execute(&networkXML, tryNet); err != nil {
-			return fmt.Errorf("executing private KVM network template: %w", err)
+		if err := tmpl.Execute(&networkXML, tryNet); err != nil {
+			return errors.Wrap(err, "executing network template")
 		}
+
 		// define the network using our template
-		var network *libvirt.Network
-		network, err = conn.NetworkDefineXML(networkXML.String())
+		network, err := conn.NetworkDefineXML(networkXML.String())
 		if err != nil {
-			return fmt.Errorf("defining private KVM network %s %s from xml %s: %w", d.PrivateNetwork, subnet.CIDR, networkXML.String(), err)
+			return errors.Wrapf(err, "defining network from xml: %s", networkXML.String())
 		}
-		// and finally create & start it
-		log.Debugf("trying to create private KVM network %s %s...", d.PrivateNetwork, subnet.CIDR)
-		if err = network.Create(); err == nil {
-			log.Debugf("private KVM network %s %s created", d.PrivateNetwork, subnet.CIDR)
-			return nil
+
+		// and finally create it
+		log.Debugf("Trying to create network %s...", d.PrivateNetwork)
+		create := func() error {
+			if err := network.Create(); err != nil {
+				return err
+			}
+			active, err := network.IsActive()
+			if err == nil && active {
+				return nil
+			}
+			return errors.Errorf("retrying %v", err)
+		}
+		if err := retry.Local(create, 10*time.Second); err != nil {
+			return errors.Wrapf(err, "creating network %s", d.PrivateNetwork)
 		}
-		log.Debugf("failed to create private KVM network %s %s, will retry: %v", d.PrivateNetwork, subnet.CIDR, err)
-		subnetAddr = subnet.IP
+		log.Debugf("Network %s created", d.PrivateNetwork)
 	}
-	return fmt.Errorf("failed to create private KVM network %s: %w", d.PrivateNetwork, err)
+	defer func() {
+		if netp != nil {
+			_ = netp.Free()
+		}
+	}()
+
+	return nil
 }
 
 func (d *Driver) deleteNetwork() error {
diff --git a/pkg/generate/docs.go b/pkg/generate/docs.go
index 17a2c2cad..fefc720d8 100644
--- a/pkg/generate/docs.go
+++ b/pkg/generate/docs.go
@@ -56,9 +56,6 @@ func DocForCommand(command *cobra.Command) (string, error) {
 	if err := generateTitle(command, buf); err != nil {
 		return "", errors.Wrap(err, "generating title")
 	}
-	if err := rewriteLogFile(); err != nil {
-		return "", errors.Wrap(err, "rewriting log_file")
-	}
 	if err := rewriteFlags(command); err != nil {
 		return "", errors.Wrap(err, "rewriting flags")
 	}
diff --git a/pkg/generate/rewrite.go b/pkg/generate/rewrite.go
index 5ff4cff5b..adca8d598 100644
--- a/pkg/generate/rewrite.go
+++ b/pkg/generate/rewrite.go
@@ -20,24 +20,8 @@ import (
 	"fmt"
 
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
-// rewriteLogFile resets the magic "log_file" flag
-// otherwise it starts out under $TMP somewhere
-// and shows up as Changed, to default value ""
-func rewriteLogFile() error {
-	flag := pflag.Lookup("log_file")
-	if flag != nil {
-		// don't show the default value
-		err := pflag.Set("log_file", "")
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 type rewrite struct {
 	flag       string
 	usage      string
diff --git a/pkg/minikube/bootstrapper/kubeadm/kubeadm.go b/pkg/minikube/bootstrapper/kubeadm/kubeadm.go
index 5f6506dcf..8ccf63beb 100644
--- a/pkg/minikube/bootstrapper/kubeadm/kubeadm.go
+++ b/pkg/minikube/bootstrapper/kubeadm/kubeadm.go
@@ -859,7 +859,7 @@ func (k *Bootstrapper) UpdateCluster(cfg config.ClusterConfig) error {
 	}
 
 	if cfg.KubernetesConfig.ShouldLoadCachedImages {
-		if err := machine.LoadCachedImages(&cfg, k.c, images, constants.ImageCacheDir); err != nil {
+		if err := machine.LoadImages(&cfg, k.c, images, constants.ImageCacheDir); err != nil {
 			out.FailureT("Unable to load cached images: {{.error}}", out.V{"error": err})
 		}
 	}
diff --git a/pkg/minikube/image/image.go b/pkg/minikube/image/image.go
index 6817f3c05..ee9a75b12 100644
--- a/pkg/minikube/image/image.go
+++ b/pkg/minikube/image/image.go
@@ -49,21 +49,6 @@ var defaultPlatform = v1.Platform{
 	OS:           "linux",
 }
 
-var (
-	useDaemon = true
-	useRemote = true
-)
-
-// UseDaemon is if we should look in local daemon for image ref
-func UseDaemon(use bool) {
-	useDaemon = use
-}
-
-// UseRemote is if we should look in remote registry for image ref
-func UseRemote(use bool) {
-	useRemote = use
-}
-
 // DigestByDockerLib uses client by docker lib to return image digest
 // img.ID in as same as image digest
 func DigestByDockerLib(imgClient *client.Client, imgName string) string {
@@ -213,31 +198,7 @@ func WriteImageToDaemon(img string) error {
 }
 
 func retrieveImage(ref name.Reference) (v1.Image, error) {
-	var err error
-	var img v1.Image
-
-	if !useDaemon && !useRemote {
-		return nil, fmt.Errorf("neither daemon nor remote")
-	}
-
 	klog.Infof("retrieving image: %+v", ref)
-	if useDaemon {
-		img, err = retrieveDaemon(ref)
-		if err == nil {
-			return img, nil
-		}
-	}
-	if useRemote {
-		img, err = retrieveRemote(ref, defaultPlatform)
-		if err == nil {
-			return fixPlatform(ref, img, defaultPlatform)
-		}
-	}
-
-	return nil, err
-}
-
-func retrieveDaemon(ref name.Reference) (v1.Image, error) {
 	img, err := daemon.Image(ref)
 	if err == nil {
 		klog.Infof("found %s locally: %+v", ref.Name(), img)
@@ -245,7 +206,12 @@ func retrieveDaemon(ref name.Reference) (v1.Image, error) {
 	}
 	// reference does not exist in the local daemon
 	klog.Infof("daemon lookup for %+v: %v", ref, err)
-	return img, err
+
+	img, err = retrieveRemote(ref, defaultPlatform)
+	if err != nil {
+		return nil, err
+	}
+	return fixPlatform(ref, img, defaultPlatform)
 }
 
 func retrieveRemote(ref name.Reference, p v1.Platform) (v1.Image, error) {
@@ -255,12 +221,7 @@ func retrieveRemote(ref name.Reference, p v1.Platform) (v1.Image, error) {
 	}
 
 	klog.Warningf("authn lookup for %+v (trying anon): %+v", ref, err)
-	img, err = remote.Image(ref, remote.WithPlatform(p))
-	// reference does not exist in the remote registry
-	if err != nil {
-		klog.Infof("remote lookup for %+v: %v", ref, err)
-	}
-	return img, err
+	return remote.Image(ref, remote.WithPlatform(p))
 }
 
 // See https://github.com/kubernetes/minikube/issues/10402
diff --git a/pkg/minikube/machine/cache_images.go b/pkg/minikube/machine/cache_images.go
index 304d9a6b7..1288e7117 100644
--- a/pkg/minikube/machine/cache_images.go
+++ b/pkg/minikube/machine/cache_images.go
@@ -61,8 +61,8 @@ func CacheImagesForBootstrapper(imageRepository string, version string, clusterB
 	return nil
 }
 
-// LoadCachedImages loads previously cached images into the container runtime
-func LoadCachedImages(cc *config.ClusterConfig, runner command.Runner, images []string, cacheDir string) error {
+// LoadImages loads previously cached images into the container runtime
+func LoadImages(cc *config.ClusterConfig, runner command.Runner, images []string, cacheDir string) error {
 	cr, err := cruntime.New(cruntime.Config{Type: cc.KubernetesConfig.ContainerRuntime, Runner: runner})
 	if err != nil {
 		return errors.Wrap(err, "runtime")
@@ -73,7 +73,6 @@ func LoadCachedImages(cc *config.ClusterConfig, runner command.Runner, images []
 		klog.Infof("Images are preloaded, skipping loading")
 		return nil
 	}
-
 	klog.Infof("LoadImages start: %s", images)
 	start := time.Now()
 
@@ -103,7 +102,7 @@ func LoadCachedImages(cc *config.ClusterConfig, runner command.Runner, images []
 				return nil
 			}
 			klog.Infof("%q needs transfer: %v", image, err)
-			return transferAndLoadCachedImage(runner, cc.KubernetesConfig, image, cacheDir)
+			return transferAndLoadImage(runner, cc.KubernetesConfig, image, cacheDir)
 		})
 	}
 	if err := g.Wait(); err != nil {
@@ -158,22 +157,6 @@ func needsTransfer(imgClient *client.Client, imgName string, cr cruntime.Manager
 	return nil
 }
 
-// LoadLocalImages loads images into the container runtime
-func LoadLocalImages(cc *config.ClusterConfig, runner command.Runner, images []string) error {
-	var g errgroup.Group
-	for _, image := range images {
-		image := image
-		g.Go(func() error {
-			return transferAndLoadImage(runner, cc.KubernetesConfig, image)
-		})
-	}
-	if err := g.Wait(); err != nil {
-		return errors.Wrap(err, "loading images")
-	}
-	klog.Infoln("Successfully loaded all images")
-	return nil
-}
-
 // CacheAndLoadImages caches and loads images to all profiles
 func CacheAndLoadImages(images []string, profiles []*config.Profile) error {
 	if len(images) == 0 {
@@ -185,11 +168,6 @@ func CacheAndLoadImages(images []string, profiles []*config.Profile) error {
 		return errors.Wrap(err, "save to dir")
 	}
 
-	return DoLoadImages(images, profiles, constants.ImageCacheDir)
-}
-
-// DoLoadImages loads images to all profiles
-func DoLoadImages(images []string, profiles []*config.Profile, cacheDir string) error {
 	api, err := NewAPIClient()
 	if err != nil {
 		return errors.Wrap(err, "api")
@@ -231,13 +209,7 @@ func DoLoadImages(images []string, profiles []*config.Profile, cacheDir string)
 				if err != nil {
 					return err
 				}
-				if cacheDir != "" {
-					// loading image names, from cache
-					err = LoadCachedImages(c, cr, images, cacheDir)
-				} else {
-					// loading image files
-					err = LoadLocalImages(c, cr, images)
-				}
+				err = LoadImages(c, cr, images, constants.ImageCacheDir)
 				if err != nil {
 					failed = append(failed, m)
 					klog.Warningf("Failed to load cached images for profile %s. make sure the profile is running. %v", pName, err)
@@ -254,20 +226,15 @@ func DoLoadImages(images []string, profiles []*config.Profile, cacheDir string)
 	return nil
 }
 
-// transferAndLoadCachedImage transfers and loads a single image from the cache
-func transferAndLoadCachedImage(cr command.Runner, k8s config.KubernetesConfig, imgName string, cacheDir string) error {
-	src := filepath.Join(cacheDir, imgName)
-	src = localpath.SanitizeCacheDir(src)
-	return transferAndLoadImage(cr, k8s, src)
-}
-
-// transferAndLoadImage transfers and loads a single image
-func transferAndLoadImage(cr command.Runner, k8s config.KubernetesConfig, src string) error {
+// transferAndLoadImage transfers and loads a single image from the cache
+func transferAndLoadImage(cr command.Runner, k8s config.KubernetesConfig, imgName string, cacheDir string) error {
 	r, err := cruntime.New(cruntime.Config{Type: k8s.ContainerRuntime, Runner: cr})
 	if err != nil {
 		return errors.Wrap(err, "runtime")
 	}
-	klog.Infof("Loading image from: %s", src)
+	src := filepath.Join(cacheDir, imgName)
+	src = localpath.SanitizeCacheDir(src)
+	klog.Infof("Loading image from cache: %s", src)
 	filename := filepath.Base(src)
 	if _, err := os.Stat(src); err != nil {
 		return err
diff --git a/pkg/network/network.go b/pkg/network/network.go
index dbe5c14d5..80933b072 100644
--- a/pkg/network/network.go
+++ b/pkg/network/network.go
@@ -20,18 +20,12 @@ import (
 	"encoding/binary"
 	"fmt"
 	"net"
-	"sync"
-	"time"
 
 	"github.com/pkg/errors"
 	"k8s.io/klog/v2"
 )
 
-const defaultReservationPeriod = 1 * time.Minute
-
 var (
-	reservedSubnets = sync.Map{}
-
 	// valid private network subnets (RFC1918)
 	privateSubnets = []net.IPNet{
 		// 10.0.0.0/8
@@ -52,11 +46,6 @@ var (
 	}
 )
 
-// reservation of free private subnet is held for defined reservation period from createdAt time.
-type reservation struct {
-	createdAt time.Time
-}
-
 // Parameters contains main network parameters.
 type Parameters struct {
 	IP        string // IP address of the network
@@ -201,14 +190,10 @@ func FreeSubnet(startSubnet string, step, tries int) (*Parameters, error) {
 				return nil, err
 			}
 			if !taken {
-				if ok := reserveSubnet(startSubnet, defaultReservationPeriod); ok {
-					klog.Infof("using free private subnet %s: %+v", n.CIDR, n)
-					return n, nil
-				}
-				klog.Infof("skipping subnet %s that is reserved: %+v", n.CIDR, n)
-			} else {
-				klog.Infof("skipping subnet %s that is taken: %+v", n.CIDR, n)
+				klog.Infof("using free private subnet %s: %+v", n.CIDR, n)
+				return n, nil
 			}
+			klog.Infof("skipping subnet %s that is taken: %+v", n.CIDR, n)
 		} else {
 			klog.Infof("skipping subnet %s that is not private", n.CIDR)
 		}
@@ -223,39 +208,3 @@ func FreeSubnet(startSubnet string, step, tries int) (*Parameters, error) {
 	}
 	return nil, fmt.Errorf("no free private network subnets found with given parameters (start: %q, step: %d, tries: %d)", startSubnet, step, tries)
 }
-
-// reserveSubnet returns if subnet was successfully reserved for given period:
-//  - false, if it already has unexpired reservation
-//  - true, if new reservation was created or expired one renewed
-// uses sync.Map to manage reservations thread-safe
-func reserveSubnet(subnet string, period time.Duration) bool {
-	// put 'zero' reservation{} Map value for subnet Map key
-	// to block other processes from concurently changing this subnet
-	zero := reservation{}
-	r, loaded := reservedSubnets.LoadOrStore(subnet, zero)
-	// check if there was previously issued reservation
-	if loaded {
-		// back off if previous reservation was already set to 'zero'
-		// as then other process is already managing this subnet concurently
-		if r == zero {
-			klog.Infof("backing off reserving subnet %s (other process is managing it!): %+v", subnet, &reservedSubnets)
-			return false
-		}
-		// check if previous reservation expired
-		createdAt := r.(reservation).createdAt
-		if time.Since(createdAt) < period {
-			// unexpired reservation: restore original createdAt value
-			reservedSubnets.Store(subnet, reservation{createdAt: createdAt})
-			klog.Infof("skipping subnet %s that has unexpired reservation: %+v", subnet, &reservedSubnets)
-			return false
-		}
-		// expired reservation: renew setting createdAt to now
-		reservedSubnets.Store(subnet, reservation{createdAt: time.Now()})
-		klog.Infof("reusing subnet %s that has expired reservation: %+v", subnet, &reservedSubnets)
-		return true
-	}
-	// new reservation
-	klog.Infof("reserving subnet %s for %v: %+v", subnet, period, &reservedSubnets)
-	reservedSubnets.Store(subnet, reservation{createdAt: time.Now()})
-	return true
-}
diff --git a/pkg/util/utils.go b/pkg/util/utils.go
index 227c8402b..f5fe5a3b2 100644
--- a/pkg/util/utils.go
+++ b/pkg/util/utils.go
@@ -29,7 +29,7 @@ import (
 )
 
 const (
-	downloadURL = "https://storage.googleapis.com/minikube/releases/%s/minikube-%s-%s%s"
+	downloadURL = "https://storage.googleapis.com/minikube/releases/%s/minikube-%s-amd64%s"
 )
 
 // CalculateSizeInMB returns the number of MB in the human readable string
@@ -62,13 +62,13 @@ func ConvertUnsignedBytesToMB(byteSize uint64) int64 {
 	return int64(byteSize / units.MiB)
 }
 
-// GetBinaryDownloadURL returns a suitable URL for the platform and arch
-func GetBinaryDownloadURL(version, platform, arch string) string {
+// GetBinaryDownloadURL returns a suitable URL for the platform
+func GetBinaryDownloadURL(version, platform string) string {
 	switch platform {
 	case "windows":
-		return fmt.Sprintf(downloadURL, version, platform, arch, ".exe")
+		return fmt.Sprintf(downloadURL, version, platform, ".exe")
 	default:
-		return fmt.Sprintf(downloadURL, version, platform, arch, "")
+		return fmt.Sprintf(downloadURL, version, platform, "")
 	}
 }
 
diff --git a/site/content/en/docs/commands/image.md b/site/content/en/docs/commands/image.md
index af13106b2..853f88b1d 100644
--- a/site/content/en/docs/commands/image.md
+++ b/site/content/en/docs/commands/image.md
@@ -72,28 +72,14 @@ minikube image help [command] [flags]
 
 ## minikube image load
 
-Load a image into minikube
+Load a local image into minikube
 
 ### Synopsis
 
-Load a image into minikube
+Load a local image into minikube
 
 ```shell
-minikube image load IMAGE | ARCHIVE | - [flags]
-```
-
-### Examples
-
-```
-minikube image load image
-minikube image load image.tar
-```
-
-### Options
-
-```
-      --daemon   Cache image from docker daemon
-      --remote   Cache image from remote registry
+minikube image load [flags]
 ```
 
 ### Options inherited from parent commands
diff --git a/site/content/en/docs/commands/status.md b/site/content/en/docs/commands/status.md
index 109948ab5..992691f07 100644
--- a/site/content/en/docs/commands/status.md
+++ b/site/content/en/docs/commands/status.md
@@ -23,7 +23,7 @@ minikube status [flags]
 
 ```
   -f, --format string         Go template format string for the status output.  The format for Go templates can be found here: https://golang.org/pkg/text/template/
-                              For the list accessible variables for the template, see the struct values here: https://godoc.org/k8s.io/minikube/cmd/minikube/cmd#Status (default "{{.Name}}\ntype: Control Plane\nhost: {{.Host}}\nkubelet: {{.Kubelet}}\napiserver: {{.APIServer}}\nkubeconfig: {{.Kubeconfig}}\n{{- if .TimeToStop }}\ntimeToStop: {{.TimeToStop}}\n{{- end }}\n{{- if .DockerEnv }}\ndocker-env: {{.DockerEnv}}\n{{- end }}\n{{- if .PodManEnv }}\npodman-env: {{.PodManEnv}}\n{{- end }}\n\n")
+                              For the list accessible variables for the template, see the struct values here: https://godoc.org/k8s.io/minikube/cmd/minikube/cmd#Status (default "{{.Name}}\ntype: Control Plane\nhost: {{.Host}}\nkubelet: {{.Kubelet}}\napiserver: {{.APIServer}}\nkubeconfig: {{.Kubeconfig}}\ntimeToStop: {{.TimeToStop}}\n{{- if .DockerEnv }}\ndocker-env: {{.DockerEnv}}\n{{- end }}\n{{- if .PodManEnv }}\npodman-env: {{.PodManEnv}}\n{{- end }}\n\n")
   -l, --layout string         output layout (EXPERIMENTAL, JSON only): 'nodes' or 'cluster' (default "nodes")
   -n, --node string           The node to check status for. Defaults to control plane. Leave blank with default format for status on all nodes.
   -o, --output string         minikube status --output OUTPUT. json, text (default "text")
diff --git a/site/content/en/docs/contrib/json_output.en.md b/site/content/en/docs/contrib/json_output.en.md
index c61e91a4e..6ef594c9f 100644
--- a/site/content/en/docs/contrib/json_output.en.md
+++ b/site/content/en/docs/contrib/json_output.en.md
@@ -6,7 +6,7 @@ description: >
   How to add logs to facilitate JSON output
 ---
 
-This document is written for minikube contributors who need to add logs to the minikube log registry for sucessful JSON output.
+This document is written for minikube contributors who need to add logs to the minikube log registry for successful JSON output.
 You may need to add logs to the registry if the `TestJSONOutput` integration test is failing on your PR.
 
 ### Background


Test patch:
diff --git a/cmd/minikube/cmd/status_test.go b/cmd/minikube/cmd/status_test.go
index bd794cbe3..aa9f905c2 100644
--- a/cmd/minikube/cmd/status_test.go
+++ b/cmd/minikube/cmd/status_test.go
@@ -56,13 +56,13 @@ func TestStatusText(t *testing.T) {
 		},
 		{
 			name:  "paused",
-			state: &Status{Name: "minikube", Host: "Running", Kubelet: "Stopped", APIServer: "Paused", Kubeconfig: Configured},
-			want:  "minikube\ntype: Control Plane\nhost: Running\nkubelet: Stopped\napiserver: Paused\nkubeconfig: Configured\n\n",
+			state: &Status{Name: "minikube", Host: "Running", Kubelet: "Stopped", APIServer: "Paused", Kubeconfig: Configured, TimeToStop: Nonexistent},
+			want:  "minikube\ntype: Control Plane\nhost: Running\nkubelet: Stopped\napiserver: Paused\nkubeconfig: Configured\ntimeToStop: Nonexistent\n\n",
 		},
 		{
 			name:  "down",
-			state: &Status{Name: "minikube", Host: "Stopped", Kubelet: "Stopped", APIServer: "Stopped", Kubeconfig: Misconfigured},
-			want:  "minikube\ntype: Control Plane\nhost: Stopped\nkubelet: Stopped\napiserver: Stopped\nkubeconfig: Misconfigured\n\n\nWARNING: Your kubectl is pointing to stale minikube-vm.\nTo fix the kubectl context, run `minikube update-context`\n",
+			state: &Status{Name: "minikube", Host: "Stopped", Kubelet: "Stopped", APIServer: "Stopped", Kubeconfig: Misconfigured, TimeToStop: Nonexistent},
+			want:  "minikube\ntype: Control Plane\nhost: Stopped\nkubelet: Stopped\napiserver: Stopped\nkubeconfig: Misconfigured\ntimeToStop: Nonexistent\n\n\nWARNING: Your kubectl is pointing to stale minikube-vm.\nTo fix the kubectl context, run `minikube update-context`\n",
 		},
 	}
 	for _, tc := range tests {
@@ -87,8 +87,8 @@ func TestStatusJSON(t *testing.T) {
 		state *Status
 	}{
 		{"ok", &Status{Host: "Running", Kubelet: "Running", APIServer: "Running", Kubeconfig: Configured, TimeToStop: "10m"}},
-		{"paused", &Status{Host: "Running", Kubelet: "Stopped", APIServer: "Paused", Kubeconfig: Configured}},
-		{"down", &Status{Host: "Stopped", Kubelet: "Stopped", APIServer: "Stopped", Kubeconfig: Misconfigured}},
+		{"paused", &Status{Host: "Running", Kubelet: "Stopped", APIServer: "Paused", Kubeconfig: Configured, TimeToStop: Nonexistent}},
+		{"down", &Status{Host: "Stopped", Kubelet: "Stopped", APIServer: "Stopped", Kubeconfig: Misconfigured, TimeToStop: Nonexistent}},
 	}
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
diff --git a/deploy/minikube/release_sanity_test.go b/deploy/minikube/release_sanity_test.go
index 07eba31e8..8788e9de7 100644
--- a/deploy/minikube/release_sanity_test.go
+++ b/deploy/minikube/release_sanity_test.go
@@ -23,7 +23,6 @@ import (
 	"encoding/hex"
 	"fmt"
 	"io/ioutil"
-	"runtime"
 	"testing"
 
 	retryablehttp "github.com/hashicorp/go-retryablehttp"
@@ -57,7 +56,7 @@ func TestReleasesJSON(t *testing.T) {
 		fmt.Printf("Checking release: %s\n", r.Name)
 		for platform, sha := range r.Checksums {
 			fmt.Printf("Checking SHA for %s.\n", platform)
-			actualSha, err := getSHAFromURL(util.GetBinaryDownloadURL(r.Name, platform, runtime.GOARCH))
+			actualSha, err := getSHAFromURL(util.GetBinaryDownloadURL(r.Name, platform))
 			if err != nil {
 				t.Errorf("Error calculating SHA for %s-%s. Error: %v", r.Name, platform, err)
 				continue
diff --git a/hack/jenkins/linux_integration_tests_docker_arm64.sh b/hack/jenkins/linux_integration_tests_docker_arm64.sh
deleted file mode 100644
index 11a1c5f40..000000000
--- a/hack/jenkins/linux_integration_tests_docker_arm64.sh
+++ /dev/null
@@ -1,38 +0,0 @@
-#!/bin/bash
-
-# Copyright 2019 The Kubernetes Authors All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-# This script runs the integration tests on a Linux machine for the KVM Driver
-
-# The script expects the following env variables:
-# MINIKUBE_LOCATION: GIT_COMMIT from upstream build.
-# COMMIT: Actual commit ID from upstream build
-# EXTRA_BUILD_ARGS (optional): Extra args to be passed into the minikube integrations tests
-# access_token: The Github API access token. Injected by the Jenkins credential provider.
-set -e
-
-mkdir -p cron && gsutil -qm rsync "gs://minikube-builds/${MINIKUBE_LOCATION}/cron" cron || echo "FAILED TO GET CRON FILES"
-sudo install cron/cleanup_and_reboot_Linux.sh /etc/cron.hourly/cleanup_and_reboot || echo "FAILED TO INSTALL CLEANUP"
-
-# removing possible left over docker containers from previous runs
-docker rm -f -v "$(docker ps -aq)" >/dev/null 2>&1 || true
-
-ARCH="arm64" \
-OS="linux" \
-VM_DRIVER="docker" \
-JOB_NAME="$JOB_NAME" \
-CONTAINER_RUNTIME="docker" \
-source ./run_tests.sh
diff --git a/hack/jenkins/linux_integration_tests_docker_containerd_arm64.sh b/hack/jenkins/linux_integration_tests_docker_containerd_arm64.sh
deleted file mode 100644
index 96685cb8c..000000000
--- a/hack/jenkins/linux_integration_tests_docker_containerd_arm64.sh
+++ /dev/null
@@ -1,38 +0,0 @@
-#!/bin/bash
-
-# Copyright 2019 The Kubernetes Authors All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-# This script runs the integration tests on a Linux machine for the KVM Driver
-
-# The script expects the following env variables:
-# MINIKUBE_LOCATION: GIT_COMMIT from upstream build.
-# COMMIT: Actual commit ID from upstream build
-# EXTRA_BUILD_ARGS (optional): Extra args to be passed into the minikube integrations tests
-# access_token: The Github API access token. Injected by the Jenkins credential provider.
-set -e
-
-mkdir -p cron && gsutil -qm rsync "gs://minikube-builds/${MINIKUBE_LOCATION}/cron" cron || echo "FAILED TO GET CRON FILES"
-sudo install cron/cleanup_and_reboot_Linux.sh /etc/cron.hourly/cleanup_and_reboot || echo "FAILED TO INSTALL CLEANUP"
-
-# removing possible left over docker containers from previous runs
-docker rm -f -v "$(docker ps -aq)" >/dev/null 2>&1 || true
-
-ARCH="arm64" \
-OS="linux" \
-VM_DRIVER="docker" \
-JOB_NAME="$JOB_NAME" \
-CONTAINER_RUNTIME="containerd" \
-source ./run_tests.sh
diff --git a/hack/jenkins/linux_integration_tests_docker_crio_arm64.sh b/hack/jenkins/linux_integration_tests_docker_crio_arm64.sh
deleted file mode 100644
index dd46df66f..000000000
--- a/hack/jenkins/linux_integration_tests_docker_crio_arm64.sh
+++ /dev/null
@@ -1,38 +0,0 @@
-#!/bin/bash
-
-# Copyright 2019 The Kubernetes Authors All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-# This script runs the integration tests on a Linux machine for the KVM Driver
-
-# The script expects the following env variables:
-# MINIKUBE_LOCATION: GIT_COMMIT from upstream build.
-# COMMIT: Actual commit ID from upstream build
-# EXTRA_BUILD_ARGS (optional): Extra args to be passed into the minikube integrations tests
-# access_token: The Github API access token. Injected by the Jenkins credential provider.
-set -e
-
-mkdir -p cron && gsutil -qm rsync "gs://minikube-builds/${MINIKUBE_LOCATION}/cron" cron || echo "FAILED TO GET CRON FILES"
-sudo install cron/cleanup_and_reboot_Linux.sh /etc/cron.hourly/cleanup_and_reboot || echo "FAILED TO INSTALL CLEANUP"
-
-# removing possible left over docker containers from previous runs
-docker rm -f -v "$(docker ps -aq)" >/dev/null 2>&1 || true
-
-ARCH="arm64" \
-OS="linux" \
-VM_DRIVER="docker" \
-JOB_NAME="$JOB_NAME" \
-CONTAINER_RUNTIME="crio" \
-source ./run_tests.sh
diff --git a/hack/jenkins/run_tests.sh b/hack/jenkins/run_tests.sh
deleted file mode 100644
index c22d2cdd9..000000000
--- a/hack/jenkins/run_tests.sh
+++ /dev/null
@@ -1,449 +0,0 @@
-#!/bin/bash
-
-# Copyright 2016 The Kubernetes Authors All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-# This script downloads the test files from the build bucket and makes some executable.
-
-# The script expects the following env variables:
-# OS: The operating system
-# ARCH: The architecture
-# VM_DRIVER: the driver to use for the test
-# CONTAINER_RUNTIME: the container runtime to use for the test
-# EXTRA_START_ARGS: additional flags to pass into minikube start
-# EXTRA_TEST_ARGS: additional flags to pass into go test
-# JOB_NAME: the name of the logfile and check name to update on github
-
-readonly OS_ARCH="${OS}-${ARCH}"
-readonly TEST_ROOT="${HOME}/minikube-integration"
-readonly TEST_HOME="${TEST_ROOT}/${OS_ARCH}-${VM_DRIVER}-${CONTAINER_RUNTIME}-${MINIKUBE_LOCATION}-$$-${COMMIT}"
-
-export GOPATH="$HOME/go"
-export KUBECONFIG="${TEST_HOME}/kubeconfig"
-export PATH=$PATH:"/usr/local/bin/:/usr/local/go/bin/:$GOPATH/bin"
-
-readonly TIMEOUT=${1:-120m}
-
-if [ "$(uname)" != "Darwin" ]; then
-  # install lsof for finding none driver procs, psmisc to use pstree in cronjobs
-  sudo apt-get -y install lsof psmisc
-fi
-
-# installing golang so we could do go get for gopogh
-sudo ARCH="$ARCH"./installers/check_install_golang.sh "1.16" "/usr/local" || true
-
-# install docker and kubectl if not present
-sudo ARCH="$ARCH" ./installers/check_install_docker.sh
-
-# let's just clean all docker artifacts up
-docker system prune --force --volumes || true
-docker system df || true
-
-echo ">> Starting at $(date)"
-echo ""
-echo "arch:      ${OS_ARCH}"
-echo "build:     ${MINIKUBE_LOCATION}"
-echo "driver:    ${VM_DRIVER}"
-echo "runtime:   ${CONTAINER_RUNTIME}"
-echo "job:       ${JOB_NAME}"
-echo "test home: ${TEST_HOME}"
-echo "sudo:      ${SUDO_PREFIX}"
-echo "kernel:    $(uname -v)"
-echo "uptime:    $(uptime)"
-# Setting KUBECONFIG prevents the version check from erroring out due to permission issues
-echo "kubectl:   $(env KUBECONFIG=${TEST_HOME} kubectl version --client --short=true)"
-echo "docker:    $(docker version --format '{{ .Client.Version }}')"
-echo "podman:    $(sudo podman version --format '{{.Version}}' || true)"
-echo "go:        $(go version || true)"
-
-
-case "${VM_DRIVER}" in
-  kvm2)
-    echo "virsh:     $(virsh --version)"
-  ;;
-  virtualbox)
-    echo "vbox:      $(vboxmanage --version)"
-  ;;
-esac
-
-echo ""
-mkdir -p out/ testdata/
-
-# Install gsutil if necessary.
-if ! type -P gsutil >/dev/null; then
-  if [[ ! -x "out/gsutil/gsutil" ]]; then
-    echo "Installing gsutil to $(pwd)/out ..."
-    curl -s https://storage.googleapis.com/pub/gsutil.tar.gz | tar -C out/ -zxf -
-  fi
-  PATH="$(pwd)/out/gsutil:$PATH"
-fi
-
-# Add the out/ directory to the PATH, for using new drivers.
-export PATH="$(pwd)/out/":$PATH
-
-
-echo
-echo ">> Downloading test inputs from ${MINIKUBE_LOCATION} ..."
-gsutil -qm cp \
-  "gs://minikube-builds/${MINIKUBE_LOCATION}/minikube-${OS_ARCH}" \
-  "gs://minikube-builds/${MINIKUBE_LOCATION}/docker-machine-driver"-* \
-  "gs://minikube-builds/${MINIKUBE_LOCATION}/e2e-${OS_ARCH}" out
-
-gsutil -qm cp -r "gs://minikube-builds/${MINIKUBE_LOCATION}/testdata"/* testdata/
-
-gsutil -qm cp "gs://minikube-builds/${MINIKUBE_LOCATION}/gvisor-addon" testdata/
-
-
-# Set the executable bit on the e2e binary and out binary
-export MINIKUBE_BIN="out/minikube-${OS_ARCH}"
-export E2E_BIN="out/e2e-${OS_ARCH}"
-chmod +x "${MINIKUBE_BIN}" "${E2E_BIN}" out/docker-machine-driver-*
-"${MINIKUBE_BIN}" version
-
-procs=$(pgrep "minikube-${OS_ARCH}|e2e-${OS_ARCH}" || true)
-if [[ "${procs}" != "" ]]; then
-  echo "Warning: found stale test processes to kill:"
-  ps -f -p ${procs} || true
-  kill ${procs} || true
-  kill -9 ${procs} || true
-fi
-
-# Quickly notice misconfigured test roots
-mkdir -p "${TEST_ROOT}"
-
-# Cleanup stale test outputs.
-echo
-echo ">> Cleaning up after previous test runs ..."
-for test_path in ${TEST_ROOT}; do
-  ls -lad "${test_path}" || continue
-
-  echo "* Cleaning stale test path: ${test_path}"
-  for tunnel in $(find ${test_path} -name tunnels.json -type f); do
-    env MINIKUBE_HOME="$(dirname ${tunnel})" ${MINIKUBE_BIN} tunnel --cleanup || true
-  done
-
-  for home in $(find ${test_path} -name .minikube -type d); do
-    env MINIKUBE_HOME="$(dirname ${home})" ${MINIKUBE_BIN} delete --all || true
-    sudo rm -Rf "${home}"
-  done
-
-  for kconfig in $(find ${test_path} -name kubeconfig -type f); do
-    sudo rm -f "${kconfig}"
-  done
-
-  ## ultimate shotgun clean up docker after we tried all
-  docker rm -f -v $(docker ps -aq) >/dev/null 2>&1 || true
-
-  # Be very specific to avoid accidentally deleting other items, like wildcards or devices
-  if [[ -d "${test_path}" ]]; then
-    rm -Rf "${test_path}" || true
-  elif [[ -f "${test_path}" ]]; then
-    rm -f "${test_path}" || true
-  fi
-done
-
-function cleanup_procs() {
-  # sometimes tests left over zombie procs that won't exit
-  # for example:
-  # jenkins  20041  0.0  0.0      0     0 ?        Z    Aug19   0:00 [minikube-linux-] <defunct>
-  zombie_defuncts=$(ps -A -ostat,ppid | awk '/[zZ]/ && !a[$2]++ {print $2}')
-  if [[ "${zombie_defuncts}" != "" ]]; then
-    echo "Found zombie defunct procs to kill..."
-    ps -f -p ${zombie_defuncts} || true
-    kill ${zombie_defuncts} || true
-  fi
-
-  if type -P virsh; then
-    virsh -c qemu:///system list --all --uuid \
-      | xargs -I {} sh -c "virsh -c qemu:///system destroy {}; virsh -c qemu:///system undefine {}" \
-      || true
-    echo ">> virsh VM list after clean up (should be empty):"
-    virsh -c qemu:///system list --all || true
-  fi
-
-  if type -P vboxmanage; then
-    killall VBoxHeadless || true
-    sleep 1
-    killall -9 VBoxHeadless || true
-
-    for guid in $(vboxmanage list vms | grep -Eo '\{[a-zA-Z0-9-]+\}'); do
-      echo "- Removing stale VirtualBox VM: $guid"
-      vboxmanage startvm "${guid}" --type emergencystop || true
-      vboxmanage unregistervm "${guid}" || true
-    done
-
-    ifaces=$(vboxmanage list hostonlyifs | grep -E "^Name:" | awk '{ print $2 }')
-    for if in $ifaces; do
-      vboxmanage hostonlyif remove "${if}" || true
-    done
-
-    echo ">> VirtualBox VM list after clean up (should be empty):"
-    vboxmanage list vms || true
-    echo ">> VirtualBox interface list after clean up (should be empty):"
-    vboxmanage list hostonlyifs || true
-  fi
-
-  if type -P hdiutil; then
-    hdiutil info | grep -E "/dev/disk[1-9][^s]" || true
-    hdiutil info \
-        | grep -E "/dev/disk[1-9][^s]" \
-        | awk '{print $1}' \
-        | xargs -I {} sh -c "hdiutil detach {}" \
-        || true
-  fi
-
-  # cleaning up stale hyperkits
-  if type -P hyperkit; then
-    for pid in $(pgrep hyperkit); do
-      echo "Killing stale hyperkit $pid"
-      ps -f -p $pid || true
-      kill $pid || true
-      kill -9 $pid || true
-    done
-  fi
-
-  if [[ "${VM_DRIVER}" == "hyperkit" ]]; then
-    if [[ -e out/docker-machine-driver-hyperkit ]]; then
-      sudo chown root:wheel out/docker-machine-driver-hyperkit || true
-      sudo chmod u+s out/docker-machine-driver-hyperkit || true
-    fi
-  fi
-
-  kprocs=$(pgrep kubectl || true)
-  if [[ "${kprocs}" != "" ]]; then
-    echo "error: killing hung kubectl processes ..."
-    ps -f -p ${kprocs} || true
-    sudo -E kill ${kprocs} || true
-  fi
-
-
-  # clean up none drivers binding on 8443
-  none_procs=$(sudo lsof -i :8443 | tail -n +2 | awk '{print $2}' || true)
-  if [[ "${none_procs}" != "" ]]; then
-    echo "Found stale api servers listening on 8443 processes to kill: "
-    for p in $none_procs
-    do
-      echo "Kiling stale none driver:  $p"
-      sudo -E ps -f -p $p || true
-      sudo -E kill $p || true
-      sudo -E kill -9 $p || true
-    done
-  fi
-}
-
-function cleanup_stale_routes() {
-  local show="netstat -rn -f inet"
-  local del="sudo route -n delete"
-
-  if [[ "$(uname)" == "Linux" ]]; then
-    show="ip route show"
-    del="sudo ip route delete"
-  fi
-
-  local troutes=$($show | awk '{ print $1 }' | grep 10.96.0.0 || true)
-  for route in ${troutes}; do
-    echo "WARNING: deleting stale tunnel route: ${route}"
-    $del "${route}" || true
-  done
-}
-
-cleanup_procs || true
-cleanup_stale_routes || true
-
-mkdir -p "${TEST_HOME}"
-export MINIKUBE_HOME="${TEST_HOME}/.minikube"
-
-
-# Build the gvisor image so that we can integration test changes to pkg/gvisor
-chmod +x ./testdata/gvisor-addon
-# skipping gvisor mac because ofg https://github.com/kubernetes/minikube/issues/5137
-if [ "$(uname)" != "Darwin" ]; then
-  # Should match GVISOR_IMAGE_VERSION in Makefile
-  docker build -t gcr.io/k8s-minikube/gvisor-addon:2 -f testdata/gvisor-addon-Dockerfile ./testdata
-fi
-
-readonly LOAD=$(uptime | egrep -o "load average.*: [0-9]+" | cut -d" " -f3)
-if [[ "${LOAD}" -gt 2 ]]; then
-  echo ""
-  echo "********************** LOAD WARNING ********************************"
-  echo "Load average is very high (${LOAD}), which may cause failures. Top:"
-  if [[ "$(uname)" == "Darwin" ]]; then
-    # Two samples, macOS does not calculate CPU usage on the first one
-    top -l 2 -o cpu -n 5 | tail -n 15
-  else
-    top -b -n1 | head -n 15
-  fi
-  echo "********************** LOAD WARNING ********************************"
-  echo "Sleeping 30s to see if load goes down ...."
-  sleep 30
-  uptime
-fi
-
-readonly TEST_OUT="${TEST_HOME}/testout.txt"
-readonly JSON_OUT="${TEST_HOME}/test.json"
-readonly HTML_OUT="${TEST_HOME}/test.html"
-readonly SUMMARY_OUT="${TEST_HOME}/test_summary.json"
-
-e2e_start_time="$(date -u +%s)"
-echo ""
-echo ">> Starting ${E2E_BIN} at $(date)"
-set -x
-
-if test -f "${TEST_OUT}"; then
-  rm "${TEST_OUT}" || true # clean up previous runs of same build
-fi
-touch "${TEST_OUT}"
-
-if [ ! -z "${CONTAINER_RUNTIME}" ]
-then
-    EXTRA_START_ARGS="${EXTRA_START_ARGS} --container-runtime=${CONTAINER_RUNTIME}"
-fi
-
-${SUDO_PREFIX}${E2E_BIN} \
-  -minikube-start-args="--driver=${VM_DRIVER} ${EXTRA_START_ARGS}" \
-  -test.timeout=${TIMEOUT} -test.v \
-  ${EXTRA_TEST_ARGS} \
-  -binary="${MINIKUBE_BIN}" 2>&1 | tee "${TEST_OUT}"
-
-result=${PIPESTATUS[0]} # capture the exit code of the first cmd in pipe.
-set +x
-echo ">> ${E2E_BIN} exited with ${result} at $(date)"
-echo ""
-
-if [[ $result -eq 0 ]]; then
-  status="success"
-  echo "minikube: SUCCESS"
-else
-  status="failure"
-  echo "minikube: FAIL"
-fi
-
-## caclucate the time took to finish running e2e binary test.
-e2e_end_time="$(date -u +%s)"
-elapsed=$(($e2e_end_time-$e2e_start_time))
-min=$(($elapsed/60))
-sec=$(tail -c 3 <<< $((${elapsed}00/60)))
-elapsed=$min.$sec
-
-
-
-echo ">> Attmpting to convert test logs to json"
-if test -f "${JSON_OUT}"; then
-  rm "${JSON_OUT}" || true # clean up previous runs of same build
-fi
-
-touch "${JSON_OUT}"
-
-# Generate JSON output
-echo ">> Running go test2json"
-go tool test2json -t < "${TEST_OUT}" > "${JSON_OUT}" || true
-
-if ! type "jq" > /dev/null; then
-echo ">> Installing jq"
-    if [ "$(uname)" != "Darwin" ]; then
-      curl -LO https://github.com/stedolan/jq/releases/download/jq-1.6/jq-linux64 && sudo install jq-linux64 /usr/local/bin/jq
-    else
-      curl -LO https://github.com/stedolan/jq/releases/download/jq-1.6/jq-osx-amd64 && sudo install jq-osx-amd64 /usr/local/bin/jq
-    fi
-fi
-
-echo ">> Installing gopogh"
-curl -LO "https://github.com/medyagh/gopogh/releases/download/v0.6.0/gopogh-${OS_ARCH}"
-sudo install "gopogh-${OS_ARCH}" /usr/local/bin/gopogh
-
-
-echo ">> Running gopogh"
-if test -f "${HTML_OUT}"; then
-    rm "${HTML_OUT}" || true # clean up previous runs of same build
-fi
-
-touch "${HTML_OUT}"
-touch "${SUMMARY_OUT}"
-gopogh_status=$(gopogh -in "${JSON_OUT}" -out_html "${HTML_OUT}" -out_summary "${SUMMARY_OUT}" -name "${JOB_NAME}" -pr "${MINIKUBE_LOCATION}" -repo github.com/kubernetes/minikube/  -details "${COMMIT}") || true
-fail_num=$(echo $gopogh_status | jq '.NumberOfFail')
-test_num=$(echo $gopogh_status | jq '.NumberOfTests')
-pessimistic_status="${fail_num} / ${test_num} failures"
-description="completed with ${status} in ${elapsed} minute(s)."
-if [ "$status" = "failure" ]; then
-  description="completed with ${pessimistic_status} in ${elapsed} minute(s)."
-fi
-echo "$description"
-
-
-REPORTS_PATH=test_reports
-mkdir -p "$REPORTS_PATH"
-cp "${TEST_OUT}" "$REPORTS_PATH/out.txt"
-cp "${JSON_OUT}" "$REPORTS_PATH/out.json"
-cp "${HTML_OUT}" "$REPORTS_PATH/out.html"
-cp "${SUMMARY_OUT}" "$REPORTS_PATH/summary.txt"
-
-
-echo ">> Cleaning up after ourselves ..."
-timeout 3m ${SUDO_PREFIX}${MINIKUBE_BIN} tunnel --cleanup || true
-timeout 5m ${SUDO_PREFIX}${MINIKUBE_BIN} delete --all --purge >/dev/null 2>/dev/null || true
-cleanup_stale_routes || true
-
-${SUDO_PREFIX} rm -Rf "${MINIKUBE_HOME}" || true
-${SUDO_PREFIX} rm -f "${KUBECONFIG}" || true
-
-rmdir "${TEST_HOME}" || true
-echo ">> ${TEST_HOME} completed at $(date)"
-
-if [[ "${MINIKUBE_LOCATION}" == "master" ]]; then
-  exit "$result"
-fi
-
-public_log_url="https://storage.googleapis.com/minikube-builds/logs/${MINIKUBE_LOCATION}/${COMMIT:0:7}/${JOB_NAME}.html"
-
-# retry_github_status provides reliable github status updates
-function retry_github_status() {
-  local commit=$1
-  local context=$2
-  local state=$3
-  local token=$4
-  local target=$5
-  local desc=$6
-
-   # Retry in case we hit our GitHub API quota or fail other ways.
-  local attempt=0
-  local timeout=2
-  local code=-1
-
-  echo "set GitHub status $context to $desc"
-
-  while [[ "${attempt}" -lt 8 ]]; do
-    local out=$(mktemp)
-    code=$(curl -o "${out}" -s --write-out "%{http_code}" -L \
-      "https://api.github.com/repos/kubernetes/minikube/statuses/${commit}?access_token=${token}" \
-      -H "Content-Type: application/json" \
-      -X POST \
-      -d "{\"state\": \"${state}\", \"description\": \"Jenkins: ${desc}\", \"target_url\": \"${target}\", \"context\": \"${context}\"}" || echo 999)
-
-    # 2xx HTTP codes
-    if [[ "${code}" =~ ^2 ]]; then
-      break
-    fi
-
-    cat "${out}" && rm -f "${out}"
-    echo "HTTP code ${code}! Retrying in ${timeout} .."
-    sleep "${timeout}"
-    attempt=$(( attempt + 1 ))
-    timeout=$(( timeout * 5 ))
-  done
-}
-
-retry_github_status "${COMMIT}" "${JOB_NAME}" "${status}" "${access_token}" "${public_log_url}" "${description}"
-
-exit "$result"
diff --git a/pkg/util/utils_test.go b/pkg/util/utils_test.go
index 3e5e36965..81952d73c 100644
--- a/pkg/util/utils_test.go
+++ b/pkg/util/utils_test.go
@@ -20,7 +20,6 @@ import (
 	"io/ioutil"
 	"os"
 	"os/user"
-	"runtime"
 	"syscall"
 	"testing"
 
@@ -39,7 +38,7 @@ func TestGetBinaryDownloadURL(t *testing.T) {
 	}
 
 	for _, tt := range testData {
-		url := GetBinaryDownloadURL(tt.version, tt.platform, runtime.GOARCH)
+		url := GetBinaryDownloadURL(tt.version, tt.platform)
 		if url != tt.expectedURL {
 			t.Fatalf("Expected '%s' but got '%s'", tt.expectedURL, url)
 		}
diff --git a/test/integration/addons_test.go b/test/integration/addons_test.go
index cb145874a..fa441e080 100644
--- a/test/integration/addons_test.go
+++ b/test/integration/addons_test.go
@@ -345,10 +345,6 @@ func validateHelmTillerAddon(ctx context.Context, t *testing.T, profile string)
 
 	defer PostMortemLogs(t, profile)
 
-	if arm64Platform() {
-		t.Skip("skip Helm test on arm64")
-	}
-
 	client, err := kapi.Client(profile)
 	if err != nil {
 		t.Fatalf("failed to get Kubernetes client for %s: %v", profile, err)
diff --git a/test/integration/scheduled_stop_test.go b/test/integration/scheduled_stop_test.go
index ac84d7f96..f10c4e2d6 100644
--- a/test/integration/scheduled_stop_test.go
+++ b/test/integration/scheduled_stop_test.go
@@ -67,10 +67,10 @@ func TestScheduledStopWindows(t *testing.T) {
 
 	// sleep for 5 seconds
 	time.Sleep(5 * time.Second)
-	// make sure minikube timetoStop is not present
-	ensureTimeToStopNotPresent(ctx, t, profile)
 	// make sure minikube status is "Stopped"
 	ensureMinikubeStatus(ctx, t, profile, "Host", state.Stopped.String())
+	// make sure minikube timtostop is "Nonexistent"
+	ensureMinikubeStatus(ctx, t, profile, "TimeToStop", "Nonexistent")
 }
 
 func TestScheduledStopUnix(t *testing.T) {
@@ -113,10 +113,10 @@ func TestScheduledStopUnix(t *testing.T) {
 		t.Fatalf("process %v running but should have been killed on reschedule of stop", pid)
 	}
 
-	// make sure minikube timetoStop is not present
-	ensureTimeToStopNotPresent(ctx, t, profile)
 	// make sure minikube status is "Stopped"
 	ensureMinikubeStatus(ctx, t, profile, "Host", state.Stopped.String())
+	// make sure minikube timtostop is "Nonexistent"
+	ensureMinikubeStatus(ctx, t, profile, "TimeToStop", "Nonexistent")
 }
 
 func startMinikube(ctx context.Context, t *testing.T, profile string) {
@@ -195,14 +195,3 @@ func ensureMinikubeScheduledTime(ctx context.Context, t *testing.T, profile stri
 		t.Fatalf("error %v", err)
 	}
 }
-
-func ensureTimeToStopNotPresent(ctx context.Context, t *testing.T, profile string) {
-	args := []string{"status", "-p", profile}
-	rr, err := Run(t, exec.CommandContext(ctx, Target(), args...))
-	if err != nil {
-		t.Fatalf("minikube status: %v\n%s", err, rr.Output())
-	}
-	if strings.Contains(rr.Output(), "TimeToStop") {
-		t.Fatalf("expected status output to not include `TimeToStop` but got *%s*", rr.Output())
-	}
-}
diff --git a/test/integration/version_upgrade_test.go b/test/integration/version_upgrade_test.go
index 841dc4174..01f02e122 100644
--- a/test/integration/version_upgrade_test.go
+++ b/test/integration/version_upgrade_test.go
@@ -43,7 +43,7 @@ func installRelease(version string) (f *os.File, err error) {
 	}
 	tf.Close()
 
-	url := pkgutil.GetBinaryDownloadURL(version, runtime.GOOS, runtime.GOARCH)
+	url := pkgutil.GetBinaryDownloadURL(version, runtime.GOOS)
 
 	if err := retry.Expo(func() error { return getter.GetFile(tf.Name(), url) }, 3*time.Second, Minutes(3)); err != nil {
 		return tf, err
@@ -79,13 +79,8 @@ func TestRunningBinaryUpgrade(t *testing.T) {
 	// Should be a version from the last 6 months
 	legacyVersion := "v1.6.2"
 	if KicDriver() {
-		if arm64Platform() {
-			// arm64 KIC driver is supported starting from v1.17.0
-			legacyVersion = "v1.17.0"
-		} else {
-			// v1.8.0 would be selected, but: https://github.com/kubernetes/minikube/issues/8740
-			legacyVersion = "v1.9.0"
-		}
+		// v1.8.0 would be selected, but: https://github.com/kubernetes/minikube/issues/8740
+		legacyVersion = "v1.9.0"
 	}
 
 	tf, err := installRelease(legacyVersion)
@@ -152,10 +147,6 @@ func TestStoppedBinaryUpgrade(t *testing.T) {
 	if KicDriver() {
 		// first release with non-experimental KIC
 		legacyVersion = "v1.8.0"
-		if arm64Platform() {
-			// first release with non-experimental arm64 KIC
-			legacyVersion = "v1.17.0"
-		}
 	}
 
 	tf, err := installRelease(legacyVersion)
diff --git a/test/stress/stress_test.go b/test/stress/stress_test.go
index 629119172..5bcf8a61c 100644
--- a/test/stress/stress_test.go
+++ b/test/stress/stress_test.go
@@ -48,7 +48,7 @@ func TestStress(t *testing.T) {
 	}
 
 	oldPath := fmt.Sprintf("../../out/minikube-%s", *upgradeFrom)
-	url := util.GetBinaryDownloadURL(*upgradeFrom, runtime.GOOS, runtime.GOARCH)
+	url := util.GetBinaryDownloadURL(*upgradeFrom, runtime.GOOS)
 	t.Logf("Downloading minikube %s from %s", *upgradeFrom, url)
 	err = getter.GetFile(oldPath, url)
 	if err != nil {