programmation système Linux.

Version imprimable

26/10/2013, 17h44
Luke spywoker

1 pièce(s) jointe(s)

programmation système Linux.

Salut les C,
je suis en train de livre de Blaess sur la programmation système sous Linux, qui est d'ailleurs très bien écrit, que je comprend parfaitement malgré mes 10 mois de pratique du C. J'y ai appris beaucoup de chose mais j'ai une question.
Certes on peut utiliser ce qui est décrit dans le livre pour des programmes pas forcément d'orientation programmation système mais ça fait le 3ieme livre sur la programmation système Linux que je lis et j'ai toujours pas d'idée sur un programme dit programmation système.
Avez vous envie de me donner des petits exercices a faire.
En échange je vous donne quelque idées de programme en mode terminal, car je refuse, pour l'instant, d'apprendre l'utilisation une interface graphique en C et j'ai donc créer pas mal de trucs en mode terminal:
-Un économiseur d'écran du terminal (pensez a ncurses).
-Un programme d"affichage d'image dans le terminal (pensez au format *.xpm et au curseur dont deux unité cote a cote forme un carré (pixels !!!).
-Un afficheur d'image ASCII fournis en argument.

Sur ce bon C a vous.

PS: mon premier programme en C :
http://www.developpez.net/forums/att...1&d=1382862826
26/10/2013, 18h15
imperio

Un programme qui affiche tous les processus courants avec la possibilite de les tuer en envoyant un signal choisi par l'utilisateur. Si t'es sur un pc portable, t'as qu'a aussi afficher la batterie recente. Ca te permettra en plus de voir un peu comment tout ca fonctionne sous linux. ;)

J'ai déja écrit un code comme ca mais
a la volée :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 #include <stdio.h> #include <limits.h> /* for SHRT_MAX (supposed pid value limit) */ #include <sys/types.h> /* for pid_t */ #include <signal.h> /* For kill() */ #define MAX_PID SHRT_MAX /* supposed max pid value */ int main() { int c ; pid_t process[MAX_PID] ; int process_counter ; for (c=1; c < MAX_PID ; c++) { /* we start at 1 for init */ if (kill((pid_t) c,0) == 0) { /* with the signal 0 (zero) kill return 0 if the process exist */ process[process_counter]=(pid_t) c ; /* register the existing process */ process_counter++ ; } } for (c=0 ; c < process_counter ; c++) { kill(process[c],SIGKILL) ; } return 0 ; }
exécuter en tant que root on tue tout le monde je crois...
enfin je l'ai exécuter (même pas en root) et le système a sauter a l'écran de login !!!

En faite c'est facile, mais tu a mis dans le mille: imperio
car je suis en train d'écrire du code qui s'intéresse a tout les processus en cours d'exécution, puis je récupère des infos grace au pseudo système de fichier /proc
grâce a un popen() sur les fichiers

Code:

"cat /proc/%d/status" pid

dont je met les infos dans une structure, bref je m'amuse.

Et je vous montrerai le code dès que j'aurai le temps dont ont pourra parler.

Je vous montrerai aussi du code qui affiche tous les signaux (Real-Time compris) en pretty print que j'ai fait pour Linux et les conseils pour l'adapter a votre distribution.

Sur ce bon code C a vous.

Chose promisse chose dû:
d'abord le signaux pour afficher l'ensemble des signaux (Ubuntu 64 bits):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
#define _GNU_SOURCE
#define _POSIX_REALTIME_SIGNALS
#include <stdio.h>
#include <signal.h>
#include <string.h>
#include <unistd.h>
 
