Desinkronisasi metrik dan status proses pada backend berbasis Linux sering bersumber dari pembacaan /proc yang mengasumsikan pseudo-filesystem ini bersifat atomik dan persisten. Gejala klasik mencakup worker pool yang gagal mendeteksi kematian child process, reporting konsumsi memori yang anomali, hingga pembacaan metrik CPU dari proses asing akibat PID recycling.

Gejala dan Dampak pada Backend Daemon

Layanan backend yang mengawasi proses (process supervisor, agent APM, atau worker pool orchestrator) biasanya mengumpulkan data dengan melakukan iterasi direktori /proc/[pid]. Masalah inkonsistensi umumnya memicu anomali berikut:

  • Metrik CPU/Memori Korup: Parsing /proc/[pid]/stat dan /proc/[pid]/status yang dilakukan bertahap menghasilkan kalkulasi bursty atau nilai negatif karena data dibaca dari dua proses berbeda pada PID yang sama.
  • Ghost Child Tracking: Worker melempar sinyal manajemen (seperti SIGTERM) ke PID target, tetapi sinyal diterima oleh proses baru yang dialokasikan OS secara instan.
  • Masking Pseudo-Filesystem di Container: Container engine me-mount /proc tanpa namespacing penuh (misalnya tanpa pid_namespace terisolasi) sehingga pembacaan path host memicu data stale akibat masking direktori sysfs/cgroups.

Root Cause: Lifecycle PID dan Non-Atomisitas /proc

Pseudo-filesystem procfs bukan filesystem fisik melainkan view runtime kernel Linux. Ketidaktahuan atas sifat internal kernel memicu dua akar masalah utama:

1. Ketiadaan Garansi Atomisitas Multiberkas

Ketika backend membuka /proc/[pid]/stat lalu membuka /proc/[pid]/cmdline, kernel tidak menyediakan transaksi baca atomik antar berkas. Jika proses mati tepat di antara kedua syscall open(), operasi kedua menghasilkan ENOENT atau membaca entri dari proses baru hasil daur ulang.

2. PID Recycling Race Condition

Secara default, nilai /proc/sys/kernel/pid_max pada arsitektur 64-bit sering bernilai 32768 atau 4194304. Di server dengan churn rate proses tinggi (misalnya runner short-lived jobs), PID yang baru selesai akan langsung digunakan kembali oleh kernel. Pengecekan status via kill(pid, 0) hanya memvalidasi ada/tidaknya proses, bukan identitas proses yang dimaksud.

Langkah Remediasi dan Pola Akses Aman

Untuk memastikan data metrik akurat dan operasi tertuju ke proses yang benar, gunakan tiga teknik mitigasi teknis berikut:

1. Validasi Inode dan Tracking start_time

Kolom ke-22 pada /proc/[pid]/stat menyimpan starttime (dihitung dalam jiffies setelah boot). Nilai ini konstan selama proses hidup. Jika starttime berubah saat pembacaan ulang, PID tersebut telah didaur ulang.

2. Linux pidfd API (Kernel 5.3+)

Pendekatan modern adalah memanfaatkan file descriptor proses via syscall pidfd_open(2). pidfd terikat langsung ke struct task_struct di kernel. Sekalipun PID numerik didaur ulang, fd tetap stabil atau memicu event poll saat proses mati, mencegah sinyal salah alamat.

Implementasi Verifikasi Proses di Go

Contoh berikut mendemonstrasikan pembacaan metrik /proc/[pid]/stat yang diverifikasi melalui field starttime dan validasi deskriptor via pidfd di Linux:

package main

import (
	"bytes"
	"errors"
	"fmt"
	"os"
	"strconv"
	"strings"
	"syscall"
	"golang.org/x/sys/unix"
)

type ProcessIdentity struct {
	PID       int
	StartTime uint64
	PIDFd     int
}

func OpenProcess(pid int) (*ProcessIdentity, error) {
	// Dapatkan pidfd untuk mencegah race condition (Linux 5.3+)
	fd, err := unix.PidfdOpen(pid, 0)
	if err != nil {
		return nil, fmt.Errorf("pidfd_open: %w", err)
	}

	startTime, err := readStartTime(pid)
	if err != nil {
		unix.Close(fd)
		return nil, err
	}

	return &ProcessIdentity{
		PID:       pid,
		StartTime: startTime,
		PIDFd:     fd,
	}, nil
}

func (p *ProcessIdentity) Validate() error {
	currentStartTime, err := readStartTime(p.PID)
	if err != nil {
		return fmt.Errorf("proses tidak ditemukan: %w", err)
	}

	if currentStartTime != p.StartTime {
		return errors.New("PID recycling terdeteksi: start_time berbeda")
	}
	return nil
}

func (p *ProcessIdentity) Close() {
	if p.PIDFd >= 0 {
		unix.Close(p.PIDFd)
	}
}

func readStartTime(pid int) (uint64, error) {
	statPath := fmt.Sprintf("/proc/%d/stat", pid)
	data, err := os.ReadFile(statPath)
	if err != nil {
		return 0, err
	}

	// Nama executable dibungkus tanda kurung, cari penutupnya untuk memotong string dengan aman
	idx := bytes.LastIndexByte(data, ')')
	if idx == -1 || idx+2 >= len(data) {
		return 0, errors.New("format /proc/[pid]/stat invalid")
	}

	fields := strings.Fields(string(data[idx+2:]))
	// Kolom 22 global adalah indeks 19 jika dihitung dari setelah field comm
	if len(fields) < 20 {
		return 0, errors.New("field stat tidak lengkap")
	}

	return strconv.ParseUint(fields[19], 10, 64)
}

func main() {
	pid := os.Getpid()
	proc, err := OpenProcess(pid)
	if err != nil {
		panic(err)
	}
	defer proc.Close()

	if err := proc.Validate(); err != nil {
		fmt.Printf("Validasi gagal: %v\n", err)
		return
	}
	fmt.Printf("Proses %d valid, start_time: %d\n", proc.PID, proc.StartTime)
}

Verifikasi dan Audit di Lingkungan Produksi

Untuk memastikan backend Anda bebas dari desinkronisasi metrik proses:

  1. Audit Syscall: Gunakan strace -e trace=openat,read,close -p <backend_pid> untuk memastikan kode membaca stat dalam single buffer dan memverifikasi stat inode dari /proc/[pid] via fstatat(2).
  2. Uji PID Thrashing: Jalankan script loop spawning proses di Linux container untuk memicu rotasi PID cepat. Amati apakah service monitoring backend melaporkan anomali lonjakan metrik atau crash dengan error ESRCH.
  3. Alternatif Netlink: Jika kernel target belum mendukung pidfd_open, manfaatkan proc_events connector berbasis Linux Netlink socket untuk menerima event lifecycle (fork, exec, exit) secara real-time via event stream daripada polling manual via procfs.