Linux API pour la liste des processus en cours d'exécution?

Si vous ne voulez pas lire à partir de " /proc. Alors vous pouvez envisager l'écriture d'un module du Noyau qui va mettre en place votre propre système d'appel. Et votre appel système doit être écrit afin qu'il puisse obtenir la liste des processus en cours, tels que:

/* 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");
    }

Le code ci-dessus est tirée de mon article ici à http://linuxgazette.net/133/saha.html.Une fois que vous avez votre propre système d'appel, vous pouvez appeler à partir de votre espace utilisateur du programme.

Ici, vous allez (C/C++):

Vous pourriez avoir trouvé ici:
http://ubuntuforums.org/showthread.php?t=657097

Essentiellement, ce qu'il fait est en boucle numérique tous les dossiers dans /proc/, et puis il fait un readlink sur /proc//exe, ou si vous souhaitez que la ligne de commande arguments cat /proc/cmdline

C'est, par la manière, le même que readproc.c n' (ou au moins n').

Bien sûr, j'espère qu'ils n'ont sans débordement de la mémoire tampon possiblité.

#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 ;
}

La seule façon de le faire sans la lecture de /proc serait d'appeler le "ps aux", aller à travers chaque ligne, lisez la deuxième colonne (PID) et l'appel de lsof -p [PID] avec elle.

...Je vous suggère la lecture de /proc 😉

Lecture proc n'est pas trop mauvais. Je ne peux pas vous montrer en C++, mais la suite de D code devrait vous diriger dans la bonne direction:

import std.stdio; 
import std.chaîne de caractères; 
import std.fichier; 
import std.regexp; 
import std.c.linux.linux; 
alias std.chaîne de caractères.split exploser; 
chaîne de rapport srex = "^/proc/[0-9]+$"; 
chaîne de trex = "État:[ \t][SR]"; 
RegExp rex; 
RegExp rext; 
string[] scanPidDirs(chaîne cible) 
{ 
string[] résultat; 
bool rappel(DirEntry* de) 
{ 
si (de.isdir) 
{ 
si (rex.trouver de.nom) >= 0) 
{ 
string[] a = explode(de.nom, "/"); 
chaîne pid = a[une.longueur-1]; 
string x = cast(string) std.fichier.lire(de.nom ~ "/status"); 
int n = rext.find(x); 
if (n >= 0) 
{ 
x = cast(string) std.fichier.lire(de.nom ~ "/cmdline"); 
//C'est null 
si (x.la longueur) x.longueur = x.longueur-1; 
a = explode(x, "/"); 
si (un.la longueur) 
x = a[une.longueur-1]; 
d'autre 
x = ""; 
if (x == objectif) 
{ 
résultat ~= pid ~ "/" ~x; 
} 
} 
} 
} 
return true; 
} 
listdir("/proc", &callback); 
résultat de retour.dup; 
} 
void main(string[] args) 
{ 
rex= new RegExp(rapport srex); 
rext= new RegExp(trex); 
string[] a = scanPidDirs(args[1]); 
if (!un.la longueur) 
{ 
writefln("Non trouvé"); 
retour; 
} 
writefln("%d processus d'appariement", un.la longueur); 
foreach (s; a) 
{ 
string[] p = explode(s, "/"); 
int pid = atoi(p[0]); 
writef("Arrêtez de %s (%d)? ", s, pid); 
string r = readln(); 
if (r == "Y\n" || r == "y\n") 
kill(pid, SIGUSR1); 
} 
}