
concepts
Pod-level CPU request is 50m, status says 28m: the cgroup v2 round trip
status.resources.requests.cpu says 28m for a 50m request? The kubelet reads cpu.weight back from cgroup v2, and the round trip loses up to 27m.
On Kubernetes 1.36, a Pod with spec.resources.requests.cpu: 50m reports
status.resources.requests.cpu: 28m about a minute after it starts. Nothing
changed the Pod. The kubelet wrote your request to the Pod’s cgroup as
cpu.weight, read that file back on its next sync, and converted it back to
millicores. cpu.weight is too coarse to hold 50m, so a smaller number comes
back.
Only the status field is wrong. The scheduler, ResourceQuota and
kubectl describe node still use 50m, and the kernel got exactly the weight a
50m request has always got. It is fixed in 1.37 for Pods that set a pod-level
CPU request, and the fix was not backported to 1.36.
The reproduction
A Pod with a pod-level request and nothing else. No limit is needed.
apiVersion: v1
kind: Pod
metadata:
name: podres
spec:
resources:
requests:
cpu: 50m
containers:
- name: app
image: busybox:1.36
command: ["sleep", "infinity"]
On a kind cluster running Kubernetes 1.36.1 (cgroup v2, containerd 2.3.1, no feature gates changed), a minute or so after the Pod starts:
kubectl get pod podres -o custom-columns='NAME:.metadata.name,SPEC:.spec.resources.requests.cpu,ALLOCATED:.status.allocatedResources.cpu,STATUS:.status.resources.requests.cpu'
NAME SPEC ALLOCATED STATUS
podres 50m 50m 28m
Three fields in one object, and two of them agree. status.allocatedResources
is what the node accepted. status.resources is what the kubelet read back from
the cgroup.
It is not 28m straight away. The Pod below was created at 08:44:57 local time, and the status was polled every ten seconds:
for i in 1 2 3 4 5 6 7 8; do sleep 10; echo "$(date +%T) $(kubectl get pod podres -o jsonpath='{.status.resources}')"; done
08:45:41 {"requests":{"cpu":"50m"}}
08:45:51 {"requests":{"cpu":"50m"}}
08:46:01 {"requests":{"cpu":"28m"}}
08:46:11 {"requests":{"cpu":"28m"}}
While the Pod the kubelet is working from is not yet Running, the status is
copied from the spec (kubelet_pods.go lines 2182–2184 on release-1.36). The
next sync reads the cgroup. The kubelet resyncs every Pod once a minute by
default (syncFrequency, pkg/kubelet/apis/config/v1beta1/defaults.go line 79),
so the number changes about a minute in and then stays wrong.
The fastest check
Compare the status with the file it was read from. Get the Pod’s UID:
kubectl get pod podres -o jsonpath='{.metadata.uid}{"\n"}'
8b11469e-0cb2-4e09-a971-f541155eb7b8
Then read cpu.weight in the Pod’s slice on the node, with the dashes in the
UID turned into underscores. This is a kind node, which sets the kubelet’s
cgroupRoot to /kubelet, so the hierarchy sits under kubelet.slice. On an
ordinary systemd node, start at /sys/fs/cgroup/kubepods.slice/ instead.
cat /sys/fs/cgroup/kubelet.slice/kubelet-kubepods.slice/*/*pod8b11469e_0cb2_4e09_a971_f541155eb7b8.slice/cpu.weight
2
If the file says 2, the status says 28m. The request is still 50m. The status is just a lossy reading of that file.
Where 28m comes from
The trip there, from millicores to shares to cpu.weight, is covered in
CPU requests vs limits: what each one writes to the cgroup.
The short version is two integer divisions:
MilliCPUToShares(50)= 50 × 1024 / 1000 = 51 shares (pkg/kubelet/cm/helpers_linux.goline 99,release-1.36)getCPUWeight(51)= 1 + (49 × 9999) / 262142 = 2 (pkg/kubelet/cm/cgroup_manager_linux.goline 276)
This article is about the trip back, which the kubelet makes on every Pod sync when it builds the Pod’s status:
getCgroupCPUConfigreadscpu.weightfrom the Pod’s cgroup (pkg/kubelet/cm/cgroup_v2_manager_linux.goline 128) and turns it back into shares withcpuWeightToCPUShares(lines 174–176): (2 − 1) × 262142 / 9999 + 2 = 28 shares.CPURequestsFromConfig(helpers_linux.goline 354) passes that toSharesToMilliCPU(lines 389–395): ceil(28 × 1000 / 1024) = 28m.convertToAPIPodLevelResourcesStatus(pkg/kubelet/kubelet_pods.goline 2181) writes it over the spec value instatus.resources(line 2236).
The kubelet’s authors knew. The function carries a comment from the start:
“TODO(ndixita): Revisit the decision to output cgroup values in Pod Status. The
internal rounding off logic can introduce minute variability, making the output
inconsistent.” (kubelet_pods.go line 2186).
Every request is affected, not just 50m
cpu.weight is an integer from 1 to 10000 standing in for shares from 2 to
262144, so one step of weight is about 26 shares, a little over 25m. Every
request inside a step is written as the same weight, and the inverse returns a
value just below the bottom of that step. Any request from 29m to 53m becomes
weight 2 and comes back as 28m. Any request from 80m to 104m becomes weight 4
and comes back as 79m.
Eight Pods on the same 1.36.1 node, one per request, requests only:
kubectl get pods --sort-by=.status.allocatedResources.cpu -o custom-columns='NAME:.metadata.name,SPEC:.spec.resources.requests.cpu,STATUS:.status.resources.requests.cpu'
NAME SPEC STATUS
podres-10 10m 2m
podres-25 25m 2m
podres 50m 28m
podres-100 100m 79m
podres-250 250m 232m
podres-500 500m 489m
podres-1cpu 1 975m
podres-2cpu 2 1999m
With the cpu.weight read from each Pod’s slice on the node:
spec request | shares written | pod cpu.weight | status on 1.36 |
|---|---|---|---|
10m | 10 | 1 | 2m |
25m | 25 | 1 | 2m |
50m | 51 | 2 | 28m |
100m | 102 | 4 | 79m |
250m | 256 | 10 | 232m |
500m | 512 | 20 | 489m |
1 | 1024 | 39 | 975m |
2 | 2048 | 79 | 1999m |
Every row was read from the live node, and a small Go program that copies the four kubelet functions verbatim reproduces all eight. Running the same program over every request from 3m to 64 CPUs shows the shape of the error: the status is never higher than the request, and never more than 27m lower. That is noise on a 2-CPU Pod and most of the request on a 25m one.
A pod-level CPU limit does not have this problem. It is written to
cpu.max as a quota and period in microseconds, which reads back exactly. With
limits.cpu: 100m added to the same Pod, cpu.max is 10000 100000 and
status.resources.limits.cpu stays 100m, while the request beside it still
drops to 28m.
Container status is not affected
status.containerStatuses[].resources does not read the cgroup. The kubelet asks
the container runtime over CRI, and the runtime reports the shares it was given,
not the weight it wrote. toKubeContainerResources converts those with the same
SharesToMilliCPU (pkg/kubelet/kuberuntime/kuberuntime_container_linux.go
lines 404–405), and ceil(51 × 1000 / 1024) is 50. A Pod with a 50m request on its
container and no pod-level resources, on 1.36.1:
kubectl get pod ctr-only -o custom-columns='NAME:.metadata.name,CONTAINER_SPEC:.spec.containers[0].resources.requests.cpu,CONTAINER_STATUS:.status.containerStatuses[0].resources.requests.cpu,POD_STATUS:.status.resources.requests.cpu'
NAME CONTAINER_SPEC CONTAINER_STATUS POD_STATUS
ctr-only 50m 50m 28m
The container status is right. What the runtime reports, from
crictl inspect on the node:
"cpuShares": "51",
The last column is the surprise. This Pod never set spec.resources, and it
still has a pod-level status.resources saying 28m. The API reference says the
field is filled in “if pod-level requests or limits are set in
PodSpec.Resources” (staging/src/k8s.io/api/core/v1/types.go lines 5465–5467,
release-1.36), but the kubelet fills it in for every running Pod whenever the
InPlacePodLevelResourcesVerticalScaling feature gate is on (kubelet_pods.go
lines 2157–2158). The Pod’s cgroup gets the summed container requests, and the
same round trip happens. A Guaranteed Pod with 50m requests and limits on its
one container reads back the same way: requests.cpu 28m, limits.cpu 50m. On
1.36 this is not a pod-level-resources bug. Every running Pod with a CPU request
of 29m or more reports a lower status.resources.requests.cpu than it asked
for, and requests from 3m to 28m drop to 2m.
The container’s own cgroup has a different weight again: 11, not 2. That weight is set by the OCI runtime (runc 1.4 on this node) with the newer shares-to-weight formula, and the kubelet never reads it back, so it plays no part here.
The fix in 1.37, and what it leaves
The bug was reported as kubernetes/kubernetes#137628 on 11 March 2026, against 1.35.0 with the feature gates turned on by hand. The fix is #137660, “fix cgroup v2 pod level cpu request readback issue”, merged on 22 July 2026 and released in 1.37.0 with the note “kubelet: fix wrong Pod-level CPU requests status from cgroup v2 readback”. It is listed under Bug or Regression in the 1.37 changelog. The issue was closed on 21 September 2026.
The fix changes nothing about what is written to the cgroup. It changes how the
readback is judged. A new helper, CPUSharesEqualAfterV2RoundTrip
(pkg/kubelet/cm/helpers_linux.go lines 430–432 on release-1.37), takes the
shares the Pod was allocated, pushes them through getCPUWeight and
cpuWeightToCPUShares, and compares the result with what was read from the
cgroup. In convertToAPIPodLevelResourcesStatus (kubelet_pods.go lines
2258–2271), a match means the difference is only rounding, so the allocated
request stays in the status. No match means something really changed the cgroup,
and the readback is reported as before. For the 50m Pod: 51 shares round-trip to
28, the cgroup says 28, so the status keeps 50m.
The same eight Pods and ctr-only on a 1.37.0 kind cluster, with the same
kubectl get pods command:
NAME SPEC STATUS
podres-10 10m 10m
podres-25 25m 25m
ctr-only <none> 28m
podres 50m 50m
podres-100 100m 100m
podres-250 250m 250m
podres-500 500m 500m
podres-1cpu 1 1
podres-2cpu 2 2
The pod cpu.weight is still 2 for the 50m Pod. Only the report changed.
ctr-only is still 28m. The value the fix compares against is the Pod’s
spec.resources (resources := allocatedPod.Spec.Resources.DeepCopy(),
kubelet_pods.go line 2234). With no pod-level request, that is zero, which
round-trips to 2 shares, which does not match 28, so the readback wins. On 1.37,
Pods that set a pod-level CPU request report it correctly. Pods that set CPU
requests only on their containers still get the lossy pod-level status. The code
is the same on master as of 30 September 2026, and we found no upstream issue
for this case.
Which versions are affected
| Version | Pod-level status.resources | CPU request in it |
|---|---|---|
| 1.34 and earlier | Field does not exist | Not affected |
| 1.35 | Only with the alpha InPlacePodLevelResourcesVerticalScaling gate turned on | Lossy when turned on |
| 1.36.0–1.36.5 | On by default (gate beta) | Lossy for every running Pod with a CPU request |
| 1.37.0, 1.37.1 | On by default | Correct with a pod-level request; still lossy without one |
The gate is alpha in 1.35 and beta, on by default, from 1.36
(pkg/features/kube_features.go lines 1529–1532 on release-1.36).
PodLevelResources itself has been beta and on by default since 1.34 (lines
1780–1783). There is no cherry-pick of #137660 on release-1.36 or
release-1.35: the helper is absent from both branches and from the v1.36.5
tag, and we found no cherry-pick PR.
Nodes on cgroup v1 are not affected on any version. There the kubelet reads
cpu.shares directly (cgroup_v1_manager_linux.go line 137, release-1.36),
and 51 shares read back as 50m. That is from the source. We did not run a
cgroup v1 node.
What reads this field, and what should
Kubernetes itself does not trust status.resources on its own. PodRequests in
k8s.io/component-helpers/resource, which the scheduler’s NodeResourcesFit
plugin uses, only consults it through determineEffectiveRequests, and that
takes the maximum of spec, status and allocated (helpers.go lines 299–304 on
release-1.36). A status that is too low cannot shrink what the node is charged:
kubectl describe node glance-blog-control-plane | grep -E 'Namespace +Name| podres +[0-9]'
Namespace Name CPU Requests CPU Limits Memory Requests Memory Limits Age
k25-podres podres 50m (0%) 0 (0%) 0 (0%) 0 (0%) 16m
kubectl describe pod prints the spec, so it shows 50m too. The field only hurts
code that reads it directly: your own scripts, dashboards and anything else that
walks Pod status. The rule for such code:
- For what a Pod asked for, read the spec. Use
spec.resourcesandspec.containers[].resources, orstatus.allocatedResources, which is the total the node admitted and is already summed across containers (types.golines 5458–5463). All three said 50m on both versions. - Read
status.resourcesas what the kubelet reads back from the node. It exists so you can see an in-place resize take effect. On cgroup v2 its CPU request is a reconstruction fromcpu.weight, and on 1.36 it will not match the spec for most values. - Do not wait for
status.resourcesto equal the spec to decide that a resize has finished. On 1.36 that wait never ends for most CPU values. Watch thePodResizePendingandPodResizeInProgressconditions instead. - Do not compare usage with the status value. A request-vs-usage report
that takes requests from
status.resourcesmakes 25m Pods look as if they reserved 2m. Take requests from the spec, as in finding reserved but idle CPU and memory.
Fixing it
On 1.36, read the spec. There is no setting that makes the 1.36 kubelet
report the right number except turning off InPlacePodLevelResourcesVerticalScaling,
which removes the field and in-place resize of pod-level resources along with it.
Change the reader, not the cluster.
On 1.37, set the request at pod level if you need the status. A Pod with
spec.resources.requests.cpu gets an exact status. A Pod whose requests are only
on its containers still gets the lossy value, so tools should keep reading the
spec.
Do not change the request to make the status look right. 28m and 50m are
the same cpu.weight, so the kernel treats the two Pods identically, but the
scheduler would reserve 28m instead of 50m. The number in the spec is the one
that decides where the Pod runs.
The Kubernetes dashboard that fits in your pocket
KubeGlance is a native Kubernetes client for iPhone and iPad — the real dashboard, not a companion — with a full Mac app on the same core. Pods, workloads, logs and events, straight from your kubeconfig.
Download KubeGlance

