--- a/go.mod
+++ b/go.mod
@@ -29,9 +29,9 @@
 	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.46.0
 	go.opentelemetry.io/otel/sdk v1.46.0
 	go.uber.org/mock v0.6.0
-	golang.org/x/net v0.59.0
-	golang.org/x/sync v0.23.0
-	golang.org/x/sys v0.48.0
+	golang.org/x/net v0.60.0
+	golang.org/x/sync v0.24.0
+	golang.org/x/sys v0.49.0
 	google.golang.org/grpc v1.83.2
 	google.golang.org/protobuf v1.36.12
 	k8s.io/api v0.35.7
@@ -138,14 +138,14 @@
 	go.opentelemetry.io/proto/otlp v1.11.0 // indirect
 	go.yaml.in/yaml/v2 v2.4.4 // indirect
 	go.yaml.in/yaml/v3 v3.0.5 // indirect
-	golang.org/x/crypto v0.57.0 // indirect
+	golang.org/x/crypto v0.58.0 // indirect
 	golang.org/x/exp v0.0.0-20250911091902-df9299821621 // indirect
 	golang.org/x/mod v0.41.0 // indirect
 	golang.org/x/oauth2 v0.36.0 // indirect
-	golang.org/x/term v0.46.0 // indirect
-	golang.org/x/text v0.42.0 // indirect
+	golang.org/x/term v0.47.0 // indirect
+	golang.org/x/text v0.43.0 // indirect
 	golang.org/x/time v0.15.0 // indirect
-	golang.org/x/tools v0.49.0 // indirect
+	golang.org/x/tools v0.51.0 // indirect
 	google.golang.org/genproto/googleapis/api v0.0.0-20260819154853-08b0e4226688 // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20260819154853-08b0e4226688 // indirect
 	gopkg.in/evanphx/json-patch.v4 v4.13.0 // indirect
@@ -201,3 +201,5 @@
 replace k8s.io/kms => k8s.io/kms v0.35.0
 
 replace k8s.io/mount-utils => k8s.io/mount-utils v0.35.1
+
+replace golang.org/x/net => golang.org/x/net v0.62.0
--- a/go.sum
+++ b/go.sum
@@ -502,38 +502,11 @@
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
 go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
 go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.1.0/go.mod h1:RecgLatLF4+eUMCP1PoPZQb+cVrJcOPbHkTkbkB9sbw=
-golang.org/x/crypto v0.11.0/go.mod h1:xgJhtzW8F9jGdVFWZESrid1U1bjeNy4zgy5cRr/CIio=
-golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
-golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc=
-golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4=
-golang.org/x/crypto v0.16.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
-golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
-golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
-golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
-golang.org/x/crypto v0.22.0/go.mod h1:vr6Su+7cTlO45qkww3VDJlzDn0ctJvRgYbC2NvXHt+M=
-golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
-golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
-golang.org/x/crypto v0.25.0/go.mod h1:T+wALwcMOSE0kXgUAnPAHqTLW+XHgcELELW8VaDgm/M=
-golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54=
-golang.org/x/crypto v0.28.0/go.mod h1:rmgy+3RHxRZMyY0jjAJShp2zgEdOqj2AO7U0pYmeQ7U=
-golang.org/x/crypto v0.30.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
-golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
-golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
-golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
-golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
-golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U=
-golang.org/x/crypto v0.40.0/go.mod h1:Qr1vMER5WyS2dfPHAlsOj01wgLbsyWtFn/aY+5+ZdxY=
-golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc=
-golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
-golang.org/x/crypto v0.43.0/go.mod h1:BFbav4mRNlXJL4wNeejLpWxB7wMbc79PdRGhWKncxR0=
-golang.org/x/crypto v0.44.0/go.mod h1:013i+Nw79BMiQiMsOPcVCB5ZIJbYkerPrGnOa00tvmc=
-golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M=
-golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA=
+golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54=
+golang.org/x/crypto v0.58.0/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE=
 golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
@@ -561,67 +534,25 @@
 golang.org/x/mod v0.21.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
 golang.org/x/mod v0.22.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
 golang.org/x/mod v0.23.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
-golang.org/x/mod v0.24.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
 golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
 golang.org/x/mod v0.26.0/go.mod h1:/j6NAhSk8iQ723BGAUyoAcn7SlD7s15Dp9Nd/SfeaFQ=
 golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc=
 golang.org/x/mod v0.28.0/go.mod h1:yfB/L0NOf/kmEbXjzCPOx1iK1fRutOydrCMsqRhEBxI=
 golang.org/x/mod v0.29.0/go.mod h1:NyhrlYXJ2H4eJiRy/WDBO6HMqZQ6q9nk4JzS3NuCK+w=
+golang.org/x/mod v0.30.0/go.mod h1:lAsf5O2EvJeSFMiBxXDki7sCgAxEUcZHXoXMKT4GJKc=
+golang.org/x/mod v0.31.0/go.mod h1:43JraMp9cGx1Rx3AqioxrbrhNsLl2l/iNAvuBkrezpg=
+golang.org/x/mod v0.32.0/go.mod h1:SgipZ/3h2Ci89DlEtEXWUk/HteuRin+HHhN+WbNhguU=
+golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w=
+golang.org/x/mod v0.34.0/go.mod h1:ykgH52iCZe79kzLLMhyCUzhMci+nQj+0XkbXpNYtVjY=
+golang.org/x/mod v0.35.0/go.mod h1:+GwiRhIInF8wPm+4AoT6L0FA1QWAad3OMdTRx4tFYlU=
+golang.org/x/mod v0.36.0/go.mod h1:moc6ELqsWcOw5Ef3xVprK5ul/MvtVvkIXLziUOICjUQ=
+golang.org/x/mod v0.37.0/go.mod h1:m8S8VeM9r4dzDwjrKO0a1sZP3YjeMamRRlD+fmR2Q/0=
+golang.org/x/mod v0.38.0/go.mod h1:V6Xz0pq8TQ3dGqVQ1FVHuelZpAL0uNhSkk9ogYP3c40=
+golang.org/x/mod v0.39.0/go.mod h1:bvIbwjQ0HUFFf5AKukeeYQG4ZBUG9yxQbR9aEweIwYY=
 golang.org/x/mod v0.41.0 h1:qJmnOUb4YB+FsEuM3HcWucdZASCPGhsX6uljO6pog0c=
 golang.org/x/mod v0.41.0/go.mod h1:Ek9pY8RKWXwsWvd3rQiHYtMqkjSUV+s1Rj7j4H5Ur6o=
-golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
-golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
-golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
-golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco=
-golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY=
-golang.org/x/net v0.3.0/go.mod h1:MBQ8lrhLObU/6UmLb4fmbmk5OcyYmqtbGd/9yIeKjEE=
-golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws=
-golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
-golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
-golang.org/x/net v0.12.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA=
-golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI=
-golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
-golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
-golang.org/x/net v0.19.0/go.mod h1:CfAk/cbD4CthTvqiEl8NpboMuiuOYsAr/7NOjZJtv1U=
-golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
-golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
-golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
-golang.org/x/net v0.24.0/go.mod h1:2Q7sJY5mzlzWjKtYUEXSlBWCdyaioyXzRB2RtU8KVE8=
-golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
-golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
-golang.org/x/net v0.27.0/go.mod h1:dDi0PyhWNoiUOrAS8uXv/vnScO4wnHQO4mj9fn/RytE=
-golang.org/x/net v0.28.0/go.mod h1:yqtgsTWOOnlGLG9GFRrK3++bGOUEkNBoHZc8MEDWPNg=
-golang.org/x/net v0.30.0/go.mod h1:2wGyMJ5iFasEhkwi13ChkO/t1ECNC4X4eBKkVFyYFlU=
-golang.org/x/net v0.32.0/go.mod h1:CwU0IoeOlnQQWJ6ioyFrfRuomB8GKF6KbYXZVyeXNfs=
-golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
-golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk=
-golang.org/x/net v0.37.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
-golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
-golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
-golang.org/x/net v0.42.0/go.mod h1:FF1RA5d3u7nAYA4z2TkclSCKh68eSXtiFwcWQpPXdt8=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
-golang.org/x/net v0.44.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY=
-golang.org/x/net v0.45.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY=
-golang.org/x/net v0.46.0/go.mod h1:Q9BGdFy1y4nkUwiLvT5qtyhAnEHgnQ/zd8PfU6nc210=
-golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU=
-golang.org/x/net v0.59.0 h1:5zfYln+w5XCxwrnMMJPufRgNoXEaGxl0wo5GqPXyues=
-golang.org/x/net v0.59.0/go.mod h1:2DA/G1UfVbCpQPeWTmMPGY7Cs2PkBkwu743bVX5PIVg=
+golang.org/x/net v0.62.0 h1:18ELalfM5+XNRwzM2nYqXsZQ9ByS1uhj2O/U7+5jqRY=
+golang.org/x/net v0.62.0/go.mod h1:WgDCOTH8iwtB66T4/GfI94AHo/hhdb7Hah9NDseQfiI=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKlU=
@@ -645,13 +576,17 @@
 golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
-golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
-golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk=
+golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
 golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
+golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA=
+golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -662,8 +597,6 @@
 golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -673,7 +606,6 @@
 golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220319134239-a9b59b0215f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220422013727-9388b58f7150/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -687,7 +619,6 @@
 golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
@@ -707,51 +638,42 @@
 golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
+golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/sys v0.44.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
 golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
+golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA=
+golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
 golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
 golang.org/x/telemetry v0.0.0-20240521205824-bda55230c457/go.mod h1:pRgIJT+bRLFKnoM1ldnzKoxTIn14Yxz928LQRYYgIN0=
 golang.org/x/telemetry v0.0.0-20250710130107-8d8967aff50b/go.mod h1:4ZwOYna0/zsOKwuR5X/m0QFOJpSZvAxFfkQT+Erd9D4=
 golang.org/x/telemetry v0.0.0-20250807160809-1a19826ec488/go.mod h1:fGb/2+tgXXjhjHsTNdVEEMZNWA0quBnfrO+AfoDSAKw=
 golang.org/x/telemetry v0.0.0-20250908211612-aef8a434d053/go.mod h1:+nZKN+XVh4LCiA9DV3ywrzN4gumyCnKjau3NGb9SGoE=
 golang.org/x/telemetry v0.0.0-20251008203120-078029d740a8/go.mod h1:Pi4ztBfryZoJEkyFTI5/Ocsu2jXyDr6iSdgJiYE/uwE=
+golang.org/x/telemetry v0.0.0-20251111182119-bc8e575c7b54/go.mod h1:hKdjCMrbv9skySur+Nek8Hd0uJ0GuxJIoIX2payrIdQ=
+golang.org/x/telemetry v0.0.0-20251203150158-8fff8a5912fc/go.mod h1:hKdjCMrbv9skySur+Nek8Hd0uJ0GuxJIoIX2payrIdQ=
+golang.org/x/telemetry v0.0.0-20260109210033-bd525da824e2/go.mod h1:b7fPSJ0pKZ3ccUh8gnTONJxhn3c/PS6tyzQvyqw4iA8=
+golang.org/x/telemetry v0.0.0-20260209163413-e7419c687ee4/go.mod h1:g5NllXBEermZrmR51cJDQxmJUHUOfRAaNyWBM+R+548=
+golang.org/x/telemetry v0.0.0-20260311193753-579e4da9a98c/go.mod h1:TpUTTEp9frx7rTdLpC9gFG9kdI7zVLFTFFlqaH2Cncw=
+golang.org/x/telemetry v0.0.0-20260409153401-be6f6cb8b1fa/go.mod h1:kHjTxDEnAu6/Nl9lDkzjWpR+bmKfxeiRuSDlsMb70gE=
+golang.org/x/telemetry v0.0.0-20260508192327-42602be52be6/go.mod h1:Eqhaxk/wZsWEH8CRxLwj6xzEJbz7k1EFGqx7nyCoabE=
+golang.org/x/telemetry v0.0.0-20260625142307-59b4966ccb57/go.mod h1:3AWMyWHS+caVoiEXpiq6+tzKA40J4vQT3MYr80ZtQpc=
+golang.org/x/telemetry v0.0.0-20260708182218-49f421fb7959/go.mod h1:LV7u5Oco+Z/g6XI7PqN+EUUUGGkEcmB1uj2ceI0fOVg=
+golang.org/x/telemetry v0.0.0-20260811182544-a038080d80e5/go.mod h1:LVehoXe41cL5SCVQilsV7Gg6BNG+Js6P9PhSbYTIUkQ=
+golang.org/x/telemetry v0.0.0-20260924152758-ed294f943157/go.mod h1:i+ivNqjDnTF3WTElsdk5g9V5DTSBYgdNo7xTU9SDwYA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc=
-golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA=
-golang.org/x/term v0.4.0/go.mod h1:9P2UbLfCdcvo3p/nzKvsmas4TnlujnuoV9hGgYzW1lQ=
-golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
-golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
-golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
-golang.org/x/term v0.10.0/go.mod h1:lpqdcUyK/oCiQxvxVrppt5ggO2KCZ5QblwqPnfZ6d5o=
-golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU=
-golang.org/x/term v0.12.0/go.mod h1:owVbMEjm3cBLCHdkQu9b1opXd4ETQWc3BhuQGKgXgvU=
-golang.org/x/term v0.13.0/go.mod h1:LTmsnFJwVN6bCy1rVCoS+qHT1HhALEFxKncY3WNNh4U=
-golang.org/x/term v0.15.0/go.mod h1:BDl952bC7+uMoWR75FIrCDx79TPU9oHkTZ9yRbYOrX0=
-golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY=
-golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
-golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58=
-golang.org/x/term v0.19.0/go.mod h1:2CuTdWZ7KHSQwUzKva0cbMg6q2DMI3Mmxp+gKJbskEk=
-golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
-golang.org/x/term v0.21.0/go.mod h1:ooXLefLobQVslOqselCNF4SxFAaoS6KujMbsGzSDmX0=
-golang.org/x/term v0.22.0/go.mod h1:F3qCibpT5AMpCRfhfT53vVJwhLtIVHhB9XDjfFvnMI4=
-golang.org/x/term v0.23.0/go.mod h1:DgV24QBUrK6jhZXl+20l6UWznPlwAHm1Q1mGHtydmSk=
-golang.org/x/term v0.25.0/go.mod h1:RPyXicDX+6vLxogjjRxjgD2TKtmAO6NZBsBRfrOLu7M=
-golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
-golang.org/x/term v0.29.0/go.mod h1:6bl4lRlvVuDgSf3179VpIxBF0o10JUpXWOnI7nErv7s=
-golang.org/x/term v0.30.0/go.mod h1:NYYFdzHoI5wRh/h5tDMdMqCqPJZEuNqVR5xJLd/n67g=
 golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
-golang.org/x/term v0.33.0/go.mod h1:s18+ql9tYWp1IfpV9DmCtQDDSRBUjKaw9M1eAv5UeF0=
-golang.org/x/term v0.34.0/go.mod h1:5jC53AEywhIVebHgPVeg0mj8OD3VO9OzclacVrqpaAw=
-golang.org/x/term v0.35.0/go.mod h1:TPGtkTLesOwf2DE8CgVYiZinHAOuy5AYUYT1lENIZnA=
-golang.org/x/term v0.36.0/go.mod h1:Qu394IJq6V6dCBRgwqshf3mPF85AqzYEzofzRdZkWss=
 golang.org/x/term v0.37.0/go.mod h1:5pB4lxRNYYVZuTLmy8oR2BH8dflOR+IbTYFD8fi3254=
-golang.org/x/term v0.46.0 h1:3+OXuTbaKDgwk8jTi3aSLHRlmWqHEUDUtxnbFigO4YE=
-golang.org/x/term v0.46.0/go.mod h1:+K02xbkittuwc0Am4abfA3Fc+XRGXkvBXNO88NCXPoc=
+golang.org/x/term v0.47.0 h1:cpyOwQkr2Nzxe2p6KnrTG7Ei2wtzjsuSjhpXXepZ/BM=
+golang.org/x/term v0.47.0/go.mod h1:efAfAuG6RKABvg1ArGebRkvX6LXul14SM67o2e4mUCY=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
@@ -770,15 +692,10 @@
 golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
 golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
 golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
-golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
-golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=
-golang.org/x/text v0.27.0/go.mod h1:1D28KMCvyooCX9hBiosv5Tz/+YLxj0j7XhWjpSUF7CU=
 golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
-golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4=
-golang.org/x/text v0.30.0/go.mod h1:yDdHFIX9t+tORqspjENWgzaCVXgk0yYnYuSZ8UzzBVM=
 golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=
-golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI=
-golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E=
+golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc=
+golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s=
 golang.org/x/time v0.0.0-20200416051211-89c76fbcd5d1/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.9.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
 golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
@@ -813,15 +730,24 @@
 golang.org/x/tools v0.26.0/go.mod h1:TPVVj70c7JJ3WCazhD8OdXcZg/og+b9+tH/KxylGwH0=
 golang.org/x/tools v0.28.0/go.mod h1:dcIOrVd3mfQKTgrDVQHqCPMWy6lnhfhtX3hLXYVLfRw=
 golang.org/x/tools v0.30.0/go.mod h1:c347cR/OJfw5TI+GfX7RUPNMdDRRbjvYTS0jPyvsVtY=
-golang.org/x/tools v0.33.0/go.mod h1:CIJMaWEY88juyUfo7UbgPqbC8rU2OqfAV1h2Qp0oMYI=
 golang.org/x/tools v0.34.0/go.mod h1:pAP9OwEaY1CAW3HOmg3hLZC5Z0CCmzjAF2UQMSqNARg=
 golang.org/x/tools v0.34.1-0.20250613162507-3f93fece84c7/go.mod h1:pAP9OwEaY1CAW3HOmg3hLZC5Z0CCmzjAF2UQMSqNARg=
 golang.org/x/tools v0.35.0/go.mod h1:NKdj5HkL/73byiZSJjqJgKn3ep7KjFkBOkR/Hps3VPw=
 golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s=
 golang.org/x/tools v0.37.0/go.mod h1:MBN5QPQtLMHVdvsbtarmTNukZDdgwdwlO5qGacAzF0w=
 golang.org/x/tools v0.38.0/go.mod h1:yEsQ/d/YK8cjh0L6rZlY8tgtlKiBNTL14pGDJPJpYQs=
-golang.org/x/tools v0.49.0 h1:3NI7VXzL9+1WZD52Dx2ttoPwD5DWrFGpl9mFZDlmisI=
+golang.org/x/tools v0.39.0/go.mod h1:JnefbkDPyD8UU2kI5fuf8ZX4/yUeh9W877ZeBONxUqQ=
+golang.org/x/tools v0.40.0/go.mod h1:Ik/tzLRlbscWpqqMRjyWYDisX8bG13FrdXp3o4Sr9lc=
+golang.org/x/tools v0.41.0/go.mod h1:XSY6eDqxVNiYgezAVqqCeihT4j1U2CCsqvH3WhQpnlg=
+golang.org/x/tools v0.42.0/go.mod h1:Ma6lCIwGZvHK6XtgbswSoWroEkhugApmsXyrUmBhfr0=
+golang.org/x/tools v0.43.0/go.mod h1:uHkMso649BX2cZK6+RpuIPXS3ho2hZo4FVwfoy1vIk0=
+golang.org/x/tools v0.44.0/go.mod h1:KA0AfVErSdxRZIsOVipbv3rQhVXTnlU6UhKxHd1seDI=
+golang.org/x/tools v0.45.0/go.mod h1:LuUGqqaXcXMEFEruIVJVm5mgDD8vww/z/SR1gQ4uE/0=
+golang.org/x/tools v0.47.0/go.mod h1:dFHnyTvFWY212G+h7ZY4Vsp/K3U4/7W9TyVaAul8uCA=
+golang.org/x/tools v0.48.0/go.mod h1:08xX0orndb/F7jJxGDicx061tyd5pcMto75YMAXr6lk=
 golang.org/x/tools v0.49.0/go.mod h1:SJNXV9DBKT0UbdttsQjbfJlAE/q+y36++zo3uL3N0Oo=
+golang.org/x/tools v0.51.0 h1:k4Xc/1Om9jwkBJBo4NVLMSARBoWtK10mx+W5BnXCeAI=
+golang.org/x/tools v0.51.0/go.mod h1:9eEncMayCV6zRMGhR5eZEC2iBx98qWcF1HZ9Z7wJOoA=
 golang.org/x/tools/go/expect v0.1.0-deprecated/go.mod h1:eihoPOH+FgIqa3FpoTwguz/bVUSGBlGQU67vpBeOrBY=
 golang.org/x/tools/go/expect v0.1.1-deprecated/go.mod h1:eihoPOH+FgIqa3FpoTwguz/bVUSGBlGQU67vpBeOrBY=
 golang.org/x/tools/go/packages/packagestest v0.1.1-deprecated/go.mod h1:RVAQXBGNv1ib0J382/DPCRS/BPnsGebyM1Gj5VSDpG8=
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/crypto/chacha20/chacha_loong64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/crypto/chacha20/chacha_loong64.go
--- a/vendor/golang.org/x/crypto/chacha20/chacha_loong64.go	1970-01-01 00:00:00.000000000 +0000
+++ b/vendor/golang.org/x/crypto/chacha20/chacha_loong64.go	2026-10-28 08:23:38.000153076 +0000
@@ -0,0 +1,22 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build gc && !purego
+
+package chacha20
+
+import "golang.org/x/sys/cpu"
+
+const bufSize = 256
+
+//go:noescape
+func xorKeyStreamVX(dst, src []byte, key *[8]uint32, nonce *[3]uint32, counter *uint32)
+
+func (c *Cipher) xorKeyStreamBlocks(dst, src []byte) {
+	if cpu.Loong64.HasLSX {
+		xorKeyStreamVX(dst, src, &c.key, &c.nonce, &c.counter)
+	} else {
+		c.xorKeyStreamBlocksGeneric(dst, src)
+	}
+}
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/crypto/chacha20/chacha_loong64.s /work/src/azuredisk-csi-driver/vendor/golang.org/x/crypto/chacha20/chacha_loong64.s
--- a/vendor/golang.org/x/crypto/chacha20/chacha_loong64.s	1970-01-01 00:00:00.000000000 +0000
+++ b/vendor/golang.org/x/crypto/chacha20/chacha_loong64.s	2026-10-28 08:23:38.000153076 +0000
@@ -0,0 +1,342 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// derived from chacha_arm64.s
+
+//go:build gc && !purego
+
+#include "textflag.h"
+
+DATA	·constants+0x00(SB)/4, $0x61707865
+DATA	·constants+0x04(SB)/4, $0x3320646e
+DATA	·constants+0x08(SB)/4, $0x79622d32
+DATA	·constants+0x0c(SB)/4, $0x6b206574
+GLOBL	·constants(SB), NOPTR|RODATA, $32
+
+DATA	·incRotMatrix+0x00(SB)/4, $0x00000000
+DATA	·incRotMatrix+0x04(SB)/4, $0x00000001
+DATA	·incRotMatrix+0x08(SB)/4, $0x00000002
+DATA	·incRotMatrix+0x0c(SB)/4, $0x00000003
+GLOBL	·incRotMatrix(SB), NOPTR|RODATA, $32
+
+#define NUM_ROUNDS 10
+
+// func xorKeyStreamVX(dst, src []byte, key *[8]uint32, nonce *[3]uint32, counter *uint32)
+TEXT ·xorKeyStreamVX(SB), NOSPLIT, $0
+	MOVV	dst+0(FP), R4
+	MOVV	src+24(FP), R5
+	MOVV	src_len+32(FP), R6
+	MOVV	key+48(FP), R7
+	MOVV	nonce+56(FP), R8
+	MOVV	counter+64(FP), R9
+
+	MOVV	$·constants(SB), R10
+	MOVV	$·incRotMatrix(SB), R11
+
+	MOVW	(R9), R12
+
+loop:
+	MOVV	$NUM_ROUNDS, R15
+	// load 4-32bit data from incRotMatrix added to counter
+	VMOVQ	(R11), V30
+
+	// load contants
+	VMOVQ	(R10), V0.W4
+	VMOVQ	4(R10), V1.W4
+	VMOVQ	8(R10), V2.W4
+	VMOVQ	12(R10), V3.W4
+
+	// load keys
+	VMOVQ	(R7), V4.W4
+	VMOVQ	4(R7), V5.W4
+	VMOVQ	8(R7), V6.W4
+	VMOVQ	12(R7), V7.W4
+	VMOVQ	16(R7), V8.W4
+	VMOVQ	20(R7), V9.W4
+	VMOVQ	24(R7), V10.W4
+	VMOVQ	28(R7), V11.W4
+
+	// load counter + nonce
+	VMOVQ	(R9), V12.W4
+
+	VMOVQ	(R8), V13.W4
+	VMOVQ	4(R8), V14.W4
+	VMOVQ	8(R8), V15.W4
+
+	// update counter
+	VADDW	V30, V12, V12
+
+chacha:
+	// V0..V3 += V4..V7
+	// V12..V15 <<<= ((V12..V15 XOR V0..V3), 16)
+	VADDW	V0, V4, V0
+	VADDW	V1, V5, V1
+	VADDW	V2, V6, V2
+	VADDW	V3, V7, V3
+	VXORV	V12, V0, V12
+	VXORV	V13, V1, V13
+	VXORV	V14, V2, V14
+	VXORV	V15, V3, V15
+	VROTRW	$16, V12, V12
+	VROTRW	$16, V13, V13
+	VROTRW	$16, V14, V14
+	VROTRW	$16, V15, V15
+
+	// V8..V11 += V12..V15
+	// V4..V7 <<<= ((V4..V7 XOR V8..V11), 12)
+	VADDW	V8, V12, V8
+	VADDW	V9, V13, V9
+	VADDW	V10, V14, V10
+	VADDW	V11, V15, V11
+	VXORV	V4, V8, V4
+	VXORV	V5, V9, V5
+	VXORV	V6, V10, V6
+	VXORV	V7, V11, V7
+	VROTRW	$20, V4, V4
+	VROTRW	$20, V5, V5
+	VROTRW	$20, V6, V6
+	VROTRW	$20, V7, V7
+
+	// V0..V3 += V4..V7
+	// V12..V15 <<<= ((V12..V15 XOR V0..V3), 8)
+	VADDW	V0, V4, V0
+	VADDW	V1, V5, V1
+	VADDW	V2, V6, V2
+	VADDW	V3, V7, V3
+	VXORV	V12, V0, V12
+	VXORV	V13, V1, V13
+	VXORV	V14, V2, V14
+	VXORV	V15, V3, V15
+	VROTRW	$24, V12, V12
+	VROTRW	$24, V13, V13
+	VROTRW	$24, V14, V14
+	VROTRW	$24, V15, V15
+
+	// V8..V11 += V12..V15
+	// V4..V7 <<<= ((V4..V7 XOR V8..V11), 7)
+	VADDW	V12, V8, V8
+	VADDW	V13, V9, V9
+	VADDW	V14, V10, V10
+	VADDW	V15, V11, V11
+	VXORV	V4, V8, V4
+	VXORV	V5, V9, V5
+	VXORV	V6, V10, V6
+	VXORV	V7, V11, V7
+	VROTRW	$25, V4, V4
+	VROTRW	$25, V5, V5
+	VROTRW	$25, V6, V6
+	VROTRW	$25, V7, V7
+
+	// V0..V3 += V5..V7, V4
+	// V15,V12-V14 <<<= ((V15,V12-V14 XOR V0..V3), 16)
+	VADDW	V0, V5, V0
+	VADDW	V1, V6, V1
+	VADDW	V2, V7, V2
+	VADDW	V3, V4, V3
+	VXORV	V15, V0, V15
+	VXORV	V12, V1, V12
+	VXORV	V13, V2, V13
+	VXORV	V14, V3, V14
+	VROTRW	$16, V15, V15
+	VROTRW	$16, V12, V12
+	VROTRW	$16, V13, V13
+	VROTRW	$16, V14, V14
+
+	// V10,V11,V8,V9 += V15,V12,V13,V14
+	// V5,V6,V7,V4 <<<= ((V5,V6,V7,V4 XOR V10,V11,V8,V9), 12)
+	VADDW	V10, V15, V10
+	VADDW	V11, V12, V11
+	VADDW	V8, V13, V8
+	VADDW	V9, V14, V9
+	VXORV	V5, V10, V5
+	VXORV	V6, V11, V6
+	VXORV	V7, V8, V7
+	VXORV	V4, V9, V4
+	VROTRW	$20, V5, V5
+	VROTRW	$20, V6, V6
+	VROTRW	$20, V7, V7
+	VROTRW	$20, V4, V4
+
+	// V0..V3 += V5..V7, V4
+	// V15,V12-V14 <<<= ((V15,V12-V14 XOR V0..V3), 8)
+	VADDW	V5, V0, V0
+	VADDW	V6, V1, V1
+	VADDW	V7, V2, V2
+	VADDW	V4, V3, V3
+	VXORV	V15, V0, V15
+	VXORV	V12, V1, V12
+	VXORV	V13, V2, V13
+	VXORV	V14, V3, V14
+	VROTRW	$24, V15, V15
+	VROTRW	$24, V12, V12
+	VROTRW	$24, V13, V13
+	VROTRW	$24, V14, V14
+
+	// V10,V11,V8,V9 += V15,V12,V13,V14
+	// V5,V6,V7,V4 <<<= ((V5,V6,V7,V4 XOR V10,V11,V8,V9), 7)
+	VADDW	V15, V10, V10
+	VADDW	V12, V11, V11
+	VADDW	V13, V8, V8
+	VADDW	V14, V9, V9
+	VXORV	V5, V10, V5
+	VXORV	V6, V11, V6
+	VXORV	V7, V8, V7
+	VXORV	V4, V9, V4
+	VROTRW	$25, V5, V5
+	VROTRW	$25, V6, V6
+	VROTRW	$25, V7, V7
+	VROTRW	$25, V4, V4
+
+	SUBV	$1, R15
+	BNE	R15, R0, chacha
+
+	// load origin contants
+	VMOVQ	(R10), V16.W4
+	VMOVQ	4(R10), V17.W4
+	VMOVQ	8(R10), V18.W4
+	VMOVQ	12(R10), V19.W4
+
+	// load origin keys
+	VMOVQ	(R7), V20.W4
+	VMOVQ	4(R7), V21.W4
+	VMOVQ	8(R7), V22.W4
+	VMOVQ	12(R7), V23.W4
+	VMOVQ	16(R7), V24.W4
+	VMOVQ	20(R7), V25.W4
+	VMOVQ	24(R7), V26.W4
+	VMOVQ	28(R7), V27.W4
+
+	// add back the initial state to generate the key stream
+	VADDW	V30, V12, V12	// update counter in advance to prevent V30 from being overwritten
+	VADDW	V16, V0, V0
+	VADDW	V17, V1, V1
+	VADDW	V18, V2, V2
+	VADDW	V19, V3, V3
+
+	// load origin counter + nonce
+	VMOVQ	(R9), V28.W4
+	VMOVQ	(R8), V29.W4
+	VMOVQ	4(R8), V30.W4
+	VMOVQ	8(R8), V31.W4
+
+	VADDW	V20, V4, V4
+	VADDW	V21, V5, V5
+	VADDW	V22, V6, V6
+	VADDW	V23, V7, V7
+	VADDW	V24, V8, V8
+	VADDW	V25, V9, V9
+	VADDW	V26, V10, V10
+	VADDW	V27, V11, V11
+	VADDW	V28, V12, V12
+	VADDW	V29, V13, V13
+	VADDW	V30, V14, V14
+	VADDW	V31, V15, V15
+
+	// shuffle
+	VILVLW	V0, V1, V16
+	VILVHW	V0, V1, V17
+	VILVLW	V2, V3, V18
+	VILVHW	V2, V3, V19
+	VILVLW	V4, V5 ,V20
+	VILVHW	V4, V5, V21
+	VILVLW	V6, V7, V22
+	VILVHW	V6, V7, V23
+	VILVLW	V8, V9, V24
+	VILVHW	V8, V9, V25
+	VILVLW	V10, V11, V26
+	VILVHW	V10, V11, V27
+	VILVLW	V12, V13, V28
+	VILVHW	V12, V13, V29
+	VILVLW	V14, V15, V30
+	VILVHW	V14, V15, V31
+	VILVLV	V16, V18, V0
+	VILVHV	V16, V18, V4
+	VILVLV	V17, V19, V8
+	VILVHV	V17, V19, V12
+
+	// load src data from R5
+	VMOVQ	0(R5), V16
+	VMOVQ	16(R5), V17
+	VMOVQ	32(R5), V18
+	VMOVQ	48(R5), V19
+
+	VILVLV	V20, V22, V1
+	VILVHV	V20, V22, V5
+	VILVLV	V21, V23, V9
+	VILVHV	V21, V23, V13
+
+	VMOVQ	64(R5), V20
+	VMOVQ	80(R5), V21
+	VMOVQ	96(R5), V22
+	VMOVQ	112(R5), V23
+
+	VILVLV	V24, V26, V2
+	VILVHV	V24, V26, V6
+	VILVLV	V25, V27, V10
+	VILVHV	V25, V27, V14
+
+	VMOVQ	128(R5), V24
+	VMOVQ	144(R5), V25
+	VMOVQ	160(R5), V26
+	VMOVQ	176(R5), V27
+
+	VILVLV	V28, V30, V3
+	VILVHV	V28, V30, V7
+	VILVLV	V29, V31, V11
+	VILVHV	V29, V31, V15
+
+	VMOVQ	192(R5), V28
+	VMOVQ	208(R5), V29
+	VMOVQ	224(R5), V30
+	VMOVQ	240(R5), V31
+
+	VXORV	V0, V16, V16
+	VXORV	V1, V17, V17
+	VXORV	V2, V18, V18
+	VXORV	V3, V19, V19
+
+	VMOVQ	V16, 0(R4)
+	VMOVQ	V17, 16(R4)
+	VMOVQ	V18, 32(R4)
+	VMOVQ	V19, 48(R4)
+
+	VXORV	V4, V20, V20
+	VXORV	V5, V21, V21
+	VXORV	V6, V22, V22
+	VXORV	V7, V23, V23
+
+	VMOVQ	V20, 64(R4)
+	VMOVQ	V21, 80(R4)
+	VMOVQ	V22, 96(R4)
+	VMOVQ	V23, 112(R4)
+
+	VXORV	V8, V24, V24
+	VXORV	V9, V25, V25
+	VXORV	V10, V26, V26
+	VXORV	V11, V27, V27
+
+	VMOVQ	V24, 128(R4)
+	VMOVQ	V25, 144(R4)
+	VMOVQ	V26, 160(R4)
+	VMOVQ	V27, 176(R4)
+
+	VXORV	V12, V28, V28
+	VXORV	V13, V29, V29
+	VXORV	V14, V30, V30
+	VXORV	V15, V31, V31
+
+	VMOVQ	V28, 192(R4)
+	VMOVQ	V29, 208(R4)
+	VMOVQ	V30, 224(R4)
+	VMOVQ	V31, 240(R4)
+
+	ADD	$4, R12, R12
+	MOVW	R12, (R9) // update counter
+
+	ADDV	$256, R4, R4
+	ADDV	$256, R5, R5
+	SUBV    $256, R6, R6
+	BNE     R6, R0, loop
+
+	RET
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/crypto/chacha20/chacha_noasm.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/crypto/chacha20/chacha_noasm.go
--- a/vendor/golang.org/x/crypto/chacha20/chacha_noasm.go	2026-10-28 08:22:44.832102895 +0000
+++ b/vendor/golang.org/x/crypto/chacha20/chacha_noasm.go	2026-10-28 08:23:38.000153076 +0000
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (!arm64 && !s390x && !ppc64 && !ppc64le) || !gc || purego
+//go:build (!arm64 && !loong64 && !s390x && !ppc64 && !ppc64le) || !gc || purego
 
 package chacha20
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/crypto/ssh/certs.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/crypto/ssh/certs.go
--- a/vendor/golang.org/x/crypto/ssh/certs.go	2026-10-28 08:22:44.832102895 +0000
+++ b/vendor/golang.org/x/crypto/ssh/certs.go	2026-10-28 08:23:38.000153076 +0000
@@ -35,6 +35,15 @@
 	CertAlgoED25519v01     = "ssh-ed25519-cert-v01@openssh.com"
 	CertAlgoSKED25519v01   = "sk-ssh-ed25519-cert-v01@openssh.com"
 
