GNU/Linux >> LINUX-Kenntnisse >  >> Linux

Linux-API zum Auflisten laufender Prozesse?

http://procps.sourceforge.net/

http://procps.cvs.sourceforge.net/viewvc/procps/procps/proc/readproc.c?view=markup

Ist die Quelle von ps und anderen Prozesswerkzeugen. Sie verwenden tatsächlich proc (was darauf hinweist, dass dies wahrscheinlich der herkömmliche und beste Weg ist). Ihre Quelle ist durchaus lesbar. Die Datei

/procps-3.2.8/proc/readproc.c

Könnte nützlich sein. Auch ein nützlicher Vorschlag als posted by ephemient verlinkt auf die von libproc bereitgestellte API , die in Ihrem Repo verfügbar sein sollte (oder bereits installiert, würde ich sagen), aber Sie benötigen die "-dev"-Variante für die Header und was nicht.

Viel Glück


Wenn Sie nicht von '/proc. Dann können Sie erwägen, ein Kernel-Modul zu schreiben, das Ihren eigenen Systemaufruf implementiert. Und Ihr Systemaufruf sollte so geschrieben sein, dass er die Liste der aktuellen Prozesse erhalten kann, wie zum Beispiel:

/* ProcessList.c 
    Robert Love Chapter 3
    */
    #include < linux/kernel.h >
    #include < linux/sched.h >
    #include < linux/module.h >

    int init_module(void) {
        struct task_struct *task;
        for_each_process(task) {
              printk("%s [%d]\n",task->comm , task->pid);
        }
        return 0;
    }
   
    void cleanup_module(void) {
        printk(KERN_INFO "Cleaning Up.\n");
    }

Der obige Code stammt aus meinem Artikel hier unter http://linuxgazette.net/133/saha.html.Sobald Sie Ihren eigenen Systemaufruf haben, können Sie ihn von Ihrem Benutzerprogramm aufrufen.


Bitte schön (C/C++):

Sie könnten es hier gefunden haben:http://ubuntuforums.org/showthread.php?t=657097

Im Wesentlichen durchläuft es alle numerischen Ordner in /proc/<pid> , und dann macht es einen readlink auf /proc/<pid>/exe , oder wenn Sie die Befehlszeilenargumente cat /proc/<pid>/cmdline möchten

Die vom Prozess geöffneten Dateideskriptoren befinden sich in /proc/<pid>/fd/<descriptor> , und Sie erhalten den Dateinamen, indem Sie auf jedem Symlink einen Readlink ausführen, z. readlink /proc/<pid>/fd/<descriptor> . fd kann ein Gerät wie /dev/null, ein Socket oder eine Datei und möglicherweise mehr sein.

#include

ssize_t readlink(const char *path, char *buf, size_t bufsiz);
Bei Erfolg gibt readlink() die Anzahl der in buf platzierten Bytes zurück.
Bei einem Fehler wird -1 zurückgegeben und errno wird gesetzt, um den Fehler anzuzeigen.

Das ist übrigens dasselbe wie readproc.c tut (oder tat es zumindest).
Hoffentlich haben sie es natürlich ohne Pufferüberlauf geschafft.

#ifndef __cplusplus
    #define _GNU_SOURCE
#endif

#include <unistd.h>
#include <dirent.h>
#include <sys/types.h> // for opendir(), readdir(), closedir()
#include <sys/stat.h> // for stat()

#ifdef __cplusplus
    #include <iostream>
    #include <cstdlib>
    #include <cstring>
    #include <cstdarg>
#else
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <stdarg.h>
#endif


#define PROC_DIRECTORY "/proc/"
#define CASE_SENSITIVE    1
#define CASE_INSENSITIVE  0
#define EXACT_MATCH       1
#define INEXACT_MATCH     0


int IsNumeric(const char* ccharptr_CharacterList)
{
    for ( ; *ccharptr_CharacterList; ccharptr_CharacterList++)
        if (*ccharptr_CharacterList < '0' || *ccharptr_CharacterList > '9')
            return 0; // false
    return 1; // true
}


int strcmp_Wrapper(const char *s1, const char *s2, int intCaseSensitive)
{
    if (intCaseSensitive)
        return !strcmp(s1, s2);
    else
        return !strcasecmp(s1, s2);
}

int strstr_Wrapper(const char* haystack, const char* needle, int intCaseSensitive)
{
    if (intCaseSensitive)
        return (int) strstr(haystack, needle);
    else
        return (int) strcasestr(haystack, needle);
}


