Windows killer copies osCmd with its sync.Once, so force kill closes the job object handle twice

Summary

newKiller on Windows copies the osCmd struct by value. The struct holds a sync.Once that guards closing the job object handle. After the copy, the killer and the original command each have their own Once. A force kill closes the job object handle through the copy. When the process exits, Wait closes the same handle value again through the original. The fix is to share one osCmd instead of copying it.

Why it matters: Windows can reuse a closed handle value, so the second close can close an unrelated handle in the runner.

Acceptance criteria

  • GOOS=windows go vet ./helpers/process/ reports no copylocks warning.
  • With FF_USE_WINDOWS_JOB_OBJECT on, a force kill followed by Wait closes the job object handle once.
  • A Windows test covers the force kill then Wait sequence and fails on the current code.
Evidence

Versions

  • Code read at commit 30f0b2097c8bbce086205e47607465ecb023c3c4 on main. Not tested on a released Runner version.
  • The go vet warning was also reproduced on the head of a branch that is one comment change ahead of that commit.
  • Not run on Windows: the double close and the handle reuse were read from the code, not observed. No Windows host was available.

Steps to reproduce

  1. Run GOOS=windows go vet ./helpers/process/ from the repository root. Use GOWORK=off if a parent go.work interferes.
  2. Result: helpers/process/killer_windows.go:27:11: literal copies lock value from *osCmd: ... contains sync.Once contains sync.noCopy.

The runtime sequence below was not run:

  1. Start a command with FF_USE_WINDOWS_JOB_OBJECT on.
  2. Cancel the job so KillAndWait runs and the graceful timeout expires.
  3. ForceKill closes the job object handle through the killer's copy. The job kills the process.
  4. Wait returns and closeJobObject closes the same handle value through the original.

Logs and output

helpers/process/killer_windows.go:27:11: literal copies lock value from *osCmd: gitlab.com/gitlab-org/gitlab-runner/helpers/process.osCmd contains sync.Once contains sync.noCopy
Detailed explanation (context for LLM agents and implementers)

Terms

  • Job object: a Windows object that groups processes. With JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE, closing its last handle kills the processes in it.
  • Killer: the windowsKiller that KillAndWait builds to stop a process.

How it works today

  1. osCmd.Start creates the job object and stores the handle in c.jobObject when UseWindowsJobObject is set: job_windows.go#L25-48.
  2. KillAndWait runs after Start. It calls newProcessKiller, then Terminate, then ForceKill after the graceful timeout: killer.go#L76-83.
  3. newKiller copies the command: cmd: *osCmd: killer_windows.go#L20-28. The copy has the handle value and a fresh, unused Once.
  4. ForceKill kills the process, then calls closeJobObject on the copy: killer_windows.go#L45-55.
  5. closeJobObject runs CloseHandle inside once.Do: job_windows.go#L67-74.
  6. The caller waits on osCmd.Wait. After the process exits, Wait calls closeJobObject on the original, whose Once was never used: job_windows.go#L50-54.

What goes wrong, and where

Step 4 and step 6 each call CloseHandle on the same handle value, because the two Once values are separate. The second call fails with an invalid handle error that the code ignores, unless another component opened a handle in the meantime. Windows can give a closed handle value to the next CreateJobObject, file or pipe call. The second close then closes that other handle. Handle reuse was not observed.

History

Not determined. The same code is at the commit above, so it did not come from the merge request that removes FF_USE_WINDOWS_LEGACY_PROCESS_STRATEGY.

  • #39289 (closed) : handle leak under the same feature flag (closed). It is where the close logic was added. Not verified that it introduced the copy.

Workaround

Do not set FF_USE_WINDOWS_JOB_OBJECT.

Proposed fix and fix options

  • Option A: store the *osCmd pointer in windowsKiller and use it directly. One Once then guards both callers. This is the smallest change. Not tested.
  • Option B: move the Once behind a pointer inside osCmd, so a copy shares it.

Tests to add

  • File helpers/process/killer_windows_test.go or a new *_windows_test.go file.
  • Setup: newOSCmd with UseWindowsJobObject: true, Start a long-running command, call newKiller(...).ForceKill(), call CreateJobObject(), then call Wait.
  • Before the fix: if the new job object has the same handle value as the first, WaitForSingleObject on it fails after Wait because it was closed. After the fix: it stays valid.
  • A compile-checked version of this test was written. It was not run.

Commands

  • GOOS=windows go vet ./helpers/process/
  • GOOS=windows go test -c ./helpers/process/ to compile the Windows tests on another OS.

Out of scope

  • The removal of FF_USE_WINDOWS_LEGACY_PROCESS_STRATEGY. This defect does not depend on it.