+	// CertAlgoMLDSA44v01Go, CertAlgoMLDSA65v01Go and CertAlgoMLDSA87v01Go
+	// are certificate algorithms based on ML-DSA. No specification defines
+	// them, so these are vendor names as per RFC 4251, Section 4.2. The
+	// format is that of [SSH-CERTS], with the public key encoded as in
+	// [SSH-MLDSA], Section 4.
+	CertAlgoMLDSA44v01Go = "ssh-mldsa-44-cert-v01@golang.org"
+	CertAlgoMLDSA65v01Go = "ssh-mldsa-65-cert-v01@golang.org"
+	CertAlgoMLDSA87v01Go = "ssh-mldsa-87-cert-v01@golang.org"
+
 	// CertAlgoRSASHA256v01 and CertAlgoRSASHA512v01 can't appear as a
 	// Certificate.Type (or PublicKey.Type), but only in
 	// ClientConfig.HostKeyAlgorithms.
@@ -525,6 +534,9 @@
 	CertAlgoSKECDSA256v01:  KeyAlgoSKECDSA256,
 	CertAlgoED25519v01:     KeyAlgoED25519,
 	CertAlgoSKED25519v01:   KeyAlgoSKED25519,
+	CertAlgoMLDSA44v01Go:   KeyAlgoMLDSA44,
+	CertAlgoMLDSA65v01Go:   KeyAlgoMLDSA65,
+	CertAlgoMLDSA87v01Go:   KeyAlgoMLDSA87,
 }
 
 // underlyingAlgo returns the signature algorithm associated with algo (which is
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/crypto/ssh/cipher.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/crypto/ssh/cipher.go
--- a/vendor/golang.org/x/crypto/ssh/cipher.go	2026-10-28 08:22:44.836102900 +0000
+++ b/vendor/golang.org/x/crypto/ssh/cipher.go	2026-10-28 08:23:38.000153076 +0000
@@ -414,10 +414,34 @@
 	return plain, nil
 }
 
-// cbcCipher implements aes128-cbc cipher defined in RFC 4253 section 6.1
+// cbcCipher implements the CBC ciphers defined in RFC 4253 section 6.1, in
+// MAC-then-encrypt mode and, for the *-etm@openssh.com MACs, in the
+// encrypt-then-MAC mode defined in [PROTOCOL], section 1.5.
+//
+//	0               4                prefixLen                   macStart
+//	|               |                |                           |
+//	+---------------+----------------+---------+-----------------+-----------+
+//	| packet_length | padding_length | payload | random padding  |    mac    |
+//	+---------------+----------------+---------+-----------------+-----------+
+//	                |<--------- length = packet_length --------->|< macSize >|
+//	                                           |< paddingLength >|
+//	|<-------------------------- entirePacketSize -------------------------->|
+//
+//	MAC-then-encrypt (encStart = 0)
+//	|<----------------------- encLength ------------------------>|
+//	|<-------------- MAC'd (seqNum || plaintext) --------------->|
+//
+//	encrypt-then-MAC (encStart = 4)
+//	                |<--------------- encLength ---------------->|
+//	|<-------------- MAC'd (seqNum || ciphertext) -------------->|
+//
+// encLength is always a multiple of effectiveBlockSize, and in ETM mode the
+// packet_length field is not part of it. The padding is only trustworthy once
+// the MAC has been verified.
 type cbcCipher struct {
 	mac       hash.Hash
 	macSize   uint32
+	etm       bool
 	decrypter cipher.BlockMode
 	encrypter cipher.BlockMode
 
@@ -431,16 +455,20 @@
 	oracleCamouflage uint32
 }
 
-func newCBCCipher(c cipher.Block, key, iv, macKey []byte, algs DirectionAlgorithms) (packetCipher, error) {
+func newCBCCipher(c cipher.Block, _, iv, macKey []byte, algs DirectionAlgorithms) (packetCipher, error) {
+	macMode := macModes[algs.MAC]
+	if macMode == nil {
+		return nil, fmt.Errorf("ssh: unsupported MAC %v", algs.MAC)
+	}
+	mac := macMode.new(macKey)
 	cbc := &cbcCipher{
-		mac:        macModes[algs.MAC].new(macKey),
+		mac:        mac,
+		macSize:    uint32(mac.Size()),
+		etm:        macMode.etm,
 		decrypter:  cipher.NewCBCDecrypter(c, iv),
 		encrypter:  cipher.NewCBCEncrypter(c, iv),
 		packetData: make([]byte, 1024),
 	}
-	if cbc.mac != nil {
-		cbc.macSize = uint32(cbc.mac.Size())
-	}
 
 	return cbc, nil
 }
@@ -473,13 +501,6 @@
 	return cbc, nil
 }
 