char *signals[32]={NULL,"SIGHUP","SIGINT","SIGQUIT","SIGILL","SIGTRAP","SIGABRT","SIGBUS","SIGFPE","SIGKILL","SIGUSR1","SIGSEGV","SIGUSR2","SIGPIPE","SIGALRM","SIGTERM","SIGSTKFLT","SIGCHLD","SIGCONT","SIGSTOP","SIGTSTP","SIGTTIN","SIGTTOU","SIGURG","SIGXCPU","SIGXFSZ","SIGVTALRM","SIGPROF","SIGWINCH","SIGIO","SIGPWR","SIGSYS"} ;
int main() {
  int c; 
  for (c=0 ; c < NSIG ; c++) {
    if (c == 0 ) {
      fprintf(stdout,"signal [%02d] %9s -> %s\n",c,"UNKNOW",strsignal(c)) ;
    }
    else if (c > 0 && c < 32) {
      fprintf(stdout,"signal [%02d] %9s -> %s\n",c,signals[c],strsignal(c)) ;
    }
    else if ( c >= SIGRTMIN && c <= SIGRTMAX ) {
      fprintf(stdout,"signal [%02d]   SIGRT%02d -> %s\n",c,c-SIGRTMIN,strsignal(c)) ;
    }
    else {
      fprintf(stdout,"signal [%02d] %9s -> %s\n",c,"REALTIME",strsignal(c)) ;
    }
  }
 
  return 0 ;
 
}

a titre d'info il faut consulter la page man: man 7 signal pour avoir un tableau des différents signaux suivant les normes|implémentations.

Voici le code de mon expérience de récupération d'information sur les processus en cours, je vous pris a moins de détecter une erreur grave dans mon code de ne pas tenir compte des code de retours non tester et de ma technique rudimentaire de parsing du fichier /proc/<pid>/status et du fichier /proc/cpuinfo, bref du laxisme et et des défauts du code.
Car le but est de l'améliorer pas dans le sens du code mais de la recherche d'informations sur mes processus par les pseudo-fichiers /proc/... ou par des fonctions de programmation système.
L'affichage des résultats pourra bien sur être formater autrement, disont que c'est un test avant d'écrire le vrai programme dont voici le code succinctement commenter:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
 
#define _GNU_SOURCE 
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <unistd.h>
#include <inttypes.h>
#include <grp.h>
#include <pwd.h>
#include <signal.h>
#include <stdint.h>
 
 
#define MAX_PID 32767
 
struct Process_Info {
  char status ;
  char *name ;
  pid_t pid  ;
  pid_t ppid  ;
  uid_t uid  ;
  pid_t pgrp ;
  pid_t sid  ;
  gid_t gid ;
  int8_t cpu_use_count ;
  int8_t cpu_1 ;
  int8_t cpu_2 ;
  int8_t cpu_3 ;
  int8_t cpu_4 ;
  int8_t priority ;
  int scheduling ;
  struct group *grp ;
  struct passwd *password ;
} process_infos[]={} ;
 
void fill_process_information(pid_t pid,struct Process_Info *process_infos,int index) ;
 
