Repository: kubernetes-sigs/gcp-compute-persistent-disk-csi-driver
Pull request #1251 (2023-06-05 23:26:42)

Delete stable overlays and update docs with recommended versions.
/kind cleanup

**What this PR does / why we need it**:

As part of cleaning up the testgrids (see https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver), we've decided to clean up the old k8s version overlays. We no longer have test jobs that verify that these overlays still actually work so it seems better not to promise as such.

```release-note
None
```

/assign @msau42 


k8s-ci-robot: [APPROVALNOTIFIER] This PR is **APPROVED**

This pull-request has been approved by: *<a href="https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1251#" title="Author self-approved">mattcary</a>*

The full list of commands accepted by this bot can be found [here](https://go.k8s.io/bot-commands?repo=kubernetes-sigs%2Fgcp-compute-persistent-disk-csi-driver).

The pull request process is described [here](https://git.k8s.io/community/contributors/guide/owners.md#the-code-review-process)

<details >
Needs approval from an approver in each of these files:

- ~~[OWNERS](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/blob/master/OWNERS)~~ [mattcary]

Approvers can indicate their approval by writing `/approve` in a comment
Approvers can cancel approval by writing `/approve cancel` in a comment
</details>
<!-- META={"approvers":[]} -->
k8s-ci-robot: @mattcary: The following test **failed**, say `/retest` to rerun all failed tests or `/retest-required` to rerun all mandatory failed tests:

Test name | Commit | Details | Required | Rerun command
--- | --- | --- | --- | ---
pull-gcp-compute-persistent-disk-csi-driver-e2e | f5e409b0bad7451a5ee116fbaf5b5058256f7961 | [link](https://prow.k8s.io/view/gs/kubernetes-jenkins/pr-logs/pull/sigs.k8s.io_gcp-compute-persistent-disk-csi-driver/1251/pull-gcp-compute-persistent-disk-csi-driver-e2e/1665865511151341568/) | true | `/test pull-gcp-compute-persistent-disk-csi-driver-e2e`

[Full PR test history](https://prow.k8s.io/pr-history?org=kubernetes-sigs&repo=gcp-compute-persistent-disk-csi-driver&pr=1251). [Your PR dashboard](https://prow.k8s.io/pr?query=is%3Apr%20state%3Aopen%20author%3Amattcary). Please help us cut down on flakes by [linking to](https://git.k8s.io/community/contributors/devel/sig-testing/flaky-tests.md#filing-issues-for-flaky-tests) an [open issue](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/issues?q=is:issue+is:open) when you hit one in your PR.

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes/test-infra](https://github.com/kubernetes/test-infra/issues/new?title=Prow%20issue:) repository. I understand the commands that are listed [here](https://go.k8s.io/bot-commands).
</details>
<!-- test report -->

Patch:
diff --git a/CHANGELOG/CHANGELOG-1.10.md b/CHANGELOG/CHANGELOG-1.10.md
index b9f2e49d..18be840a 100644
--- a/CHANGELOG/CHANGELOG-1.10.md
+++ b/CHANGELOG/CHANGELOG-1.10.md
@@ -1,32 +1,3 @@
-# v1.10.4 - Changelog since v1.10.3
-
-## Changes by Kind
-
-## Features
-
-- Add alpha-level force attach storage class parameter. ([#1257](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1257), [@k8s-infra-cherrypick-robot](https://github.com/k8s-infra-cherrypick-robot))
-
-## Bug or Regression
-
-- Fix provisioned-iops-on-create passing logic([#1282](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1282))
-- Bugfix for empty disk type being registered in metric for Create volume function. ([#1267](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1267), [@k8s-infra-cherrypick-robot](https://github.com/k8s-infra-cherrypick-robot))
-
-### Cleanup
-
-- Update go version to 1.20.5 to address CVE fixes ([#1265](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1265), [@k8s-infra-cherrypick-robot](https://github.com/k8s-infra-cherrypick-robot))
-- [release-1.10] Update Docker.Windows to 1.20.5 ([#1272](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1272), [@saikat-royc](https://github.com/saikat-royc))
-
-# v1.10.3 - Changelog since v1.10.2
-
-### Feature
-
-- Add alpha-level force attach storage class parameter. ([#1257](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1257), [@k8s-infra-cherrypick-robot](https://github.com/k8s-infra-cherrypick-robot))
-
-### Cleanup
-
-- Add metrics for CSI server side error count ([#1237](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1237), [@k8s-infra-cherrypick-robot](https://github.com/k8s-infra-cherrypick-robot))
-
-
 # v1.10.2 - Changelog since v1.10.1
 
 ### Bug or Regression
diff --git a/CHANGELOG/CHANGELOG-1.7.md b/CHANGELOG/CHANGELOG-1.7.md
index d7f3c970..eb525055 100644
--- a/CHANGELOG/CHANGELOG-1.7.md
+++ b/CHANGELOG/CHANGELOG-1.7.md
@@ -1,13 +1,3 @@
-# v1.7.9 - Changelog since v1.7.8
-
-## Changes by Kind
-
-### Other (Cleanup or Flake)
-
-- Separate user errors from internal errors ([#1219](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1219), [@sunnylovestiramisu](https://github.com/sunnylovestiramisu))
-- Update go version to 1.19.10 ([#1273](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1273), [@k8s-infra-cherrypick-robot](https://github.com/k8s-infra-cherrypick-robot))
-- Updates error message to be more user friendly when PD CSI Driver encounters an disk type UNSUPPORTED_OPERATION on ControllerPublishVolume ([#1224](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1224), [@pwschuurman](https://github.com/pwschuurman))
-
 # v1.7.8 - Changelog since v1.7.7
 
 ## Changes by Kind
diff --git a/CHANGELOG/CHANGELOG-1.8.md b/CHANGELOG/CHANGELOG-1.8.md
index f011c55c..20160fb0 100644
--- a/CHANGELOG/CHANGELOG-1.8.md
+++ b/CHANGELOG/CHANGELOG-1.8.md
@@ -1,23 +1,6 @@
-# v1.8.7 - Changelog since v1.8.6
-
-### Bug or Regression
-
-- Fix provisioned-iops-on-create passing logic([#1284](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1284))
-- Bugfix for empty disk type being registered in metric for Create volume function. ([#1269](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1269), [@k8s-infra-cherrypick-robot](https://github.com/k8s-infra-cherrypick-robot))
-
-### Cleanup
-
-- #1079: Add provisionedIops for pd-extreme
-  #1101: Add provisionedThroughput for hyperdisk
-  #1240: Change iops params directly convert string to int64 ([#1241](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1241), [@sunnylovestiramisu](https://github.com/sunnylovestiramisu))
-- #1150: fix bug where volume cloning topology requirements are
-  #1232: Use errors.As so we can detect wrapped errors, and check for
-  #1227: Adding new metric pdcsi_operation_errors to fetch error ([#1244](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1244), [@sunnylovestiramisu](https://github.com/sunnylovestiramisu))
-- Update go version to 1.19.10 ([#1271](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1271), [@saikat-royc](https://github.com/saikat-royc))
-
 # v1.8.6 - Changelog since v1.8.5
 
-## Changes by Kind
+## Changes by Kind 
 
 ### Cleanup
 
diff --git a/CHANGELOG/CHANGELOG-1.9.md b/CHANGELOG/CHANGELOG-1.9.md
index d4608b7c..1be2f0bd 100644
--- a/CHANGELOG/CHANGELOG-1.9.md
+++ b/CHANGELOG/CHANGELOG-1.9.md
@@ -1,19 +1,3 @@
-# v1.9.6 - Changelog since v1.9.5
-
-## Changes by Kind
-
-### Bug or Regression
-
-- Fix provisioned-iops-on-create passing logic([#1283](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1283))
-- Bugfix for empty disk type being registered in metric for Create volume function. ([#1268](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1268), [@k8s-infra-cherrypick-robot](https://github.com/k8s-infra-cherrypick-robot))
-
-### Cleanup
-
-- Automated cherry pick of #1150: satisfy volume cloning topology requirements when choosing zone for CreateVolume, #1232: Use errors.As so we can detect wrapped errors, #1227: Adding new metric pdcsi_operation_errors to fetch error ([#1240](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1240), [@sunnylovestiramisu](https://github.com/sunnylovestiramisu))
-- Update go version to 1.20.5 to address CVE fixes ([#1266](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1266), [@k8s-infra-cherrypick-robot](https://github.com/k8s-infra-cherrypick-robot))
-- Updates error message to be more user friendly when PD CSI Driver encounters an disk type UNSUPPORTED_OPERATION on ControllerPublishVolume ([#1222](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1222), [@pwschuurman](https://github.com/pwschuurman))
-- [release-1.10] Update Docker.Windows to 1.20.5 ([#1274](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/pull/1274), [@k8s-infra-cherrypick-robot](https://github.com/k8s-infra-cherrypick-robot))
-
 # v1.9.5 - Changelog since v1.9.4
 
 ### Bug or Regression
diff --git a/Dockerfile b/Dockerfile
index a87269e2..284fa394 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -14,7 +14,7 @@
 
 ARG BUILDPLATFORM
 
-FROM --platform=$BUILDPLATFORM golang:1.20.5 as builder
+FROM --platform=$BUILDPLATFORM golang:1.20.3 as builder
 
 ARG STAGINGVERSION
 ARG TARGETPLATFORM
diff --git a/Dockerfile.Windows b/Dockerfile.Windows
index 4f83884f..12c0f42a 100644
--- a/Dockerfile.Windows
+++ b/Dockerfile.Windows
@@ -13,7 +13,7 @@
 # limitations under the License.
 
 ARG BASE_IMAGE
-FROM --platform=$BUILDPLATFORM golang:1.20.5 AS builder
+FROM --platform=$BUILDPLATFORM golang:1.20.3 AS builder
 
 ARG TARGETPLATFORM
 ARG BUILDPLATFORM
diff --git a/README.md b/README.md
index ee7182fa..9cbe060e 100644
--- a/README.md
+++ b/README.md
@@ -21,34 +21,28 @@ Latest stable image: `registry.k8s.io/cloud-provider-gcp/gcp-compute-persistent-
 | Driver Version | Kubernetes Version | Test Status |
 |----------------|--------------------|-------------|
 | HEAD Latest | HEAD | [<img alt="Test Status" src="https://testgrid.k8s.io/q/summary/provider-gcp-compute-persistent-disk-csi-driver/Kubernetes%20Master%20Driver%20Latest/tests_status" />](https://testgrid.k8s.io/provider-gcp-compute-persistent-disk-csi-driver#Kubernetes%20Master%20Driver%20Latest) |
-| 0.7.x stable | HEAD | [<img alt="Test Status" src="https://testgrid.k8s.io/q/summary/provider-gcp-compute-persistent-disk-csi-driver/Kubernetes%20Master%20Driver%20Release%200.7/tests_status" />](https://https://testgrid.k8s.io/provider-gcp-compute-persistent-disk-csi-driver#Kubernetes%20Master%20Driver%20Release%200.7) |
-| HEAD Latest | HEAD (Migration ON) | [<img alt="Test Status" src="https://testgrid.k8s.io/q/summary/provider-gcp-compute-persistent-disk-csi-driver/Migration%20Kubernetes%20Master%20Driver%20Latest/tests_status" />](https://testgrid.k8s.io/provider-gcp-compute-persistent-disk-csi-driver#Migration%20Kubernetes%20Master%20Driver%20Latest) |
-| HEAD stable-master | HEAD (Migration ON) | [<img alt="Test Status" src="https://testgrid.k8s.io/q/summary/provider-gcp-compute-persistent-disk-csi-driver/Migration%20Kubernetes%20Master%20Driver%20Stable/tests_status" />](https://testgrid.k8s.io/provider-gcp-compute-persistent-disk-csi-driver#Migration%20Kubernetes%20Master%20Driver%20Stable) |
+| HEAD stable-master | HEAD (Migration ON) | [<img alt="Test Status" src="https://testgrid.k8s.io/q/summary/provider-gcp-compute-persistent-disk-csi-driver/Kubernetes%20Master%20Driver%20Latest%20Release/tests_status" />](https://testgrid.k8s.io/provider-gcp-compute-persistent-disk-csi-driver#Kubernetes%20Master%20Driver%20Latest%20Release) |
 
 ### CSI Compatibility
 
 This plugin is compatible with CSI versions [v1.2.0](https://github.com/container-storage-interface/spec/blob/v1.2.0/spec.md), [v1.1.0](https://github.com/container-storage-interface/spec/blob/v1.1.0/spec.md), and [v1.0.0](https://github.com/container-storage-interface/spec/blob/v1.0.0/spec.md)
 
-### Kubernetes Compatibility
-The following table captures the compatibility matrix of the core persistent disk driver binary
-`gke.gcr.io/gcp-compute-persistent-disk-csi-driver`
+### Kubernetes Version Recommendations
 
-| GCE PD CSI Driver\Kubernetes Version | 1.17+ |
-|--------------------------------------|-------|
-| v0.7.x (beta)                        | yes   |
-| v1.0.x (ga)                          | yes   |
-| dev                                  | yes   |
+The latest stable of this driver is recommended for the latest stable Kubernetes
+version. For previous Kubernetes versions, we recommend the following driver
+versions.
 
-The manifest bundle which captures all the driver components (driver pod which includes the containers csi-provisioner, csi-resizer, csi-snapshotter, gce-pd-driver, csi-driver-registrar;
-csi driver object, rbacs, pod security policies etc) can be picked up from the master branch [overlays](deploy/kubernetes/overlays) directory. We structure the overlays directory, per minor version of kubernetes because not all driver components can be used with all kubernetes versions.
-
-Example:
-
-`stable-1-21` overlays bundle can be used to deploy all the components of the driver on kubernetes 1.21.
+| Kubernetes Version | PD CSI Driver Version |
+|--------------------|-----------------------|
+| HEAD               | v1.10.x               |
+| 1.27               | v1.10.x               |
+| 1.26               | v1.9.x                |
+| 1.25               | v1.8.x                |
 
-`stable-master` overlays bundle can be used to deploy all the components of the driver on kubernetes master.
-
-For more details about per k8s minor version overlays, please check this [doc](docs/release/overlays.md)
+The manifest bundle which captures all the driver components (driver pod which includes the containers csi-provisioner, csi-resizer, csi-snapshotter, gce-pd-driver, csi-driver-registrar;
+csi driver object, rbacs, pod security policies etc) for the lastest stable
+release can be picked up from the master branch [overlays](deploy/kubernetes/overlays) directory.
 
 ### Known Issues
 
diff --git a/cmd/gce-pd-csi-driver/main.go b/cmd/gce-pd-csi-driver/main.go
index 479559af..0402ac64 100644
--- a/cmd/gce-pd-csi-driver/main.go
+++ b/cmd/gce-pd-csi-driver/main.go
@@ -63,9 +63,6 @@ var (
 	maxConcurrentFormat     = flag.Int("max-concurrent-format", 1, "The maximum number of concurrent format exec calls")
 	concurrentFormatTimeout = flag.Duration("concurrent-format-timeout", 1*time.Minute, "The maximum duration of a format operation before its concurrency token is released")
 
-	maxConcurrentFormatAndMount = flag.Int("max-concurrent-format-and-mount", 1, "If set then format and mount operations are serialized on each node. This is stronger than max-concurrent-format as it includes fsck and other mount operations")
-	formatAndMountTimeout       = flag.Duration("format-and-mount-timeout", 1*time.Minute, "The maximum duration of a format and mount operation before another such operation will be started. Used only if --serialize-format-and-mount")
-
 	version string
 )
 
@@ -156,9 +153,6 @@ func handle() {
 			klog.Fatalf("Failed to set up metadata service: %v", err.Error())
 		}
 		nodeServer = driver.NewNodeServer(gceDriver, mounter, deviceUtils, meta, statter)
-		if *maxConcurrentFormatAndMount > 0 {
-			nodeServer = nodeServer.WithSerializedFormatAndMount(*formatAndMountTimeout, *maxConcurrentFormatAndMount)
-		}
 	}
 
 	err = gceDriver.SetupGCEDriver(driverName, version, extraVolumeLabels, identityServer, controllerServer, nodeServer)
diff --git a/deploy/kubernetes/images/prow-stable-sidecar-rc-master/image.yaml b/deploy/kubernetes/images/prow-stable-sidecar-rc-master/image.yaml
index 8fb5c802..ceaecad0 100644
--- a/deploy/kubernetes/images/prow-stable-sidecar-rc-master/image.yaml
+++ b/deploy/kubernetes/images/prow-stable-sidecar-rc-master/image.yaml
@@ -48,6 +48,6 @@ metadata:
 imageTag:
   name: registry.k8s.io/cloud-provider-gcp/gcp-compute-persistent-disk-csi-driver
   newName: gcr.io/k8s-staging-cloud-provider-gcp/gcp-compute-persistent-disk-csi-driver
-  newTag: "v1.10.3"
+  newTag: "v1.10.1-rc1"
 ---
 
diff --git a/deploy/kubernetes/images/stable-1-21/image.yaml b/deploy/kubernetes/images/stable-1-21/image.yaml
deleted file mode 100644
index a2e450b2..00000000
--- a/deploy/kubernetes/images/stable-1-21/image.yaml
+++ /dev/null
@@ -1,53 +0,0 @@
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-provisioner
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-provisioner
-  newTag: "v3.1.0"
-
----
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-attacher
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-attacher
-  newTag: "v3.4.0"
----
-
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-resizer
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-resizer
-  newTag: "v1.4.0"
----
-
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-snapshotter
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-snapshotter
-  newTag: "v4.0.1"
----
-
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-node-registrar
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-node-driver-registrar
-  newTag: "v2.5.0"
----
-
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-gcepd-driver
-imageTag:
-  name: gke.gcr.io/gcp-compute-persistent-disk-csi-driver
-  newTag: "v1.4.0"
----
diff --git a/deploy/kubernetes/images/stable-1-21/kustomization.yaml b/deploy/kubernetes/images/stable-1-21/kustomization.yaml
deleted file mode 100644
index f16988f1..00000000
--- a/deploy/kubernetes/images/stable-1-21/kustomization.yaml
+++ /dev/null
@@ -1,4 +0,0 @@
-namespace:
-  gce-pd-csi-driver
-resources:
-- image.yaml
diff --git a/deploy/kubernetes/images/stable-1-22/image.yaml b/deploy/kubernetes/images/stable-1-22/image.yaml
deleted file mode 100644
index 6c1fae7a..00000000
--- a/deploy/kubernetes/images/stable-1-22/image.yaml
+++ /dev/null
@@ -1,54 +0,0 @@
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-provisioner
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-provisioner
-  newTag: "v3.1.0"
-
----
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-attacher
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-attacher
-  newTag: "v3.4.0"
----
-
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-resizer
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-resizer
-  newTag: "v1.4.0"
----
-
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-snapshotter
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-snapshotter
-  newTag: "v4.0.1"
----
-
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-node-registrar
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-node-driver-registrar
-  newTag: "v2.5.0"
----
-
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-gcepd-driver
-imageTag:
-  name: gke.gcr.io/gcp-compute-persistent-disk-csi-driver
-  newName: registry.k8s.io/cloud-provider-gcp/gcp-compute-persistent-disk-csi-driver
-  newTag: "v1.7.1"
----
diff --git a/deploy/kubernetes/images/stable-1-22/kustomization.yaml b/deploy/kubernetes/images/stable-1-22/kustomization.yaml
deleted file mode 100644
index f16988f1..00000000
--- a/deploy/kubernetes/images/stable-1-22/kustomization.yaml
+++ /dev/null
@@ -1,4 +0,0 @@
-namespace:
-  gce-pd-csi-driver
-resources:
-- image.yaml
diff --git a/deploy/kubernetes/images/stable-1-23/image.yaml b/deploy/kubernetes/images/stable-1-23/image.yaml
deleted file mode 100644
index 6c1fae7a..00000000
--- a/deploy/kubernetes/images/stable-1-23/image.yaml
+++ /dev/null
@@ -1,54 +0,0 @@
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-provisioner
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-provisioner
-  newTag: "v3.1.0"
-
----
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-attacher
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-attacher
-  newTag: "v3.4.0"
----
-
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-resizer
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-resizer
-  newTag: "v1.4.0"
----
-
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-snapshotter
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-snapshotter
-  newTag: "v4.0.1"
----
-
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-node-registrar
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-node-driver-registrar
-  newTag: "v2.5.0"
----
-
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-gcepd-driver
-imageTag:
-  name: gke.gcr.io/gcp-compute-persistent-disk-csi-driver
-  newName: registry.k8s.io/cloud-provider-gcp/gcp-compute-persistent-disk-csi-driver
-  newTag: "v1.7.1"
----
diff --git a/deploy/kubernetes/images/stable-1-23/kustomization.yaml b/deploy/kubernetes/images/stable-1-23/kustomization.yaml
deleted file mode 100644
index f16988f1..00000000
--- a/deploy/kubernetes/images/stable-1-23/kustomization.yaml
+++ /dev/null
@@ -1,4 +0,0 @@
-namespace:
-  gce-pd-csi-driver
-resources:
-- image.yaml
diff --git a/deploy/kubernetes/images/stable-1-24/image.yaml b/deploy/kubernetes/images/stable-1-24/image.yaml
deleted file mode 100644
index 2f56fe7a..00000000
--- a/deploy/kubernetes/images/stable-1-24/image.yaml
+++ /dev/null
@@ -1,56 +0,0 @@
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-provisioner
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-provisioner
-  newTag: "v3.1.0"
-
----
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-attacher
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-attacher
-  newTag: "v3.4.0"
----
-
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-resizer
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-resizer
-  newTag: "v1.4.0"
----
-
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-snapshotter
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-snapshotter
-  newTag: "v4.0.1"
----
-
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-csi-node-registrar
-imageTag:
-  name: registry.k8s.io/sig-storage/csi-node-driver-registrar
-  newTag: "v2.5.0"
----
-
-apiVersion: builtin
-kind: ImageTagTransformer
-metadata:
-  name: imagetag-gcepd-driver
-imageTag:
-  name: gke.gcr.io/gcp-compute-persistent-disk-csi-driver
-  # Don't change stable image without changing pdImagePlaceholder in
-  # test/k8s-integration/main.go
-  newName: registry.k8s.io/cloud-provider-gcp/gcp-compute-persistent-disk-csi-driver
-  newTag: "v1.7.1"
----
diff --git a/deploy/kubernetes/images/stable-1-24/kustomization.yaml b/deploy/kubernetes/images/stable-1-24/kustomization.yaml
deleted file mode 100644
index f16988f1..00000000
--- a/deploy/kubernetes/images/stable-1-24/kustomization.yaml
+++ /dev/null
@@ -1,4 +0,0 @@
-namespace:
-  gce-pd-csi-driver
-resources:
-- image.yaml
diff --git a/deploy/kubernetes/overlays/stable-1-21/kustomization.yaml b/deploy/kubernetes/overlays/stable-1-21/kustomization.yaml
deleted file mode 100644
index 131348a9..00000000
--- a/deploy/kubernetes/overlays/stable-1-21/kustomization.yaml
+++ /dev/null
@@ -1,11 +0,0 @@
-apiVersion: kustomize.config.k8s.io/v1beta1
-kind: Kustomization
-namespace:
-  gce-pd-csi-driver
-resources:
-- ../../base/
-- psp_controller.yaml
-- psp_linux.yaml
-- psp_windows.yaml
-transformers:
-- ../../images/stable-1-21
diff --git a/deploy/kubernetes/overlays/stable-1-21/psp_controller.yaml b/deploy/kubernetes/overlays/stable-1-21/psp_controller.yaml
deleted file mode 100644
index 2e3a1838..00000000
--- a/deploy/kubernetes/overlays/stable-1-21/psp_controller.yaml
+++ /dev/null
@@ -1,17 +0,0 @@
-apiVersion: policy/v1beta1
-kind: PodSecurityPolicy
-metadata:
-  name: csi-gce-pd-controller-psp
-spec:
-  seLinux:
-    rule: RunAsAny
-  supplementalGroups:
-    rule: RunAsAny
-  runAsUser:
-    rule: RunAsAny
-  fsGroup:
-    rule: RunAsAny
-  volumes:
-    - "emptyDir"
-    - "secret"
-  hostNetwork: true
diff --git a/deploy/kubernetes/overlays/stable-1-21/psp_linux.yaml b/deploy/kubernetes/overlays/stable-1-21/psp_linux.yaml
deleted file mode 100644
index 079b2822..00000000
--- a/deploy/kubernetes/overlays/stable-1-21/psp_linux.yaml
+++ /dev/null
@@ -1,27 +0,0 @@
-apiVersion: policy/v1beta1
-kind: PodSecurityPolicy
-metadata:
-  name: csi-gce-pd-node-psp
-spec:
-  seLinux:
-    rule: RunAsAny
-  supplementalGroups:
-    rule: RunAsAny
-  runAsUser:
-    rule: RunAsAny
-  fsGroup:
-    rule: RunAsAny
-  privileged: true
-  volumes:
-  - '*'
-  hostNetwork: true
-  allowedHostPaths:
-  - pathPrefix: "/var/lib/kubelet/plugins_registry/"
-  - pathPrefix: "/var/lib/kubelet"
-  - pathPrefix: "/var/lib/kubelet/plugins/pd.csi.storage.gke.io/"
-  - pathPrefix: "/dev"
-  - pathPrefix: "/etc/udev"
-  - pathPrefix: "/lib/udev"
-  - pathPrefix: "/run/udev"
-  - pathPrefix: "/sys"
-
diff --git a/deploy/kubernetes/overlays/stable-1-21/psp_windows.yaml b/deploy/kubernetes/overlays/stable-1-21/psp_windows.yaml
deleted file mode 100644
index 557660a0..00000000
--- a/deploy/kubernetes/overlays/stable-1-21/psp_windows.yaml
+++ /dev/null
@@ -1,30 +0,0 @@
-apiVersion: policy/v1beta1
-kind: PodSecurityPolicy
-metadata:
-  name: csi-gce-pd-node-psp-win
-spec:
-  supplementalGroups:
-    rule: RunAsAny
-  runAsUser:
-    rule: RunAsAny
-  fsGroup:
-    rule: RunAsAny
-  seLinux:
-    rule: RunAsAny
-  volumes:
-  - '*'
-  hostNetwork: true
-  allowedHostPaths:
-  - pathPrefix: \var\lib\kubelet
-  - pathPrefix: \var\lib\kubelet\plugins_registry
-  - pathPrefix: \var\lib\kubelet\plugins\pd.csi.storage.gke.io
-  - pathPrefix: \\.\pipe\csi-proxy-disk-v1
-  - pathPrefix: \\.\pipe\csi-proxy-volume-v1
-  - pathPrefix: \\.\pipe\csi-proxy-filesystem-v1
-  # these paths are allowed only for compatibility mode if the PD CSI driver
-  # is using the CSI Proxy v1 client and the node is still using the
-  # beta version of the CSI proxy
-  - pathPrefix: \\.\pipe\csi-proxy-disk-v1beta2
-  - pathPrefix: \\.\pipe\csi-proxy-volume-v1beta1
-  - pathPrefix: \\.\pipe\csi-proxy-filesystem-v1beta1
-
diff --git a/deploy/kubernetes/overlays/stable-1-22/kustomization.yaml b/deploy/kubernetes/overlays/stable-1-22/kustomization.yaml
deleted file mode 100644
index 4f7f113e..00000000
--- a/deploy/kubernetes/overlays/stable-1-22/kustomization.yaml
+++ /dev/null
@@ -1,11 +0,0 @@
-apiVersion: kustomize.config.k8s.io/v1beta1
-kind: Kustomization
-namespace:
-  gce-pd-csi-driver
-resources:
-- ../../base/
-- psp_controller.yaml
-- psp_linux.yaml
-- psp_windows.yaml
-transformers:
-- ../../images/stable-1-22
diff --git a/deploy/kubernetes/overlays/stable-1-22/psp_controller.yaml b/deploy/kubernetes/overlays/stable-1-22/psp_controller.yaml
deleted file mode 100644
index 2e3a1838..00000000
--- a/deploy/kubernetes/overlays/stable-1-22/psp_controller.yaml
+++ /dev/null
@@ -1,17 +0,0 @@
-apiVersion: policy/v1beta1
-kind: PodSecurityPolicy
-metadata:
-  name: csi-gce-pd-controller-psp
-spec:
-  seLinux:
-    rule: RunAsAny
-  supplementalGroups:
-    rule: RunAsAny
-  runAsUser:
-    rule: RunAsAny
-  fsGroup:
-    rule: RunAsAny
-  volumes:
-    - "emptyDir"
-    - "secret"
-  hostNetwork: true
diff --git a/deploy/kubernetes/overlays/stable-1-22/psp_linux.yaml b/deploy/kubernetes/overlays/stable-1-22/psp_linux.yaml
deleted file mode 100644
index 079b2822..00000000
--- a/deploy/kubernetes/overlays/stable-1-22/psp_linux.yaml
+++ /dev/null
@@ -1,27 +0,0 @@
-apiVersion: policy/v1beta1
-kind: PodSecurityPolicy
-metadata:
-  name: csi-gce-pd-node-psp
-spec:
-  seLinux:
-    rule: RunAsAny
-  supplementalGroups:
-    rule: RunAsAny
-  runAsUser:
-    rule: RunAsAny
-  fsGroup:
-    rule: RunAsAny
-  privileged: true
-  volumes:
-  - '*'
-  hostNetwork: true
-  allowedHostPaths:
-  - pathPrefix: "/var/lib/kubelet/plugins_registry/"
-  - pathPrefix: "/var/lib/kubelet"
-  - pathPrefix: "/var/lib/kubelet/plugins/pd.csi.storage.gke.io/"
-  - pathPrefix: "/dev"
-  - pathPrefix: "/etc/udev"
-  - pathPrefix: "/lib/udev"
-  - pathPrefix: "/run/udev"
-  - pathPrefix: "/sys"
-
diff --git a/deploy/kubernetes/overlays/stable-1-22/psp_windows.yaml b/deploy/kubernetes/overlays/stable-1-22/psp_windows.yaml
deleted file mode 100644
index 557660a0..00000000
--- a/deploy/kubernetes/overlays/stable-1-22/psp_windows.yaml
+++ /dev/null
@@ -1,30 +0,0 @@
-apiVersion: policy/v1beta1
-kind: PodSecurityPolicy
-metadata:
-  name: csi-gce-pd-node-psp-win
-spec:
-  supplementalGroups:
-    rule: RunAsAny
-  runAsUser:
-    rule: RunAsAny
-  fsGroup:
-    rule: RunAsAny
-  seLinux:
-    rule: RunAsAny
-  volumes:
-  - '*'
-  hostNetwork: true
-  allowedHostPaths:
-  - pathPrefix: \var\lib\kubelet
-  - pathPrefix: \var\lib\kubelet\plugins_registry
-  - pathPrefix: \var\lib\kubelet\plugins\pd.csi.storage.gke.io
-  - pathPrefix: \\.\pipe\csi-proxy-disk-v1
-  - pathPrefix: \\.\pipe\csi-proxy-volume-v1
-  - pathPrefix: \\.\pipe\csi-proxy-filesystem-v1
-  # these paths are allowed only for compatibility mode if the PD CSI driver
-  # is using the CSI Proxy v1 client and the node is still using the
-  # beta version of the CSI proxy
-  - pathPrefix: \\.\pipe\csi-proxy-disk-v1beta2
-  - pathPrefix: \\.\pipe\csi-proxy-volume-v1beta1
-  - pathPrefix: \\.\pipe\csi-proxy-filesystem-v1beta1
-
diff --git a/deploy/kubernetes/overlays/stable-1-23/kustomization.yaml b/deploy/kubernetes/overlays/stable-1-23/kustomization.yaml
deleted file mode 100644
index 5b76e328..00000000
--- a/deploy/kubernetes/overlays/stable-1-23/kustomization.yaml
+++ /dev/null
@@ -1,11 +0,0 @@
-apiVersion: kustomize.config.k8s.io/v1beta1
-kind: Kustomization
-namespace:
-  gce-pd-csi-driver
-resources:
-- ../../base/
-- psp_controller.yaml
-- psp_linux.yaml
-- psp_windows.yaml
-transformers:
-- ../../images/stable-1-23
diff --git a/deploy/kubernetes/overlays/stable-1-23/psp_controller.yaml b/deploy/kubernetes/overlays/stable-1-23/psp_controller.yaml
deleted file mode 100644
index 2e3a1838..00000000
--- a/deploy/kubernetes/overlays/stable-1-23/psp_controller.yaml
+++ /dev/null
@@ -1,17 +0,0 @@
-apiVersion: policy/v1beta1
-kind: PodSecurityPolicy
-metadata:
-  name: csi-gce-pd-controller-psp
-spec:
-  seLinux:
-    rule: RunAsAny
-  supplementalGroups:
-    rule: RunAsAny
-  runAsUser:
-    rule: RunAsAny
-  fsGroup:
-    rule: RunAsAny
-  volumes:
-    - "emptyDir"
-    - "secret"
-  hostNetwork: true
diff --git a/deploy/kubernetes/overlays/stable-1-23/psp_linux.yaml b/deploy/kubernetes/overlays/stable-1-23/psp_linux.yaml
deleted file mode 100644
index 079b2822..00000000
--- a/deploy/kubernetes/overlays/stable-1-23/psp_linux.yaml
+++ /dev/null
@@ -1,27 +0,0 @@
-apiVersion: policy/v1beta1
-kind: PodSecurityPolicy
-metadata:
-  name: csi-gce-pd-node-psp
-spec:
-  seLinux:
-    rule: RunAsAny
-  supplementalGroups:
-    rule: RunAsAny
-  runAsUser:
-    rule: RunAsAny
-  fsGroup:
-    rule: RunAsAny
-  privileged: true
-  volumes:
-  - '*'
-  hostNetwork: true
-  allowedHostPaths:
-  - pathPrefix: "/var/lib/kubelet/plugins_registry/"
-  - pathPrefix: "/var/lib/kubelet"
-  - pathPrefix: "/var/lib/kubelet/plugins/pd.csi.storage.gke.io/"
-  - pathPrefix: "/dev"
-  - pathPrefix: "/etc/udev"
-  - pathPrefix: "/lib/udev"
-  - pathPrefix: "/run/udev"
-  - pathPrefix: "/sys"
-
diff --git a/deploy/kubernetes/overlays/stable-1-23/psp_windows.yaml b/deploy/kubernetes/overlays/stable-1-23/psp_windows.yaml
deleted file mode 100644
index 557660a0..00000000
--- a/deploy/kubernetes/overlays/stable-1-23/psp_windows.yaml
+++ /dev/null
@@ -1,30 +0,0 @@
-apiVersion: policy/v1beta1
-kind: PodSecurityPolicy
-metadata:
-  name: csi-gce-pd-node-psp-win
-spec:
-  supplementalGroups:
-    rule: RunAsAny
-  runAsUser:
-    rule: RunAsAny
-  fsGroup:
-    rule: RunAsAny
-  seLinux:
-    rule: RunAsAny
-  volumes:
-  - '*'
-  hostNetwork: true
-  allowedHostPaths:
-  - pathPrefix: \var\lib\kubelet
-  - pathPrefix: \var\lib\kubelet\plugins_registry
-  - pathPrefix: \var\lib\kubelet\plugins\pd.csi.storage.gke.io
-  - pathPrefix: \\.\pipe\csi-proxy-disk-v1
-  - pathPrefix: \\.\pipe\csi-proxy-volume-v1
-  - pathPrefix: \\.\pipe\csi-proxy-filesystem-v1
-  # these paths are allowed only for compatibility mode if the PD CSI driver
-  # is using the CSI Proxy v1 client and the node is still using the
-  # beta version of the CSI proxy
-  - pathPrefix: \\.\pipe\csi-proxy-disk-v1beta2
-  - pathPrefix: \\.\pipe\csi-proxy-volume-v1beta1
-  - pathPrefix: \\.\pipe\csi-proxy-filesystem-v1beta1
-
diff --git a/deploy/kubernetes/overlays/stable-1-24/kustomization.yaml b/deploy/kubernetes/overlays/stable-1-24/kustomization.yaml
deleted file mode 100644
index 70a57aac..00000000
--- a/deploy/kubernetes/overlays/stable-1-24/kustomization.yaml
+++ /dev/null
@@ -1,11 +0,0 @@
-apiVersion: kustomize.config.k8s.io/v1beta1
-kind: Kustomization
-namespace:
-  gce-pd-csi-driver
-resources:
-- ../../base
-- psp_controller.yaml
-- psp_linux.yaml
-- psp_windows.yaml
-transformers:
-- ../../images/stable-1-24
diff --git a/deploy/kubernetes/overlays/stable-1-24/psp_controller.yaml b/deploy/kubernetes/overlays/stable-1-24/psp_controller.yaml
deleted file mode 100644
index 2e3a1838..00000000
--- a/deploy/kubernetes/overlays/stable-1-24/psp_controller.yaml
+++ /dev/null
@@ -1,17 +0,0 @@
-apiVersion: policy/v1beta1
-kind: PodSecurityPolicy
-metadata:
-  name: csi-gce-pd-controller-psp
-spec:
-  seLinux:
-    rule: RunAsAny
-  supplementalGroups:
-    rule: RunAsAny
-  runAsUser:
-    rule: RunAsAny
-  fsGroup:
-    rule: RunAsAny
-  volumes:
-    - "emptyDir"
-    - "secret"
-  hostNetwork: true
diff --git a/deploy/kubernetes/overlays/stable-1-24/psp_linux.yaml b/deploy/kubernetes/overlays/stable-1-24/psp_linux.yaml
deleted file mode 100644
index 079b2822..00000000
--- a/deploy/kubernetes/overlays/stable-1-24/psp_linux.yaml
+++ /dev/null
@@ -1,27 +0,0 @@
-apiVersion: policy/v1beta1
-kind: PodSecurityPolicy
-metadata:
-  name: csi-gce-pd-node-psp
-spec:
-  seLinux:
-    rule: RunAsAny
-  supplementalGroups:
-    rule: RunAsAny
-  runAsUser:
-    rule: RunAsAny
-  fsGroup:
-    rule: RunAsAny
-  privileged: true
-  volumes:
-  - '*'
-  hostNetwork: true
-  allowedHostPaths:
-  - pathPrefix: "/var/lib/kubelet/plugins_registry/"
-  - pathPrefix: "/var/lib/kubelet"
-  - pathPrefix: "/var/lib/kubelet/plugins/pd.csi.storage.gke.io/"
-  - pathPrefix: "/dev"
-  - pathPrefix: "/etc/udev"
-  - pathPrefix: "/lib/udev"
-  - pathPrefix: "/run/udev"
-  - pathPrefix: "/sys"
-
diff --git a/deploy/kubernetes/overlays/stable-1-24/psp_windows.yaml b/deploy/kubernetes/overlays/stable-1-24/psp_windows.yaml
deleted file mode 100644
index 557660a0..00000000
--- a/deploy/kubernetes/overlays/stable-1-24/psp_windows.yaml
+++ /dev/null
@@ -1,30 +0,0 @@
-apiVersion: policy/v1beta1
-kind: PodSecurityPolicy
-metadata:
-  name: csi-gce-pd-node-psp-win
-spec:
-  supplementalGroups:
-    rule: RunAsAny
-  runAsUser:
-    rule: RunAsAny
-  fsGroup:
-    rule: RunAsAny
-  seLinux:
-    rule: RunAsAny
-  volumes:
-  - '*'
-  hostNetwork: true
-  allowedHostPaths:
-  - pathPrefix: \var\lib\kubelet
-  - pathPrefix: \var\lib\kubelet\plugins_registry
-  - pathPrefix: \var\lib\kubelet\plugins\pd.csi.storage.gke.io
-  - pathPrefix: \\.\pipe\csi-proxy-disk-v1
-  - pathPrefix: \\.\pipe\csi-proxy-volume-v1
-  - pathPrefix: \\.\pipe\csi-proxy-filesystem-v1
-  # these paths are allowed only for compatibility mode if the PD CSI driver
-  # is using the CSI Proxy v1 client and the node is still using the
-  # beta version of the CSI proxy
-  - pathPrefix: \\.\pipe\csi-proxy-disk-v1beta2
-  - pathPrefix: \\.\pipe\csi-proxy-volume-v1beta1
-  - pathPrefix: \\.\pipe\csi-proxy-filesystem-v1beta1
-
diff --git a/docs/release/overlays.md b/docs/release/overlays.md
index 7ea9d5e9..a4b997aa 100644
--- a/docs/release/overlays.md
+++ b/docs/release/overlays.md
@@ -1,191 +1,45 @@
-# Overview of per kubernetes minor version overlays
+# Overview of per kubernetes overlays
 
-The Persistent Disk CSI Driver manifest [bundle](../../deploy/kubernetes/base) is a set of many kubernetes resources (driver pod which includes the containers csi-provisioner, csi-resizer, csi-snapshotter, gce-pd-driver, csi-driver-registrar; csi driver object, rbacs, pod security policies etc). Not all driver capabilties can be used with all kubernetes versions. For example [volume snapshots](https://kubernetes.io/docs/concepts/storage/volume-snapshots/) are supported on 1.17+ kubernetes versions. Thus structuring the overlays on a per kubernetes minor version is beneficial to quickly identify driver capabilities supported for a given minor version of kubernetes (example `stable-1-16` driver manifests did not contain the snapshotter sidecar), and facilitates easy maintenance/updates of the CSI driver. The master branch has the up-to-date [overlays](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/tree/master/deploy/kubernetes/overlays) for each kubernetes version, which specify which driver release version to use with each kubernetes version.
-
-Example:
-`stable-1-22` [overlays](../../deploy/kubernetes/overlays/stable-1-22) bundle can be used to deploy all the components of the driver on kubernetes 1.22. This overlay uses persistent disk driver release version [1.4.0](../../deploy/kubernetes/images/stable-1-22/image.yaml).
+The Persistent Disk CSI Driver manifest [bundle](../../deploy/kubernetes/base) is a set of many kubernetes resources (driver pod which includes the containers csi-provisioner, csi-resizer, csi-snapshotter, gce-pd-driver, csi-driver-registrar; csi driver object, rbacs, pod security policies etc). The master branch has the up-to-date [overlays](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver/tree/master/deploy/kubernetes/overlays) for the lastest stable release, in addition to several other overlays used for release and other testing.
 
 ## General guidelines for creation/modification of new/existing overlays
 
 When it comes to creation of overlays there are no strict rules on how overlays must be created/modified but the following captures some of the common scenarios of adding new capabilities to the CSI driver bundle and how it would affect the overlays creation/modification.
 
 1. Creating a new k8s minor version overlay with an existing released driver image
-   * Consider a scenario where we have existing overlays `stable-1-22`, `stable-master`. We plan to now create a new overlay for k8s 1.23
-   * Update the `deploy/kubernetes/images/prow-stable-sidecar-rc-master` directory with appropriate image versions. If the images used in `stable-master` or `stable-1-22` are compatible with 1.23, no updates are necessary. 
+   * Consider a scenario where the existing `stable-master` overlay needs to be changed for a new kubernetes version.
+   * Update the `deploy/kubernetes/images/prow-stable-sidecar-rc-master` directory with appropriate image versions.
    * Update the `deploy/kubernetes/images/prow-stable-sidecar-rc-master` directory. If there are no additional kustomize diff patches to add, no updates are necessary.
    * At this stage, validate the changes made to the `prow-stable-sidecar-rc-master` overlay. Ensure the upstream testgrids like [this](https://k8s-testgrid.appspot.com/provider-gcp-compute-persistent-disk-csi-driver) are green, and verify with repository maintainers that downstream test grids (e.g GKE internal prow test grids) are green. Care must be taken to avoid directly making changes to `deploy/kubernetes/base` manifests at this stage, as they may impact existing overlays.
 
    A sample kustomize patch file would look like this:
 
    ```
-   deploy/kubernetes/overlays/prow-stable-sidecar-rc-master/your-1-23-kustomize-diff-patch.yaml
+   deploy/kubernetes/overlays/prow-stable-sidecar-rc-master/your-new-version-kustomize-diff-patch.yaml
    ```
 
    In deploy/kubernetes/overlays/prow-stable-sidecar-rc-master/kustomize.yaml,
 
-   ```
-    apiVersion: kustomize.config.k8s.io/v1beta1
-    kind: Kustomization
-    resources:
-    - ../stable-master (If this 1.23 overlay is created based out of stable-master)
-    patchesStrategicMerge: # or any other patch strategies (such as JsonPatches6902)
-    - <your-1-23-kustomize-diff-patch.yaml>
-    transformers:
-    - ../../images/prow-stable-sidecar-rc-master
-   ```
-
-   * When `prow-stable-sidecar-rc-master` is validated, we have couple of options to update the stable-1-23. If the kustomize diffs are a one-off change specific to 1.23, we can simply move the kustomize patches to stable-1-23. The kustomize patch file would now look like this.
-
-   ```
-   $ mv deploy/kubernetes/overlays/prow-stable-sidecar-rc-master/your-1-23-kustomize-diff-patch.yaml deploy/kubernetes/overlays/stable-1-23/your-1-23-kustomize-diff-patch.yaml
-   ```
-
-   For `stable-1-23`, 
-   ```
-    apiVersion: kustomize.config.k8s.io/v1beta1
-    kind: Kustomization
-    namespace:
-    gce-pd-csi-driver
-    resources:
-    - ../../base/controller
-    - ../../base/node_linux
-    patchesStrategicMerge: # or any other patch strategies (such as JsonPatches6902)
-    - <your-1-23-kustomize-diff-patch.yaml>
-    transformers:
-    - ../../images/stable-1-23
-   ```
-
-   For `prow-stable-sidecar-rc-master`,
-   ```
-    apiVersion: kustomize.config.k8s.io/v1beta1
-    kind: Kustomization
-    resources:
-    - ../stable-master
-    transformers:
-    - ../../images/prow-stable-sidecar-rc-master
-   ```
-
-   * If the changes are long term, make the changes to `deploy/kubernetes/base`, add the appropriate diff to remove the changes from the overlays less than `stable-1-23`. The overlay kustomize would look something like this
-
-   For `stable-1-23`,
-   ```
-    apiVersion: kustomize.config.k8s.io/v1beta1
-    kind: Kustomization
-    namespace:
-    gce-pd-csi-driver
-    resources:
-    - ../../base
-    # no patches needed since changes merged to deploy/kubernetes/base
-    transformers:
-    - ../../images/stable-1-23
-   ```
-
-   For `prow-stable-sidecar-rc-master`,
    ```
     apiVersion: kustomize.config.k8s.io/v1beta1
     kind: Kustomization
     resources:
     - ../stable-master
-    transformers:
-    - ../../images/prow-stable-sidecar-rc-master
-   ```
-
-   For `stable-1-22` and older overlays,
-   ```
-    apiVersion: kustomize.config.k8s.io/v1beta1
-    kind: Kustomization
-    namespace:
-    gce-pd-csi-driver
-    resources:
-    - ../../base
     patchesStrategicMerge: # or any other patch strategies (such as JsonPatches6902)
-    - <your-1-22-kustomize-diff-remove-1-23-changes-patch.yaml>
-    transformers:
-    - ../../images/stable-1-22
-   ```
-
-2. Sidecar image version update for existing overlays
-   * Consider a scenario where we have three existing stable overlays `stable-1-22`, `stable-1-23`, `stable-master`. Sidecar S1 is available 1.22+, S2 is available 1.23+. If we need to upgrade the image versions for these sidecars, we would do the following:
-   * Update the `deploy/kubernetes/images/prow-stable-sidecar-rc-master` for sidecar S1 and S2.
-   * Validate the changes made to the staging overlays. Ensure the upstream testgrids like [this](https://k8s-testgrid.appspot.com/provider-gcp-compute-persistent-disk-csi-driver) are green, and verify with repository maintainers that downstream test grids (e.g GKE internal prow test grids) are green.
-   * Now update `deploy/kubernetes/images/stable-1-22` for sidecar S1, and `deploy/kubernetes/images/stable-1-23`, `deploy/kubernetes/images/stable-master` for sidecar S1 and S2. Repository maintainers should ensure that any internal downstream testgrids are green before approving the pull request to merge changes to a stable overlay.
-
-3. Sidecar spec changes
-   * Consider a scenario where a sidecar S1 has version V1 in 1.22 and V2 in 1.23. V2 introcudes a new capability via a new arg 'new-flag' (and say this flag deprecates 'old-flag'). To introduce this change, first we make changes to the `deploy/kubernetes/images/prow-stable-sidecar-rc-master` sidecar spec.
-
-   For `prow-stable-sidecar-rc-master` overlay, 
-   ```
-   apiVersion: kustomize.config.k8s.io/v1beta1
-   kind: Kustomization
-   resources:
-   - ../stable-master
-   patchesStrategicMerge: # or any other patch strategies (such as JsonPatches6902)
-   - <your-1-23-kustomize-diff-patch-for-new-sidecar-spec.yaml>
-   transformers:
-   - ../../images/prow-stable-sidecar-rc-master
-   ```
-
-   * Validate the changes made to the staging overlays. Ensure the upstream testgrids like [this](https://k8s-testgrid.appspot.com/provider-gcp-compute-persistent-disk-csi-driver) are green, and verify with repository maintainers that downstream test grids (e.g GKE internal prow test grids) are green.
-   * Now to merge the change to stable overlay, we incorporate the change in deploy/kubernetes/base, 
-
-   ```
-   containers:
-        - name: <your-sidecar>
-          ...
-          args:
-            - "--new-flag" # --old-flag deleted.
-   ```
-
-   * 
-   For `stable-1-23`,
-   ```
-    apiVersion: kustomize.config.k8s.io/v1beta1
-    kind: Kustomization
-    namespace:
-    gce-pd-csi-driver
-    resources:
-    - ../../base
-    # no patches needed since changes merged to deploy/kubernetes/base
-    transformers:
-    - ../../images/stable-1-23
-   ```
-
-   For `prow-stable-sidecar-rc-master`,
-   ```
-    apiVersion: kustomize.config.k8s.io/v1beta1
-    kind: Kustomization
-    resources:
-    - ../stable-master
+    - <your-1-23-kustomize-diff-patch.yaml>
     transformers:
     - ../../images/prow-stable-sidecar-rc-master
    ```
 
-   For `stable-1-22` and older overlays,
-   ```
-    apiVersion: kustomize.config.k8s.io/v1beta1
-    kind: Kustomization
-    namespace:
-    gce-pd-csi-driver
-    resources:
-    - ../../base
-    patchesStrategicMerge: # or any other patch strategies (such as JsonPatches6902)
-    - <your-1-22-kustomize-diff-patch-to-replace-new-flag-with-old-flag.yaml>
-    transformers:
-    - ../../images/stable-1-22
+   * When `prow-stable-sidecar-rc-master` is validated, we can then update the yaml in the `base/` directory.
    ```
 
-4. Driver image update
-   * If we have released a new driver image version, update the drivers image version in `deploy/kubernetes/images/prow-stable-sidecar-rc-master/image.yaml`. 
-   * Validate the staging drivers and then make changes to the `deploy/kubernetes/images/stable-{k8s-minor}/image.yaml` and `deploy/kubernetes/images/stable-master/image.yaml`, for whichever k8s minor versions are compatible with the new driver image version.
-
-5. Cutting new releases
-   * With the master branch maintaining the stable-x.y overlays, the master branch stable overlays can always be the referenced to pick the latest and greatest stable driver manifest bundle.
-   * At the time of cutting a release branch (e.g release-1.0), we should ensure that the release branch has valid overlays bundle for all the k8s minor versions the driver supports, and tests running against the release branch will work. As the master branch moves forward, the release branch is still valid (but not necessarily up-to-date). For the most up-to-date manifests, refer to the master stable-x.y overlays.
-   * GKE  managed driver changes will be pulled from the master branch stable-x.y overlays.
+2. Cutting new releases
+   * At the time of cutting a release branch (e.g release-1.0), we should ensure that the release branch has valid overlays bundle for all the most recent k8s minor version. As the master branch moves forward, the release branch is still valid (but not necessarily up-to-date). For the most up-to-date manifests, refer to the master overlay.
    * As the master branch moves forward (changes to sidecars etc), we should cherry-pick changes to an older release branch only on a need basis. Possible cases of cherrypick:
 
     1. Critical bug fixes on the core driver.
 
     2. If a critical bug fix involves multiple components (driver and sidecar), cherry-pick all the changes to the older release branch.
 
-   After a change has been cherry-picked to a release branch, a new patch release will have to be cut on that branch, and the overlays would be updated to reflect the new driver image version. Check release process [here](../../release-tools/README.md)
\ No newline at end of file
+   After a change has been cherry-picked to a release branch, a new patch release will have to be cut on that branch, and the overlays would be updated to reflect the new driver image version. Check release process [here](../../release-tools/README.md)
diff --git a/pkg/common/parameters.go b/pkg/common/parameters.go
index f91d915e..e7f0104d 100644
--- a/pkg/common/parameters.go
+++ b/pkg/common/parameters.go
@@ -29,7 +29,6 @@ const (
 	ParameterKeyLabels                        = "labels"
 	ParameterKeyProvisionedIOPSOnCreate       = "provisioned-iops-on-create"
 	ParameterKeyProvisionedThroughputOnCreate = "provisioned-throughput-on-create"
-	ParameterAvailabilityClass                = "availability-class"
 
 	// Parameters for VolumeSnapshotClass
 	ParameterKeyStorageLocations = "storage-locations"
@@ -39,10 +38,6 @@ const (
 	DiskImageType                = "images"
 	replicationTypeNone          = "none"
 
-	// Parameters for AvailabilityClass
-	ParameterNoAvailabilityClass       = "none"
-	ParameterRegionalHardFailoverClass = "regional-hard-failover"
-
 	// Keys for PV and PVC parameters as reported by external-provisioner
 	ParameterKeyPVCName      = "csi.storage.k8s.io/pvc/name"
 	ParameterKeyPVCNamespace = "csi.storage.k8s.io/pvc/namespace"
@@ -88,8 +83,6 @@ type DiskParameters struct {
 	// Values: {int64}
 	// Default: none
 	ProvisionedThroughputOnCreate int64
-	// Default: false
-	ForceAttach bool
 }
 
 // SnapshotParameters contains normalized and defaulted parameters for snapshots
@@ -162,14 +155,6 @@ func ExtractAndDefaultParameters(parameters map[string]string, driverName string
 				return p, fmt.Errorf("parameters contain invalid provisionedThroughputOnCreate parameter: %w", err)
 			}
 			p.ProvisionedThroughputOnCreate = paramProvisionedThroughputOnCreate
-		case ParameterAvailabilityClass:
-			paramAvailabilityClass, err := ConvertStringToAvailabilityClass(v)
-			if err != nil {
-				return p, fmt.Errorf("parameters contain invalid availability class parameter: %w", err)
-			}
-			if paramAvailabilityClass == ParameterRegionalHardFailoverClass {
-				p.ForceAttach = true
-			}
 		default:
 			return p, fmt.Errorf("parameters contains invalid option %q", k)
 		}
diff --git a/pkg/common/utils.go b/pkg/common/utils.go
index 1fd22cba..af4e5d21 100644
--- a/pkg/common/utils.go
+++ b/pkg/common/utils.go
@@ -79,14 +79,6 @@ var (
 	// Full or partial URL of the machine type resource, in the format:
 	//   zones/zone/machineTypes/machine-type
 	machineTypeRegex = regexp.MustCompile(machineTypePattern)
-
-	// userErrorCodeMap tells how API error types are translated to error codes.
-	userErrorCodeMap = map[int]codes.Code{
-		http.StatusForbidden:       codes.PermissionDenied,
-		http.StatusBadRequest:      codes.InvalidArgument,
-		http.StatusTooManyRequests: codes.ResourceExhausted,
-		http.StatusNotFound:        codes.NotFound,
-	}
 )
 
 func BytesToGbRoundDown(bytes int64) int64 {
@@ -292,28 +284,6 @@ func ConvertMiStringToInt64(str string) (int64, error) {
 	return volumehelpers.RoundUpToMiB(quantity)
 }
 
-// ConvertStringToBool converts a string to a boolean.
-func ConvertStringToBool(str string) (bool, error) {
-	switch strings.ToLower(str) {
-	case "true":
-		return true, nil
-	case "false":
-		return false, nil
-	}
-	return false, fmt.Errorf("Unexpected boolean string %s", str)
-}
-
-// ConvertStringToAvailabilityClass converts a string to an availability class string.
-func ConvertStringToAvailabilityClass(str string) (string, error) {
-	switch strings.ToLower(str) {
-	case ParameterNoAvailabilityClass:
-		return ParameterNoAvailabilityClass, nil
-	case ParameterRegionalHardFailoverClass:
-		return ParameterRegionalHardFailoverClass, nil
-	}
-	return "", fmt.Errorf("Unexpected boolean string %s", str)
-}
-
 // ParseMachineType returns an extracted machineType from a URL, or empty if not found.
 // machineTypeUrl: Full or partial URL of the machine type resource, in the format:
 //
@@ -326,63 +296,82 @@ func ParseMachineType(machineTypeUrl string) (string, error) {
 	return machineType[1], nil
 }
 
-// CodeForError returns the grpc error code that maps to the http error code for the
-// passed in user googleapi error or context error. Returns codes.Internal if the given
-// error is not a googleapi error caused by the user. userErrorCodeMap is used for
-// encoding most errors.
-func CodeForError(sourceError error) codes.Code {
-	if sourceError == nil {
-		return codes.Internal
+// CodeForError returns a pointer to the grpc error code that maps to the http
+// error code for the passed in user googleapi error or context error. Returns
+// codes.Internal if the given error is not a googleapi error caused by the user.
+// The following http error codes are considered user errors:
+// (1) http 400 Bad Request, returns grpc InvalidArgument,
+// (2) http 403 Forbidden, returns grpc PermissionDenied,
+// (3) http 404 Not Found, returns grpc NotFound
+// (4) http 429 Too Many Requests, returns grpc ResourceExhausted
+// The following errors are considered context errors:
+// (1) "context deadline exceeded", returns grpc DeadlineExceeded,
+// (2) "context canceled", returns grpc Canceled
+func CodeForError(err error) *codes.Code {
+	if err == nil {
+		return nil
 	}
 
-	if code, err := existingErrorCode(sourceError); err == nil {
-		return code
+	if errCode := existingErrorCode(err); errCode != nil {
+		return errCode
 	}
-	if code, err := isContextError(sourceError); err == nil {
+	if code := isContextError(err); code != nil {
 		return code
 	}
 
+	internalErrorCode := codes.Internal
+	// Upwrap the error
 	var apiErr *googleapi.Error
-	if !errors.As(sourceError, &apiErr) {
-		return codes.Internal
+	if !errors.As(err, &apiErr) {
+		return &internalErrorCode
 	}
-	if code, ok := userErrorCodeMap[apiErr.Code]; ok {
-		return code
+
+	userErrors := map[int]codes.Code{
+		http.StatusForbidden:       codes.PermissionDenied,
+		http.StatusBadRequest:      codes.InvalidArgument,
+		http.StatusTooManyRequests: codes.ResourceExhausted,
+		http.StatusNotFound:        codes.NotFound,
+	}
+	if code, ok := userErrors[apiErr.Code]; ok {
+		return &code
 	}
 
-	return codes.Internal
+	return &internalErrorCode
 }
 
-// isContextError returns the grpc error code DeadlineExceeded if the passed in error
-// contains the "context deadline exceeded" string and returns the grpc error code
-// Canceled if the error contains the "context canceled" string. It returns and error if
-// err isn't a context error.
-func isContextError(err error) (codes.Code, error) {
+// isContextError returns a pointer to the grpc error code DeadlineExceeded
+// if the passed in error contains the "context deadline exceeded" string and returns
+// the grpc error code Canceled if the error contains the "context canceled" string.
+func isContextError(err error) *codes.Code {
 	if err == nil {
-		return codes.Unknown, fmt.Errorf("null error")
+		return nil
 	}
 
 	errStr := err.Error()
 	if strings.Contains(errStr, context.DeadlineExceeded.Error()) {
-		return codes.DeadlineExceeded, nil
+		return errCodePtr(codes.DeadlineExceeded)
 	}
 	if strings.Contains(errStr, context.Canceled.Error()) {
-		return codes.Canceled, nil
+		return errCodePtr(codes.Canceled)
 	}
-	return codes.Unknown, fmt.Errorf("Not a context error: %w", err)
+	return nil
 }
 
-func existingErrorCode(err error) (codes.Code, error) {
+func existingErrorCode(err error) *codes.Code {
 	if err == nil {
-		return codes.Unknown, fmt.Errorf("null error")
+		return nil
 	}
 	if status, ok := status.FromError(err); ok {
-		return status.Code(), nil
+		return errCodePtr(status.Code())
 	}
-	return codes.Unknown, fmt.Errorf("no existing error code for %w", err)
+	return nil
+}
+
+func errCodePtr(code codes.Code) *codes.Code {
+	return &code
 }
 
 func LoggedError(msg string, err error) error {
 	klog.Errorf(msg+"%v", err.Error())
-	return status.Errorf(CodeForError(err), msg+"%v", err.Error())
+	return status.Errorf(*CodeForError(err), msg+"%v", err.Error())
 }
diff --git a/pkg/gce-cloud-provider/compute/fake-gce.go b/pkg/gce-cloud-provider/compute/fake-gce.go
index 4efc3fad..e6731140 100644
--- a/pkg/gce-cloud-provider/compute/fake-gce.go
+++ b/pkg/gce-cloud-provider/compute/fake-gce.go
@@ -229,10 +229,10 @@ func (cloud *FakeCloudProvider) InsertDisk(ctx context.Context, project string,
 	switch volKey.Type() {
 	case meta.Zonal:
 		computeDisk.Zone = volKey.Zone
-		computeDisk.SelfLink = fmt.Sprintf("%sprojects/%s/zones/%s/disks/%s", BasePath, project, volKey.Zone, volKey.Name)
+		computeDisk.SelfLink = fmt.Sprintf("projects/%s/zones/%s/disks/%s", project, volKey.Zone, volKey.Name)
 	case meta.Regional:
 		computeDisk.Region = volKey.Region
-		computeDisk.SelfLink = fmt.Sprintf("%sprojects/%s/regions/%s/disks/%s", BasePath, project, volKey.Region, volKey.Name)
+		computeDisk.SelfLink = fmt.Sprintf("projects/%s/regions/%s/disks/%s", project, volKey.Region, volKey.Name)
 	default:
 		return fmt.Errorf("could not create disk, key was neither zonal nor regional, instead got: %v", volKey.String())
 	}
@@ -246,16 +246,15 @@ func (cloud *FakeCloudProvider) DeleteDisk(ctx context.Context, project string,
 	return nil
 }
 
-func (cloud *FakeCloudProvider) AttachDisk(ctx context.Context, project string, volKey *meta.Key, readWrite, diskType, instanceZone, instanceName string, forceAttach bool) error {
+func (cloud *FakeCloudProvider) AttachDisk(ctx context.Context, project string, volKey *meta.Key, readWrite, diskType, instanceZone, instanceName string) error {
 	source := cloud.GetDiskSourceURI(project, volKey)
 
 	attachedDiskV1 := &computev1.AttachedDisk{
-		DeviceName:  volKey.Name,
-		Kind:        diskKind,
-		Mode:        readWrite,
-		Source:      source,
-		Type:        diskType,
-		ForceAttach: forceAttach,
+		DeviceName: volKey.Name,
+		Kind:       diskKind,
+		Mode:       readWrite,
+		Source:     source,
+		Type:       diskType,
 	}
 	instance, ok := cloud.instances[instanceName]
 	if !ok {
@@ -539,14 +538,14 @@ func (cloud *FakeBlockingCloudProvider) DetachDisk(ctx context.Context, project,
 	return cloud.FakeCloudProvider.DetachDisk(ctx, project, deviceName, instanceZone, instanceName)
 }
 
-func (cloud *FakeBlockingCloudProvider) AttachDisk(ctx context.Context, project string, volKey *meta.Key, readWrite, diskType, instanceZone, instanceName string, forceAttach bool) error {
+func (cloud *FakeBlockingCloudProvider) AttachDisk(ctx context.Context, project string, volKey *meta.Key, readWrite, diskType, instanceZone, instanceName string) error {
 	execute := make(chan Signal)
 	cloud.ReadyToExecute <- execute
 	val := <-execute
 	if val.ReportError {
 		return fmt.Errorf("force mock error for AttachDisk: volkey %s", volKey)
 	}
-	return cloud.FakeCloudProvider.AttachDisk(ctx, project, volKey, readWrite, diskType, instanceZone, instanceName, forceAttach)
+	return cloud.FakeCloudProvider.AttachDisk(ctx, project, volKey, readWrite, diskType, instanceZone, instanceName)
 }
 
 func notFoundError() *googleapi.Error {
diff --git a/pkg/gce-cloud-provider/compute/gce-compute.go b/pkg/gce-cloud-provider/compute/gce-compute.go
index 5c20e686..6631855a 100644
--- a/pkg/gce-cloud-provider/compute/gce-compute.go
+++ b/pkg/gce-cloud-provider/compute/gce-compute.go
@@ -92,7 +92,7 @@ type GCECompute interface {
 	ValidateExistingDisk(ctx context.Context, disk *CloudDisk, params common.DiskParameters, reqBytes, limBytes int64, multiWriter bool) error
 	InsertDisk(ctx context.Context, project string, volKey *meta.Key, params common.DiskParameters, capBytes int64, capacityRange *csi.CapacityRange, replicaZones []string, snapshotID string, volumeContentSourceVolumeID string, multiWriter bool) error
 	DeleteDisk(ctx context.Context, project string, volumeKey *meta.Key) error
-	AttachDisk(ctx context.Context, project string, volKey *meta.Key, readWrite, diskType, instanceZone, instanceName string, forceAttach bool) error
+	AttachDisk(ctx context.Context, project string, volKey *meta.Key, readWrite, diskType, instanceZone, instanceName string) error
 	DetachDisk(ctx context.Context, project, deviceName, instanceZone, instanceName string) error
 	GetDiskSourceURI(project string, volKey *meta.Key) string
 	GetDiskTypeURI(project string, volKey *meta.Key, diskType string) string
@@ -419,9 +419,6 @@ func convertV1DiskToBetaDisk(v1Disk *computev1.Disk, provisionedThroughputOnCrea
 		ReplicaZones:      v1Disk.ReplicaZones,
 		DiskEncryptionKey: dek,
 	}
-	if v1Disk.ProvisionedIops > 0 {
-		betaDisk.ProvisionedIops = v1Disk.ProvisionedIops
-	}
 	if provisionedThroughputOnCreate > 0 {
 		betaDisk.ProvisionedThroughput = provisionedThroughputOnCreate
 	}
@@ -452,11 +449,12 @@ func (cloud *CloudProvider) insertRegionalDisk(
 	}
 
 	diskToCreate := &computev1.Disk{
-		Name:        volKey.Name,
-		SizeGb:      common.BytesToGbRoundUp(capBytes),
-		Description: description,
-		Type:        cloud.GetDiskTypeURI(cloud.project, volKey, params.DiskType),
-		Labels:      params.Labels,
+		Name:            volKey.Name,
+		SizeGb:          common.BytesToGbRoundUp(capBytes),
+		Description:     description,
+		Type:            cloud.GetDiskTypeURI(cloud.project, volKey, params.DiskType),
+		Labels:          params.Labels,
+		ProvisionedIops: params.ProvisionedIOPSOnCreate,
 	}
 	if snapshotID != "" {
 		_, snapshotType, _, err := common.SnapshotIDToProjectKey(snapshotID)
@@ -564,12 +562,11 @@ func (cloud *CloudProvider) insertZonalDisk(
 	}
 
 	diskToCreate := &computev1.Disk{
-		Name:            volKey.Name,
-		SizeGb:          common.BytesToGbRoundUp(capBytes),
-		Description:     description,
-		Type:            cloud.GetDiskTypeURI(project, volKey, params.DiskType),
-		Labels:          params.Labels,
-		ProvisionedIops: params.ProvisionedIOPSOnCreate,
+		Name:        volKey.Name,
+		SizeGb:      common.BytesToGbRoundUp(capBytes),
+		Description: description,
+		Type:        cloud.GetDiskTypeURI(project, volKey, params.DiskType),
+		Labels:      params.Labels,
 	}
 
 	if snapshotID != "" {
@@ -703,7 +700,7 @@ func (cloud *CloudProvider) deleteRegionalDisk(ctx context.Context, project, reg
 	return nil
 }
 
-func (cloud *CloudProvider) AttachDisk(ctx context.Context, project string, volKey *meta.Key, readWrite, diskType, instanceZone, instanceName string, forceAttach bool) error {
+func (cloud *CloudProvider) AttachDisk(ctx context.Context, project string, volKey *meta.Key, readWrite, diskType, instanceZone, instanceName string) error {
 	klog.V(5).Infof("Attaching disk %v to %s", volKey, instanceName)
 	source := cloud.GetDiskSourceURI(project, volKey)
 
@@ -717,13 +714,9 @@ func (cloud *CloudProvider) AttachDisk(ctx context.Context, project string, volK
 		Mode:       readWrite,
 		Source:     source,
 		Type:       diskType,
-		// This parameter is ignored in the call, the ForceAttach decorator
-		// (query parameter) is the important one. We'll set it in both places
-		// in case that behavior changes.
-		ForceAttach: forceAttach,
 	}
 
-	op, err := cloud.service.Instances.AttachDisk(project, instanceZone, instanceName, attachedDiskV1).Context(ctx).ForceAttach(forceAttach).Do()
+	op, err := cloud.service.Instances.AttachDisk(project, instanceZone, instanceName, attachedDiskV1).Context(ctx).Do()
 	if err != nil {
 		return fmt.Errorf("failed cloud service attach disk call: %w", err)
 	}
@@ -859,10 +852,6 @@ func (cloud *CloudProvider) WaitForAttach(ctx context.Context, project string, v
 }
 
 func wrapOpErr(name string, opErr *computev1.OperationErrorErrors) error {
-	if opErr == nil {
-		return nil
-	}
-
 	if opErr.Code == "UNSUPPORTED_OPERATION" {
 		if diskType := pdDiskTypeUnsupportedRegex.FindStringSubmatch(opErr.Message); diskType != nil {
 			return &UnsupportedDiskError{
@@ -870,29 +859,7 @@ func wrapOpErr(name string, opErr *computev1.OperationErrorErrors) error {
 			}
 		}
 	}
-	grpcErrCode := codeForGCEOpError(*opErr)
-	return status.Errorf(grpcErrCode, "operation %v failed (%v): %v", name, opErr.Code, opErr.Message)
-}
-
-// codeForGCEOpError return the grpc error code for the passed in
-// gce operation error.
-func codeForGCEOpError(err computev1.OperationErrorErrors) codes.Code {
-	userErrors := map[string]codes.Code{
-		"RESOURCE_NOT_FOUND":                        codes.NotFound,
-		"RESOURCE_ALREADY_EXISTS":                   codes.AlreadyExists,
-		"RESOURCE_IN_USE_BY_ANOTHER_RESOURCE":       codes.InvalidArgument,
-		"OPERATION_CANCELED_BY_USER":                codes.Aborted,
-		"QUOTA_EXCEEDED":                            codes.ResourceExhausted,
-		"ZONE_RESOURCE_POOL_EXHAUSTED":              codes.Unavailable,
-		"ZONE_RESOURCE_POOL_EXHAUSTED_WITH_DETAILS": codes.Unavailable,
-		"REGION_QUOTA_EXCEEDED":                     codes.ResourceExhausted,
-		"RATE_LIMIT_EXCEEDED":                       codes.ResourceExhausted,
-		"INVALID_USAGE":                             codes.InvalidArgument,
-	}
-	if code, ok := userErrors[err.Code]; ok {
-		return code
-	}
-	return codes.Internal
+	return fmt.Errorf("operation %v failed (%v): %v", name, opErr.Code, opErr.Message)
 }
 
 func opIsDone(op *computev1.Operation) (bool, error) {
diff --git a/pkg/gce-pd-csi-driver/controller.go b/pkg/gce-pd-csi-driver/controller.go
index 3655ce13..b2157960 100644
--- a/pkg/gce-pd-csi-driver/controller.go
+++ b/pkg/gce-pd-csi-driver/controller.go
@@ -19,7 +19,7 @@ import (
 	"errors"
 	"fmt"
 	"math/rand"
-	neturl "net/url"
+	"regexp"
 	"sort"
 	"strings"
 	"time"
@@ -92,12 +92,10 @@ type GCEControllerServer struct {
 	errorBackoff *csiErrorBackoff
 }
 
-type csiErrorBackoffId string
-
 type csiErrorBackoff struct {
-	backoff    *flowcontrol.Backoff
-	errorCodes map[csiErrorBackoffId]codes.Code
+	backoff *flowcontrol.Backoff
 }
+type csiErrorBackoffId string
 
 type workItem struct {
 	ctx          context.Context
@@ -113,11 +111,6 @@ type locationRequirements struct {
 	cloneReplicationType string
 }
 
-// PDCSIContext is the extracted VolumeContext from controller requests.
-type PDCSIContext struct {
-	ForceAttach bool
-}
-
 var _ csi.ControllerServer = &GCEControllerServer{}
 
 const (
@@ -137,17 +130,6 @@ const (
 	// but 500 is a good proxy (gives ~8KB of data per ListVolumesResponse#Entry)
 	// See https://github.com/grpc/grpc/blob/master/include/grpc/impl/codegen/grpc_types.h#L503)
 	maxListVolumesResponseEntries = 500
-
-	// Keys in the volume context.
-	contextForceAttach = "force-attach"
-
-	resourceApiScheme  = "https"
-	resourceApiService = "compute"
-	resourceProject    = "projects"
-)
-
-var (
-	validResourceApiVersions = map[string]bool{"v1": true, "alpha": true, "beta": true}
 )
 
 func isDiskReady(disk *gce.CloudDisk) (bool, error) {
@@ -215,7 +197,9 @@ func (gceCS *GCEControllerServer) CreateVolume(ctx context.Context, req *csi.Cre
 	var err error
 	diskTypeForMetric := ""
 	defer func() {
-		gceCS.Metrics.RecordOperationErrorMetrics("CreateVolume", err, diskTypeForMetric)
+		if err != nil {
+			gceCS.Metrics.RecordOperationErrorMetrics("CreateVolume", err, diskTypeForMetric)
+		}
 	}()
 	// Validate arguments
 	volumeCapabilities := req.GetVolumeCapabilities()
@@ -252,11 +236,6 @@ func (gceCS *GCEControllerServer) CreateVolume(ctx context.Context, req *csi.Cre
 		gceAPIVersion = gce.GCEAPIVersionBeta
 	}
 
-	// Verify that the regional availability class is only used on regional disks.
-	if params.ForceAttach && params.ReplicationType != replicationTypeRegionalPD {
-		return nil, status.Errorf(codes.InvalidArgument, "invalid availabilty class for zonal disk")
-	}
-
 	var locationTopReq *locationRequirements
 	if useVolumeCloning(req) {
 		locationTopReq, err = cloningLocationRequirements(req, params.ReplicationType)
@@ -304,6 +283,7 @@ func (gceCS *GCEControllerServer) CreateVolume(ctx context.Context, req *csi.Cre
 
 	// Validate if disk already exists
 	existingDisk, err := gceCS.CloudProvider.GetDisk(ctx, gceCS.CloudProvider.GetDefaultProject(), volKey, gceAPIVersion)
+	diskTypeForMetric = metrics.GetDiskType(existingDisk)
 	if err != nil {
 		if !gce.IsGCEError(err, "notFound") {
 			return nil, common.LoggedError("CreateVolume, failed to getDisk when validating: ", err)
@@ -329,7 +309,7 @@ func (gceCS *GCEControllerServer) CreateVolume(ctx context.Context, req *csi.Cre
 
 		// If there is no validation error, immediately return success
 		klog.V(4).Infof("CreateVolume succeeded for disk %v, it already exists and was compatible", volKey)
-		return generateCreateVolumeResponse(existingDisk, zones, params)
+		return generateCreateVolumeResponse(existingDisk, zones), nil
 	}
 
 	snapshotID := ""
@@ -444,7 +424,7 @@ func (gceCS *GCEControllerServer) CreateVolume(ctx context.Context, req *csi.Cre
 	}
 
 	klog.V(4).Infof("CreateVolume succeeded for disk %v", volKey)
-	return generateCreateVolumeResponse(disk, zones, params)
+	return generateCreateVolumeResponse(disk, zones), nil
 
 }
 
@@ -452,7 +432,9 @@ func (gceCS *GCEControllerServer) DeleteVolume(ctx context.Context, req *csi.Del
 	var err error
 	diskTypeForMetric := ""
 	defer func() {
-		gceCS.Metrics.RecordOperationErrorMetrics("DeleteVolume", err, diskTypeForMetric)
+		if err != nil {
+			gceCS.Metrics.RecordOperationErrorMetrics("DeleteVolume", err, diskTypeForMetric)
+		}
 	}()
 	// Validate arguments
 	volumeID := req.GetVolumeId()
@@ -496,23 +478,25 @@ func (gceCS *GCEControllerServer) ControllerPublishVolume(ctx context.Context, r
 	var err error
 	diskTypeForMetric := ""
 	defer func() {
-		gceCS.Metrics.RecordOperationErrorMetrics("ControllerPublishVolume", err, diskTypeForMetric)
+		if err != nil {
+			gceCS.Metrics.RecordOperationErrorMetrics("ControllerPublishVolume", err, diskTypeForMetric)
+		}
 	}()
 	// Only valid requests will be accepted
-	_, _, _, err = gceCS.validateControllerPublishVolumeRequest(ctx, req)
+	_, _, err = gceCS.validateControllerPublishVolumeRequest(ctx, req)
 	if err != nil {
 		return nil, err
 	}
 
 	backoffId := gceCS.errorBackoff.backoffId(req.NodeId, req.VolumeId)
 	if gceCS.errorBackoff.blocking(backoffId) {
-		return nil, status.Errorf(gceCS.errorBackoff.code(backoffId), "ControllerPublish not permitted on node %q due to backoff condition", req.NodeId)
+		return nil, status.Errorf(codes.Unavailable, "ControllerPublish not permitted on node %q due to backoff condition", req.NodeId)
 	}
 
 	resp, err, diskTypeForMetric := gceCS.executeControllerPublishVolume(ctx, req)
 	if err != nil {
-		klog.Infof("For node %s adding backoff due to error for volume %s: %v", req.NodeId, req.VolumeId, err)
-		gceCS.errorBackoff.next(backoffId, common.CodeForError(err))
+		klog.Infof("For node %s adding backoff due to error for volume %s: %v", req.NodeId, req.VolumeId, err.Error())
+		gceCS.errorBackoff.next(backoffId)
 	} else {
 		klog.Infof("For node %s clear backoff due to successful publish of volume %v", req.NodeId, req.VolumeId)
 		gceCS.errorBackoff.reset(backoffId)
@@ -520,37 +504,32 @@ func (gceCS *GCEControllerServer) ControllerPublishVolume(ctx context.Context, r
 	return resp, err
 }
 
-func (gceCS *GCEControllerServer) validateControllerPublishVolumeRequest(ctx context.Context, req *csi.ControllerPublishVolumeRequest) (string, *meta.Key, *PDCSIContext, error) {
+func (gceCS *GCEControllerServer) validateControllerPublishVolumeRequest(ctx context.Context, req *csi.ControllerPublishVolumeRequest) (string, *meta.Key, error) {
 	// Validate arguments
 	volumeID := req.GetVolumeId()
 	nodeID := req.GetNodeId()
 	volumeCapability := req.GetVolumeCapability()
 	if len(volumeID) == 0 {
-		return "", nil, nil, status.Error(codes.InvalidArgument, "ControllerPublishVolume Volume ID must be provided")
+		return "", nil, status.Error(codes.InvalidArgument, "ControllerPublishVolume Volume ID must be provided")
 	}
 	if len(nodeID) == 0 {
-		return "", nil, nil, status.Error(codes.InvalidArgument, "ControllerPublishVolume Node ID must be provided")
+		return "", nil, status.Error(codes.InvalidArgument, "ControllerPublishVolume Node ID must be provided")
 	}
 	if volumeCapability == nil {
-		return "", nil, nil, status.Error(codes.InvalidArgument, "ControllerPublishVolume Volume capability must be provided")
+		return "", nil, status.Error(codes.InvalidArgument, "ControllerPublishVolume Volume capability must be provided")
 	}
 
 	project, volKey, err := common.VolumeIDToKey(volumeID)
 	if err != nil {
-		return "", nil, nil, status.Errorf(codes.InvalidArgument, "ControllerPublishVolume volume ID is invalid: %v", err.Error())
+		return "", nil, status.Errorf(codes.InvalidArgument, "ControllerPublishVolume volume ID is invalid: %v", err.Error())
 	}
 
 	// TODO(#253): Check volume capability matches for ALREADY_EXISTS
 	if err = validateVolumeCapability(volumeCapability); err != nil {
-		return "", nil, nil, status.Errorf(codes.InvalidArgument, "VolumeCapabilities is invalid: %v", err.Error())
+		return "", nil, status.Errorf(codes.InvalidArgument, "VolumeCapabilities is invalid: %v", err.Error())
 	}
 
-	var pdcsiContext *PDCSIContext
-	if pdcsiContext, err = extractVolumeContext(req.VolumeContext); err != nil {
-		return "", nil, nil, status.Errorf(codes.InvalidArgument, "Invalid volume context: %v", err.Error())
-	}
-
-	return project, volKey, pdcsiContext, nil
+	return project, volKey, nil
 }
 
 func parseMachineType(machineTypeUrl string) string {
@@ -564,7 +543,7 @@ func parseMachineType(machineTypeUrl string) string {
 
 func (gceCS *GCEControllerServer) executeControllerPublishVolume(ctx context.Context, req *csi.ControllerPublishVolumeRequest) (*csi.ControllerPublishVolumeResponse, error, string) {
 	diskType := ""
-	project, volKey, pdcsiContext, err := gceCS.validateControllerPublishVolumeRequest(ctx, req)
+	project, volKey, err := gceCS.validateControllerPublishVolumeRequest(ctx, req)
 	if err != nil {
 		return nil, err, diskType
 	}
@@ -599,7 +578,7 @@ func (gceCS *GCEControllerServer) executeControllerPublishVolume(ctx context.Con
 		if gce.IsGCENotFoundError(err) {
 			return nil, status.Errorf(codes.NotFound, "Could not find disk %v: %v", volKey.String(), err.Error()), diskType
 		}
-		return nil, common.LoggedError("Failed to getDisk: ", err), diskType
+		return nil, status.Errorf(codes.Internal, "Failed to getDisk: %v", err.Error()), diskType
 	}
 	instanceZone, instanceName, err := common.NodeIDToZoneAndName(nodeID)
 	if err != nil {
@@ -636,7 +615,7 @@ func (gceCS *GCEControllerServer) executeControllerPublishVolume(ctx context.Con
 	if err != nil {
 		return nil, status.Errorf(codes.InvalidArgument, "could not split nodeID: %v", err.Error()), diskType
 	}
-	err = gceCS.CloudProvider.AttachDisk(ctx, project, volKey, readWrite, attachableDiskTypePersistent, instanceZone, instanceName, pdcsiContext.ForceAttach)
+	err = gceCS.CloudProvider.AttachDisk(ctx, project, volKey, readWrite, attachableDiskTypePersistent, instanceZone, instanceName)
 	if err != nil {
 		var udErr *gce.UnsupportedDiskError
 		if errors.As(err, &udErr) {
@@ -661,7 +640,9 @@ func (gceCS *GCEControllerServer) ControllerUnpublishVolume(ctx context.Context,
 	var err error
 	diskTypeForMetric := ""
 	defer func() {
-		gceCS.Metrics.RecordOperationErrorMetrics("ControllerUnpublishVolume", err, diskTypeForMetric)
+		if err != nil {
+			gceCS.Metrics.RecordOperationErrorMetrics("ControllerUnpublishVolume", err, diskTypeForMetric)
+		}
 	}()
 	_, _, err = gceCS.validateControllerUnpublishVolumeRequest(ctx, req)
 	if err != nil {
@@ -671,12 +652,12 @@ func (gceCS *GCEControllerServer) ControllerUnpublishVolume(ctx context.Context,
 	// Only valid requests will be queued
 	backoffId := gceCS.errorBackoff.backoffId(req.NodeId, req.VolumeId)
 	if gceCS.errorBackoff.blocking(backoffId) {
-		return nil, status.Errorf(gceCS.errorBackoff.code(backoffId), "ControllerUnpublish not permitted on node %q due to backoff condition", req.NodeId)
+		return nil, status.Errorf(codes.Unavailable, "ControllerUnpublish not permitted on node %q due to backoff condition", req.NodeId)
 	}
 	resp, err, diskTypeForMetric := gceCS.executeControllerUnpublishVolume(ctx, req)
 	if err != nil {
-		klog.Infof("For node %s adding backoff due to error for volume %s: %v", req.NodeId, req.VolumeId, err)
-		gceCS.errorBackoff.next(backoffId, common.CodeForError(err))
+		klog.Infof("For node %s adding backoff due to error for volume %s", req.NodeId, req.VolumeId)
+		gceCS.errorBackoff.next(backoffId)
 	} else {
 		klog.Infof("For node %s clear backoff due to successful unpublish of volume %v", req.NodeId, req.VolumeId)
 		gceCS.errorBackoff.reset(backoffId)
@@ -770,7 +751,9 @@ func (gceCS *GCEControllerServer) ValidateVolumeCapabilities(ctx context.Context
 	var err error
 	diskTypeForMetric := ""
 	defer func() {
-		gceCS.Metrics.RecordOperationErrorMetrics("ValidateVolumeCapabilities", err, diskTypeForMetric)
+		if err != nil {
+			gceCS.Metrics.RecordOperationErrorMetrics("ValidateVolumeCapabilities", err, diskTypeForMetric)
+		}
 	}()
 	if req.GetVolumeCapabilities() == nil || len(req.GetVolumeCapabilities()) == 0 {
 		return nil, status.Error(codes.InvalidArgument, "Volume Capabilities must be provided")
@@ -805,6 +788,11 @@ func (gceCS *GCEControllerServer) ValidateVolumeCapabilities(ctx context.Context
 		return nil, common.LoggedError("Failed to getDisk: ", err)
 	}
 
+	// Check Volume Context is Empty
+	if len(req.GetVolumeContext()) != 0 {
+		return generateFailedValidationMessage("VolumeContext expected to be empty but got %v", req.GetVolumeContext()), nil
+	}
+
 	// Check volume capabilities supported by PD. These are the same for any PD
 	if err := validateVolumeCapabilities(req.GetVolumeCapabilities()); err != nil {
 		return generateFailedValidationMessage("VolumeCapabilities not valid: %v", err.Error()), nil
@@ -879,23 +867,13 @@ func (gceCS *GCEControllerServer) ListVolumes(ctx context.Context, req *csi.List
 	entries := []*csi.ListVolumesResponse_Entry{}
 	for i := 0; i+offset < len(gceCS.disks) && i < maxEntries; i++ {
 		d := gceCS.disks[i+offset]
-		diskRsrc, err := getResourceId(d.SelfLink)
-		if err != nil {
-			klog.Warningf("Bad ListVolumes disk resource %s, skipped: %v (%+v)", d.SelfLink, err, d)
-			continue
-		}
 		users := []string{}
 		for _, u := range d.Users {
-			rsrc, err := getResourceId(u)
-			if err != nil {
-				klog.Warningf("Bad ListVolumes user %s, skipped: %v", u, err)
-			} else {
-				users = append(users, rsrc)
-			}
+			users = append(users, cleanSelfLink(u))
 		}
 		entries = append(entries, &csi.ListVolumesResponse_Entry{
 			Volume: &csi.Volume{
-				VolumeId: diskRsrc,
+				VolumeId: cleanSelfLink(d.SelfLink),
 			},
 			Status: &csi.ListVolumesResponse_VolumeStatus{
 				PublishedNodeIds: users,
@@ -932,7 +910,9 @@ func (gceCS *GCEControllerServer) CreateSnapshot(ctx context.Context, req *csi.C
 	var err error
 	diskTypeForMetric := ""
 	defer func() {
-		gceCS.Metrics.RecordOperationErrorMetrics("CreateSnapshot", err, diskTypeForMetric)
+		if err != nil {
+			gceCS.Metrics.RecordOperationErrorMetrics("CreateSnapshot", err, diskTypeForMetric)
+		}
 	}()
 	// Validate arguments
 	volumeID := req.GetSourceVolumeId()
@@ -1008,10 +988,6 @@ func (gceCS *GCEControllerServer) createPDSnapshot(ctx context.Context, project
 			return nil, common.LoggedError("Failed to create snapshot: ", err)
 		}
 	}
-	snapshotId, err := getResourceId(snapshot.SelfLink)
-	if err != nil {
-		return nil, common.LoggedError(fmt.Sprintf("Cannot extract resource id from snapshot %s", snapshot.SelfLink), err)
-	}
 
 	err = gceCS.validateExistingSnapshot(snapshot, volKey)
 	if err != nil {
@@ -1030,7 +1006,7 @@ func (gceCS *GCEControllerServer) createPDSnapshot(ctx context.Context, project
 
 	return &csi.Snapshot{
 		SizeBytes:      common.GbToBytes(snapshot.DiskSizeGb),
-		SnapshotId:     snapshotId,
+		SnapshotId:     cleanSelfLink(snapshot.SelfLink),
 		SourceVolumeId: volumeID,
 		CreationTime:   timestamp,
 		ReadyToUse:     ready,
@@ -1059,10 +1035,6 @@ func (gceCS *GCEControllerServer) createImage(ctx context.Context, project strin
 			return nil, common.LoggedError("Failed to create image: ", err)
 		}
 	}
-	imageId, err := getResourceId(image.SelfLink)
-	if err != nil {
-		return nil, common.LoggedError(fmt.Sprintf("Cannot extract resource id from snapshot %s", image.SelfLink), err)
-	}
 
 	err = gceCS.validateExistingImage(image, volKey)
 	if err != nil {
@@ -1081,7 +1053,7 @@ func (gceCS *GCEControllerServer) createImage(ctx context.Context, project strin
 
 	return &csi.Snapshot{
 		SizeBytes:      common.GbToBytes(image.DiskSizeGb),
-		SnapshotId:     imageId,
+		SnapshotId:     cleanSelfLink(image.SelfLink),
 		SourceVolumeId: volumeID,
 		CreationTime:   timestamp,
 		ReadyToUse:     ready,
@@ -1093,13 +1065,9 @@ func (gceCS *GCEControllerServer) validateExistingImage(image *compute.Image, vo
 		return fmt.Errorf("disk does not exist")
 	}
 
-	sourceId, err := getResourceId(image.SourceDisk)
-	if err != nil {
-		return fmt.Errorf("failed to get source id from %s: %w", image.SourceDisk, err)
-	}
-	_, sourceKey, err := common.VolumeIDToKey(sourceId)
+	_, sourceKey, err := common.VolumeIDToKey(cleanSelfLink(image.SourceDisk))
 	if err != nil {
-		return fmt.Errorf("failed to get source disk key %s: %w", image.SourceDisk, err)
+		return fmt.Errorf("fail to get source disk key %s, %w", image.SourceDisk, err)
 	}
 
 	if sourceKey.String() != volKey.String() {
@@ -1148,11 +1116,7 @@ func (gceCS *GCEControllerServer) validateExistingSnapshot(snapshot *compute.Sna
 		return fmt.Errorf("disk does not exist")
 	}
 
-	sourceId, err := getResourceId(snapshot.SourceDisk)
-	if err != nil {
-		return fmt.Errorf("failed to get source id from %s: %w", snapshot.SourceDisk, err)
-	}
-	_, sourceKey, err := common.VolumeIDToKey(sourceId)
+	_, sourceKey, err := common.VolumeIDToKey(cleanSelfLink(snapshot.SourceDisk))
 	if err != nil {
 		return fmt.Errorf("fail to get source disk key %s, %w", snapshot.SourceDisk, err)
 	}
@@ -1183,7 +1147,9 @@ func (gceCS *GCEControllerServer) DeleteSnapshot(ctx context.Context, req *csi.D
 	var err error
 	diskTypeForMetric := ""
 	defer func() {
-		gceCS.Metrics.RecordOperationErrorMetrics("DeleteSnapshot", err, diskTypeForMetric)
+		if err != nil {
+			gceCS.Metrics.RecordOperationErrorMetrics("DeleteSnapshot", err, diskTypeForMetric)
+		}
 	}()
 	// Validate arguments
 	snapshotID := req.GetSnapshotId()
@@ -1195,7 +1161,7 @@ func (gceCS *GCEControllerServer) DeleteSnapshot(ctx context.Context, req *csi.D
 	if err != nil {
 		// Cannot get snapshot ID from the passing request
 		// This is a success according to the spec
-		klog.Warningf("Snapshot id does not have the correct format %s: %v", snapshotID, err)
+		klog.Warningf("Snapshot id does not have the correct format %s", snapshotID)
 		return &csi.DeleteSnapshotResponse{}, nil
 	}
 
@@ -1272,7 +1238,9 @@ func (gceCS *GCEControllerServer) ControllerExpandVolume(ctx context.Context, re
 	var err error
 	diskTypeForMetric := ""
 	defer func() {
-		gceCS.Metrics.RecordOperationErrorMetrics("ControllerExpandVolume", err, diskTypeForMetric)
+		if err != nil {
+			gceCS.Metrics.RecordOperationErrorMetrics("ControllerExpandVolume", err, diskTypeForMetric)
+		}
 	}()
 	volumeID := req.GetVolumeId()
 	if len(volumeID) == 0 {
@@ -1386,7 +1354,7 @@ func (gceCS *GCEControllerServer) getSnapshotByID(ctx context.Context, snapshotI
 				return &csi.ListSnapshotsResponse{}, nil
 			}
 		}
-		e, err := generateDiskImageEntry(image)
+		e, err := generateImageEntry(image)
 		if err != nil {
 			return nil, fmt.Errorf("failed to generate image entry: %w", err)
 		}
@@ -1408,15 +1376,6 @@ func generateDiskSnapshotEntry(snapshot *compute.Snapshot) (*csi.ListSnapshotsRe
 		return nil, fmt.Errorf("Failed to covert creation timestamp: %w", err)
 	}
 
-	snapshotId, err := getResourceId(snapshot.SelfLink)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get snapshot id from %s: %w", snapshot.SelfLink, err)
-	}
-	sourceId, err := getResourceId(snapshot.SourceDisk)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get source id from %s: %w", snapshot.SourceDisk, err)
-	}
-
 	// We ignore the error intentionally here since we are just listing snapshots
 	// TODO: If the snapshot is in "FAILED" state we need to think through what this
 	// should actually look like.
@@ -1425,8 +1384,8 @@ func generateDiskSnapshotEntry(snapshot *compute.Snapshot) (*csi.ListSnapshotsRe
 	entry := &csi.ListSnapshotsResponse_Entry{
 		Snapshot: &csi.Snapshot{
 			SizeBytes:      common.GbToBytes(snapshot.DiskSizeGb),
-			SnapshotId:     snapshotId,
-			SourceVolumeId: sourceId,
+			SnapshotId:     cleanSelfLink(snapshot.SelfLink),
+			SourceVolumeId: cleanSelfLink(snapshot.SourceDisk),
 			CreationTime:   tp,
 			ReadyToUse:     ready,
 		},
@@ -1442,23 +1401,35 @@ func generateDiskImageEntry(image *compute.Image) (*csi.ListSnapshotsResponse_En
 		return nil, fmt.Errorf("failed to covert creation timestamp: %w", err)
 	}
 
-	imageId, err := getResourceId(image.SelfLink)
-	if err != nil {
-		return nil, fmt.Errorf("cannot get image id from %s: %w", image.SelfLink, err)
+	ready, _ := isImageReady(image.Status)
+
+	entry := &csi.ListSnapshotsResponse_Entry{
+		Snapshot: &csi.Snapshot{
+			SizeBytes:      common.GbToBytes(image.DiskSizeGb),
+			SnapshotId:     cleanSelfLink(image.SelfLink),
+			SourceVolumeId: cleanSelfLink(image.SourceDisk),
+			CreationTime:   tp,
+			ReadyToUse:     ready,
+		},
 	}
-	sourceId, err := getResourceId(image.SourceDisk)
+	return entry, nil
+}
+
+func generateImageEntry(image *compute.Image) (*csi.ListSnapshotsResponse_Entry, error) {
+	timestamp, err := parseTimestamp(image.CreationTimestamp)
 	if err != nil {
-		return nil, fmt.Errorf("cannot get source id from %s: %w", image.SourceDisk, err)
+		return nil, fmt.Errorf("Failed to covert creation timestamp: %w", err)
 	}
 
+	// ignore the error intentionally here since we are just listing images
 	ready, _ := isImageReady(image.Status)
 
 	entry := &csi.ListSnapshotsResponse_Entry{
 		Snapshot: &csi.Snapshot{
 			SizeBytes:      common.GbToBytes(image.DiskSizeGb),
-			SnapshotId:     imageId,
-			SourceVolumeId: sourceId,
-			CreationTime:   tp,
+			SnapshotId:     cleanSelfLink(image.SelfLink),
+			SourceVolumeId: cleanSelfLink(image.SourceDisk),
+			CreationTime:   timestamp,
 			ReadyToUse:     ready,
 		},
 	}
@@ -1696,40 +1667,7 @@ func getDefaultZonesInRegion(ctx context.Context, gceCS *GCEControllerServer, ex
 	return ret, nil
 }
 
-func paramsToVolumeContext(params common.DiskParameters) map[string]string {
-	context := map[string]string{}
-	if params.ForceAttach {
-		context[contextForceAttach] = "true"
-	}
-	if len(context) > 0 {
-		return context
-	}
-	return nil
-}
-
-func extractVolumeContext(context map[string]string) (*PDCSIContext, error) {
-	info := &PDCSIContext{}
-	// Note that sidecars may inject values in the context (eg,
-	// csiProvisionerIdentity). So we don't validate that all keys are known.
-	for key, val := range context {
-		switch key {
-		case contextForceAttach:
-			b, err := common.ConvertStringToBool(val)
-			if err != nil {
-				return nil, fmt.Errorf("Bad volume context force attach: %v", err)
-			}
-			info.ForceAttach = b
-		}
-	}
-	return info, nil
-}
-
-func generateCreateVolumeResponse(disk *gce.CloudDisk, zones []string, params common.DiskParameters) (*csi.CreateVolumeResponse, error) {
-	volumeId, err := getResourceId(disk.GetSelfLink())
-	if err != nil {
-		return nil, fmt.Errorf("cannot get volume id from %s: %w", disk.GetSelfLink(), err)
-	}
-
+func generateCreateVolumeResponse(disk *gce.CloudDisk, zones []string) *csi.CreateVolumeResponse {
 	tops := []*csi.Topology{}
 	for _, zone := range zones {
 		tops = append(tops, &csi.Topology{
@@ -1740,8 +1678,8 @@ func generateCreateVolumeResponse(disk *gce.CloudDisk, zones []string, params co
 	createResp := &csi.CreateVolumeResponse{
 		Volume: &csi.Volume{
 			CapacityBytes:      realDiskSizeBytes,
-			VolumeId:           volumeId,
-			VolumeContext:      paramsToVolumeContext(params),
+			VolumeId:           cleanSelfLink(disk.GetSelfLink()),
+			VolumeContext:      nil,
 			AccessibleTopology: tops,
 		},
 	}
@@ -1779,36 +1717,12 @@ func generateCreateVolumeResponse(disk *gce.CloudDisk, zones []string, params co
 		}
 		createResp.Volume.ContentSource = contentSource
 	}
-	return createResp, nil
+	return createResp
 }
 
-func getResourceId(resourceLink string) (string, error) {
-	url, err := neturl.Parse(resourceLink)
-	if err != nil {
-		return "", fmt.Errorf("Could not parse resource %s: %w", resourceLink, err)
-	}
-	if url.Scheme != resourceApiScheme {
-		return "", fmt.Errorf("Unexpected API scheme for resource %s", resourceLink)
-	}
-
-	// Note that the resource host can basically be anything, if we are running in
-	// a distributed cloud or trusted partner environment.
-
-	// The path should be /compute/VERSION/project/....
-	elts := strings.Split(url.Path, "/")
-	if len(elts) < 4 {
-		return "", fmt.Errorf("Short resource path %s", resourceLink)
-	}
-	if elts[1] != resourceApiService {
-		return "", fmt.Errorf("Bad resource service %s in %s", elts[1], resourceLink)
-	}
-	if _, ok := validResourceApiVersions[elts[2]]; !ok {
-		return "", fmt.Errorf("Bad version %s in %s", elts[2], resourceLink)
-	}
-	if elts[3] != resourceProject {
-		return "", fmt.Errorf("Expected %v to start with %s in resource %s", elts[3:], resourceProject, resourceLink)
-	}
-	return strings.Join(elts[3:], "/"), nil
+func cleanSelfLink(selfLink string) string {
+	r, _ := regexp.Compile("https:\\/\\/www.*apis.com\\/.*(v1|beta|alpha)\\/")
+	return r.ReplaceAllString(selfLink, "")
 }
 
 func createRegionalDisk(ctx context.Context, cloudProvider gce.GCECompute, name string, zones []string, params common.DiskParameters, capacityRange *csi.CapacityRange, capBytes int64, snapshotID string, volumeContentSourceVolumeID string, multiWriter bool) (*gce.CloudDisk, error) {
@@ -1878,7 +1792,7 @@ func pickRandAndConsecutive(slice []string, n int) ([]string, error) {
 }
 
 func newCsiErrorBackoff(initialDuration, errorBackoffMaxDuration time.Duration) *csiErrorBackoff {
-	return &csiErrorBackoff{flowcontrol.NewBackOff(initialDuration, errorBackoffMaxDuration), make(map[csiErrorBackoffId]codes.Code)}
+	return &csiErrorBackoff{flowcontrol.NewBackOff(initialDuration, errorBackoffMaxDuration)}
 }
 
 func (_ *csiErrorBackoff) backoffId(nodeId, volumeId string) csiErrorBackoffId {
@@ -1890,22 +1804,10 @@ func (b *csiErrorBackoff) blocking(id csiErrorBackoffId) bool {
 	return blk
 }
 
-func (b *csiErrorBackoff) code(id csiErrorBackoffId) codes.Code {
-	if code, ok := b.errorCodes[id]; ok {
-		return code
-	}
-	// If we haven't recorded a code, return unavailable, which signals a problem with the driver
-	// (ie, next() wasn't called correctly).
-	klog.Errorf("using default code for %s", id)
-	return codes.Unavailable
-}
-
-func (b *csiErrorBackoff) next(id csiErrorBackoffId, code codes.Code) {
+func (b *csiErrorBackoff) next(id csiErrorBackoffId) {
 	b.backoff.Next(string(id), b.backoff.Clock.Now())
-	b.errorCodes[id] = code
 }
 
 func (b *csiErrorBackoff) reset(id csiErrorBackoffId) {
 	b.backoff.Reset(string(id))
-	delete(b.errorCodes, id)
 }
diff --git a/pkg/gce-pd-csi-driver/node.go b/pkg/gce-pd-csi-driver/node.go
index fb284b5a..095da7c2 100644
--- a/pkg/gce-pd-csi-driver/node.go
+++ b/pkg/gce-pd-csi-driver/node.go
@@ -20,7 +20,6 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
-	"time"
 
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
@@ -47,15 +46,6 @@ type GCENodeServer struct {
 	// A map storing all volumes with ongoing operations so that additional operations
 	// for that same volume (as defined by VolumeID) return an Aborted error
 	volumeLocks *common.VolumeLocks
-
-	// If set, this semaphore will be used to serialize formatAndMount. It will be raised
-	// when the operation starts, and lowered either when finished, or when
-	// formatAndMountTimeout has expired.
-	//
-	// This is used only on linux (where memory problems for concurrent fsck and mkfs have
-	// been observed).
-	formatAndMountSemaphore chan any
-	formatAndMountTimeout   time.Duration
 }
 
 var _ csi.NodeServer = &GCENodeServer{}
@@ -96,14 +86,6 @@ func (ns *GCENodeServer) isVolumePathMounted(path string) bool {
 	return false
 }
 
-func (ns *GCENodeServer) WithSerializedFormatAndMount(timeout time.Duration, maxConcurrent int) *GCENodeServer {
-	if maxConcurrent > 0 {
-		ns.formatAndMountSemaphore = make(chan any, maxConcurrent)
-		ns.formatAndMountTimeout = timeout
-	}
-	return ns
-}
-
 func (ns *GCENodeServer) NodePublishVolume(ctx context.Context, req *csi.NodePublishVolumeRequest) (*csi.NodePublishVolumeResponse, error) {
 	// Validate Arguments
 	targetPath := req.GetTargetPath()
@@ -336,7 +318,7 @@ func (ns *GCENodeServer) NodeStageVolume(ctx context.Context, req *csi.NodeStage
 		klog.V(4).Infof("CSI volume is read-only, mounting with extra option ro")
 	}
 
-	err = ns.formatAndMount(devicePath, stagingTargetPath, fstype, options, ns.Mounter)
+	err = formatAndMount(devicePath, stagingTargetPath, fstype, options, ns.Mounter)
 	if err != nil {
 		// If a volume is created from a content source like snapshot or cloning, the filesystem might get marked
 		// as "dirty" even if it is otherwise consistent and ext3/4 will try to restore to a consistent state by replaying
@@ -347,7 +329,7 @@ func (ns *GCENodeServer) NodeStageVolume(ctx context.Context, req *csi.NodeStage
 			klog.V(4).Infof("Failed to mount CSI volume read-only, retry mounting with extra option noload")
 
 			options = append(options, "noload")
-			err = ns.formatAndMount(devicePath, stagingTargetPath, fstype, options, ns.Mounter)
+			err = formatAndMount(devicePath, stagingTargetPath, fstype, options, ns.Mounter)
 			if err == nil {
 				klog.V(4).Infof("NodeStageVolume succeeded with \"noload\" option on %v to %s", volumeID, stagingTargetPath)
 				return &csi.NodeStageVolumeResponse{}, nil
diff --git a/pkg/gce-pd-csi-driver/utils_linux.go b/pkg/gce-pd-csi-driver/utils_linux.go
index 805fb6e8..8f1f0367 100644
--- a/pkg/gce-pd-csi-driver/utils_linux.go
+++ b/pkg/gce-pd-csi-driver/utils_linux.go
@@ -20,7 +20,6 @@ import (
 	"os"
 	"strconv"
 	"strings"
-	"time"
 
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
@@ -48,33 +47,7 @@ func getDevicePath(ns *GCENodeServer, volumeID, partition string) (string, error
 	return devicePath, nil
 }
 
-func (ns *GCENodeServer) formatAndMount(source, target, fstype string, options []string, m *mount.SafeFormatAndMount) error {
-	if ns.formatAndMountSemaphore != nil {
-		done := make(chan any)
-		defer close(done)
-
-		// Aquire the semaphore. This will block if another formatAndMount has put an item
-		// into the semaphore channel.
-		ns.formatAndMountSemaphore <- struct{}{}
-
-		go func() {
-			defer func() { <-ns.formatAndMountSemaphore }()
-
-			// Add a timeout where so the semaphore will be released even if
-			// formatAndMount is still working. This allows the node to make progress on
-			// volumes if some error causes one formatAndMount to get stuck. The
-			// motivation for this serialization is to reduce memory usage; if stuck
-			// processes cause OOMs then the containers will be killed and restarted,
-			// including the stuck threads and with any luck making progress.
-			timeout := time.NewTimer(ns.formatAndMountTimeout)
-			defer timeout.Stop()
-
-			select {
-			case <-done:
-			case <-timeout.C:
-			}
-		}()
-	}
+func formatAndMount(source, target, fstype string, options []string, m *mount.SafeFormatAndMount) error {
 	return m.FormatAndMount(source, target, fstype, options)
 }
 
diff --git a/pkg/gce-pd-csi-driver/utils_windows.go b/pkg/gce-pd-csi-driver/utils_windows.go
index b12f4f82..4661cd89 100644
--- a/pkg/gce-pd-csi-driver/utils_windows.go
+++ b/pkg/gce-pd-csi-driver/utils_windows.go
@@ -24,7 +24,7 @@ import (
 	mounter "sigs.k8s.io/gcp-compute-persistent-disk-csi-driver/pkg/mount-manager"
 )
 
-func (ns *GCENodeServer) formatAndMount(source, target, fstype string, options []string, m *mount.SafeFormatAndMount) error {
+func formatAndMount(source, target, fstype string, options []string, m *mount.SafeFormatAndMount) error {
 	if !strings.EqualFold(fstype, defaultWindowsFsType) {
 		return fmt.Errorf("GCE PD CSI driver can only supports %s file system, it does not support %s", defaultWindowsFsType, fstype)
 	}
diff --git a/pkg/metrics/metrics.go b/pkg/metrics/metrics.go
index a0aff7d8..43282ee4 100644
--- a/pkg/metrics/metrics.go
+++ b/pkg/metrics/metrics.go
@@ -21,7 +21,6 @@ import (
 	"net/http"
 	"os"
 
-	"google.golang.org/grpc/codes"
 	"k8s.io/component-base/metrics"
 	"k8s.io/klog/v2"
 	"sigs.k8s.io/gcp-compute-persistent-disk-csi-driver/pkg/common"
@@ -91,11 +90,7 @@ func (mm *MetricsManager) RecordOperationErrorMetrics(
 	operationName string,
 	operationErr error,
 	diskType string) {
-	err := codes.OK.String()
-	if operationErr != nil {
-		err = common.CodeForError(operationErr).String()
-	}
-	pdcsiOperationErrorsMetric.WithLabelValues(pdcsiDriverName, "/csi.v1.Controller/"+operationName, err, diskType).Inc()
+	pdcsiOperationErrorsMetric.WithLabelValues(pdcsiDriverName, "/csi.v1.Controller/"+operationName, common.CodeForError(operationErr).String(), diskType).Inc()
 }
 
 func (mm *MetricsManager) EmitGKEComponentVersion() error {


Test patch:
diff --git a/pkg/common/parameters_test.go b/pkg/common/parameters_test.go
index acffe5a5..2d1a4b6b 100644
--- a/pkg/common/parameters_test.go
+++ b/pkg/common/parameters_test.go
@@ -178,27 +178,6 @@ func TestExtractAndDefaultParameters(t *testing.T) {
 				Labels:               map[string]string{"key1": "value1", "label-1": "value-a", "label-2": "label-value-2"},
 			},
 		},
-		{
-			name:       "availability class parameters",
-			parameters: map[string]string{ParameterAvailabilityClass: ParameterRegionalHardFailoverClass},
-			expectParams: DiskParameters{
-				DiskType:        "pd-standard",
-				ReplicationType: "none",
-				ForceAttach:     true,
-				Tags:            map[string]string{},
-				Labels:          map[string]string{},
-			},
-		},
-		{
-			name:       "no force attach parameters",
-			parameters: map[string]string{ParameterAvailabilityClass: ParameterNoAvailabilityClass},
-			expectParams: DiskParameters{
-				DiskType:        "pd-standard",
-				ReplicationType: "none",
-				Tags:            map[string]string{},
-				Labels:          map[string]string{},
-			},
-		},
 	}
 
 	for _, tc := range tests {
diff --git a/pkg/common/utils_test.go b/pkg/common/utils_test.go
index 812fb25e..edf49e28 100644
--- a/pkg/common/utils_test.go
+++ b/pkg/common/utils_test.go
@@ -597,12 +597,6 @@ func TestConvertStringToInt64(t *testing.T) {
 			expInt64:    10000,
 			expectError: false,
 		},
-		{
-			desc:        "test higher number",
-			inputStr:    "15000",
-			expInt64:    15000,
-			expectError: false,
-		},
 		{
 			desc:        "round M to number",
 			inputStr:    "1M",
@@ -812,114 +806,6 @@ func TestConvertMiStringToInt64(t *testing.T) {
 	}
 }
 
-func TestConvertStringToBool(t *testing.T) {
-	tests := []struct {
-		desc        string
-		inputStr    string
-		expected    bool
-		expectError bool
-	}{
-		{
-			desc:        "valid true",
-			inputStr:    "true",
-			expected:    true,
-			expectError: false,
-		},
-		{
-			desc:        "valid mixed case true",
-			inputStr:    "True",
-			expected:    true,
-			expectError: false,
-		},
-		{
-			desc:        "valid false",
-			inputStr:    "false",
-			expected:    false,
-			expectError: false,
-		},
-		{
-			desc:        "valid mixed case false",
-			inputStr:    "False",
-			expected:    false,
-			expectError: false,
-		},
-		{
-			desc:        "invalid",
-			inputStr:    "yes",
-			expected:    false,
-			expectError: true,
-		},
-	}
-	for _, tc := range tests {
-		t.Run(tc.desc, func(t *testing.T) {
-			got, err := ConvertStringToBool(tc.inputStr)
-			if err != nil && !tc.expectError {
-				t.Errorf("Got error %v converting string to bool %s; expect no error", err, tc.inputStr)
-			}
-			if err == nil && tc.expectError {
-				t.Errorf("Got no error converting string to bool %s; expect an error", tc.inputStr)
-			}
-			if err == nil && got != tc.expected {
-				t.Errorf("Got %v for converting string to bool; expect %v", got, tc.expected)
-			}
-		})
-	}
-}
-
-func TestConvertStringToAvailabilityClass(t *testing.T) {
-	tests := []struct {
-		desc        string
-		inputStr    string
-		expected    string
-		expectError bool
-	}{
-		{
-			desc:        "valid none",
-			inputStr:    "none",
-			expected:    ParameterNoAvailabilityClass,
-			expectError: false,
-		},
-		{
-			desc:        "valid mixed case none",
-			inputStr:    "None",
-			expected:    ParameterNoAvailabilityClass,
-			expectError: false,
-		},
-		{
-			desc:        "valid failover",
-			inputStr:    "regional-hard-failover",
-			expected:    ParameterRegionalHardFailoverClass,
-			expectError: false,
-		},
-		{
-			desc:        "valid mixed case failover",
-			inputStr:    "Regional-Hard-Failover",
-			expected:    ParameterRegionalHardFailoverClass,
-			expectError: false,
-		},
-		{
-			desc:        "invalid",
-			inputStr:    "yes",
-			expected:    "",
-			expectError: true,
-		},
-	}
-	for _, tc := range tests {
-		t.Run(tc.desc, func(t *testing.T) {
-			got, err := ConvertStringToAvailabilityClass(tc.inputStr)
-			if err != nil && !tc.expectError {
-				t.Errorf("Got error %v converting string to availablity class %s; expect no error", err, tc.inputStr)
-			}
-			if err == nil && tc.expectError {
-				t.Errorf("Got no error converting string to availablity class %s; expect an error", tc.inputStr)
-			}
-			if err == nil && got != tc.expected {
-				t.Errorf("Got %v for converting string to availablity class; expect %v", got, tc.expected)
-			}
-		})
-	}
-}
-
 func TestParseMachineType(t *testing.T) {
 	tests := []struct {
 		desc                string
@@ -975,51 +861,57 @@ func TestParseMachineType(t *testing.T) {
 }
 
 func TestCodeForError(t *testing.T) {
+	internalErrorCode := codes.Internal
+	userErrorCode := codes.InvalidArgument
 	testCases := []struct {
 		name     string
 		inputErr error
-		expCode  codes.Code
+		expCode  *codes.Code
 	}{
 		{
 			name:     "Not googleapi.Error",
 			inputErr: errors.New("I am not a googleapi.Error"),
-			expCode:  codes.Internal,
+			expCode:  &internalErrorCode,
 		},
 		{
 			name:     "User error",
 			inputErr: &googleapi.Error{Code: http.StatusBadRequest, Message: "User error with bad request"},
-			expCode:  codes.InvalidArgument,
+			expCode:  &userErrorCode,
 		},
 		{
 			name:     "googleapi.Error but not a user error",
 			inputErr: &googleapi.Error{Code: http.StatusInternalServerError, Message: "Internal error"},
-			expCode:  codes.Internal,
+			expCode:  &internalErrorCode,
 		},
 		{
 			name:     "context canceled error",
 			inputErr: context.Canceled,
-			expCode:  codes.Canceled,
+			expCode:  errCodePtr(codes.Canceled),
 		},
 		{
 			name:     "context deadline exceeded error",
 			inputErr: context.DeadlineExceeded,
-			expCode:  codes.DeadlineExceeded,
+			expCode:  errCodePtr(codes.DeadlineExceeded),
 		},
 		{
 			name:     "status error with Aborted error code",
 			inputErr: status.Error(codes.Aborted, "aborted error"),
-			expCode:  codes.Aborted,
+			expCode:  errCodePtr(codes.Aborted),
 		},
 		{
 			name:     "nil error",
 			inputErr: nil,
-			expCode:  codes.Internal,
+			expCode:  nil,
 		},
 	}
 
 	for _, tc := range testCases {
+		t.Logf("Running test: %v", tc.name)
 		errCode := CodeForError(tc.inputErr)
-		if errCode != tc.expCode {
+		if (tc.expCode == nil) != (errCode == nil) {
+			t.Errorf("test %v failed: got %v, expected %v", tc.name, errCode, tc.expCode)
+		}
+		if tc.expCode != nil && *errCode != *tc.expCode {
 			t.Errorf("test %v failed: got %v, expected %v", tc.name, errCode, tc.expCode)
 		}
 	}
@@ -1029,48 +921,46 @@ func TestIsContextError(t *testing.T) {
 	cases := []struct {
 		name            string
 		err             error
-		expectedErrCode codes.Code
-		expectError     bool
+		expectedErrCode *codes.Code
 	}{
 		{
 			name:            "deadline exceeded error",
 			err:             context.DeadlineExceeded,
-			expectedErrCode: codes.DeadlineExceeded,
+			expectedErrCode: errCodePtr(codes.DeadlineExceeded),
 		},
 		{
 			name:            "contains 'context deadline exceeded'",
 			err:             fmt.Errorf("got error: %w", context.DeadlineExceeded),
-			expectedErrCode: codes.DeadlineExceeded,
+			expectedErrCode: errCodePtr(codes.DeadlineExceeded),
 		},
 		{
 			name:            "context canceled error",
 			err:             context.Canceled,
-			expectedErrCode: codes.Canceled,
+			expectedErrCode: errCodePtr(codes.Canceled),
 		},
 		{
 			name:            "contains 'context canceled'",
 			err:             fmt.Errorf("got error: %w", context.Canceled),
-			expectedErrCode: codes.Canceled,
+			expectedErrCode: errCodePtr(codes.Canceled),
 		},
 		{
-			name:        "does not contain 'context canceled' or 'context deadline exceeded'",
-			err:         fmt.Errorf("unknown error"),
-			expectError: true,
+			name:            "does not contain 'context canceled' or 'context deadline exceeded'",
+			err:             fmt.Errorf("unknown error"),
+			expectedErrCode: nil,
 		},
 		{
-			name:        "nil error",
-			err:         nil,
-			expectError: true,
+			name:            "nil error",
+			err:             nil,
+			expectedErrCode: nil,
 		},
 	}
 
 	for _, test := range cases {
-		errCode, err := isContextError(test.err)
-		if test.expectError {
-			if err == nil {
-				t.Errorf("test %v failed, expected error, got %v", test.name, errCode)
-			}
-		} else if errCode != test.expectedErrCode {
+		errCode := isContextError(test.err)
+		if (test.expectedErrCode == nil) != (errCode == nil) {
+			t.Errorf("test %v failed: got %v, expected %v", test.name, errCode, test.expectedErrCode)
+		}
+		if test.expectedErrCode != nil && *errCode != *test.expectedErrCode {
 			t.Errorf("test %v failed: got %v, expected %v", test.name, errCode, test.expectedErrCode)
 		}
 	}
diff --git a/pkg/gce-cloud-provider/compute/gce-compute_test.go b/pkg/gce-cloud-provider/compute/gce-compute_test.go
index 652b111a..1a9c9f6e 100644
--- a/pkg/gce-cloud-provider/compute/gce-compute_test.go
+++ b/pkg/gce-cloud-provider/compute/gce-compute_test.go
@@ -18,7 +18,6 @@ import (
 	"testing"
 
 	computev1 "google.golang.org/api/compute/v1"
-	"google.golang.org/grpc/codes"
 	"sigs.k8s.io/gcp-compute-persistent-disk-csi-driver/pkg/common"
 )
 
@@ -102,75 +101,3 @@ func TestValidateDiskParameters(t *testing.T) {
 		}
 	}
 }
-
-func TestCodeForGCEOpError(t *testing.T) {
-	testCases := []struct {
-		name     string
-		inputErr computev1.OperationErrorErrors
-		expCode  codes.Code
-	}{
-		{
-			name:     "RESOURCE_NOT_FOUND error",
-			inputErr: computev1.OperationErrorErrors{Code: "RESOURCE_NOT_FOUND"},
-			expCode:  codes.NotFound,
-		},
-		{
-			name:     "RESOURCE_ALREADY_EXISTS error",
-			inputErr: computev1.OperationErrorErrors{Code: "RESOURCE_ALREADY_EXISTS"},
-			expCode:  codes.AlreadyExists,
-		},
-		{
-			name:     "OPERATION_CANCELED_BY_USER error",
-			inputErr: computev1.OperationErrorErrors{Code: "OPERATION_CANCELED_BY_USER"},
-			expCode:  codes.Aborted,
-		},
-		{
-			name:     "QUOTA_EXCEEDED error",
-			inputErr: computev1.OperationErrorErrors{Code: "QUOTA_EXCEEDED"},
-			expCode:  codes.ResourceExhausted,
-		},
-		{
-			name:     "ZONE_RESOURCE_POOL_EXHAUSTED error",
-			inputErr: computev1.OperationErrorErrors{Code: "ZONE_RESOURCE_POOL_EXHAUSTED"},
-			expCode:  codes.Unavailable,
-		},
-		{
-			name:     "ZONE_RESOURCE_POOL_EXHAUSTED_WITH_DETAILS error",
-			inputErr: computev1.OperationErrorErrors{Code: "ZONE_RESOURCE_POOL_EXHAUSTED_WITH_DETAILS"},
-			expCode:  codes.Unavailable,
-		},
-		{
-			name:     "REGION_QUOTA_EXCEEDED error",
-			inputErr: computev1.OperationErrorErrors{Code: "REGION_QUOTA_EXCEEDED"},
-			expCode:  codes.ResourceExhausted,
-		},
-		{
-			name:     "RATE_LIMIT_EXCEEDED error",
-			inputErr: computev1.OperationErrorErrors{Code: "RATE_LIMIT_EXCEEDED"},
-			expCode:  codes.ResourceExhausted,
-		},
-		{
-			name:     "INVALID_USAGE error",
-			inputErr: computev1.OperationErrorErrors{Code: "INVALID_USAGE"},
-			expCode:  codes.InvalidArgument,
-		},
-		{
-			name:     "RESOURCE_IN_USE_BY_ANOTHER_RESOURCE error",
-			inputErr: computev1.OperationErrorErrors{Code: "RESOURCE_IN_USE_BY_ANOTHER_RESOURCE"},
-			expCode:  codes.InvalidArgument,
-		},
-		{
-			name:     "UNSUPPORTED_OPERATION error",
-			inputErr: computev1.OperationErrorErrors{Code: "UNSUPPORTED_OPERATION"},
-			expCode:  codes.Internal,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Logf("Running test: %v", tc.name)
-		errCode := codeForGCEOpError(tc.inputErr)
-		if errCode != tc.expCode {
-			t.Errorf("test %v failed: got %v, expected %v", tc.name, errCode, tc.expCode)
-		}
-	}
-}
diff --git a/pkg/gce-pd-csi-driver/controller_test.go b/pkg/gce-pd-csi-driver/controller_test.go
index 8997056a..d49809c7 100644
--- a/pkg/gce-pd-csi-driver/controller_test.go
+++ b/pkg/gce-pd-csi-driver/controller_test.go
@@ -257,6 +257,7 @@ func TestDeleteSnapshot(t *testing.T) {
 		_, err := gceDriver.cs.DeleteSnapshot(context.Background(), tc.req)
 		if err != nil {
 			serverError, ok := status.FromError(err)
+			t.Logf("get server error %v", serverError)
 			if !ok {
 				t.Fatalf("Could not get error status code from err: %v", serverError)
 			}
@@ -929,11 +930,7 @@ func TestListVolumePagination(t *testing.T) {
 			var d []*gce.CloudDisk
 			for i := 0; i < tc.diskCount; i++ {
 				// Create diskCount dummy disks
-				name := fmt.Sprintf("disk-%v", i)
-				d = append(d, gce.CloudDiskFromV1(&compute.Disk{
-					Name:     name,
-					SelfLink: fmt.Sprintf("https://www.googleapis.com/compute/v1/projects/project/zones/zone/disk/%s", name),
-				}))
+				d = append(d, gce.CloudDiskFromV1(&compute.Disk{Name: fmt.Sprintf("%v", i)}))
 			}
 			gceDriver := initGCEDriver(t, d)
 			tok := ""
@@ -991,11 +988,7 @@ func TestListVolumeArgs(t *testing.T) {
 			var d []*gce.CloudDisk
 			for i := 0; i < diskCount; i++ {
 				// Create 600 dummy disks
-				name := fmt.Sprintf("disk-%v", i)
-				d = append(d, gce.CloudDiskFromV1(&compute.Disk{
-					Name:     name,
-					SelfLink: fmt.Sprintf("https://www.googleapis.com/compute/v1/projects/project/zones/zone/disk/%s", name),
-				}))
+				d = append(d, gce.CloudDiskFromV1(&compute.Disk{Name: fmt.Sprintf("%v", i)}))
 			}
 			gceDriver := initGCEDriver(t, d)
 			lvr := &csi.ListVolumesRequest{
@@ -1894,8 +1887,7 @@ func TestCreateVolumeRandomRequisiteTopology(t *testing.T) {
 
 func createZonalCloudDisk(name string) *gce.CloudDisk {
 	return gce.CloudDiskFromV1(&compute.Disk{
-		Name:     name,
-		SelfLink: fmt.Sprintf("https://www.googleapis.com/compute/v1/projects/project/zones/zone/name/%s", name),
+		Name: name,
 	})
 }
 
@@ -2978,7 +2970,7 @@ type backoffDriverConfig struct {
 
 func newFakeCSIErrorBackoff(tc *clock.FakeClock) *csiErrorBackoff {
 	backoff := flowcontrol.NewFakeBackOff(errorBackoffInitialDuration, errorBackoffMaxDuration, tc)
-	return &csiErrorBackoff{backoff, make(map[csiErrorBackoffId]codes.Code)}
+	return &csiErrorBackoff{backoff}
 }
 
 func TestControllerUnpublishBackoff(t *testing.T) {
@@ -3018,7 +3010,7 @@ func TestControllerUnpublishBackoff(t *testing.T) {
 			}
 
 			// Mock an active backoff condition on the node.
-			driver.cs.errorBackoff.next(backoffId, codes.Unavailable)
+			driver.cs.errorBackoff.next(backoffId)
 
 			tc.config.clock.Step(step)
 			// A requst for a a different volume should succeed. This volume is not
@@ -3036,9 +3028,7 @@ func TestControllerUnpublishBackoff(t *testing.T) {
 				VolumeId: testVolumeID,
 				NodeId:   testNodeID,
 			}
-			// For the first 199 ms, the backoff condition is true. All controller publish
-			// request will be denied with the same unavailable error code as was set on
-			// the original error.
+			// For the first 199 ms, the backoff condition is true. All controller publish request will be denied with 'Unavailable' error code.
 			for i := 0; i < 199; i++ {
 				var err error
 				_, err = driver.cs.ControllerUnpublishVolume(context.Background(), unpubreq)
@@ -3062,23 +3052,18 @@ func TestControllerUnpublishBackoff(t *testing.T) {
 				return
 			}
 
-			// Mock an error. This will produce an Internal error, which is different from
-			// the default error and what's used in the failure above, so that the correct
-			// error code can be confirmed.
+			// Mock an error
 			if err := runUnpublishRequest(unpubreq, true); err == nil {
 				t.Errorf("expected error")
 			}
 
-			// The above failure should cause driver to call backoff.next() again and a
-			// backoff duration of 400 ms duration is set starting at the 200th
-			// millisecond.  For the 200-599 ms, the backoff condition is true, with an
-			// internal error this time, and new controller publish requests will be
-			// denied.
+			// The above failure should cause driver to call Backoff.Next() again and a backoff duration of 400 ms duration is set starting at the 200th millisecond.
+			// For the 200-599 ms, the backoff condition is true, and new controller publish requests will be deined.
 			for i := 0; i < 399; i++ {
 				tc.config.clock.Step(step)
 				var err error
 				_, err = driver.cs.ControllerUnpublishVolume(context.Background(), unpubreq)
-				if !isInternalError(err) {
+				if !isUnavailableError(err) {
 					t.Errorf("unexpected error %v", err)
 				}
 			}
@@ -3132,11 +3117,9 @@ func TestControllerUnpublishSucceedsIfNotFound(t *testing.T) {
 
 func TestControllerPublishBackoff(t *testing.T) {
 	for desc, tc := range map[string]struct {
-		config      *backoffDriverConfig
-		forceAttach bool
+		config *backoffDriverConfig
 	}{
-		"success":      {},
-		"force attach": {forceAttach: true},
+		"success": {},
 		"missing instance": {
 			config: &backoffDriverConfig{
 				mockMissingInstance: true,
@@ -3154,8 +3137,8 @@ func TestControllerPublishBackoff(t *testing.T) {
 			backoffId := driver.cs.errorBackoff.backoffId(testNodeID, testVolumeID)
 			step := 1 * time.Millisecond
 
-			// Mock an active bakcoff condition on the node.
-			driver.cs.errorBackoff.next(backoffId, codes.Unavailable)
+			// Mock an active backoff condition on the node.
+			driver.cs.errorBackoff.next(backoffId)
 
 			// A detach request for a different disk should succeed. As this disk is not
 			// on the instance, the detach will succeed without calling the gce detach
@@ -3165,12 +3148,6 @@ func TestControllerPublishBackoff(t *testing.T) {
 				t.Errorf("expected no error on different unpublish, got %v", err)
 			}
 
-			var volumeContext map[string]string
-			if tc.forceAttach {
-				volumeContext = map[string]string{
-					contextForceAttach: "true",
-				}
-			}
 			pubreq := &csi.ControllerPublishVolumeRequest{
 				VolumeId: testVolumeID,
 				NodeId:   testNodeID,
@@ -3182,7 +3159,6 @@ func TestControllerPublishBackoff(t *testing.T) {
 						Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
 					},
 				},
-				VolumeContext: volumeContext,
 			}
 			// For the first 199 ms, the backoff condition is true. All controller publish request will be denied with 'Unavailable' error code.
 			for i := 0; i < 199; i++ {
@@ -3228,16 +3204,13 @@ func TestControllerPublishBackoff(t *testing.T) {
 				t.Errorf("expected error")
 			}
 
-			// The above failure should cause driver to call backoff.next() again and a
-			// backoff duration of 400 ms duration is set starting at the 200th
-			// millisecond.  For the 200-599 ms, the backoff condition is true, with an
-			// internal error this time, and new controller publish requests will be
-			// denied.
+			// The above failure should cause driver to call Backoff.Next() again and a backoff duration of 400 ms duration is set starting at the 200th millisecond.
+			// For the 200-599 ms, the backoff condition is true, and new controller publish requests will be deined.
 			for i := 0; i < 399; i++ {
 				tc.config.clock.Step(step)
 				var err error
 				_, err = driver.cs.ControllerPublishVolume(context.Background(), pubreq)
-				if !isInternalError(err) {
+				if !isUnavailableError(err) {
 					t.Errorf("unexpected error %v", err)
 				}
 			}
@@ -3249,18 +3222,6 @@ func TestControllerPublishBackoff(t *testing.T) {
 				t.Errorf("unexpected error")
 			}
 
-			if tc.forceAttach {
-				instance, err := driver.cs.CloudProvider.GetInstanceOrError(context.Background(), zone, node)
-				if err != nil {
-					t.Fatalf("%s instance not found: %v", node, err)
-				}
-				for _, disk := range instance.Disks {
-					if !disk.ForceAttach {
-						t.Errorf("Expected %s to be force attached", disk.DeviceName)
-					}
-				}
-			}
-
 			// Driver is expected to remove the node key from the backoff map.
 			t1 := driver.cs.errorBackoff.backoff.Get(string(backoffId))
 			if t1 != 0 {
@@ -3270,12 +3231,11 @@ func TestControllerPublishBackoff(t *testing.T) {
 	}
 }
 
-func TestGetResource(t *testing.T) {
+func TestCleanSelfLink(t *testing.T) {
 	testCases := []struct {
-		name  string
-		in    string
-		want  string
-		error bool
+		name string
+		in   string
+		want string
 	}{
 		{
 			name: "v1 full standard w/ endpoint prefix",
@@ -3293,38 +3253,24 @@ func TestGetResource(t *testing.T) {
 			want: "projects/project/zones/zone/disks/disk",
 		},
 		{
-			name:  "no prefix",
-			in:    "projects/project/zones/zone/disks/disk",
-			error: true,
+			name: "no prefix",
+			in:   "projects/project/zones/zone/disks/disk",
+			want: "projects/project/zones/zone/disks/disk",
 		},
+
 		{
-			name:  "no prefix + project omitted",
-			in:    "zones/zone/disks/disk",
-			error: true,
+			name: "no prefix + project omitted",
+			in:   "zones/zone/disks/disk",
+			want: "zones/zone/disks/disk",
 		},
 		{
-			name: "Compute prefix, www google api",
+			name: "Compute prefix, google api",
 			in:   "https://www.compute.googleapis.com/compute/v1/projects/project/zones/zone/disks/disk",
 			want: "projects/project/zones/zone/disks/disk",
 		},
 		{
 			name: "Compute prefix, partner api",
-			in:   "https://www.compute.partnerapis.com/compute/v1/projects/project/zones/zone/disks/disk",
-			want: "projects/project/zones/zone/disks/disk",
-		},
-		{
-			name: "Compute, alternate googleapis host",
-			in:   "https://content-compute.googleapis.com/compute/v1/projects/project/zones/zone/disks/disk",
-			want: "projects/project/zones/zone/disks/disk",
-		},
-		{
-			name: "Compute, partner host",
-			in:   "https://compute.blahapis.com/compute/v1/projects/project/zones/zone/disks/disk",
-			want: "projects/project/zones/zone/disks/disk",
-		},
-		{
-			name: "Alternate partner host with mtls domain",
-			in:   "https://content-compute.us-central1.rep.mtls.googleapis.com/compute/v1/projects/project/zones/zone/disks/disk",
+			in:   "https://www.compute.PARTNERapis.com/compute/v1/projects/project/zones/zone/disks/disk",
 			want: "projects/project/zones/zone/disks/disk",
 		},
 		{
@@ -3337,66 +3283,13 @@ func TestGetResource(t *testing.T) {
 			in:   "https://www.partnerapis.com/compute/alpha/projects/project/zones/zone/disks/disk",
 			want: "projects/project/zones/zone/disks/disk",
 		},
-		{
-			name: "alpha project",
-			in:   "https://www.googleapis.com/compute/alpha/projects/alphaproject/zones/zone/disks/disk",
-			want: "projects/alphaproject/zones/zone/disks/disk",
-		},
-		{
-			name: "beta project",
-			in:   "https://www.googleapis.com/compute/alpha/projects/betabeta/zones/zone/disks/disk",
-			want: "projects/betabeta/zones/zone/disks/disk",
-		},
-		{
-			name: "v1 project",
-			in:   "https://www.googleapis.com/compute/alpha/projects/projectv1/zones/zone/disks/disk",
-			want: "projects/projectv1/zones/zone/disks/disk",
-		},
-		{
-			name: "random host",
-			in:   "https://npr.org/compute/v1/projects/project/zones/zone/disks/disk",
-			want: "projects/project/zones/zone/disks/disk",
-		},
-		{
-			name:  "no prefix",
-			in:    "projects/project/zones/zone/disks/disk",
-			error: true,
-		},
-		{
-			name:  "bad scheme",
-			in:    "ftp://www.googleapis.com/compute/v1/projects/project/zones/zone/disks/disk",
-			error: true,
-		},
-		{
-			name:  "insecure scheme",
-			in:    "http://www.googleapis.com/compute/v1/projects/project/zones/zone/disks/disk",
-			error: true,
-		},
-		{
-			name:  "bad service",
-			in:    "https://www.googleapis.com/computers/v1/projects/project/zones/zone/disks/disk",
-			error: true,
-		},
-		{
-			name:  "bad version",
-			in:    "https://www..googleapis.com/compute/zeta/projects/project/zones/zone/disks/disk",
-			error: true,
-		},
 	}
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			got, err := getResourceId(tc.in)
-			if tc.error {
-				if err == nil {
-					t.Errorf("Expected error, but got none")
-				}
-			} else {
-				if err != nil {
-					t.Errorf("Unexpected error %v", err)
-				} else if got != tc.want {
-					t.Errorf("Expected cleaned self link: %v, got: %v", tc.want, got)
-				}
+			got := cleanSelfLink(tc.in)
+			if got != tc.want {
+				t.Errorf("Expected cleaned self link: %v, got: %v", tc.want, got)
 			}
 		})
 	}
@@ -3449,16 +3342,3 @@ func isUnavailableError(err error) bool {
 
 	return st.Code().String() == "Unavailable"
 }
-
-func isInternalError(err error) bool {
-	if err == nil {
-		return false
-	}
-
-	st, ok := status.FromError(err)
-	if !ok {
-		return false
-	}
-
-	return st.Code().String() == "Internal"
-}
diff --git a/pkg/gce-pd-csi-driver/node_test.go b/pkg/gce-pd-csi-driver/node_test.go
index 10d470c1..91a65f7b 100644
--- a/pkg/gce-pd-csi-driver/node_test.go
+++ b/pkg/gce-pd-csi-driver/node_test.go
@@ -23,7 +23,6 @@ import (
 	"path/filepath"
 	"strings"
 	"testing"
-	"time"
 
 	"k8s.io/utils/exec"
 	testingexec "k8s.io/utils/exec/testing"
@@ -59,7 +58,7 @@ func getCustomTestGCEDriver(t *testing.T, mounter *mount.SafeFormatAndMount, dev
 	return gceDriver
 }
 
-func getTestBlockingMountGCEDriver(t *testing.T, readyToExecute chan chan struct{}) *GCEDriver {
+func getTestBlockingGCEDriver(t *testing.T, readyToExecute chan chan struct{}) *GCEDriver {
 	gceDriver := GetGCEDriver()
 	mounter := mountmanager.NewFakeSafeBlockingMounter(readyToExecute)
 	nodeServer := NewNodeServer(gceDriver, mounter, deviceutils.NewFakeDeviceUtils(false), metadataservice.NewFakeService(), mountmanager.NewFakeStatter(mounter))
@@ -70,18 +69,6 @@ func getTestBlockingMountGCEDriver(t *testing.T, readyToExecute chan chan struct
 	return gceDriver
 }
 
-func getTestBlockingFormatAndMountGCEDriver(t *testing.T, readyToExecute chan chan struct{}) *GCEDriver {
-	gceDriver := GetGCEDriver()
-	mounter := mountmanager.NewFakeSafeBlockingMounter(readyToExecute)
-	nodeServer := NewNodeServer(gceDriver, mounter, deviceutils.NewFakeDeviceUtils(false), metadataservice.NewFakeService(), mountmanager.NewFakeStatter(mounter)).WithSerializedFormatAndMount(5*time.Second, 1)
-
-	err := gceDriver.SetupGCEDriver(driver, "test-vendor", nil, nil, nil, nodeServer)
-	if err != nil {
-		t.Fatalf("Failed to setup GCE Driver: %v", err)
-	}
-	return gceDriver
-}
-
 func makeFakeCmd(fakeCmd *testingexec.FakeCmd, cmd string, args ...string) testingexec.FakeCommandAction {
 	c := cmd
 	a := args
@@ -862,7 +849,9 @@ func TestNodeGetCapabilities(t *testing.T) {
 	}
 }
 
-func runBlockingFormatAndMount(t *testing.T, gceDriver *GCEDriver, readyToExecute chan chan struct{}) {
+func TestConcurrentNodeOperations(t *testing.T) {
+	readyToExecute := make(chan chan struct{}, 1)
+	gceDriver := getTestBlockingGCEDriver(t, readyToExecute)
 	ns := gceDriver.ns
 	tempDir, err := ioutil.TempDir("", "cno")
 	if err != nil {
@@ -942,15 +931,3 @@ func runBlockingFormatAndMount(t *testing.T, gceDriver *GCEDriver, readyToExecut
 		t.Errorf("Unexpected error: %v", err)
 	}
 }
-
-func TestBlockingMount(t *testing.T) {
-	readyToExecute := make(chan chan struct{}, 1)
-	gceDriver := getTestBlockingMountGCEDriver(t, readyToExecute)
-	runBlockingFormatAndMount(t, gceDriver, readyToExecute)
-}
-
-func TestBlockingFormatAndMount(t *testing.T) {
-	readyToExecute := make(chan chan struct{}, 1)
-	gceDriver := getTestBlockingFormatAndMountGCEDriver(t, readyToExecute)
-	runBlockingFormatAndMount(t, gceDriver, readyToExecute)
-}
diff --git a/test/e2e/tests/multi_zone_e2e_test.go b/test/e2e/tests/multi_zone_e2e_test.go
index bb54356c..5149c4d8 100644
--- a/test/e2e/tests/multi_zone_e2e_test.go
+++ b/test/e2e/tests/multi_zone_e2e_test.go
@@ -31,14 +31,6 @@ import (
 	remote "sigs.k8s.io/gcp-compute-persistent-disk-csi-driver/test/remote"
 )
 
-type verifyArgs struct {
-	publishDir, stageDir string
-}
-
-type verifyFunc func(*verifyArgs) error
-
-type detacherFunc func()
-
 var _ = Describe("GCE PD CSI Driver Multi-Zone", func() {
 	BeforeEach(func() {
 		Expect(len(testContexts)).To(BeNumerically(">", 1))
@@ -85,7 +77,7 @@ var _ = Describe("GCE PD CSI Driver Multi-Zone", func() {
 			}
 		}
 
-		Expect(len(zoneToContext)).To(Equal(2), "Must have instances in 2 zones")
+		Expect(len(zoneToContext)).To(Equal(2), "Must have instances in exactly 2 zones")
 
 		controllerContext := zoneToContext[zones[0]]
 		controllerClient := controllerContext.Client
@@ -98,7 +90,7 @@ var _ = Describe("GCE PD CSI Driver Multi-Zone", func() {
 
 		// Create Disk
 		volName := testNamePrefix + string(uuid.NewUUID())
-		volume, err := controllerClient.CreateVolume(volName, map[string]string{
+		volID, err := controllerClient.CreateVolume(volName, map[string]string{
 			common.ParameterKeyReplicationType: "regional-pd",
 		}, defaultRepdSizeGb, &csi.TopologyRequirement{
 			Requisite: []*csi.Topology{
@@ -129,7 +121,7 @@ var _ = Describe("GCE PD CSI Driver Multi-Zone", func() {
 
 		defer func() {
 			// Delete Disk
-			controllerClient.DeleteVolume(volume.VolumeId)
+			controllerClient.DeleteVolume(volID)
 			Expect(err).To(BeNil(), "DeleteVolume failed")
 
 			// Validate Disk Deleted
@@ -144,121 +136,22 @@ var _ = Describe("GCE PD CSI Driver Multi-Zone", func() {
 			if i >= 1 {
 				readOnly = true
 			}
-			err = testAttachWriteReadDetach(volume.VolumeId, volName, testContext.Instance, testContext.Client, readOnly)
+			err = testAttachWriteReadDetach(volID, volName, testContext.Instance, testContext.Client, readOnly)
 			Expect(err).To(BeNil(), "failed volume lifecycle checks")
 			i = i + 1
 		}
 	})
+})
 
-	It("Should create a RePD instance, write to it, force-attach it to another instance, and read the same data", func() {
-		Expect(testContexts).NotTo(BeEmpty())
-
-		zoneToContext := map[string]*remote.TestContext{}
-		zones := []string{}
-
-		for _, tc := range testContexts {
-			_, z, _ := tc.Instance.GetIdentity()
-			// Zone hasn't been seen before
-			if _, ok := zoneToContext[z]; !ok {
-				zoneToContext[z] = tc
-				zones = append(zones, z)
-			}
-			if len(zoneToContext) == 2 {
-				break
-			}
-		}
-
-		Expect(len(zoneToContext)).To(Equal(2), "Must have instances in 2 zones")
-
-		controllerContext := zoneToContext[zones[0]]
-		controllerClient := controllerContext.Client
-		controllerInstance := controllerContext.Instance
-
-		p, _, _ := controllerInstance.GetIdentity()
-
-		region, err := common.GetRegionFromZones(zones)
-		Expect(err).To(BeNil(), "Failed to get region from zones")
-
-		// Create Disk
-		volName := testNamePrefix + string(uuid.NewUUID())
-		volume, err := controllerClient.CreateVolume(volName, map[string]string{
-			common.ParameterKeyReplicationType: "regional-pd",
-			common.ParameterAvailabilityClass:  common.ParameterRegionalHardFailoverClass,
-		}, defaultRepdSizeGb, &csi.TopologyRequirement{
-			Requisite: []*csi.Topology{
-				{
-					Segments: map[string]string{common.TopologyKeyZone: zones[0]},
-				},
-				{
-					Segments: map[string]string{common.TopologyKeyZone: zones[1]},
-				},
-			},
-		}, nil)
-		Expect(err).To(BeNil(), "CreateVolume failed with error: %v", err)
-
-		// Validate Disk Created
-		cloudDisk, err := computeService.RegionDisks.Get(p, region, volName).Do()
-		Expect(err).To(BeNil(), "Could not get disk from cloud directly")
-		Expect(cloudDisk.Type).To(ContainSubstring(standardDiskType))
-		Expect(cloudDisk.Status).To(Equal(readyState))
-		Expect(cloudDisk.SizeGb).To(Equal(defaultRepdSizeGb))
-		Expect(cloudDisk.Name).To(Equal(volName))
-		Expect(len(cloudDisk.ReplicaZones)).To(Equal(2))
-		zonesSet := sets.NewString(zones...)
-		for _, replicaZone := range cloudDisk.ReplicaZones {
-			tokens := strings.Split(replicaZone, "/")
-			actualZone := tokens[len(tokens)-1]
-			Expect(zonesSet.Has(actualZone)).To(BeTrue(), "Expected zone %v to exist in zone set %v", actualZone, zones)
-		}
-		Expect(volume.VolumeContext).To(HaveKeyWithValue("force-attach", "true"))
-
-		detachers := []detacherFunc{}
-
-		defer func() {
-			// Perform any detaches
-			for _, fn := range detachers {
-				fn()
-			}
-
-			// Delete Disk
-			controllerClient.DeleteVolume(volume.VolumeId)
-			Expect(err).To(BeNil(), "DeleteVolume failed")
-
-			// Validate Disk Deleted
-			_, err = computeService.RegionDisks.Get(p, region, volName).Do()
-			Expect(gce.IsGCEError(err, "notFound")).To(BeTrue(), "Expected disk to not be found")
-		}()
+type verifyArgs struct {
+	publishDir string
+}
 
-		// Attach disk to instance in the first zone.
-		tc0 := zoneToContext[zones[0]]
-		err, detacher, args := testAttachAndMount(volume.VolumeId, volName, tc0.Instance, tc0.Client, false /* useBlock */, false /* forceAttach */)
-		detachers = append(detachers, detacher)
-		Expect(err).To(BeNil(), "failed attach in zone 0")
-		testFileName := filepath.Join(args.publishDir, "force-attach-test")
-		testFileContents := "force attach test"
-		err = testutils.WriteFile(tc0.Instance, testFileName, testFileContents)
-		Expect(err).To(BeNil(), "failed write in zone 0")
-		_, err = tc0.Instance.SSH("sync") // Sync so force detach doesn't lose data.
-		Expect(err).To(BeNil(), "failed sync")
-
-		readContents, err := testutils.ReadFile(tc0.Instance, testFileName)
-		Expect(err).To(BeNil(), "failed read in zone 0")
-		Expect(strings.TrimSpace(string(readContents))).To(BeIdenticalTo(testFileContents), "content mismatch in zone 0")
-
-		// Now force attach to the second instance without detaching.
-		tc1 := zoneToContext[zones[1]]
-		err, detacher, args = testAttachAndMount(volume.VolumeId, volName, tc1.Instance, tc1.Client, false /* useBlock */, true /* forceAttach */)
-		detachers = append(detachers, detacher)
-		Expect(err).To(BeNil(), "failed force attach in zone 1")
-		readContents, err = testutils.ReadFile(tc1.Instance, testFileName)
-		Expect(err).To(BeNil(), "failed read in zone 1")
-		Expect(strings.TrimSpace(string(readContents))).To(BeIdenticalTo(testFileContents), "content mismatch in zone 1")
-	})
-})
+type verifyFunc func(verifyArgs) error
 
 func testAttachWriteReadDetach(volID string, volName string, instance *remote.InstanceInfo, client *remote.CsiClient, readOnly bool) error {
 	var testFileContents = "test"
-	writeFile := func(a *verifyArgs) error {
+	writeFile := func(a verifyArgs) error {
 		if !readOnly {
 			// Write a file
 			testFile := filepath.Join(a.publishDir, "testfile")
@@ -270,7 +163,7 @@ func testAttachWriteReadDetach(volID string, volName string, instance *remote.In
 		return nil
 	}
 
-	verifyReadFile := func(a *verifyArgs) error {
+	verifyReadFile := func(a verifyArgs) error {
 		// Read File
 		secondTestFile := filepath.Join(a.publishDir, "testfile")
 		readContents, err := testutils.ReadFile(instance, secondTestFile)
@@ -285,20 +178,23 @@ func testAttachWriteReadDetach(volID string, volName string, instance *remote.In
 	return testLifecycleWithVerify(volID, volName, instance, client, readOnly, false /* fs */, writeFile, verifyReadFile)
 }
 
-func testAttachAndMount(volID string, volName string, instance *remote.InstanceInfo, client *remote.CsiClient, useBlock, forceAttach bool) (error, func(), *verifyArgs) {
+func testLifecycleWithVerify(volID string, volName string, instance *remote.InstanceInfo, client *remote.CsiClient, readOnly, useBlock bool, firstMountVerify, secondMountVerify verifyFunc) error {
+	var err error
+	klog.Infof("Starting testAttachWriteReadDetach with volume %v node %v with readonly %v\n", volID, instance.GetNodeID(), readOnly)
 	// Attach Disk
-	err := client.ControllerPublishVolume(volID, instance.GetNodeID(), forceAttach)
+	err = client.ControllerPublishVolume(volID, instance.GetNodeID())
 	if err != nil {
-		return fmt.Errorf("ControllerPublishVolume failed with error for disk %v on node %v: %v", volID, instance.GetNodeID(), err.Error()), nil, nil
+		return fmt.Errorf("ControllerPublishVolume failed with error for disk %v on node %v: %v", volID, instance.GetNodeID(), err.Error())
 	}
 
-	detach := func() {
+	defer func() {
 		// Detach Disk
 		err = client.ControllerUnpublishVolume(volID, instance.GetNodeID())
 		if err != nil {
 			klog.Errorf("Failed to detach disk: %w", err)
 		}
-	}
+
+	}()
 
 	// Stage Disk
 	stageDir := filepath.Join("/tmp/", volName, "stage")
@@ -308,12 +204,12 @@ func testAttachAndMount(volID string, volName string, instance *remote.InstanceI
 		err = client.NodeStageExt4Volume(volID, stageDir)
 	}
 
+	//err = client.NodeStageExt4Volume(volID, stageDir)
 	if err != nil {
-		detach()
-		return fmt.Errorf("NodeStageExt4Volume failed with error: %w", err), nil, nil
+		return fmt.Errorf("NodeStageExt4Volume failed with error: %w", err)
 	}
 
-	unstageAndDetach := func() {
+	defer func() {
 		// Unstage Disk
 		err = client.NodeUnstageVolume(volID, stageDir)
 		if err != nil {
@@ -324,9 +220,7 @@ func testAttachAndMount(volID string, volName string, instance *remote.InstanceI
 		if err != nil {
 			klog.Errorf("Failed to rm file path %s: %w", fp, err)
 		}
-
-		detach()
-	}
+	}()
 
 	// Mount Disk
 	publishDir := filepath.Join("/tmp/", volName, "mount")
@@ -338,38 +232,24 @@ func testAttachAndMount(volID string, volName string, instance *remote.InstanceI
 	}
 
 	if err != nil {
-		unstageAndDetach()
-		return fmt.Errorf("NodePublishVolume failed with error: %v", err.Error()), nil, nil
+		return fmt.Errorf("NodePublishVolume failed with error: %v", err.Error())
 	}
 	err = testutils.ForceChmod(instance, filepath.Join("/tmp/", volName), "777")
 	if err != nil {
-		unstageAndDetach()
-		return fmt.Errorf("Chmod failed with error: %v", err.Error()), nil, nil
+		return fmt.Errorf("Chmod failed with error: %v", err.Error())
 	}
 
-	args := &verifyArgs{
+	a := verifyArgs{
 		publishDir: publishDir,
-		stageDir:   stageDir,
-	}
-
-	return nil, unstageAndDetach, args
-}
-
-func testLifecycleWithVerify(volID string, volName string, instance *remote.InstanceInfo, client *remote.CsiClient, readOnly, useBlock bool, firstMountVerify, secondMountVerify verifyFunc) error {
-	klog.Infof("Starting testAttachWriteReadDetach with volume %v node %v with readonly %v\n", volID, instance.GetNodeID(), readOnly)
-	err, detacher, args := testAttachAndMount(volID, volName, instance, client, useBlock, false /* forceAttach */)
-	if err != nil {
-		return fmt.Errorf("failed to attach and mount: %w", err)
 	}
-	defer detacher()
 
-	err = firstMountVerify(args)
+	err = firstMountVerify(a)
 	if err != nil {
-		return fmt.Errorf("failed to verify after first mount to %s: %w", args.publishDir, err)
+		return fmt.Errorf("failed to verify after first mount to %s: %v", publishDir, err)
 	}
 
 	// Unmount Disk
-	err = client.NodeUnpublishVolume(volID, args.publishDir)
+	err = client.NodeUnpublishVolume(volID, publishDir)
 	if err != nil {
 		return fmt.Errorf("NodeUnpublishVolume failed with error: %v", err.Error())
 	}
@@ -378,9 +258,9 @@ func testLifecycleWithVerify(volID string, volName string, instance *remote.Inst
 		// Mount disk somewhere else
 		secondPublishDir := filepath.Join("/tmp/", volName, "secondmount")
 		if useBlock {
-			err = client.NodePublishBlockVolume(volID, args.stageDir, secondPublishDir)
+			err = client.NodePublishBlockVolume(volID, stageDir, secondPublishDir)
 		} else {
-			err = client.NodePublishVolume(volID, args.stageDir, secondPublishDir)
+			err = client.NodePublishVolume(volID, stageDir, secondPublishDir)
 		}
 		if err != nil {
 			return fmt.Errorf("NodePublishVolume failed with error: %v", err.Error())
@@ -393,9 +273,9 @@ func testLifecycleWithVerify(volID string, volName string, instance *remote.Inst
 		b := verifyArgs{
 			publishDir: secondPublishDir,
 		}
-		err = secondMountVerify(&b)
+		err = secondMountVerify(b)
 		if err != nil {
-			return fmt.Errorf("failed to verify after second mount to %s: %v", args.publishDir, err.Error())
+			return fmt.Errorf("failed to verify after second mount to %s: %v", publishDir, err.Error())
 		}
 
 		// Unmount Disk
diff --git a/test/e2e/tests/resize_e2e_test.go b/test/e2e/tests/resize_e2e_test.go
index 2b04047d..f6126475 100644
--- a/test/e2e/tests/resize_e2e_test.go
+++ b/test/e2e/tests/resize_e2e_test.go
@@ -38,7 +38,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		// Create Disk
 		volName := testNamePrefix + string(uuid.NewUUID())
-		volume, err := client.CreateVolume(volName, nil, defaultSizeGb,
+		volID, err := client.CreateVolume(volName, nil, defaultSizeGb,
 			&csi.TopologyRequirement{
 				Requisite: []*csi.Topology{
 					{
@@ -58,7 +58,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		defer func() {
 			// Delete Disk
-			client.DeleteVolume(volume.VolumeId)
+			client.DeleteVolume(volID)
 			Expect(err).To(BeNil(), "DeleteVolume failed")
 
 			// Validate Disk Deleted
@@ -67,12 +67,12 @@ var _ = Describe("GCE PD CSI Driver", func() {
 		}()
 
 		// Attach Disk
-		err = client.ControllerPublishVolume(volume.VolumeId, instance.GetNodeID(), false /* forceAttach */)
+		err = client.ControllerPublishVolume(volID, instance.GetNodeID())
 		Expect(err).To(BeNil(), "Controller publish volume failed")
 
 		defer func() {
 			// Detach Disk
-			err = client.ControllerUnpublishVolume(volume.VolumeId, instance.GetNodeID())
+			err = client.ControllerUnpublishVolume(volID, instance.GetNodeID())
 			if err != nil {
 				klog.Errorf("Failed to detach disk: %w", err)
 			}
@@ -80,12 +80,12 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		// Stage Disk
 		stageDir := filepath.Join("/tmp/", volName, "stage")
-		err = client.NodeStageExt4Volume(volume.VolumeId, stageDir)
+		err = client.NodeStageExt4Volume(volID, stageDir)
 		Expect(err).To(BeNil(), "Node Stage volume failed")
 
 		defer func() {
 			// Unstage Disk
-			err = client.NodeUnstageVolume(volume.VolumeId, stageDir)
+			err = client.NodeUnstageVolume(volID, stageDir)
 			if err != nil {
 				klog.Errorf("Failed to unstage volume: %w", err)
 			}
@@ -98,12 +98,12 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		// Mount Disk
 		publishDir := filepath.Join("/tmp/", volName, "mount")
-		err = client.NodePublishVolume(volume.VolumeId, stageDir, publishDir)
+		err = client.NodePublishVolume(volID, stageDir, publishDir)
 		Expect(err).To(BeNil(), "Node publish volume failed")
 
 		defer func() {
 			// Unmount Disk
-			err = client.NodeUnpublishVolume(volume.VolumeId, publishDir)
+			err = client.NodeUnpublishVolume(volID, publishDir)
 			if err != nil {
 				klog.Errorf("NodeUnpublishVolume failed with error: %w", err)
 			}
@@ -116,7 +116,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		// Resize controller
 		var newSizeGb int64 = 10
-		err = client.ControllerExpandVolume(volume.VolumeId, newSizeGb)
+		err = client.ControllerExpandVolume(volID, newSizeGb)
 
 		Expect(err).To(BeNil(), "Controller expand volume failed")
 
@@ -126,7 +126,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 		Expect(cloudDisk.SizeGb).To(Equal(newSizeGb))
 
 		// Resize node
-		_, err = client.NodeExpandVolume(volume.VolumeId, publishDir, newSizeGb)
+		_, err = client.NodeExpandVolume(volID, publishDir, newSizeGb)
 		Expect(err).To(BeNil(), "Node expand volume failed")
 
 		// Verify disk size
@@ -145,7 +145,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		// Create Disk
 		volName := testNamePrefix + string(uuid.NewUUID())
-		volume, err := client.CreateVolume(volName, nil, defaultSizeGb,
+		volID, err := client.CreateVolume(volName, nil, defaultSizeGb,
 			&csi.TopologyRequirement{
 				Requisite: []*csi.Topology{
 					{
@@ -165,7 +165,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		defer func() {
 			// Delete Disk
-			client.DeleteVolume(volume.VolumeId)
+			client.DeleteVolume(volID)
 			Expect(err).To(BeNil(), "DeleteVolume failed")
 
 			// Validate Disk Deleted
@@ -174,12 +174,12 @@ var _ = Describe("GCE PD CSI Driver", func() {
 		}()
 
 		// Volume should be attached/formatted/mounted/unmounted/detached
-		err = testAttachWriteReadDetach(volume.VolumeId, volName, instance, client, false /* readOnly */)
+		err = testAttachWriteReadDetach(volID, volName, instance, client, false /* readOnly */)
 		Expect(err).To(BeNil(), "Failed to go through volume lifecycle")
 
 		// Resize controller
 		var newSizeGb int64 = 10
-		err = client.ControllerExpandVolume(volume.VolumeId, newSizeGb)
+		err = client.ControllerExpandVolume(volID, newSizeGb)
 
 		Expect(err).To(BeNil(), "Controller expand volume failed")
 
@@ -189,12 +189,12 @@ var _ = Describe("GCE PD CSI Driver", func() {
 		Expect(cloudDisk.SizeGb).To(Equal(newSizeGb))
 
 		// Attach and mount again
-		err = client.ControllerPublishVolume(volume.VolumeId, instance.GetNodeID(), false /* forceAttach */)
+		err = client.ControllerPublishVolume(volID, instance.GetNodeID())
 		Expect(err).To(BeNil(), "Controller publish volume failed")
 
 		defer func() {
 			// Detach Disk
-			err = client.ControllerUnpublishVolume(volume.VolumeId, instance.GetNodeID())
+			err = client.ControllerUnpublishVolume(volID, instance.GetNodeID())
 			if err != nil {
 				klog.Errorf("Failed to detach disk: %w", err)
 			}
@@ -203,12 +203,12 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		// Stage Disk
 		stageDir := filepath.Join("/tmp/", volName, "stage")
-		err = client.NodeStageExt4Volume(volume.VolumeId, stageDir)
+		err = client.NodeStageExt4Volume(volID, stageDir)
 		Expect(err).To(BeNil(), "Node Stage volume failed")
 
 		defer func() {
 			// Unstage Disk
-			err = client.NodeUnstageVolume(volume.VolumeId, stageDir)
+			err = client.NodeUnstageVolume(volID, stageDir)
 			if err != nil {
 				klog.Errorf("Failed to unstage volume: %w", err)
 			}
@@ -221,19 +221,19 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		// Mount Disk
 		publishDir := filepath.Join("/tmp/", volName, "mount")
-		err = client.NodePublishVolume(volume.VolumeId, stageDir, publishDir)
+		err = client.NodePublishVolume(volID, stageDir, publishDir)
 		Expect(err).To(BeNil(), "Node publish volume failed")
 
 		defer func() {
 			// Unmount Disk
-			err = client.NodeUnpublishVolume(volume.VolumeId, publishDir)
+			err = client.NodeUnpublishVolume(volID, publishDir)
 			if err != nil {
 				klog.Errorf("NodeUnpublishVolume failed with error: %w", err)
 			}
 		}()
 
 		// Resize node
-		_, err = client.NodeExpandVolume(volume.VolumeId, publishDir, newSizeGb)
+		_, err = client.NodeExpandVolume(volID, publishDir, newSizeGb)
 		Expect(err).To(BeNil(), "Node expand volume failed")
 
 		// Verify disk size
@@ -252,7 +252,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		// Create Disk
 		volName := testNamePrefix + string(uuid.NewUUID())
-		volume, err := client.CreateVolume(volName, nil, defaultSizeGb,
+		volID, err := client.CreateVolume(volName, nil, defaultSizeGb,
 			&csi.TopologyRequirement{
 				Requisite: []*csi.Topology{
 					{
@@ -272,7 +272,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		defer func() {
 			// Delete Disk
-			client.DeleteVolume(volume.VolumeId)
+			client.DeleteVolume(volID)
 			Expect(err).To(BeNil(), "DeleteVolume failed")
 
 			// Validate Disk Deleted
@@ -281,12 +281,12 @@ var _ = Describe("GCE PD CSI Driver", func() {
 		}()
 
 		// Attach Disk
-		err = client.ControllerPublishVolume(volume.VolumeId, instance.GetNodeID(), false /* forceAttach */)
+		err = client.ControllerPublishVolume(volID, instance.GetNodeID())
 		Expect(err).To(BeNil(), "Controller publish volume failed")
 
 		defer func() {
 			// Detach Disk
-			err = client.ControllerUnpublishVolume(volume.VolumeId, instance.GetNodeID())
+			err = client.ControllerUnpublishVolume(volID, instance.GetNodeID())
 			if err != nil {
 				klog.Errorf("Failed to detach disk: %w", err)
 			}
@@ -295,12 +295,12 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		// Stage Disk
 		stageDir := filepath.Join("/tmp/", volName, "stage")
-		err = client.NodeStageBlockVolume(volume.VolumeId, stageDir)
+		err = client.NodeStageBlockVolume(volID, stageDir)
 		Expect(err).To(BeNil(), "Node Stage volume failed")
 
 		defer func() {
 			// Unstage Disk
-			err = client.NodeUnstageVolume(volume.VolumeId, stageDir)
+			err = client.NodeUnstageVolume(volID, stageDir)
 			if err != nil {
 				klog.Errorf("Failed to unstage volume: %w", err)
 			}
@@ -313,12 +313,12 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		// Mount Disk
 		publishDir := filepath.Join("/tmp/", volName, "mount")
-		err = client.NodePublishBlockVolume(volume.VolumeId, stageDir, publishDir)
+		err = client.NodePublishBlockVolume(volID, stageDir, publishDir)
 		Expect(err).To(BeNil(), "Node publish volume failed")
 
 		defer func() {
 			// Unmount Disk
-			err = client.NodeUnpublishVolume(volume.VolumeId, publishDir)
+			err = client.NodeUnpublishVolume(volID, publishDir)
 			if err != nil {
 				klog.Errorf("NodeUnpublishVolume failed with error: %w", err)
 			}
@@ -331,7 +331,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		// Resize controller
 		var newSizeGb int64 = 10
-		err = client.ControllerExpandVolume(volume.VolumeId, newSizeGb)
+		err = client.ControllerExpandVolume(volID, newSizeGb)
 
 		Expect(err).To(BeNil(), "Controller expand volume failed")
 
@@ -341,7 +341,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 		Expect(cloudDisk.SizeGb).To(Equal(newSizeGb))
 
 		// Resize node
-		resp, err := client.NodeExpandVolume(volume.VolumeId, publishDir, newSizeGb)
+		resp, err := client.NodeExpandVolume(volID, publishDir, newSizeGb)
 		Expect(err).To(BeNil(), "Node expand volume failed")
 		Expect(resp.CapacityBytes).To(Equal(common.GbToBytes(newSizeGb)), "Node expand should not do anything")
 
diff --git a/test/e2e/tests/single_zone_e2e_test.go b/test/e2e/tests/single_zone_e2e_test.go
index 9b402e17..96075799 100644
--- a/test/e2e/tests/single_zone_e2e_test.go
+++ b/test/e2e/tests/single_zone_e2e_test.go
@@ -45,15 +45,14 @@ const (
 	testNamePrefix = "gcepd-csi-e2e-"
 
 	defaultSizeGb              int64 = 5
-	defaultExtremeSizeGb       int64 = 500
 	defaultRepdSizeGb          int64 = 200
 	defaultMwSizeGb            int64 = 200
 	defaultVolumeLimit         int64 = 127
 	readyState                       = "READY"
 	standardDiskType                 = "pd-standard"
 	extremeDiskType                  = "pd-extreme"
-	provisionedIOPSOnCreate          = "12345"
-	provisionedIOPSOnCreateInt       = int64(12345)
+	provisionedIOPSOnCreate          = "100000"
+	provisionedIOPSOnCreateInt       = int64(100000)
 
 	defaultEpsilon = 500000000 // 500M
 )
@@ -114,7 +113,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 		}()
 
 		// Attach Disk
-		err := client.ControllerPublishVolume(volID, instance.GetNodeID(), false /* forceAttach */)
+		err := client.ControllerPublishVolume(volID, instance.GetNodeID())
 		Expect(err).To(BeNil(), "ControllerPublishVolume failed with error for disk %v on node %v: %v", volID, instance.GetNodeID())
 
 		defer func() {
@@ -186,7 +185,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 		}()
 
 		// Attach Disk
-		err := client.ControllerPublishVolume(volID, instance.GetNodeID(), false /* forceAttach */)
+		err := client.ControllerPublishVolume(volID, instance.GetNodeID())
 		Expect(err).To(BeNil(), "ControllerPublishVolume failed with error for disk %v on node %v: %v", volID, instance.GetNodeID())
 
 		defer func() {
@@ -252,10 +251,10 @@ var _ = Describe("GCE PD CSI Driver", func() {
 					},
 				},
 			}
-			volume, err := testContext.Client.CreateVolume(volName, nil, defaultSizeGb, topReq, nil)
+			volID, err := testContext.Client.CreateVolume(volName, nil, defaultSizeGb, topReq, nil)
 			Expect(err).To(BeNil(), "Failed to create volume")
 			defer func() {
-				err = testContext.Client.DeleteVolume(volume.VolumeId)
+				err = testContext.Client.DeleteVolume(volID)
 				Expect(err).To(BeNil(), "Failed to delete volume")
 			}()
 
@@ -325,7 +324,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 			}()
 
 			// Attach Disk
-			err := client.ControllerPublishVolume(underSpecifiedID, instance.GetNodeID(), false /* forceAttach */)
+			err := client.ControllerPublishVolume(underSpecifiedID, instance.GetNodeID())
 			Expect(err).To(BeNil(), "ControllerPublishVolume failed")
 		},
 		Entry("on pd-standard", standardDiskType),
@@ -346,7 +345,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		// Create Disk
 		volName := testNamePrefix + string(uuid.NewUUID())
-		volume, err := controllerClient.CreateVolume(volName, map[string]string{
+		volID, err := controllerClient.CreateVolume(volName, map[string]string{
 			common.ParameterKeyReplicationType: "regional-pd",
 		}, defaultRepdSizeGb, nil, nil)
 		Expect(err).To(BeNil(), "CreateVolume failed with error: %v", err)
@@ -367,7 +366,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 		}
 		defer func() {
 			// Delete Disk
-			controllerClient.DeleteVolume(volume.VolumeId)
+			controllerClient.DeleteVolume(volID)
 			Expect(err).To(BeNil(), "DeleteVolume failed")
 
 			// Validate Disk Deleted
@@ -387,27 +386,20 @@ var _ = Describe("GCE PD CSI Driver", func() {
 			// Create Disk
 			disk := typeToDisk[diskType]
 			volName := testNamePrefix + string(uuid.NewUUID())
-
-			diskSize := defaultSizeGb
-			if diskType == extremeDiskType {
-				diskSize = defaultExtremeSizeGb
-			}
-
-			volume, err := client.CreateVolume(volName, disk.params, diskSize, nil, nil)
-
+			volID, err := client.CreateVolume(volName, disk.params, defaultSizeGb, nil, nil)
 			Expect(err).To(BeNil(), "CreateVolume failed with error: %v", err)
 
 			// Validate Disk Created
 			cloudDisk, err := computeService.Disks.Get(p, z, volName).Do()
 			Expect(err).To(BeNil(), "Could not get disk from cloud directly")
 			Expect(cloudDisk.Status).To(Equal(readyState))
-			Expect(cloudDisk.SizeGb).To(Equal(diskSize))
+			Expect(cloudDisk.SizeGb).To(Equal(defaultSizeGb))
 			Expect(cloudDisk.Name).To(Equal(volName))
 			disk.validate(cloudDisk)
 
 			defer func() {
 				// Delete Disk
-				client.DeleteVolume(volume.VolumeId)
+				client.DeleteVolume(volID)
 				Expect(err).To(BeNil(), "DeleteVolume failed")
 
 				// Validate Disk Deleted
@@ -433,19 +425,14 @@ var _ = Describe("GCE PD CSI Driver", func() {
 			params := merge(disk.params, map[string]string{
 				common.ParameterKeyLabels: "key1=value1,key2=value2",
 			})
-
-			diskSize := defaultSizeGb
-			if diskType == extremeDiskType {
-				diskSize = defaultExtremeSizeGb
-			}
-			volume, err := client.CreateVolume(volName, params, diskSize, nil, nil)
+			volID, err := client.CreateVolume(volName, params, defaultSizeGb, nil, nil)
 			Expect(err).To(BeNil(), "CreateVolume failed with error: %v", err)
 
 			// Validate Disk Created
 			cloudDisk, err := computeService.Disks.Get(p, z, volName).Do()
 			Expect(err).To(BeNil(), "Could not get disk from cloud directly")
 			Expect(cloudDisk.Status).To(Equal(readyState))
-			Expect(cloudDisk.SizeGb).To(Equal(diskSize))
+			Expect(cloudDisk.SizeGb).To(Equal(defaultSizeGb))
 			Expect(cloudDisk.Labels).To(Equal(map[string]string{
 				"key1": "value1",
 				"key2": "value2",
@@ -457,7 +444,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 			defer func() {
 				// Delete Disk
-				err := client.DeleteVolume(volume.VolumeId)
+				err := client.DeleteVolume(volID)
 				Expect(err).To(BeNil(), "DeleteVolume failed")
 
 				// Validate Disk Deleted
@@ -560,25 +547,20 @@ var _ = Describe("GCE PD CSI Driver", func() {
 					},
 				},
 			}
-
-			diskSize := defaultSizeGb
-			if diskType == extremeDiskType {
-				diskSize = defaultExtremeSizeGb
-			}
-			volume, err := controllerClient.CreateVolume(volName, params, diskSize, topology, nil)
+			volID, err := controllerClient.CreateVolume(volName, params, defaultSizeGb, topology, nil)
 			Expect(err).To(BeNil(), "CreateVolume failed with error: %v", err)
 
 			// Validate Disk Created
 			cloudDisk, err := computeService.Disks.Get(p, z, volName).Do()
 			Expect(err).To(BeNil(), "Could not get disk from cloud directly")
 			Expect(cloudDisk.Status).To(Equal(readyState))
-			Expect(cloudDisk.SizeGb).To(Equal(diskSize))
+			Expect(cloudDisk.SizeGb).To(Equal(defaultSizeGb))
 			Expect(cloudDisk.Name).To(Equal(volName))
 			disk.validate(cloudDisk)
 
 			defer func() {
 				// Delete Disk
-				err = controllerClient.DeleteVolume(volume.VolumeId)
+				err = controllerClient.DeleteVolume(volID)
 				Expect(err).To(BeNil(), "DeleteVolume failed")
 
 				// Validate Disk Deleted
@@ -587,7 +569,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 			}()
 
 			// Test disk works
-			err = testAttachWriteReadDetach(volume.VolumeId, volName, controllerInstance, controllerClient, false /* readOnly */)
+			err = testAttachWriteReadDetach(volID, volName, controllerInstance, controllerClient, false /* readOnly */)
 			Expect(err).To(BeNil(), "Failed to go through volume lifecycle before revoking CMEK key")
 
 			// Revoke CMEK key
@@ -608,7 +590,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 			}
 
 			// Make sure attach of PD fails
-			err = testAttachWriteReadDetach(volume.VolumeId, volName, controllerInstance, controllerClient, false /* readOnly */)
+			err = testAttachWriteReadDetach(volID, volName, controllerInstance, controllerClient, false /* readOnly */)
 			Expect(err).ToNot(BeNil(), "Volume lifecycle should have failed, but succeeded")
 
 			// Restore CMEK key
@@ -629,7 +611,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 			// The controller publish failure in above step would set a backoff condition on the node. Wait suffcient amount of time for the driver to accept new controller publish requests.
 			time.Sleep(time.Second)
 			// Make sure attach of PD succeeds
-			err = testAttachWriteReadDetach(volume.VolumeId, volName, controllerInstance, controllerClient, false /* readOnly */)
+			err = testAttachWriteReadDetach(volID, volName, controllerInstance, controllerClient, false /* readOnly */)
 			Expect(err).To(BeNil(), "Failed to go through volume lifecycle after restoring CMEK key")
 		},
 		Entry("on pd-standard", standardDiskType),
@@ -652,7 +634,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 		defer deleteVolumeOrError(client, secondVolID)
 
 		// Attach volID to current instance
-		err := client.ControllerPublishVolume(volID, nodeID, false /* forceAttach */)
+		err := client.ControllerPublishVolume(volID, nodeID)
 		Expect(err).To(BeNil(), "Failed ControllerPublishVolume")
 		defer client.ControllerUnpublishVolume(volID, nodeID)
 
@@ -680,7 +662,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		// Create Disk
 		volName := testNamePrefix + string(uuid.NewUUID())
-		volume, err := controllerClient.CreateVolume(volName, map[string]string{
+		volID, err := controllerClient.CreateVolume(volName, map[string]string{
 			common.ParameterKeyReplicationType: "regional-pd",
 		}, defaultRepdSizeGb, nil, nil)
 		Expect(err).To(BeNil(), "CreateVolume failed with error: %v", err)
@@ -702,7 +684,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		// Create Snapshot
 		snapshotName := testNamePrefix + string(uuid.NewUUID())
-		snapshotID, err := controllerClient.CreateSnapshot(snapshotName, volume.VolumeId, nil)
+		snapshotID, err := controllerClient.CreateSnapshot(snapshotName, volID, nil)
 		Expect(err).To(BeNil(), "CreateSnapshot failed with error: %v", err)
 
 		// Validate Snapshot Created
@@ -722,7 +704,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		defer func() {
 			// Delete Disk
-			err := controllerClient.DeleteVolume(volume.VolumeId)
+			err := controllerClient.DeleteVolume(volID)
 			Expect(err).To(BeNil(), "DeleteVolume failed")
 
 			// Validate Disk Deleted
@@ -758,7 +740,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 			Expect(gce.IsGCEError(err, "notFound")).To(BeTrue(), "Expected disk to not be found")
 		}()
 
-		verifyVolumeStats := func(a *verifyArgs) error {
+		verifyVolumeStats := func(a verifyArgs) error {
 			available, capacity, used, inodesFree, inodes, inodesUsed, err := client.NodeGetVolumeStats(volID, a.publishDir)
 			if err != nil {
 				return fmt.Errorf("failed to get node volume stats: %v", err.Error())
@@ -795,7 +777,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 			Expect(gce.IsGCEError(err, "notFound")).To(BeTrue(), "Expected disk to not be found")
 		}()
 
-		verifyVolumeStats := func(a *verifyArgs) error {
+		verifyVolumeStats := func(a verifyArgs) error {
 			available, capacity, used, inodesFree, inodes, inodesUsed, err := client.NodeGetVolumeStats(volID, a.publishDir)
 			if err != nil {
 				return fmt.Errorf("failed to get node volume stats: %v", err.Error())
@@ -861,14 +843,14 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		// Attach Disk
 		testFileContents := "test"
-		writeFunc := func(a *verifyArgs) error {
+		writeFunc := func(a verifyArgs) error {
 			err := testutils.WriteBlock(instance, a.publishDir, testFileContents)
 			if err != nil {
 				return fmt.Errorf("Failed to write file: %v", err.Error())
 			}
 			return nil
 		}
-		verifyReadFunc := func(a *verifyArgs) error {
+		verifyReadFunc := func(a verifyArgs) error {
 			readContents, err := testutils.ReadBlock(instance, a.publishDir, len(testFileContents))
 			if err != nil {
 				return fmt.Errorf("ReadFile failed with error: %v", err.Error())
@@ -890,11 +872,6 @@ var _ = Describe("GCE PD CSI Driver", func() {
 			controllerInstance := testContext.Instance
 			controllerClient := testContext.Client
 
-			diskSize := defaultSizeGb
-			if diskType == extremeDiskType {
-				diskSize = defaultExtremeSizeGb
-			}
-
 			p, z, _ := controllerInstance.GetIdentity()
 
 			// Create Disk
@@ -905,21 +882,21 @@ var _ = Describe("GCE PD CSI Driver", func() {
 				common.ParameterKeyPVCNamespace: "test-pvc-namespace",
 				common.ParameterKeyPVName:       "test-pv-name",
 			})
-			volume, err := controllerClient.CreateVolume(volName, params, diskSize, nil /* topReq */, nil)
+			volID, err := controllerClient.CreateVolume(volName, params, defaultSizeGb, nil /* topReq */, nil)
 			Expect(err).To(BeNil(), "CreateVolume failed with error: %v", err)
 
 			// Validate Disk Created
 			cloudDisk, err := computeService.Disks.Get(p, z, volName).Do()
 			Expect(err).To(BeNil(), "Could not get disk from cloud directly")
 			Expect(cloudDisk.Status).To(Equal(readyState))
-			Expect(cloudDisk.SizeGb).To(Equal(diskSize))
+			Expect(cloudDisk.SizeGb).To(Equal(defaultSizeGb))
 			Expect(cloudDisk.Name).To(Equal(volName))
 			Expect(cloudDisk.Description).To(Equal("{\"kubernetes.io/created-for/pv/name\":\"test-pv-name\",\"kubernetes.io/created-for/pvc/name\":\"test-pvc\",\"kubernetes.io/created-for/pvc/namespace\":\"test-pvc-namespace\",\"storage.gke.io/created-by\":\"pd.csi.storage.gke.io\"}"))
 			disk.validate(cloudDisk)
 
 			defer func() {
 				// Delete Disk
-				controllerClient.DeleteVolume(volume.VolumeId)
+				controllerClient.DeleteVolume(volID)
 				Expect(err).To(BeNil(), "DeleteVolume failed")
 
 				// Validate Disk Deleted
@@ -1065,7 +1042,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		// Create Disk
 		volName := testNamePrefix + string(uuid.NewUUID())
-		volume, err := controllerClient.CreateVolume(volName, map[string]string{
+		volID, err := controllerClient.CreateVolume(volName, map[string]string{
 			common.ParameterKeyReplicationType: "none",
 		}, defaultSizeGb,
 			&csi.TopologyRequirement{
@@ -1098,7 +1075,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 		Expect(zoneFromURL(cloudDisk.Zone)).To(Equal(srcKey.Zone))
 		defer func() {
 			// Delete Disk
-			controllerClient.DeleteVolume(volume.VolumeId)
+			controllerClient.DeleteVolume(volID)
 			Expect(err).To(BeNil(), "DeleteVolume failed")
 
 			// Validate Disk Deleted
@@ -1121,18 +1098,18 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		// Create Source Disk
 		srcVolName := testNamePrefix + string(uuid.NewUUID())
-		srcVolume, err := controllerClient.CreateVolume(srcVolName, map[string]string{
+		srcVolID, err := controllerClient.CreateVolume(srcVolName, map[string]string{
 			common.ParameterKeyReplicationType: "none",
 		}, defaultRepdSizeGb, nil, nil)
 		// Create Disk
 		volName := testNamePrefix + string(uuid.NewUUID())
-		volume, err := controllerClient.CreateVolume(volName, map[string]string{
+		volID, err := controllerClient.CreateVolume(volName, map[string]string{
 			common.ParameterKeyReplicationType: "regional-pd",
 		}, defaultRepdSizeGb, nil,
 			&csi.VolumeContentSource{
 				Type: &csi.VolumeContentSource_Volume{
 					Volume: &csi.VolumeContentSource_VolumeSource{
-						VolumeId: srcVolume.VolumeId,
+						VolumeId: srcVolID,
 					},
 				},
 			})
@@ -1148,7 +1125,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 		Expect(cloudDisk.Name).To(Equal(volName))
 		Expect(len(cloudDisk.ReplicaZones)).To(Equal(2))
 		replicaZonesCompatible := false
-		_, srcKey, err := common.VolumeIDToKey(srcVolume.VolumeId)
+		_, srcKey, err := common.VolumeIDToKey(srcVolID)
 		Expect(err).To(BeNil(), "Could not get source volume key from id")
 		for _, replicaZone := range cloudDisk.ReplicaZones {
 			actualZone := zoneFromURL(replicaZone)
@@ -1163,7 +1140,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 		Expect(replicaZonesCompatible).To(Equal(true))
 		defer func() {
 			// Delete Disk
-			controllerClient.DeleteVolume(volume.VolumeId)
+			controllerClient.DeleteVolume(volID)
 			Expect(err).To(BeNil(), "DeleteVolume failed")
 
 			// Validate Disk Deleted
@@ -1186,18 +1163,18 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 		// Create Source Disk
 		srcVolName := testNamePrefix + string(uuid.NewUUID())
-		srcVolume, err := controllerClient.CreateVolume(srcVolName, map[string]string{
+		srcVolID, err := controllerClient.CreateVolume(srcVolName, map[string]string{
 			common.ParameterKeyReplicationType: "regional-pd",
 		}, defaultRepdSizeGb, nil, nil)
 		// Create Disk
 		volName := testNamePrefix + string(uuid.NewUUID())
-		volume, err := controllerClient.CreateVolume(volName, map[string]string{
+		volID, err := controllerClient.CreateVolume(volName, map[string]string{
 			common.ParameterKeyReplicationType: "regional-pd",
 		}, defaultRepdSizeGb, nil,
 			&csi.VolumeContentSource{
 				Type: &csi.VolumeContentSource_Volume{
 					Volume: &csi.VolumeContentSource_VolumeSource{
-						VolumeId: srcVolume.VolumeId,
+						VolumeId: srcVolID,
 					},
 				},
 			})
@@ -1224,7 +1201,7 @@ var _ = Describe("GCE PD CSI Driver", func() {
 		}
 		defer func() {
 			// Delete Disk
-			controllerClient.DeleteVolume(volume.VolumeId)
+			controllerClient.DeleteVolume(volID)
 			Expect(err).To(BeNil(), "DeleteVolume failed")
 
 			// Validate Disk Deleted
@@ -1279,12 +1256,7 @@ func createAndValidateUniqueZonalDisk(client *remote.CsiClient, project, zone st
 	// Create Disk
 	disk := typeToDisk[diskType]
 	volName := testNamePrefix + string(uuid.NewUUID())
-
-	diskSize := defaultSizeGb
-	if diskType == extremeDiskType {
-		diskSize = defaultExtremeSizeGb
-	}
-	volume, err := client.CreateVolume(volName, disk.params, diskSize,
+	volID, err := client.CreateVolume(volName, disk.params, defaultSizeGb,
 		&csi.TopologyRequirement{
 			Requisite: []*csi.Topology{
 				{
@@ -1298,11 +1270,11 @@ func createAndValidateUniqueZonalDisk(client *remote.CsiClient, project, zone st
 	cloudDisk, err := computeService.Disks.Get(project, zone, volName).Do()
 	Expect(err).To(BeNil(), "Could not get disk from cloud directly")
 	Expect(cloudDisk.Status).To(Equal(readyState))
-	Expect(cloudDisk.SizeGb).To(Equal(diskSize))
+	Expect(cloudDisk.SizeGb).To(Equal(defaultSizeGb))
 	Expect(cloudDisk.Name).To(Equal(volName))
 	disk.validate(cloudDisk)
 
-	return volName, volume.VolumeId
+	return volName, volID
 }
 
 func deleteVolumeOrError(client *remote.CsiClient, volID string) {
@@ -1321,7 +1293,7 @@ func createAndValidateUniqueZonalMultiWriterDisk(client *remote.CsiClient, proje
 	// Create Disk
 	disk := typeToDisk[diskType]
 	volName := testNamePrefix + string(uuid.NewUUID())
-	volume, err := client.CreateVolumeWithCaps(volName, disk.params, defaultMwSizeGb,
+	volID, err := client.CreateVolumeWithCaps(volName, disk.params, defaultMwSizeGb,
 		&csi.TopologyRequirement{
 			Requisite: []*csi.Topology{
 				{
@@ -1353,7 +1325,7 @@ func createAndValidateUniqueZonalMultiWriterDisk(client *remote.CsiClient, proje
 	Expect(err).To(BeNil(), "Failed to get cloud disk using alpha API")
 	Expect(alphaDisk.MultiWriter).To(Equal(true))
 
-	return volName, volume.VolumeId
+	return volName, volID
 }
 
 func cleanSelfLink(selfLink string) string {
diff --git a/test/e2e/utils/utils.go b/test/e2e/utils/utils.go
index 97364bed..8a80501e 100644
--- a/test/e2e/utils/utils.go
+++ b/test/e2e/utils/utils.go
@@ -53,18 +53,14 @@ func GCEClientAndDriverSetup(instance *remote.InstanceInfo, computeEndpoint stri
 	binPath := path.Join(pkgPath, "bin/gce-pd-csi-driver")
 
 	endpoint := fmt.Sprintf("tcp://localhost:%s", port)
-	extra_flags := []string{
-		fmt.Sprintf("--extra-labels=%s=%s", DiskLabelKey, DiskLabelValue),
-		"--max-concurrent-format-and-mount=20", // otherwise the serialization times out the e2e test.
-	}
+	computeFlag := ""
 	if computeEndpoint != "" {
-		extra_flags = append(extra_flags, fmt.Sprintf("--compute-endpoint %s", computeEndpoint))
+		computeFlag = fmt.Sprintf("--compute-endpoint %s", computeEndpoint)
 	}
+
 	workspace := remote.NewWorkspaceDir("gce-pd-e2e-")
-	// Log at V(6) as the compute API calls are emitted at that level and it's
-	// useful to see what's happening when debugging tests.
-	driverRunCmd := fmt.Sprintf("sh -c '/usr/bin/nohup %s/gce-pd-csi-driver -v=6 --endpoint=%s %s 2> %s/prog.out < /dev/null > /dev/null &'",
-		workspace, endpoint, strings.Join(extra_flags, " "), workspace)
+	driverRunCmd := fmt.Sprintf("sh -c '/usr/bin/nohup %s/gce-pd-csi-driver -v=4 --endpoint=%s %s --extra-labels=%s=%s 2> %s/prog.out < /dev/null > /dev/null &'",
+		workspace, endpoint, computeFlag, DiskLabelKey, DiskLabelValue, workspace)
 
 	config := &remote.ClientConfig{
 		PkgPath:      pkgPath,
diff --git a/test/k8s-integration/cluster.go b/test/k8s-integration/cluster.go
index 3d74f159..e3425935 100644
--- a/test/k8s-integration/cluster.go
+++ b/test/k8s-integration/cluster.go
@@ -183,7 +183,7 @@ func clusterUpGKE(gceZone, gceRegion string, numNodes int, numWindowsNodes int,
 	var cmd *exec.Cmd
 	cmdParams := []string{"container", "clusters", "create", *gkeTestClusterName,
 		locationArg, locationVal, "--num-nodes", strconv.Itoa(numNodes),
-		"--quiet", "--machine-type", "n1-standard-2", "--image-type", imageType, "--no-enable-autoupgrade"}
+		"--quiet", "--machine-type", "n1-standard-2", "--image-type", imageType}
 	if isVariableSet(gkeClusterVer) {
 		cmdParams = append(cmdParams, "--cluster-version", *gkeClusterVer)
 	} else {
diff --git a/test/k8s-integration/config/test-config-template.in b/test/k8s-integration/config/test-config-template.in
index a70686c5..6571ae9e 100644
--- a/test/k8s-integration/config/test-config-template.in
+++ b/test/k8s-integration/config/test-config-template.in
@@ -22,7 +22,7 @@ DriverInfo:
     NumRestarts: 10
   SupportedMountOption:
     debug:
-    noatime:
+    nouid32:
   SupportedSizeRange:
     Min: {{.MinimumVolumeSize}}
     Max: 64Ti
diff --git a/test/remote/client-wrappers.go b/test/remote/client-wrappers.go
index 7c86e657..748c0918 100644
--- a/test/remote/client-wrappers.go
+++ b/test/remote/client-wrappers.go
@@ -99,7 +99,7 @@ func (c *CsiClient) CloseConn() error {
 	return c.conn.Close()
 }
 
-func (c *CsiClient) CreateVolumeWithCaps(volName string, params map[string]string, sizeInGb int64, topReq *csipb.TopologyRequirement, caps []*csipb.VolumeCapability, volContentSrc *csipb.VolumeContentSource) (*csipb.Volume, error) {
+func (c *CsiClient) CreateVolumeWithCaps(volName string, params map[string]string, sizeInGb int64, topReq *csipb.TopologyRequirement, caps []*csipb.VolumeCapability, volContentSrc *csipb.VolumeContentSource) (string, error) {
 	capRange := &csipb.CapacityRange{
 		RequiredBytes: common.GbToBytes(sizeInGb),
 	}
@@ -117,12 +117,12 @@ func (c *CsiClient) CreateVolumeWithCaps(volName string, params map[string]strin
 	}
 	cresp, err := c.ctrlClient.CreateVolume(context.Background(), cvr)
 	if err != nil {
-		return nil, err
+		return "", err
 	}
-	return cresp.Volume, nil
+	return cresp.GetVolume().GetVolumeId(), nil
 }
 
-func (c *CsiClient) CreateVolume(volName string, params map[string]string, sizeInGb int64, topReq *csipb.TopologyRequirement, volContentSrc *csipb.VolumeContentSource) (*csipb.Volume, error) {
+func (c *CsiClient) CreateVolume(volName string, params map[string]string, sizeInGb int64, topReq *csipb.TopologyRequirement, volContentSrc *csipb.VolumeContentSource) (string, error) {
 	return c.CreateVolumeWithCaps(volName, params, sizeInGb, topReq, stdVolCaps, volContentSrc)
 }
 
@@ -134,18 +134,13 @@ func (c *CsiClient) DeleteVolume(volId string) error {
 	return err
 }
 
-func (c *CsiClient) ControllerPublishVolume(volId, nodeId string, forceAttach bool) error {
+func (c *CsiClient) ControllerPublishVolume(volId, nodeId string) error {
 	cpreq := &csipb.ControllerPublishVolumeRequest{
 		VolumeId:         volId,
 		NodeId:           nodeId,
 		VolumeCapability: stdVolCap,
 		Readonly:         false,
 	}
-	if forceAttach {
-		cpreq.VolumeContext = map[string]string{
-			"force-attach": "true",
-		}
-	}
 	_, err := c.ctrlClient.ControllerPublishVolume(context.Background(), cpreq)
 	return err
 }
diff --git a/test/run-e2e-local.sh b/test/run-e2e-local.sh
index 6e60ccc8..be0455a1 100755
--- a/test/run-e2e-local.sh
+++ b/test/run-e2e-local.sh
@@ -2,13 +2,7 @@
 
 set -o nounset
 set -o errexit
-set -x
-
-echo Using GOPATH $GOPATH
 
 readonly PKGDIR=sigs.k8s.io/gcp-compute-persistent-disk-csi-driver
 
-# This requires application default credentials to be set up, eg by
-# `gcloud auth application-default login`
-
-ginkgo --v "test/e2e/tests" -- --project "${PROJECT}" --service-account "${IAM_NAME}" --v=6 --logtostderr
+ginkgo --v "test/e2e/tests" -- --project "${PROJECT}" --service-account "${IAM_NAME}" --v=4 --logtostderr