Skip to main content

Cyber AI România

Duminică, 8 noiembrie 2026

osnoise și timerlat: identifici sursa jitterului în Linux

Un proces periodic rulează corect de mii de ori, apoi întârzie brusc cu câteva milisecunde. Media rămâne bună, însă aplicația audio, controlerul industrial sau serviciul de tranzacționare observă exact vârful pe care un benchmark obișnuit îl ascunde.

În acest laborator vom produce controlat un asemenea vârf pe CPU 2, îl vom clasifica prin osnoise, apoi vom folosi timerlat pentru a păstra urma care indică procesul responsabil. La final rămân un serviciu de test limitat, un diagnostic automat, jurnale rotite și un timer systemd pentru verificări periodice.

Laboratorul este destinat exclusiv unui server de test cu cel puțin patru procesoare logice. Generatorul folosește temporar politica SCHED_FIFO cu prioritate ridicată; nu îl porni pe un sistem de producție și nu îl muta pe CPU 0.

Rezultatul urmărit: un vârf controlat și numele procesului care l-a produs

Vom instala pe Ubuntu Server 24.04 LTS un program numit jitter-pulse. Acesta doarme aproximativ 100 ms, apoi ocupă CPU 2 timp de aproximativ 2 ms. Serviciul systemd îi aplică politica SCHED_FIFO, prioritatea 98 și afinitatea la un singur CPU.

Diagnosticul rulează două măsurători succesive:

  • rtla osnoise top arată că CPU 2 acumulează zgomot atribuit execuției altui thread;
  • rtla timerlat top folosește pragul automat de 500 µs și păstrează urma în care apare jitter-pulse;
  • scriptul scrie rezultatele în /var/log/latency-lab;
  • dacă numele generatorului apare în captura timerlat, este creat fișierul ALERT și este emis un mesaj în jurnal.

osnoise și timerlat nu răspund la aceeași întrebare. Primul separă timpul consumat de NMI, IRQ, softirq și thread-uri. Al doilea urmărește latența dintre expirarea timerului, handlerul IRQ și trezirea threadului periodic. Împreună permit trecerea de la „există jitter” la „această activitate a întârziat threadul măsurat”.

Pentru analiza detaliată a funcțiilor kernelului după identificarea evenimentului, continuarea firească este urmărirea latenței cu function_graph tracer. Dacă vârful coincide cu operații de disc, diagnosticul trebuie corelat separat cu iostat, pidstat, blktrace și PSI.

Fixăm laboratorul la CPU 2 și la un kernel cu tracerele necesare

Configurația folosită este:

  • Ubuntu Server 24.04 LTS;
  • kernel generic Ubuntu din seria 6.8, împreună cu pachetul linux-tools corespunzător exact kernelului pornit;
  • rtla furnizat de pachetul Ubuntu pentru acel kernel;
  • systemd din Ubuntu 24.04;
  • minimum patru procesoare logice;
  • aproximativ 100 MB liberi;
  • acces administrativ prin sudo;
  • 15-20 de minute pentru instalare și test.

Versiunea completă a kernelului depinde de actualizările instalate. Nu combina binarul rtla al altui kernel cu sistemul curent. Verifică mediul înainte să creezi serviciile:

cat /etc/os-release
uname -r
nproc
rtla version 2>/dev/null || true
systemd-analyze --version | head -n 1
gcc --version | head -n 1
grep -E 'CONFIG_(OSNOISE_TRACER|TIMERLAT_TRACER)=' "/boot/config-$(uname -r)"
grep -wE 'osnoise|timerlat' /sys/kernel/tracing/available_tracers

Un exemplu de rezultat compatibil este:

NAME="Ubuntu"
VERSION="24.04 LTS (Noble Numbat)"
6.8.0-xx-generic
4
CONFIG_OSNOISE_TRACER=y
CONFIG_TIMERLAT_TRACER=y
timerlat osnoise