#ifdef __cplusplus
pid_t GetPIDbyName(const char* cchrptr_ProcessName, int intCaseSensitiveness, int intExactMatch)
#else
pid_t GetPIDbyName_implements(const char* cchrptr_ProcessName, int intCaseSensitiveness, int intExactMatch)
#endif
{
    char chrarry_CommandLinePath[100]  ;
    char chrarry_NameOfProcess[300]  ;
    char* chrptr_StringToCompare = NULL ;
    pid_t pid_ProcessIdentifier = (pid_t) -1 ;
    struct dirent* de_DirEntity = NULL ;
    DIR* dir_proc = NULL ;

    int (*CompareFunction) (const char*, const char*, int) ;

    if (intExactMatch)
        CompareFunction = &strcmp_Wrapper;
    else
        CompareFunction = &strstr_Wrapper;


    dir_proc = opendir(PROC_DIRECTORY) ;
    if (dir_proc == NULL)
    {
        perror("Couldn't open the " PROC_DIRECTORY " directory") ;
        return (pid_t) -2 ;
    }

    // Loop while not NULL
    while ( (de_DirEntity = readdir(dir_proc)) )
    {
        if (de_DirEntity->d_type == DT_DIR)
        {
            if (IsNumeric(de_DirEntity->d_name))
            {
                strcpy(chrarry_CommandLinePath, PROC_DIRECTORY) ;
                strcat(chrarry_CommandLinePath, de_DirEntity->d_name) ;
                strcat(chrarry_CommandLinePath, "/cmdline") ;
                FILE* fd_CmdLineFile = fopen (chrarry_CommandLinePath, "rt") ;  // open the file for reading text
                if (fd_CmdLineFile)
                {
                    fscanf(fd_CmdLineFile, "%s", chrarry_NameOfProcess) ; // read from /proc/<NR>/cmdline
                    fclose(fd_CmdLineFile);  // close the file prior to exiting the routine

                    if (strrchr(chrarry_NameOfProcess, '/'))
                        chrptr_StringToCompare = strrchr(chrarry_NameOfProcess, '/') +1 ;
                    else
                        chrptr_StringToCompare = chrarry_NameOfProcess ;

                    //printf("Process name: %s\n", chrarry_NameOfProcess);
                    //printf("Pure Process name: %s\n", chrptr_StringToCompare );

                    if ( CompareFunction(chrptr_StringToCompare, cchrptr_ProcessName, intCaseSensitiveness) )
                    {
                        pid_ProcessIdentifier = (pid_t) atoi(de_DirEntity->d_name) ;
                        closedir(dir_proc) ;
                        return pid_ProcessIdentifier ;
                    }
                }
            }
        }
    }
    closedir(dir_proc) ;
    return pid_ProcessIdentifier ;
}

#ifdef __cplusplus
    pid_t GetPIDbyName(const char* cchrptr_ProcessName)
    {
        return GetPIDbyName(cchrptr_ProcessName, CASE_INSENSITIVE, EXACT_MATCH) ;
    }
#else
    // C cannot overload functions - fixed
    pid_t GetPIDbyName_Wrapper(const char* cchrptr_ProcessName, ... )
    {
        int intTempArgument ;
        int intInputArguments[2] ;
        // intInputArguments[0] = 0 ;
        // intInputArguments[1] = 0 ;
        memset(intInputArguments, 0, sizeof(intInputArguments) ) ;
        int intInputIndex ;
        va_list argptr;

        va_start( argptr, cchrptr_ProcessName );
            for (intInputIndex = 0;  (intTempArgument = va_arg( argptr, int )) != 15; ++intInputIndex)
            {
                intInputArguments[intInputIndex] = intTempArgument ;
            }
        va_end( argptr );
        return GetPIDbyName_implements(cchrptr_ProcessName, intInputArguments[0], intInputArguments[1]);
    }

    #define GetPIDbyName(ProcessName,...) GetPIDbyName_Wrapper(ProcessName, ##__VA_ARGS__, (int) 15)

#endif

int main()
{
    pid_t pid = GetPIDbyName("bash") ; // If -1 = not found, if -2 = proc fs access error
    printf("PID %d\n", pid);
    return EXIT_SUCCESS ;
}

Wenn Sie es nicht tun, wird die API, die Sie verwenden, am Ende das /proc-Dateisystem lesen. Hier sind einige Beispiele für Programme, die dies tun:

  • qps
  • top
  • Props

Aber leider stellt das keine API dar.


Linux
  1. 3 Möglichkeiten zum Auflisten von Benutzern in Linux

  2. So beenden Sie laufende Prozesse in Linux

  3. Linux-ps-Befehl

  4. Linux-ls-Befehl - Dateien auflisten

  5. Wie listet man Prozesse auf, die an ein Shared-Memory-Segment in Linux angehängt sind?

So finden und beenden Sie laufende Prozesse in Linux

SS-Befehl unter Linux

Prozessüberwachung unter Linux

Laufende Prozesse

Prozesse unter Linux verstehen

So finden Sie die am häufigsten ausgeführten Prozesse nach Speicher- und CPU-Auslastung in Linux