src/sgps/sgps.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <strings.h>
#include <pwd.h>
#include "statgrab.h"

char *size_conv(long long number){
        char type[] = {'B', 'K', 'M', 'G', 'T'};
        int x=0;
        static char string[10];

        for(;x<5;x++){
                if( (number/1024) < (100)) {
                        break;
                }
                number = (number/1024);
        }

        snprintf(string, 10, "%lld%c", number, type[x]);        
        return string;
        
}

char *username(uid_t uid){
        static struct passwd *pass;

        pass = getpwuid(uid);
        if(pass == NULL){
                return "NULL";
        }

        return pass->pw_name;
}

char *proc_state(sg_process_state state){
        static char *pstat = "Unk";

        if(state == SG_PROCESS_STATE_RUNNING){
                pstat="Run";
        }

        if(state == SG_PROCESS_STATE_SLEEPING){
                pstat="Sleep";
        }

        if(state == SG_PROCESS_STATE_STOPPED){
                pstat="Stop";
        }

        if(state == SG_PROCESS_STATE_ZOMBIE){
                pstat="Zomb";
        }

        if(state == SG_PROCESS_STATE_UNKNOWN){
                pstat="Unk";
        }
        
        return pstat;
}

int main(int argc, char **argv){
        extern char *optarg;
        int c;
        int x;
        int full=0;
        int detailed=0;
        int nolookup=0;
        char *user = NULL;
 
        int (*sortby_ptr)(const void *va, const void *vb);

        int entries;
        extern char *optarg;


        sg_process_stats *sg_proc = NULL;
        /* Default behaviour - sort by pid */
        sortby_ptr = sg_process_compare_pid;

        while ((c = getopt(argc, argv, "neAfu:o:")) != -1){
                switch (c){
                        case 'e':
                        case 'A':
                                full=1;
                                break;
                        case 'f':
                                detailed=1;
                                break;
                        case 'n':
                                nolookup=1;
                                break;
                        case 'u':
                                user = strdup(optarg);
                                if (user == NULL) exit(1);
                                break;
                        case 'o':
                                if(!strncasecmp(optarg, "cpu", 3)){
                                        sortby_ptr = sg_process_compare_cpu;
                                        break;
                                }
                                if(!strncasecmp(optarg, "size", 3)){
                                        sortby_ptr = sg_process_compare_size;
                                        break;
                                }
                                if(!strncasecmp(optarg, "pid", 3)){
                                        sortby_ptr = sg_process_compare_pid;
                                        break;
                                }
                                if(!strncasecmp(optarg, "mem", 3)){
                                        sortby_ptr = sg_process_compare_res;
                                        break;
                                }
                                if(!strncasecmp(optarg, "res", 3)){
                                        sortby_ptr = sg_process_compare_res;
                                        break;
                                }
                                if(!strncasecmp(optarg, "uid", 3)){
                                        sortby_ptr = sg_process_compare_uid;
                                        break;
                                }
                                if(!strncasecmp(optarg, "gid", 3)){
                                        sortby_ptr = sg_process_compare_gid;
                                        break;
                                }
                        default:
                                sortby_ptr = sg_process_compare_cpu;
                                break;
                }
        }

        /* Get the procs - and sort them */
        sg_proc = sg_get_process_stats(&entries);
        qsort(sg_proc, entries, sizeof *sg_proc, sortby_ptr);

        if (full){ 
                printf("%9s %6s %6s %6s %7s %7s %4s %s\n", "User", "pid", "parent", "state", "size", "res", "CPU", "Process");
        }else{
                printf("%6s %7s %4s %s\n", "pid", "size", "CPU", "Process");
        }

        for(x=0; x<entries; x++){
                char *proc_out=NULL;
                if (detailed) {
                        proc_out = sg_proc->proctitle;
                }else{
                        proc_out = sg_proc->process_name;
                }

                if(full){
                        printf("%9s %6d %6d %6s %7s %7s %2.2f %s\n", username(sg_proc->uid), (int)sg_proc->pid, (int)sg_proc->parent, proc_state(sg_proc->state), size_conv(sg_proc->proc_size), size_conv(sg_proc->proc_resident), sg_proc->cpu_percent, proc_out);
                }else{
                        printf("%6d %7s %2.2f %s\n", (int)sg_proc->pid, size_conv(sg_proc->proc_size), sg_proc->cpu_percent, proc_out);
                }

                sg_proc++;
        }

        return 0;
}
Revision:	1.1
Committed:	Mon Apr 4 14:10:08 2005 UTC (19 years, 5 months ago) by pajs
Content type:	text/plain
Branch:	MAIN
Log Message:	Initial version. Only compiled on solaris - but seems to work. Makes use of efA flags, and also a 'o' flag for sorting.. ps -o cpu ps -o mem will sort by that type. Need to do the -n flag still (not look up names - although, is there much point to that?)
#	User	Rev	Content
1	pajs	1.1	#include <stdio.h>
2			#include <stdlib.h>
3			#include <unistd.h>
4			#include <strings.h>
5			#include <pwd.h>
6			#include "statgrab.h"
7
8			char *size_conv(long long number){
9			char type[] = {'B', 'K', 'M', 'G', 'T'};
10			int x=0;
11			static char string[10];
12
13			for(;x<5;x++){
14			if( (number/1024) < (100)) {
15			break;
16			}
17			number = (number/1024);
18			}
19
20			snprintf(string, 10, "%lld%c", number, type[x]);
21			return string;
22
23			}
24
25			char *username(uid_t uid){
26			static struct passwd *pass;
27
28			pass = getpwuid(uid);
29			if(pass == NULL){
30			return "NULL";
31			}
32
33			return pass->pw_name;
34			}
35
36			char *proc_state(sg_process_state state){
37			static char *pstat = "Unk";
38
39			if(state == SG_PROCESS_STATE_RUNNING){
40			pstat="Run";
41			}
42
43			if(state == SG_PROCESS_STATE_SLEEPING){
44			pstat="Sleep";
45			}
46
47			if(state == SG_PROCESS_STATE_STOPPED){
48			pstat="Stop";
49			}
50
51			if(state == SG_PROCESS_STATE_ZOMBIE){
52			pstat="Zomb";
53			}
54
55			if(state == SG_PROCESS_STATE_UNKNOWN){
56			pstat="Unk";
57			}
58
59			return pstat;
60			}
61
62			int main(int argc, char **argv){
63			extern char *optarg;
64			int c;
65			int x;
66			int full=0;
67			int detailed=0;
68			int nolookup=0;
69			char *user = NULL;
70
71			int (sortby_ptr)(const void va, const void *vb);
72
73			int entries;
74			extern char *optarg;
75
76
77			sg_process_stats *sg_proc = NULL;
78			/* Default behaviour - sort by pid */
79			sortby_ptr = sg_process_compare_pid;
80
81			while ((c = getopt(argc, argv, "neAfu:o:")) != -1){
82			switch (c){
83			case 'e':
84			case 'A':
85			full=1;
86			break;
87			case 'f':
88			detailed=1;
89			break;
90			case 'n':
91			nolookup=1;
92			break;
93			case 'u':
94			user = strdup(optarg);
95			if (user == NULL) exit(1);
96			break;
97			case 'o':
98			if(!strncasecmp(optarg, "cpu", 3)){
99			sortby_ptr = sg_process_compare_cpu;
100			break;
101			}
102			if(!strncasecmp(optarg, "size", 3)){
103			sortby_ptr = sg_process_compare_size;
104			break;
105			}
106			if(!strncasecmp(optarg, "pid", 3)){
107			sortby_ptr = sg_process_compare_pid;
108			break;
109			}
110			if(!strncasecmp(optarg, "mem", 3)){
111			sortby_ptr = sg_process_compare_res;
112			break;
113			}
114			if(!strncasecmp(optarg, "res", 3)){
115			sortby_ptr = sg_process_compare_res;
116			break;
117			}
118			if(!strncasecmp(optarg, "uid", 3)){
119			sortby_ptr = sg_process_compare_uid;
120			break;
121			}
122			if(!strncasecmp(optarg, "gid", 3)){
123			sortby_ptr = sg_process_compare_gid;
124			break;
125			}
126			default:
127			sortby_ptr = sg_process_compare_cpu;
128			break;
129			}
130			}
131
132			/* Get the procs - and sort them */
133			sg_proc = sg_get_process_stats(&entries);
134			qsort(sg_proc, entries, sizeof *sg_proc, sortby_ptr);
135
136			if (full){
137			printf("%9s %6s %6s %6s %7s %7s %4s %s\n", "User", "pid", "parent", "state", "size", "res", "CPU", "Process");
138			}else{
139			printf("%6s %7s %4s %s\n", "pid", "size", "CPU", "Process");
140			}
141
142			for(x=0; x<entries; x++){
143			char *proc_out=NULL;
144			if (detailed) {
145			proc_out = sg_proc->proctitle;
146			}else{
147			proc_out = sg_proc->process_name;
148			}
149
150			if(full){
151			printf("%9s %6d %6d %6s %7s %7s %2.2f %s\n", username(sg_proc->uid), (int)sg_proc->pid, (int)sg_proc->parent, proc_state(sg_proc->state), size_conv(sg_proc->proc_size), size_conv(sg_proc->proc_resident), sg_proc->cpu_percent, proc_out);
152			}else{
153			printf("%6d %7s %2.2f %s\n", (int)sg_proc->pid, size_conv(sg_proc->proc_size), sg_proc->cpu_percent, proc_out);
154			}
155
156			sg_proc++;
157			}
158
159			return 0;
160			}