Numărul de revizie xx, versiunea exactă rtla și ordinea tracerelor pot diferi. Condițiile obligatorii sunt existența CPU 2 și prezența cuvintelor osnoise și timerlat în available_tracers.

Dacă /sys/kernel/tracing nu este montat, montează tracefs, apoi repetă ultima verificare:

sudo mount -t tracefs nodev /sys/kernel/tracing

Instalarea rămâne într-un singur bloc. Pachetul construit pentru uname -r evită nealinierea dintre kernel și uneltele sale:

sudo apt update
sudo apt install -y 
  build-essential 
  linux-tools-common 
  "linux-tools-$(uname -r)" 
  util-linux 
  logrotate
command -v rtla
command -v gcc
command -v flock

Outputul așteptat pentru ultimele comenzi conține căile executabilelor, de regulă:

/usr/bin/rtla
/usr/bin/gcc
/usr/bin/flock

Punct de control: dacă pachetul linux-tools-$(uname -r) nu există, sistemul rulează probabil un kernel din alt depozit sau unul pentru care nu sunt instalate uneltele potrivite; nu continua până când kernelul și pachetul linux-tools nu provin din aceeași sursă.

Cele șapte fișiere separă interferența, măsurarea și retenția

Proiectul va avea această structură:

/usr/local/src/latency-lab/
└── jitter-pulse.c                 generatorul periodic, limitat la 2 ms

/usr/local/libexec/latency-lab/
├── jitter-pulse                   binarul compilat
└── run-diagnostic.sh              rulează osnoise și timerlat succesiv

/etc/systemd/system/
├── latency-jitter.service         aplică CPUAffinity și SCHED_FIFO generatorului
├── latency-diagnostic.service     lansează măsurarea cu privilegii administrative
└── latency-diagnostic.timer       programează verificarea periodică

/etc/logrotate.d/
└── latency-lab                    comprimă și limitează istoricul

Datele rezultate apar în subdirectoare cu marcaj temporal din /var/log/latency-lab. Generatorul rulează ca utilizatorul fără login latnoise; numai diagnosticul rulează ca root, deoarece rtla trebuie să configureze tracerele kernelului.

Pasul 1 — Compilăm un generator periodic care cedează CPU-ul după 2 ms

Programul trebuie să producă o interferență măsurabilă fără o buclă infinită care monopolizează complet procesorul. El folosește somn absolut pe ceasul CLOCK_MONOTONIC, apoi execută o buclă ocupată până la expirarea ferestrei de 2 ms.

Avertisment: serviciul va primi ulterior prioritatea real-time 98. Folosește numai CPU 2 al serverului de test și păstrează o sesiune administrativă deschisă pe alt CPU.

Creează utilizatorul, directoarele și fișierul /usr/local/src/latency-lab/jitter-pulse.c:

sudo useradd --system --no-create-home --shell /usr/sbin/nologin latnoise 2>/dev/null || true
sudo install -d -m 0755 /usr/local/src/latency-lab
sudo install -d -m 0755 /usr/local/libexec/latency-lab
sudo install -d -m 0750 /var/log/latency-lab

sudo tee /usr/local/src/latency-lab/jitter-pulse.c >/dev/null <<'EOF'
#define _GNU_SOURCE

#include <errno.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/prctl.h>
#include <time.h>
#include <unistd.h>

static volatile sig_atomic_t keep_running = 1;

static void stop_handler(int signo)
{
    (void)signo;
    keep_running = 0;
}

static int64_t to_ns(const struct timespec *value)
{
    return (int64_t)value->tv_sec * 1000000000LL + value->tv_nsec;
}

static struct timespec from_ns(int64_t value)
{
    struct timespec result;
    result.tv_sec = value / 1000000000LL;
    result.tv_nsec = value % 1000000000LL;
    return result;
}

