ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/i-scream/projects/libstatgrab/src/libstatgrab/process_stats.c
(Generate patch)

Comparing projects/libstatgrab/src/libstatgrab/process_stats.c (file contents):
Revision 1.62 by pajs, Wed Apr 7 14:45:33 2004 UTC vs.
Revision 1.79 by tdb, Sat Nov 6 23:54:12 2004 UTC

# Line 51 | Line 51
51   #define MAX_FILE_LENGTH PATH_MAX
52   #endif
53   #ifdef ALLBSD
54 + #include <errno.h>
55   #include <stdlib.h>
56   #include <sys/param.h>
57   #include <sys/sysctl.h>
# Line 71 | Line 72
72   #include <sys/lwp.h>
73   #endif
74   #endif
75 + #ifdef HPUX
76 + #include <sys/param.h>
77 + #include <sys/pstat.h>
78 + #include <unistd.h>
79 + #define PROCESS_BATCH 30
80 + #endif
81  
82   static void proc_state_init(sg_process_stats *s) {
83          s->process_name = NULL;
# Line 84 | Line 91 | static void proc_state_destroy(sg_process_stats *s) {
91  
92   sg_process_stats *sg_get_process_stats(int *entries){
93          VECTOR_DECLARE_STATIC(proc_state, sg_process_stats, 64,
94 <                              proc_state_init, proc_state_destroy);
94 >                              proc_state_init, proc_state_destroy);
95          int proc_state_size = 0;
96          sg_process_stats *proc_state_ptr;
97 + #ifdef HPUX
98 +        struct pst_status pstat_procinfo[PROCESS_BATCH];
99 +        long procidx = 0;
100 +        long long pagesize;
101 +        int num, i;
102 + #endif
103   #ifdef ALLBSD
104          int mib[4];
105          size_t size;
# Line 99 | Line 112 | sg_process_stats *sg_get_process_stats(int *entries){
112          int argslen = 0;
113   #else
114          long buflen;
115 <        char *p;
115 >        char *p, *proctitletmp;
116   #endif
117   #ifdef NETBSD2
118          int lwps;
# Line 107 | Line 120 | sg_process_stats *sg_get_process_stats(int *entries){
120   #endif
121   #endif
122   #if defined(SOLARIS) || defined(LINUX)
123 <        DIR *proc_dir;
124 <        struct dirent *dir_entry;
125 <        char filename[MAX_FILE_LENGTH];
126 <        FILE *f;
123 >        DIR *proc_dir;
124 >        struct dirent *dir_entry;
125 >        char filename[MAX_FILE_LENGTH];
126 >        FILE *f;
127   #ifdef SOLARIS
128          psinfo_t process_info;
129   #endif
# Line 130 | Line 143 | sg_process_stats *sg_get_process_stats(int *entries){
143  
144   #ifdef LINUX
145          if ((f=fopen("/proc/uptime", "r")) == NULL) {
146 +                sg_set_error_with_errno(SG_ERROR_OPEN, "/proc/uptime");
147                  return NULL;
148          }
149          if((fscanf(f,"%lu %*d",&uptime)) != 1){
150 +                sg_set_error(SG_ERROR_PARSE, NULL);
151                  return NULL;
152          }
153          fclose(f);
154   #endif
155  
156 <        if((proc_dir=opendir(PROC_LOCATION))==NULL){
157 <                return NULL;
158 <        }
156 >        if((proc_dir=opendir(PROC_LOCATION))==NULL){
157 >                sg_set_error_with_errno(SG_ERROR_OPENDIR, PROC_LOCATION);
158 >                return NULL;
159 >        }
160  
161 <        while((dir_entry=readdir(proc_dir))!=NULL){
162 <                if(atoi(dir_entry->d_name) == 0) continue;
161 >        while((dir_entry=readdir(proc_dir))!=NULL){
162 >                if(atoi(dir_entry->d_name) == 0) continue;
163  
164   #ifdef SOLARIS
165 <                snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/psinfo", dir_entry->d_name);
165 >                snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/psinfo", dir_entry->d_name);
166   #endif
167   #ifdef LINUX
168                  snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/stat", dir_entry->d_name);
169   #endif
170 <                if((f=fopen(filename, "r"))==NULL){
171 <                        /* Open failed.. Process since vanished, or the path was too long.
172 <                         * Ah well, move onwards to the next one */
173 <                        continue;
174 <                }
170 >                if((f=fopen(filename, "r"))==NULL){
171 >                        /* Open failed.. Process since vanished, or the path was too long.
172 >                         * Ah well, move onwards to the next one */
173 >                        continue;
174 >                }
175   #ifdef SOLARIS
176 <                fread(&process_info, sizeof(psinfo_t), 1, f);
176 >                fread(&process_info, sizeof(psinfo_t), 1, f);
177 >                fclose(f);
178   #endif
179  
180                  if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
# Line 177 | Line 194 | sg_process_stats *sg_get_process_stats(int *entries){
194                  proc_state_ptr->proc_resident = (process_info.pr_rssize) * 1024;
195                  proc_state_ptr->time_spent = process_info.pr_time.tv_sec;
196                  proc_state_ptr->cpu_percent = (process_info.pr_pctcpu * 100.0) / 0x8000;
197 +                proc_state_ptr->nice = (int)process_info.pr_lwp.pr_nice - 20;
198                  if (sg_update_string(&proc_state_ptr->process_name,
199 <                                     process_info.pr_fname) < 0) {
199 >                                     process_info.pr_fname) < 0) {
200                          return NULL;
201                  }
202                  if (sg_update_string(&proc_state_ptr->proctitle,
203 <                                     process_info.pr_psargs) < 0) {
203 >                                     process_info.pr_psargs) < 0) {
204                          return NULL;
205                  }
206  
207 <                if(process_info.pr_lwp.pr_state==1) proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
208 <                if(process_info.pr_lwp.pr_state==2) proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
209 <                if(process_info.pr_lwp.pr_state==3) proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
210 <                if(process_info.pr_lwp.pr_state==4) proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
211 <                if(process_info.pr_lwp.pr_state==6) proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
207 >                switch (process_info.pr_lwp.pr_state) {
208 >                case 1:
209 >                        proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
210 >                        break;
211 >                case 2:
212 >                case 5:
213 >                        proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
214 >                        break;
215 >                case 3:
216 >                        proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
217 >                        break;
218 >                case 4:
219 >                        proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
220 >                        break;
221 >                }
222   #endif
223   #ifdef LINUX
224                  x = fscanf(f, "%d %4096s %c %d %d %*d %*d %*d %*u %*u %*u %*u %*u %lu %lu %*d %*d %*d %d %*d %*d %lu %llu %llu %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*d %*d\n", &(proc_state_ptr->pid), ps_name, &s, &(proc_state_ptr->parent), &(proc_state_ptr->pgid), &utime, &stime, &(proc_state_ptr->nice), &starttime, &(proc_state_ptr->proc_size), &(proc_state_ptr->proc_resident));
225                  /* +3 becuase man page says "Resident  Set Size: number of pages the process has in real memory, minus 3 for administrative purposes." */
226                  proc_state_ptr->proc_resident = (proc_state_ptr->proc_resident + 3) * getpagesize();
227 <                if(s == 'S') proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
228 <                if(s == 'R') proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
229 <                if(s == 'Z') proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
230 <                if(s == 'T') proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
231 <                if(s == 'D') proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
227 >                switch (s) {
228 >                case 'S':
229 >                        proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
230 >                        break;
231 >                case 'R':
232 >                        proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
233 >                        break;
234 >                case 'Z':
235 >                        proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
236 >                        break;
237 >                case 'T':
238 >                case 'D':
239 >                        proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
240 >                        break;
241 >                }
242          
243                  /* pa_name[0] should = '(' */
244                  ptr = strchr(&ps_name[1], ')');
245                  if(ptr !=NULL) *ptr='\0';
246  
247                  if (sg_update_string(&proc_state_ptr->process_name,
248 <                                     &ps_name[1]) < 0) {
248 >                                     &ps_name[1]) < 0) {
249                          return NULL;
250                  }
251  
252                  /* cpu */
253                  proc_state_ptr->cpu_percent = (100.0 * (utime + stime)) / ((uptime * 100.0) - starttime);
254  
255 <                fclose(f);
255 >                fclose(f);
256  
257                  /* uid / gid */
258                  snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/status", dir_entry->d_name);
259 <                if ((f=fopen(filename, "r")) == NULL) {
260 <                        /* Open failed.. Process since vanished, or the path was too long.
261 <                         * Ah well, move onwards to the next one */
262 <                        continue;
263 <                }
259 >                if ((f=fopen(filename, "r")) == NULL) {
260 >                        /* Open failed.. Process since vanished, or the path was too long.
261 >                         * Ah well, move onwards to the next one */
262 >                        continue;
263 >                }
264  
265                  if((ptr=sg_f_read_line(f, "Uid:"))==NULL){
266                          fclose(f);
# Line 231 | Line 269 | sg_process_stats *sg_get_process_stats(int *entries){
269                  sscanf(ptr, "Uid:\t%d\t%d\t%*d\t%*d\n", &(proc_state_ptr->uid), &(proc_state_ptr->euid));
270  
271                  if((ptr=sg_f_read_line(f, "Gid:"))==NULL){
272 <                        fclose(f);
273 <                        continue;
274 <                }
275 <                sscanf(ptr, "Gid:\t%d\t%d\t%*d\t%*d\n", &(proc_state_ptr->gid), &(proc_state_ptr->egid));
272 >                        fclose(f);
273 >                        continue;
274 >                }
275 >                sscanf(ptr, "Gid:\t%d\t%d\t%*d\t%*d\n", &(proc_state_ptr->gid), &(proc_state_ptr->egid));
276  
277                  fclose(f);
278  
279                  /* proctitle */
280                  snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/cmdline", dir_entry->d_name);
281  
282 <                if((fn=open(filename, O_RDONLY)) == -1){
283 <                        /* Open failed.. Process since vanished, or the path was too long.
284 <                         * Ah well, move onwards to the next one */
285 <                        continue;
286 <                }
282 >                if((fn=open(filename, O_RDONLY)) == -1){
283 >                        /* Open failed.. Process since vanished, or the path was too long.
284 >                         * Ah well, move onwards to the next one */
285 >                        continue;
286 >                }
287  
288   #define READ_BLOCK_SIZE 128
289                  len = 0;
# Line 291 | Line 329 | sg_process_stats *sg_get_process_stats(int *entries){
329   #endif
330  
331                  proc_state_size++;
332 <        }
333 <        closedir(proc_dir);
332 >        }
333 >        closedir(proc_dir);
334   #endif
335  
336   #ifdef ALLBSD
# Line 301 | Line 339 | sg_process_stats *sg_get_process_stats(int *entries){
339          mib[2] = KERN_PROC_ALL;
340  
341          if(sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
342 +                sg_set_error_with_errno(SG_ERROR_SYSCTL,
343 +                                        "CTL_KERN.KERN_PROC.KERN_PROC_ALL");
344                  return NULL;
345          }
346  
# Line 313 | Line 353 | sg_process_stats *sg_get_process_stats(int *entries){
353          memset(kp_stats, 0, size);
354  
355          if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
356 +                sg_set_error_with_errno(SG_ERROR_SYSCTL,
357 +                                        "CTL_KERN.KERN_PROC.KERN_PROC_ALL");
358                  free(kp_stats);
359                  return NULL;
360          }
# Line 354 | Line 396 | sg_process_stats *sg_get_process_stats(int *entries){
396                  }
397  
398   #if defined(FREEBSD5) || defined(NETBSD) || defined(OPENBSD)
357 –                size = sizeof(buflen);
399  
400   #ifdef FREEBSD5
360 –                if(sysctlbyname("kern.ps_arg_cache_limit", &buflen, &size, NULL, 0) < 0) {
361 –                        return NULL;
362 –                }
363 – #else
364 –                /* FIXME - this value can be too large on some of
365 –                   the BSD's, which causes sysctl not to return
366 –                   anything. Maybe we need something smaller? */
367 –                mib[1] = KERN_ARGMAX;
368 –
369 –                if(sysctl(mib, 2, &buflen, &size, NULL, 0) < 0) {
370 –                        return NULL;
371 –                }
372 – #endif
373 –
374 –                proctitle = sg_malloc(buflen);
375 –                if(proctitle == NULL) {
376 –                        return NULL;
377 –                }
378 –
379 –                size = buflen;
380 –
381 – #ifdef FREEBSD5
401                  mib[2] = KERN_PROC_ARGS;
402                  mib[3] = kp_stats[i].ki_pid;
403   #else
# Line 388 | Line 407 | sg_process_stats *sg_get_process_stats(int *entries){
407   #endif
408  
409                  free(proc_state_ptr->proctitle);
410 <                if(sysctl(mib, 4, proctitle, &size, NULL, 0) < 0) {
411 <                        free(proctitle);
412 <                        proc_state_ptr->proctitle = NULL;
413 <                }
414 <                else if(size > 0) {
410 >                proc_state_ptr->proctitle = NULL;
411 >
412 > /* Starting size - we'll double this straight away */
413 > #define PROCTITLE_START_SIZE 64
414 >                buflen = PROCTITLE_START_SIZE;
415 >                size = buflen;
416 >                proctitle = NULL;
417 >
418 >                do {
419 >                        if((long) size >= buflen) {
420 >                                buflen *= 2;
421 >                                size = buflen;
422 >                                proctitletmp = sg_realloc(proctitle, buflen);
423 >                                if(proctitletmp == NULL) {
424 >                                        free(proctitle);
425 >                                        proctitle = NULL;
426 >                                        proc_state_ptr->proctitle = NULL;
427 >                                        size = 0;
428 >                                        break;
429 >                                }
430 >                                proctitle = proctitletmp;
431 >                                bzero(proctitle, buflen);
432 >                        }
433 >
434 >                        if(sysctl(mib, 4, proctitle, &size, NULL, 0) < 0) {
435 >                                free(proctitle);
436 >                                proctitle = NULL;
437 >                                proc_state_ptr->proctitle = NULL;
438 >                                size = 0;
439 >                                break;
440 >                        }
441 >                } while((long) size >= buflen);
442 >
443 >                if(size > 0) {
444                          proc_state_ptr->proctitle = sg_malloc(size+1);
445                          if(proc_state_ptr->proctitle == NULL) {
446                                  return NULL;
447                          }
448                          p = proctitle;
449 + #ifdef OPENBSD
450 +                        /* On OpenBSD, this value has the argv pointers (which
451 +                         * are terminated by a NULL) at the front, so we have
452 +                         * to skip over them to get to the strings. */
453 +                        while (*(char ***)p != NULL) {
454 +                                p += sizeof(char **);
455 +                        }
456 +                        p += sizeof(char **);
457 + #endif
458                          proc_state_ptr->proctitle[0] = '\0';
459                          do {
460                                  sg_strlcat(proc_state_ptr->proctitle, p, size+1);
# Line 405 | Line 462 | sg_process_stats *sg_get_process_stats(int *entries){
462                                  p += strlen(p) + 1;
463                          } while (p < proctitle + size);
464                          free(proctitle);
465 +                        proctitle = NULL;
466                          /* remove trailing space */
467                          proc_state_ptr->proctitle[strlen(proc_state_ptr->proctitle)-1] = '\0';
468                  }
469                  else {
470 <                        free(proctitle);
470 >                        if(proctitle != NULL) {
471 >                                free(proctitle);
472 >                                proctitle = NULL;
473 >                        }
474                          proc_state_ptr->proctitle = NULL;
475                  }
476   #else
477                  free(proc_state_ptr->proctitle);
478 +                proc_state_ptr->proctitle = NULL;
479                  if(kvmd != NULL) {
480                          args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
481                          if(args != NULL) {
# Line 518 | Line 580 | sg_process_stats *sg_get_process_stats(int *entries){
580                          mib[4] = 0;
581  
582                          if(sysctl(mib, 5, NULL, &size, NULL, 0) < 0) {
583 +                                sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_KERN.KERN_LWP.pid.structsize.0");
584                                  return NULL;
585                          }
586  
# Line 530 | Line 593 | sg_process_stats *sg_get_process_stats(int *entries){
593                          }
594  
595                          if(sysctl(mib, 5, kl_stats, &size, NULL, 0) < 0) {
596 +                                sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_KERN.KERN_LWP.pid.structsize.buffersize");
597                                  return NULL;
598                          }
599                  }
# Line 571 | Line 635 | sg_process_stats *sg_get_process_stats(int *entries){
635                          proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
636                          break;
637                  }
638 +
639 +                free(kl_stats);
640   #else
641   #ifdef FREEBSD5
642                  switch (kp_stats[i].ki_stat) {
# Line 613 | Line 679 | sg_process_stats *sg_get_process_stats(int *entries){
679          free(kp_stats);
680   #endif
681  
682 + #ifdef HPUX
683 +        if ((pagesize = sysconf(_SC_PAGESIZE)) == -1) {
684 +                sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PAGESIZE");
685 +                return NULL;
686 +        }
687 +
688 +        while (1) {
689 +                num = pstat_getproc(pstat_procinfo, sizeof pstat_procinfo[0],
690 +                                    PROCESS_BATCH, procidx);
691 +                if (num == -1) {
692 +                        sg_set_error_with_errno(SG_ERROR_PSTAT,
693 +                                                "pstat_getproc");
694 +                        return NULL;
695 +                } else if (num == 0) {
696 +                        break;
697 +                }
698 +
699 +                for (i = 0; i < num; i++) {
700 +                        struct pst_status *pi = &pstat_procinfo[i];
701 +
702 +                        if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
703 +                                return NULL;
704 +                        }
705 +                        proc_state_ptr = proc_state+proc_state_size;
706 +        
707 +                        proc_state_ptr->pid = pi->pst_pid;
708 +                        proc_state_ptr->parent = pi->pst_ppid;
709 +                        proc_state_ptr->pgid = pi->pst_pgrp;
710 +                        proc_state_ptr->uid = pi->pst_uid;
711 +                        proc_state_ptr->euid = pi->pst_euid;
712 +                        proc_state_ptr->gid = pi->pst_gid;
713 +                        proc_state_ptr->egid = pi->pst_egid;
714 +                        proc_state_ptr->proc_size = (pi->pst_dsize + pi->pst_tsize + pi->pst_ssize) * pagesize;
715 +                        proc_state_ptr->proc_resident = pi->pst_rssize * pagesize;
716 +                        proc_state_ptr->time_spent = pi->pst_time;
717 +                        proc_state_ptr->cpu_percent = (pi->pst_pctcpu * 100.0) / 0x8000;
718 +                        proc_state_ptr->nice = pi->pst_nice;
719 +        
720 +                        if (sg_update_string(&proc_state_ptr->process_name,
721 +                                             pi->pst_ucomm) < 0) {
722 +                                return NULL;
723 +                        }
724 +                        if (sg_update_string(&proc_state_ptr->proctitle,
725 +                                             pi->pst_cmd) < 0) {
726 +                                return NULL;
727 +                        }
728 +        
729 +                        switch (pi->pst_stat) {
730 +                        case PS_SLEEP:
731 +                                proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
732 +                                break;
733 +                        case PS_RUN:
734 +                                proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
735 +                                break;
736 +                        case PS_STOP:
737 +                                proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
738 +                                break;
739 +                        case PS_ZOMBIE:
740 +                                proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
741 +                                break;
742 +                        case PS_IDLE:
743 +                        case PS_OTHER:
744 +                                proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
745 +                                break;
746 +                        }
747 +        
748 +                        proc_state_size++;
749 +                }
750 +                procidx = pstat_procinfo[num - 1].pst_idx + 1;
751 +        }
752 + #endif
753 +
754   #ifdef CYGWIN
755 +        sg_set_error(SG_ERROR_UNSUPPORTED, "Cygwin");
756          return NULL;
757   #endif
758  
# Line 663 | Line 802 | sg_process_count *sg_get_process_count() {
802  
803          return &process_stat;
804   }
805 +
806 + int sg_process_compare_name(const void *va, const void *vb) {
807 +        const sg_process_stats *a = (sg_process_stats *)va;
808 +        const sg_process_stats *b = (sg_process_stats *)vb;
809 +
810 +        return strcmp(a->process_name, b->process_name);
811 + }
812 +
813 + int sg_process_compare_pid(const void *va, const void *vb) {
814 +        const sg_process_stats *a = (sg_process_stats *)va;
815 +        const sg_process_stats *b = (sg_process_stats *)vb;
816 +
817 +        if (a->pid < b->pid) {
818 +                return -1;
819 +        } else if (a->pid == b->pid) {
820 +                return 0;
821 +        } else {
822 +                return 1;
823 +        }
824 + }
825 +
826 + int sg_process_compare_uid(const void *va, const void *vb) {
827 +        const sg_process_stats *a = (sg_process_stats *)va;
828 +        const sg_process_stats *b = (sg_process_stats *)vb;
829 +
830 +        if (a->uid < b->uid) {
831 +                return -1;
832 +        } else if (a->uid == b->uid) {
833 +                return 0;
834 +        } else {
835 +                return 1;
836 +        }
837 + }
838 +
839 + int sg_process_compare_gid(const void *va, const void *vb) {
840 +        const sg_process_stats *a = (sg_process_stats *)va;
841 +        const sg_process_stats *b = (sg_process_stats *)vb;
842 +
843 +        if (a->gid < b->gid) {
844 +                return -1;
845 +        } else if (a->gid == b->gid) {
846 +                return 0;
847 +        } else {
848 +                return 1;
849 +        }
850 + }
851 +
852 + int sg_process_compare_size(const void *va, const void *vb) {
853 +        const sg_process_stats *a = (sg_process_stats *)va;
854 +        const sg_process_stats *b = (sg_process_stats *)vb;
855 +
856 +        if (a->proc_size < b->proc_size) {
857 +                return -1;
858 +        } else if (a->proc_size == b->proc_size) {
859 +                return 0;
860 +        } else {
861 +                return 1;
862 +        }
863 + }
864 +
865 + int sg_process_compare_res(const void *va, const void *vb) {
866 +        const sg_process_stats *a = (sg_process_stats *)va;
867 +        const sg_process_stats *b = (sg_process_stats *)vb;
868 +
869 +        if (a->proc_resident < b->proc_resident) {
870 +                return -1;
871 +        } else if (a->proc_resident == b->proc_resident) {
872 +                return 0;
873 +        } else {
874 +                return 1;
875 +        }
876 + }
877 +
878 + int sg_process_compare_cpu(const void *va, const void *vb) {
879 +        const sg_process_stats *a = (sg_process_stats *)va;
880 +        const sg_process_stats *b = (sg_process_stats *)vb;
881 +
882 +        if (a->cpu_percent < b->cpu_percent) {
883 +                return -1;
884 +        } else if (a->cpu_percent == b->cpu_percent) {
885 +                return 0;
886 +        } else {
887 +                return 1;
888 +        }
889 + }
890 +
891 + int sg_process_compare_time(const void *va, const void *vb) {
892 +        const sg_process_stats *a = (sg_process_stats *)va;
893 +        const sg_process_stats *b = (sg_process_stats *)vb;
894 +
895 +        if (a->time_spent < b->time_spent) {
896 +                return -1;
897 +        } else if (a->time_spent == b->time_spent) {
898 +                return 0;
899 +        } else {
900 +                return 1;
901 +        }
902 + }
903 +

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines