add a process picker for attaching by PID

Author: matthewbastien

lldb/tools/lldb-dap/package.json

@@ -146,6 +146,9 @@
         "windows": {
           "program": "./bin/lldb-dap.exe"
         },
+        "variables": {
+          "PickProcess": "lldb-dap.pickProcess"
+        },
         "configurationAttributes": {
           "launch": {
             "required": [
@@ -517,6 +520,16 @@
               "cwd": "^\"\\${workspaceRoot}\""
             }
           },
+          {
+            "label": "LLDB: Attach to Process",
+            "description": "",
+            "body": {
+              "type": "lldb-dap",
+              "request": "attach",
+              "name": "${1:Attach}",
+              "pid": "^\"\\${command:PickProcess}\""
+            }
+          },
           {
             "label": "LLDB: Attach",
             "description": "",
@@ -541,6 +554,21 @@
           }
         ]
       }
-    ]
+    ],
+    "commands": [
+      {
+        "command": "lldb-dap.pickProcess",
+        "title": "Pick Process",
+        "category": "LLDB DAP"
+      }
+    ],
+    "menus": {
+      "commandPalette": [
+        {
+          "command": "lldb-dap.pickProcess",
+          "when": "false"
+        }
+      ]
+    }
   }
 }

lldb/tools/lldb-dap/src-ts/commands/pick-process.ts

@@ -0,0 +1,37 @@
+import * as path from "path";
+import * as vscode from "vscode";
+import { createProcessTree } from "../process-tree";
+
+interface ProcessQuickPick extends vscode.QuickPickItem {
+  processId: number;
+}
+
+/**
+ * Prompts the user to select a running process.
+ *
+ * @returns The pid of the process as a string or undefined if cancelled.
+ */
+export async function pickProcess(): Promise<string | undefined> {
+  const processTree = createProcessTree();
+  const selectedProcess = await vscode.window.showQuickPick<ProcessQuickPick>(
+    processTree.listAllProcesses().then((processes): ProcessQuickPick[] => {
+      return processes
+        .sort((a, b) => b.start - a.start) // Sort by start date in descending order
+        .map((proc) => {
+          return {
+            processId: proc.id,
+            label: path.basename(proc.command),
+            description: proc.id.toString(),
+            detail: proc.arguments,
+          } satisfies ProcessQuickPick;
+        });
+    }),
+    {
+      placeHolder: "Select a process to attach the debugger to",
+    },
+  );
+  if (!selectedProcess) {
+    return;
+  }
+  return selectedProcess.processId.toString();
+}

lldb/tools/lldb-dap/src-ts/extension.ts

@@ -1,7 +1,6 @@
-import * as path from "path";
-import * as util from "util";
 import * as vscode from "vscode";
 
+import { pickProcess } from "./commands/pick-process";
 import {
   LLDBDapDescriptorFactory,
   isExecutable,
@@ -38,6 +37,10 @@ export class LLDBDapExtension extends DisposableContext {
         }
       }),
     );
+
+    this.pushSubscription(
+      vscode.commands.registerCommand("lldb-dap.pickProcess", pickProcess),
+    );
   }
 }
 

lldb/tools/lldb-dap/src-ts/process-tree/base-process-tree.ts

@@ -0,0 +1,102 @@
+import { ChildProcessWithoutNullStreams } from "child_process";
+import { Process, ProcessTree } from ".";
+import { Transform } from "stream";
+
+/** Parses process information from a given line of process output. */
+export type ProcessTreeParser = (line: string) => Process | undefined;
+
+/**
+ * Implements common behavior between the different {@link ProcessTree} implementations.
+ */
+export abstract class BaseProcessTree implements ProcessTree {
+  /**
+   * Spawn the process responsible for collecting all processes on the system.
+   */
+  protected abstract spawnProcess(): ChildProcessWithoutNullStreams;
+
+  /**
+   * Create a new parser that can read the process information from stdout of the process
+   * spawned by {@link spawnProcess spawnProcess()}.
+   */
+  protected abstract createParser(): ProcessTreeParser;
+
+  listAllProcesses(): Promise<Process[]> {
+    return new Promise<Process[]>((resolve, reject) => {
+      const proc = this.spawnProcess();
+      const parser = this.createParser();
+
+      // Capture processes from stdout
+      const processes: Process[] = [];
+      proc.stdout.pipe(new LineBasedStream()).on("data", (line) => {
+        const process = parser(line.toString());
+        if (process && process.id !== proc.pid) {
+          processes.push(process);
+        }
+      });
+
+      // Resolve or reject the promise based on exit code/signal/error
+      proc.on("error", reject);
+      proc.on("exit", (code, signal) => {
+        if (code === 0) {
+          resolve(processes);
+        } else if (signal) {
+          reject(
+            new Error(
+              `Unable to list processes: process exited due to signal ${signal}`,
+            ),
+          );
+        } else {
+          reject(
+            new Error(
+              `Unable to list processes: process exited with code ${code}`,
+            ),
+          );
+        }
+      });
+    });
+  }
+}
+
+/**
+ * A stream that emits each line as a single chunk of data. The end of a line is denoted
+ * by the newline character '\n'.
+ */
+export class LineBasedStream extends Transform {
+  private readonly newline: number = "\n".charCodeAt(0);
+  private buffer: Buffer = Buffer.alloc(0);
+
+  override _transform(
+    chunk: Buffer,
+    _encoding: string,
+    callback: () => void,
+  ): void {
+    let currentIndex = 0;
+    while (currentIndex < chunk.length) {
+      const newlineIndex = chunk.indexOf(this.newline, currentIndex);
+      if (newlineIndex === -1) {
+        this.buffer = Buffer.concat([
+          this.buffer,
+          chunk.subarray(currentIndex),
+        ]);
+        break;
+      }
+
+      const newlineChunk = chunk.subarray(currentIndex, newlineIndex);
+      const line = Buffer.concat([this.buffer, newlineChunk]);
+      this.push(line);
+      this.buffer = Buffer.alloc(0);
+
+      currentIndex = newlineIndex + 1;
+    }
+
+    callback();
+  }
+
+  override _flush(callback: () => void): void {
+    if (this.buffer.length) {
+      this.push(this.buffer);
+    }
+
+    callback();
+  }
+}