int main() {
  /* creation of one seperator line (use the fullscreen terminal size for displaying)
   * and start the programm as root.
   */ 
 
  char *sep_string=malloc(88) ;
  int c ;
  strcpy(sep_string,"-") ;
  for (c=1; c < 87 ; c++) {
    strcat(sep_string,"-") ;
  }
  sep_string[c]='\0' ;
 
  /* process search */
  pid_t list_of_process[MAX_PID] ;
  int counter ;
  int process_counter=0 ;
  for (counter=1 ; counter < MAX_PID ; counter++) {
    pid_t exist=counter;
    int8_t ok ;
    if ( (ok=kill(exist,0) == 0) ) {
      list_of_process[process_counter]=exist ;
 
 
      process_counter++ ;
      ok = -1 ;
    }
 
  }
 
 
  for (counter=0 ; counter < process_counter ; counter++) {
 
 
    fill_process_information(list_of_process[counter],process_infos,counter) ;
 
    /* affichage des résultat */
    fprintf(stdout,"%s\n",sep_string) ;
    fprintf(stdout,"Process...: %-20s PID  %05d PGRP %05d PPID %05d  SID %05d STATUS: %c \n",process_infos[counter].name,process_infos[counter].pid,process_infos[counter].pgrp,process_infos[counter].ppid,process_infos[counter].sid,process_infos[counter].status) ;
    fprintf(stdout,"User......: %-20s UID  %05d  GID %05d GECOS   %s\n",process_infos[counter].password->pw_name,process_infos[counter].password->pw_uid,process_infos[counter].password->pw_gid,process_infos[counter].password->pw_gecos) ;
    fprintf(stdout,"Group.....: %-20s GID  %05d  MEMBERS ",process_infos[counter].grp->gr_name,process_infos[counter].grp->gr_gid) ;
 
    /* show  the information: members of the group */
    int c=0 ;
    char *tmp_ptr ;
    tmp_ptr=process_infos[counter].grp->gr_mem[c] ;
    while ( tmp_ptr != NULL) {
      fprintf(stdout,"%s ",tmp_ptr) ;
      c++ ;
      tmp_ptr=process_infos[counter].grp->gr_mem[c] ;
    }
    fprintf(stdout,"\n") ;
    /* How many processors|core and wich the processus use.  
     * 4 processors available on my system 
     */
    fprintf(stdout,"Processor.: \t\t\t COUNT %d CPU1 %d CPU2 %d CPU3 %d CPU4 %d\n",process_infos[counter].cpu_use_count,process_infos[counter].cpu_1,process_infos[counter].cpu_2,process_infos[counter].cpu_3,process_infos[counter].cpu_4) ;
 
 
 
  }
  exit(EXIT_SUCCESS) ; 
}
 
 
void fill_process_information(pid_t pid,struct Process_Info *process_infos,int index) {
 
    FILE *fp ;
    char buffer[255] ;
    if (sprintf(buffer,"cat /proc/%d/status",pid) == 0) {
      char *err_msg ;
      err_msg=strerror(errno) ;
      fprintf(stderr,"%s\n",err_msg) ;
      exit(EXIT_FAILURE) ;
    }
 
    if ((fp=popen(buffer,"r")) == NULL) {
      char *err_msg ;
      err_msg=strerror(errno) ;
      fprintf(stderr,"%s\n",err_msg) ;
      exit(EXIT_FAILURE) ;
    }
    char *get_status_file_content=malloc(1024) ; /* wc -c /proc/<pid>/status == 820 */
    if (fread(get_status_file_content, (size_t) 1024, (size_t) 1, fp) < 0) {
      /* print SUCCCES
      char *err_msg ;
      err_msg=strerror(errno) ;
      fprintf(stderr,"%s\n",err_msg) ;
      */
    }
 
    else {
      pclose(fp) ;
 
      /* getting pid */
 
      process_infos[index].pid= pid ;
 
      /* Getting the status of the process */
      char *get_state ;
      get_state=strstr(get_status_file_content,"State:") ;
      process_infos[index].status=*get_state ;
 
      /* Getting process Name from /proc/<pid>/status */
      char *get_name=strstr(get_status_file_content,"Name:") ;
 
      int counter=0 ;
      get_name += 6 ; /* offset to get the process name */
      char name[64] ;
      name[0]=*get_name ;
      while (*get_name != '\n') {
	counter++ ;
	get_name++ ;
	name[counter]=*get_name ;
      }
      name[counter]='\0' ;
 
      process_infos[index].name=name ;
 
       /* Getting process Gid from /proc/<pid>/status */
      uid_t get_gid[4] ;
      sscanf(strstr(get_status_file_content,"Gid:"),"Gid: %d %d %d %d",&get_gid[0],&get_gid[1],&get_gid[2],&get_gid[3]) ;
 
 
      if ( get_gid[0] == get_gid[1] && get_gid[1] == get_gid[2] && get_gid[2] == get_gid[3]) {
	process_infos[index].gid = get_gid[0] ;
      }
      else {
	process_infos[index].gid = -1 ;
      }
 
      /* Getting process Uid from /proc/<pid>/status */
      uid_t get_uid[4] ;
      sscanf(strstr(get_status_file_content,"Uid:"),"Uid: %d %d %d %d",&get_uid[0],&get_uid[1],&get_uid[2],&get_uid[3]) ;
 
      if ( get_uid[0] == get_uid[1] && get_uid[1] == get_uid[2] && get_uid[2] == get_uid[3]) {
	process_infos[index].uid = get_uid[0] ;
      }
      else {
	process_infos[index].uid = -1 ;
      }
 
      /* Getting process PPID from /proc/<pid>/status */
      pid_t get_ppid ;
      sscanf(strstr(get_status_file_content,"PPid:"),"PPid: %d",&get_ppid) ;
      process_infos[index].ppid = get_ppid ;
 
      /* Getting the process group */
      process_infos[index].pgrp = getpgid(pid) ;
 
 
      process_infos[index].scheduling=sched_getscheduler(pid) ;
      process_infos[index].priority=getpriority(PRIO_PROCESS, pid);
 
 
      /* popen /proc/cpuinfo to parse it to get the number of processors */     
      char buffer_cpu[255] ;
      if (sprintf(buffer_cpu,"cat /proc/%d/cpuinfo",pid) == 0) {
	char *err_msg ;
	err_msg=strerror(errno) ;
	fprintf(stderr,"%s\n",err_msg) ;
	exit(EXIT_FAILURE) ;
      }
      if ((fp=popen(buffer,"r")) == NULL) {
	char *err_msg ;
	err_msg=strerror(errno) ;
	fprintf(stderr,"%s\n",err_msg) ;
	exit(EXIT_FAILURE) ;
      }
 
      char *get_cpuinfo_file_content=malloc(4096) ; /* wc -c /proc/cpuinfo  == 3376 */
      if (fread(get_cpuinfo_file_content, (size_t) 4096, (size_t) 1, fp) < 0) {
	/* print SUCCCES
	char *err_msg ;
	err_msg=strerror(errno) ;
	fprintf(stderr,"%s\n",err_msg) ;
	*/
      }
      pclose(fp) ;
      free(get_status_file_content) ;
      free(get_cpuinfo_file_content) ;
      /* Getting the processors informations */
      char *cpu_counter_ptr ;
      int cpu_counter ;
      cpu_set_t set ;
 
      CPU_ZERO(&set) ;
 
      sched_getaffinity(pid, sizeof(cpu_set_t),&set);
      process_infos[index].cpu_use_count=CPU_COUNT(&set);
      process_infos[index].cpu_1=CPU_ISSET(0,&set)  ;
      process_infos[index].cpu_2=CPU_ISSET(1,&set)  ;
      process_infos[index].cpu_3=CPU_ISSET(2,&set)  ;
      process_infos[index].cpu_4=CPU_ISSET(3,&set) ;
 
      /* Getting struct group */ 
      struct group *grp ;
      grp=getgrgid(get_gid[0]);
      process_infos[index].grp=grp ;
 
      /* Getting struct passwd */ 
      struct passwd *password ;
      password=getpwuid(get_uid[0]);
      process_infos[index].password=password ;
 
    }
    return ;
}