int main(void)
{
    const int64_t period_ns = 100000000LL;
    const int64_t busy_ns = 2000000LL;
    struct timespec wake;
    struct timespec now;
    int sleep_result;

    if (signal(SIGTERM, stop_handler) == SIG_ERR ||
        signal(SIGINT, stop_handler) == SIG_ERR) {
        perror("signal");
        return EXIT_FAILURE;
    }

    if (prctl(PR_SET_NAME, "jitter-pulse", 0, 0, 0) == -1) {
        perror("prctl");
        return EXIT_FAILURE;
    }

    if (clock_gettime(CLOCK_MONOTONIC, &wake) == -1) {
        perror("clock_gettime");
        return EXIT_FAILURE;
    }

    fprintf(stdout, "jitter-pulse: period=100000us busy=2000usn");
    fflush(stdout);

    while (keep_running) {
        wake = from_ns(to_ns(&wake) + period_ns);

        do {
            sleep_result = clock_nanosleep(
                CLOCK_MONOTONIC,
                TIMER_ABSTIME,
                &wake,
                NULL
            );
        } while (sleep_result == EINTR && keep_running);

        if (sleep_result != 0 && sleep_result != EINTR) {
            errno = sleep_result;
            perror("clock_nanosleep");
            return EXIT_FAILURE;
        }

        if (!keep_running) {
            break;
        }

        if (clock_gettime(CLOCK_MONOTONIC, &now) == -1) {
            perror("clock_gettime");
            return EXIT_FAILURE;
        }

        {
            const int64_t busy_until = to_ns(&now) + busy_ns;
            do {
                if (clock_gettime(CLOCK_MONOTONIC, &now) == -1) {
                    perror("clock_gettime");
                    return EXIT_FAILURE;
                }
            } while (keep_running && to_ns(&now) < busy_until);
        }
    }

    return EXIT_SUCCESS;
}
EOF

sudo gcc 
  -O2 
  -Wall 
  -Wextra 
  -Werror 
  -std=c11 
  /usr/local/src/latency-lab/jitter-pulse.c 
  -o /usr/local/libexec/latency-lab/jitter-pulse

sudo chown root:root /usr/local/libexec/latency-lab/jitter-pulse
sudo chmod 0755 /usr/local/libexec/latency-lab/jitter-pulse

TIMER_ABSTIME împiedică acumularea erorilor de perioadă: următoarea trezire rămâne raportată la calendarul monoton, nu la momentul în care s-a terminat iterația precedentă. Cele două valori sunt fixe tocmai pentru ca laboratorul să aibă o singură configurație reproductibilă.

Verifică binarul fără prioritate real-time:

timeout --signal=TERM 1s /usr/local/libexec/latency-lab/jitter-pulse

Exemplul de output este:

jitter-pulse: period=100000us busy=2000us

Punct de control: dacă compilarea eșuează, nu relaxa opțiunile -Werror; mesajul compilatorului trebuie rezolvat înainte ca binarul să fie instalat ca serviciu privilegiat de scheduler.

Pasul 2 — Izolăm generatorul pe CPU 2 și îi limităm privilegiile

Fișierul /etc/systemd/system/latency-jitter.service stabilește afinitatea și politica de scheduling înainte de lansarea procesului:

[Unit]
Description=Controlled latency jitter generator for CPU 2
Documentation=https://docs.kernel.org/trace/osnoise-tracer.html
ConditionPathIsExecutable=/usr/local/libexec/latency-lab/jitter-pulse

[Service]
Type=simple
User=latnoise
Group=latnoise
ExecStart=/usr/local/libexec/latency-lab/jitter-pulse
Restart=on-failure
RestartSec=2s
CPUAffinity=2
CPUSchedulingPolicy=fifo
CPUSchedulingPriority=98
LimitRTPRIO=98
Nice=-20
NoNewPrivileges=yes
PrivateTmp=yes
PrivateDevices=yes
ProtectSystem=strict
ProtectHome=yes
ProtectControlGroups=yes
ProtectKernelModules=yes
ProtectKernelTunables=yes
RestrictAddressFamilies=AF_UNIX
LockPersonality=yes
MemoryDenyWriteExecute=yes