lldb/tools/lldb-dap/src-ts/process-tree/index.ts

@@ -0,0 +1,36 @@
+import { DarwinProcessTree } from "./platforms/darwin-process-tree";
+import { LinuxProcessTree } from "./platforms/linux-process-tree";
+import { WindowsProcessTree } from "./platforms/windows-process-tree";
+
+/**
+ * Represents a single process running on the system.
+ */
+export interface Process {
+  /** Process ID */
+  id: number;
+
+  /** Command that was used to start the process */
+  command: string;
+
+  /** The full command including arguments that was used to start the process */
+  arguments: string;
+
+  /** The date when the process was started */
+  start: number;
+}
+
+export interface ProcessTree {
+  listAllProcesses(): Promise<Process[]>;
+}
+
+/** Returns a {@link ProcessTree} based on the current platform. */
+export function createProcessTree(): ProcessTree {
+  switch (process.platform) {
+    case "darwin":
+      return new DarwinProcessTree();
+    case "win32":
+      return new WindowsProcessTree();
+    default:
+      return new LinuxProcessTree();
+  }
+}

lldb/tools/lldb-dap/src-ts/process-tree/platforms/darwin-process-tree.ts

@@ -0,0 +1,16 @@
+import { ChildProcessWithoutNullStreams, spawn } from "child_process";
+import { LinuxProcessTree } from "./linux-process-tree";
+
+function fill(prefix: string, suffix: string, length: number): string {
+  return prefix + suffix.repeat(length - prefix.length);
+}
+
+export class DarwinProcessTree extends LinuxProcessTree {
+  protected override spawnProcess(): ChildProcessWithoutNullStreams {
+    return spawn("ps", [
+      "-xo",
+      // The length of comm must be large enough or data will be truncated.
+      `pid=PID,lstart=START,comm=${fill("COMMAND", "-", 256)},command=ARGUMENTS`,
+    ]);
+  }
+}

lldb/tools/lldb-dap/src-ts/process-tree/platforms/linux-process-tree.ts

@@ -0,0 +1,38 @@
+import { ChildProcessWithoutNullStreams, spawn } from "child_process";
+import { BaseProcessTree, ProcessTreeParser } from "../base-process-tree";
+
+export class LinuxProcessTree extends BaseProcessTree {
+  protected override spawnProcess(): ChildProcessWithoutNullStreams {
+    return spawn(
+      "ps",
+      ["-axo", `pid=PID,lstart=START,comm:128=COMMAND,command=ARGUMENTS`],
+      {
+        stdio: "pipe",
+      },
+    );
+  }
+
+  protected override createParser(): ProcessTreeParser {
+    let commandOffset: number | undefined;
+    let argumentsOffset: number | undefined;
+    return (line) => {
+      if (!commandOffset || !argumentsOffset) {
+        commandOffset = line.indexOf("COMMAND");
+        argumentsOffset = line.indexOf("ARGUMENTS");
+        return;
+      }
+
+      const pid = /^\s*([0-9]+)\s*/.exec(line);
+      if (!pid) {
+        return;
+      }
+
+      return {
+        id: Number(pid[1]),
+        command: line.slice(commandOffset, argumentsOffset).trim(),
+        arguments: line.slice(argumentsOffset).trim(),
+        start: Date.parse(line.slice(pid[0].length, commandOffset).trim()),
+      };
+    };
+  }
+}

lldb/tools/lldb-dap/src-ts/process-tree/platforms/windows-process-tree.ts

@@ -0,0 +1,52 @@
+import * as path from "path";
+import { BaseProcessTree, ProcessTreeParser } from "../base-process-tree";
+import { ChildProcessWithoutNullStreams, spawn } from "child_process";
+
+export class WindowsProcessTree extends BaseProcessTree {
+  protected override spawnProcess(): ChildProcessWithoutNullStreams {
+    const wmic = path.join(
+      process.env["WINDIR"] || "C:\\Windows",
+      "System32",
+      "wbem",
+      "WMIC.exe",
+    );
+    return spawn(
+      wmic,
+      ["process", "get", "CommandLine,CreationDate,ProcessId"],
+      { stdio: "pipe" },
+    );
+  }
+
+  protected override createParser(): ProcessTreeParser {
+    const lineRegex = /^(.*)\s+([0-9]+)\.[0-9]+[+-][0-9]+\s+([0-9]+)$/;
+
+    return (line) => {
+      const matches = lineRegex.exec(line.trim());
+      if (!matches || matches.length !== 4) {
+        return;
+      }
+
+      const id = Number(matches[3]);
+      const start = Number(matches[2]);
+      let fullCommandLine = matches[1].trim();
+      if (isNaN(id) || !fullCommandLine) {
+        return;
+      }
+      // Extract the command from the full command line
+      let command = fullCommandLine;
+      if (fullCommandLine[0] === '"') {
+        const end = fullCommandLine.indexOf('"', 1);
+        if (end > 0) {
+          command = fullCommandLine.slice(1, end - 1);
+        }
+      } else {
+        const end = fullCommandLine.indexOf(" ");
+        if (end > 0) {
+          command = fullCommandLine.slice(0, end);
+        }
+      }
+
+      return { id, command, arguments: fullCommandLine, start };
+    };
+  }
+}