Sospende/riprendi i processi come PsSuspend fa

Question

Spero che questo post non sia un duplicato. Lasciatemi spiegare:

Ho considerato il post simile How to pause/resume any external process under Windows? ma con preferenza C++/Python e tuttavia senza una risposta accettata al momento della pubblicazione.

---

La mia domanda:

Sono interessato a una possibile implementazione a Delfi delle funzionalità fornite da PsSuspend da Mark Russinovich di Windows Sysinternals.

Citazioni:

PsSuspend consente di sospendere i processi sul locale o un sistema remoto, che è desiderabile nei casi in cui un processo sta consumando una risorsa (ad esempio rete, CPU o del disco) che si desidera per consentire l'utilizzo di diversi processi . Piuttosto che uccidere il processo che sta consumando la risorsa, la sospensione di consente di lasciarlo continuare l'operazione in un secondo momento successivo a .

Grazie.

---

Edit:

Un attuazione parziale farà. Le funzionalità remote possono essere eliminate.

Answer 1

Si può provare a utilizzare il seguente codice. Utilizza le funzioni non documentate NtSuspendProcess e NtResumeProcess. L'ho provato su Windows 7 a 64 bit dall'applicazione a 32 bit di Delphi 2009 e funziona per me. Si noti che queste funzioni non documentate possono quindi essere rimosse dalle versioni future di Windows.

Aggiornamento

I SuspendProcess e ResumeProcess involucri dal seguente codice sono ora funzioni e restituisce true se riesce, False altrimenti.

type 
    NTSTATUS = LongInt; 
    TProcFunction = function(ProcHandle: THandle): NTSTATUS; stdcall; 

const 
    STATUS_SUCCESS = $00000000; 
    PROCESS_SUSPEND_RESUME = $0800; 

function SuspendProcess(const PID: DWORD): Boolean; 
var 
    LibHandle: THandle; 
    ProcHandle: THandle; 
    NtSuspendProcess: TProcFunction; 
begin 
    Result := False; 
    LibHandle := SafeLoadLibrary('ntdll.dll'); 
    if LibHandle <> 0 then 
    try 
    @NtSuspendProcess := GetProcAddress(LibHandle, 'NtSuspendProcess'); 
    if @NtSuspendProcess <> nil then 
    begin 
     ProcHandle := OpenProcess(PROCESS_SUSPEND_RESUME, False, PID); 
     if ProcHandle <> 0 then 
     try 
     Result := NtSuspendProcess(ProcHandle) = STATUS_SUCCESS; 
     finally 
     CloseHandle(ProcHandle); 
     end; 
    end; 
    finally 
    FreeLibrary(LibHandle); 
    end; 
end; 

function ResumeProcess(const PID: DWORD): Boolean; 
var 
    LibHandle: THandle; 
    ProcHandle: THandle; 
    NtResumeProcess: TProcFunction; 
begin 
    Result := False; 
    LibHandle := SafeLoadLibrary('ntdll.dll'); 
    if LibHandle <> 0 then 
    try 
    @NtResumeProcess := GetProcAddress(LibHandle, 'NtResumeProcess'); 
    if @NtResumeProcess <> nil then 
    begin 
     ProcHandle := OpenProcess(PROCESS_SUSPEND_RESUME, False, PID); 
     if ProcHandle <> 0 then 
     try 
     Result := NtResumeProcess(ProcHandle) = STATUS_SUCCESS; 
     finally 
     CloseHandle(ProcHandle); 
     end; 
    end; 
    finally 
    FreeLibrary(LibHandle); 
    end; 
end; 

Answer 2

Non esiste una chiamata API SuspendProcess in Windows. Quindi, quello che devi fare è:

1. Enumerare tutti i thread nel processo. Vedi RRUZ's answer per il codice di esempio.
2. Chiamare SuspendThread per ciascuna di queste discussioni.
3. Per implementare la parte di ripresa del programma, chiamare ResumeThread per ogni thread.

Answer 3

Ho appena trovato il seguente snippet here (Autore: steve10120).

Penso che siano oggetti di valore e non posso fare a meno di postarli anche come risposta alternativa alla mia domanda.

---

Riprendi processo:

function ResumeProcess(ProcessID: DWORD): Boolean; 
var 
    Snapshot,cThr: DWORD; 
    ThrHandle: THandle; 
    Thread:TThreadEntry32; 
begin 
    Result := False; 
    cThr := GetCurrentThreadId; 
    Snapshot := CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0); 
    if Snapshot <> INVALID_HANDLE_VALUE then 
    begin 
    Thread.dwSize := SizeOf(TThreadEntry32); 
    if Thread32First(Snapshot, Thread) then 
     repeat 
     if (Thread.th32ThreadID <> cThr) and (Thread.th32OwnerProcessID = ProcessID) then 
     begin 
     ThrHandle := OpenThread(THREAD_ALL_ACCESS, false, Thread.th32ThreadID); 
     if ThrHandle = 0 then Exit; 
     ResumeThread(ThrHandle); 
     CloseHandle(ThrHandle); 
     end; 
     until not Thread32Next(Snapshot, Thread); 
     Result := CloseHandle(Snapshot); 
    end; 
end; 

---

Sospendere processo:

function SuspendProcess(PID:DWORD):Boolean; 
var 
hSnap: THandle; 
THR32: THREADENTRY32; 
hOpen: THandle; 
begin 
    Result := FALSE; 
    hSnap := CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0); 
    if hSnap <> INVALID_HANDLE_VALUE then 
    begin 
    THR32.dwSize := SizeOf(THR32); 
    Thread32First(hSnap, THR32); 
    repeat 
     if THR32.th32OwnerProcessID = PID then 
     begin 
     hOpen := OpenThread($0002, FALSE, THR32.th32ThreadID); 
     if hOpen <> INVALID_HANDLE_VALUE then 
     begin 
      Result := TRUE; 
      SuspendThread(hOpen); 
      CloseHandle(hOpen); 
     end; 
     end; 
    until Thread32Next(hSnap, THR32) = FALSE; 
    CloseHandle(hSnap); 
    end; 
end; 

---

Disclaimer:

Non li ho testati affatto. Si prega di godere e non dimenticare di feedback.

Answer 4

Esiste una condizione di competizione per l'implementazione "sospendi tutti i thread": cosa accade se il programma che si sta tentando di sospendere crea uno o più thread tra il momento in cui si crea lo snapshot e il momento in cui si completa la sospensione?

È possibile eseguire il loop, ottenere un'altra istantanea e sospendere eventuali thread non sospesi, uscendo solo quando non ne è stato trovato nessuno.

La funzione non documentata evita questo problema.