En faite quand on lance le programme comme root on récupère les processus appartenant a celui-ci et pareil si on récupère pour les processus de l'utilisateur qui le lance avec une erreur de segmentation en primes.

Tout conseils, critiques, astuces, idées, leçon (si vous avez l'esprit didactique) sont la bienvenue.

Merci pour vos réponses éclairées.

27/10/2013, 15h05
imperio

T'utilises kill pour voir si un process existe ? 8O C'est degueulasse ! Pour ca utiliser opendir, readdir, closedir sur /proc et la t'auras tous les proc qui tournent. Ca me parait deja bien plus logique.
29/10/2013, 05h29
Luke spywoker

D'accord j'utilise effectivement l'appel système kill() mais avec le signal 0 donc je n'envoie pas de signal SIGKILL et la fonction renvoie explicite zéro si le processus du pid passer en argument existe, ce n'est pas de ma faute si la l'appel système kill permet cela.
Maintenant c'est sur que parser le directory /proc pour voir les pid serai une autre méthode, je ne comprend pas ton abjection.
29/10/2013, 09h14
Metalman

/proc n'étant pas "toujours dispo" sur tous les *n*x, c'est Luke qui a raison.

De plus, d'après le man 2 de kill, en effet, le signal 0 sert à checker les erreurs sans envoyer de signal, donc c'est bon.

C'est juste que "fonctionnellement parlant", kill parait plus adapté à l'envoi de signal qu'autre chose.
29/10/2013, 12h32
imperio

Ah bon ? Me semblait pourtant que c’était propre a tous les systèmes unix... Si ce n'est pas le cas il doit forcement y avoir une autre solution que kill...

Ce que je reproche a cette solution c'est de devoir tester a l'aveugle tous les pid existants. C'est pas franchement folichon... De plus il faut rappeler cette méthode a chaque fois qu'on veut vérifier si un nouveau processus a été lance ou si un autre s'est termine. Avec ma méthode on peut utiliser inotify et ainsi savoir directement tout changement. C'est quand même sacrement mieux je trouve.
29/10/2013, 12h35
Metalman

inotify est dédié linux aussi... donc pas UNIX !

/proc ça provient de PROCFS, qui est une extension à la VFS du coup...

Bref, kill est LA méthode pour tester ou envoyer un signal à un PID connu.
La question à se poser est plutôt : comment connaitre les PID en cours sur un UNIX.
29/10/2013, 12h41
imperio

Décidément va falloir que je me mette a jour parce que j'ai l'impression de confondre linux et unix. M'a toujours semble que ce qui fonctionnait sur linux fonctionnait aussi sur unix...
29/10/2013, 13h12
Metalman

C'est l'inverse ! :P
Ce qui fonctionne sur un UNIX/POSIX fonctionnera très très probablement sur un Linux ! (attention à Debian qui ne respecte pas certains define POSIX et nécessite un syscall pour récupérer la valeur................. oui oui... c'est ce qu'un dev kernel m'avait répondu)

Enfin moi c'est parce que je suis un tordu qui veut coder en C/ANSI portable POSIX....
Bref...

Ta méthode est bonne quand même, hein ! :P
Mais kill peut "aussi" servir à ça.
31/10/2013, 04h21
Luke spywoker

Merci pour ces informations complémentaires,
pour info je me suis servis de kill() car c'était écrit dans le bouquin de Blaess, j'apprends des meilleurs quand ont sait que c'est lui qui a rédiger la plupart des pages man en français...
Il reste la question de savoir la valeur maximale qu'un pid peut prendre:
j'ai pris un SHRT_MAX (32767) définis dans limits.h la valeur maximale de 2 octets signés et je ne sais si c'est exacte ?
Parcourir le répertoire /proc est une autre solution surtout que:
Quand on lance mon programme en tant qu'un utilisateur spécifique normal ou root, le programme détecte que les pid des processus de cet utilisateur.
On peut aussi regarder tout les secondes le fichier /proc/meminfo pour voir la mémoire utiliser: avez vous d'autres idées d'exploitation du répertoire de pseudo-fichiers /proc ?
31/10/2013, 09h06
Metalman

Alors pour les PID... si tu veux rester "UNIX compliant"...
Je cite la SUS :

Citation:

[...] pid_t [...] are signed integral types.

sys/types.h

Etant donné que d'autres font mention "d'extended signed integral type"...
Du int ou du short est possible.

Ca vient de me faire tilt en fait.... il faut utiliser : sizeof (pid_t)

Citation:

Envoyé par Metalman

La question à se poser est plutôt : comment connaitre les PID en cours sur un UNIX.

Une méthode portable (la seule en fait) consiste à analyser la sortie de ps, par exemple:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 #include <stdio.h> #include <stdlib.h> int main(void) { char buf[16]; FILE *fp=popen("ps -Ao pid=", "r"); while(fgets(buf,15,fp)) { printf("%d\n",atoi(buf)); } return 0; }