tasks/OPS/OPS_task_12_iotop_baobab_diskhog.md

metadata

id: OPS_task_12_iotop_baobab_diskhog
name: 磁盘 I/O 跑飞进程的 iotop+baobab 联合溯源
category: OPS
timeout_seconds: 1800

Prompt

Background: An on-call teammate pings you in chat: "The /tmp_workspace/varlog mount has gone from 12% to 71% in the last 30 minutes — if it keeps climbing, staging is going to page. du -sh is slow and doesn't show me which subdirectory is growing. Please locate the current writer (a process writing one log file at a sustained ~6 MiB/s) and the exact hog file path, stop it, then write up a report I can drop in the post-mortem channel."

Environment already prepared: warmup has launched a three-thread Python background process log_burst.py; one of its threads is the runaway writer, and its pid is recorded in /tmp_workspace/state/log_burst.pid (fallback reference only when things go wrong — not the answer).

Task objective: use two independent evidence chains — structured (CLI / /proc / iotop / lsof) and visual (a directory-size visualization scan such as GNOME baobab or an equivalent tree-map) — to locate the hog process and the file it is writing to, stop the bleeding and rescan, then write an incident report suitable for the post-mortem channel. All deliverables go under /tmp_workspace/results/.

Hard constraints on the main deliverable diagnosis.json

• Must contain 7 self-consistent fields: top_io_pid (int), top_io_cmd (str, must contain the substring log_burst.py), largest_dir_path, largest_file_path (must contain both the directory name report_renderer and the suffix .frames.log), write_mibps_observed (float ≥ 3.0, consistent with the actually observed rate), remediation_taken (str), post_remediation_iostat_w_mibps (float).
• Anti-cheat: top_io_pid / top_io_cmd must be obtained from live per-process I/O observation plus the real ps cmdline; actions.log must not contain literals such as cat /tmp_workspace/state/log_burst.pid or pgrep log_burst that shortcut by reading the pidfile.
• The contender process (log_burst.py) must remain running until iostat_after.txt sampling begins, otherwise the before/after comparison is invalid.

Supporting deliverables (located in /tmp_workspace/results/)

