programmation système Linux.

**Luke spywoker** · 26/10/2013, 17h44

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

**imperio** · 26/10/2013, 18h15

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.

**Luke spywoker** · 27/10/2013, 12h19

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

 "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.

**Luke spywoker** · 27/10/2013, 13h56

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

**imperio** · 27/10/2013, 15h05

T'utilises kill pour voir si un process existe ?

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.

**Luke spywoker** · 29/10/2013, 05h29

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.

programmation système Linux.

C

Vue hybride

Discussions similaires

Partager

Partager