[Install]
WantedBy=multi-user.target

Aplică unitatea și pornește generatorul numai după ce confirmi că CPU 2 este online:

test -d /sys/devices/system/cpu/cpu2
grep -qw 2 /sys/devices/system/cpu/online || grep -qw '0-3' /sys/devices/system/cpu/online
sudo systemctl daemon-reload
sudo systemctl start latency-jitter.service
systemctl --no-pager --full status latency-jitter.service
ps -eLo pid,tid,cls,rtprio,psr,comm | grep '[j]itter-pulse'

CPUAffinity=2 împiedică generatorul să migreze. CPUSchedulingPriority=98 îl plasează deasupra threadului timerlat folosit în mod uzual pentru măsurare, iar NoNewPrivileges=yes împiedică procesul să obțină ulterior privilegii noi. Setările de protecție sunt posibile deoarece generatorul nu citește configurația kernelului și nu scrie fișiere.

Outputul ps trebuie să arate clasa FF, prioritatea real-time 98, procesorul 2 și numele jitter-pulse:

PID   TID CLS RTPRIO PSR COMMAND
...   ... FF      98   2 jitter-pulse

PID-ul diferă la fiecare pornire.

Punct de control: dacă PSR nu este 2 sau CLS nu este FF, oprește serviciul și inspectează journalctl -u latency-jitter.service; măsurarea nu mai testează scenariul definit aici.

Pasul 3 — Legăm clasificarea osnoise de captura timerlat

osnoise rulează primul pentru a confirma categoria interferenței. timerlat rulează apoi cu prag automat de 500 µs, suficient de mic față de pulsul controlat de aproximativ 2 ms. Cele două nu sunt lansate simultan, deoarece ambele configurează infrastructura globală de tracing.

Fișierul complet /usr/local/libexec/latency-lab/run-diagnostic.sh este:

#!/usr/bin/env bash
set -euo pipefail

readonly CPU=2
readonly THRESHOLD_US=500
readonly OUTPUT_ROOT=/var/log/latency-lab
readonly TRACEFS=/sys/kernel/tracing
readonly LOCK_FILE=/run/lock/latency-lab.lock
readonly RTLA=/usr/bin/rtla

fail() {
    printf 'ERROR: %sn' "$*" >&2
    exit 1
}

[[ ${EUID} -eq 0 ]] || fail "diagnostic must run as root"
[[ -x ${RTLA} ]] || fail "rtla is not executable at /usr/bin/rtla"
[[ -d /sys/devices/system/cpu/cpu${CPU} ]] || fail "CPU 2 does not exist"
grep -qw "${CPU}" /sys/devices/system/cpu/online ||
    grep -Eq "(^|,)0-${CPU}(,|$)" /sys/devices/system/cpu/online ||
    fail "CPU 2 is not online"
[[ -r ${TRACEFS}/available_tracers ]] ||
    fail "tracefs is unavailable at /sys/kernel/tracing"
grep -qw osnoise "${TRACEFS}/available_tracers" ||
    fail "osnoise tracer is unavailable"
grep -qw timerlat "${TRACEFS}/available_tracers" ||
    fail "timerlat tracer is unavailable"

exec 9>"${LOCK_FILE}"
flock -n 9 || fail "another latency-lab diagnostic holds the lock"

readonly RUN_ID
RUN_ID="$(date -u +%Y%m%dT%H%M%SZ)"
readonly RUN_DIR="${OUTPUT_ROOT}/${RUN_ID}"

install -d -m 0750 "${RUN_DIR}"

{
    printf 'run_id=%sn' "${RUN_ID}"
    printf 'kernel=%sn' "$(uname -r)"
    printf 'cpu=%sn' "${CPU}"
    printf 'threshold_us=%sn' "${THRESHOLD_US}"
    printf 'rtla='
    "${RTLA}" version 2>&1 || true
} >"${RUN_DIR}/environment.txt"