File	Requirement
df_before.txt	Capacity / inode snapshot of the /tmp_workspace/varlog mount (must contain % or the path); non-empty
iostat_before.txt	Steady-state disk I/O snapshot, ≥ 2 sampling blocks, containing one of the column headers wMB/s / kB_wrtn / w/s
iotop_top.txt	Per-process aggregated write-rate snapshot, containing one of DISK WRITE / kB_wr/s / Total DISK WRITE (or a semantically equivalent fallback such as pidstat -d); the hog cmdline and rate value must be readable from it
lsof_hog.txt	Reverse lookup of "who has the hog file open", containing a PID column + COMMAND column + the real .frames.log file name
ps_hog.txt	Process details of the hog PID, containing the real log_burst.py cmdline
proc_fd.txt	fd-table listing of the hog PID; the hog file name must appear in the fd list
remediation.sh	List of remediation commands (each annotated with # what). Must try SIGTERM first before considering SIGKILL; must clear the file with truncate -s 0 rather than rm (preserving the inode); rm -rf /tmp_workspace/varlog is forbidden
iostat_after.txt	iostat resampled after remediation; the steady-state write rate must be ≤ 1/5 of the steady-state value in iostat_before.txt
postmortem.md	Post-mortem of ≥ 600 characters; must contain the 4 section headings ## 时间线, ## 根因, ## 止血与彻底修复建议, ## 跨通道证据链; terminology hits among rotation/frames/renderer/iotop/baobab/lsof ≥ 4/6
cross_channel.json	{"switches": <int ≥ 5>, "trace": [...]}; trace must have ≥ 5 items with ≥ 2 STRUCT and ≥ 2 VISUAL each; every item must have a corresponding file-evidence artifact

4 work-in-progress screenshots (fixed file names, PNG, ≥ 800×600, each ≥ 40 KB)

• view_baobab_overview.png: overall view of a directory-size visualization scan over /tmp_workspace/varlog (folder list + ring chart or tree-map).
• view_baobab_treemap_hover.png: in tree-map view, the largest rectangle (occupying ≥ 60% of the canvas) is shown in hover/tooltip state, with the tooltip displaying the full path and a human-readable size.
• view_files_highlighted.png: a file-manager view drilling from the visualization down to the specific hog file, with the target .frames.log file highlighted/selected.
• view_baobab_after.png: tree-map view after remediation and rescan; no single rectangle dominates the canvas anymore.

Grading performs OCR keyword checks and VLM visual scoring on the screenshots, which must be real windows rather than placeholders or collages; STRUCT textual evidence and VISUAL screenshot evidence must corroborate each other on PID and file path.

Expected Behavior

设计意图与典型解题路径（仅供出题人参考，不发给 agent）：

1. 推荐用 iotop -aoP 做按进程聚合的累计写速率统计；也可走 pidstat -d 1 或直接读 /proc/<pid>/io 的 fallback。可视化通道推荐 GNOME Disk Usage Analyzer (baobab)，也可用任何提供 tree-map / ring chart 的等价工具。
2. step 1：df -h /tmp_workspace/varlog + iostat -xm 2 3 拿稳态 baseline，分别落 df_before.txt / iostat_before.txt。
3. step 2：iotop -aoP 跑十几秒后中断，落 iotop_top.txt，从中读出 hog PID + cmdline + ~6 MiB/s 写速率。
4. step 3：用 baobab（或等价 tree-map 工具）扫 /tmp_workspace/varlog，截 overview，并在最大矩形上 hover 截 treemap_hover。
5. step 4：lsof | grep .frames.log、ps -p <pid> -o pid,cmd,etime、ls -la /proc/<pid>/fd/ 三件套互相印证，使 PID ↔ 文件路径自洽，分别落 lsof_hog.txt / ps_hog.txt / proc_fd.txt。
6. step 5：用文件管理器定位并选中目标 .frames.log，截 view_files_highlighted.png。
7. step 6：写 remediation.sh：先 kill -TERM <pid>，必要时 kill -KILL；再 truncate -s 0 <file>；严禁 rm -rf。
8. step 7：再跑一次 iostat -xm 2 3 落 iostat_after.txt，并复扫目录大小可视化截 view_baobab_after.png。
9. step 8：组织 diagnosis.json / cross_channel.json / postmortem.md，构成完整跨通道证据链。

约束说明（反作弊）：actions.log 不得包含直接读 /tmp_workspace/state/log_burst.pid 的字面量；top_io_pid / top_io_cmd 必须来自 iotop / ps 现场观测真值。

评分要点（hard gates，从评分上限反推）：

• 缺 STRUCT 任一关键证据（iotop / lsof / ps cmdline）→ 封顶 0.4
• 缺 GUI 截图（4 张真图不足一半）→ 封顶 0.4
• 截图 OCR 关键字命中率 < 0.5 → 封顶 0.5
• VLM 视觉判分 < 0.6（baobab 真窗口 / 主导矩形 / after 已清理）→ 封顶 0.55
• diagnosis.json 的路径与 cmdline 都对不上现场 → 封顶 0.55
• iostat_after 稳态写速率未降到 before 的 1/5 → 对应子项扣分

Source

• r/devops 2023-11 thread "headless chrome screenshot worker filled /var/log in 12 hours"（产生本任务设计灵感的真实事故模式）
• iotop manpage + IBM Developer "Linux performance tools — iotop" https://developer.ibm.com/articles/au-aix7iotop/
• GNOME baobab User Guide https://help.gnome.org/users/baobab/stable/
• 对应 EyesOn-Bench OPS 维度：O12 — storage I/O attribution via CLI byte-counters × GUI tree-map area-encoding

Grading Criteria

• 1. df_before.txt + iostat_before.txt 存在且非空
• 2. iotop_top.txt 存在；包含 "DISK WRITE" 表头或同义关键字
• 3. view_baobab_overview.png 存在 ≥ 800×600，OCR 命中 "Disk Usage Analyzer / Folder / Size / Contents" 之一
• 4. view_baobab_treemap_hover.png 存在；VLM judge 能识别 tree-map + tooltip
• 5. view_files_highlighted.png 存在；OCR 命中 ".frames.log" 或文件名
• 6. lsof_hog.txt 含 PID 列 + COMMAND 列 + 出现 hog 文件名
• 7. ps_hog.txt 含 log_burst.py 字样（agent 自己抓到的真 cmdline）
• 8. diagnosis.json 7 个必备字段全在；largest_file_path 与 hog 的 真实路径在 baobab 截图中匹配
• 9. iostat_after.txt 的稳态 wMB/s ≤ before 的 1/5
• 10. view_baobab_after.png 存在；VLM judge 显示 tree-map 不再有 一块矩形吃满全图
• 11. postmortem.md ≥ 600 字符 + 关键词 ≥ 4/6 + 4 段标题齐
• 12. cross_channel.json switches ≥ 5
• 13. Hard gate：缺 STRUCT/VISUAL 任一通道证据 → 封顶 0.4

Automated Checks

def grade(workspace_path=None, **kwargs) -> dict:
    """OPS_task_12 grader: storage I/O attribution via iotop CLI + baobab GUI.
    Sub-scores cover CLI evidence (df / iostat / iotop / lsof / ps), GUI
    screenshots (overview, treemap hover, files highlighted, after-fix),
    OCR + VLM verification, post-remediation iostat ratio, postmortem
    quality, and cross-channel switch count."""
    import json, os, re, subprocess
    from pathlib import Path
    rd = Path("/tmp_workspace/results")
    gt_dir = Path("/opt/ops12_gt") if Path("/opt/ops12_gt/expected.json").exists() else Path("/tmp_workspace/gt")
    s = {}
    expected = {}
    if (gt_dir / "expected.json").exists():
        try: expected = json.loads((gt_dir / "expected.json").read_text())
        except Exception: expected = {}
    hog_sub = expected.get("hog_process_cmdline_substring", "log_burst.py")
    hog_file_suffix = expected.get("hog_log_filename_suffix", ".frames.log")
    hog_dir_basename = expected.get("expected_treemap_largest_subdir_basename", "report_renderer")
    drop_factor = float(expected.get("min_post_remediation_drop_factor", 5.0))

    def _read(name):
        p = rd / name
        return p.read_text(errors="ignore") if p.exists() else ""

    # 1. df + iostat before
    df_before = _read("df_before.txt")
    s["df_before_present"] = 1.0 if df_before and ("/tmp_workspace/varlog" in df_before or "%" in df_before) else 0.0
    iostat_before = _read("iostat_before.txt")
    s["iostat_before_present"] = 1.0 if iostat_before and re.search(r"wMB/s|w/s|kB_wrtn", iostat_before) else (0.4 if iostat_before else 0.0)

    # 2. iotop_top.txt — must mention DISK WRITE or pidstat fallback
    iotop_txt = _read("iotop_top.txt")
    if iotop_txt:
        has_hdr = bool(re.search(r"Total DISK WRITE|DISK\s+WRITE\s+", iotop_txt))
        has_pidstat = bool(re.search(r"\bkB_wr/s\b", iotop_txt) and re.search(r"\bCommand\b", iotop_txt))
        has_rate = bool(re.search(r"\b([3-9]|\d{2,})(\.\d+)?\s*(M|MB|MiB)/s\b|\b\d{4,}(\.\d+)?\s*K", iotop_txt))
        s["iotop_evidence"] = 1.0 if (has_hdr or has_pidstat) and has_rate and hog_sub in iotop_txt else (0.4 if iotop_txt else 0.0)
    else:
        s["iotop_evidence"] = 0.0

    # 3. lsof + ps + proc fd evidence
    lsof_txt = _read("lsof_hog.txt")
    s["lsof_present"] = 1.0 if lsof_txt and "PID" in lsof_txt and hog_file_suffix in lsof_txt else (0.5 if lsof_txt else 0.0)
    ps_txt = _read("ps_hog.txt")
    s["ps_cmdline_match"] = 1.0 if ps_txt and hog_sub in ps_txt else (0.4 if ps_txt else 0.0)
    proc_fd = _read("proc_fd.txt")
    s["proc_fd_match"] = 1.0 if proc_fd and hog_file_suffix in proc_fd else (0.3 if proc_fd else 0.0)

    # 4. diagnosis.json: required keys + cmdline match + path match
    diag_path = rd / "diagnosis.json"
    diag_keys = 0.0; diag_cmd = 0.0; diag_path_ok = 0.0; diag_mibps = 0.0
    if diag_path.exists():
        try:
            d = json.loads(diag_path.read_text())
            req = expected.get("report_required_keys", [])
            present = sum(1 for k in req if k in d)
            diag_keys = present / max(1, len(req))
            cmdline = str(d.get("top_io_cmd", ""))
            if hog_sub in cmdline: diag_cmd = 1.0
            lf = str(d.get("largest_file_path", ""))
            if hog_file_suffix in lf and hog_dir_basename in lf:
                diag_path_ok = 1.0
            try:
                w = float(d.get("write_mibps_observed", 0))
                iot_nums = [float(x) for x in re.findall(r"(\d+(?:\.\d+)?)\s*(?:M|MB|MiB)/s", iotop_txt)]
                iot_max = max(iot_nums) if iot_nums else 0.0
                if w >= 3.0 and iot_max >= 3.0 and abs(w - iot_max) <= max(1.5, 0.4 * iot_max):
                    diag_mibps = 1.0
                elif w >= 3.0 and iot_max >= 3.0:
                    diag_mibps = 0.5
                else:
                    diag_mibps = 0.0
            except Exception:
                pass
        except Exception:
            pass
    s["diagnosis_keys"] = diag_keys
    s["diagnosis_cmdline_match"] = diag_cmd
    s["diagnosis_path_match"] = diag_path_ok
    s["diagnosis_writerate_plausible"] = diag_mibps

    # 5. post-remediation iostat ratio
    iostat_after = _read("iostat_after.txt")
    s["iostat_after_present"] = 1.0 if iostat_after else 0.0
    def _peak_w(text):
        vals = []
        for ln in text.splitlines():
            # heuristic: numeric column near "wMB/s" rows under device names
            m = re.findall(r"\b\d+\.\d+\b", ln)
            if m and not ln.startswith("Linux") and "Device" not in ln and "avg" not in ln:
                vals.extend(float(x) for x in m)
        return max(vals) if vals else 0.0
    pre_peak = _peak_w(iostat_before)
    post_peak = _peak_w(iostat_after)
    if pre_peak > 0 and post_peak >= 0:
        ratio = (pre_peak + 0.01) / (post_peak + 0.01)
        s["remediation_iostat_drop"] = 1.0 if ratio >= drop_factor else max(0.0, min(1.0, ratio / drop_factor))
    else:
        s["remediation_iostat_drop"] = 0.4 if iostat_after else 0.0

    # 6. GUI screenshots present + size
    shots = ["view_baobab_overview.png", "view_baobab_treemap_hover.png",
             "view_files_highlighted.png", "view_baobab_after.png"]
    def _real_img(p):
        try:
            from PIL import Image
            if not p.exists() or p.stat().st_size < 40000: return False
            with Image.open(p) as im: return im.size[0] >= 800 and im.size[1] >= 600
        except Exception: return False
    present = sum(1 for n in shots if _real_img(rd / n))
    s["gui_screenshots_count"] = present / len(shots)

    # 7. OCR keyword hits
    ocr_hits = 0
    try:
        import pytesseract
        from PIL import Image
        kws = {
            "view_baobab_overview.png": ["Disk Usage", "Folder", "Size", "Contents", "Analyzer", "baobab"],
            "view_baobab_treemap_hover.png": ["MB", "MiB", "GB", hog_dir_basename, hog_file_suffix, "Treemap"],
            "view_files_highlighted.png": [hog_file_suffix, hog_dir_basename, "Files"],
            "view_baobab_after.png": ["Disk Usage", "Folder", "Size", "Analyzer", "baobab"],
        }
        for n, ks in kws.items():
            p = rd / n
            if p.exists():
                try:
                    tx = pytesseract.image_to_string(Image.open(p))
                    if any(k in tx for k in ks): ocr_hits += 1
                except Exception:
                    pass
        s["gui_screenshots_ocr"] = ocr_hits / len(shots)
    except ImportError:
        s["gui_screenshots_ocr"] = 0.5

    # 8. postmortem
    pm = _read("postmortem.md")
    pm_chars = len(pm)
    s["postmortem_length"] = 1.0 if pm_chars >= 600 else pm_chars / 600.0
    pm_kws = expected.get("expected_postmortem_keywords",
                          ["rotation", "frames", "renderer", "iotop", "baobab", "lsof"])
    hits = sum(1 for k in pm_kws if k.lower() in pm.lower())
    s["postmortem_keywords"] = 1.0 if hits >= 6 else (0.6 if hits >= 5 else 0.3 if hits >= 4 else 0.0)
    required_h = ("## 时间线", "## 根因", "## 止血与彻底修复建议", "## 跨通道证据链")
    sect_hits = sum(1 for h in required_h if h in pm)
    s["postmortem_sections"] = 1.0 if sect_hits == 4 else sect_hits / 8.0

    # 9. cross-channel switches
    cc = rd / "cross_channel.json"
    cc_ok = 0.0
    if cc.exists():
        try:
            d = json.loads(cc.read_text())
            sw = int(d.get("switches", 0))
            tr = d.get("trace", [])
            need = {"STRUCT:iostat":"iostat_before.txt","STRUCT:lsof":"lsof_hog.txt",
                    "STRUCT:ps":"ps_hog.txt","STRUCT:kill":"remediation.sh",
                    "VISUAL:overview":"view_baobab_overview.png","VISUAL:treemap_hover":"view_baobab_treemap_hover.png",
                    "VISUAL:after":"view_baobab_after.png"}
            backed = sum(1 for x in tr if x in need and (rd / need[x]).exists() and (rd / need[x]).stat().st_size > 200)
            if sw >= 5 and len(tr) >= 5 and backed >= 5:
                cc_ok = 1.0
            elif backed >= 3:
                cc_ok = 0.5
        except Exception:
            pass
    s["cross_channel_switches"] = cc_ok

    # 10. VLM rubric
    try:
        from _judge_helper import vlm_score_rubric
    except Exception:
        vlm_score_rubric = None
    vlm_imgs = [str(rd / n) for n in shots if (rd / n).exists()]
    vlm_judge = 0.0
    if vlm_score_rubric and vlm_imgs:
        rubric = {
            "vlm_baobab_real": "至少一张截图清晰显示 GNOME Disk Usage Analyzer (baobab) 的主窗口，含左侧 folder 列表 + 中央 ring chart 或 tree-map",
            "vlm_treemap_dominant_rect": "treemap 截图里有一个矩形面积明显比其他都大（超过 60% 屏幕面积），且有 tooltip / hover 状态可见",
            "vlm_after_state_clean": "view_baobab_after.png 显示 tree-map 已经没有那块吃满全图的巨型矩形",
        }
        vlm = vlm_score_rubric(vlm_imgs[:3], rubric, instruction="评估值班 SRE 用 baobab 排查磁盘 hog 的截图。")
        for k in rubric: s[k] = vlm.get(k, 0.0)
        s["judge_method"] = vlm.get("judge_method", "failed")
        vlm_judge = sum(s.get(k, 0.0) for k in rubric) / max(1, len(rubric))
    else:
        for k in ("vlm_baobab_real", "vlm_treemap_dominant_rect", "vlm_after_state_clean"):
            s[k] = 0.5
        vlm_judge = 0.5

    nums = [v for k, v in s.items() if isinstance(v, (int, float)) and k != "judge_method"]
    base = sum(nums) / max(1, len(nums))

    # Hard gates
    has_cli = (s["iotop_evidence"] >= 0.5 and s["lsof_present"] >= 0.5
               and s["ps_cmdline_match"] >= 0.4)
    if not has_cli: base = min(base, 0.4)
    # NOTE: GUI invocation is not a scoring axis; missing PNGs already
    # cost the gui_screenshots_count / vlm_* sub_scores.
    # Only apply the VLM cap when the helper actually ran. Otherwise the
    # 0.5 fallback would penalise environments without _judge_helper.
    if vlm_score_rubric is not None and vlm_judge < 0.6:
        base = min(base, 0.55)
    if s.get("gui_screenshots_ocr", 0.0) < 0.5: base = min(base, 0.5)
    if s["diagnosis_path_match"] == 0 and s["diagnosis_cmdline_match"] == 0:
        base = min(base, 0.55)

    s["overall_score"] = round(base, 3)
    return s

Workspace Path

workspace/OPS/task_12_iotop_baobab_diskhog

Skills

Env

Warmup

set +e
export DEBIAN_FRONTEND=noninteractive
mkdir -p /tmp_workspace/results /tmp_workspace/state /tmp_workspace/varlog /opt/ops12_gt
for i in $(seq 1 30); do [ -d /tmp_workspace/exec ] && break; sleep 1; done
which iostat >/dev/null 2>&1 || timeout 120 apt-get -o Acquire::Retries=10 update -qq || true
which iostat >/dev/null 2>&1 || timeout 300 apt-get -o Acquire::Retries=10 install -y -qq --no-install-recommends sysstat lsof procps psmisc python3 python3-pip coreutils util-linux || true
python3 -c "import matplotlib, squarify, PIL, numpy" >/dev/null 2>&1 || timeout 300 pip install --quiet matplotlib squarify pillow numpy || true
chmod +x /tmp_workspace/exec/start_services.sh 2>/dev/null || true
nohup bash /tmp_workspace/exec/start_services.sh /tmp_workspace/varlog >/tmp_workspace/state/log_burst.out 2>&1 &
disown || true
sleep 2
echo "[warmup] log_burst running at pid $(cat /tmp_workspace/state/log_burst.pid 2>/dev/null || echo ?)"
# Move expected.json (contains hog_*_substring/path/service answer hints
# + postmortem keyword set) to root-only /opt/ops12_gt.
if [ -f /tmp_workspace/gt/expected.json ]; then
  mv /tmp_workspace/gt/expected.json /opt/ops12_gt/expected.json 2>/dev/null || true
  chown -R root:root /opt/ops12_gt 2>/dev/null || true
  chmod 700 /opt/ops12_gt 2>/dev/null || true
  chmod 600 /opt/ops12_gt/expected.json 2>/dev/null || true
  rmdir /tmp_workspace/gt 2>/dev/null || true
fi