-func maxUInt32(a, b int) uint32 {
-	if a > b {
-		return uint32(a)
-	}
-	return uint32(b)
-}
-
 const (
 	cbcMinPacketSizeMultiple = 8
 	cbcMinPacketSize         = 16
@@ -493,25 +514,38 @@
 
 func (c *cbcCipher) readCipherPacket(seqNum uint32, r io.Reader) ([]byte, error) {
 	p, err := c.readCipherPacketLeaky(seqNum, r)
-	if err != nil {
-		if _, ok := err.(cbcError); ok {
-			// Verification error: read a fixed amount of
-			// data, to make distinguishing between
-			// failing MAC and failing length check more
-			// difficult.
-			io.CopyN(io.Discard, r, int64(c.oracleCamouflage))
-		}
+	if _, ok := err.(cbcError); ok {
+		// Verification error: read a fixed amount of
+		// data, to make distinguishing between
+		// failing MAC and failing length check more
+		// difficult.
+		io.CopyN(io.Discard, r, int64(c.oracleCamouflage))
 	}
 	return p, err
 }
 
 func (c *cbcCipher) readCipherPacketLeaky(seqNum uint32, r io.Reader) ([]byte, error) {
 	blockSize := c.decrypter.BlockSize()
+	// The encrypted portion of a packet is a multiple of the cipher block size
+	// or 8, whichever is larger.
+	effectiveBlockSize := uint32(max(cbcMinPacketSizeMultiple, blockSize))
+	encStart := uint32(0)
+	// A packet is at least 16 bytes, or the cipher block size if larger. This does
+	// not apply to EtM (but the encrypted length still can't be zero).
+	minEncLength := uint32(max(cbcMinPacketSize, blockSize))
+	// For EtM MACs the packet length is transmitted in the clear and is not part
+	// of the encrypted data, which starts after it.
+	if c.etm {
+		encStart = 4
+		minEncLength = effectiveBlockSize
+	}
 
 	// Read the header, which will include some of the subsequent data in the
-	// case of block ciphers - this is copied back to the payload later.
-	// How many bytes of payload/padding will be read with this first read.
-	firstBlockLength := uint32((prefixLen + blockSize - 1) / blockSize * blockSize)
+	// case of block ciphers - this is copied back to the payload later. The
+	// rounding up to the block size covers at least prefixLen bytes, so the
+	// padding length is always within firstBlock.
+	headerEncLength := prefixLen - encStart
+	firstBlockLength := encStart + (headerEncLength+uint32(blockSize)-1)/uint32(blockSize)*uint32(blockSize)
 	firstBlock := c.packetData[:firstBlockLength]
 	if _, err := io.ReadFull(r, firstBlock); err != nil {
 		return nil, err
@@ -519,30 +553,49 @@
 
 	c.oracleCamouflage = maxPacket + 4 + c.macSize - firstBlockLength
 
-	c.decrypter.CryptBlocks(firstBlock, firstBlock)
-	length := binary.BigEndian.Uint32(firstBlock[:4])
+	c.mac.Reset()
+	binary.BigEndian.PutUint32(c.seqNumBytes[:], seqNum)
+	c.mac.Write(c.seqNumBytes[:])
+
+	var length uint32
+	if c.etm {
+		// For EtM MACs the MAC is computed over the cleartext packet length
+		// followed by the ciphertext, so it is updated before decrypting.
+		length = binary.BigEndian.Uint32(firstBlock[:encStart])
+		c.mac.Write(firstBlock[:encStart])
+		c.mac.Write(firstBlock[encStart:])
+		c.decrypter.CryptBlocks(firstBlock[encStart:], firstBlock[encStart:])
+	} else {
+		c.decrypter.CryptBlocks(firstBlock, firstBlock)
+		length = binary.BigEndian.Uint32(firstBlock[:4])
+	}
+
 	if length > maxPacket {
 		return nil, cbcError("ssh: packet too large")
 	}
-	if length+4 < maxUInt32(cbcMinPacketSize, blockSize) {
-		// The minimum size of a packet is 16 (or the cipher block size, whichever
-		// is larger) bytes.
+	// Length of the encrypted portion of the packet, which includes the packet
+	// length field only for non-EtM MACs.
+	encLength := 4 + length - encStart
+	if encLength < minEncLength {
 		return nil, cbcError("ssh: packet too small")
 	}
-	// The length of the packet (including the length field but not the MAC) must
-	// be a multiple of the block size or 8, whichever is larger.
-	if (length+4)%maxUInt32(cbcMinPacketSizeMultiple, blockSize) != 0 {
+	if encLength%effectiveBlockSize != 0 {
 		return nil, cbcError("ssh: invalid packet length multiple")
 	}
 
+	// The padding length is part of the encrypted data. For EtM MACs it is not
+	// acted upon before the MAC is verified, otherwise the CBC padding would
+	// still be usable as an oracle, which is what EtM prevents.
 	paddingLength := uint32(firstBlock[4])
-	if paddingLength < cbcMinPaddingSize || length <= paddingLength+1 {
-		return nil, cbcError("ssh: invalid packet length")
+	if !c.etm {
+		if paddingLength < cbcMinPaddingSize || length <= paddingLength+1 {
+			return nil, cbcError("ssh: invalid packet length")
+		}
 	}
 
-	// Positions within the c.packetData buffer:
-	macStart := 4 + length
-	paddingStart := macStart - paddingLength
+	// Positions within the c.packetData buffer: the MAC follows the encrypted
+	// data.
+	macStart := encStart + encLength
 
 	// Entire packet size, starting before length, ending at end of mac.
 	entirePacketSize := macStart + c.macSize
@@ -564,42 +617,58 @@
 	c.oracleCamouflage -= uint32(n)
 
 	remainingCrypted := c.packetData[firstBlockLength:macStart]
+	if c.etm {
+		c.mac.Write(remainingCrypted)
+	}
 	c.decrypter.CryptBlocks(remainingCrypted, remainingCrypted)
 
-	mac := c.packetData[macStart:]
-	if c.mac != nil {
-		c.mac.Reset()
-		binary.BigEndian.PutUint32(c.seqNumBytes[:], seqNum)
-		c.mac.Write(c.seqNumBytes[:])
+	if !c.etm {
 		c.mac.Write(c.packetData[:macStart])
-		c.macResult = c.mac.Sum(c.macResult[:0])
-		if subtle.ConstantTimeCompare(c.macResult, mac) != 1 {
-			return nil, cbcError("ssh: MAC failure")
+	}
+	c.macResult = c.mac.Sum(c.macResult[:0])
+	if subtle.ConstantTimeCompare(c.macResult, c.packetData[macStart:]) != 1 {
+		return nil, cbcError("ssh: MAC failure")
+	}
+
+	if c.etm {
+		if paddingLength < cbcMinPaddingSize || length <= paddingLength+1 {
+			return nil, cbcError("ssh: invalid packet length")
 		}
 	}
 
-	return c.packetData[prefixLen:paddingStart], nil
+	return c.packetData[prefixLen : macStart-paddingLength], nil
 }
 
-func (c *cbcCipher) writeCipherPacket(seqNum uint32, w io.Writer, rand io.Reader, packet []byte) error {
-	effectiveBlockSize := maxUInt32(cbcMinPacketSizeMultiple, c.encrypter.BlockSize())
-
-	// Length of encrypted portion of the packet (header, payload, padding).
-	// Enforce minimum padding and packet size.
-	encLength := maxUInt32(prefixLen+len(packet)+cbcMinPaddingSize, cbcMinPacketSize)
+func (c *cbcCipher) writeCipherPacket(seqNum uint32, w io.Writer, rand io.Reader, payload []byte) error {
+	blockSize := c.encrypter.BlockSize()
+	// The encrypted portion of a packet is a multiple of the cipher block size
+	// or 8, whichever is larger.
+	effectiveBlockSize := uint32(max(cbcMinPacketSizeMultiple, blockSize))
+	// For EtM MACs the packet length is transmitted in the clear and is not part
+	// of the encrypted data, which starts after it.
+	encStart := uint32(0)
+	if c.etm {
+		encStart = 4
+	}
+	// Length of the encrypted portion of the packet (header, payload, padding),
+	// enforcing the minimum padding and the minimum packet size of RFC 4253,
+	// Section 6: 16 bytes, or the cipher block size if larger, excluding the
+	// MAC.
+	encLength := uint32(max(prefixLen-int(encStart)+len(payload)+cbcMinPaddingSize, cbcMinPacketSize-int(encStart)))
 	// Enforce block size.
 	encLength = (encLength + effectiveBlockSize - 1) / effectiveBlockSize * effectiveBlockSize
-
-	length := encLength - 4
-	paddingLength := int(length) - (1 + len(packet))
+	// The packet length field covers the whole packet except the field itself.
+	length := encStart + encLength - 4
+	paddingLength := int(length) - (1 + len(payload))
 
 	// Overall buffer contains: header, payload, padding, mac.
 	// Space for the MAC is reserved in the capacity but not the slice length.
-	bufferSize := encLength + c.macSize
-	if uint32(cap(c.packetData)) < bufferSize {
-		c.packetData = make([]byte, encLength, bufferSize)
+	macStart := encStart + encLength
+	entirePacketSize := macStart + c.macSize
+	if uint32(cap(c.packetData)) < entirePacketSize {
+		c.packetData = make([]byte, macStart, entirePacketSize)
 	} else {
-		c.packetData = c.packetData[:encLength]
+		c.packetData = c.packetData[:macStart]
 	}
 
 	p := c.packetData
@@ -611,24 +680,29 @@
 
 	// Payload.
 	p = p[1:]
-	copy(p, packet)
+	copy(p, payload)
 
 	// Padding.
-	p = p[len(packet):]
+	p = p[len(payload):]
 	if _, err := io.ReadFull(rand, p); err != nil {
 		return err
 	}
 
-	if c.mac != nil {
-		c.mac.Reset()
-		binary.BigEndian.PutUint32(c.seqNumBytes[:], seqNum)
-		c.mac.Write(c.seqNumBytes[:])
+	c.mac.Reset()
+	binary.BigEndian.PutUint32(c.seqNumBytes[:], seqNum)
+	c.mac.Write(c.seqNumBytes[:])
+	if c.etm {
+		// For EtM MACs the MAC is computed over the cleartext packet length
+		// followed by the ciphertext.
+		c.mac.Write(c.packetData[:encStart])
+		c.encrypter.CryptBlocks(c.packetData[encStart:], c.packetData[encStart:])
+		c.mac.Write(c.packetData[encStart:])
+	} else {
 		c.mac.Write(c.packetData)
-		// The MAC is now appended into the capacity reserved for it earlier.
-		c.packetData = c.mac.Sum(c.packetData)
+		c.encrypter.CryptBlocks(c.packetData, c.packetData)
 	}
-
-	c.encrypter.CryptBlocks(c.packetData[:encLength], c.packetData[:encLength])
+	// The MAC is now appended into the capacity reserved for it earlier.
+	c.packetData = c.mac.Sum(c.packetData)
 
 	if _, err := w.Write(c.packetData); err != nil {
 		return err
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/crypto/ssh/common.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/crypto/ssh/common.go
--- a/vendor/golang.org/x/crypto/ssh/common.go	2026-10-28 08:22:44.836102900 +0000
+++ b/vendor/golang.org/x/crypto/ssh/common.go	2026-10-28 08:23:38.000153076 +0000
@@ -258,6 +258,11 @@
 }
 
 func init() {
+	supportedHostKeyAlgos = slices.Concat(supportedHostKeyAlgos, mldsaCertAlgos, mldsaKeyAlgos)
+	defaultHostKeyAlgos = slices.Concat(defaultHostKeyAlgos, mldsaCertAlgos, mldsaKeyAlgos)
+	supportedPubKeyAuthAlgos = slices.Concat(supportedPubKeyAuthAlgos, mldsaKeyAlgos)
+	defaultPubKeyAuthAlgos = slices.Concat(defaultPubKeyAuthAlgos, mldsaKeyAlgos)
+
 	if fips140.Enabled() {
 		defaultHostKeyAlgos = slices.DeleteFunc(defaultHostKeyAlgos, func(algo string) bool {
 			_, err := hashFunc(underlyingAlgo(algo))
@@ -281,6 +286,10 @@
 	case KeyAlgoED25519:
 		// KeyAlgoED25519 doesn't pre-hash.
 		return 0, nil
+	case KeyAlgoMLDSA44, KeyAlgoMLDSA65, KeyAlgoMLDSA87:
+		// ML-DSA doesn't pre-hash. This case is not build tagged, availability
+		// is decided by mldsaKeyAlgos.
+		return 0, nil
 	case KeyAlgoRSA, InsecureKeyAlgoDSA:
 		if fips140.Enabled() {
 			return 0, fmt.Errorf("ssh: hash algorithm for format %q not allowed in FIPS 140 mode", format)
@@ -354,7 +363,13 @@
 		CertAlgoECDSA521v01,
 		CertAlgoSKECDSA256v01,
 		CertAlgoED25519v01,
-		CertAlgoSKED25519v01:
+		CertAlgoSKED25519v01,
+		KeyAlgoMLDSA44,
+		KeyAlgoMLDSA65,
+		KeyAlgoMLDSA87,
+		CertAlgoMLDSA44v01Go,
+		CertAlgoMLDSA65v01Go,
+		CertAlgoMLDSA87v01Go:
 		return sigAlgo
 	default:
 		return ""
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/crypto/ssh/doc.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/crypto/ssh/doc.go
--- a/vendor/golang.org/x/crypto/ssh/doc.go	2026-10-28 08:22:44.836102900 +0000
+++ b/vendor/golang.org/x/crypto/ssh/doc.go	2026-10-28 08:23:38.000153076 +0000
@@ -17,6 +17,7 @@
 	[PROTOCOL.certkeys]: http://cvsweb.openbsd.org/cgi-bin/cvsweb/src/usr.bin/ssh/PROTOCOL.certkeys?rev=HEAD
 	[SSH-PARAMETERS]:    http://www.iana.org/assignments/ssh-parameters/ssh-parameters.xml#ssh-parameters-1
 	[SSH-CERTS]:	https://datatracker.ietf.org/doc/html/draft-miller-ssh-cert-01
+	[SSH-MLDSA]:	https://datatracker.ietf.org/doc/html/draft-sfluhrer-ssh-mldsa-08
 	[FIPS 140-3 mode]: https://go.dev/doc/security/fips140
 
 This package does not fall under the stability promise of the Go language itself,
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/crypto/ssh/keys.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/crypto/ssh/keys.go
--- a/vendor/golang.org/x/crypto/ssh/keys.go	2026-10-28 08:22:44.836102900 +0000
+++ b/vendor/golang.org/x/crypto/ssh/keys.go	2026-10-28 08:23:38.000153076 +0000
@@ -51,6 +51,12 @@
 	KeyAlgoED25519     = "ssh-ed25519"
 	KeyAlgoSKED25519   = "sk-ssh-ed25519@openssh.com"
 
+	// KeyAlgoMLDSA44, KeyAlgoMLDSA65 and KeyAlgoMLDSA87 are the ML-DSA
+	// algorithms of [SSH-MLDSA].
+	KeyAlgoMLDSA44 = "ssh-mldsa-44"
+	KeyAlgoMLDSA65 = "ssh-mldsa-65"
+	KeyAlgoMLDSA87 = "ssh-mldsa-87"
+
 	// KeyAlgoRSASHA256 and KeyAlgoRSASHA512 are only public key algorithms, not
 	// public key formats, so they can't appear as a PublicKey.Type. The
 	// corresponding PublicKey.Type is KeyAlgoRSA. See RFC 8332, Section 2.
@@ -83,7 +89,10 @@
 		return parseED25519(in)
 	case KeyAlgoSKED25519:
 		return parseSKEd25519(in)
-	case CertAlgoRSAv01, InsecureCertAlgoDSAv01, CertAlgoECDSA256v01, CertAlgoECDSA384v01, CertAlgoECDSA521v01, CertAlgoSKECDSA256v01, CertAlgoED25519v01, CertAlgoSKED25519v01:
+	case KeyAlgoMLDSA44, KeyAlgoMLDSA65, KeyAlgoMLDSA87:
+		return parseMLDSA(in, algo)
+	case CertAlgoRSAv01, InsecureCertAlgoDSAv01, CertAlgoECDSA256v01, CertAlgoECDSA384v01, CertAlgoECDSA521v01, CertAlgoSKECDSA256v01, CertAlgoED25519v01, CertAlgoSKED25519v01,
+		CertAlgoMLDSA44v01Go, CertAlgoMLDSA65v01Go, CertAlgoMLDSA87v01Go:
 		cert, err := parseCert(in, certKeyAlgoNames[algo])
 		if err != nil {
 			return nil, nil, err
@@ -98,11 +107,30 @@
 	return nil, nil, fmt.Errorf("ssh: unknown key algorithm: %v", algo)
 }
 
+// trimSpace removes leading and trailing ASCII space and tab.
+func trimSpace(in []byte) []byte {
+	return bytes.Trim(in, " \t")
+}
+
+// asciiFields splits in around each run of ASCII space and tab.
+func asciiFields(in []byte) [][]byte {
+	return bytes.FieldsFunc(in, func(r rune) bool {
+		return r == ' ' || r == '\t'
+	})
+}
+
+// dropCR removes a single trailing carriage return, so that an entry written
+// with CRLF line endings is read like one written with LF endings. A carriage
+// return anywhere else belongs to the field that holds it.
+func dropCR(in []byte) []byte {
+	return bytes.TrimSuffix(in, []byte("\r"))
+}
+
 // parseAuthorizedKey parses a public key in OpenSSH authorized_keys format
 // (see sshd(8) manual page) once the options and key type fields have been
 // removed.
 func parseAuthorizedKey(in []byte) (out PublicKey, comment string, err error) {
-	in = bytes.TrimSpace(in)
+	in = trimSpace(in)
 
 	i := bytes.IndexAny(in, " \t")
 	if i == -1 {
@@ -120,7 +148,7 @@
 	if err != nil {
 		return nil, "", err
 	}
-	comment = string(bytes.TrimSpace(in[i:]))
+	comment = string(trimSpace(in[i:]))
 	return out, comment, nil
 }
 
@@ -149,12 +177,9 @@
 			rest = nil
 		}
 
-		end = bytes.IndexByte(in, '\r')
-		if end != -1 {
-			in = in[:end]
-		}
+		in = dropCR(in)
 
-		in = bytes.TrimSpace(in)
+		in = trimSpace(in)
 		if len(in) == 0 || in[0] == '#' {
 			in = rest
 			continue
@@ -168,8 +193,10 @@
 
 		// Strip out the beginning of the known_host key.
 		// This is either an optional marker or a (set of) hostname(s).
-		keyFields := bytes.Fields(in)
-		if len(keyFields) < 3 || len(keyFields) > 5 {
+		// The comment is not delimited, so there is no upper bound on the
+		// number of fields.
+		keyFields := asciiFields(in)
+		if len(keyFields) < 3 {
 			return "", nil, nil, "", nil, errors.New("ssh: invalid entry in known_hosts data")
 		}
 
@@ -215,12 +242,9 @@
 			rest = nil
 		}
 
-		end = bytes.IndexByte(in, '\r')
-		if end != -1 {
-			in = in[:end]
-		}
+		in = dropCR(in)
 
-		in = bytes.TrimSpace(in)
+		in = trimSpace(in)
 		if len(in) == 0 || in[0] == '#' {
 			in = rest
 			continue
@@ -334,7 +358,8 @@
 }
 
 // MarshalPrivateKey returns a PEM block with the private key serialized in the
-// OpenSSH format.
+// OpenSSH format. ML-DSA keys are not supported, since no OpenSSH format is
+// defined for them: use [x509.MarshalPKCS8PrivateKey] instead.
 func MarshalPrivateKey(key crypto.PrivateKey, comment string) (*pem.Block, error) {
 	return marshalOpenSSHPrivateKey(key, comment, unencryptedOpenSSHMarshaler)
 }
@@ -1173,9 +1198,9 @@
 }
 
 // NewSignerFromKey takes an *rsa.PrivateKey, *dsa.PrivateKey,
-// *ecdsa.PrivateKey or any other crypto.Signer and returns a
-// corresponding Signer instance. ECDSA keys must use P-256, P-384 or
-// P-521. DSA keys must use parameter size L1024N160.
+// *ecdsa.PrivateKey, *mldsa.PrivateKey, or any other crypto.Signer and returns
+// a corresponding Signer instance. ECDSA keys must use P-256, P-384 or P-521.
+// DSA keys must use parameter size L1024N160.
 func NewSignerFromKey(key interface{}) (Signer, error) {
 	switch key := key.(type) {
 	case crypto.Signer:
@@ -1285,8 +1310,8 @@
 }
 
 // NewPublicKey takes an *rsa.PublicKey, *dsa.PublicKey, *ecdsa.PublicKey,
-// or ed25519.PublicKey returns a corresponding PublicKey instance.
-// ECDSA keys must use P-256, P-384 or P-521.
+// ed25519.PublicKey, or an *mldsa.PublicKey, and returns a corresponding
+// PublicKey instance. ECDSA keys must use P-256, P-384 or P-521.
 func NewPublicKey(key interface{}) (PublicKey, error) {
 	switch key := key.(type) {
 	case *rsa.PublicKey:
@@ -1304,7 +1329,13 @@
 		}
 		return ed25519PublicKey(key), nil
 	default:
-		return nil, fmt.Errorf("ssh: unsupported key type %T", key)
+		pub, err := newMLDSAPublicKey(key)
+		if errors.Is(err, errNotMLDSAKey) {
+			return nil, fmt.Errorf("ssh: unsupported key type %T", key)
+		} else if err != nil {
+			return nil, err
+		}
+		return pub, nil
 	}
 }
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/crypto/ssh/mldsa.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/crypto/ssh/mldsa.go
--- a/vendor/golang.org/x/crypto/ssh/mldsa.go	1970-01-01 00:00:00.000000000 +0000
+++ b/vendor/golang.org/x/crypto/ssh/mldsa.go	2026-10-28 08:23:38.004153080 +0000
@@ -0,0 +1,133 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.27 && !fips140v1.0
+
+package ssh
+
+import (
+	"crypto"
+	"crypto/mldsa"
+	"errors"
+	"fmt"
+)
+
+// mldsaKeyAlgos are the ML-DSA public key algorithms implemented by this
+// package.
+var mldsaKeyAlgos = []string{
+	KeyAlgoMLDSA44,
+	KeyAlgoMLDSA65,
+	KeyAlgoMLDSA87,
+}
+
+// mldsaCertAlgos are the certificate algorithms for the keys in mldsaKeyAlgos.
+var mldsaCertAlgos = []string{
+	CertAlgoMLDSA44v01Go,
+	CertAlgoMLDSA65v01Go,
+	CertAlgoMLDSA87v01Go,
+}
+
+var errNotMLDSAKey = errors.New("ssh: not an ML-DSA key")
+
+// mldsaParameters returns the ML-DSA parameter set for the given public key
+// algorithm name.
+func mldsaParameters(algo string) (mldsa.Parameters, error) {
+	switch algo {
+	case KeyAlgoMLDSA44:
+		return mldsa.MLDSA44(), nil
+	case KeyAlgoMLDSA65:
+		return mldsa.MLDSA65(), nil
+	case KeyAlgoMLDSA87:
+		return mldsa.MLDSA87(), nil
+	default:
+		return mldsa.Parameters{}, fmt.Errorf("ssh: not an ML-DSA algorithm: %q", algo)
+	}
+}
+
+// mldsaKeyAlgo returns the public key algorithm name for the given ML-DSA
+// parameter set.
+func mldsaKeyAlgo(params mldsa.Parameters) string {
+	switch params {
+	case mldsa.MLDSA44():
+		return KeyAlgoMLDSA44
+	case mldsa.MLDSA65():
+		return KeyAlgoMLDSA65
+	case mldsa.MLDSA87():
+		return KeyAlgoMLDSA87
+	default:
+		panic("ssh: internal error: unknown ML-DSA parameter set: " + params.String())
+	}
+}
+
+// mldsaPublicKey implements PublicKey for the ML-DSA algorithms of [SSH-MLDSA].
+type mldsaPublicKey struct {
+	key *mldsa.PublicKey
+}
+
+func (k *mldsaPublicKey) Type() string {
+	return mldsaKeyAlgo(k.key.Parameters())
+}
+
+func parseMLDSA(in []byte, algo string) (out PublicKey, rest []byte, err error) {
+	params, err := mldsaParameters(algo)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var w struct {
+		KeyBytes []byte
+		Rest     []byte `ssh:"rest"`
+	}
+
+	if err := Unmarshal(in, &w); err != nil {
+		return nil, nil, err
+	}
+
+	key, err := mldsa.NewPublicKey(params, w.KeyBytes)
+	if err != nil {
+		return nil, nil, fmt.Errorf("ssh: invalid %s public key: %v", params, err)
+	}
+
+	return &mldsaPublicKey{key: key}, w.Rest, nil
+}
+
+func (k *mldsaPublicKey) Marshal() []byte {
+	w := struct {
+		Name     string
+		KeyBytes []byte
+	}{
+		k.Type(),
+		k.key.Bytes(),
+	}
+	return Marshal(&w)
+}
+
+func (k *mldsaPublicKey) Verify(b []byte, sig *Signature) error {
+	if sig.Format != k.Type() {
+		return fmt.Errorf("ssh: signature type %s for key type %s", sig.Format, k.Type())
+	}
+	// nil options select pure ML-DSA with an empty context, as required by
+	// [SSH-MLDSA], Sections 6 and 8.
+	if err := mldsa.Verify(k.key, b, sig.Blob, nil); err != nil {
+		return errors.New("ssh: signature did not verify")
+	}
+
+	return nil
+}
+
+func (k *mldsaPublicKey) CryptoPublicKey() crypto.PublicKey {
+	return k.key
+}
+
+// newMLDSAPublicKey returns a PublicKey wrapping key.
+func newMLDSAPublicKey(key crypto.PublicKey) (PublicKey, error) {
+	k, ok := key.(*mldsa.PublicKey)
+	if !ok {
+		return nil, errNotMLDSAKey
+	}
+	if k == nil || *k == (mldsa.PublicKey{}) {
+		return nil, errors.New("ssh: invalid ML-DSA public key")
+	}
+	return &mldsaPublicKey{key: k}, nil
+}
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/crypto/ssh/mldsa_unsupported.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/crypto/ssh/mldsa_unsupported.go
--- a/vendor/golang.org/x/crypto/ssh/mldsa_unsupported.go	1970-01-01 00:00:00.000000000 +0000
+++ b/vendor/golang.org/x/crypto/ssh/mldsa_unsupported.go	2026-10-28 08:23:38.004153080 +0000
@@ -0,0 +1,29 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !go1.27 || fips140v1.0
+
+package ssh
+
+import (
+	"crypto"
+	"errors"
+	"fmt"
+)
+
+var mldsaKeyAlgos, mldsaCertAlgos []string
+
+var errMLDSAUnsupported = fmt.Errorf("ssh: ML-DSA is not available in this build: %w",
+	errors.ErrUnsupported)
+
+var errNotMLDSAKey = errors.New("ssh: not an ML-DSA key")
+
+func parseMLDSA(in []byte, algo string) (out PublicKey, rest []byte, err error) {
+	return nil, nil, errMLDSAUnsupported
+}
+
+func newMLDSAPublicKey(key crypto.PublicKey) (PublicKey, error) {
+	// In this version of Go, *mldsa.PublicKey does not exist.
+	return nil, errNotMLDSAKey
+}
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/net/html/parse.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/net/html/parse.go
--- a/vendor/golang.org/x/net/html/parse.go	2026-10-28 08:22:44.836102900 +0000
+++ b/vendor/golang.org/x/net/html/parse.go	2026-10-28 08:23:38.184153279 +0000
@@ -51,6 +51,9 @@
 	// context is the context element when parsing an HTML fragment
 	// (section 12.4).
 	context *Node
+	// textNodes holds buffers for TextNodes that have had multiple text
+	// tokens coalesced into them.
+	textNodes map[*Node][]byte
 }
 
 func (p *parser) top() *Node {
@@ -292,7 +295,7 @@
 		prev = parent.LastChild
 	}
 	if prev != nil && prev.Type == TextNode && n.Type == TextNode {
-		prev.Data += n.Data
+		p.appendText(prev, n.Data)
 		return
 	}
 
@@ -316,7 +319,7 @@
 
 	t := p.top()
 	if n := t.LastChild; n != nil && n.Type == TextNode {
-		n.Data += text
+		p.appendText(n, text)
 		return
 	}
 	p.addChild(&Node{
@@ -325,6 +328,18 @@
 	})
 }
 
+func (p *parser) appendText(n *Node, text string) {
+	if p.textNodes == nil {
+		p.textNodes = make(map[*Node][]byte)
+	}
+	b, ok := p.textNodes[n]
+	if !ok {
+		b = []byte(n.Data)
+		n.Data = ""
+	}
+	p.textNodes[n] = append(b, text...)
+}
+
 func attrCompare(a, b Attribute) int {
 	return cmp.Or(
 		cmp.Compare(a.Namespace, b.Namespace),
@@ -2242,6 +2257,10 @@
 		}
 		p.parseCurrentToken()
 	}
+	for n, b := range p.textNodes {
+		n.Data = string(b)
+	}
+	p.textNodes = nil
 	return nil
 }
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/net/html/render.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/net/html/render.go
--- a/vendor/golang.org/x/net/html/render.go	2026-10-28 08:22:44.836102900 +0000
+++ b/vendor/golang.org/x/net/html/render.go	2026-10-28 08:23:38.184153279 +0000
@@ -246,18 +246,17 @@
 
 	switch n.Data {
 	case "iframe", "noembed", "noframes", "noscript", "plaintext", "script", "style", "xmp":
-		// We need to check if n is a node that was fostered from a HTML namespace
-		// into a non-HTML namespace (in which case, different rules apply to it).
-		// We do this by walking up the tree until we find a node with a non-empty
-		// namespace. If we find such a node, we also have to check if it's
-		// an HTML integration point. If it isn't, then the node we're currently
-		// looking at is foster-parented and we should return false.
-		for p := n.Parent; p != nil; p = p.Parent {
-			if p.Namespace != "" {
-				if !htmlIntegrationPoint(p) {
-					return false
-				}
-				break
+		// n's text is literal only if the parser would keep n in the HTML
+		// namespace when the output is re-parsed. An ancestor may have been
+		// fostered under a foreign element (such as an HTML <mglyph> under
+		// <mtext>) where the parser would instead create it, and its
+		// descendants, in that element's namespace. We walk up the whole tree
+		// and check that every transition out of a non-HTML namespace happens
+		// at an HTML integration point. This is stricter than the parser, so
+		// some text that would be safe literally is escaped.
+		for c, p := n, n.Parent; p != nil; c, p = p, p.Parent {
+			if p.Namespace != "" && p.Namespace != c.Namespace && !htmlIntegrationPoint(p) {
+				return false
 			}
 		}
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/net/http2/flow.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/net/http2/flow.go
--- a/vendor/golang.org/x/net/http2/flow.go	2026-10-28 08:22:44.840102903 +0000
+++ b/vendor/golang.org/x/net/http2/flow.go	2026-10-28 08:23:38.184153279 +0000
@@ -10,6 +10,9 @@
 // flow control window update.
 const inflowMinRefresh = 4 << 10
 
+// maxFlowWindow is the maximum size of a flow control window.
+const maxFlowWindow = (1 << 31) - 1
+
 // inflow accounts for an inbound flow control window.
 // It tracks both the latest window sent to the peer (used for enforcement)
 // and the accumulated unsent window.
@@ -74,47 +77,99 @@
 	return true
 }
 
-// outflow is the outbound flow control window's size.
+// connOutflow is connection-level outbound flow control.
+type connOutflow struct {
+	initial int32 // SETTINGS_INITIAL_WINDOW_SIZE, changes with settings updates
+	n       int32 // connection-level flow control window
+	flowErr bool  // set when a flow control error is encountered
+}
+
+func (f *connOutflow) init() {
+	f.initial = initialWindowSize // initial stream window size
+	f.n = initialWindowSize       // current connection window size
+}
+
+func (f *connOutflow) changeInitialWindowSize(size int64) bool {
+	if size > maxFlowWindow {
+		f.flowErr = true
+		return false
+	}
+	f.initial = int32(size)
+	return true
+}
+
+func (f *connOutflow) add(n int32) bool {
+	sum := int64(f.n) + int64(n)
+	if sum > maxFlowWindow {
+		f.flowErr = true
+		return false
+	}
+	f.n += n
+	return true
+}
+
+// outflow is the stream-level outbound flow control window's size.
 type outflow struct {
 	_ incomparable
 
-	// n is the number of DATA bytes we're allowed to send.
-	// An outflow is kept both on a conn and a per-stream.
-	n int32
+	// delta is the difference between the stream's flow control window and
+	// the connection's initial window size (conn.initial).
+	//
+	// Another view is that delta is the number of flow control bytes provided to this
+	// stream in WINDOW_UPDATE frames, less the number of bytes sent on the stream.
+	delta int32
 
 	// conn points to the shared connection-level outflow that is
-	// shared by all streams on that conn. It is nil for the outflow
-	// that's on the conn directly.
-	conn *outflow
+	// shared by all streams on that conn.
+	conn *connOutflow
 }
 
-func (f *outflow) setConnFlow(cf *outflow) { f.conn = cf }
-
-func (f *outflow) available() int32 {
-	n := f.n
-	if f.conn != nil && f.conn.n < n {
-		n = f.conn.n
+func (f *outflow) available() (int32, bool) {
+	if f.conn == nil {
+		return maxFlowWindow, true // only happens in tests
 	}
-	return n
+	if f.conn.flowErr {
+		// Block all sending once any stream observes a flow control error.
+		return 0, false
+	}
+	n := int64(f.conn.initial) + int64(f.delta)
+	if n > maxFlowWindow {
+		f.conn.flowErr = true
+		return 0, false
+	}
+	return min(int32(n), f.conn.n), true
 }
 
 func (f *outflow) take(n int32) {
-	if n > f.available() {
-		panic("internal error: took too much")
+	if f.conn == nil {
+		return // only happens in tests
 	}
-	f.n -= n
-	if f.conn != nil {
-		f.conn.n -= n
+	avail, _ := f.available()
+	if n > avail {
+		panic("internal error: took too much")
 	}
+	f.delta -= n
+	f.conn.n -= n
 }
 
 // add adds n bytes (positive or negative) to the flow control window.
 // It returns false if the sum would exceed 2^31-1.
 func (f *outflow) add(n int32) bool {
-	sum := f.n + n
-	if (sum > n) == (f.n > 0) {
-		f.n = sum
-		return true
+	if f.conn == nil {
+		return true // only happens in tests
+	}
+	avail := int64(f.conn.initial) + int64(f.delta)
+	if avail > maxFlowWindow {
+		// An earlier change to the initial window pushed this stream over the limit.
+		// This is a connection-level flow control error.
+		f.conn.flowErr = true
+		return false
 	}
-	return false
+	if avail+int64(n) > maxFlowWindow {
+		// This update would push the stream over the limit.
+		// This is a stream-level flow control error.
+		return false
+	}
+	f.delta += n
+	return true
 }
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/net/http2/frame.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/net/http2/frame.go
--- a/vendor/golang.org/x/net/http2/frame.go	2026-10-28 08:22:44.840102903 +0000
+++ b/vendor/golang.org/x/net/http2/frame.go	2026-10-28 08:23:38.184153279 +0000
@@ -1711,7 +1711,8 @@
 	mh := &MetaHeadersFrame{
 		HeadersFrame: hf,
 	}
-	var remainSize = fr.maxHeaderListSize()
+	var headersRemainSize = fr.maxHeaderListSize()
+	var trailersRemainSize = fr.maxHeaderListSize()
 	var sawRegular bool
 
 	var invalid error // pseudo header field errors
@@ -1743,14 +1744,29 @@
 			return
 		}
 
-		size := hf.Size()
-		if size > remainSize {
+		var remainSize *uint32
+		var size uint32
+		if hf.Name == "trailer" {
+			remainSize = &trailersRemainSize
+			fieldCount := strings.Count(hf.Value, ",") + 1
+			// Rather than actually constructing hpack.HeaderField for each
+			// trailer field and cumulatively adding its Size, just do the math
+			// manually to avoid unnecessary work. This does make it so
+			// whitespaces after comma are counted against the budget, but that
+			// should be innocuous.
+			size = uint32(len(hf.Value)-fieldCount+1) + uint32(fieldCount)*hpack.HeaderField{}.Size()
+		} else {
+			remainSize = &headersRemainSize
+			size = hf.Size()
+		}
+		if size > *remainSize {
 			hdec.SetEmitEnabled(false)
 			mh.Truncated = true
-			remainSize = 0
+			headersRemainSize = 0
+			trailersRemainSize = 0
 			return
 		}
-		remainSize -= size
+		*remainSize -= size
 
 		mh.Fields = append(mh.Fields, hf)
 	})
@@ -1766,10 +1782,10 @@
 		// skip parsing the fragment and close the connection.
 		//
 		// "Too much" is either any CONTINUATION frame after we've already
-		// exceeded the max header list size (in which case remainSize is 0),
-		// or a frame whose encoded size is more than twice the remaining
-		// header list bytes we're willing to accept.
-		if int64(len(frag)) > int64(2*remainSize) {
+		// exceeded the max header list size (if so, both budgets are 0), or a
+		// frame whose encoded size is more than twice the remaining header
+		// list bytes we're willing to accept.
+		if int64(len(frag)) > 2*int64(headersRemainSize+trailersRemainSize) {
 			if VerboseLogs {
 				log.Printf("http2: header list too large")
 			}
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/net/http2/server.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/net/http2/server.go
--- a/vendor/golang.org/x/net/http2/server.go	2026-10-28 08:22:44.840102903 +0000
+++ b/vendor/golang.org/x/net/http2/server.go	2026-10-28 08:23:38.184153279 +0000
@@ -280,7 +280,6 @@
 		doneServing:                 make(chan struct{}),
 		clientMaxStreams:            math.MaxUint32, // Section 6.5.2: "Initially, there is no limit to this value"
 		advMaxStreams:               conf.MaxConcurrentStreams,
-		initialStreamSendWindowSize: initialWindowSize,
 		initialStreamRecvWindowSize: conf.MaxUploadBufferPerStream,
 		maxFrameSize:                initialMaxFrameSize,
 		pingTimeout:                 conf.PingTimeout,
@@ -320,7 +319,7 @@
 	// These start at the RFC-specified defaults. If there is a higher
 	// configured value for inflow, that will be updated when we send a
 	// WINDOW_UPDATE shortly after sending SETTINGS.
-	sc.flow.add(initialWindowSize)
+	sc.flow.init()
 	sc.inflow.init(initialWindowSize)
 	sc.hpackEncoder = hpack.NewEncoder(&sc.headerWriteBuf)
 	sc.hpackEncoder.SetMaxDynamicTableSizeLimit(conf.MaxEncoderHeaderTableSize)
@@ -427,7 +426,7 @@
 	wroteFrameCh     chan frameWriteResult  // from writeFrameAsync -> serve, tickles more frame writes
 	bodyReadCh       chan bodyReadMsg       // from handlers -> serve
 	serveMsgCh       chan interface{}       // misc messages & code to send to / run on the serve loop
-	flow             outflow                // conn-wide (not stream-specific) outbound flow control
+	flow             connOutflow            // conn-wide (not stream-specific) outbound flow control
 	inflow           inflow                 // conn-wide inbound flow control
 	tlsState         *tls.ConnectionState   // shared by all handlers, like net/http
 	remoteAddrStr    string
@@ -441,6 +440,9 @@
 	sawFirstSettings            bool // got the initial SETTINGS frame after the preface
 	needToSendSettingsAck       bool
 	unackedSettings             int    // how many SETTINGS have we sent without ACKs?
+	pendingEncoderTableSize     bool   // peer changed SETTINGS_HEADER_TABLE_SIZE; apply to hpackEncoder before the next frame write
+	encoderTableSizeMin         uint32 // smallest SETTINGS_HEADER_TABLE_SIZE since the last apply
+	encoderTableSize            uint32 // latest SETTINGS_HEADER_TABLE_SIZE
 	queuedControlFrames         int    // control frames in the writeSched queue
 	clientMaxStreams            uint32 // SETTINGS_MAX_CONCURRENT_STREAMS from client (our PUSH_PROMISE limit)
 	advMaxStreams               uint32 // our SETTINGS_MAX_CONCURRENT_STREAMS advertised the client
@@ -451,7 +453,6 @@
 	maxPushPromiseID            uint32 // ID of the last push promise (even), or 0 if there have been no pushes
 	streams                     map[uint32]*stream
 	unstartedHandlers           []unstartedHandler
-	initialStreamSendWindowSize int32
 	initialStreamRecvWindowSize int32
 	maxFrameSize                int32
 	peerMaxHeaderListSize       uint32            // zero means unknown (default)
@@ -521,7 +522,8 @@
 	// immutable:
 	sc        *serverConn
 	id        uint32
-	body      *pipe       // non-nil if expecting DATA frames
+	body      *pipe // non-nil if expecting DATA frames
+	reqBody   *requestBody
 	cw        closeWaiter // closed wait stream transitions to closed state
 	ctx       context.Context
 	cancelCtx func()
@@ -1172,6 +1174,16 @@
 
 	sc.writingFrame = true
 	sc.needsFrameFlush = true
+	if sc.pendingEncoderTableSize {
+		// hpackEncoder may be in use by writeFrameAsync, so SETTINGS
+		// changes to it are deferred until no frame is being written.
+		// Replaying the smallest size before the latest one keeps the
+		// encoder's view identical to having applied every change
+		// (RFC 7541, Section 4.2).
+		sc.pendingEncoderTableSize = false
+		sc.hpackEncoder.SetMaxDynamicTableSize(sc.encoderTableSizeMin)
+		sc.hpackEncoder.SetMaxDynamicTableSize(sc.encoderTableSize)
+	}
 	if wr.write.staysWithinBuffer(sc.bw.Available()) {
 		sc.writingFrameAsync = false
 		err := wr.write.writeFrame(sc)
@@ -1271,6 +1283,11 @@
 	}
 	sc.inFrameScheduleLoop = true
 	for !sc.writingFrameAsync {
+		if sc.flow.flowErr && (!sc.inGoAway || sc.goAwayCode == ErrCodeNo) {
+			sc.inGoAway = true
+			sc.needToSendGoAway = true
+			sc.goAwayCode = ErrCodeFlowControl
+		}
 		if sc.needToSendGoAway {
 			sc.needToSendGoAway = false
 			sc.startFrameWrite(FrameWriteRequest{
@@ -1294,6 +1311,9 @@
 				sc.startFrameWrite(wr)
 				continue
 			}
+			if sc.flow.flowErr {
+				continue
+			}
 		}
 		if sc.needsFrameFlush {
 			sc.startFrameWrite(FrameWriteRequest{write: flushFrameWriter{}})
@@ -1526,6 +1546,10 @@
 			return nil
 		}
 		if !st.flow.add(int32(f.Increment)) {
+			if st.flow.conn.flowErr {
+				// This is a lazily-detected connection-level flow control error.
+				return sc.countError("bad_flow", ConnectionError(ErrCodeFlowControl))
+			}
 			return sc.countError("bad_flow", streamError(f.StreamID, ErrCodeFlowControl))
 		}
 	default: // connection-level flow control
@@ -1584,10 +1608,6 @@
 		}
 	}
 	if p := st.body; p != nil {
-		// Return any buffered unread bytes worth of conn-level flow control.
-		// See golang.org/issue/16481
-		sc.sendWindowUpdate(nil, p.Len())
-
 		p.CloseWithError(err)
 	}
 	if e, ok := err.(StreamError); ok {
@@ -1641,7 +1661,12 @@
 	}
 	switch s.ID {
 	case SettingHeaderTableSize:
-		sc.hpackEncoder.SetMaxDynamicTableSize(s.Val)
+		// Applied by startFrameWrite; see comment there.
+		if !sc.pendingEncoderTableSize || s.Val < sc.encoderTableSizeMin {
+			sc.encoderTableSizeMin = s.Val
+		}
+		sc.encoderTableSize = s.Val
+		sc.pendingEncoderTableSize = true
 	case SettingEnablePush:
 		sc.pushEnabled = s.Val != 0
 	case SettingMaxConcurrentStreams:
@@ -1672,28 +1697,14 @@
 
 func (sc *serverConn) processSettingInitialWindowSize(val uint32) error {
 	sc.serveG.check()
-	// Note: val already validated to be within range by
-	// processSetting's Valid call.
-
-	// "A SETTINGS frame can alter the initial flow control window
-	// size for all current streams. When the value of
-	// SETTINGS_INITIAL_WINDOW_SIZE changes, a receiver MUST
-	// adjust the size of all stream flow control windows that it
-	// maintains by the difference between the new value and the
-	// old value."
-	old := sc.initialStreamSendWindowSize
-	sc.initialStreamSendWindowSize = int32(val)
-	growth := int32(val) - old // may be negative
-	for _, st := range sc.streams {
-		if !st.flow.add(growth) {
-			// 6.9.2 Initial Flow Control Window Size
-			// "An endpoint MUST treat a change to
-			// SETTINGS_INITIAL_WINDOW_SIZE that causes any flow
-			// control window to exceed the maximum size as a
-			// connection error (Section 5.4.1) of type
-			// FLOW_CONTROL_ERROR."
-			return sc.countError("setting_win_size", ConnectionError(ErrCodeFlowControl))
-		}
+	if !sc.flow.changeInitialWindowSize(int64(val)) {
+		// 6.9.2 Initial Flow Control Window Size
+		// "An endpoint MUST treat a change to
+		// SETTINGS_INITIAL_WINDOW_SIZE that causes any flow
+		// control window to exceed the maximum size as a
+		// connection error (Section 5.4.1) of type
+		// FLOW_CONTROL_ERROR."
+		return sc.countError("setting_win_size", ConnectionError(ErrCodeFlowControl))
 	}
 	return nil
 }
@@ -1966,7 +1977,7 @@
 	if st.reqTrailer != nil {
 		st.trailer = make(http.Header)
 	}
-	st.body = req.Body.(*requestBody).pipe // may be nil
+	st.body = st.reqBody.pipe // may be nil
 	st.declBodyBytes = req.ContentLength
 
 	handler := sc.handler.ServeHTTP
@@ -1989,7 +2000,7 @@
 		st.readDeadline = time.AfterFunc(sc.hs.ReadTimeout, st.onReadTimeout)
 	}
 
-	return sc.scheduleHandler(id, rw, req, handler)
+	return sc.scheduleHandler(st, rw, req, handler)
 }
 
 func (sc *serverConn) upgradeRequest(req *http.Request) {
@@ -2102,7 +2113,6 @@
 	}
 	st.cw.Init()
 	st.flow.conn = &sc.flow // link to conn-level counter
-	st.flow.add(sc.initialStreamSendWindowSize)
 	st.inflow.init(sc.initialStreamRecvWindowSize)
 	if sc.hs.WriteTimeout > 0 {
 		st.writeDeadline = time.AfterFunc(sc.hs.WriteTimeout, st.onWriteTimeout)
@@ -2184,7 +2194,7 @@
 		} else {
 			req.ContentLength = -1
 		}
-		req.Body.(*requestBody).pipe = &pipe{
+		st.reqBody.pipe = &pipe{
 			b: &dataBuffer{expected: req.ContentLength},
 		}
 	}
@@ -2204,7 +2214,7 @@
 		return nil, nil, sc.countError(res.InvalidReason, streamError(st.id, ErrCodeProtocol))
 	}
 
-	body := &requestBody{
+	st.reqBody = &requestBody{
 		conn:          sc,
 		stream:        st,
 		needsContinue: res.NeedsContinue,
@@ -2220,7 +2230,7 @@
 		ProtoMinor: 0,
 		TLS:        tlsState,
 		Host:       rp.Authority,
-		Body:       body,
+		Body:       st.reqBody,
 		Trailer:    res.Trailer,
 	}).WithContext(st.ctx)
 	rw := sc.newResponseWriter(st, req)
@@ -2244,11 +2254,12 @@
 	rw       *responseWriter
 	req      *http.Request
 	handler  func(http.ResponseWriter, *http.Request)
+	body     *pipe
 }
 
 // scheduleHandler starts a handler goroutine,
 // or schedules one to start as soon as an existing handler finishes.
-func (sc *serverConn) scheduleHandler(streamID uint32, rw *responseWriter, req *http.Request, handler func(http.ResponseWriter, *http.Request)) error {
+func (sc *serverConn) scheduleHandler(st *stream, rw *responseWriter, req *http.Request, handler func(http.ResponseWriter, *http.Request)) error {
 	sc.serveG.check()
 	maxHandlers := sc.advMaxStreams
 	if sc.curHandlers < maxHandlers {
@@ -2260,10 +2271,11 @@
 		return sc.countError("too_many_early_resets", ConnectionError(ErrCodeEnhanceYourCalm))
 	}
 	sc.unstartedHandlers = append(sc.unstartedHandlers, unstartedHandler{
-		streamID: streamID,
+		streamID: st.id,
 		rw:       rw,
 		req:      req,
 		handler:  handler,
+		body:     st.body,
 	})
 	return nil
 }
@@ -2277,6 +2289,10 @@
 		u := sc.unstartedHandlers[i]
 		if sc.streams[u.streamID] == nil {
 			// This stream was reset before its goroutine had a chance to start.
+			if u.body != nil {
+				u.body.BreakWithError(errClosedBody)
+				sc.sendWindowUpdate(nil, u.body.Len())
+			}
 			continue
 		}
 		if sc.curHandlers >= maxHandlers {
@@ -2298,6 +2314,12 @@
 	didPanic := true
 	defer func() {
 		rw.rws.stream.cancelCtx()
+		if b := rw.rws.stream.reqBody; b != nil {
+			// Closing the body refunds flow control credit for any unconsumed data.
+			// (reqBody is nil for Upgrade: h2c requests, but those do not use flow
+			// control for the request body.)
+			b.Close()
+		}
 		if req.MultipartForm != nil {
 			req.MultipartForm.RemoveAll()
 		}
@@ -2396,7 +2418,7 @@
 func (sc *serverConn) noteBodyRead(st *stream, n int) {
 	sc.serveG.check()
 	sc.sendWindowUpdate(nil, n) // conn-level
-	if st.state != stateHalfClosedRemote && st.state != stateClosed {
+	if st != nil && st.state != stateHalfClosedRemote && st.state != stateClosed {
 		// Don't send this WINDOW_UPDATE if the stream is closed
 		// remotely.
 		sc.sendWindowUpdate(st, n)
@@ -2444,6 +2466,9 @@
 	b.closeOnce.Do(func() {
 		if b.pipe != nil {
 			b.pipe.BreakWithError(errClosedBody)
+			if unread := b.pipe.Len(); unread > 0 {
+				b.conn.noteBodyReadFromHandler(nil, unread, errClosedBody)
+			}
 		}
 	})
 	return nil
@@ -2461,9 +2486,6 @@
 	if err == io.EOF {
 		b.sawEOF = true
 	}
-	if b.conn == nil {
-		return
-	}
 	b.conn.noteBodyReadFromHandler(b.stream, n, err)
 	return
 }
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/net/http2/transport.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/net/http2/transport.go
--- a/vendor/golang.org/x/net/http2/transport.go	2026-10-28 08:22:44.840102903 +0000
+++ b/vendor/golang.org/x/net/http2/transport.go	2026-10-28 08:23:38.184153279 +0000
@@ -27,6 +27,7 @@
 	"net/http"
 	"net/http/httptrace"
 	"net/textproto"
+	"slices"
 	"strconv"
 	"sync"
 	"sync/atomic"
@@ -203,7 +204,7 @@
 
 	mu               sync.Mutex // guards following
 	cond             *sync.Cond // hold mu; broadcast on flow/closed changes
-	flow             outflow    // our conn-level flow control quota (cs.outflow is per stream)
+	flow             connOutflow // our conn-level flow control quota (cs.outflow is per stream)
 	inflow           inflow     // peer's conn-level flow control
 	doNotReuse       bool       // whether conn is marked to not be reused for any future requests
 	closing          bool
@@ -227,7 +228,6 @@
 	maxConcurrentStreams        uint32
 	peerMaxHeaderListSize       uint64
 	peerMaxHeaderTableSize      uint32
-	initialWindowSize           uint32
 	initialStreamRecvWindowSize int32
 	readIdleTimeout             time.Duration
 	pingTimeout                 time.Duration
@@ -472,7 +472,6 @@
 		readerDone:                  make(chan struct{}),
 		nextStreamID:                1,
 		maxFrameSize:                16 << 10, // spec default
-		initialWindowSize:           65535,    // spec default
 		initialStreamRecvWindowSize: conf.MaxUploadBufferPerStream,
 		maxConcurrentStreams:        initialMaxConcurrentStreams, // "infinite", per spec. Use a smaller value until we have received server settings.
 		strictMaxConcurrentStreams:  conf.StrictMaxConcurrentRequests,
@@ -497,7 +496,7 @@
 	}
 
 	cc.cond = sync.NewCond(&cc.mu)
-	cc.flow.add(int32(initialWindowSize))
+	cc.flow.init()
 
 	// TODO: adjust this writer size to account for frame size +
 	// MTU + crypto/tls record padding.
@@ -876,6 +875,33 @@
 	return nil
 }
 
+func (cc *ClientConn) goAwayAndClose(code ErrCode) {
+	cc.mu.Lock()
+	closed := cc.closed
+	cc.closing = true
+	cc.closed = true
+	cc.mu.Unlock()
+	if closed {
+		return
+	}
+	if f := cc.fr.countError; f != nil {
+		f(fmt.Sprintf("conn_close_error_%s", code.stringToken()))
+	}
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		cc.wmu.Lock()
+		cc.fr.WriteGoAway(0, code, nil)
+		cc.bw.Flush()
+		cc.wmu.Unlock()
+	}()
+	select {
+	case <-done:
+	case <-time.After(250 * time.Millisecond):
+	}
+	cc.closeForError(fmt.Errorf("http2: closing connection with %v", code))
+}
+
 // closes the client connection immediately. In-flight requests are interrupted.
 // err is sent to streams.
 func (cc *ClientConn) closeForError(err error) {
@@ -1319,7 +1345,9 @@
 	}
 	if err != nil {
 		cs.abortStream(err) // possibly redundant, but harmless
-		if cs.sentHeaders {
+		if ce, ok := err.(ConnectionError); ok {
+			cc.goAwayAndClose(ErrCode(ce))
+		} else if cs.sentHeaders {
 			if se, ok := err.(StreamError); ok {
 				if se.Cause != errFromPeer {
 					cc.writeStreamReset(cs.ID, se.Code, false, err)
@@ -1648,8 +1676,12 @@
 			return 0, errRequestCanceled
 		default:
 		}
-		if a := cs.flow.available(); a > 0 {
-			take := a
+		avail, ok := cs.flow.available()
+		if !ok {
+			return 0, ConnectionError(ErrCodeFlowControl)
+		}
+		if avail > 0 {
+			take := avail
 			if int(take) > maxBytes {
 
 				take = int32(maxBytes) // can't truncate int; take is int32
@@ -1710,8 +1742,7 @@
 
 // requires cc.mu be held.
 func (cc *ClientConn) addStreamLocked(cs *clientStream) {
-	cs.flow.add(int32(cc.initialWindowSize))
-	cs.flow.setConnFlow(&cc.flow)
+	cs.flow.conn = &cc.flow
 	cs.inflow.init(cc.initialStreamRecvWindowSize)
 	cs.ID = cc.nextStreamID
 	cc.nextStreamID += 2
@@ -2095,18 +2126,42 @@
 		return nil, nil
 	}
 
+	// Delete various headers that might mess up framing for HTTP/1. This is
+	// not a problem for HTTP/2, but someone might use HTTP/2 transport as a
+	// reverse proxy which forwards the response to an HTTP/1 client. Our
+	// HTTP/1 client transport will properly reject improper headers such as
+	// multiple conflicting Content-Length headers, but other implementations
+	// might not.
+	// TODO: just reject such responses? We deleted them for compatibility
+	// since this was done in a security fix (go.dev/issue/81115). However,
+	// rejecting them seems entirely reasonable and relatively safe.
+
+	// Connection-specific header fields must not appear in an HTTP/2 message,
+	// and any message containing them is malformed. RFC 9113, Section 8.2.2.
+	for _, k := range connHeaders {
+		delete(res.Header, k)
+	}
 	res.ContentLength = -1
-	if clens := res.Header["Content-Length"]; len(clens) == 1 {
-		if cl, err := strconv.ParseUint(clens[0], 10, 63); err == nil {
-			res.ContentLength = int64(cl)
+	if clens, ok := res.Header["Content-Length"]; ok {
+		// Repeated Content-Length values may be collapsed into one only if
+		// they are identical per RFC 9110 Section 8.6.
+		// No need to trim whitespace, HTTP/2 header values must not have
+		// extraneous whitespace per RFC 9113 Section 8.2.1.
+		// Non-canonical headers are already rejected by our framer at this
+		// point.
+		conflicting := slices.ContainsFunc(clens[1:], func(clen string) bool {
+			return clen != clens[0]
+		})
+		cl, err := strconv.ParseUint(clens[0], 10, 63)
+		if conflicting || err != nil {
+			delete(res.Header, "Content-Length")
 		} else {
-			// TODO: care? unlike http/1, it won't mess up our framing, so it's
-			// more safe smuggling-wise to ignore.
+			res.Header["Content-Length"] = clens[:1]
+			res.ContentLength = int64(cl)
 		}
-	} else if len(clens) > 1 {
-		// TODO: care? unlike http/1, it won't mess up our framing, so it's
-		// more safe smuggling-wise to ignore.
-	} else if f.StreamEnded() && !cs.isHead {
+	}
+
+	if res.ContentLength < 0 && f.StreamEnded() && !cs.isHead {
 		res.ContentLength = 0
 	}
 
@@ -2417,6 +2472,10 @@
 func (rl *clientConnReadLoop) streamByID(id uint32, headerOrData bool) *clientStream {
 	rl.cc.mu.Lock()
 	defer rl.cc.mu.Unlock()
+	return rl.streamByIDLocked(id, headerOrData)
+}
+
+func (rl *clientConnReadLoop) streamByIDLocked(id uint32, headerOrData bool) *clientStream {
 	if headerOrData {
 		// Work around an unfortunate gRPC behavior.
 		// See comment on ClientConn.rstStreamPingsBlocked for details.
@@ -2499,24 +2558,10 @@
 		case SettingMaxHeaderListSize:
 			cc.peerMaxHeaderListSize = uint64(s.Val)
 		case SettingInitialWindowSize:
-			// Values above the maximum flow-control
-			// window size of 2^31-1 MUST be treated as a
-			// connection error (Section 5.4.1) of type
-			// FLOW_CONTROL_ERROR.
-			if s.Val > math.MaxInt32 {
+			if !cc.flow.changeInitialWindowSize(int64(s.Val)) {
 				return ConnectionError(ErrCodeFlowControl)
 			}
-
-			// Adjust flow control of currently-open
-			// frames by the difference of the old initial
-			// window size and this one.
-			delta := int32(s.Val) - int32(cc.initialWindowSize)
-			for _, cs := range cc.streams {
-				cs.flow.add(delta)
-			}
 			cc.cond.Broadcast()
-
-			cc.initialWindowSize = s.Val
 		case SettingHeaderTableSize:
 			cc.henc.SetMaxDynamicTableSize(s.Val)
 			cc.peerMaxHeaderTableSize = s.Val
@@ -2558,29 +2603,30 @@
 
 func (rl *clientConnReadLoop) processWindowUpdate(f *WindowUpdateFrame) error {
 	cc := rl.cc
-	cs := rl.streamByID(f.StreamID, notHeaderOrDataFrame)
-	if f.StreamID != 0 && cs == nil {
-		return nil
-	}
-
 	cc.mu.Lock()
 	defer cc.mu.Unlock()
-
-	fl := &cc.flow
-	if cs != nil {
-		fl = &cs.flow
-	}
-	if !fl.add(int32(f.Increment)) {
-		// For stream, the sender sends RST_STREAM with an error code of FLOW_CONTROL_ERROR
-		if cs != nil {
+	if f.StreamID == 0 {
+		if !cc.flow.add(int32(f.Increment)) {
+			return ConnectionError(ErrCodeFlowControl)
+		}
+	} else {
+		cs := rl.streamByIDLocked(f.StreamID, notHeaderOrDataFrame)
+		if cs == nil {
+			return nil
+		}
+		if !cs.flow.add(int32(f.Increment)) {
+			if cs.flow.conn.flowErr {
+				// This is a lazily-detected connection-level flow control error.
+				return ConnectionError(ErrCodeFlowControl)
+			}
+			// For stream, the sender sends RST_STREAM with
+			// an error code of FLOW_CONTROL_ERROR.
 			rl.endStreamErrorLocked(cs, StreamError{
 				StreamID: f.StreamID,
 				Code:     ErrCodeFlowControl,
 			})
 			return nil
 		}
-
-		return ConnectionError(ErrCodeFlowControl)
 	}
 	cc.cond.Broadcast()
 	return nil
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/net/http2/transport_wrap.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/net/http2/transport_wrap.go
--- a/vendor/golang.org/x/net/http2/transport_wrap.go	2026-10-28 08:22:44.840102903 +0000
+++ b/vendor/golang.org/x/net/http2/transport_wrap.go	2026-10-28 08:23:38.184153279 +0000
@@ -119,33 +119,27 @@
 
 // DialFromContext dials a new connection using the http2.Transport's DialTLS/DialTLSContext.
 func (t transportConfig) DialFromContext(ctx context.Context, network, address string) (net.Conn, error) {
-	if ctx.Value(http2TransportContextKey{}) == nil {
+	dial, _ := ctx.Value(http2TransportContextKey{}).(*transportRoundTripState)
+	if dial == nil {
 		// We're being called from a RoundTrip that did not start with an http2.Transport.
 		// Use the http.Transport's dialer.
 		return nil, errors.ErrUnsupported
 	}
-
-	tlsConf := t.t.TLSClientConfig
-	if tlsConf == nil {
-		tlsConf = &tls.Config{}
-	} else {
-		tlsConf = tlsConf.Clone()
-	}
-	if !slices.Contains(tlsConf.NextProtos, "h2") {
-		tlsConf.NextProtos = append([]string{"h2"}, tlsConf.NextProtos...)
-	}
-	if tlsConf.ServerName == "" {
-		host, _, err := net.SplitHostPort(address)
-		if err == nil {
-			tlsConf.ServerName = host
-		}
-	}
-	return t.t.dialTLS(ctx, network, address, tlsConf)
+	return t.t.dialForRoundTrip(ctx, dial, network, address)
 }
 
 type transportInternal struct {
 	initOnce sync.Once
 	lazyt1   *http.Transport
+
+	dialMu sync.Mutex
+	dials  map[string]*transportDialState
+}
+
+type transportDialState struct {
+	dialc   chan struct{} // close when dial returns
+	dialErr error         // dial result, set before dialc is closed
+	rtdonec chan struct{} // closed when RoundTrip initiating the dial returns
 }
 
 func (t *Transport) init() *http.Transport {
@@ -167,6 +161,52 @@
 	}
 }
 
+// transportRoundTripState is the state of the dial for an http2.Transport.RoundTrip.
+type transportRoundTripState struct {
+	mu       sync.Mutex
+	rtdone   bool          // set when RoundTrip returns
+	rtdonec  chan struct{} // closed when RoundTrip returns
+	gotconnc chan struct{} // closed when GotConn hook is called
+}
+
+// startDial is called when a dial starts.
+//
+// It returns done=true if the RoundTrip has already returned,
+// in which case we should skip dialing.
+func (dial *transportRoundTripState) startDial() (gotconnc chan struct{}, done bool) {
+	dial.mu.Lock()
+	defer dial.mu.Unlock()
+	if dial.rtdone {
+		return nil, true
+	}
+	if dial.rtdonec == nil {
+		dial.rtdonec = make(chan struct{})
+	}
+	dial.gotconnc = make(chan struct{})
+	return dial.gotconnc, false
+}
+
+// gotConn is called when RoundTrip gets a connection.
+// This may happen multiple times per RoundTrip, if a request is retried.
+func (dial *transportRoundTripState) gotConn() {
+	dial.mu.Lock()
+	defer dial.mu.Unlock()
+	if dial.gotconnc != nil {
+		close(dial.gotconnc)
+		dial.gotconnc = nil
+	}
+}
+
+// roundTripDone is called when RoundTrip returns.
+func (dial *transportRoundTripState) roundTripDone() {
+	dial.mu.Lock()
+	defer dial.mu.Unlock()
+	dial.rtdone = true
+	if dial.rtdonec != nil {
+		close(dial.rtdonec)
+	}
+}
+
 func (t *Transport) roundTripOpt(req *http.Request, opt RoundTripOpt) (*http.Response, error) {
 	t1 := t.init()
 
@@ -186,12 +226,146 @@
 	// Both http.Transport and http2.Transport allow the user to provide a custom
 	// dial function, and historically you only get the dial function from the
 	// Transport you're calling RoundTrip on.
-	ctx := context.WithValue(req.Context(), http2TransportContextKey{}, t)
+	//
+	// In addition, http2.Transport coalesces dials, which http.Transport historically
+	// has not.
+	dial := &transportRoundTripState{}
+	defer dial.roundTripDone()
+	ctx := context.WithValue(req.Context(), http2TransportContextKey{}, dial)
+	ctx = httptrace.WithClientTrace(ctx, &httptrace.ClientTrace{
+		GotConn: func(httptrace.GotConnInfo) {
+			// Tell dialForRoundTrip that we have received a connection.
+			dial.gotConn()
+		},
+	})
 	req = req.WithContext(ctx)
-
 	return t1.RoundTrip(req)
 }
 
+var errCoalescedDialAbandoned = errors.New("http2: abandoned coalesced dial")
+
+const coalescedDialRetryTimeout = 50 * time.Millisecond
+
+// dialForRoundTrip is called (indirectly) by net/http when dialing a new connection
+// for a request call which originated as an http2.Transport.RoundTrip call.
+//
+// It uses the http2.Transport's Dial hooks and coalesces dials.
+func (t *Transport) dialForRoundTrip(ctx context.Context, dial *transportRoundTripState, network, address string) (net.Conn, error) {
+	gotconnc, rtdone := dial.startDial()
+	if rtdone {
+		// RoundTrip returned, no need for this dial to proceed.
+		return nil, errCoalescedDialAbandoned
+	}
+
+	var state *transportDialState
+	for {
+		// The first dial to an address registers itself with t.dials.
+		// When the dial finishes, it records the outcome and removes itself from t.dials
+		// so future dials will start a new round of coalescing.
+		//
+		// Subsequent dials observe that a dial is in progress, and skip dialing.
+		t.dialMu.Lock()
+		if t.dials == nil {
+			t.dials = make(map[string]*transportDialState)
+		}
+		leader := t.dials[address]
+		if leader == nil {
+			// No entry in t.dials to coalesce with. Add ourselves as leader.
+			state = &transportDialState{
+				dialc:   make(chan struct{}),
+				rtdonec: dial.rtdonec,
+			}
+			t.dials[address] = state
+		}
+		t.dialMu.Unlock()
+		if leader == nil {
+			// We are the leader, so we should dial for real.
+			break
+		}
+
+		// Coalesce with a previous dial.
+		var (
+			done          = false
+			leaderdialc   = leader.dialc
+			leaderrtdonec = leader.rtdonec
+			timerc        <-chan time.Time
+		)
+		for !done {
+			if leaderdialc == nil && leaderrtdonec == nil && timerc == nil {
+				// The leader finished dialing, and its RoundTrip finished.
+				//
+				// There are several possibilities, which reduce to:
+				//   - The RoundTrip we are dialing for is about to receive
+				//     a connection (possibly the one the leader just dialed),
+				//     but we haven't observed it yet.
+				//   - There's something wrong with the leader's connection,
+				//     such as a TLS handshake failure.
+				//
+				// We have no good way to distinguish between these cases.
+				//
+				// Wait a short time for the leader's connection (or some
+				// other usable connection) to be delivered to our RoundTrip.
+				// If it is not, start a dial of our own.
+				timerc = time.After(coalescedDialRetryTimeout)
+			}
+			select {
+			case <-leaderdialc:
+				// The leader's dial completed.
+				if leader.dialErr != nil {
+					return nil, leader.dialErr
+				}
+				leaderdialc = nil
+			case <-leaderrtdonec:
+				// The leader's RoundTrip completed.
+				leaderrtdonec = nil
+			case <-timerc:
+				// The leader's dial and RoundTrip completed, and some time
+				// has passed. Assume we're not getting a connection and
+				// restart the dial process.
+				done = true
+			case <-dial.rtdonec:
+				// Our RoundTrip returned.
+				return nil, errCoalescedDialAbandoned
+			case <-gotconnc:
+				// Our RoundTrip got a connection.
+				return nil, errCoalescedDialAbandoned
+			case <-ctx.Done():
+				// net/http abandoned the dial.
+				return nil, ctx.Err()
+			}
+		}
+	}
+
+	// Dial for real.
+	tlsConf := t.TLSClientConfig
+	if tlsConf == nil {
+		tlsConf = &tls.Config{}
+	} else {
+		tlsConf = tlsConf.Clone()
+	}
+	if !slices.Contains(tlsConf.NextProtos, "h2") {
+		tlsConf.NextProtos = append([]string{"h2"}, tlsConf.NextProtos...)
+	}
+	if tlsConf.ServerName == "" {
+		host, _, err := net.SplitHostPort(address)
+		if err == nil {
+			tlsConf.ServerName = host
+		}
+	}
+	nc, err := t.dialTLS(ctx, network, address, tlsConf)
+
+	// Remove this dial from t.dials, so future dial attempts will not coalesce with it.
+	t.dialMu.Lock()
+	delete(t.dials, address)
+	t.dialMu.Unlock()
+
+	// Notify any dial coalesced with this one that we are done.
+	state.dialErr = err
+	close(state.dialc)
+
+	return nc, err
+}
+
 func (t *Transport) closeIdleConnections() {
 	t1 := t.init()
 	t1.CloseIdleConnections()
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/net/http2/writesched.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/net/http2/writesched.go
--- a/vendor/golang.org/x/net/http2/writesched.go	2026-10-28 08:22:44.840102903 +0000
+++ b/vendor/golang.org/x/net/http2/writesched.go	2026-10-28 08:23:38.184153279 +0000
@@ -79,10 +79,11 @@
 	}
 
 	// Might need to split after applying limits.
-	allowed := wr.stream.flow.available()
-	if n < allowed {
-		allowed = n
+	avail, ok := wr.stream.flow.available()
+	if !ok {
+		return empty, empty, 0
 	}
+	allowed := min(n, avail)
 	if wr.stream.sc.maxFrameSize < allowed {
 		allowed = wr.stream.sc.maxFrameSize
 	}
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/net/internal/httpcommon/gzip.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/net/internal/httpcommon/gzip.go
--- a/vendor/golang.org/x/net/internal/httpcommon/gzip.go	1970-01-01 00:00:00.000000000 +0000
+++ b/vendor/golang.org/x/net/internal/httpcommon/gzip.go	2026-10-28 08:23:38.188153284 +0000
@@ -0,0 +1,132 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package httpcommon
+
+import (
+	"compress/flate"
+	"compress/gzip"
+	"errors"
+	"io"
+	"io/fs"
+	"sync"
+)
+
+var errConcurrentRead = errors.New("http: concurrent read on response body")
+
+// incomparable is a zero-width, non-comparable type. Adding it to a struct
+// makes that struct also non-comparable, and generally doesn't add
+// any size (as long as it's first).
+type incomparable [0]func()
+
+// GzipReader wraps a response body so it can lazily
+// get gzip.Reader from the pool on the first call to Read.
+// After Close is called it puts gzip.Reader to the pool immediately
+// if there is no Read in progress or later when Read completes.
+type GzipReader struct {
+	_    incomparable
+	Body io.ReadCloser // underlying Response.Body
+	mu   sync.Mutex    // guards zr and zerr
+	zr   *gzip.Reader  // stores gzip reader from the pool between reads
+	zerr error         // sticky gzip reader init error or sentinel value to detect concurrent read and read after close
+}
+
+type eofReader struct{}
+
+func (eofReader) Read([]byte) (int, error) { return 0, io.EOF }
+func (eofReader) ReadByte() (byte, error)  { return 0, io.EOF }
+
+var gzipPool = sync.Pool{New: func() any { return new(gzip.Reader) }}
+
+// gzipPoolGet gets a gzip.Reader from the pool and resets it to read from r.
+func gzipPoolGet(r io.Reader) (*gzip.Reader, error) {
+	zr := gzipPool.Get().(*gzip.Reader)
+	if err := zr.Reset(r); err != nil {
+		gzipPoolPut(zr)
+		return nil, err
+	}
+	return zr, nil
+}
+
+// gzipPoolPut puts a gzip.Reader back into the pool.
+func gzipPoolPut(zr *gzip.Reader) {
+	// Reset will allocate bufio.Reader if we pass it anything
+	// other than a flate.Reader, so ensure that it's getting one.
+	var r flate.Reader = eofReader{}
+	zr.Reset(r)
+	gzipPool.Put(zr)
+}
+
+// acquire returns a gzip.Reader for reading response body.
+// The reader must be released after use.
+func (gz *GzipReader) acquire() (*gzip.Reader, error) {
+	gz.mu.Lock()
+	defer gz.mu.Unlock()
+	if gz.zerr != nil {
+		return nil, gz.zerr
+	}
+	if gz.zr == nil {
+		// gzipPoolGet might block indefinitely since it reads the gzip header.
+		// Therefore, drop mu temporarily when using gzipPoolGet.
+		// We set zerr to errConcurrentRead to prevent concurrent read
+		// even when mu is temporarily dropped.
+		gz.zerr = errConcurrentRead
+		gz.mu.Unlock()
+		zr, err := gzipPoolGet(gz.Body)
+		gz.mu.Lock()
+		// Guard against Close being called while gzipPoolGet is running.
+		if gz.zerr != errConcurrentRead {
+			if zr != nil {
+				gzipPoolPut(zr)
+			}
+			return nil, gz.zerr
+		}
+		gz.zr, gz.zerr = zr, err
+		if gz.zerr != nil {
+			return nil, gz.zerr
+		}
+	}
+	ret := gz.zr
+	gz.zr, gz.zerr = nil, errConcurrentRead
+	return ret, nil
+}
+
+// release returns the gzip.Reader to the pool if Close was called during Read.
+func (gz *GzipReader) release(zr *gzip.Reader) {
+	gz.mu.Lock()
+	defer gz.mu.Unlock()
+	if gz.zerr == errConcurrentRead {
+		gz.zr, gz.zerr = zr, nil
+	} else { // fs.ErrClosed
+		gzipPoolPut(zr)
+	}
+}
+
+// close returns the gzip.Reader to the pool immediately or
+// signals release to do so after Read completes.
+func (gz *GzipReader) close() {
+	gz.mu.Lock()
+	defer gz.mu.Unlock()
+	if gz.zerr == nil && gz.zr != nil {
+		gzipPoolPut(gz.zr)
+		gz.zr = nil
+	}
+	gz.zerr = fs.ErrClosed
+}
+
+func (gz *GzipReader) Read(p []byte) (n int, err error) {
+	zr, err := gz.acquire()
+	if err != nil {
+		return 0, err
+	}
+	defer gz.release(zr)
+
+	return zr.Read(p)
+}
+
+func (gz *GzipReader) Close() error {
+	gz.close()
+
+	return gz.Body.Close()
+}
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/cpu/cpu.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/cpu/cpu.go
--- a/vendor/golang.org/x/sys/cpu/cpu.go	2026-10-28 08:22:44.844102908 +0000
+++ b/vendor/golang.org/x/sys/cpu/cpu.go	2026-10-28 08:23:38.364153478 +0000
@@ -61,7 +61,11 @@
 	HasBMI2             bool // Bit manipulation instruction set 2
 	HasCX16             bool // Compare and exchange 16 Bytes
 	HasERMS             bool // Enhanced REP for MOVSB and STOSB
+	HasF16C             bool // 16-bit floating-point conversion instructions
 	HasFMA              bool // Fused-multiply-add instructions
+	HasLAHF             bool // LAHF/SAHF available in 64-bit mode
+	HasLZCNT            bool // Leading zeros count instruction
+	HasMOVBE            bool // Move data after byte swap
 	HasOSXSAVE          bool // OS supports XSAVE/XRESTOR for saving/restoring XMM registers.
 	HasPCLMULQDQ        bool // PCLMULQDQ instruction - most often used for AES-GCM
 	HasPOPCNT           bool // Hamming weight instruction POPCNT.
@@ -75,6 +79,7 @@
 	HasAVXIFMA          bool // Advanced vector extension Integer Fused Multiply Add
 	HasAVXVNNI          bool // Advanced vector extension Vector Neural Network Instructions
 	HasAVXVNNIInt8      bool // Advanced vector extension Vector Neural Network Int8 instructions
+	HasXSAVE            bool // XSAVE/XRSTOR/XSETBV/XGETBV instructions (hardware support; see also HasOSXSAVE)
 	_                   CacheLinePad
 }
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/cpu/cpu_x86.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/cpu/cpu_x86.go
--- a/vendor/golang.org/x/sys/cpu/cpu_x86.go	2026-10-28 08:22:44.844102908 +0000
+++ b/vendor/golang.org/x/sys/cpu/cpu_x86.go	2026-10-28 08:23:38.368153483 +0000
@@ -43,7 +43,11 @@
 		{Name: "bmi2", Feature: &X86.HasBMI2},
 		{Name: "cx16", Feature: &X86.HasCX16},
 		{Name: "erms", Feature: &X86.HasERMS},
+		{Name: "f16c", Feature: &X86.HasF16C},
 		{Name: "fma", Feature: &X86.HasFMA},
+		{Name: "lahf", Feature: &X86.HasLAHF},
+		{Name: "lzcnt", Feature: &X86.HasLZCNT},
+		{Name: "movbe", Feature: &X86.HasMOVBE},
 		{Name: "osxsave", Feature: &X86.HasOSXSAVE},
 		{Name: "pclmulqdq", Feature: &X86.HasPCLMULQDQ},
 		{Name: "popcnt", Feature: &X86.HasPOPCNT},
@@ -56,6 +60,7 @@
 		{Name: "avxifma", Feature: &X86.HasAVXIFMA},
 		{Name: "avxvnni", Feature: &X86.HasAVXVNNI},
 		{Name: "avxvnniint8", Feature: &X86.HasAVXVNNIInt8},
+		{Name: "xsave", Feature: &X86.HasXSAVE},
 
 		// These capabilities should always be enabled on amd64:
 		{Name: "sse2", Feature: &X86.HasSSE2, Required: runtime.GOARCH == "amd64"},
@@ -83,10 +88,13 @@
 		cpuid_AVX512VPOPCNTDQ = 1 << 14
 		cpuid_SSE41           = 1 << 19
 		cpuid_SSE42           = 1 << 20
+		cpuid_MOVBE           = 1 << 22
 		cpuid_POPCNT          = 1 << 23
 		cpuid_AES             = 1 << 25
+		cpuid_XSAVE           = 1 << 26
 		cpuid_OSXSAVE         = 1 << 27
 		cpuid_AVX             = 1 << 28
+		cpuid_F16C            = 1 << 29
 
 		// "Extended Feature Flag" bits returned in EBX for CPUID EAX=0x7 ECX=0x0
 		cpuid_BMI1     = 1 << 3
@@ -110,6 +118,9 @@
 
 		// edx bits
 		cpuid_FSRM = 1 << 4
+		// ecx bits for CPUID 0x80000001
+		cpuid_LAHF  = 1 << 0
+		cpuid_LZCNT = 1 << 5
 		// edx bits for CPUID 0x80000001
 		cpuid_RDTSCP = 1 << 27
 	)
@@ -158,9 +169,21 @@
 	X86.HasSSE42 = isSet(ecx1, cpuid_SSE42)
 	X86.HasPOPCNT = isSet(ecx1, cpuid_POPCNT)
 	X86.HasAES = isSet(ecx1, cpuid_AES)
+	X86.HasXSAVE = isSet(ecx1, cpuid_XSAVE)
 	X86.HasOSXSAVE = isSet(ecx1, cpuid_OSXSAVE)
+	X86.HasF16C = isSet(ecx1, cpuid_F16C)
+	X86.HasMOVBE = isSet(ecx1, cpuid_MOVBE)
 	X86.HasRDRAND = isSet(ecx1, cpuid_RDRAND)
 
+	// Extended processor info and feature bits, under the separate extended
+	// (0x8000_0000-prefixed) leaf hierarchy, so maxID (the basic leaf count)
+	// doesn't gate it.
+	if maxExtID, _, _, _ := cpuid(0x80000000, 0); maxExtID >= 0x80000001 {
+		_, _, ecxExt1, _ := cpuid(0x80000001, 0)
+		X86.HasLAHF = isSet(ecxExt1, cpuid_LAHF)
+		X86.HasLZCNT = isSet(ecxExt1, cpuid_LZCNT)
+	}
+
 	var osSupportsAVX, osSupportsAVX512 bool
 	// For XGETBV, OSXSAVE bit is required and sufficient.
 	if X86.HasOSXSAVE {
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s
--- a/vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s	2026-10-28 08:22:44.848102913 +0000
+++ b/vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s	2026-10-28 08:23:38.372153487 +0000
@@ -13,6 +13,16 @@
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
 
+TEXT ·Syscall(SB),NOSPLIT,$0-56
+	MOVD	$syscall·Syscall(SB), R31
+	MOVD	R31, CTR
+	JMP	(CTR)
+
+TEXT ·Syscall6(SB),NOSPLIT,$0-80
+	MOVD	$syscall·Syscall6(SB), R31
+	MOVD	R31, CTR
+	JMP	(CTR)
+
 TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
 	BL	runtime·entersyscall(SB)
 	MOVD	a1+8(FP), R3
@@ -28,6 +38,16 @@
 	BL	runtime·exitsyscall(SB)
 	RET
 
+TEXT ·RawSyscall(SB),NOSPLIT,$0-56
+	MOVD	$syscall·RawSyscall(SB), R31
+	MOVD	R31, CTR
+	JMP	(CTR)
+
+TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
+	MOVD	$syscall·RawSyscall6(SB), R31
+	MOVD	R31, CTR
+	JMP	(CTR)
+
 TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
 	MOVD	a1+8(FP), R3
 	MOVD	a2+16(FP), R4
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/asm_linux_sparc64.s /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/asm_linux_sparc64.s
--- a/vendor/golang.org/x/sys/unix/asm_linux_sparc64.s	1970-01-01 00:00:00.000000000 +0000
+++ b/vendor/golang.org/x/sys/unix/asm_linux_sparc64.s	2026-10-28 08:23:38.372153487 +0000
@@ -0,0 +1,48 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build linux && sparc64 && gc
+
+#include "textflag.h"
+
+//
+// System calls for sparc64, Linux
+//
+
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
+
+TEXT ·Syscall(SB), NOSPLIT, $0-56
+	JMP	syscall·Syscall(SB)
+
+TEXT ·Syscall6(SB), NOSPLIT, $0-80
+	JMP	syscall·Syscall6(SB)
+
+TEXT ·SyscallNoError(SB), NOSPLIT, $0-48
+	CALL	runtime·entersyscall(SB)
+	MOVD	trap+0(FP), R1	// syscall entry
+	MOVD	a1+8(FP), R8
+	MOVD	a2+16(FP), R9
+	MOVD	a3+24(FP), R10
+	TA	$0x6d
+	MOVD	R8, r1+32(FP)
+	MOVD	R9, r2+40(FP)
+	CALL	runtime·exitsyscall(SB)
+	RET
+
+TEXT ·RawSyscall(SB), NOSPLIT, $0-56
+	JMP	syscall·RawSyscall(SB)
+
+TEXT ·RawSyscall6(SB), NOSPLIT, $0-80
+	JMP	syscall·RawSyscall6(SB)
+
+TEXT ·RawSyscallNoError(SB), NOSPLIT, $0-48
+	MOVD	trap+0(FP), R1	// syscall entry
+	MOVD	a1+8(FP), R8
+	MOVD	a2+16(FP), R9
+	MOVD	a3+24(FP), R10
+	TA	$0x6d
+	MOVD	R8, r1+32(FP)
+	MOVD	R9, r2+40(FP)
+	RET
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/asm_zos_s390x.s /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/asm_zos_s390x.s
--- a/vendor/golang.org/x/sys/unix/asm_zos_s390x.s	2026-10-28 08:22:44.848102913 +0000
+++ b/vendor/golang.org/x/sys/unix/asm_zos_s390x.s	2026-10-28 08:23:38.372153487 +0000
@@ -30,21 +30,8 @@
 #define SVC_LOAD   BYTE $0x0A; BYTE $0x08 // SVC 08 LOAD
 #define SVC_DELETE BYTE $0x0A; BYTE $0x09 // SVC 09 DELETE
 
-DATA zosLibVec<>(SB)/8, $0
-GLOBL zosLibVec<>(SB), NOPTR, $8
-
-TEXT ·initZosLibVec(SB), NOSPLIT|NOFRAME, $0-0
-	MOVW PSALAA, R8
-	MOVD LCA64(R8), R8
-	MOVD CAA(R8), R8
-	MOVD EDCHPXV(R8), R8
-	MOVD R8, zosLibVec<>(SB)
-	RET
-
 TEXT ·GetZosLibVec(SB), NOSPLIT|NOFRAME, $0-0
-	MOVD zosLibVec<>(SB), R8
-	MOVD R8, ret+0(FP)
-	RET
+	JMP  runtime·GetZosLibVec(SB)
 
 TEXT ·clearErrno(SB), NOSPLIT, $0-0
 	BL   addrerrno<>(SB)
@@ -160,163 +147,13 @@
 // errno and errno2 is retrieved
 //
 TEXT ·CallLeFuncWithErr(SB), NOSPLIT, $0
-	MOVW PSALAA, R8
-	MOVD LCA64(R8), R8
-	MOVD CAA(R8), R9
-	MOVD g, GOCB(R9)
-
-	// Restore LE stack.
-	MOVD SAVSTACK_ASYNC(R8), R9 // R9-> LE stack frame saving address
-	MOVD 0(R9), R4              // R4-> restore previously saved stack frame pointer
-
-	MOVD parms_base+8(FP), R7 // R7 -> argument array
-	MOVD parms_len+16(FP), R8 // R8 number of arguments
-
-	//  arg 1 ---> R1
-	CMP  R8, $0
-	BEQ  docall
-	SUB  $1, R8
-	MOVD 0(R7), R1
-
-	//  arg 2 ---> R2
-	CMP  R8, $0
-	BEQ  docall
-	SUB  $1, R8
-	ADD  $8, R7
-	MOVD 0(R7), R2
-
-	//  arg 3 --> R3
-	CMP  R8, $0
-	BEQ  docall
-	SUB  $1, R8
-	ADD  $8, R7
-	MOVD 0(R7), R3
-
-	CMP  R8, $0
-	BEQ  docall
-	MOVD $2176+16, R6 // starting LE stack address-8 to store 4th argument
-
-repeat:
-	ADD  $8, R7
-	MOVD 0(R7), R0      // advance arg pointer by 8 byte
-	ADD  $8, R6         // advance LE argument address by 8 byte
-	MOVD R0, (R4)(R6*1) // copy argument from go-slice to le-frame
-	SUB  $1, R8
-	CMP  R8, $0
-	BNE  repeat
-
-docall:
-	MOVD funcdesc+0(FP), R8 // R8-> function descriptor
-	LMG  0(R8), R5, R6
-	MOVD $0, 0(R9)          // R9 address of SAVSTACK_ASYNC
-	LE_CALL                 // balr R7, R6 (return #1)
-	NOPH
-	MOVD R3, ret+32(FP)
-	CMP  R3, $-1            // compare result to -1
-	BNE  done
-
-	// retrieve errno and errno2
-	MOVD  zosLibVec<>(SB), R8
-	ADD   $(__errno), R8
-	LMG   0(R8), R5, R6
-	LE_CALL                   // balr R7, R6 __errno (return #3)
-	NOPH
-	MOVWZ 0(R3), R3
-	MOVD  R3, err+48(FP)
-	MOVD  zosLibVec<>(SB), R8
-	ADD   $(__err2ad), R8
-	LMG   0(R8), R5, R6
-	LE_CALL                   // balr R7, R6 __err2ad (return #2)
-	NOPH
-	MOVW  (R3), R2            // retrieve errno2
-	MOVD  R2, errno2+40(FP)   // store in return area
-
-done:
-	MOVD R4, 0(R9)            // Save stack pointer.
-	RET
-
+        JMP  runtime·CallLeFuncWithErr(SB)
 //
 // Call LE function, if the return is 0
 // errno and errno2 is retrieved
 //
 TEXT ·CallLeFuncWithPtrReturn(SB), NOSPLIT, $0
-	MOVW PSALAA, R8
-	MOVD LCA64(R8), R8
-	MOVD CAA(R8), R9
-	MOVD g, GOCB(R9)
-
-	// Restore LE stack.
-	MOVD SAVSTACK_ASYNC(R8), R9 // R9-> LE stack frame saving address
-	MOVD 0(R9), R4              // R4-> restore previously saved stack frame pointer
-
-	MOVD parms_base+8(FP), R7 // R7 -> argument array
-	MOVD parms_len+16(FP), R8 // R8 number of arguments
-
-	//  arg 1 ---> R1
-	CMP  R8, $0
-	BEQ  docall
-	SUB  $1, R8
-	MOVD 0(R7), R1
-
-	//  arg 2 ---> R2
-	CMP  R8, $0
-	BEQ  docall
-	SUB  $1, R8
-	ADD  $8, R7
-	MOVD 0(R7), R2
-
-	//  arg 3 --> R3
-	CMP  R8, $0
-	BEQ  docall
-	SUB  $1, R8
-	ADD  $8, R7
-	MOVD 0(R7), R3
-
-	CMP  R8, $0
-	BEQ  docall
-	MOVD $2176+16, R6 // starting LE stack address-8 to store 4th argument
-
-repeat:
-	ADD  $8, R7
-	MOVD 0(R7), R0      // advance arg pointer by 8 byte
-	ADD  $8, R6         // advance LE argument address by 8 byte
-	MOVD R0, (R4)(R6*1) // copy argument from go-slice to le-frame
-	SUB  $1, R8
-	CMP  R8, $0
-	BNE  repeat
-
-docall:
-	MOVD funcdesc+0(FP), R8 // R8-> function descriptor
-	LMG  0(R8), R5, R6
-	MOVD $0, 0(R9)          // R9 address of SAVSTACK_ASYNC
-	LE_CALL                 // balr R7, R6 (return #1)
-	NOPH
-	MOVD R3, ret+32(FP)
-	CMP  R3, $0             // compare result to 0
-	BNE  done
-
-	// retrieve errno and errno2
-	MOVD  zosLibVec<>(SB), R8
-	ADD   $(__errno), R8
-	LMG   0(R8), R5, R6
-	LE_CALL                   // balr R7, R6 __errno (return #3)
-	NOPH
-	MOVWZ 0(R3), R3
-	MOVD  R3, err+48(FP)
-	MOVD  zosLibVec<>(SB), R8
-	ADD   $(__err2ad), R8
-	LMG   0(R8), R5, R6
-	LE_CALL                   // balr R7, R6 __err2ad (return #2)
-	NOPH
-	MOVW  (R3), R2            // retrieve errno2
-	MOVD  R2, errno2+40(FP)   // store in return area
-	XOR   R2, R2
-	MOVWZ R2, (R3)            // clear errno2
-
-done:
-	MOVD R4, 0(R9)            // Save stack pointer.
-	RET
-
+        JMP runtime·CallLeFuncWithPtrReturn(SB)
 //
 // function to test if a pointer can be safely dereferenced (content read)
 // return 0 for succces
@@ -360,23 +197,4 @@
 //
 // func safeload(ptr uintptr) ( value uintptr, error uintptr)
 TEXT ·safeload(SB), NOSPLIT, $0-24
-	MOVD ptr+0(FP), R10                                                    // test pointer in R10
-	MOVD $0x0, R6
-	BYTE $0xE3; BYTE $0x20; BYTE $0x04; BYTE $0xB8; BYTE $0x00; BYTE $0x17 // llgt  2,1208
-	BYTE $0xB9; BYTE $0x17; BYTE $0x00; BYTE $0x22                         // llgtr 2,2
-	BYTE $0xA5; BYTE $0x26; BYTE $0x7F; BYTE $0xFF                         // nilh  2,32767
-	BYTE $0xE3; BYTE $0x22; BYTE $0x00; BYTE $0x58; BYTE $0x00; BYTE $0x04 // lg    2,88(2)
-	BYTE $0xE3; BYTE $0x22; BYTE $0x00; BYTE $0x08; BYTE $0x00; BYTE $0x04 // lg    2,8(2)
-	BYTE $0x41; BYTE $0x22; BYTE $0x03; BYTE $0x68                         // la    2,872(2)
-	BYTE $0xB9; BYTE $0x82; BYTE $0x00; BYTE $0x33                         // xgr   3,3
-	BYTE $0xA7; BYTE $0x55; BYTE $0x00; BYTE $0x04                         // bras  5,lbl1
-	BYTE $0xA7; BYTE $0x39; BYTE $0x00; BYTE $0x01                         // lghi  3,1
-	BYTE $0xB9; BYTE $0x02; BYTE $0x00; BYTE $0x33                         // lbl1     ltgr  3,3
-	BYTE $0xA7; BYTE $0x74; BYTE $0x00; BYTE $0x08                         // brc   b'0111',lbl2
-	BYTE $0xE3; BYTE $0x52; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x24 // stg 5,0(2)
-	BYTE $0xE3; BYTE $0x6A; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x04 // lg    6,0(10)
-	BYTE $0xB9; BYTE $0x82; BYTE $0x00; BYTE $0x99                         // lbl2     xgr   9,9
-	BYTE $0xE3; BYTE $0x92; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x24 // stg   9,0(2)
-	MOVD R6, value+8(FP)                                                   // result in R6
-	MOVD R3, error+16(FP)                                                  // error in R3
-	RET
+        JMP  runtime·ZosSafeLoad(SB)
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/bpxsvc_zos.s /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/bpxsvc_zos.s
--- a/vendor/golang.org/x/sys/unix/bpxsvc_zos.s	2026-10-28 08:22:44.848102913 +0000
+++ b/vendor/golang.org/x/sys/unix/bpxsvc_zos.s	2026-10-28 08:23:38.372153487 +0000
@@ -20,15 +20,15 @@
 	MOVD  plist_base+0(FP), R1  // r1 points to plist
 	MOVD  bpx_offset+24(FP), R2 // r2 offset to BPX vector table
 	MOVD  R14, R7               // save r14
-	MOVD  R15, R8               // save r15
-	MOVWZ 16(R0), R9
-	MOVWZ 544(R9), R9
-	MOVWZ 24(R9), R9            // call vector in r9
-	ADD   R2, R9                // add offset to vector table
-	MOVWZ (R9), R9              // r9 points to entry point
-	BYTE  $0x0D                 // BL R14,R9 --> basr r14,r9
-	BYTE  $0xE9                 // clobbers 0,1,14,15
-	MOVD  R8, R15               // restore 15
+	MOVD  R15, R9               // save r15
+	MOVWZ 16(R0), R15
+	MOVWZ 544(R15), R15
+	MOVWZ 24(R15), R15          // call vector in r15
+	ADD   R2, R15               // add offset to vector table
+	MOVWZ (R15), R15            // r15 points to entry point
+	BYTE  $0x0D                 // BL R14,R15 --> basr r14,r15
+	BYTE  $0xEF                 // clobbers 0,1,14,15
+	MOVD  R9, R15               // restore 15
 	JMP   R7                    // return via saved return address
 
 //   func A2e(arr [] byte)
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/fcntl_darwin.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/fcntl_darwin.go
--- a/vendor/golang.org/x/sys/unix/fcntl_darwin.go	2026-10-28 08:22:44.848102913 +0000
+++ b/vendor/golang.org/x/sys/unix/fcntl_darwin.go	2026-10-28 08:23:38.372153487 +0000
@@ -13,12 +13,12 @@
 
 // FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command.
 func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error {
-	_, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(lk))))
+	_, err := fcntlPtr(int(fd), cmd, unsafe.Pointer(lk))
 	return err
 }
 
 // FcntlFstore performs a fcntl syscall for the F_PREALLOCATE command.
 func FcntlFstore(fd uintptr, cmd int, fstore *Fstore_t) error {
-	_, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(fstore))))
+	_, err := fcntlPtr(int(fd), cmd, unsafe.Pointer(fstore))
 	return err
 }
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/mkerrors.sh /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/mkerrors.sh
--- a/vendor/golang.org/x/sys/unix/mkerrors.sh	2026-10-28 08:22:44.848102913 +0000
+++ b/vendor/golang.org/x/sys/unix/mkerrors.sh	2026-10-28 08:23:38.372153487 +0000
@@ -579,7 +579,7 @@
 		$2 ~ /^DIOC/ ||
 		$2 ~ /^RUSAGE_(SELF|CHILDREN|THREAD)/ ||
 		$2 ~ /^RLIMIT_(AS|CORE|CPU|DATA|FSIZE|LOCKS|MEMLOCK|MSGQUEUE|NICE|NOFILE|NPROC|RSS|RTPRIO|RTTIME|SIGPENDING|STACK)|RLIM_INFINITY/ ||
-		$2 ~ /^PRIO_(PROCESS|PGRP|USER)/ ||
+		$2 ~ /^PRIO_(PROCESS|PGRP|USER|DARWIN_(THREAD|PROCESS|BG|NONUI))/ ||
 		$2 ~ /^CLONE_[A-Z_]+/ ||
 		$2 !~ /^(BPF_TIMEVAL|BPF_FIB_LOOKUP_[A-Z]+|BPF_F_LINK)$/ &&
 		$2 ~ /^(BPF|DLT)_/ ||
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ptrace_zos.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ptrace_zos.go
--- a/vendor/golang.org/x/sys/unix/ptrace_zos.go	1970-01-01 00:00:00.000000000 +0000
+++ b/vendor/golang.org/x/sys/unix/ptrace_zos.go	2026-10-28 08:23:38.372153487 +0000
@@ -0,0 +1,537 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build zos
+
+package unix
+
+import "unsafe"
+
+// z/OS ptrace implementation notes:
+//
+// This file provides ptrace wrappers for z/OS that match the Linux API as closely
+// as possible. However, there are fundamental differences in how z/OS implements
+// process tracing compared to Linux:
+//
+// 1. SYSTEM CALL INTERFACE:
+//    - z/OS uses BPX4PTR (5 parameters) vs Linux ptrace syscall (4 parameters)
+//    - The 5th parameter (buffer) is used for block operations
+//
+// 2. MEMORY OPERATIONS:
+//    - z/OS: PT_READ_BLOCK/PT_WRITE_BLOCK for efficient block transfers
+//    - Linux: PTRACE_PEEKTEXT/POKETEXT for word-by-word access
+//
+// 3. REGISTER OPERATIONS:
+//    - z/OS: PT_READ_GPR/PT_WRITE_GPR with register number for 64-bit values
+//    - Linux: PTRACE_GETREGSET/SETREGSET with iovec structure
+//
+// 4. SINGLE-STEPPING:
+//    - z/OS: No native single-step; requires temporary breakpoints or PER
+//    - Linux: PTRACE_SINGLESTEP natively supported
+//      a) Read instruction at current PSW
+//      b) Calculate next instruction address (handle branches)
+//      c) Set temporary breakpoint (SVC 144 = 0x0A90) at next address
+//      d) Continue execution until breakpoint hit
+//      e) Restore original instruction and adjust PSW
+//
+// 5. SYSCALL TRACING:
+//    - z/OS: No PTRACE_SYSCALL equivalent; requires breakpoint-based approach
+//    - Linux: PTRACE_SYSCALL stops at syscall entry/exit
+//      a) Identify BPX syscall vector location
+//      b) Set breakpoints at syscall entry points
+//      c) Detect BASR instructions calling into syscall vector
+//      d) Parse arguments from registers before/after syscall
+//
+// 6. LIMITATIONS:
+//    - PtraceSetOptions: No equivalent (returns ENOSYS)
+//    - PtraceGetEventMsg: No equivalent (returns ENOSYS)
+//    - PtraceSingleStep: Requires complex implementation (returns ENOSYS)
+//    - PtraceInterrupt: No equivalent (returns ENOSYS)
+//    - PtracePokeUser: No PT_WRITE_U (returns ENOSYS)
+//
+// For reference implementations of single-stepping and syscall tracing on z/OS,
+
+// ptrace is the basic wrapper for BPX4PTR on z/OS.
+// Note: z/OS ptrace (BPX4PTR) takes 5 parameters vs 4 on Linux/Darwin.
+// The 5th parameter (buffer) is used for operations like PT_READ_BLOCK/PT_WRITE_BLOCK.
+//
+// data is an integer-valued argument (signal number, register index, byte count,
+// or a target-process address). It is not a Go-managed pointer. We must not pass
+// it to Bpx4ptr as unsafe.Pointer(data) because the garbage collector would treat
+// that integer as a pointer and may crash trying to follow it.
+//
+// Instead we inline the parms array that Bpx4ptr would construct, placing &data
+// at parms[3]. BPX4PTR dereferences parms[3] to obtain the data value, so it
+// receives data unchanged while the GC only ever sees a valid stack pointer.
+func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
+	req32 := int32(request)
+	pid32 := int32(pid)
+	var rv, rc, rn int32
+	var buffer unsafe.Pointer
+	parms := [8]unsafe.Pointer{
+		unsafe.Pointer(&req32),
+		unsafe.Pointer(&pid32),
+		unsafe.Pointer(&addr),
+		unsafe.Pointer(&data), // &data, not unsafe.Pointer(data)
+		unsafe.Pointer(&buffer),
+		unsafe.Pointer(&rv),
+		unsafe.Pointer(&rc),
+		unsafe.Pointer(&rn),
+	}
+	bpxcall(parms[:], BPX4PTR)
+	if rv != 0 {
+		err = errnoErr2(Errno(rc), uintptr(rn))
+	}
+	return
+}
+
+// ptracePtr is a variant that accepts unsafe.Pointer for the data parameter.
+// addr is a target-process address (a raw integer), not a Go-managed pointer.
+// We must not pass it to Bpx4ptr as unsafe.Pointer(addr); instead we inline the
+// parms array and place &addr at parms[2], exactly as ptrace() does for data.
+func ptracePtr(request int, pid int, addr uintptr, data unsafe.Pointer) (err error) {
+	req32 := int32(request)
+	pid32 := int32(pid)
+	var rv, rc, rn int32
+	var buffer unsafe.Pointer
+	parms := [8]unsafe.Pointer{
+		unsafe.Pointer(&req32),
+		unsafe.Pointer(&pid32),
+		unsafe.Pointer(&addr), // &addr, not unsafe.Pointer(addr)
+		unsafe.Pointer(&data),
+		unsafe.Pointer(&buffer),
+		unsafe.Pointer(&rv),
+		unsafe.Pointer(&rc),
+		unsafe.Pointer(&rn),
+	}
+	bpxcall(parms[:], BPX4PTR)
+	if rv != 0 {
+		err = errnoErr2(Errno(rc), uintptr(rn))
+	}
+	return
+}
+
+// ptracePtrWithBuffer is used for operations that require the buffer parameter.
+// addr is a target-process address; same &addr treatment as ptracePtr.
+func ptracePtrWithBuffer(request int, pid int, addr uintptr, data unsafe.Pointer, buffer unsafe.Pointer) (err error) {
+	req32 := int32(request)
+	pid32 := int32(pid)
+	var rv, rc, rn int32
+	parms := [8]unsafe.Pointer{
+		unsafe.Pointer(&req32),
+		unsafe.Pointer(&pid32),
+		unsafe.Pointer(&addr), // &addr, not unsafe.Pointer(addr)
+		unsafe.Pointer(&data),
+		unsafe.Pointer(&buffer),
+		unsafe.Pointer(&rv),
+		unsafe.Pointer(&rc),
+		unsafe.Pointer(&rn),
+	}
+	bpxcall(parms[:], BPX4PTR)
+	if rv != 0 {
+		err = errnoErr2(Errno(rc), uintptr(rn))
+	}
+	return
+}
+
+// High-level convenience functions matching the Linux/Darwin API
+
+func PtraceAttach(pid int) (err error) {
+	return ptrace(PT_ATTACH, pid, 0, 0)
+}
+
+func PtraceDetach(pid int) (err error) {
+	return ptrace(PT_DETACH, pid, 0, 0)
+}
+
+func PtraceCont(pid int, signal int) (err error) {
+	// PT_CONTINUE can be interrupted by signals (EINTR), retry if needed
+	for {
+		err = ptrace(PT_CONTINUE, pid, 0, uintptr(signal))
+		if err != EINTR {
+			break
+		}
+	}
+	return err
+}
+
+func PtraceKill(pid int) (err error) {
+	return ptrace(PT_KILL, pid, 0, 0)
+}
+
+// ptracePeek implements the peek operations using PT_READ_BLOCK.
+// On z/OS, PT_READ_BLOCK can read arbitrary-length data efficiently.
+// Unlike Linux which reads word-by-word, z/OS can read blocks directly.
+func ptracePeek(req int, pid int, addr uintptr, out []byte) (count int, err error) {
+	if len(out) == 0 {
+		return 0, nil
+	}
+
+	// z/OS PT_READ_BLOCK can read blocks directly without word-by-word alignment
+	// The buffer parameter points to the output buffer
+	buffer := unsafe.Pointer(&out[0])
+	err = ptracePtrWithBuffer(req, pid, addr, unsafe.Pointer(uintptr(len(out))), buffer)
+	if err != nil {
+		return 0, err
+	}
+	return len(out), nil
+}
+
+// PtracePeekText reads from the traced process's text segment.
+func PtracePeekText(pid int, addr uintptr, out []byte) (count int, err error) {
+	return ptracePeek(PT_READ_BLOCK, pid, addr, out)
+}
+
+// PtracePeekData reads from the traced process's data segment.
+func PtracePeekData(pid int, addr uintptr, out []byte) (count int, err error) {
+	return ptracePeek(PT_READ_BLOCK, pid, addr, out)
+}
+
+// PtracePeekUser reads from the traced process's user area.
+// On z/OS, PT_READ_U reads a 32-bit word from the user area at the specified offset.
+// To match Linux behavior, we implement word-by-word reading for arbitrary lengths.
+func PtracePeekUser(pid int, addr uintptr, out []byte) (count int, err error) {
+	if len(out) == 0 {
+		return 0, nil
+	}
+
+	// PT_READ_U reads 32-bit words from user area
+	// We need to read word-by-word to handle arbitrary lengths
+	n := 0
+	for n < len(out) {
+		var data uint32
+		err = ptracePtr(PT_READ_U, pid, addr+uintptr(n), unsafe.Pointer(&data))
+		if err != nil {
+			return n, err
+		}
+
+		// Copy up to 4 bytes to output
+		remaining := len(out) - n
+		if remaining >= 4 {
+			out[n] = byte(data >> 24)
+			out[n+1] = byte(data >> 16)
+			out[n+2] = byte(data >> 8)
+			out[n+3] = byte(data)
+			n += 4
+		} else {
+			// Handle partial word at the end
+			for i := 0; i < remaining; i++ {
+				out[n+i] = byte(data >> (24 - i*8))
+			}
+			n += remaining
+		}
+	}
+	return n, nil
+}
+
+// ptracePoke implements the poke operations using PT_WRITE_BLOCK.
+func ptracePoke(pokeReq int, peekReq int, pid int, addr uintptr, data []byte) (count int, err error) {
+	if len(data) == 0 {
+		return 0, nil
+	}
+
+	// z/OS PT_WRITE_BLOCK can write blocks directly
+	buffer := unsafe.Pointer(&data[0])
+	err = ptracePtrWithBuffer(pokeReq, pid, addr, unsafe.Pointer(uintptr(len(data))), buffer)
+	if err != nil {
+		return 0, err
+	}
+	return len(data), nil
+}
+
+// PtracePokeText writes to the traced process's text segment.
+func PtracePokeText(pid int, addr uintptr, data []byte) (count int, err error) {
+	return ptracePoke(PT_WRITE_BLOCK, PT_READ_BLOCK, pid, addr, data)
+}
+
+// PtracePokeData writes to the traced process's data segment.
+func PtracePokeData(pid int, addr uintptr, data []byte) (count int, err error) {
+	return ptracePoke(PT_WRITE_BLOCK, PT_READ_BLOCK, pid, addr, data)
+}
+
+// PtracePokeUser writes to the traced process's user area.
+// Note: z/OS does not have a direct PT_WRITE_U equivalent.
+// This function returns ENOSYS to indicate it's not supported.
+// DIFFERENCE FROM LINUX: Linux supports PTRACE_POKEUSR, z/OS does not.
+func PtracePokeUser(pid int, addr uintptr, data []byte) (count int, err error) {
+	// z/OS doesn't have PT_WRITE_U
+	return 0, ENOSYS
+}
+
+// PtraceGetRegs retrieves the general purpose registers from the traced process.
+// On z/OS, PT_READ_GPR can read individual registers as 64-bit values when called
+// with a register number, or read all registers when called with a buffer.
+// This function reads each register individually to ensure full 64-bit values.
+// DIFFERENCE FROM LINUX: Linux uses PTRACE_GETREGSET with iovec, z/OS uses PT_READ_GPR.
+func PtraceGetRegs(pid int, regsout *PtraceRegs) (err error) {
+	// Use PT_REGHSET to enable reading high GPRs for AMODE 64 programs
+	rv, rc, rn := Bpx4ptr(int32(PT_REGHSET), int32(pid), nil, nil, nil)
+	_ = rv
+	_ = rc
+	_ = rn
+
+	// Use PT_BLOCKREQ to read GPRs and PSW in one call
+	// dbx uses 3 requests: PT_READ_GPR, PT_READ_U, PT_READ_GPRH
+	// PT_READ_U is required for ptrace to populate PSW in GPR block
+	//
+	// IMPORTANT: z/OS ptrace always returns 64-bit ESA/390 format PSW in the Psw field.
+	// The 128-bit Pswg field is never populated, even with PSWG_Req bit set.
+	// We convert ESA/390 to z/Architecture format in software (matching DBX behavior).
+	const (
+		numRequests = 3
+		reqSize     = int(unsafe.Sizeof(PtraceBlkReqReq{}))
+		gprSize     = int(unsafe.Sizeof(PtraceBlkGpr{}))
+		uareaSize   = int(unsafe.Sizeof(PtraceBlkUar{})) + 6*int(unsafe.Sizeof(PtraceBlkUarOcw{}))
+		totalSize   = int(unsafe.Sizeof(PtraceBlkReq{})) + numRequests*reqSize + gprSize*2 + uareaSize
+	)
+
+	// Allocate buffer for block request
+	buf := make([]byte, totalSize)
+
+	// Setup block request header
+	blkReq := (*PtraceBlkReq)(unsafe.Pointer(&buf[0]))
+	blkReq.Numreq = numRequests
+
+	// Setup request array
+	reqOffset := int(unsafe.Sizeof(PtraceBlkReq{}))
+	reqs := (*[3]PtraceBlkReqReq)(unsafe.Pointer(&buf[reqOffset]))
+
+	// Setup GPR block (lower 32 bits)
+	gprOffset := reqOffset + numRequests*reqSize
+	gprBlock := (*PtraceBlkGpr)(unsafe.Pointer(&buf[gprOffset]))
+
+	// Setup user area block (required for PSW)
+	uareaOffset := gprOffset + gprSize
+	uareaBlock := (*PtraceBlkUar)(unsafe.Pointer(&buf[uareaOffset]))
+	uareaBlock.Num = 6 // Number of control info entries
+
+	// Setup user area offset/control words
+	uareaOcw := (*[6]PtraceBlkUarOcw)(unsafe.Pointer(&buf[uareaOffset+int(unsafe.Sizeof(PtraceBlkUar{}))]))
+	uareaOcw[0].Ofs = 1025 // program interrupt code
+	uareaOcw[1].Ofs = 1026 // abend completion code
+	uareaOcw[2].Ofs = 1027 // abend reason code
+	uareaOcw[3].Ofs = 1028 // signal code
+	uareaOcw[4].Ofs = 1029 // instruction length code
+	uareaOcw[5].Ofs = 1030 // process flags
+
+	// Setup high GPR block (upper 32 bits)
+	gprHighOffset := uareaOffset + uareaSize
+	gprHighBlock := (*PtraceBlkGpr)(unsafe.Pointer(&buf[gprHighOffset]))
+
+	// Configure requests (order matters: GPR, U, GPRH)
+	// reqdata contains OFFSET from buffer start, not absolute address
+	// dbx: brr[0].reqdata=(unsigned long)brg; where brg is the offset
+	reqs[0].Reqtype = PT_READ_GPR
+	reqs[0].Reqdata = uint32(gprOffset)
+	reqs[1].Reqtype = PT_READ_U
+	reqs[1].Reqdata = uint32(uareaOffset)
+	reqs[2].Reqtype = PT_READ_GPRH
+	reqs[2].Reqdata = uint32(gprHighOffset)
+
+	// Execute block request
+	rvBlk, rcBlk, rnBlk := Bpx4ptr(int32(PT_BLOCKREQ), int32(pid),
+		unsafe.Pointer(&buf[0]), unsafe.Pointer(uintptr(totalSize)), nil)
+	if rvBlk == -1 {
+		return errnoErr2(Errno(rcBlk), uintptr(rnBlk))
+	}
+
+	// Extract GPRs (combine low and high 32 bits)
+	for i := 0; i < 16; i++ {
+		low := uint64(gprBlock.Gpr[i])
+		high := uint64(gprHighBlock.Gpr[i]) << 32
+		regsout.Gprs[i] = high | low
+	}
+
+	// Extract PSW from GPR block structure
+	// z/OS ptrace ALWAYS returns 8-byte ESA/390 format PSW at offset 144.
+	// The 16-byte PSWG field at offset 152 is NEVER populated (always zero).
+	// We must convert ESA/390 format to z/Architecture format in software (like DBX does).
+	//
+	// ESA/390 PSW format (8 bytes):
+	//   Word 1 (bytes 0-3): Mask with bit 12 = 1 (ECMODE31BIT)
+	//   Word 2 (bytes 4-7): Address with bit 0 = AMODE bit (1=31-bit, 0=64-bit)
+	//
+	// z/Architecture PSW format (16 bytes):
+	//   Mask (bytes 0-7): Extended mask with bit 12 = 0, bits 31-32 = EA+BA (AMODE)
+	//   Addr (bytes 8-15): Full 64-bit instruction address
+
+	// Read ESA/390 PSW as two 32-bit words
+	pswWord1 := uint32(gprBlock.Psw[0])<<24 | uint32(gprBlock.Psw[1])<<16 |
+		uint32(gprBlock.Psw[2])<<8 | uint32(gprBlock.Psw[3])
+	pswWord2 := uint32(gprBlock.Psw[4])<<24 | uint32(gprBlock.Psw[5])<<16 |
+		uint32(gprBlock.Psw[6])<<8 | uint32(gprBlock.Psw[7])
+
+	// Convert ESA/390 to z/Architecture format (matching DBX psw_ESA390_to_zArchitecture)
+	const ECMODE31BIT = uint64(0x0000000000080000)
+	const AMODE31BIT = uint64(0x0000000080000000)
+	const ADDR_MASK_31 = uint64(0x000000007FFFFFFF)
+
+	// Extract AMODE bit from address word (bit 0 of word 2)
+	amode31 := uint64(pswWord2) & AMODE31BIT
+
+	// Mask off AMODE bit from address
+	addr := uint64(pswWord2) & ADDR_MASK_31
+
+	// Convert mask: clear ECMODE31BIT, shift left 32 bits, add AMODE bit
+	mask := uint64(pswWord1) & ^ECMODE31BIT
+	mask = (mask << 32) | amode31
+
+	regsout.Psw.Mask = mask
+	regsout.Psw.Addr = addr
+
+	// Note: Access registers (Acrs), floating point registers (Fp_regs),
+	// PER info (Per_info), and other fields would require additional
+	// PT_READ_* calls. For now, we focus on GPRs and PSW which are
+	// the most commonly used registers for debugging.
+
+	return nil
+}
+
+// ptraceWritePSW writes only the PSW address register.
+// This is a lower-level function used internally for single-stepping.
+// Based on ztrace's write_psw function.
+func ptraceWritePSW(pid int, pswAddr uint32) error {
+	const PTRACE_REG_PSWA = 41
+	rv, rc, rn := Bpx4ptr(int32(PT_WRITE_GPR), int32(pid),
+		unsafe.Pointer(uintptr(PTRACE_REG_PSWA)),
+		unsafe.Pointer(uintptr(pswAddr)),
+		nil)
+	if rv == -1 {
+		return errnoErr2(Errno(rc), uintptr(rn))
+	}
+	return nil
+}
+
+// PtraceSetRegs sets the general purpose registers in the traced process.
+// Uses PT_BLOCKREQ to write GPRs and PSW in a single call, matching dbx implementation.
+// DIFFERENCE FROM LINUX: Linux uses PTRACE_SETREGSET with iovec, z/OS uses PT_BLOCKREQ.
+// NOTE: The process must be in a stopped state for register writes to succeed.
+func PtraceSetRegs(pid int, regs *PtraceRegs) (err error) {
+	// Use PT_REGHSET to enable writing high GPRs for AMODE 64 programs
+	rv, rc, rn := Bpx4ptr(int32(PT_REGHSET), int32(pid), nil, nil, nil)
+	_ = rv
+	_ = rc
+	_ = rn
+
+	// Use PT_BLOCKREQ to write GPRs and PSW in one call
+	const (
+		numRequests = 2
+		reqSize     = int(unsafe.Sizeof(PtraceBlkReqReq{}))
+		gprSize     = int(unsafe.Sizeof(PtraceBlkGpr{}))
+		totalSize   = int(unsafe.Sizeof(PtraceBlkReq{})) + numRequests*reqSize + gprSize*2
+	)
+
+	// Allocate buffer for block request
+	buf := make([]byte, totalSize)
+
+	// Setup block request header
+	blkReq := (*PtraceBlkReq)(unsafe.Pointer(&buf[0]))
+	blkReq.Numreq = numRequests
+
+	// Setup request array
+	reqOffset := int(unsafe.Sizeof(PtraceBlkReq{}))
+	reqs := (*[2]PtraceBlkReqReq)(unsafe.Pointer(&buf[reqOffset]))
+
+	// Setup GPR block (lower 32 bits)
+	gprOffset := reqOffset + numRequests*reqSize
+	gprBlock := (*PtraceBlkGpr)(unsafe.Pointer(&buf[gprOffset]))
+
+	// Setup high GPR block (upper 32 bits)
+	gprHighOffset := gprOffset + gprSize
+	gprHighBlock := (*PtraceBlkGpr)(unsafe.Pointer(&buf[gprHighOffset]))
+
+	// Mark all GPRs as modified (set all 16 bits)
+	gprBlock.Writebitflags = 0xFFFF
+	gprHighBlock.Writebitflags = 0xFFFF
+
+	// Split 64-bit GPRs into low and high 32 bits
+	for i := 0; i < 16; i++ {
+		gprBlock.Gpr[i] = uint32(regs.Gprs[i] & 0xFFFFFFFF)
+		gprHighBlock.Gpr[i] = uint32(regs.Gprs[i] >> 32)
+	}
+
+	// Pack PSW for 31-bit targets (current z/OS)
+	// Upper 32 bits = mask, lower 32 bits = address
+	gprBlock.Wpsw = 1 // Mark PSW as modified
+	// Write PSW in old format (8 bytes at offset 144)
+	// Word 1 (mask) at bytes 0-3, Word 2 (addr) at bytes 4-7
+	pswMask := uint32(regs.Psw.Mask)
+	pswAddr := uint32(regs.Psw.Addr)
+	gprBlock.Psw[0] = byte(pswMask >> 24)
+	gprBlock.Psw[1] = byte(pswMask >> 16)
+	gprBlock.Psw[2] = byte(pswMask >> 8)
+	gprBlock.Psw[3] = byte(pswMask)
+	gprBlock.Psw[4] = byte(pswAddr >> 24)
+	gprBlock.Psw[5] = byte(pswAddr >> 16)
+	gprBlock.Psw[6] = byte(pswAddr >> 8)
+	gprBlock.Psw[7] = byte(pswAddr)
+
+	// Clear extended PSWG (not used for 31-bit targets)
+	for i := 0; i < 16; i++ {
+		gprBlock.Pswg[i] = 0
+	}
+
+	// Configure requests
+	// reqdata contains OFFSET from buffer start, not absolute address
+	reqs[0].Reqtype = PT_WRITE_GPR
+	reqs[0].Reqdata = uint32(gprOffset)
+	reqs[1].Reqtype = PT_WRITE_GPRH
+	reqs[1].Reqdata = uint32(gprHighOffset)
+
+	// Execute block request
+	rvBlk, rcBlk, rnBlk := Bpx4ptr(int32(PT_BLOCKREQ), int32(pid),
+		unsafe.Pointer(&buf[0]), unsafe.Pointer(uintptr(totalSize)), nil)
+	if rvBlk == -1 {
+		return errnoErr2(Errno(rcBlk), uintptr(rnBlk))
+	}
+
+	return nil
+}
+
+// PtraceSetOptions sets ptrace options.
+// DIFFERENCE FROM LINUX: z/OS doesn't have PTRACE_SETOPTIONS equivalent.
+// Returns ENOSYS to indicate this is not supported on z/OS.
+func PtraceSetOptions(pid int, options int) (err error) {
+	return ENOSYS
+}
+
+// PtraceGetEventMsg retrieves a message about the ptrace event.
+// DIFFERENCE FROM LINUX: z/OS doesn't have PTRACE_GETEVENTMSG equivalent.
+// Returns ENOSYS to indicate this is not supported on z/OS.
+func PtraceGetEventMsg(pid int) (msg uint, err error) {
+	return 0, ENOSYS
+}
+
+// PtraceSyscall continues execution and stops at the next syscall entry/exit.
+// DIFFERENCE FROM LINUX: z/OS doesn't have PTRACE_SYSCALL equivalent.
+// This function falls back to PT_CONTINUE and will NOT stop at syscalls.
+//
+// To trace syscalls on z/OS, applications must:
+// 1. Set breakpoints at BPX syscall entry points (requires knowledge of syscall vector)
+// 2. Detect BASR instructions that call into the BPX syscall vector
+// 3. Use PT_LDINFO to identify loaded modules and their entry points
+func PtraceSyscall(pid int, signal int) (err error) {
+	// z/OS doesn't have a direct PTRACE_SYSCALL equivalent
+	// Use PT_CONTINUE as a fallback (won't stop at syscalls)
+	return ptrace(PT_CONTINUE, pid, 0, uintptr(signal))
+}
+
+// Note: PtraceSingleStep is implemented in ptrace_zos_singlestep.go
+// with full two-breakpoint emulation for branch instructions.
+
+// PtraceInterrupt interrupts the traced process.
+// DIFFERENCE FROM LINUX: z/OS doesn't have PTRACE_INTERRUPT equivalent.
+// Returns ENOSYS to indicate this is not supported on z/OS.
+func PtraceInterrupt(pid int) (err error) {
+	return ENOSYS
+}
+
+// PtraceSeize attaches to a process without stopping it.
+// DIFFERENCE FROM LINUX: z/OS doesn't have PTRACE_SEIZE equivalent.
+// Uses PT_ATTACH as a fallback, which will stop the process.
+func PtraceSeize(pid int) (err error) {
+	// z/OS doesn't have PTRACE_SEIZE, use PT_ATTACH
+	// Note: This WILL stop the process, unlike Linux PTRACE_SEIZE
+	return ptrace(PT_ATTACH, pid, 0, 0)
+}
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ptrace_zos_singlestep.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ptrace_zos_singlestep.go
--- a/vendor/golang.org/x/sys/unix/ptrace_zos_singlestep.go	1970-01-01 00:00:00.000000000 +0000
+++ b/vendor/golang.org/x/sys/unix/ptrace_zos_singlestep.go	2026-10-28 08:23:38.372153487 +0000
@@ -0,0 +1,425 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build zos
+
+package unix
+
+import (
+	"sync"
+)
+
+// Single-stepping emulation for z/OS
+//
+// z/OS does not have native single-step support like Linux's PTRACE_SINGLESTEP.
+// Instead, single-stepping must be emulated using temporary breakpoints.
+//
+// This file provides a complete implementation of single-step emulation using
+// temporary breakpoints at both the sequential next instruction and branch target.
+
+const (
+	// NO_BRANCH_DEST indicates the instruction is not a branch or cannot branch
+	NO_BRANCH_DEST = 0xFFFFFFFF
+
+	// SVC_144 is the breakpoint instruction (SVC 144 = 0x0A90)
+	SVC_144 = 0x0A90
+
+	// Maximum number of temporary breakpoints (one for next PC, one for branch dest)
+	MAX_TEMP_BREAKPOINTS = 2
+
+	// S/390 branch instruction opcodes
+	// RR format (Register-Register)
+	opBCR   = 0x07 // Branch on Condition Register
+	opBALR  = 0x05 // Branch and Link Register
+	opBASR  = 0x0D // Branch and Save Register
+	opBASSM = 0x0C // Branch and Save and Set Mode
+	opBSM   = 0x0B // Branch and Set Mode
+	opBCTR  = 0x06 // Branch on Count Register
+
+	// RX format (Register-Index-Storage)
+	opBC  = 0x47 // Branch on Condition
+	opBAL = 0x45 // Branch and Link
+	opBCT = 0x46 // Branch on Count
+	opBAS = 0x4D // Branch and Save
+
+	// RS format (Register-Storage)
+	opBXH  = 0x86 // Branch on Index High
+	opBXLE = 0x87 // Branch on Index Low or Equal
+
+	// Extended branch opcodes
+	opBA7 = 0xA7 // A7x series (BRC, BRAS, BRCT, BRCTG)
+	opBC0 = 0xC0 // C0x series (BRASL, BRCL)
+	opBEC = 0xEC // ECxx series (RIEc format: compare-and-branch)
+)
+
+// tempBreakpoint represents a temporary breakpoint for single-stepping
+type tempBreakpoint struct {
+	address      uint64
+	originalInsn [8]byte // Save up to 8 bytes (full instruction)
+	active       bool
+}
+
+// singleStepState manages temporary breakpoints for a process
+type singleStepState struct {
+	mu          sync.Mutex
+	breakpoints [MAX_TEMP_BREAKPOINTS]tempBreakpoint
+}
+
+var (
+	// Global map of process states (pid -> state)
+	processStates   = make(map[int]*singleStepState)
+	processStatesMu sync.Mutex
+)
+
+// getProcessState returns or creates the single-step state for a process
+func getProcessState(pid int) *singleStepState {
+	processStatesMu.Lock()
+	defer processStatesMu.Unlock()
+
+	state, exists := processStates[pid]
+	if !exists {
+		state = &singleStepState{}
+		processStates[pid] = state
+	}
+	return state
+}
+
+// cleanupProcessState removes the state for a process (call on detach)
+func cleanupProcessState(pid int) {
+	processStatesMu.Lock()
+	defer processStatesMu.Unlock()
+	delete(processStates, pid)
+}
+
+// GetInstructionLength returns the length of an S/390 instruction in bytes.
+func GetInstructionLength(firstByte byte) int {
+	switch (firstByte >> 6) & 0x03 {
+	case 0x00:
+		return 2
+	case 0x01, 0x02:
+		return 4
+	case 0x03:
+		return 6
+	default:
+		return 2
+	}
+}
+
+// GetNextInstructionAddr returns the address of the next sequential instruction.
+func GetNextInstructionAddr(pc uint64, instruction []byte) uint64 {
+	if len(instruction) < 1 {
+		return pc + 2
+	}
+	insnLen := GetInstructionLength(instruction[0])
+	return pc + uint64(insnLen)
+}
+
+// CalculateBranchDest calculates the destination address for branch instructions.
+func CalculateBranchDest(pid int, pc uint64, instruction []byte) uint64 {
+	if len(instruction) < 6 {
+		return NO_BRANCH_DEST
+	}
+
+	inst0_15 := uint16(instruction[0])<<8 | uint16(instruction[1])
+	inst16_31 := uint16(instruction[2])<<8 | uint16(instruction[3])
+	inst32_47 := uint16(instruction[4])<<8 | uint16(instruction[5])
+	opcode := instruction[0]
+
+	var dest uint64 = NO_BRANCH_DEST
+
+	// RR format branches
+	if opcode == opBCR || opcode == opBALR || opcode == opBASR ||
+		opcode == opBASSM || opcode == opBSM || opcode == opBCTR {
+
+		r2 := int(inst0_15 & 0x0F)
+
+		if opcode == opBCR {
+			mask := int((inst0_15 >> 4) & 0x0F)
+			if mask == 0 || r2 == 0 {
+				return NO_BRANCH_DEST
+			}
+		} else {
+			if r2 == 0 {
+				return NO_BRANCH_DEST
+			}
+		}
+
+		var regs PtraceRegs
+		if err := PtraceGetRegs(pid, &regs); err == nil {
+			if r2 >= 0 && r2 < 16 {
+				regVal := regs.Gprs[r2]
+				dest = regVal
+			}
+		}
+	} else if opcode == opBC || opcode == opBAL || opcode == opBCT || opcode == opBAS {
+		// RX format branches
+		if opcode == opBC {
+			mask := int((inst0_15 >> 4) & 0x0F)
+			if mask == 0 {
+				return NO_BRANCH_DEST
+			}
+		}
+
+		index := int(inst0_15 & 0x0F)
+		base := int((inst16_31 >> 12) & 0x0F)
+		displacement := uint32(inst16_31 & 0x0FFF)
+
+		var baseVal, indexVal uint64
+		var regs PtraceRegs
+		if err := PtraceGetRegs(pid, &regs); err == nil {
+			if base != 0 && base < 16 {
+				baseVal = regs.Gprs[base]
+			}
+			if index != 0 && index < 16 {
+				indexVal = regs.Gprs[index]
+			}
+		}
+
+		if base == 0 && index == 0 {
+			dest = pc + uint64(displacement)
+		} else {
+			dest = baseVal + indexVal + uint64(displacement)
+		}
+	} else if opcode == opBXH || opcode == opBXLE {
+		// RS format branches
+		base := int((inst16_31 >> 12) & 0x0F)
+		displacement := uint32(inst16_31 & 0x0FFF)
+
+		var baseVal uint64
+		var regs PtraceRegs
+		if err := PtraceGetRegs(pid, &regs); err == nil {
+			if base != 0 && base < 16 {
+				baseVal = regs.Gprs[base]
+			}
+		}
+
+		dest = baseVal + uint64(displacement)
+	} else if opcode == opBA7 {
+		// RI format branches
+		subOp := int(inst0_15 & 0x0F)
+
+		if subOp < 4 || subOp > 7 {
+			return NO_BRANCH_DEST
+		}
+
+		if subOp == 0x04 {
+			mask := int((inst0_15 >> 4) & 0x0F)
+			if mask == 0 {
+				return NO_BRANCH_DEST
+			}
+		}
+
+		relDispl := int16(inst16_31)
+		dest = uint64(int64(pc) + int64(relDispl)*2)
+	} else if opcode == opBC0 {
+		// RIL format branches
+		subOp := int(inst0_15 & 0x0F)
+
+		if subOp == 0x04 || subOp == 0x05 {
+			if subOp == 0x04 {
+				mask := int((inst0_15 >> 4) & 0x0F)
+				if mask == 0 {
+					return NO_BRANCH_DEST
+				}
+			}
+
+			inst16_47 := (uint32(inst16_31) << 16) | uint32(inst32_47)
+			relDispl4 := int32(inst16_47)
+			dest = uint64(int64(pc) + int64(relDispl4)*2)
+		}
+	} else if opcode == opBEC {
+		// RIEc format compare-and-branch
+		subOp := instruction[4]
+
+		isCompareBranch := (subOp >= 0x64 && subOp <= 0x67) ||
+			(subOp >= 0x76 && subOp <= 0x77) ||
+			(subOp >= 0x7C && subOp <= 0x7F)
+
+		if isCompareBranch {
+			ri4 := int16(inst16_31)
+			dest = uint64(int64(pc) + int64(ri4)*2)
+		}
+	}
+
+	if dest < 0x2000 {
+		return NO_BRANCH_DEST
+	}
+
+	return dest
+}
+
+// setTempBreakpoint sets a temporary breakpoint at the specified address
+func (s *singleStepState) setTempBreakpoint(pid int, addr uint64) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	// Find free slot
+	slot := -1
+	for i := 0; i < MAX_TEMP_BREAKPOINTS; i++ {
+		if !s.breakpoints[i].active {
+			slot = i
+			break
+		}
+	}
+
+	if slot == -1 {
+		return ENOMEM // All slots in use
+	}
+
+	// Read original instruction (up to 8 bytes for safety)
+	_, err := PtracePeekText(pid, uintptr(addr), s.breakpoints[slot].originalInsn[:])
+	if err != nil {
+		return err
+	}
+
+	// Write SVC 144 (0x0A90) as breakpoint
+	svc144 := []byte{0x0A, 0x90}
+	_, err = PtracePokeText(pid, uintptr(addr), svc144)
+	if err != nil {
+		return err
+	}
+
+	s.breakpoints[slot].address = addr
+	s.breakpoints[slot].active = true
+
+	return nil
+}
+
+// removeTempBreakpoints removes all active temporary breakpoints
+func (s *singleStepState) removeTempBreakpoints(pid int) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	var lastErr error
+	for i := 0; i < MAX_TEMP_BREAKPOINTS; i++ {
+		if !s.breakpoints[i].active {
+			continue
+		}
+
+		// Restore original instruction (first 2 bytes are enough for SVC 144)
+		_, err := PtracePokeText(pid, uintptr(s.breakpoints[i].address), s.breakpoints[i].originalInsn[:2])
+		if err != nil {
+			lastErr = err
+		}
+
+		s.breakpoints[i].active = false
+	}
+
+	return lastErr
+}
+
+// isTempBreakpoint checks if an address is a temporary breakpoint
+func (s *singleStepState) isTempBreakpoint(addr uint64) bool {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	for i := 0; i < MAX_TEMP_BREAKPOINTS; i++ {
+		if s.breakpoints[i].active && s.breakpoints[i].address == addr {
+			return true
+		}
+	}
+	return false
+}
+
+// PtraceSingleStep executes a single instruction using temporary breakpoints.
+//
+// This function:
+// 1. Reads the current instruction at PSW
+// 2. Calculates the next instruction address (sequential)
+// 3. If branch instruction, calculates branch destination
+// 4. Sets temporary breakpoints at both addresses
+// 5. Continues execution until breakpoint hit
+// 6. Restores original instructions and adjusts PSW
+//
+// Returns nil on success, error on failure.
+func PtraceSingleStep(pid int) error {
+	state := getProcessState(pid)
+
+	// 1. Get current PSW
+	var regs PtraceRegs
+	if err := PtraceGetRegs(pid, &regs); err != nil {
+		return err
+	}
+	pc := regs.Psw.Addr
+
+	// 2. Read instruction at PC
+	insn := make([]byte, 8)
+	if _, err := PtracePeekText(pid, uintptr(pc), insn); err != nil {
+		return err
+	}
+
+	// 3. Calculate next instruction addresses
+	nextPC := GetNextInstructionAddr(pc, insn)
+	branchDest := CalculateBranchDest(pid, pc, insn)
+
+	// 4. Set temporary breakpoints
+	if err := state.setTempBreakpoint(pid, nextPC); err != nil {
+		return err
+	}
+
+	// If branch instruction, set breakpoint at branch destination too
+	if branchDest != NO_BRANCH_DEST && branchDest != nextPC {
+		if err := state.setTempBreakpoint(pid, branchDest); err != nil {
+			state.removeTempBreakpoints(pid) // Cleanup first breakpoint
+			return err
+		}
+	}
+
+	// 5. Continue execution
+	if err := PtraceCont(pid, 0); err != nil {
+		state.removeTempBreakpoints(pid)
+		return err
+	}
+
+	// 6. Wait for breakpoint hit (retry on EINTR)
+	var status WaitStatus
+	for {
+		_, err := Wait4(pid, &status, 0, nil)
+		if err == EINTR {
+			continue // Retry on interrupted system call
+		}
+		if err != nil {
+			state.removeTempBreakpoints(pid)
+			return err
+		}
+		break
+	}
+
+	// Check if process stopped (should be at breakpoint)
+	if !status.Stopped() {
+		state.removeTempBreakpoints(pid)
+		return ECHILD // Process exited or error
+	}
+
+	// 7. Get current PSW (should be at breakpoint + 2)
+	if err := PtraceGetRegs(pid, &regs); err != nil {
+		state.removeTempBreakpoints(pid)
+		return err
+	}
+
+	// 8. Remove temporary breakpoints
+	if err := state.removeTempBreakpoints(pid); err != nil {
+		return err
+	}
+
+	// 9. Back up PSW by 2 bytes (to point at original instruction, not SVC 144)
+	// Use direct PSW write like ztrace does, not full register set
+	hitAddr := regs.Psw.Addr
+	if state.isTempBreakpoint(hitAddr - 2) {
+		if err := ptraceWritePSW(pid, uint32(hitAddr-2)); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// PtraceDetachWithCleanup detaches from a process and cleans up single-step state.
+// Use this instead of PtraceDetach when using PtraceSingleStep.
+func PtraceDetachWithCleanup(pid int) error {
+	state := getProcessState(pid)
+	state.removeTempBreakpoints(pid)
+	cleanupProcessState(pid)
+	return PtraceDetach(pid)
+}
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/syscall_darwin.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/syscall_darwin.go
--- a/vendor/golang.org/x/sys/unix/syscall_darwin.go	2026-10-28 08:22:44.848102913 +0000
+++ b/vendor/golang.org/x/sys/unix/syscall_darwin.go	2026-10-28 08:23:38.376153491 +0000
@@ -369,6 +369,7 @@
  */
 
 //sys	fcntl(fd int, cmd int, arg int) (val int, err error)
+//sys	fcntlPtr(fd int, cmd int, arg unsafe.Pointer) (val int, err error) = SYS_FCNTL
 
 //sys	kill(pid int, signum int, posix int) (err error)
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/syscall_freebsd.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/syscall_freebsd.go
--- a/vendor/golang.org/x/sys/unix/syscall_freebsd.go	2026-10-28 08:22:44.852102916 +0000
+++ b/vendor/golang.org/x/sys/unix/syscall_freebsd.go	2026-10-28 08:23:38.376153491 +0000
@@ -369,6 +369,15 @@
 //sys	ExtattrSetLink(link string, attrnamespace int, attrname string, data uintptr, nbytes int) (ret int, err error)
 //sys	ExtattrDeleteLink(link string, attrnamespace int, attrname string) (err error)
 //sys	ExtattrListLink(link string, attrnamespace int, data uintptr, nbytes int) (ret int, err error)
+//sys	extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error)
 //sys	Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_POSIX_FADVISE
 //sys	Faccessat(dirfd int, path string, mode uint32, flags int) (err error)
 //sys	Fchdir(fd int) (err error)
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/syscall_linux.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/syscall_linux.go
--- a/vendor/golang.org/x/sys/unix/syscall_linux.go	2026-10-28 08:22:44.852102916 +0000
+++ b/vendor/golang.org/x/sys/unix/syscall_linux.go	2026-10-28 08:23:38.376153491 +0000
@@ -1991,7 +1991,24 @@
 	return fsconfig(fd, FSCONFIG_CMD_RECONFIGURE, nil, nil, 0)
 }
 
-//sys	Getdents(fd int, buf []byte) (n int, err error) = SYS_GETDENTS64
+//sys	getdents(fd int, buf []byte) (n int, err error) = SYS_GETDENTS64
+
+// Getdents reads directory entries from fd into buf.
+func Getdents(fd int, buf []byte) (n int, err error) {
+	// getdents64 stores d_ino with a 64-bit write, which faults on
+	// strict-alignment targets unless buf is 8-aligned.
+	if len(buf) > 0 {
+		if off := int(-uintptr(unsafe.Pointer(&buf[0])) & 7); off > 0 && off < len(buf) {
+			n, err = getdents(fd, buf[off:])
+			if n > 0 {
+				copy(buf, buf[off:off+n])
+			}
+			return n, err
+		}
+	}
+	return getdents(fd, buf)
+}
+
 //sysnb	Getpgid(pid int) (pgid int, err error)
 
 func Getpgrp() (pid int) {
@@ -2033,6 +2050,7 @@
 //sysnb	Kill(pid int, sig syscall.Signal) (err error)
 //sys	Klogctl(typ int, buf []byte) (n int, err error) = SYS_SYSLOG
 //sys	Lgetxattr(path string, attr string, dest []byte) (sz int, err error)
+//sys	Listns(req *NsIdReq, nsIds []uint64, flags uint) (n int, err error)
 //sys	Listxattr(path string, dest []byte) (sz int, err error)
 //sys	Llistxattr(path string, dest []byte) (sz int, err error)
 //sys	Lremovexattr(path string, attr string) (err error)
@@ -2046,6 +2064,7 @@
 //sys	PerfEventOpen(attr *PerfEventAttr, pid int, cpu int, groupFd int, flags int) (fd int, err error)
 //sys	PivotRoot(newroot string, putold string) (err error) = SYS_PIVOT_ROOT
 //sys	Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error)
+//sys	PrctlArg5Ptr(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 unsafe.Pointer) (err error) = SYS_PRCTL
 //sys	pselect6(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timespec, sigmask *sigset_argpack) (n int, err error)
 //sys	read(fd int, p []byte) (n int, err error)
 //sys	Removexattr(path string, attr string) (err error)
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go
--- a/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go	2026-10-28 08:22:44.852102916 +0000
+++ b/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go	2026-10-28 08:23:38.376153491 +0000
@@ -8,7 +8,7 @@
 
 //sys	Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_FADVISE64
 //sys	Fchown(fd int, uid int, gid int) (err error)
-//sys	Fstat(fd int, stat *Stat_t) (err error)
+//sys	Fstat(fd int, stat *Stat_t) (err error) = SYS_FSTAT64
 //sys	Fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) = SYS_FSTATAT64
 //sys	Fstatfs(fd int, buf *Statfs_t) (err error)
 //sys	Ftruncate(fd int, length int64) (err error)
@@ -19,7 +19,7 @@
 //sysnb	Getuid() (uid int)
 //sys	Lchown(path string, uid int, gid int) (err error)
 //sys	Listen(s int, n int) (err error)
-//sys	Lstat(path string, stat *Stat_t) (err error)
+//sys	Lstat(path string, stat *Stat_t) (err error) = SYS_LSTAT64
 //sys	Pause() (err error)
 //sys	pread(fd int, p []byte, offset int64) (n int, err error) = SYS_PREAD64
 //sys	pwrite(fd int, p []byte, offset int64) (n int, err error) = SYS_PWRITE64
@@ -31,7 +31,7 @@
 //sys	setfsuid(uid int) (prev int, err error)
 //sys	Shutdown(fd int, how int) (err error)
 //sys	Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int64, err error)
-//sys	Stat(path string, stat *Stat_t) (err error)
+//sys	Stat(path string, stat *Stat_t) (err error) = SYS_STAT64
 //sys	Statfs(path string, buf *Statfs_t) (err error)
 //sys	SyncFileRange(fd int, off int64, n int64, flags int) (err error)
 //sys	Truncate(path string, length int64) (err error)
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/syscall_netbsd.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/syscall_netbsd.go
--- a/vendor/golang.org/x/sys/unix/syscall_netbsd.go	2026-10-28 08:22:44.852102916 +0000
+++ b/vendor/golang.org/x/sys/unix/syscall_netbsd.go	2026-10-28 08:23:38.376153491 +0000
@@ -293,6 +293,15 @@
 //sys	ExtattrSetLink(link string, attrnamespace int, attrname string, data uintptr, nbytes int) (ret int, err error)
 //sys	ExtattrDeleteLink(link string, attrnamespace int, attrname string) (err error)
 //sys	ExtattrListLink(link string, attrnamespace int, data uintptr, nbytes int) (ret int, err error)
+//sys	extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error)
 //sys	Faccessat(dirfd int, path string, mode uint32, flags int) (err error)
 //sys	Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_POSIX_FADVISE
 //sys	Fchdir(fd int) (err error)
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/syscall_unix_gc.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/syscall_unix_gc.go
--- a/vendor/golang.org/x/sys/unix/syscall_unix_gc.go	2026-10-28 08:22:44.852102916 +0000
+++ b/vendor/golang.org/x/sys/unix/syscall_unix_gc.go	2026-10-28 08:23:38.376153491 +0000
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (darwin || dragonfly || freebsd || (linux && !ppc64 && !ppc64le) || netbsd || openbsd || solaris) && gc
+//go:build (darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris) && gc
 
 package unix
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/syscall_unix_gc_ppc64x.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/syscall_unix_gc_ppc64x.go
--- a/vendor/golang.org/x/sys/unix/syscall_unix_gc_ppc64x.go	2026-10-28 08:22:44.852102916 +0000
+++ b/vendor/golang.org/x/sys/unix/syscall_unix_gc_ppc64x.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,22 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build linux && (ppc64le || ppc64) && gc
-
-package unix
-
-import "syscall"
-
-func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {
-	return syscall.Syscall(trap, a1, a2, a3)
-}
-func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) {
-	return syscall.Syscall6(trap, a1, a2, a3, a4, a5, a6)
-}
-func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {
-	return syscall.RawSyscall(trap, a1, a2, a3)
-}
-func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) {
-	return syscall.RawSyscall6(trap, a1, a2, a3, a4, a5, a6)
-}
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
--- a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go	2026-10-28 08:22:44.852102916 +0000
+++ b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go	2026-10-28 08:23:38.376153491 +0000
@@ -28,13 +28,9 @@
 )
 
 //go:noescape
-func initZosLibVec()
-
-//go:noescape
 func GetZosLibVec() uintptr
 
 func init() {
-	initZosLibVec()
 	r0, _, _ := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS_____GETENV_A<<4, uintptr(unsafe.Pointer(&([]byte("__ZOS_XSYSTRACE\x00"))[0])))
 	if r0 != 0 {
 		n, _, _ := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___ATOI_A<<4, r0)
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/xattr_bsd.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/xattr_bsd.go
--- a/vendor/golang.org/x/sys/unix/xattr_bsd.go	2026-10-28 08:22:44.852102916 +0000
+++ b/vendor/golang.org/x/sys/unix/xattr_bsd.go	2026-10-28 08:23:38.380153496 +0000
@@ -56,7 +56,7 @@
 		return -1, err
 	}
 
-	return ExtattrGetFile(file, nsid, a, uintptr(d), destsize)
+	return extattrGetFile(file, nsid, a, d, destsize)
 }
 
 func Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) {
@@ -68,7 +68,7 @@
 		return -1, err
 	}
 
-	return ExtattrGetFd(fd, nsid, a, uintptr(d), destsize)
+	return extattrGetFd(fd, nsid, a, d, destsize)
 }
 
 func Lgetxattr(link string, attr string, dest []byte) (sz int, err error) {
@@ -80,7 +80,7 @@
 		return -1, err
 	}
 
-	return ExtattrGetLink(link, nsid, a, uintptr(d), destsize)
+	return extattrGetLink(link, nsid, a, d, destsize)
 }
 
 // flags are unused on FreeBSD
@@ -97,7 +97,7 @@
 		return
 	}
 
-	_, err = ExtattrSetFd(fd, nsid, a, uintptr(d), datasiz)
+	_, err = extattrSetFd(fd, nsid, a, d, datasiz)
 	return
 }
 
@@ -113,7 +113,7 @@
 		return
 	}
 
-	_, err = ExtattrSetFile(file, nsid, a, uintptr(d), datasiz)
+	_, err = extattrSetFile(file, nsid, a, d, datasiz)
 	return
 }
 
@@ -129,7 +129,7 @@
 		return
 	}
 
-	_, err = ExtattrSetLink(link, nsid, a, uintptr(d), datasiz)
+	_, err = extattrSetLink(link, nsid, a, d, datasiz)
 	return
 }
 
@@ -199,9 +199,9 @@
 	d := initxattrdest(dest, 0)
 	destsiz := len(dest)
 
-	s, e := ExtattrListFile(file, nsid, uintptr(d), destsiz)
+	s, e := extattrListFile(file, nsid, d, destsiz)
 	if e != nil {
-		return 0, err
+		return 0, e
 	}
 
 	return s, nil
@@ -235,9 +235,9 @@
 	d := initxattrdest(dest, 0)
 	destsiz := len(dest)
 
-	s, e := ExtattrListFd(fd, nsid, uintptr(d), destsiz)
+	s, e := extattrListFd(fd, nsid, d, destsiz)
 	if e != nil {
-		return 0, err
+		return 0, e
 	}
 
 	return s, nil
@@ -271,9 +271,9 @@
 	d := initxattrdest(dest, 0)
 	destsiz := len(dest)
 
-	s, e := ExtattrListLink(link, nsid, uintptr(d), destsiz)
+	s, e := extattrListLink(link, nsid, d, destsiz)
 	if e != nil {
-		return 0, err
+		return 0, e
 	}
 
 	return s, nil
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
--- a/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go	2026-10-28 08:22:44.856102921 +0000
+++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go	2026-10-28 08:23:38.380153496 +0000
@@ -1128,6 +1128,7 @@
 	O_DSYNC                                 = 0x400000
 	O_EVTONLY                               = 0x8000
 	O_EXCL                                  = 0x800
+	O_EXEC                                  = 0x40000000
 	O_EXLOCK                                = 0x20
 	O_FSYNC                                 = 0x80
 	O_NDELAY                                = 0x4
@@ -1138,6 +1139,7 @@
 	O_POPUP                                 = 0x80000000
 	O_RDONLY                                = 0x0
 	O_RDWR                                  = 0x2
+	O_SEARCH                                = 0x40100000
 	O_SHLOCK                                = 0x10
 	O_SYMLINK                               = 0x200000
 	O_SYNC                                  = 0x80
@@ -1147,6 +1149,10 @@
 	PARMRK                                  = 0x8
 	PARODD                                  = 0x2000
 	PENDIN                                  = 0x20000000
+	PRIO_DARWIN_BG                          = 0x1000
+	PRIO_DARWIN_NONUI                       = 0x1001
+	PRIO_DARWIN_PROCESS                     = 0x4
+	PRIO_DARWIN_THREAD                      = 0x3
 	PRIO_PGRP                               = 0x1
 	PRIO_PROCESS                            = 0x0
 	PRIO_USER                               = 0x2
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
--- a/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go	2026-10-28 08:22:44.856102921 +0000
+++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go	2026-10-28 08:23:38.380153496 +0000
@@ -1128,6 +1128,7 @@
 	O_DSYNC                                 = 0x400000
 	O_EVTONLY                               = 0x8000
 	O_EXCL                                  = 0x800
+	O_EXEC                                  = 0x40000000
 	O_EXLOCK                                = 0x20
 	O_FSYNC                                 = 0x80
 	O_NDELAY                                = 0x4
@@ -1138,6 +1139,7 @@
 	O_POPUP                                 = 0x80000000
 	O_RDONLY                                = 0x0
 	O_RDWR                                  = 0x2
+	O_SEARCH                                = 0x40100000
 	O_SHLOCK                                = 0x10
 	O_SYMLINK                               = 0x200000
 	O_SYNC                                  = 0x80
@@ -1147,6 +1149,10 @@
 	PARMRK                                  = 0x8
 	PARODD                                  = 0x2000
 	PENDIN                                  = 0x20000000
+	PRIO_DARWIN_BG                          = 0x1000
+	PRIO_DARWIN_NONUI                       = 0x1001
+	PRIO_DARWIN_PROCESS                     = 0x4
+	PRIO_DARWIN_THREAD                      = 0x3
 	PRIO_PGRP                               = 0x1
 	PRIO_PROCESS                            = 0x0
 	PRIO_USER                               = 0x2
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux.go
--- a/vendor/golang.org/x/sys/unix/zerrors_linux.go	2026-10-28 08:22:44.856102921 +0000
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux.go	2026-10-28 08:23:38.380153496 +0000
@@ -752,10 +752,12 @@
 	CLONE_ARGS_SIZE_VER0                        = 0x40
 	CLONE_ARGS_SIZE_VER1                        = 0x50
 	CLONE_ARGS_SIZE_VER2                        = 0x58
+	CLONE_AUTOREAP                              = 0x400000000
 	CLONE_CHILD_CLEARTID                        = 0x200000
 	CLONE_CHILD_SETTID                          = 0x1000000
 	CLONE_CLEAR_SIGHAND                         = 0x100000000
 	CLONE_DETACHED                              = 0x400000
+	CLONE_EMPTY_MNTNS                           = 0x2000000000
 	CLONE_FILES                                 = 0x400
 	CLONE_FS                                    = 0x200
 	CLONE_INTO_CGROUP                           = 0x200000000
@@ -768,9 +770,11 @@
 	CLONE_NEWTIME                               = 0x80
 	CLONE_NEWUSER                               = 0x10000000
 	CLONE_NEWUTS                                = 0x4000000
+	CLONE_NNP                                   = 0x800000000
 	CLONE_PARENT                                = 0x8000
 	CLONE_PARENT_SETTID                         = 0x100000
 	CLONE_PIDFD                                 = 0x1000
+	CLONE_PIDFD_AUTOKILL                        = 0x1000000000
 	CLONE_PTRACE                                = 0x2000
 	CLONE_SETTLS                                = 0x80000
 	CLONE_SIGHAND                               = 0x800
@@ -803,12 +807,15 @@
 	DEVLINK_GENL_MCGRP_CONFIG_NAME              = "config"
 	DEVLINK_GENL_NAME                           = "devlink"
 	DEVLINK_GENL_VERSION                        = 0x1
+	DEVLINK_INDEX_BUS_NAME                      = "devlink_index"
 	DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO            = 0x4
 	DEVLINK_PORT_FN_CAP_IPSEC_PACKET            = 0x8
 	DEVLINK_PORT_FN_CAP_MIGRATABLE              = 0x2
 	DEVLINK_PORT_FN_CAP_ROCE                    = 0x1
 	DEVLINK_RATE_TCS_MAX                        = 0x8
 	DEVLINK_RATE_TC_INDEX_MAX                   = 0x7
+	DEVLINK_RESOURCE_SCOPE_DEV                  = 0x1
+	DEVLINK_RESOURCE_SCOPE_PORT                 = 0x2
 	DEVLINK_SB_THRESHOLD_TO_ALPHA_MAX           = 0x14
 	DEVLINK_SUPPORTED_FLASH_OVERWRITE_SECTIONS  = 0x3
 	DEVMEM_MAGIC                                = 0x454d444d
@@ -1127,6 +1134,7 @@
 	ETHTOOL_SWOL                                = 0x6
 	ETHTOOL_TEST                                = 0x1a
 	ETH_P_1588                                  = 0x88f7
+	ETH_P_8021AC                                = 0x8870
 	ETH_P_8021AD                                = 0x88a8
 	ETH_P_8021AH                                = 0x88e7
 	ETH_P_8021Q                                 = 0x8100
@@ -1170,6 +1178,7 @@
 	ETH_P_ETHERCAT                              = 0x88a4
 	ETH_P_FCOE                                  = 0x8906
 	ETH_P_FIP                                   = 0x8914
+	ETH_P_GRE_OSI                               = 0xfe
 	ETH_P_HDLC                                  = 0x19
 	ETH_P_HSR                                   = 0x892f
 	ETH_P_IBOE                                  = 0x8915
@@ -1198,6 +1207,7 @@
 	ETH_P_MXLGSW                                = 0x88c3
 	ETH_P_NCSI                                  = 0x88f8
 	ETH_P_NSH                                   = 0x894f
+	ETH_P_NXP_NETC                              = 0xfd3a
 	ETH_P_PAE                                   = 0x888e
 	ETH_P_PAUSE                                 = 0x8808
 	ETH_P_PHONET                                = 0xf5
@@ -1359,6 +1369,7 @@
 	FAN_UNLIMITED_MARKS                         = 0x20
 	FAN_UNLIMITED_QUEUE                         = 0x10
 	FD_CLOEXEC                                  = 0x1
+	FD_NSFS_ROOT                                = -0x2713
 	FD_PIDFS_ROOT                               = -0x2712
 	FD_SETSIZE                                  = 0x400
 	FF0                                         = 0x0
@@ -1427,6 +1438,8 @@
 	FS_POLICY_FLAGS_PAD_8                       = 0x1
 	FS_POLICY_FLAGS_PAD_MASK                    = 0x3
 	FS_POLICY_FLAGS_VALID                       = 0x7
+	FS_SHUTDOWN_FLAGS_LOGFLUSH                  = 0x1
+	FS_SHUTDOWN_FLAGS_NOLOGFLUSH                = 0x2
 	FS_VERITY_FL                                = 0x100000
 	FS_VERITY_HASH_ALG_SHA256                   = 0x1
 	FS_VERITY_HASH_ALG_SHA512                   = 0x2
@@ -1441,6 +1454,7 @@
 	F_DUPFD_CLOEXEC                             = 0x406
 	F_DUPFD_QUERY                               = 0x403
 	F_EXLCK                                     = 0x4
+	F_GETDELEG                                  = 0x40f
 	F_GETFD                                     = 0x1
 	F_GETFL                                     = 0x3
 	F_GETLEASE                                  = 0x401
@@ -1462,6 +1476,7 @@
 	F_SEAL_SEAL                                 = 0x1
 	F_SEAL_SHRINK                               = 0x2
 	F_SEAL_WRITE                                = 0x8
+	F_SETDELEG                                  = 0x410
 	F_SETFD                                     = 0x2
 	F_SETFL                                     = 0x4
 	F_SETLEASE                                  = 0x400
@@ -1632,6 +1647,7 @@
 	IN_UNMOUNT                                  = 0x2000
 	IOCTL_MEI_CONNECT_CLIENT                    = 0xc0104801
 	IOCTL_MEI_CONNECT_CLIENT_VTAG               = 0xc0144804
+	IPPROTO_AGGFRAG                             = 0x90
 	IPPROTO_AH                                  = 0x33
 	IPPROTO_BEETPH                              = 0x5e
 	IPPROTO_COMP                                = 0x6c
@@ -1913,10 +1929,14 @@
 	LANDLOCK_ACCESS_FS_REFER                    = 0x2000
 	LANDLOCK_ACCESS_FS_REMOVE_DIR               = 0x10
 	LANDLOCK_ACCESS_FS_REMOVE_FILE              = 0x20
+	LANDLOCK_ACCESS_FS_RESOLVE_UNIX             = 0x10000
 	LANDLOCK_ACCESS_FS_TRUNCATE                 = 0x4000
 	LANDLOCK_ACCESS_FS_WRITE_FILE               = 0x2
 	LANDLOCK_ACCESS_NET_BIND_TCP                = 0x1
+	LANDLOCK_ACCESS_NET_BIND_UDP                = 0x4
+	LANDLOCK_ACCESS_NET_CONNECT_SEND_UDP        = 0x8
 	LANDLOCK_ACCESS_NET_CONNECT_TCP             = 0x2
+	LANDLOCK_ADD_RULE_QUIET                     = 0x1
 	LANDLOCK_CREATE_RULESET_ERRATA              = 0x2
 	LANDLOCK_CREATE_RULESET_VERSION             = 0x1
 	LANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ON      = 0x2
@@ -3408,6 +3428,7 @@
 	SCHED_FLAG_UTIL_CLAMP                       = 0x60
 	SCHED_FLAG_UTIL_CLAMP_MAX                   = 0x40
 	SCHED_FLAG_UTIL_CLAMP_MIN                   = 0x20
+	SCHED_GETATTR_FLAG_DL_DYNAMIC               = 0x1
 	SCHED_IDLE                                  = 0x5
 	SCHED_NORMAL                                = 0x0
 	SCHED_RESET_ON_FORK                         = 0x40000000
@@ -3790,6 +3811,14 @@
 	TCPOPT_TIMESTAMP                            = 0x8
 	TCPOPT_TSTAMP_HDR                           = 0x101080a
 	TCPOPT_WINDOW                               = 0x3
+	TCP_ACCECN_ACE_FAIL_RECV                    = 0x2
+	TCP_ACCECN_ACE_FAIL_SEND                    = 0x1
+	TCP_ACCECN_OPT_COUNTER_SEEN                 = 0x2
+	TCP_ACCECN_OPT_EMPTY_SEEN                   = 0x1
+	TCP_ACCECN_OPT_FAIL_RECV                    = 0x8
+	TCP_ACCECN_OPT_FAIL_SEEN                    = 0x3
+	TCP_ACCECN_OPT_FAIL_SEND                    = 0x4
+	TCP_ACCECN_OPT_NOT_SEEN                     = 0x0
 	TCP_AO_KEYF_EXCLUDE_OPT                     = 0x2
 	TCP_AO_KEYF_IFINDEX                         = 0x1
 	TCP_AO_MAXKEYLEN                            = 0x50
@@ -3804,6 +3833,7 @@
 	TCP_COOKIE_TRANSACTIONS                     = 0xf
 	TCP_CORK                                    = 0x3
 	TCP_DEFER_ACCEPT                            = 0x9
+	TCP_DELACK_MAX_US                           = 0x2e
 	TCP_FASTOPEN                                = 0x17
 	TCP_FASTOPEN_CONNECT                        = 0x1e
 	TCP_FASTOPEN_KEY                            = 0x21
@@ -3836,6 +3866,8 @@
 	TCP_REPAIR_OPTIONS                          = 0x16
 	TCP_REPAIR_QUEUE                            = 0x14
 	TCP_REPAIR_WINDOW                           = 0x1d
+	TCP_RTO_MAX_MS                              = 0x2c
+	TCP_RTO_MIN_US                              = 0x2d
 	TCP_SAVED_SYN                               = 0x1c
 	TCP_SAVE_SYN                                = 0x1b
 	TCP_SYNCNT                                  = 0x7
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_386.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go	2026-10-28 08:22:44.860102926 +0000
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go	2026-10-28 08:23:38.380153496 +0000
@@ -600,6 +600,7 @@
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -840,6 +841,7 @@
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go	2026-10-28 08:22:44.860102926 +0000
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go	2026-10-28 08:23:38.380153496 +0000
@@ -600,6 +600,7 @@
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -840,6 +841,7 @@
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go	2026-10-28 08:22:44.860102926 +0000
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go	2026-10-28 08:23:38.380153496 +0000
@@ -605,6 +605,7 @@
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -845,6 +846,7 @@
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go	2026-10-28 08:22:44.860102926 +0000
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go	2026-10-28 08:23:38.380153496 +0000
@@ -602,6 +602,7 @@
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -842,6 +843,7 @@
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go	2026-10-28 08:22:44.860102926 +0000
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go	2026-10-28 08:23:38.380153496 +0000
@@ -592,6 +592,7 @@
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -832,6 +833,7 @@
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go	2026-10-28 08:22:44.860102926 +0000
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go	2026-10-28 08:23:38.380153496 +0000
@@ -601,6 +601,7 @@
 	EDQUOT          = syscall.Errno(0x46d)
 	EFSBADCRC       = syscall.Errno(0x4d)
 	EFSCORRUPTED    = syscall.Errno(0x87)
+	EFTYPE          = syscall.Errno(0xa9)
 	EHOSTDOWN       = syscall.Errno(0x93)
 	EHOSTUNREACH    = syscall.Errno(0x94)
 	EHWPOISON       = syscall.Errno(0xa8)
@@ -845,6 +846,7 @@
 	{166, "ENOTRECOVERABLE", "state not recoverable"},
 	{167, "ERFKILL", "operation not possible due to RF-kill"},
 	{168, "EHWPOISON", "memory page has hardware error"},
+	{169, "EFTYPE", "unknown error 169"},
 	{1133, "EDQUOT", "disk quota exceeded"},
 }
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go	2026-10-28 08:22:44.860102926 +0000
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go	2026-10-28 08:23:38.380153496 +0000
@@ -601,6 +601,7 @@
 	EDQUOT          = syscall.Errno(0x46d)
 	EFSBADCRC       = syscall.Errno(0x4d)
 	EFSCORRUPTED    = syscall.Errno(0x87)
+	EFTYPE          = syscall.Errno(0xa9)
 	EHOSTDOWN       = syscall.Errno(0x93)
 	EHOSTUNREACH    = syscall.Errno(0x94)
 	EHWPOISON       = syscall.Errno(0xa8)
@@ -845,6 +846,7 @@
 	{166, "ENOTRECOVERABLE", "state not recoverable"},
 	{167, "ERFKILL", "operation not possible due to RF-kill"},
 	{168, "EHWPOISON", "memory page has hardware error"},
+	{169, "EFTYPE", "unknown error 169"},
 	{1133, "EDQUOT", "disk quota exceeded"},
 }
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go	2026-10-28 08:22:44.860102926 +0000
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go	2026-10-28 08:23:38.380153496 +0000
@@ -601,6 +601,7 @@
 	EDQUOT          = syscall.Errno(0x46d)
 	EFSBADCRC       = syscall.Errno(0x4d)
 	EFSCORRUPTED    = syscall.Errno(0x87)
+	EFTYPE          = syscall.Errno(0xa9)
 	EHOSTDOWN       = syscall.Errno(0x93)
 	EHOSTUNREACH    = syscall.Errno(0x94)
 	EHWPOISON       = syscall.Errno(0xa8)
@@ -845,6 +846,7 @@
 	{166, "ENOTRECOVERABLE", "state not recoverable"},
 	{167, "ERFKILL", "operation not possible due to RF-kill"},
 	{168, "EHWPOISON", "memory page has hardware error"},
+	{169, "EFTYPE", "unknown error 169"},
 	{1133, "EDQUOT", "disk quota exceeded"},
 }
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go	2026-10-28 08:22:44.860102926 +0000
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go	2026-10-28 08:23:38.380153496 +0000
@@ -601,6 +601,7 @@
 	EDQUOT          = syscall.Errno(0x46d)
 	EFSBADCRC       = syscall.Errno(0x4d)
 	EFSCORRUPTED    = syscall.Errno(0x87)
+	EFTYPE          = syscall.Errno(0xa9)
 	EHOSTDOWN       = syscall.Errno(0x93)
 	EHOSTUNREACH    = syscall.Errno(0x94)
 	EHWPOISON       = syscall.Errno(0xa8)
@@ -845,6 +846,7 @@
 	{166, "ENOTRECOVERABLE", "state not recoverable"},
 	{167, "ERFKILL", "operation not possible due to RF-kill"},
 	{168, "EHWPOISON", "memory page has hardware error"},
+	{169, "EFTYPE", "unknown error 169"},
 	{1133, "EDQUOT", "disk quota exceeded"},
 }
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go	2026-10-28 08:22:44.860102926 +0000
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go	2026-10-28 08:23:38.380153496 +0000
@@ -657,6 +657,7 @@
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -898,6 +899,7 @@
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go	2026-10-28 08:22:44.860102926 +0000
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go	2026-10-28 08:23:38.380153496 +0000
@@ -661,6 +661,7 @@
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -902,6 +903,7 @@
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go	2026-10-28 08:22:44.860102926 +0000
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go	2026-10-28 08:23:38.380153496 +0000
@@ -661,6 +661,7 @@
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -902,6 +903,7 @@
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go	2026-10-28 08:22:44.860102926 +0000
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go	2026-10-28 08:23:38.380153496 +0000
@@ -602,6 +602,7 @@
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -842,6 +843,7 @@
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go	2026-10-28 08:22:44.860102926 +0000
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go	2026-10-28 08:23:38.380153496 +0000
@@ -661,6 +661,7 @@
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -901,6 +902,7 @@
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go	2026-10-28 08:22:44.860102926 +0000
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go	2026-10-28 08:23:38.380153496 +0000
@@ -704,6 +704,7 @@
 	EDQUOT          = syscall.Errno(0x45)
 	EFSBADCRC       = syscall.Errno(0x4c)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x88)
 	EHOSTDOWN       = syscall.Errno(0x40)
 	EHOSTUNREACH    = syscall.Errno(0x41)
 	EHWPOISON       = syscall.Errno(0x87)
@@ -950,6 +951,7 @@
 	{133, "ENOTRECOVERABLE", "state not recoverable"},
 	{134, "ERFKILL", "operation not possible due to RF-kill"},
 	{135, "EHWPOISON", "memory page has hardware error"},
+	{136, "EFTYPE", "unknown error 136"},
 }
 
 // Signal table
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go	2026-10-28 08:22:44.860102926 +0000
+++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go	2026-10-28 08:23:38.380153496 +0000
@@ -702,6 +702,17 @@
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func fcntlPtr(fd int, cmd int, arg unsafe.Pointer) (val int, err error) {
+	r0, _, e1 := syscall_syscall(libc_fcntl_trampoline_addr, uintptr(fd), uintptr(cmd), uintptr(arg))
+	val = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func kill(pid int, signum int, posix int) (err error) {
 	_, _, e1 := syscall_syscall(libc_kill_trampoline_addr, uintptr(pid), uintptr(signum), uintptr(posix))
 	if e1 != 0 {
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go	2026-10-28 08:22:44.860102926 +0000
+++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go	2026-10-28 08:23:38.384153500 +0000
@@ -702,6 +702,17 @@
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func fcntlPtr(fd int, cmd int, arg unsafe.Pointer) (val int, err error) {
+	r0, _, e1 := syscall_syscall(libc_fcntl_trampoline_addr, uintptr(fd), uintptr(cmd), uintptr(arg))
+	val = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func kill(pid int, signum int, posix int) (err error) {
 	_, _, e1 := syscall_syscall(libc_kill_trampoline_addr, uintptr(pid), uintptr(signum), uintptr(posix))
 	if e1 != 0 {
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_freebsd_386.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_freebsd_386.go
--- a/vendor/golang.org/x/sys/unix/zsyscall_freebsd_386.go	2026-10-28 08:22:44.860102926 +0000
+++ b/vendor/golang.org/x/sys/unix/zsyscall_freebsd_386.go	2026-10-28 08:23:38.384153500 +0000
@@ -825,6 +825,165 @@
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FD, uintptr(fd), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Fadvise(fd int, offset int64, length int64, advice int) (err error) {
 	_, _, e1 := Syscall6(SYS_POSIX_FADVISE, uintptr(fd), uintptr(offset), uintptr(offset>>32), uintptr(length), uintptr(length>>32), uintptr(advice))
 	if e1 != 0 {
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_freebsd_amd64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_freebsd_amd64.go
--- a/vendor/golang.org/x/sys/unix/zsyscall_freebsd_amd64.go	2026-10-28 08:22:44.864102929 +0000
+++ b/vendor/golang.org/x/sys/unix/zsyscall_freebsd_amd64.go	2026-10-28 08:23:38.384153500 +0000
@@ -825,6 +825,165 @@
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FD, uintptr(fd), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Fadvise(fd int, offset int64, length int64, advice int) (err error) {
 	_, _, e1 := Syscall6(SYS_POSIX_FADVISE, uintptr(fd), uintptr(offset), uintptr(length), uintptr(advice), 0, 0)
 	if e1 != 0 {
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm.go
--- a/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm.go	2026-10-28 08:22:44.864102929 +0000
+++ b/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm.go	2026-10-28 08:23:38.384153500 +0000
@@ -825,6 +825,165 @@
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FD, uintptr(fd), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Fadvise(fd int, offset int64, length int64, advice int) (err error) {
 	_, _, e1 := Syscall9(SYS_POSIX_FADVISE, uintptr(fd), 0, uintptr(offset), uintptr(offset>>32), uintptr(length), uintptr(length>>32), uintptr(advice), 0, 0)
 	if e1 != 0 {
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm64.go
--- a/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm64.go	2026-10-28 08:22:44.864102929 +0000
+++ b/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm64.go	2026-10-28 08:23:38.384153500 +0000
@@ -825,6 +825,165 @@
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FD, uintptr(fd), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Fadvise(fd int, offset int64, length int64, advice int) (err error) {
 	_, _, e1 := Syscall6(SYS_POSIX_FADVISE, uintptr(fd), uintptr(offset), uintptr(length), uintptr(advice), 0, 0)
 	if e1 != 0 {
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_freebsd_riscv64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_freebsd_riscv64.go
--- a/vendor/golang.org/x/sys/unix/zsyscall_freebsd_riscv64.go	2026-10-28 08:22:44.864102929 +0000
+++ b/vendor/golang.org/x/sys/unix/zsyscall_freebsd_riscv64.go	2026-10-28 08:23:38.384153500 +0000
@@ -825,6 +825,165 @@
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FD, uintptr(fd), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Fadvise(fd int, offset int64, length int64, advice int) (err error) {
 	_, _, e1 := Syscall6(SYS_POSIX_FADVISE, uintptr(fd), uintptr(offset), uintptr(length), uintptr(advice), 0, 0)
 	if e1 != 0 {
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_linux.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_linux.go
--- a/vendor/golang.org/x/sys/unix/zsyscall_linux.go	2026-10-28 08:22:44.864102929 +0000
+++ b/vendor/golang.org/x/sys/unix/zsyscall_linux.go	2026-10-28 08:23:38.384153500 +0000
@@ -943,7 +943,7 @@
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func Getdents(fd int, buf []byte) (n int, err error) {
+func getdents(fd int, buf []byte) (n int, err error) {
 	var _p0 unsafe.Pointer
 	if len(buf) > 0 {
 		_p0 = unsafe.Pointer(&buf[0])
@@ -1167,6 +1167,23 @@
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func Listns(req *NsIdReq, nsIds []uint64, flags uint) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(nsIds) > 0 {
+		_p0 = unsafe.Pointer(&nsIds[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall6(SYS_LISTNS, uintptr(unsafe.Pointer(req)), uintptr(_p0), uintptr(len(nsIds)), uintptr(flags), 0, 0)
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Listxattr(path string, dest []byte) (sz int, err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
@@ -1384,6 +1401,16 @@
 	_, _, e1 := Syscall6(SYS_PRCTL, uintptr(option), uintptr(arg2), uintptr(arg3), uintptr(arg4), uintptr(arg5), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func PrctlArg5Ptr(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 unsafe.Pointer) (err error) {
+	_, _, e1 := Syscall6(SYS_PRCTL, uintptr(option), uintptr(arg2), uintptr(arg3), uintptr(arg4), uintptr(arg5), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
 	}
 	return
 }
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_linux_sparc64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_linux_sparc64.go
--- a/vendor/golang.org/x/sys/unix/zsyscall_linux_sparc64.go	2026-10-28 08:22:44.864102929 +0000
+++ b/vendor/golang.org/x/sys/unix/zsyscall_linux_sparc64.go	2026-10-28 08:23:38.384153500 +0000
@@ -66,7 +66,7 @@
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstat(fd int, stat *Stat_t) (err error) {
-	_, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := Syscall(SYS_FSTAT64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -183,7 +183,7 @@
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_LSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := Syscall(SYS_LSTAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -338,7 +338,7 @@
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := Syscall(SYS_STAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go
--- a/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go	2026-10-28 08:22:44.864102929 +0000
+++ b/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go	2026-10-28 08:23:38.384153500 +0000
@@ -802,6 +802,165 @@
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FD, uintptr(fd), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go
--- a/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go	2026-10-28 08:22:44.864102929 +0000
+++ b/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go	2026-10-28 08:23:38.384153500 +0000
@@ -802,6 +802,165 @@
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FD, uintptr(fd), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go
--- a/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go	2026-10-28 08:22:44.864102929 +0000
+++ b/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go	2026-10-28 08:23:38.384153500 +0000
@@ -802,6 +802,165 @@
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FD, uintptr(fd), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go
--- a/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go	2026-10-28 08:22:44.864102929 +0000
+++ b/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go	2026-10-28 08:23:38.384153500 +0000
@@ -802,6 +802,165 @@
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FD, uintptr(fd), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go
--- a/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go	2026-10-28 08:22:44.868102934 +0000
+++ b/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go	2026-10-28 08:23:38.388153505 +0000
@@ -2848,5 +2848,18 @@
 	SYS_____CHATTRAT64_A                = 0xE39 // 3641
 	SYS_MADVISE                         = 0xE3A // 3642
 	SYS___AUTHENTICATE                  = 0xE3B // 3643
+	SYS_GETPWENT_R                      = 0xE3C // 3644
+	SYS___GETPWENT_R_A                  = 0xE3D // 3645
+	SYS_STRNLEN                         = 0xE3E // 3646
+	SYS_STPCPY                          = 0xE3F // 3647
+	SYS_STPNCPY                         = 0xE40 // 3648
+	SYS_STRSIGNAL                       = 0xE41 // 3649
+	SYS_WCPCPY                          = 0xE42 // 3650
+	SYS_WCPNCPY                         = 0xE43 // 3651
+	SYS_WCSNLEN                         = 0xE44 // 3652
+	SYS___STRSIGNAL_A                   = 0xE45 // 3653
+	SYS_FDOPENDIR                       = 0xE46 // 3654
+	SYS_FDCLOSEDIR                      = 0xE47 // 3655
+	SYS_SYSCALL                         = 0xE48 // 3656
 
 )
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux.go
--- a/vendor/golang.org/x/sys/unix/ztypes_linux.go	2026-10-28 08:22:44.868102934 +0000
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux.go	2026-10-28 08:23:38.388153505 +0000
@@ -933,6 +933,29 @@
 
 const SizeofOpenHow = 0x18
 
+type NsIdReq struct {
+	Size       uint32
+	Spare      uint32
+	Ns_id      uint64
+	Ns_type    uint32
+	Spare2     uint32
+	User_ns_id uint64
+}
+
+const (
+	NS_ID_REQ_SIZE_VER0 = 0x20
+	LISTNS_CURRENT_USER = 0xffffffffffffffff
+
+	TIME_NS   = 0x80
+	MNT_NS    = 0x20000
+	CGROUP_NS = 0x2000000
+	UTS_NS    = 0x4000000
+	IPC_NS    = 0x8000000
+	USER_NS   = 0x10000000
+	PID_NS    = 0x20000000
+	NET_NS    = 0x40000000
+)
+
 const (
 	RESOLVE_BENEATH       = 0x8
 	RESOLVE_IN_ROOT       = 0x10
@@ -3579,7 +3602,7 @@
 	DEVLINK_ATTR_LINECARD_SUPPORTED_TYPES              = 0xae
 	DEVLINK_ATTR_NESTED_DEVLINK                        = 0xaf
 	DEVLINK_ATTR_SELFTESTS                             = 0xb0
-	DEVLINK_ATTR_MAX                                   = 0xb7
+	DEVLINK_ATTR_MAX                                   = 0xb9
 	DEVLINK_DPIPE_FIELD_MAPPING_TYPE_NONE              = 0x0
 	DEVLINK_DPIPE_FIELD_MAPPING_TYPE_IFINDEX           = 0x1
 	DEVLINK_DPIPE_MATCH_TYPE_FIELD_EXACT               = 0x0
@@ -4101,7 +4124,7 @@
 	ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL   = 0x17
 	ETHTOOL_A_COALESCE_USE_CQE_MODE_TX        = 0x18
 	ETHTOOL_A_COALESCE_USE_CQE_MODE_RX        = 0x19
-	ETHTOOL_A_COALESCE_MAX                    = 0x1e
+	ETHTOOL_A_COALESCE_MAX                    = 0x20
 	ETHTOOL_A_PAUSE_UNSPEC                    = 0x0
 	ETHTOOL_A_PAUSE_HEADER                    = 0x1
 	ETHTOOL_A_PAUSE_AUTONEG                   = 0x2
@@ -4113,7 +4136,7 @@
 	ETHTOOL_A_PAUSE_STAT_PAD                  = 0x1
 	ETHTOOL_A_PAUSE_STAT_TX_FRAMES            = 0x2
 	ETHTOOL_A_PAUSE_STAT_RX_FRAMES            = 0x3
-	ETHTOOL_A_PAUSE_STAT_MAX                  = 0x3
+	ETHTOOL_A_PAUSE_STAT_MAX                  = 0x4
 	ETHTOOL_A_EEE_UNSPEC                      = 0x0
 	ETHTOOL_A_EEE_HEADER                      = 0x1
 	ETHTOOL_A_EEE_MODES_OURS                  = 0x2
@@ -4537,9 +4560,12 @@
 )
 
 type LandlockRulesetAttr struct {
-	Access_fs  uint64
-	Access_net uint64
-	Scoped     uint64
+	Handled_access_fs  uint64
+	Handled_access_net uint64
+	Scoped             uint64
+	Quiet_access_fs    uint64
+	Quiet_access_net   uint64
+	Quiet_scoped       uint64
 }
 
 type LandlockPathBeneathAttr struct {
@@ -4569,28 +4595,31 @@
 	PIDFD_COREDUMP_USER        = 0x4
 	PIDFD_COREDUMP_ROOT        = 0x8
 	PIDFD_INFO_SIZE_VER0       = 0x40
-	PIDFD_GET_INFO             = 0xc048ff0b
+	PIDFD_GET_INFO             = 0xc058ff0b
 )
 
-const SizeofPidfdInfo = 0x48
+const SizeofPidfdInfo = 0x58
 
 type PidfdInfo struct {
-	Mask          uint64
-	Cgroupid      uint64
-	Pid           uint32
-	Tgid          uint32
-	Ppid          uint32
-	Ruid          uint32
-	Rgid          uint32
-	Euid          uint32
-	Egid          uint32
-	Suid          uint32
-	Sgid          uint32
-	Fsuid         uint32
-	Fsgid         uint32
-	Exit_code     int32
-	Coredump_mask uint32
-	_             uint32
+	Mask            uint64
+	Cgroupid        uint64
+	Pid             uint32
+	Tgid            uint32
+	Ppid            uint32
+	Ruid            uint32
+	Rgid            uint32
+	Euid            uint32
+	Egid            uint32
+	Suid            uint32
+	Sgid            uint32
+	Fsuid           uint32
+	Fsgid           uint32
+	Exit_code       int32
+	Coredump_mask   uint32
+	Coredump_signal uint32
+	Coredump_code   uint32
+	Coredump_pad    uint32
+	Supported_mask  uint64
 }
 
 const (
@@ -4932,7 +4961,7 @@
 	NL80211_ATTR_MAC_HINT                                   = 0xc8
 	NL80211_ATTR_MAC_MASK                                   = 0xd7
 	NL80211_ATTR_MAX_AP_ASSOC_STA                           = 0xca
-	NL80211_ATTR_MAX                                        = 0x15c
+	NL80211_ATTR_MAX                                        = 0x16e
 	NL80211_ATTR_MAX_CRIT_PROT_DURATION                     = 0xb4
 	NL80211_ATTR_MAX_CSA_COUNTERS                           = 0xce
 	NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS                     = 0x143
@@ -5147,12 +5176,12 @@
 	NL80211_ATTR_WOWLAN_TRIGGERS                            = 0x75
 	NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED                  = 0x76
 	NL80211_ATTR_WPA_VERSIONS                               = 0x4b
-	NL80211_AUTHTYPE_AUTOMATIC                              = 0x9
+	NL80211_AUTHTYPE_AUTOMATIC                              = 0xa
 	NL80211_AUTHTYPE_FILS_PK                                = 0x7
 	NL80211_AUTHTYPE_FILS_SK                                = 0x5
 	NL80211_AUTHTYPE_FILS_SK_PFS                            = 0x6
 	NL80211_AUTHTYPE_FT                                     = 0x2
-	NL80211_AUTHTYPE_MAX                                    = 0x8
+	NL80211_AUTHTYPE_MAX                                    = 0x9
 	NL80211_AUTHTYPE_NETWORK_EAP                            = 0x3
 	NL80211_AUTHTYPE_OPEN_SYSTEM                            = 0x0
 	NL80211_AUTHTYPE_SAE                                    = 0x4
@@ -5320,7 +5349,7 @@
 	NL80211_CMD_LEAVE_MESH                                  = 0x45
 	NL80211_CMD_LEAVE_OCB                                   = 0x6d
 	NL80211_CMD_LINKS_REMOVED                               = 0x9a
-	NL80211_CMD_MAX                                         = 0x9f
+	NL80211_CMD_MAX                                         = 0xa7
 	NL80211_CMD_MICHAEL_MIC_FAILURE                         = 0x29
 	NL80211_CMD_MODIFY_LINK_STA                             = 0x97
 	NL80211_CMD_NAN_MATCH                                   = 0x78
@@ -5566,7 +5595,7 @@
 	NL80211_FREQUENCY_ATTR_GO_CONCURRENT                    = 0xf
 	NL80211_FREQUENCY_ATTR_INDOOR_ONLY                      = 0xe
 	NL80211_FREQUENCY_ATTR_IR_CONCURRENT                    = 0xf
-	NL80211_FREQUENCY_ATTR_MAX                              = 0x27
+	NL80211_FREQUENCY_ATTR_MAX                              = 0x29
 	NL80211_FREQUENCY_ATTR_MAX_TX_POWER                     = 0x6
 	NL80211_FREQUENCY_ATTR_NO_10MHZ                         = 0x11
 	NL80211_FREQUENCY_ATTR_NO_160MHZ                        = 0xc
@@ -5639,7 +5668,7 @@
 	NL80211_IFTYPE_AKM_ATTR_SUITES                          = 0x2
 	NL80211_IFTYPE_AP                                       = 0x3
 	NL80211_IFTYPE_AP_VLAN                                  = 0x4
-	NL80211_IFTYPE_MAX                                      = 0xc
+	NL80211_IFTYPE_MAX                                      = 0xe
 	NL80211_IFTYPE_MESH_POINT                               = 0x7
 	NL80211_IFTYPE_MONITOR                                  = 0x6
 	NL80211_IFTYPE_NAN                                      = 0xc
@@ -5664,7 +5693,7 @@
 	NL80211_KEY_DEFAULT_TYPES                               = 0x8
 	NL80211_KEY_DEFAULT_TYPE_UNICAST                        = 0x1
 	NL80211_KEY_IDX                                         = 0x2
-	NL80211_KEY_MAX                                         = 0xa
+	NL80211_KEY_MAX                                         = 0xb
 	NL80211_KEY_MODE                                        = 0x9
 	NL80211_KEY_NO_TX                                       = 0x1
 	NL80211_KEY_RX_TX                                       = 0x0
@@ -5822,7 +5851,7 @@
 	NL80211_PMKSA_CANDIDATE_BSSID                           = 0x2
 	NL80211_PMKSA_CANDIDATE_INDEX                           = 0x1
 	NL80211_PMKSA_CANDIDATE_PREAUTH                         = 0x3
-	NL80211_PMSR_ATTR_MAX                                   = 0x5
+	NL80211_PMSR_ATTR_MAX                                   = 0x7
 	NL80211_PMSR_ATTR_MAX_PEERS                             = 0x1
 	NL80211_PMSR_ATTR_PEERS                                 = 0x5
 	NL80211_PMSR_ATTR_RANDOMIZE_MAC_ADDR                    = 0x3
@@ -5831,7 +5860,7 @@
 	NL80211_PMSR_FTM_CAPA_ATTR_ASAP                         = 0x1
 	NL80211_PMSR_FTM_CAPA_ATTR_BANDWIDTHS                   = 0x6
 	NL80211_PMSR_FTM_CAPA_ATTR_MAX_BURSTS_EXPONENT          = 0x7
-	NL80211_PMSR_FTM_CAPA_ATTR_MAX                          = 0x12
+	NL80211_PMSR_FTM_CAPA_ATTR_MAX                          = 0x1f
 	NL80211_PMSR_FTM_CAPA_ATTR_MAX_FTMS_PER_BURST           = 0x8
 	NL80211_PMSR_FTM_CAPA_ATTR_NON_ASAP                     = 0x2
 	NL80211_PMSR_FTM_CAPA_ATTR_NON_TRIGGER_BASED            = 0xa
@@ -5853,7 +5882,7 @@
 	NL80211_PMSR_FTM_REQ_ATTR_BURST_PERIOD                  = 0x4
 	NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST                = 0x6
 	NL80211_PMSR_FTM_REQ_ATTR_LMR_FEEDBACK                  = 0xc
-	NL80211_PMSR_FTM_REQ_ATTR_MAX                           = 0xe
+	NL80211_PMSR_FTM_REQ_ATTR_MAX                           = 0x17
 	NL80211_PMSR_FTM_REQ_ATTR_NON_TRIGGER_BASED             = 0xb
 	NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP                = 0x3
 	NL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIES              = 0x7
@@ -5871,7 +5900,7 @@
 	NL80211_PMSR_FTM_RESP_ATTR_FAIL_REASON                  = 0x1
 	NL80211_PMSR_FTM_RESP_ATTR_FTMS_PER_BURST               = 0x8
 	NL80211_PMSR_FTM_RESP_ATTR_LCI                          = 0x13
-	NL80211_PMSR_FTM_RESP_ATTR_MAX                          = 0x16
+	NL80211_PMSR_FTM_RESP_ATTR_MAX                          = 0x21
 	NL80211_PMSR_FTM_RESP_ATTR_NUM_BURSTS_EXP               = 0x6
 	NL80211_PMSR_FTM_RESP_ATTR_NUM_FTMR_ATTEMPTS            = 0x3
 	NL80211_PMSR_FTM_RESP_ATTR_NUM_FTMR_SUCCESSES           = 0x4
@@ -5885,7 +5914,7 @@
 	NL80211_PMSR_FTM_RESP_ATTR_TX_RATE                      = 0xb
 	NL80211_PMSR_PEER_ATTR_ADDR                             = 0x1
 	NL80211_PMSR_PEER_ATTR_CHAN                             = 0x2
-	NL80211_PMSR_PEER_ATTR_MAX                              = 0x4
+	NL80211_PMSR_PEER_ATTR_MAX                              = 0x5
 	NL80211_PMSR_PEER_ATTR_REQ                              = 0x3
 	NL80211_PMSR_PEER_ATTR_RESP                             = 0x4
 	NL80211_PMSR_REQ_ATTR_DATA                              = 0x1
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_386.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_386.go
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_386.go	2026-10-28 08:22:44.868102934 +0000
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_386.go	2026-10-28 08:23:38.388153505 +0000
@@ -163,6 +163,11 @@
 	Flags      int32
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+}
+
 type Cmsghdr struct {
 	Len   uint32
 	Level int32
@@ -178,6 +183,7 @@
 	SizeofSockaddrNFCLLCP = 0x58
 	SizeofIovec           = 0x8
 	SizeofMsghdr          = 0x1c
+	SizeofMmsghdr         = 0x20
 	SizeofCmsghdr         = 0xc
 )
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go	2026-10-28 08:22:44.868102934 +0000
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go	2026-10-28 08:23:38.388153505 +0000
@@ -166,6 +166,12 @@
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -181,6 +187,7 @@
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go	2026-10-28 08:22:44.872102938 +0000
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go	2026-10-28 08:23:38.388153505 +0000
@@ -169,6 +169,11 @@
 	Flags      int32
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+}
+
 type Cmsghdr struct {
 	Len   uint32
 	Level int32
@@ -184,6 +189,7 @@
 	SizeofSockaddrNFCLLCP = 0x58
 	SizeofIovec           = 0x8
 	SizeofMsghdr          = 0x1c
+	SizeofMmsghdr         = 0x20
 	SizeofCmsghdr         = 0xc
 )
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go	2026-10-28 08:22:44.872102938 +0000
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go	2026-10-28 08:23:38.388153505 +0000
@@ -167,6 +167,12 @@
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -182,6 +188,7 @@
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go	2026-10-28 08:22:44.872102938 +0000
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go	2026-10-28 08:23:38.388153505 +0000
@@ -167,6 +167,12 @@
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -182,6 +188,7 @@
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go	2026-10-28 08:22:44.872102938 +0000
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go	2026-10-28 08:23:38.388153505 +0000
@@ -168,6 +168,11 @@
 	Flags      int32
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+}
+
 type Cmsghdr struct {
 	Len   uint32
 	Level int32
@@ -183,6 +188,7 @@
 	SizeofSockaddrNFCLLCP = 0x58
 	SizeofIovec           = 0x8
 	SizeofMsghdr          = 0x1c
+	SizeofMmsghdr         = 0x20
 	SizeofCmsghdr         = 0xc
 )
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go	2026-10-28 08:22:44.872102938 +0000
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go	2026-10-28 08:23:38.388153505 +0000
@@ -167,6 +167,12 @@
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -182,6 +188,7 @@
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go	2026-10-28 08:22:44.872102938 +0000
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go	2026-10-28 08:23:38.388153505 +0000
@@ -167,6 +167,12 @@
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -182,6 +188,7 @@
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go	2026-10-28 08:22:44.872102938 +0000
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go	2026-10-28 08:23:38.388153505 +0000
@@ -168,6 +168,11 @@
 	Flags      int32
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+}
+
 type Cmsghdr struct {
 	Len   uint32
 	Level int32
@@ -183,6 +188,7 @@
 	SizeofSockaddrNFCLLCP = 0x58
 	SizeofIovec           = 0x8
 	SizeofMsghdr          = 0x1c
+	SizeofMmsghdr         = 0x20
 	SizeofCmsghdr         = 0xc
 )
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go	2026-10-28 08:22:44.872102938 +0000
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go	2026-10-28 08:23:38.388153505 +0000
@@ -169,6 +169,11 @@
 	Flags      int32
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+}
+
 type Cmsghdr struct {
 	Len   uint32
 	Level int32
@@ -184,6 +189,7 @@
 	SizeofSockaddrNFCLLCP = 0x58
 	SizeofIovec           = 0x8
 	SizeofMsghdr          = 0x1c
+	SizeofMmsghdr         = 0x20
 	SizeofCmsghdr         = 0xc
 )
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go	2026-10-28 08:22:44.872102938 +0000
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go	2026-10-28 08:23:38.388153505 +0000
@@ -168,6 +168,12 @@
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -183,6 +189,7 @@
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go	2026-10-28 08:22:44.872102938 +0000
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go	2026-10-28 08:23:38.388153505 +0000
@@ -168,6 +168,12 @@
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -183,6 +189,7 @@
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go	2026-10-28 08:22:44.872102938 +0000
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go	2026-10-28 08:23:38.388153505 +0000
@@ -167,6 +167,12 @@
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -182,6 +188,7 @@
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go	2026-10-28 08:22:44.872102938 +0000
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go	2026-10-28 08:23:38.388153505 +0000
@@ -166,6 +166,12 @@
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -181,6 +187,7 @@
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go	2026-10-28 08:22:44.872102938 +0000
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go	2026-10-28 08:23:38.388153505 +0000
@@ -84,22 +84,20 @@
 
 type Stat_t struct {
 	Dev     uint64
-	_       uint16
 	Ino     uint64
+	Nlink   uint64
 	Mode    uint32
-	Nlink   uint32
 	Uid     uint32
 	Gid     uint32
+	_       uint32
 	Rdev    uint64
-	_       uint16
 	Size    int64
 	Blksize int64
 	Blocks  int64
 	Atim    Timespec
 	Mtim    Timespec
 	Ctim    Timespec
-	_       uint64
-	_       uint64
+	_       [3]int64
 }
 
 type Dirent struct {
@@ -170,6 +168,12 @@
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -185,6 +189,7 @@
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go
--- a/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go	2026-10-28 08:22:44.872102938 +0000
+++ b/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go	2026-10-28 08:23:38.392153509 +0000
@@ -209,6 +209,84 @@
 	Total_retrans  uint32
 }
 
+// Ptrace structures for z/OS
+
+type PtraceRegs struct {
+	Psw                      PtracePsw
+	Gprs                     [16]uint64
+	Acrs                     [16]uint32
+	Orig_gpr2                uint64
+	Fp_regs                  PtraceFpregs
+	Per_info                 PtracePer
+	Ieee_instruction_pointer uint64
+}
+
+type PtracePsw struct {
+	Mask uint64
+	Addr uint64
+}
+
+type PtraceFpregs struct {
+	Fpc  uint32
+	Fprs [16]float64
+}
+
+type PtracePer struct {
+	Control_regs  [3]uint64
+	_             [8]byte
+	Starting_addr uint64
+	Ending_addr   uint64
+	Perc_atmid    uint16
+	Address       uint64
+	Access_id     uint8
+	_             [7]byte
+}
+
+// PT_BLOCKREQ structures for block ptrace requests
+// Layout matches BPXYPTRC HLASM macro (PtBR_GPR + PtBR_GPR_EXT):
+//
+//	Offset 0-1:    Writebitflags (PtBR_GPR_CntlGPR, 2 bytes)
+//	Offset 2-3:    Wpsw (PtBR_GPR_CntlMisc, 2 bytes with WPSW bit flag)
+//	Offset 4-15:   Reserved (12 bytes)
+//	Offset 16-79:  Gpr (64 bytes, 16 GPRs)
+//	Offset 80-143: Ctl (64 bytes, 16 CRs)
+//	Offset 144-151: Psw old format (8 bytes, PtBR_GPR_PSW)
+//	Offset 152-167: Pswg extended (16 bytes, PtBR_GPR_PSWG for 64-bit)
+//	Total: 168 bytes (base 152 + extended 16)
+type PtraceBlkGpr struct {
+	Writebitflags uint16     // 2 bytes at offset 0 (PtBR_GPR_CntlGPR)
+	Wpsw          uint16     // 2 bytes at offset 2 (PtBR_GPR_CntlMisc with WPSW flag)
+	_             [12]byte   // 12 bytes reserved (offset 4-15)
+	Gpr           [16]uint32 // 64 bytes at offset 16 (GPRs)
+	Ctl           [16]uint32 // 64 bytes at offset 80 (CRs)
+	Psw           [8]byte    // 8 bytes at offset 144 (old PSW format)
+	Pswg          [16]byte   // 16 bytes at offset 152 (extended PSWG)
+	// Total: 2+2+12+64+64+8+16 = 168 bytes
+}
+
+type PtraceBlkReqReq struct {
+	Reqtype int32
+	Reqstat int32
+	Reqdata uint32
+	_       [4]byte
+}
+
+type PtraceBlkReq struct {
+	Numreq int32
+	_      [12]byte
+}
+
+// PT_READ_U structures for reading user area (control info)
+type PtraceBlkUarOcw struct {
+	Ofs uint32 // Control information offset
+	Ctl uint32 // Control information
+}
+
+type PtraceBlkUar struct {
+	Num uint32 // Number of entries
+	_   [4]byte
+}
+
 type _Gid_t uint32
 
 type rusage_zos struct {
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/sys/windows/types_windows_arm.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/sys/windows/types_windows_arm.go
--- a/vendor/golang.org/x/sys/windows/types_windows_arm.go	2026-10-28 08:22:44.872102938 +0000
+++ b/vendor/golang.org/x/sys/windows/types_windows_arm.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,35 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package windows
-
-type WSAData struct {
-	Version      uint16
-	HighVersion  uint16
-	Description  [WSADESCRIPTION_LEN + 1]byte
-	SystemStatus [WSASYS_STATUS_LEN + 1]byte
-	MaxSockets   uint16
-	MaxUdpDg     uint16
-	VendorInfo   *byte
-}
-
-type Servent struct {
-	Name    *byte
-	Aliases **byte
-	Port    uint16
-	Proto   *byte
-}
-
-type JOBOBJECT_BASIC_LIMIT_INFORMATION struct {
-	PerProcessUserTimeLimit int64
-	PerJobUserTimeLimit     int64
-	LimitFlags              uint32
-	MinimumWorkingSetSize   uintptr
-	MaximumWorkingSetSize   uintptr
-	ActiveProcessLimit      uint32
-	Affinity                uintptr
-	PriorityClass           uint32
-	SchedulingClass         uint32
-	_                       uint32 // pad to 8 byte boundary
-}
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/text/secure/bidirule/bidirule.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/text/secure/bidirule/bidirule.go
--- a/vendor/golang.org/x/text/secure/bidirule/bidirule.go	2026-10-28 08:22:44.892102960 +0000
+++ b/vendor/golang.org/x/text/secure/bidirule/bidirule.go	2026-10-28 08:23:38.532153664 +0000
@@ -10,6 +10,7 @@
 
 import (
 	"errors"
+	"sync"
 	"unicode/utf8"
 
 	"golang.org/x/text/transform"
@@ -246,8 +247,9 @@
 // Precomputing the ASCII values decreases running time for the ASCII fast path
 // by about 30%.
 var asciiTable [128]bidi.Properties
+var asciiTableOnce sync.Once
 
-func init() {
+func initASCIITable() {
 	for i := range asciiTable {
 		p, _ := bidi.LookupRune(rune(i))
 		asciiTable[i] = p
@@ -255,6 +257,8 @@
 }
 
 func (t *Transformer) advance(s []byte) (n int, ok bool) {
+	asciiTableOnce.Do(initASCIITable)
+
 	var e bidi.Properties
 	var sz int
 	for n < len(s) {
@@ -297,6 +301,8 @@
 }
 
 func (t *Transformer) advanceString(s string) (n int, ok bool) {
+	asciiTableOnce.Do(initASCIITable)
+
 	var e bidi.Properties
 	var sz int
 	for n < len(s) {
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/text/unicode/bidi/core.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/text/unicode/bidi/core.go
--- a/vendor/golang.org/x/text/unicode/bidi/core.go	2026-10-28 08:22:44.892102960 +0000
+++ b/vendor/golang.org/x/text/unicode/bidi/core.go	2026-10-28 08:23:38.532153664 +0000
@@ -208,27 +208,23 @@
 		p.matchingIsolateInitiator[i] = -1
 	}
 
+	var open []int
 	for i := range p.matchingPDI {
 		p.matchingPDI[i] = -1
 
-		if t := p.resultTypes[i]; t.in(LRI, RLI, FSI) {
-			depthCounter := 1
-			for j := i + 1; j < p.Len(); j++ {
-				if u := p.resultTypes[j]; u.in(LRI, RLI, FSI) {
-					depthCounter++
-				} else if u == PDI {
-					if depthCounter--; depthCounter == 0 {
-						p.matchingPDI[i] = j
-						p.matchingIsolateInitiator[j] = i
-						break
-					}
-				}
-			}
-			if p.matchingPDI[i] == -1 {
-				p.matchingPDI[i] = p.Len()
-			}
+		switch t := p.resultTypes[i]; {
+		case t.in(LRI, RLI, FSI):
+			open = append(open, i)
+		case t == PDI && len(open) > 0:
+			j := open[len(open)-1]
+			open = open[:len(open)-1]
+			p.matchingPDI[j] = i
+			p.matchingIsolateInitiator[i] = j
 		}
 	}
+	for _, i := range open {
+		p.matchingPDI[i] = p.Len()
+	}
 }
 
 // determineParagraphEmbeddingLevel reports the resolved paragraph direction of
@@ -496,16 +492,13 @@
 
 	// Rule W2.
 	// EN does not change at the start of the run, because sos != AL.
+	lastStrong := unknownClass
 	for i, t := range s.types {
-		if t == EN {
-			for j := i - 1; j >= 0; j-- {
-				if t := s.types[j]; t.in(L, R, AL) {
-					if t == AL {
-						s.types[i] = AN
-					}
-					break
-				}
-			}
+		switch {
+		case t.in(L, R, AL):
+			lastStrong = t
+		case t == EN && lastStrong == AL:
+			s.types[i] = AN
 		}
 	}
 
@@ -543,29 +536,30 @@
 	}
 
 	// Rule W5.
-	for i, t := range s.types {
-		if t == ET {
-			// locate end of sequence
-			runStart := i
-			runEnd := s.findRunLimit(runStart, ET)
-
-			// check values at ends of sequence
-			t := s.sos
-			if runStart > 0 {
-				t = s.types[runStart-1]
+	for i := 0; i < len(s.types); i++ {
+		if s.types[i] != ET {
+			continue
+		}
+		// locate end of sequence
+		runStart := i
+		runEnd := s.findRunLimit(runStart, ET)
+
+		// check values at ends of sequence
+		t := s.sos
+		if runStart > 0 {
+			t = s.types[runStart-1]
+		}
+		if t != EN {
+			t = s.eos
+			if runEnd < len(s.types) {
+				t = s.types[runEnd]
 			}
-			if t != EN {
-				t = s.eos
-				if runEnd < len(s.types) {
-					t = s.types[runEnd]
-				}
-			}
-			if t == EN {
-				setTypes(s.types[runStart:runEnd], EN)
-			}
-			// continue at end of sequence
-			i = runEnd
 		}
+		if t == EN {
+			setTypes(s.types[runStart:runEnd], EN)
+		}
+		// continue at end of sequence
+		i = runEnd
 	}
 
 	// Rule W6.
@@ -576,20 +570,13 @@
 	}
 
 	// Rule W7.
+	prevStrongType := s.sos
 	for i, t := range s.types {
-		if t == EN {
-			// set default if we reach start of run
-			prevStrongType := s.sos
-			for j := i - 1; j >= 0; j-- {
-				t = s.types[j]
-				if t == L || t == R { // AL's have been changed to R
-					prevStrongType = t
-					break
-				}
-			}
-			if prevStrongType == L {
-				s.types[i] = L
-			}
+		switch {
+		case t == L || t == R: // AL's have been changed to R
+			prevStrongType = t
+		case t == EN && prevStrongType == L:
+			s.types[i] = L
 		}
 	}
 }
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go
--- a/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go	2026-10-28 08:22:44.896102964 +0000
+++ b/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go	2026-10-28 08:23:38.660153806 +0000
@@ -2,63 +2,44 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Package gcexportdata provides functions for reading and writing
-// export data, which is a serialized description of the API of a Go
-// package including the names, kinds, types, and locations of all
-// exported declarations.
-//
-// The standard Go compiler (cmd/compile) writes an export data file
-// for each package it compiles, which it later reads when compiling
-// packages that import the earlier one. The compiler must thus
-// contain logic to both write and read export data.
-// (See the "Export" section in the cmd/compile/README file.)
-//
-// The [Read] function in this package can read files produced by the
-// compiler, producing [go/types] data structures. As a matter of
-// policy, Read supports export data files produced by only the last
-// two Go releases plus tip; see https://go.dev/issue/68898. The
-// export data files produced by the compiler contain additional
-// details related to generics, inlining, and other optimizations that
-// cannot be decoded by the [Read] function.
-//
-// In files written by the compiler, the export data is not at the
-// start of the file. Before calling Read, use [NewReader] to locate
-// the desired portion of the file.
-//
-// The [Write] function in this package encodes the exported API of a
-// Go package ([types.Package]) as a file. Such files can be later
-// decoded by Read, but cannot be consumed by the compiler.
-//
-// # Future changes
-//
-// Although Read supports the formats written by both Write and the
-// compiler, the two are quite different, and there is an open
-// proposal (https://go.dev/issue/69491) to separate these APIs.
-//
-// Under that proposal, this package would ultimately provide only the
-// Read operation for compiler export data, which must be defined in
-// this module (golang.org/x/tools), not in the standard library, to
-// avoid version skew for developer tools that need to read compiler
-// export data both before and after a Go release, such as from Go
-// 1.23 to Go 1.24. Because this package lives in the tools module,
-// clients can update their version of the module some time before the
-// Go 1.24 release and rebuild and redeploy their tools, which will
-// then be able to consume both Go 1.23 and Go 1.24 export data files,
-// so they will work before and after the Go update. (See discussion
-// at https://go.dev/issue/15651.)
-//
-// The operations to import and export [go/types] data structures
-// would be defined in the go/types package as Import and Export.
-// [Write] would (eventually) delegate to Export,
-// and [Read], when it detects a file produced by Export,
-// would delegate to Import.
+// Package gcexportdata provides functions for writing and reading
+// export data, a serialized representation of a [types.Package].
+// It describes the API of a Go package, including the names,
+// kinds, types, and locations of all exported declarations.
+//
+// Files may be written and read using the [Write] and [Read]
+// functions.
+// Alternatively, files may be produced by the "go list -export" command.
+// This command runs the type checker on each specified Go package and
+// writes export data for each package into a file named by the Export
+// field of go list's -json output.
+// The [Read] function may then be used to read those files.
+//
+// The export data format evolves with each Go release. As a matter of
+// policy, [Read] supports reading files produced by only the last two
+// Go releases plus tip; see https://go.dev/issue/68898.
+//
+// The name of this package reflects its origins at a time when
+// cmd/compile was named gc, and [Read] parsed export data
+// from .a archives produced by the Go compiler.
+// However, starting with go1.28, the format of the files
+// produced by "go list -export" will diverge from the format
+// used by the standard Go compiler.
+// Consequently, this package will eventually stop being
+// capable of reading those files.
+// In the meantime, when using [Read] on a .a file written by the
+// compiler, be aware that export data is not at the start of the file.
+// Before calling Read, one must use [NewReader] to locate the export
+// data section of the file.
+// For more information on the compiler's export data, see the
+// "Export" section in the GOROOT/src/cmd/compile/README file.
 //
 // # Deprecations
 //
-// The [NewImporter] and [Find] functions are deprecated and should
-// not be used in new code. The [WriteBundle] and [ReadBundle]
-// functions are experimental, and there is an open proposal to
-// deprecate them (https://go.dev/issue/69573).
+// The [NewImporter], [Find], and [NewReader] functions are deprecated
+// and should not be used in new code.
+// The [WriteBundle] and [ReadBundle] functions are experimental, and
+// there is an open proposal to deprecate them (https://go.dev/issue/69573).
 package gcexportdata
 
 import (
@@ -101,11 +82,30 @@
 	return data.Export, data.ImportPath
 }
 
-// NewReader returns a reader for the export data section of an object
-// (.o) or archive (.a) file read from r.  The new reader may provide
-// additional trailing data beyond the end of the export data.
+// NewReader returns a reader for export data read from r. Export data
+// may be read from:
+//
+//   - The export data section of an object (.o) or archive file (.a).
+//     In this case, the new reader may provide additional trailing data
+//     beyond the end of the export data.
+//   - The output of the cmd/export tool (e.g. via "go list -export").
+//     In this case, the new reader contains no trailing data.
+//
+// Deprecated: This package will stop supporting the reading of export
+// data from compiler-produced archive files in Go 1.29. To read
+// cmd/export files, use [Read] directly instead.
 func NewReader(r io.Reader) (io.Reader, error) {
 	buf := bufio.NewReader(r)
+	peek, err := buf.Peek(1)
+	if err != nil {
+		return nil, err
+	}
+	if peek[0] == 'i' {
+		// We were given an output of cmd/export. The entire file is
+		// export data.
+		return buf, nil
+	}
+
 	size, err := gcimporter.FindExportData(buf)
 	if err != nil {
 		return nil, err
@@ -176,16 +176,7 @@
 		case 'i':
 			// indexed, produced by cmd/compile till go1.19,
 			// and also by [Write].
-			//
-			// If proposal #69491 is accepted, go/types
-			// serialization will be implemented by
-			// types.Export, to which Write would eventually
-			// delegate (explicitly dropping any pretence at
-			// inter-version Write-Read compatibility).
-			// This [Read] function would delegate to types.Import
-			// when it detects that the file was produced by Export.
-			_, pkg, err := gcimporter.IImportData(fset, imports, data[1:], path)
-			return pkg, err
+			return gcimporter.IImportData(fset, imports, data[1:], path)
 
 		case 'u':
 			// unified, produced by cmd/compile since go1.20
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/go/packages/golist.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/go/packages/golist.go
--- a/vendor/golang.org/x/tools/go/packages/golist.go	2026-10-28 08:22:44.896102964 +0000
+++ b/vendor/golang.org/x/tools/go/packages/golist.go	2026-10-28 08:23:38.660153806 +0000
@@ -317,10 +317,17 @@
 	if err != nil {
 		return nil, err
 	}
-	// If we get nothing back from `go list`,
-	// try to make this file into its own ad-hoc package.
-	// TODO(rstambler): Should this check against the original response?
-	if len(response.Packages) == 0 {
+	// Only .go files can form ad-hoc packages (command-line-arguments);
+	// non-Go files cannot be compiled as Go packages (golang.org/issue/54815).
+	if filepath.Ext(query) != ".go" {
+		return response, nil
+	}
+
+	switch len(response.Packages) {
+	case 0:
+		// If we get nothing back from `go list`,
+		// try to make this file into its own ad-hoc package.
+		// TODO(rstambler): Should this check against the original response?
 		response.Packages = append(response.Packages, &Package{
 			ID:              "command-line-arguments",
 			PkgPath:         query,
@@ -329,22 +336,23 @@
 			Imports:         make(map[string]*Package),
 		})
 		response.Roots = append(response.Roots, "command-line-arguments")
-	}
-	// Handle special cases.
-	if len(response.Packages) == 1 {
+
+	case 1:
+		// Handle special cases.
 		// golang/go#33482: If this is a file= query for ad-hoc packages where
 		// the file only exists on an overlay, and exists outside of a module,
 		// add the file to the package and remove the errors.
-		if response.Packages[0].ID == "command-line-arguments" ||
-			filepath.ToSlash(response.Packages[0].PkgPath) == filepath.ToSlash(query) {
-			if len(response.Packages[0].GoFiles) == 0 {
+		pkg := response.Packages[0]
+		if pkg.ID == "command-line-arguments" ||
+			filepath.ToSlash(pkg.PkgPath) == filepath.ToSlash(query) {
+			if len(pkg.GoFiles) == 0 {
 				filename := filepath.Join(pattern, filepath.Base(query)) // avoid recomputing abspath
 				// TODO(matloob): check if the file is outside of a root dir?
 				for path := range state.cfg.Overlay {
 					if path == filename {
-						response.Packages[0].Errors = nil
-						response.Packages[0].GoFiles = []string{path}
-						response.Packages[0].CompiledGoFiles = []string{path}
+						pkg.Errors = nil
+						pkg.GoFiles = []string{path}
+						pkg.CompiledGoFiles = []string{path}
 					}
 				}
 			}
@@ -683,9 +691,14 @@
 
 		if p.Error != nil {
 			msg := strings.TrimSpace(p.Error.Err) // Trim to work around golang.org/issue/32363.
-			// Address golang.org/issue/35964 by appending import stack to error message.
-			if msg == "import cycle not allowed" && len(p.Error.ImportStack) != 0 {
-				msg += fmt.Sprintf(": import stack: %v", p.Error.ImportStack)
+			// Address golang.org/issue/35964 and golang.org/issue/38826 by appending import stack to error message.
+			// Address golang/go#38826 by removing " (test)"
+			if (msg == "import cycle not allowed" || msg == "import cycle not allowed in test") && len(p.Error.ImportStack) != 0 {
+				stack := make([]string, len(p.Error.ImportStack))
+				for i, s := range p.Error.ImportStack {
+					stack[i] = strings.TrimSuffix(s, " (test)")
+				}
+				msg += fmt.Sprintf(": import stack: %v", stack)
 			}
 			pkg.Errors = append(pkg.Errors, Error{
 				Pos:  p.Error.Pos,
@@ -752,29 +765,27 @@
 		return "", false, err
 	}
 
+	// A directory can be contained in multiple roots, for example when a
+	// replaced module is nested inside the main module. Choose the most
+	// specific root, breaking ties lexically for deterministic behavior.
+	var bestRoot, bestPath, bestRel string
 	for rdir, rpath := range roots {
-		// Make sure that the directory is in the module,
-		// to avoid creating a path relative to another module.
-		if !strings.HasPrefix(dir, rdir) {
-			continue
-		}
 		// TODO(matloob): This doesn't properly handle symlinks.
 		r, err := filepath.Rel(rdir, dir)
-		if err != nil {
+		if err != nil || !filepath.IsLocal(r) {
 			continue
 		}
-		if rpath != "" {
-			// We choose only one root even though the directory even it can belong in multiple modules
-			// or GOPATH entries. This is okay because we only need to work with absolute dirs when a
-			// file is missing from disk, for instance when gopls calls go/packages in an overlay.
-			// Once the file is saved, gopls, or the next invocation of the tool will get the correct
-			// result straight from golist.
-			// TODO(matloob): Implement module tiebreaking?
-			return path.Join(rpath, filepath.ToSlash(r)), true, nil
+		if bestRoot == "" || len(rdir) > len(bestRoot) || len(rdir) == len(bestRoot) && rdir < bestRoot {
+			bestRoot, bestPath, bestRel = rdir, rpath, r
 		}
-		return filepath.ToSlash(r), true, nil
 	}
-	return "", false, nil
+	if bestRoot == "" {
+		return "", false, nil
+	}
+	if bestPath != "" {
+		return path.Join(bestPath, filepath.ToSlash(bestRel)), true, nil
+	}
+	return filepath.ToSlash(bestRel), true, nil
 }
 
 // absJoin absolutizes and flattens the lists of files.
@@ -996,9 +1007,12 @@
 			return bytes.NewBufferString(output), nil
 		}
 
-		// Workaround for #29280: go list -e has incorrect behavior when an ad-hoc package doesn't exist.
+		// Workaround for #29280 and #31344: go list -e has incorrect behavior when an ad-hoc package doesn't exist.
 		// Note that the error message we look for in this case is different that the one looked for above.
-		if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "no such file or directory") {
+		// "no such file or directory" is emitted on Unix,
+		if len(stderr.String()) > 0 && (strings.Contains(stderr.String(), "no such file or directory") || // Unix
+			strings.Contains(stderr.String(), "The system cannot find the file specified") || // Windows ERROR_FILE_NOT_FOUND
+			strings.Contains(stderr.String(), "The system cannot find the path specified")) { // Windows ERROR_PATH_NOT_FOUND
 			output := fmt.Sprintf(`{"ImportPath": "command-line-arguments","Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
 				strings.Trim(stderr.String(), "\n"))
 			return bytes.NewBufferString(output), nil
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/go/packages/golist_overlay.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/go/packages/golist_overlay.go
--- a/vendor/golang.org/x/tools/go/packages/golist_overlay.go	2026-10-28 08:22:44.896102964 +0000
+++ b/vendor/golang.org/x/tools/go/packages/golist_overlay.go	2026-10-28 08:23:38.660153806 +0000
@@ -31,8 +31,8 @@
 }
 
 func (state *golistState) determineRootDirsModules() (map[string]string, error) {
-	// List all of the modules--the first will be the directory for the main
-	// module. Any replaced modules will also need to be treated as roots.
+	// List all of the modules. Main modules and replaced modules need to be
+	// treated as roots.
 	// Editing files in the module cache isn't a great idea, so we don't
 	// plan to ever support that.
 	out, err := state.invokeGo("list", "-m", "-json", "all")
@@ -46,8 +46,6 @@
 		}
 	}
 	roots := map[string]string{}
-	modules := map[string]string{}
-	var i int
 	for dec := json.NewDecoder(out); dec.More(); {
 		mod := new(gocommand.ModuleJSON)
 		if err := dec.Decode(mod); err != nil {
@@ -59,13 +57,10 @@
 			if err != nil {
 				return nil, err
 			}
-			modules[absDir] = mod.Path
-			// The first result is the main module.
-			if i == 0 || mod.Replace != nil && mod.Replace.Path != "" {
+			if mod.Main || mod.Replace != nil && mod.Replace.Path != "" {
 				roots[absDir] = mod.Path
 			}
 		}
-		i++
 	}
 	return roots, nil
 }
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/go/packages/packages.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/go/packages/packages.go
--- a/vendor/golang.org/x/tools/go/packages/packages.go	2026-10-28 08:22:44.896102964 +0000
+++ b/vendor/golang.org/x/tools/go/packages/packages.go	2026-10-28 08:23:38.660153806 +0000
@@ -1508,7 +1508,7 @@
 	}
 	defer f.Close()
 
-	// Read gc export data.
+	// Read gc or cmd/export export data.
 	//
 	// We don't currently support gccgo export data because all
 	// underlying workspaces use the gc toolchain. (Even build
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go
--- a/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go	2026-10-28 08:22:44.896102964 +0000
+++ b/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go	2026-10-28 08:23:38.660153806 +0000
@@ -31,8 +31,7 @@
 	"strconv"
 	"strings"
 	"sync"
-
-	"golang.org/x/tools/internal/typesinternal"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 // TODO(adonovan): think about generic aliases.
@@ -692,8 +691,13 @@
 		return "", false
 	}
 
-	_, named := typesinternal.ReceiverNamed(meth.Signature().Recv())
-	if named == nil {
+	// Avoid dependency on typesinternal.RecvBase here.
+	t := meth.Signature().Recv().Type()
+	if ptr, ok := types.Unalias(t).(*types.Pointer); ok {
+		t = ptr.Elem()
+	}
+	named, ok := types.Unalias(t).(*types.Named)
+	if !ok {
 		return "", false
 	}
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/aliases/aliases.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/aliases/aliases.go
--- a/vendor/golang.org/x/tools/internal/aliases/aliases.go	2026-10-28 08:22:44.896102964 +0000
+++ b/vendor/golang.org/x/tools/internal/aliases/aliases.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,18 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package aliases
-
-import (
-	"go/token"
-	"go/types"
-)
-
-// New creates a new TypeName in Package pkg that
-// is an alias for the type rhs.
-func New(pos token.Pos, pkg *types.Package, name string, rhs types.Type, tparams []*types.TypeParam) *types.TypeName {
-	tname := types.NewTypeName(pos, pkg, name, nil)
-	types.NewAlias(tname, rhs).SetTypeParams(tparams)
-	return tname
-}
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/gcimporter/bimport.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/gcimporter/bimport.go
--- a/vendor/golang.org/x/tools/internal/gcimporter/bimport.go	2026-10-28 08:22:44.896102964 +0000
+++ b/vendor/golang.org/x/tools/internal/gcimporter/bimport.go	2026-10-28 08:23:38.664153810 +0000
@@ -12,6 +12,7 @@
 	"go/token"
 	"go/types"
 	"sync"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 func errorf(format string, args ...any) {
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/gcimporter/exportdata.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/gcimporter/exportdata.go
--- a/vendor/golang.org/x/tools/internal/gcimporter/exportdata.go	2026-10-28 08:22:44.896102964 +0000
+++ b/vendor/golang.org/x/tools/internal/gcimporter/exportdata.go	2026-10-28 08:23:38.664153810 +0000
@@ -19,6 +19,7 @@
 	"path/filepath"
 	"strings"
 	"sync"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 // FindExportData positions the reader r at the beginning of the
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/gcimporter/gcimporter.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/gcimporter/gcimporter.go
--- a/vendor/golang.org/x/tools/internal/gcimporter/gcimporter.go	2026-10-28 08:22:44.896102964 +0000
+++ b/vendor/golang.org/x/tools/internal/gcimporter/gcimporter.go	2026-10-28 08:23:38.664153810 +0000
@@ -28,6 +28,7 @@
 	"go/types"
 	"io"
 	"os"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 const (
@@ -95,6 +96,19 @@
 	defer rc.Close()
 
 	buf := bufio.NewReader(rc)
+	peek, err := buf.Peek(1)
+	if err != nil {
+		return
+	}
+	if peek[0] == 'i' {
+		var data []byte // avoid redeclaring err
+		data, err = io.ReadAll(buf)
+		if err != nil {
+			return
+		}
+		pkg, err = IImportData(fset, packages, data[1:], path)
+		return
+	}
 	data, err := ReadUnified(buf)
 	if err != nil {
 		err = fmt.Errorf("import %q: %v", path, err)
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/gcimporter/iexport.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/gcimporter/iexport.go
--- a/vendor/golang.org/x/tools/internal/gcimporter/iexport.go	2026-10-28 08:22:44.896102964 +0000
+++ b/vendor/golang.org/x/tools/internal/gcimporter/iexport.go	2026-10-28 08:23:38.664153810 +0000
@@ -242,6 +242,7 @@
 	"strings"
 
 	"golang.org/x/tools/go/types/objectpath"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 // IExportShallow encodes "shallow" export data for the specified package.
@@ -712,7 +713,7 @@
 		w.typ(obj.Type(), obj.Pkg())
 
 	case *types.Func:
-		sig, _ := obj.Type().(*types.Signature)
+		sig := obj.Type().(*types.Signature)
 		if sig.Recv() != nil {
 			// We shouldn't see methods in the package scope,
 			// but the type checker may repair "func () F() {}"
@@ -745,7 +746,7 @@
 	case *types.Const:
 		w.tag(constTag)
 		w.pos(obj.Pos())
-		w.value(obj.Type(), obj.Val())
+		w.value(obj.Type(), obj.Val(), obj.Pkg())
 
 	case *types.TypeName:
 		t := obj.Type()
@@ -822,7 +823,7 @@
 			m := named.Method(i)
 			w.pos(m.Pos())
 			w.string(m.Name())
-			sig, _ := m.Type().(*types.Signature)
+			sig := m.Type().(*types.Signature)
 			if w.p.version >= iexportVersionGenericMethods && w.bool(sig.TypeParams().Len() > 0) {
 				w.tparamList(obj.Name()+"."+m.Name(), sig.TypeParams(), obj.Pkg())
 			}
@@ -970,9 +971,11 @@
 // typ emits the specified type.
 //
 // Objects within the type (struct fields and interface methods) are
-// qualified by pkg. It may be nil if the type cannot contain objects,
-// such as the type of a constant.
+// qualified by pkg.
 func (w *exportWriter) typ(t types.Type, pkg *types.Package) {
+	if pkg == nil {
+		pkg = w.p.localpkg
+	}
 	w.data.uint64(w.p.typOff(t, pkg))
 }
 
@@ -1148,7 +1151,7 @@
 			}
 			w.pos(m.Pos())
 			w.string(m.Name())
-			sig, _ := m.Type().(*types.Signature)
+			sig := m.Type().(*types.Signature)
 			w.signature(sig)
 		}
 
@@ -1295,8 +1298,12 @@
 	w.typ(obj.Type(), obj.Pkg())
 }
 
-func (w *exportWriter) value(typ types.Type, v constant.Value) {
-	w.typ(typ, nil)
+// only called for constants
+func (w *exportWriter) value(typ types.Type, v constant.Value, pkg *types.Package) {
+	if pkg == nil {
+		pkg = w.p.localpkg
+	}
+	w.typ(typ, pkg)
 	if w.p.version >= iexportVersionGo1_18 {
 		w.int64(int64(v.Kind()))
 	}
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/gcimporter/iimport.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/gcimporter/iimport.go
--- a/vendor/golang.org/x/tools/internal/gcimporter/iimport.go	2026-10-28 08:22:44.896102964 +0000
+++ b/vendor/golang.org/x/tools/internal/gcimporter/iimport.go	2026-10-28 08:23:38.664153810 +0000
@@ -21,8 +21,7 @@
 	"strings"
 
 	"golang.org/x/tools/go/types/objectpath"
-	"golang.org/x/tools/internal/aliases"
-	"golang.org/x/tools/internal/typesinternal"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 type intReader struct {
@@ -30,14 +29,6 @@
 	path string
 }
 
-func (r *intReader) int64() int64 {
-	i, err := binary.ReadVarint(r.Reader)
-	if err != nil {
-		errorf("import %q: read varint error: %v", r.path, err)
-	}
-	return i
-}
-
 func (r *intReader) uint64() uint64 {
 	i, err := binary.ReadUvarint(r.Reader)
 	if err != nil {
@@ -101,12 +92,12 @@
 // and returns 0 and a reference to the package.
 // If the export data version is not recognized or the format is otherwise
 // compromised, an error is returned.
-func IImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (int, *types.Package, error) {
+func IImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (*types.Package, error) {
 	pkgs, err := iimportCommon(fset, GetPackagesFromMap(imports), data, false, path, false, nil)
 	if err != nil {
-		return 0, nil, err
+		return nil, err
 	}
-	return 0, pkgs[0], nil
+	return pkgs[0], nil
 }
 
 // IImportBundle imports a set of packages from the serialized package bundle.
@@ -574,8 +565,8 @@
 		if tag == genericAliasTag {
 			tparams = r.tparamList()
 		}
-		typ := r.typ()
-		obj := aliases.New(pos, pkg, name, typ, tparams)
+		obj := types.NewTypeName(pos, pkg, name, nil)
+		types.NewAlias(obj, r.typ()).SetTypeParams(tparams)
 		markBlack(obj) // workaround for golang/go#69912
 		r.declare(obj)
 
@@ -624,8 +615,13 @@
 				// If the receiver has any targs, set those as the
 				// rparams of the method (since those are the
 				// typeparams being used in the method sig/body).
-				_, recvNamed := typesinternal.ReceiverNamed(recv)
-				targs := recvNamed.TypeArgs()
+				//
+				// Avoid dependency on typesinternal.RecvBase here.
+				t := recv.Type()
+				if ptr, ok := types.Unalias(t).(*types.Pointer); ok {
+					t = ptr.Elem()
+				}
+				targs := types.Unalias(t).(*types.Named).TypeArgs()
 				var rparams []*types.TypeParam
 				if targs.Len() > 0 {
 					rparams = make([]*types.TypeParam, targs.Len())
@@ -675,7 +671,7 @@
 		typ := r.typ()
 
 		v := types.NewVar(pos, pkg, name, typ)
-		typesinternal.SetVarKind(v, typesinternal.PackageVar)
+		v.SetKind(types.PackageVar)
 		r.declare(v)
 
 	default:
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/gcimporter/predeclared.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/gcimporter/predeclared.go
--- a/vendor/golang.org/x/tools/internal/gcimporter/predeclared.go	2026-10-28 08:22:44.896102964 +0000
+++ b/vendor/golang.org/x/tools/internal/gcimporter/predeclared.go	2026-10-28 08:23:38.664153810 +0000
@@ -7,6 +7,7 @@
 import (
 	"go/types"
 	"sync"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 // predecl is a cache for the predeclared types in types.Universe.
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/gcimporter/support.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/gcimporter/support.go
--- a/vendor/golang.org/x/tools/internal/gcimporter/support.go	2026-10-28 08:22:44.896102964 +0000
+++ b/vendor/golang.org/x/tools/internal/gcimporter/support.go	2026-10-28 08:23:38.664153810 +0000
@@ -9,6 +9,7 @@
 	"io"
 	"strconv"
 	"strings"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 // Copy of $GOROOT/src/cmd/internal/archive.ReadHeader.
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/gcimporter/ureader.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/gcimporter/ureader.go
--- a/vendor/golang.org/x/tools/internal/gcimporter/ureader.go	2026-10-28 08:22:44.896102964 +0000
+++ b/vendor/golang.org/x/tools/internal/gcimporter/ureader.go	2026-10-28 08:23:38.664153810 +0000
@@ -13,9 +13,8 @@
 	"sort"
 	"strings"
 
-	"golang.org/x/tools/internal/aliases"
 	"golang.org/x/tools/internal/pkgbits"
-	"golang.org/x/tools/internal/typesinternal"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 // A pkgReader holds the shared state for reading a unified IR package
@@ -551,7 +550,9 @@
 				tparams = r.typeParamNames(false)
 			}
 			typ := r.typ()
-			declare(aliases.New(pos, objPkg, objName, typ, tparams))
+			tname := types.NewTypeName(pos, objPkg, objName, nil)
+			types.NewAlias(tname, typ).SetTypeParams(tparams)
+			declare(tname)
 
 		case pkgbits.ObjConst:
 			pos := r.pos()
@@ -588,7 +589,7 @@
 						sig := fn.Type().(*types.Signature)
 
 						recv := types.NewVar(fn.Pos(), fn.Pkg(), "", named)
-						typesinternal.SetVarKind(recv, typesinternal.RecvVar)
+						recv.SetKind(types.RecvVar)
 						methods[i] = types.NewFunc(fn.Pos(), fn.Pkg(), fn.Name(), types.NewSignatureType(recv, nil, nil, sig.Params(), sig.Results(), sig.Variadic()))
 					}
 
@@ -629,11 +630,26 @@
 				})
 			}
 
-			for i, n := 0, r.Len(); i < n; i++ {
-				named.AddMethod(r.method())
-			}
-
 			if r.Version().Has(pkgbits.GenericMethods) {
+				// V4 (go1.27.0) emitted all non-generic methods
+				// before all generic ones, discarding source
+				// order: a bug (go.dev/issue/81188).
+				// V5 (go1.27.x) fixes it by emitting an explicit
+				// index along with each method.
+				type indexedMethod struct {
+					index int // (or -1 in V4)
+					fn    *types.Func
+				}
+
+				var methods []indexedMethod
+
+				// ordinary methods
+				for range r.Len() {
+					idx, m := r.method()
+					methods = append(methods, indexedMethod{idx, m})
+				}
+
+				// generic methods
 				for range r.Len() {
 					// Careful: objIdx is used to read in package-scoped declarations, which
 					// methods are not. Instead, decode it here. This makes it easier to
@@ -648,11 +664,31 @@
 					pkg, name := r.selector()
 					rtparams := r.typeParamNames(true)
 					recv := r.param()
+					methodIdx := -1
+					if r.Version().Has(pkgbits.PreserveMethodOrder) {
+						methodIdx = r.Len()
+					}
 					tparams := r.typeParamNames(false)
 					sig := r.signature(recv, rtparams, tparams)
 
 					pr.retireReader(r)
-					named.AddMethod(types.NewFunc(pos, pkg, name, sig))
+					methods = append(methods, indexedMethod{methodIdx, types.NewFunc(pos, pkg, name, sig)})
+				}
+
+				if r.Version().Has(pkgbits.PreserveMethodOrder) {
+					sort.Slice(methods, func(i, j int) bool {
+						return methods[i].index < methods[j].index
+					})
+				}
+
+				for _, m := range methods {
+					named.AddMethod(m.fn)
+				}
+
+			} else {
+				for range r.Len() {
+					_, m := r.method()
+					named.AddMethod(m)
 				}
 			}
 
@@ -660,7 +696,7 @@
 			pos := r.pos()
 			typ := r.typ()
 			v := types.NewVar(pos, objPkg, objName, typ)
-			typesinternal.SetVarKind(v, typesinternal.PackageVar)
+			v.SetKind(types.PackageVar)
 			declare(v)
 		}
 	}
@@ -766,8 +802,12 @@
 	return tparams
 }
 
-func (r *reader) method() *types.Func {
+func (r *reader) method() (int, *types.Func) {
 	r.Sync(pkgbits.SyncMethod)
+	idx := -1
+	if r.Version().Has(pkgbits.PreserveMethodOrder) {
+		idx = r.Len()
+	}
 	pos := r.pos()
 	pkg, name := r.selector()
 
@@ -775,7 +815,7 @@
 	sig := r.signature(r.param(), rparams, nil)
 
 	_ = r.pos() // TODO(mdempsky): Remove; this is a hacker for linker.go.
-	return types.NewFunc(pos, pkg, name, sig)
+	return idx, types.NewFunc(pos, pkg, name, sig)
 }
 
 func (r *reader) qualifiedIdent() (*types.Package, string) { return r.ident(pkgbits.SyncSym) }
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/pkgbits/codes.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/pkgbits/codes.go
--- a/vendor/golang.org/x/tools/internal/pkgbits/codes.go	2026-10-28 08:22:44.900102968 +0000
+++ b/vendor/golang.org/x/tools/internal/pkgbits/codes.go	2026-10-28 08:23:38.664153810 +0000
@@ -4,6 +4,8 @@
 
 package pkgbits
 
+// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
+
 // A Code is an enum value that can be encoded into bitstreams.
 //
 // Code types are preferable for enum types, because they allow
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/pkgbits/decoder.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/pkgbits/decoder.go
--- a/vendor/golang.org/x/tools/internal/pkgbits/decoder.go	2026-10-28 08:22:44.900102968 +0000
+++ b/vendor/golang.org/x/tools/internal/pkgbits/decoder.go	2026-10-28 08:23:38.664153810 +0000
@@ -15,6 +15,7 @@
 	"os"
 	"runtime"
 	"strings"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 // A PkgDecoder provides methods for decoding a package's Unified IR
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/pkgbits/doc.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/pkgbits/doc.go
--- a/vendor/golang.org/x/tools/internal/pkgbits/doc.go	2026-10-28 08:22:44.900102968 +0000
+++ b/vendor/golang.org/x/tools/internal/pkgbits/doc.go	2026-10-28 08:23:38.664153810 +0000
@@ -30,3 +30,5 @@
 //
 // This is a copy of internal/pkgbits in the Go implementation.
 package pkgbits
+
+// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/pkgbits/encoder.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/pkgbits/encoder.go
--- a/vendor/golang.org/x/tools/internal/pkgbits/encoder.go	2026-10-28 08:22:44.900102968 +0000
+++ b/vendor/golang.org/x/tools/internal/pkgbits/encoder.go	2026-10-28 08:23:38.664153810 +0000
@@ -13,6 +13,7 @@
 	"math/big"
 	"runtime"
 	"strings"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 // A PkgEncoder provides methods for encoding a package's Unified IR
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/pkgbits/reloc.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/pkgbits/reloc.go
--- a/vendor/golang.org/x/tools/internal/pkgbits/reloc.go	2026-10-28 08:22:44.900102968 +0000
+++ b/vendor/golang.org/x/tools/internal/pkgbits/reloc.go	2026-10-28 08:23:38.664153810 +0000
@@ -4,6 +4,8 @@
 
 package pkgbits
 
+// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
+
 // A RelocKind indicates a particular section within a unified IR export.
 type RelocKind int32
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/pkgbits/support.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/pkgbits/support.go
--- a/vendor/golang.org/x/tools/internal/pkgbits/support.go	2026-10-28 08:22:44.900102968 +0000
+++ b/vendor/golang.org/x/tools/internal/pkgbits/support.go	2026-10-28 08:23:38.664153810 +0000
@@ -4,6 +4,7 @@
 
 package pkgbits
 
+// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 import "fmt"
 
 func assert(b bool) {
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/pkgbits/sync.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/pkgbits/sync.go
--- a/vendor/golang.org/x/tools/internal/pkgbits/sync.go	2026-10-28 08:22:44.900102968 +0000
+++ b/vendor/golang.org/x/tools/internal/pkgbits/sync.go	2026-10-28 08:23:38.664153810 +0000
@@ -8,6 +8,7 @@
 	"fmt"
 	"runtime"
 	"strings"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 // fmtFrames formats a backtrace for reporting reader/writer desyncs.
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/pkgbits/version.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/pkgbits/version.go
--- a/vendor/golang.org/x/tools/internal/pkgbits/version.go	2026-10-28 08:22:44.900102968 +0000
+++ b/vendor/golang.org/x/tools/internal/pkgbits/version.go	2026-10-28 08:23:38.664153810 +0000
@@ -4,6 +4,8 @@
 
 package pkgbits
 
+// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
+
 // Version indicates a version of a unified IR bitstream.
 // Each Version indicates the addition, removal, or change of
 // new data in the bitstream.
@@ -37,6 +39,10 @@
 	// V4: encodes generic methods as standalone function objects
 	V4
 
+	// V5: encodes the index of methods to preserve relative order
+	// of nongeneric and generic methods (go.dev/issue/81188).
+	V5
+
 	numVersions = iota
 )
 
@@ -76,6 +82,10 @@
 	// Generic methods may appear as standalone function objects.
 	GenericMethods
 
+	// Method index is encoded to preserve relative order of
+	// nongeneric and generic methods.
+	PreserveMethodOrder
+
 	numFields = iota
 )
 
@@ -85,6 +95,7 @@
 	AliasTypeParamNames: V2,
 	CompactCompLiterals: V3,
 	GenericMethods:      V4,
+	PreserveMethodOrder: V5,
 }
 
 // removed is the version a field was removed in or 0 for fields
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/stdlib/deps.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/stdlib/deps.go
--- a/vendor/golang.org/x/tools/internal/stdlib/deps.go	2026-10-28 08:22:44.900102968 +0000
+++ b/vendor/golang.org/x/tools/internal/stdlib/deps.go	2026-10-28 08:23:38.664153810 +0000
@@ -44,7 +44,7 @@
 	{"crypto/internal/boring/bcache", "\xcf\x02\x14"},
 	{"crypto/internal/boring/sig", ""},
 	{"crypto/internal/constanttime", ""},
-	{"crypto/internal/cryptotest", "\x03\r\v\n%\x11\x1a\r\x12\x12!\x04\x06\n\x19\x01\x11\x11\x1d\x01\a\x03\x02\b\x02\x01\x05\f"},
+	{"crypto/internal/cryptotest", "\x03\r\v\n%\x11\x1a\r\x12\x12!\x04\x06\n\x19\x01\x11\x11\x1d\x01\a\x03\x02\b\x02\x01\x04\x01\f"},
 	{"crypto/internal/cryptotest/wycheproof", "\x0e\x12T\x01\f\x01r@\x05\x03\x15\x10"},
 	{"crypto/internal/cryptotest/x509limbo", "u\n\x03\xba\x01\x03\x1e"},
 	{"crypto/internal/entropy", "M"},
@@ -122,7 +122,7 @@
 	{"embed/internal/embedtest", ""},
 	{"encoding", ""},
 	{"encoding/ascii85", "\x86\x02E"},
-	{"encoding/asn1", "\x03|\x03h(\x01)\r\x02\x01\x11\x03\x01"},
+	{"encoding/asn1", "\x03|\x03h(\x01)\x05\b\x02\x01\x11\x03\x01"},
 	{"encoding/base32", "\x86\x02C\x02"},
 	{"encoding/base64", "\xaa\x01\\C\x02"},
 	{"encoding/binary", "\x7f\x87\x01\f*\r\x05"},
@@ -319,7 +319,7 @@
 	{"net/rpc/jsonrpc", "u\n\x03\x84\x01\x16\x13\x1f"},
 	{"net/smtp", "\x196\r\x14\x0f\x03\x84\x01\x16\x16\x1a"},
 	{"net/textproto", "\x02\x01|\x03\x84\x01\f\n/\x01\x02\x15"},
-	{"net/url", "\x7f\x03Ff\v\x10\x02\x01\x17"},
+	{"net/url", "\x03|\x03Ff\v\x10\x02\x01\x17"},
 	{"os", "\x7f*\x01\x19\x04\x11\x14\x01\x03\x01\x05\x10\x01:\b\x05\x01\x01\r\x06"},
 	{"os/exec", "\x03\nrI(\x01\x15\x01-\x06\a\n\x01\x03\x01\r"},
 	{"os/exec/internal/fdtest", "\xd0\x02"},
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/typesinternal/isnamed.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/typesinternal/isnamed.go
--- a/vendor/golang.org/x/tools/internal/typesinternal/isnamed.go	2026-10-28 08:22:44.900102968 +0000
+++ b/vendor/golang.org/x/tools/internal/typesinternal/isnamed.go	2026-10-28 08:23:38.664153810 +0000
@@ -60,12 +60,10 @@
 // which is important for the performance of syntax matching.
 func IsMethodNamed(obj types.Object, pkgPath string, typeName string, names ...string) bool {
 	if fn, ok := obj.(*types.Func); ok {
-		if recv := fn.Signature().Recv(); recv != nil {
-			_, T := ReceiverNamed(recv)
-			return T != nil &&
-				IsTypeNamed(T, pkgPath, typeName) &&
-				slices.Contains(names, fn.Name())
-		}
+		_, T := RecvBase(fn)
+		return T != nil &&
+			IsTypeNamed(T, pkgPath, typeName) &&
+			slices.Contains(names, fn.Name())
 	}
 	return false
 }
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/typesinternal/recv.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/typesinternal/recv.go
--- a/vendor/golang.org/x/tools/internal/typesinternal/recv.go	2026-10-28 08:22:44.900102968 +0000
+++ b/vendor/golang.org/x/tools/internal/typesinternal/recv.go	2026-10-28 08:23:38.664153810 +0000
@@ -8,19 +8,32 @@
 	"go/types"
 )
 
-// ReceiverNamed returns the named type (if any) associated with the
-// type of recv, which may be of the form N or *N, or aliases thereof.
-// It also reports whether a Pointer was present.
+// RecvBase returns the receiver base type (if any) of the method fn,
+// and reports whether the receiver is a pointer to it.
 //
-// The named result may be nil if recv is from a method on an
-// anonymous interface or struct types or in ill-typed code.
-func ReceiverNamed(recv *types.Var) (isPtr bool, named *types.Named) {
-	t := recv.Type()
-	if ptr, ok := types.Unalias(t).(*types.Pointer); ok {
-		isPtr = true
-		t = ptr.Elem()
+// The spec says of a method declaration: the receiver's "type must be
+// a defined type T or a pointer to a defined type T, possibly followed
+// by a list of type parameter names [P1, P2, …] enclosed in square
+// brackets. T is called the receiver base type."
+//
+// The named result is nil if fn is not a method, or if its receiver
+// is an anonymous interface or struct type, as in interface{ f() }.
+//
+// TODO(adonovan): go.dev/issue/81715 proposes this as a method of *types.Func.
+func RecvBase(fn *types.Func) (isPtr bool, named *types.Named) {
+	// The boolean result appears first to
+	// avoid misinterpretation as an 'ok'
+	// bool, and because that's the natural
+	// reading order in "*Named".
+
+	if recv := fn.Signature().Recv(); recv != nil {
+		t := recv.Type()
+		if ptr, ok := types.Unalias(t).(*types.Pointer); ok {
+			isPtr = true
+			t = ptr.Elem()
+		}
+		named, _ = types.Unalias(t).(*types.Named)
 	}
-	named, _ = types.Unalias(t).(*types.Named)
 	return
 }
 
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/typesinternal/types.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/typesinternal/types.go
--- a/vendor/golang.org/x/tools/internal/typesinternal/types.go	2026-10-28 08:22:44.900102968 +0000
+++ b/vendor/golang.org/x/tools/internal/typesinternal/types.go	2026-10-28 08:23:38.668153814 +0000
@@ -9,7 +9,7 @@
 //   - functions for converting types to strings or syntax (e.g. [TypeExpr], FileQualifier]);
 //   - helpers for working with the [go/types] API (e.g. [NewTypesInfo]);
 //   - access to internal go/types APIs that are not yet
-//     exported (e.g. [SetUsesCgo], [ErrorCodeStartEnd], [VarKind]); and
+//     exported (e.g. [SetUsesCgo], [ErrorCodeStartEnd]); and
 //   - common algorithms related to types (e.g. [TooNewStdSymbols]).
 //
 // See also:
@@ -215,17 +215,17 @@
 		}
 	case *types.Var:
 		switch obj.Kind() {
-		case PackageVar:
+		case types.PackageVar:
 			return "package-level variable"
-		case LocalVar:
+		case types.LocalVar:
 			return "local variable"
-		case RecvVar:
+		case types.RecvVar:
 			return "receiver"
-		case ParamVar:
+		case types.ParamVar:
 			return "parameter"
-		case ResultVar:
+		case types.ResultVar:
 			return "result variable"
-		case FieldVar:
+		case types.FieldVar:
 			return "struct field"
 		}
 	case *types.Func:
@@ -271,6 +271,8 @@
 	}
 }
 
+// TupleOf returns a tuple type with the specified list of (unnamed)
+// var types. Neither the zero nor one cases are special.
 func TupleOf(elems ...types.Type) *types.Tuple {
 	params := make([]*types.Var, len(elems))
 	for i, elem := range elems {
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/typesinternal/varkind.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/typesinternal/varkind.go
--- a/vendor/golang.org/x/tools/internal/typesinternal/varkind.go	2026-10-28 08:22:44.900102968 +0000
+++ b/vendor/golang.org/x/tools/internal/typesinternal/varkind.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,23 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build go1.25
-
-package typesinternal
-
-import "go/types"
-
-type VarKind = types.VarKind
-
-const (
-	PackageVar = types.PackageVar
-	LocalVar   = types.LocalVar
-	RecvVar    = types.RecvVar
-	ParamVar   = types.ParamVar
-	ResultVar  = types.ResultVar
-	FieldVar   = types.FieldVar
-)
-
-func GetVarKind(v *types.Var) VarKind       { return v.Kind() }
-func SetVarKind(v *types.Var, kind VarKind) { v.SetKind(kind) }
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/typesinternal/varkind_go124.go /work/src/azuredisk-csi-driver/vendor/golang.org/x/tools/internal/typesinternal/varkind_go124.go
--- a/vendor/golang.org/x/tools/internal/typesinternal/varkind_go124.go	2026-10-28 08:22:44.900102968 +0000
+++ b/vendor/golang.org/x/tools/internal/typesinternal/varkind_go124.go	1970-01-01 00:00:00.000000000 +0000
@@ -1,39 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build !go1.25
-
-package typesinternal
-
-import "go/types"
-
-type VarKind uint8
-
-const (
-	_          VarKind = iota // (not meaningful)
-	PackageVar                // a package-level variable
-	LocalVar                  // a local variable
-	RecvVar                   // a method receiver variable
-	ParamVar                  // a function parameter variable
-	ResultVar                 // a function result variable
-	FieldVar                  // a struct field
-)
-
-func (kind VarKind) String() string {
-	return [...]string{
-		0:          "VarKind(0)",
-		PackageVar: "PackageVar",
-		LocalVar:   "LocalVar",
-		RecvVar:    "RecvVar",
-		ParamVar:   "ParamVar",
-		ResultVar:  "ResultVar",
-		FieldVar:   "FieldVar",
-	}[kind]
-}
-
-// GetVarKind returns an invalid VarKind.
-func GetVarKind(v *types.Var) VarKind { return 0 }
-
-// SetVarKind has no effect.
-func SetVarKind(v *types.Var, kind VarKind) {}
diff -Nur /work/src-orig/azuredisk-csi-driver/vendor/modules.txt /work/src/azuredisk-csi-driver/vendor/modules.txt
--- a/vendor/modules.txt	2026-10-28 08:22:45.204103267 +0000
+++ b/vendor/modules.txt	2026-10-28 08:23:41.292156728 +0000
@@ -572,7 +572,7 @@
 # go.yaml.in/yaml/v3 v3.0.5
 ## explicit; go 1.16
 go.yaml.in/yaml/v3
-# golang.org/x/crypto v0.57.0
+# golang.org/x/crypto v0.58.0
 ## explicit; go 1.26.0
 golang.org/x/crypto/blowfish
 golang.org/x/crypto/chacha20
@@ -591,7 +591,7 @@
 # golang.org/x/mod v0.41.0
 ## explicit; go 1.26.0
 golang.org/x/mod/semver
-# golang.org/x/net v0.59.0
+# golang.org/x/net v0.60.0 => golang.org/x/net v0.62.0
 ## explicit; go 1.26.0
 golang.org/x/net/context
 golang.org/x/net/html
@@ -612,21 +612,21 @@
 ## explicit; go 1.25.0
 golang.org/x/oauth2
 golang.org/x/oauth2/internal
-# golang.org/x/sync v0.23.0
+# golang.org/x/sync v0.24.0
 ## explicit; go 1.26.0
 golang.org/x/sync/errgroup
 golang.org/x/sync/singleflight
-# golang.org/x/sys v0.48.0
+# golang.org/x/sys v0.49.0
 ## explicit; go 1.26.0
 golang.org/x/sys/cpu
 golang.org/x/sys/plan9
 golang.org/x/sys/unix
 golang.org/x/sys/windows
 golang.org/x/sys/windows/registry
-# golang.org/x/term v0.46.0
+# golang.org/x/term v0.47.0
 ## explicit; go 1.26.0
 golang.org/x/term
-# golang.org/x/text v0.42.0
+# golang.org/x/text v0.43.0
 ## explicit; go 1.26.0
 golang.org/x/text/cases
 golang.org/x/text/encoding
@@ -660,15 +660,14 @@
 # golang.org/x/time v0.15.0
 ## explicit; go 1.25.0
 golang.org/x/time/rate
-# golang.org/x/tools v0.49.0
-## explicit; go 1.25.0
+# golang.org/x/tools v0.51.0
+## explicit; go 1.26.0
 golang.org/x/tools/cover
 golang.org/x/tools/go/ast/edge
 golang.org/x/tools/go/ast/inspector
 golang.org/x/tools/go/gcexportdata
 golang.org/x/tools/go/packages
 golang.org/x/tools/go/types/objectpath
-golang.org/x/tools/internal/aliases
 golang.org/x/tools/internal/event
 golang.org/x/tools/internal/event/core
 golang.org/x/tools/internal/event/keys
@@ -1694,3 +1693,4 @@
 # k8s.io/sample-controller => k8s.io/sample-controller v0.35.0
 # k8s.io/kms => k8s.io/kms v0.35.0
 # k8s.io/mount-utils => k8s.io/mount-utils v0.35.1
+# golang.org/x/net => golang.org/x/net v0.62.0