printf 'Running osnoise on CPU %sn' "${CPU}"
"${RTLA}" osnoise top 
    -c "${CPU}" 
    -d 20s 
    2>&1 | tee "${RUN_DIR}/osnoise.txt"

printf 'Running timerlat on CPU %s with %s us automatic thresholdn' 
    "${CPU}" "${THRESHOLD_US}"
"${RTLA}" timerlat top 
    -c "${CPU}" 
    -d 30s 
    -a "${THRESHOLD_US}" 
    2>&1 | tee "${RUN_DIR}/timerlat.txt"

if grep -Fq 'jitter-pulse' "${RUN_DIR}/timerlat.txt"; then
    printf 'source=jitter-pulsenstatus=threshold-triggeredn' 
        >"${RUN_DIR}/ALERT"
    logger -p daemon.warning -t latency-lab 
        "timerlat identified jitter-pulse on CPU ${CPU}; results: ${RUN_DIR}"
    printf 'ALERT: timerlat trace contains jitter-pulsen'
else
    printf 'INFO: jitter-pulse was not present in the captured timerlat outputn'
fi

printf 'RESULT_DIR=%sn' "${RUN_DIR}"

Instalează permisiunile:

sudo chown root:root /usr/local/libexec/latency-lab/run-diagnostic.sh
sudo chmod 0750 /usr/local/libexec/latency-lab/run-diagnostic.sh
sudo bash -n /usr/local/libexec/latency-lab/run-diagnostic.sh

-c 2 restrânge măsurarea la CPU 2. -d pune o limită explicită ambelor etape. În comanda timerlat, -a 500 activează modul automat și oprește captura când latența depășește 500 µs, păstrând informația de tracing asociată evenimentului.

Outputul final al scriptului trebuie să conțină:

Running osnoise on CPU 2
Running timerlat on CPU 2 with 500 us automatic threshold
ALERT: timerlat trace contains jitter-pulse
RESULT_DIR=/var/log/latency-lab/<marcaj-UTC>

Rândurile și valorile măsurate de rtla diferă între sisteme. În raportul osnoise, coloana asociată thread-urilor trebuie să fie nenulă; în captura timerlat trebuie căutat numele jitter-pulse, nu o valoare identică de latență.

Punct de control: dacă osnoise vede interferență de thread, dar timerlat.txt nu conține numele generatorului, verifică mai întâi clasa, prioritatea și CPU-ul prin comanda ps din pasul anterior.

Pasul 4 — Rulăm diagnosticul ca unitate și îl programăm săptămânal

Diagnosticul trebuie să configureze tracefs, deci rulează ca root. Suprafața sa este totuși limitată: nu primește acces la rețea, scrie numai în directorul jurnalelor și este omorât dacă depășește două minute.

Fișierul /etc/systemd/system/latency-diagnostic.service:

[Unit]
Description=Measure CPU 2 jitter with osnoise and timerlat
Documentation=https://docs.kernel.org/tools/rtla/rtla-osnoise.html
Documentation=https://docs.kernel.org/tools/rtla/rtla-timerlat.html
RequiresMountsFor=/sys/kernel/tracing
ConditionPathIsExecutable=/usr/bin/rtla
ConditionPathIsExecutable=/usr/local/libexec/latency-lab/run-diagnostic.sh

[Service]
Type=oneshot
User=root
Group=root
ExecStart=/usr/local/libexec/latency-lab/run-diagnostic.sh
TimeoutStartSec=2min
CPUAffinity=0
Nice=10
PrivateTmp=yes
ProtectHome=yes
ProtectSystem=strict
ReadWritePaths=/var/log/latency-lab /run/lock
RestrictAddressFamilies=AF_UNIX
LockPersonality=yes
RestrictRealtime=yes
SystemCallArchitectures=native

