Gestion de le mémoire utilisée par un processus

Commenter

Contenu du snippet

Ce code permet d'observer l'utilisation de la mémoire par un processus et de fixer une limite sur celle-ci. Si la limité est dépassé, le processus est terminé.

Have fun.

lilxam.

Source / Exemple : 


#include <iostream>
#include <cstdio>
#include <windows.h>
#include <tlhelp32.h>
#include <psapi.h>

using namespace std;

int fileExist(const char* fileName)
{
    return (0 <= (INT_PTR)GetFileAttributesA(fileName));
}

void SetDebugPrivilege(){
TOKEN_PRIVILEGES privilege;
LUID Luid;
HANDLE handle1;
HANDLE handle2;
handle1 = OpenProcess(PROCESS_ALL_ACCESS, FALSE, GetCurrentProcessId());
OpenProcessToken(handle1, TOKEN_ALL_ACCESS, &handle2);
LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &Luid);
privilege.PrivilegeCount = 1;
privilege.Privileges[0].Luid = Luid;
privilege.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
AdjustTokenPrivileges(handle2, FALSE, &privilege, sizeof(privilege), NULL, NULL);
CloseHandle(handle2);
CloseHandle(handle1);
}
 
int main(int argc, char *argv[])
{
    
    char ProcessName[20];
    cout<<"\nProcess : "; //On récupère le nom du processus
    cin>>ProcessName;
    
    int limit = 0;
    cout << "\nBytes limit :"; //On récupère la limite en bytes de l'utilisation de la mémoire
    cin >> limit; 
    
    HANDLE hSnapShot; //Handle de la liste de processus
    PROCESSENTRY32 uProcess;
    
    SetDebugPrivilege();
                                      
    hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); //On créé une liste des processus
    uProcess.dwSize = (DWORD) sizeof(PROCESSENTRY32);
    
    int p;
    short PID = 0;
    
    p = Process32First(hSnapShot, &uProcess); //On se positionne sur le premier processus
    
    do
    {
        if(strstr(uProcess.szExeFile, ProcessName)) //On recherche le nom de notre processus dans la liste
        {
                                      FILE * fichier; //On place les informations dans un fichier log
                                      char FileName[30] = "";
                                      strcat(FileName, uProcess.szExeFile);
                                      strcat(FileName, ".log");
                                      if(fileExist(FileName))//Si il existe déjà un fichier log pour le meme processus on le supprime
                                      {
                                                            DeleteFile(FileName);
                                      }
                                      fichier = fopen(FileName, "a+");
                                      fprintf(fichier, "**************Looking at %s *************\n", uProcess.szExeFile);
                                      
                                      cout<<"\n\nProcess found : "<<uProcess.szExeFile<<"\n";
                                      
                                      PID = (short) uProcess.th32ProcessID; //On récupere le PID de notre processus
                                      
                                      HANDLE hTemp; //Handle du processus
                                      PROCESS_MEMORY_COUNTERS pmc;
                                      

                                      hTemp = OpenProcess(PROCESS_QUERY_INFORMATION|PROCESS_ALL_ACCESS, 0, (DWORD) PID);//On accede au processus en récupérant les informations le concernant et en gardant tout accès dessus
                                      
                                      
                                      system("pause");
                                      system("cls");
                                      while(GetProcessMemoryInfo(hTemp, &pmc, sizeof(pmc)))//On récupere des informations sur l'utilisation de la mémoire pas notre processus
                                      {
                                             long work = pmc.WorkingSetSize / 1024;
                                             fprintf(fichier , "\nProcessus using %ld bytes ", work);
                                             cout<<"Process "<<uProcess.szExeFile<<" is using "<<work<<" bytes";
                                             Sleep(1000);                                            
                                             
                                             if(work > limit) //Si le processus utilise plus de mémoire que la limite on le termine
                                             {
         
                                                     TerminateProcess(hTemp, 0);
                                                     cout<<"\nProcess Killed\n";
                                                     goto s;
                                             }
                                             system("cls");
                                             
                                      }
        }
        
        p = Process32Next(hSnapShot, &uProcess);//On se positionne sur le processus suivant
    }while(p);

    
    s:
      system("pause");
      return 0; 
}

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (cs_lilxam)