[lldb-dap] Add process picker command to VS Code extension

lldb/tools/lldb-dap/README.md

@@ -65,6 +65,18 @@ This will attach to a process `a.out` whose process ID is 123:
 }
 ```
 
+You can also use the variable substituion `${command:pickProcess}` to select a
+process at the start of the debug session instead of setting the pid manually:
+
+```javascript
+{
+  "type": "lldb-dap",
+  "request": "attach",
+  "name": "Attach to PID",
+  "pid": "${command:pickProcess}"
+}
+```
+
 #### Attach by Name
 
 This will attach to an existing process whose base
@@ -224,7 +236,7 @@ the following `lldb-dap` specific key/value pairs:
 | Parameter                         | Type        | Req |         |
 |-----------------------------------|-------------|:---:|---------|
 | **program**                       | string      |     | Path to the executable to attach to. This value is optional but can help to resolve breakpoints prior the attaching to the program.
-| **pid**                           | number      |     | The process id of the process you wish to attach to. If **pid** is omitted, the debugger will attempt to attach to the program by finding a process whose file name matches the file name from **porgram**. Setting this value to `${command:pickMyProcess}` will allow interactive process selection in the IDE.
+| **pid**                           | number      |     | The process id of the process you wish to attach to. If **pid** is omitted, the debugger will attempt to attach to the program by finding a process whose file name matches the file name from **program**. Setting this value to `${command:pickProcess}` will allow interactive process selection in the IDE.
 | **waitFor**                       | boolean     |     | Wait for the process to launch.
 | **attachCommands**                | [string]    |     | LLDB commands that will be executed after **preRunCommands** which take place of the code that normally does the attach. The commands can create a new target and attach or launch it however desired. This allows custom launch and attach configurations. Core files can use `target create --core /path/to/core` to attach to core files.
 

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,26 @@
           }
         ]
       }
-    ]
+    ],
+    "commands": [
+      {
+        "command": "lldb-dap.attachToProcess",
+        "title": "Attach to Process...",
+        "category": "LLDB DAP"
+      },
+      {
+        "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/attach-to-process.ts

@@ -0,0 +1,10 @@
+import * as vscode from "vscode";
+
+export async function attachToProcess(): Promise<boolean> {
+  return await vscode.debug.startDebugging(undefined, {
+    type: "lldb-dap",
+    request: "attach",
+    name: "Attach to Process",
+    pid: "${command:pickProcess}",
+  });
+}

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

@@ -0,0 +1,57 @@
+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.
+ *
+ * The return value must be a string so that it is compatible with VS Code's
+ * string substitution infrastructure. The value will eventually be converted
+ * to a number by the debug configuration provider.
+ *
+ * @param configuration The related debug configuration, if any
+ * @returns The pid of the process as a string or undefined if cancelled.
+ */
+export async function pickProcess(
+  configuration?: vscode.DebugConfiguration,
+): Promise<string | undefined> {
+  const processTree = createProcessTree();
+  const selectedProcess = await vscode.window.showQuickPick<ProcessQuickPick>(
+    processTree.listAllProcesses().then((processes): ProcessQuickPick[] => {
+      // Sort by start date in descending order
+      processes.sort((a, b) => b.start - a.start);
+      // Filter by program if requested
+      if (typeof configuration?.program === "string") {
+        processes = processes.filter(
+          (proc) => proc.command === configuration.program,
+        );
+        // Show a better message if all processes were filtered out
+        if (processes.length === 0) {
+          return [
+            {
+              label: "No processes matched the debug configuration's program",
+            },
+          ];
+        }
+      }
+      // Convert to a QuickPickItem
+      return processes.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",
+      matchOnDetail: true,
+    },
+  );
+  return selectedProcess?.processId?.toString();
+}

lldb/tools/lldb-dap/src-ts/debug-configuration-provider.ts

@@ -0,0 +1,54 @@
+import * as vscode from "vscode";
+
+/**
+ * Converts the given value to an integer if it isn't already.
+ *
+ * If the value cannot be converted then this function will return undefined.
+ *
+ * @param value the value to to be converted
+ * @returns the integer value or undefined if unable to convert
+ */
+function convertToInteger(value: any): number | undefined {
+  let result: number | undefined;
+  switch (typeof value) {
+    case "number":
+      result = value;
+      break;
+    case "string":
+      result = Number(value);
+      break;
+    default:
+      return undefined;
+  }
+  if (!Number.isInteger(result)) {
+    return undefined;
+  }
+  return result;
+}
+
+/**
+ * A {@link vscode.DebugConfigurationProvider} used to resolve LLDB DAP debug configurations.
+ *
+ * Performs checks on the debug configuration before launching a debug session.
+ */
+export class LLDBDapConfigurationProvider
+  implements vscode.DebugConfigurationProvider
+{
+  resolveDebugConfigurationWithSubstitutedVariables(
+    _folder: vscode.WorkspaceFolder | undefined,
+    debugConfiguration: vscode.DebugConfiguration,
+  ): vscode.ProviderResult<vscode.DebugConfiguration> {
+    // Convert the "pid" option to a number if it is a string
+    if ("pid" in debugConfiguration) {
+      const pid = convertToInteger(debugConfiguration.pid);
+      if (pid === undefined) {
+        vscode.window.showErrorMessage(
+          "Invalid debug configuration: property 'pid' must either be an integer or a string containing an integer value.",
+        );
+        return null;
+      }
+      debugConfiguration.pid = pid;
+    }
+    return debugConfiguration;
+  }
+}

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

@@ -1,12 +1,13 @@
-import * as path from "path";
-import * as util from "util";
 import * as vscode from "vscode";
 
+import { pickProcess } from "./commands/pick-process";
 import {
   LLDBDapDescriptorFactory,
   isExecutable,
 } from "./debug-adapter-factory";
 import { DisposableContext } from "./disposable-context";
+import { LLDBDapConfigurationProvider } from "./debug-configuration-provider";
+import { attachToProcess } from "./commands/attach-to-process";
 
 /**
  * This class represents the extension and manages its life cycle. Other extensions
@@ -15,6 +16,12 @@ import { DisposableContext } from "./disposable-context";
 export class LLDBDapExtension extends DisposableContext {
   constructor() {
     super();
+    this.pushSubscription(
+      vscode.debug.registerDebugConfigurationProvider(
+        "lldb-dap",
+        new LLDBDapConfigurationProvider(),
+      ),
+    );
     this.pushSubscription(
       vscode.debug.registerDebugAdapterDescriptorFactory(
         "lldb-dap",
@@ -38,6 +45,16 @@ export class LLDBDapExtension extends DisposableContext {
         }
       }),
     );
+
+    this.pushSubscription(
+      vscode.commands.registerCommand("lldb-dap.pickProcess", pickProcess),
+    );
+    this.pushSubscription(
+      vscode.commands.registerCommand(
+        "lldb-dap.attachToProcess",
+        attachToProcess,
+      ),
+    );
   }
 }
 

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

@@ -0,0 +1,41 @@
+import * as util from "util";
+import * as child_process from "child_process";
+import { Process, ProcessTree } from ".";
+
+const exec = util.promisify(child_process.execFile);
+
+/** 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 {
+  /**
+   * Get the command responsible for collecting all processes on the system.
+   */
+  protected abstract getCommand(): string;
+
+  /**
+   * Get the list of arguments used to launch the command.
+   */
+  protected abstract getCommandArguments(): string[];
+
+  /**
+   * Create a new parser that can read the process information from stdout of the process
+   * spawned by {@link spawnProcess spawnProcess()}.
+   */
+  protected abstract createParser(): ProcessTreeParser;
+
+  async listAllProcesses(): Promise<Process[]> {
+    const execCommand = exec(this.getCommand(), this.getCommandArguments());
+    const parser = this.createParser();
+    return (await execCommand).stdout.split("\n").flatMap((line) => {
+      const process = parser(line.toString());
+      if (!process || process.id === execCommand.child.pid) {
+        return [];
+      }
+      return [process];
+    });
+  }
+}

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,11 @@
+import { LinuxProcessTree } from "./linux-process-tree";
+
+export class DarwinProcessTree extends LinuxProcessTree {
+  protected override getCommandArguments(): string[] {
+    return [
+      "-axo",
+      // The length of comm must be large enough or data will be truncated.
+      `pid=PID,lstart=START,comm=${"COMMAND".padEnd(256, "-")},args=ARGUMENTS`,
+    ];
+  }
+}

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

@@ -0,0 +1,44 @@
+import { BaseProcessTree, ProcessTreeParser } from "../base-process-tree";
+
+export class LinuxProcessTree extends BaseProcessTree {
+  protected override getCommand(): string {
+    return "ps";
+  }
+
+  protected override getCommandArguments(): string[] {
+    return [
+      "-axo",
+      // The length of exe must be large enough or data will be truncated.
+      `pid=PID,lstart=START,exe:128=COMMAND,args=ARGUMENTS`,
+    ];
+  }
+
+  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;
+      }
+
+      const command = line.slice(commandOffset, argumentsOffset).trim();
+      if (command === "-") {
+        return;
+      }
+
+      return {
+        id: Number(pid[1]),
+        command,
+        arguments: line.slice(argumentsOffset).trim(),
+        start: Date.parse(line.slice(pid[0].length, commandOffset).trim()),
+      };
+    };
+  }
+}