Procesul de control rulează pe CPU 0, în timp ce thread-urile tracerului sunt create pentru CPU 2 prin opțiunea -c 2. Nu activa ProtectKernelTunables=yes aici: rtla trebuie să scrie legitim în controalele tracefs.

Fișierul /etc/systemd/system/latency-diagnostic.timer:

[Unit]
Description=Weekly CPU 2 latency diagnostic

[Timer]
OnCalendar=Sun *-*-* 03:00:00
RandomizedDelaySec=5min
Persistent=true
Unit=latency-diagnostic.service

[Install]
WantedBy=timers.target

Instalează unitățile și execută prima măsurare manual:

sudo systemctl daemon-reload
sudo systemctl enable --now latency-diagnostic.timer
sudo systemctl start latency-diagnostic.service
systemctl --no-pager --full status latency-diagnostic.service
systemctl list-timers latency-diagnostic.timer --all
journalctl -u latency-diagnostic.service --no-pager
journalctl -t latency-lab --no-pager

Persistent=true face ca o rulare ratată în timp ce serverul era oprit să fie recuperată după pornire. RandomizedDelaySec=5min evită suprapunerea exactă cu alte activități săptămânale programate la aceeași oră.

Exemplul de stare reușită este:

Active: inactive (dead)
Result: success

O unitate oneshot terminată corect apare ca inactivă; aceasta nu indică un eșec. Jurnalul cu identificatorul latency-lab trebuie să indice directorul în care a fost găsită sursa.

Punct de control: verifică Result: success și existența unui director nou. Nu interpreta simplul cuvânt inactive ca problemă.

Pasul 5 — Păstrăm opt rotații fără să pierdem directorul ultimei capturi

Fiecare execuție produce fișiere text într-un director separat. logrotate poate procesa aceste fișiere fără să trimită semnale serviciilor, deoarece ele nu țin descriptorii deschiși după terminarea diagnosticului.

Fișierul /etc/logrotate.d/latency-lab:

/var/log/latency-lab/*/*.txt /var/log/latency-lab/*/ALERT {
    weekly
    rotate 8
    compress
    delaycompress
    missingok
    notifempty
    su root root
}

Testează sintaxa și simulează decizia de rotație:

sudo logrotate --debug /etc/logrotate.d/latency-lab

weekly stabilește frecvența, iar rotate 8 păstrează opt generații. delaycompress lasă ultima rotație necomprimată și comprimă generațiile mai vechi. Directoarele cu marcaj temporal rămân disponibile pentru corelarea fișierelor din aceeași măsurare.

Outputul de debug trebuie să enumere fișierele din /var/log/latency-lab și să precizeze dacă au nevoie sau nu de rotație. Modul --debug nu modifică fișierele.

Punct de control: dacă apare mesajul error: skipping ... because parent directory has insecure permissions, verifică proprietarul și readu directorul la root:root, cu modul 0750.

Testul de capăt: dintr-o singură rulare obținem clasificarea și procesul

Rulează întregul traseu și verifică ultimul director:

sudo systemctl restart latency-jitter.service
sudo systemctl start latency-diagnostic.service

LATEST_DIR="$(
  sudo find /var/log/latency-lab 
    -mindepth 1 
    -maxdepth 1 
    -type d 
    -printf '%fn' |
  sort |
  tail -n 1
)"

sudo test -n "${LATEST_DIR}"
sudo test -s "/var/log/latency-lab/${LATEST_DIR}/environment.txt"
sudo test -s "/var/log/latency-lab/${LATEST_DIR}/osnoise.txt"
sudo test -s "/var/log/latency-lab/${LATEST_DIR}/timerlat.txt"
sudo test -s "/var/log/latency-lab/${LATEST_DIR}/ALERT"
sudo grep -F 'source=jitter-pulse' 
  "/var/log/latency-lab/${LATEST_DIR}/ALERT"
sudo grep -F 'jitter-pulse' 
  "/var/log/latency-lab/${LATEST_DIR}/timerlat.txt"

Rezultatul acceptat include:

source=jitter-pulse

A doua comandă grep trebuie să afișeze cel puțin o linie din captura timerlat care conține același nume. Timestampurile, PID-urile și latențele diferă în mod legitim.

Interpretarea se face în această ordine:

  1. osnoise.txt confirmă că pe CPU 2 există timp consumat de alt thread, nu doar de IRQ sau softirq.
  2. timerlat.txt confirmă depășirea pragului de 500 µs.
  3. Urma păstrată conține jitter-pulse.
  4. ALERT leagă rezultatul automat de directorul măsurării.

Dacă într-un sistem real predomină IRQ sau softirq în locul categoriei thread, verifică afinitatea întreruperilor și dispozitivul asociat înainte să modifici schedulerul. Dacă problema indică wakeup-uri și întârzieri de rulare ale proceselor obișnuite, analiza schedulerului EEVDF oferă traseul următor. Optimizări precum rseq time slice extension se evaluează abia după identificarea mecanismului, nu ca remediu generic pentru orice vârf.

Cinci defecțiuni care localizează ruptura laboratorului

ERROR: CPU 2 does not exist

Mașina are mai puțin de trei procesoare logice sau CPU 2 nu este expus mediului virtual. Confirmă:

nproc
ls -d /sys/devices/system/cpu/cpu[0-9]*

Acest laborator cere minimum patru procesoare logice. Nu schimba mecanic valoarea în toate fișierele fără să alegi un CPU care nu găzduiește sesiunea administrativă.

ERROR: timerlat tracer is unavailable

Kernelul pornit nu include tracerul sau tracefs nu este montat. Separă cele două cauze:

mountpoint /sys/kernel/tracing || sudo mount -t tracefs nodev /sys/kernel/tracing
grep CONFIG_TIMERLAT_TRACER "/boot/config-$(uname -r)"
grep -w timerlat /sys/kernel/tracing/available_tracers

Dacă opțiunea kernelului nu este activă, pornește un kernel Ubuntu care o furnizează și instalează pachetul linux-tools al acelei versiuni.

ERROR: another latency-lab diagnostic holds the lock

Timerul și o rulare manuală s-au suprapus. Nu șterge fișierul de lock cât timp procesul există. Verifică unitatea și așteaptă terminarea:

systemctl status latency-diagnostic.service
journalctl -u latency-diagnostic.service -n 50 --no-pager

flock eliberează automat blocarea când procesul se încheie.

Failed to set SCHED_FIFO în jurnalul generatorului

Managerul de servicii nu a putut aplica politica cerută, de regulă din cauza unei limite real-time impuse sistemului sau containerului. Verifică unitatea și mediul:

systemctl show latency-jitter.service 
  -p CPUSchedulingPolicy 
  -p CPUSchedulingPriority 
  -p LimitRTPRIO
systemd-detect-virt

Laboratorul trebuie rulat pe o mașină sau mașină virtuală care permite scheduling real-time. Nu rezolva problema prin rularea binarului ca root; utilizatorul dedicat trebuie păstrat.

INFO: jitter-pulse was not present in the captured timerlat output

Măsurarea s-a terminat fără urma așteptată. Verifică dacă generatorul este activ, fixat pe CPU 2 și are prioritatea 98:

systemctl is-active latency-jitter.service
ps -eLo pid,tid,cls,rtprio,psr,comm | grep '[j]itter-pulse'
sudo grep -E 'CPU|jitter-pulse|timerlat' 
  /var/log/latency-lab/*/timerlat.txt |
  tail -n 30

Dacă serviciul este corect, repetă diagnosticul fără să pornești alte tracere în paralel. perf, trace-cmd sau altă sesiune rtla poate modifica infrastructura globală de tracing și invalida captura.

Oprim prioritatea real-time înainte să ștergem laboratorul

Ordinea contează: întâi oprește generatorul, apoi timerul și diagnosticul. Abia după aceea elimină fișierele.

sudo systemctl stop latency-jitter.service
sudo systemctl disable --now latency-diagnostic.timer
sudo systemctl stop latency-diagnostic.service 2>/dev/null || true

sudo rm -f 
  /etc/systemd/system/latency-jitter.service 
  /etc/systemd/system/latency-diagnostic.service 
  /etc/systemd/system/latency-diagnostic.timer 
  /etc/logrotate.d/latency-lab

sudo systemctl daemon-reload
sudo systemctl reset-failed

sudo rm -rf 
  /usr/local/src/latency-lab 
  /usr/local/libexec/latency-lab 
  /var/log/latency-lab

sudo userdel latnoise 2>/dev/null || true

Pachetele linux-tools nu sunt eliminate: ele aparțin depanării kernelului și pot fi folosite de alte fluxuri administrative. Verifică dispariția procesului real-time:

ps -eLo pid,tid,cls,rtprio,psr,comm | grep '[j]itter-pulse' || true
systemctl list-timers latency-diagnostic.timer --all

Outputul nu trebuie să mai conțină jitter-pulse sau timerul laboratorului.

Bifele care confirmă un diagnostic valid

  • ☐ CPU 2 există și este online.
  • ☐ Kernelul curent listează atât osnoise, cât și timerlat.
  • ☐ Binarul rtla aparține setului de unelte instalat pentru kernelul pornit.
  • ☐ jitter-pulse rulează ca utilizatorul latnoise, în clasa FF, cu prioritatea 98.
  • ☐ Generatorul rămâne fixat pe CPU 2.
  • ☐ osnoise.txt indică interferență produsă de un thread pe CPU 2.
  • ☐ timerlat.txt conține numele jitter-pulse.
  • ☐ Fișierul ALERT conține source=jitter-pulse.
  • ☐ Diagnosticul automat se termină cu Result: success.
  • ☐ Logurile au retenție de opt rotații, iar generatorul este oprit după test.

Trei extinderi după ce laboratorul identifică sursa

Prima extindere este înlocuirea generatorului cu serviciul real, păstrând aceeași măsurare pe CPU-ul aplicației. Pragul de 500 µs trebuie schimbat numai după ce este stabilit bugetul real de latență al acelui serviciu.

A doua este corelarea capturii cu function_graph atunci când urma indică o cale kernel lungă, nu un proces concurent. Colectarea trebuie făcută într-o fereastră scurtă, deoarece tracingul suplimentar poate modifica el însuși latența.

A treia este compararea aceleiași sarcini înainte și după mutarea IRQ-urilor sau izolarea CPU-ului. Păstrează fișierele environment.txt, aceeași durată și același prag; altfel compari configurații și condiții diferite, nu efectul unei singure schimbări.

Întrebări frecvente

Pot rula osnoise și timerlat simultan?

Nu în acest proiect. Ambele configurează infrastructura globală de tracing, iar scriptul le rulează succesiv: osnoise clasifică interferența, apoi timerlat capturează evenimentul și procesul asociat.

De ce generatorul folosește prioritatea real-time 98?

Prioritatea ridicată produce controlat o întârziere observabilă pe CPU 2. Procesul ocupă CPU-ul aproximativ 2 ms, apoi doarme aproximativ 100 ms și este limitat la serverul de test.

De ce unitatea de diagnostic rulează ca root?

rtla trebuie să configureze tracerele prin tracefs. Generatorul nu are această nevoie și rulează separat ca utilizatorul fără login latnoise.

Este suficient un rezultat mare în osnoise pentru a identifica procesul?

Nu. osnoise arată categoria sursei, precum thread, IRQ sau softirq. În laborator, numele jitter-pulse este confirmat în captura produsă de timerlat.

Surse

Facebook
X
WhatsApp
osnoise și timerlat: cum găsești sursa jitterului pe sisteme Linux sensibile la latență

Te-ar putea interesa si: