| blob | 6ad37f2e592dcabc73462af042f5c27de21ccfa3 |
1 Existing patch from desktop for building on Solaris - Needs reworking and cleanup so this can be contributed upstream.
3 XXX file upstream enhancement
5 diff -urN libgtop-2.25.91/include/glibtop/procstate.h ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/include/glibtop/procstate.h
6 --- libgtop-2.25.91/include/glibtop/procstate.h 2008-05-23 22:13:20.000000000 +0000
7 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/include/glibtop/procstate.h 2009-02-25 17:16:38.052247000 +0000
8 @@ -69,6 +69,13 @@
9 int has_cpu;
10 int processor;
11 int last_processor;
12 +
13 + gint32 nice; /*zhua: used to store nice */
14 + guint64 start_time; /* start time of process -- */
15 + guint64 vsize; /* number of pages of virtual memory ... */
16 + guint64 resident; /* number of resident set */
17 + guint load; /* cpu load for process */
18 + gint32 ppid; /* pid of parent process */
19 };
21 void glibtop_get_proc_state(glibtop_proc_state *buf, pid_t pid);
22 diff -urN libgtop-2.25.91/procmap.c ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/procmap.c
23 --- libgtop-2.25.91/procmap.c 1970-01-01 00:00:00.000000000 +0000
24 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/procmap.c 2009-02-25 17:16:38.053079000 +0000
25 @@ -0,0 +1,252 @@
26 +/* Copyright (C) 1998-99 Martin Baulig
27 + This file is part of LibGTop 1.0.
28 +
29 + Contributed by Martin Baulig <martin@home-of-linux.org>, April 1998.
30 +
31 + LibGTop is free software; you can redistribute it and/or modify it
32 + under the terms of the GNU General Public License as published by
33 + the Free Software Foundation; either version 2 of the License,
34 + or (at your option) any later version.
35 +
36 + LibGTop is distributed in the hope that it will be useful, but WITHOUT
37 + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
38 + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
39 + for more details.
40 +
41 + You should have received a copy of the GNU General Public License
42 + along with LibGTop; see the file COPYING. If not, write to the
43 + Free Software Foundation, Inc., 59 Temple Place - Suite 330,
44 + Boston, MA 02111-1307, USA.
45 +*/
46 +
47 +
48 +#include <config.h>
49 +#include <glibtop.h>
50 +#include <glibtop/error.h>
51 +#include <glibtop/procmap.h>
52 +
53 +#include <errno.h>
54 +
55 +#include "safeio.h"
56 +
57 +
58 +static const unsigned long _glibtop_sysdeps_proc_map =
59 +(1L << GLIBTOP_PROC_MAP_NUMBER) + (1L << GLIBTOP_PROC_MAP_TOTAL) +
60 +(1L << GLIBTOP_PROC_MAP_SIZE);
61 +static const unsigned long _glibtop_sysdeps_map_entry =
62 +(1L << GLIBTOP_MAP_ENTRY_START) + (1L << GLIBTOP_MAP_ENTRY_END) +
63 +(1L << GLIBTOP_MAP_ENTRY_OFFSET) + (1L << GLIBTOP_MAP_ENTRY_PERM);
64 +static const unsigned long _glibtop_sysdeps_map_device =
65 +(1L << GLIBTOP_MAP_ENTRY_DEVICE) + (1L << GLIBTOP_MAP_ENTRY_INODE);
66 +
67 +
68 +/* Init function. */
69 +
70 +void
71 +_glibtop_init_proc_map_s (glibtop *server)
72 +{
73 + server->sysdeps.proc_map = _glibtop_sysdeps_proc_map;
74 +}
75 +
76 +/* Provides detailed information about a process. */
77 +
78 +glibtop_map_entry *
79 +glibtop_get_proc_map_s (glibtop *server, glibtop_proc_map *buf, pid_t pid)
80 +{
81 + int fd, i, nmaps, pr_err, heap;
82 +
83 + char filename [BUFSIZ];
84 + /* use flags as a check condition, if it is 1, check, or, not check... zhua */
85 + int check = buf->flags;
86 + /* set flags back to 0 */
87 + buf->flags = 0;
88 +
89 +#if GLIBTOP_SOLARIS_RELEASE >= 50600
90 + prxmap_t *maps;
91 +// struct ps_prochandle *Pr = NULL;
92 +#else
93 + prmap_t *maps;
94 +#endif
95 +
96 + /* A few defines, to make it shorter down there */
97 +
98 +#ifdef HAVE_PROCFS_H
99 +# define OFFSET pr_offset
100 +#else
101 +# define OFFSET pr_off
102 +#endif
103 +
104 + glibtop_map_entry *entry;
105 + struct stat inode;
106 + char buffer[BUFSIZ];
107 +
108 + memset (buf, 0, sizeof (glibtop_proc_map));
109 +
110 +#ifdef HAVE_PROCFS_H
111 + sprintf(buffer, "/proc/%d/xmap", (int)pid);
112 +#else
113 + sprintf(buffer, "/proc/%d", (int)pid);
114 +#endif
115 + if((fd = s_open(buffer, O_RDONLY)) < 0)
116 + {
117 + if (errno != EPERM && errno != EACCES)
118 + glibtop_warn_io_r(server, "open (%s)", buffer);
119 + return NULL;
120 + }
121 +#ifdef HAVE_PROCFS_H
122 + if(fstat(fd, &inode) < 0)
123 + {
124 + if(errno != EOVERFLOW)
125 + glibtop_warn_io_r(server, "fstat (%s)", buffer);
126 + /* else call daemon for 64-bit support */
127 + s_close(fd);
128 + return NULL;
129 + }
130 + maps = g_alloca(inode.st_size);
131 + nmaps = inode.st_size / sizeof(prxmap_t);
132 + if(s_pread(fd, maps, inode.st_size, 0) != inode.st_size)
133 + {
134 + glibtop_warn_io_r(server, "pread (%s)", buffer);
135 + s_close(fd);
136 + return NULL;
137 + }
138 +#else
139 + if(ioctl(fd, PIOCNMAP, &nmaps) < 0)
140 + {
141 + glibtop_warn_io_r(server, "ioctl(%s, PIOCNMAP)", buffer);
142 + s_close(fd);
143 + return NULL;
144 + }
145 + maps = g_alloca((nmaps + 1) * sizeof(prmap_t));
146 + if(ioctl(fd, PIOCMAP, maps) < 0)
147 + {
148 + glibtop_warn_io_r(server, "ioctl(%s, PIOCMAP)", buffer);
149 + s_close(fd);
150 + return NULL;
151 + }
152 +#endif
153 + buf->number = nmaps;
154 + buf->size = sizeof(glibtop_map_entry);
155 + buf->total = nmaps * sizeof(glibtop_map_entry);
156 + entry = g_malloc0(buf->total);
157 +
158 +//#if GLIBTOP_SOLARIS_RELEASE >= 50600
159 +
160 +// if(server->machine.objname && server->machine.pgrab &&
161 +// server->machine.pfree)
162 +// Pr = (server->machine.pgrab)(pid, 1, &pr_err);
163 +//#endif
164 + for(heap = 0,i = 0; i < nmaps; ++i)
165 + {
166 + int len;
167 +
168 + /* take a check to see if we need all information, if not, just get what we need..
169 + Also please see comments in get_process_memory_writable() of gnome-system-monitor zhua */
170 + if (check == 1)
171 + {
172 + if(maps[i].pr_mflags & MA_WRITE){
173 + entry[i].perm |= GLIBTOP_MAP_PERM_WRITE;
174 + entry[i].size = maps[i].pr_size;
175 + }
176 + if(maps[i].pr_mflags & MA_SHARED){
177 + entry[i].perm |= GLIBTOP_MAP_PERM_SHARED;
178 + /* here use shared_clean to store Shared Memory */
179 + entry[i].shared_clean = maps[i].pr_size;
180 + }
181 + }
182 + else
183 + if (check == 2)
184 + {
185 + if(maps[i].pr_mflags & MA_SHARED){
186 + entry[i].perm |= GLIBTOP_MAP_PERM_SHARED;
187 + /* here use shared_clean to store Shared Memory */
188 + entry[i].shared_clean = maps[i].pr_size;
189 + }
190 + }
191 + else {
192 +
193 + int len, rv;
194 +
195 +
196 + entry[i].start = maps[i].pr_vaddr;
197 + entry[i].end = maps[i].pr_vaddr + maps[i].pr_size;
198 +
199 +#if GLIBTOP_SOLARIS_RELEASE >= 50600
200 +
201 + if(maps[i].pr_dev != PRNODEV)
202 + {
203 + entry[i].device = maps[i].pr_dev;
204 + entry[i].inode = maps[i].pr_ino;
205 + entry[i].flags |= _glibtop_sysdeps_map_device;
206 + }
207 +#endif
208 + entry[i].offset = maps[i].OFFSET;
209 + if(maps[i].pr_mflags & MA_READ)
210 + entry[i].perm |= GLIBTOP_MAP_PERM_READ;
211 + if(maps[i].pr_mflags & MA_WRITE){
212 + entry[i].perm |= GLIBTOP_MAP_PERM_WRITE;
213 + entry[i].size = maps[i].pr_size;
214 + }
215 + if(maps[i].pr_mflags & MA_EXEC)
216 + entry[i].perm |= GLIBTOP_MAP_PERM_EXECUTE;
217 + if(maps[i].pr_mflags & MA_SHARED)
218 + entry[i].perm |= GLIBTOP_MAP_PERM_SHARED;
219 + else
220 + entry[i].perm |= GLIBTOP_MAP_PERM_PRIVATE;
221 + entry[i].flags = _glibtop_sysdeps_map_entry;
222 +
223 +#if GLIBTOP_SOLARIS_RELEASE >= 50600
224 +
225 + if(maps[i].pr_mflags & MA_ANON)
226 + {
227 + if(!heap)
228 + {
229 + ++heap;
230 + strcpy(entry[i].filename, "[ heap ]");
231 + }
232 + else
233 + if(i == nmaps - 1)
234 + strcpy(entry[i].filename, "[ stack ]");
235 + else
236 + strcpy(entry[i].filename, "[ anon ]");
237 + entry[i].flags |= (1L << GLIBTOP_MAP_ENTRY_FILENAME);
238 + }
239 + else
240 +// if(Pr)
241 +// {
242 +// server->machine.objname(Pr, maps[i].pr_vaddr, buffer,
243 +// BUFSIZ);
244 +// if((len = resolvepath(buffer, entry[i].filename,
245 +// GLIBTOP_MAP_FILENAME_LEN)) > 0)
246 +// {
247 +// entry[i].filename[len] = 0;
248 +// entry[i].flags |= (1L << GLIBTOP_MAP_ENTRY_FILENAME);
249 +// }
250 +// }
251 + {
252 + g_strlcpy(buffer, maps[i].pr_mapname, sizeof buffer);
253 + /* from /path get file name */
254 + g_snprintf(filename, sizeof filename, "/proc/%d/path/%s",
255 + pid, buffer);
256 +
257 + rv = readlink(filename, entry[i].filename, sizeof(entry[i].filename) - 1);
258 + /* read object, if have not, set it as NULL */
259 + if(rv < 0)
260 + rv = 0;
261 + entry[i].filename[rv] = '\0';
262 + /* now set the flags */
263 + entry[i].flags |= (1L << GLIBTOP_MAP_ENTRY_FILENAME);
264 + }
265 +#endif
266 + }
267 + }
268 +
269 +//#if GLIBTOP_SOLARIS_RELEASE >= 50600
270 +
271 +// if(Pr)
272 +// server->machine.pfree(Pr);
273 +//#endif
274 + buf->flags = _glibtop_sysdeps_proc_map;
275 + s_close(fd);
276 + return entry;
277 +}
278 diff -urN libgtop-2.25.91/sysdeps/common/fsusage.c ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/common/fsusage.c
279 --- libgtop-2.25.91/sysdeps/common/fsusage.c 2008-05-23 22:13:22.000000000 +0000
280 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/common/fsusage.c 2009-02-25 17:25:57.183257000 +0000
281 @@ -149,6 +149,15 @@
282 #define _glibtop_get_fsusage_read_write(S, B, P) \
283 _glibtop_freebsd_get_fsusage_read_write(S, B, P)
285 +#elif (defined(sun) || defined(__sun))
286 +G_GNUC_INTERNAL void
287 +_glibtop_sun_get_fsusage_read_write(glibtop *server,
288 + glibtop_fsusage *buf,
289 + const char *path);
290 +
291 +#define _glibtop_get_fsusage_read_write(S, B, P) \
292 + _glibtop_sun_get_fsusage_read_write(S, B, P)
293 +
294 #else /* default fallback */
295 #warning glibtop_get_fsusage .read .write are not implemented.
296 static inline void
297 diff -urN libgtop-2.25.91/sysdeps/common/mountlist.c ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/common/mountlist.c
298 --- libgtop-2.25.91/sysdeps/common/mountlist.c 2008-05-23 22:13:22.000000000 +0000
299 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/common/mountlist.c 2009-02-25 17:16:38.053543000 +0000
300 @@ -591,6 +591,17 @@
302 for (cur = &entries[0]; cur != NULL; cur = next) {
304 + /*zhua: delete these 2 type of fs: objfs,ctfs */
305 + if (!strcmp(cur->me_type, "objfs") || !strcmp(cur->me_type,"ctfs")){
306 + /* free current mount_entry and move to the next */
307 + next = cur->me_next;
308 + g_free(cur->me_devname);
309 + g_free(cur->me_mountdir);
310 + g_free(cur->me_type);
311 + g_free(cur);
312 + continue;
313 + }
314 +
315 if(all_fs || !ignore_mount_entry(cur)) {
316 /* add a new glibtop_mountentry */
317 glibtop_mountentry e;
318 diff -urN libgtop-2.25.91/sysdeps/solaris/Makefile.am ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/Makefile.am
319 --- libgtop-2.25.91/sysdeps/solaris/Makefile.am 2008-05-23 22:13:24.000000000 +0000
320 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/Makefile.am 2009-02-25 17:27:23.462319000 +0000
321 @@ -8,7 +8,8 @@
322 proclist.c procstate.c procuid.c \
323 proctime.c procmem.c procsignal.c \
324 prockernel.c procsegment.c procargs.c \
325 - procopenfiles.c \
326 + procopenfiles.c sysinfo.c fsusage.c procwd.c \
327 + glibtop_private.c procaffinity.c \
328 procmap.c netload.c ppp.c procdata.c netlist.c
330 libgtop_sysdeps_2_0_la_LDFLAGS = $(LT_VERSION_INFO)
331 diff -urN libgtop-2.25.91/sysdeps/solaris/cpu.c ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/cpu.c
332 --- libgtop-2.25.91/sysdeps/solaris/cpu.c 2008-05-23 22:13:24.000000000 +0000
333 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/cpu.c 2009-02-25 17:16:38.055204000 +0000
334 @@ -34,6 +34,7 @@
336 static const unsigned long _glibtop_sysdeps_cpu_all =
337 (1L << GLIBTOP_CPU_TOTAL) + (1L << GLIBTOP_CPU_USER) +
338 +(1L << GLIBTOP_CPU_NICE) + /* this value is needed by multiload */
339 (1L << GLIBTOP_CPU_SYS) + (1L << GLIBTOP_CPU_IDLE) +
340 (1L << GLIBTOP_XCPU_TOTAL) + (1L << GLIBTOP_XCPU_USER) +
341 (1L << GLIBTOP_XCPU_SYS) + (1L << GLIBTOP_XCPU_IDLE) +
342 diff -urN libgtop-2.25.91/sysdeps/solaris/fsusage.c ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/fsusage.c
343 --- libgtop-2.25.91/sysdeps/solaris/fsusage.c 1970-01-01 00:00:00.000000000 +0000
344 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/fsusage.c 2009-02-25 17:20:33.608888000 +0000
345 @@ -0,0 +1,99 @@
346 +#include <config.h>
347 +#include <glibtop.h>
348 +#include <glibtop/error.h>
349 +#include <glibtop/fsusage.h>
350 +#include <glibtop/union.h>
351 +
352 +#include "glibtop_private.h"
353 +
354 +#include <glib.h>
355 +
356 +#include <unistd.h>
357 +#include <kstat.h>
358 +#include <sys/types.h>
359 +#include <sys/stat.h>
360 +#include <sys/statvfs.h>
361 +
362 +#include <stdio.h>
363 +#include <string.h>
364 +#include <stdlib.h>
365 +
366 +G_GNUC_INTERNAL void
367 +_glibtop_sun_get_fsusage_read_write(glibtop *server,
368 + glibtop_fsusage *buf,
369 + const char *path)
370 +{
371 + struct statvfs64 statvfsbuf;
372 + char ksname[KSTAT_STRLEN + 1];
373 + kstat_ctl_t * const kctl = server->machine->kc;
374 + kstat_t *ksp;
375 + kstat_io_t kio;
376 + kstat_named_t *kread, *kwrite;
377 + int i;
378 +
379 + /*
380 + * get a kstat handle and update the user's kstat chain
381 + */
382 + if( kctl == NULL ){
383 + glibtop_warn_io_r (server, "kstat_open ()");
384 + return;
385 + }
386 +
387 + /* make sure we have current data */
388 + while( kstat_chain_update( kctl ) != 0 )
389 + ;
390 +
391 + for (ksp = kctl->kc_chain, i =0; ksp != NULL; ksp = ksp->ks_next, i++) {
392 + if (ksp->ks_type == KSTAT_TYPE_IO && strcmp(ksp->ks_class,"disk") == 0) {
393 + kstat_read(kctl, ksp, &kio);
394 + buf->read += kio.nread;
395 + buf->write += kio.nwritten;
396 + }
397 + }
398 +#if 0
399 + /* these codes keep here, because they are a good way to get the
400 + fsusage information, but at the moment, the interfaces used
401 + are not public or stable. so let's use them when public...
402 + */
403 + /*
404 + * get a kstat handle and update the user's kstat chain
405 + */
406 + if( kctl == NULL ){
407 + glibtop_warn_io_r (server, "kstat_open ()");
408 + return;
409 + }
410 +
411 + while( kstat_chain_update( kctl ) != 0 )
412 + ;
413 +
414 + if (statvfs64(path, &statvfsbuf) != 0) {
415 + glibtop_warn_io_r (server, "kstat_open ()");
416 + return;
417 + }
418 + snprintf(ksname, KSTAT_STRLEN, "%s%lx", VOPSTATS_STR,
419 + statvfsbuf.f_fsid);
420 +
421 + /*
422 + * traverse the kstat chain
423 + * to find the appropriate statistics
424 + */
425 + if( (ksp = kstat_lookup( kctl,
426 + "unix", 0, ksname )) == NULL ) {
427 + return;
428 + }
429 + if( kstat_read( kctl, ksp, NULL ) == -1 ) {
430 + return;
431 + }
432 +
433 + kread = (kstat_named_t *)kstat_data_lookup(ksp,"read_bytes");
434 + if( kread != NULL ) {
435 + buf->read = kread->value.ull;
436 + }
437 +
438 + kwrite = (kstat_named_t *)kstat_data_lookup(ksp,"write_bytes");
439 + if( kwrite != NULL ) {
440 + buf->write = kwrite->value.ull;
441 + }
442 +#endif
443 + buf->flags |= (1 << GLIBTOP_FSUSAGE_READ) | (1 << GLIBTOP_FSUSAGE_WRITE);
444 +}
445 diff -urN libgtop-2.25.91/sysdeps/solaris/glibtop_machine.h ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/glibtop_machine.h
446 --- libgtop-2.25.91/sysdeps/solaris/glibtop_machine.h 2008-05-23 22:13:24.000000000 +0000
447 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/glibtop_machine.h 2009-02-25 17:16:38.055426000 +0000
448 @@ -61,14 +61,14 @@
449 int pagesize; /* in bits to shift, ie. 2^pagesize gives Kb */
450 int ticks; /* clock ticks, as returned by sysconf() */
451 unsigned long long boot; /* boot time, although it's ui32 in kstat */
452 - void *libproc; /* libproc handle */
453 -#if GLIBTOP_SOLARIS_RELEASE >= 50600
454 - void (*objname)(void *, uintptr_t, const char *, size_t);
455 - struct ps_prochandle *(*pgrab)(pid_t, int, int *);
456 - void (*pfree)(void *);
457 -#else
458 +// void *libproc; /* libproc handle */
459 +//#if GLIBTOP_SOLARIS_RELEASE >= 50600
460 +// void (*objname)(void *, uintptr_t, const char *, size_t);
461 +// struct ps_prochandle *(*pgrab)(pid_t, int, int *);
462 +// void (*pfree)(void *);
463 +//#else
464 void *filler[3];
465 -#endif
466 +//#endif
467 };
469 G_END_DECLS
470 diff -urN libgtop-2.25.91/sysdeps/solaris/glibtop_private.c ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/glibtop_private.c
471 --- libgtop-2.25.91/sysdeps/solaris/glibtop_private.c 1970-01-01 00:00:00.000000000 +0000
472 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/glibtop_private.c 2009-02-25 17:16:38.055744000 +0000
473 @@ -0,0 +1,203 @@
474 +#include <config.h>
475 +#include <glibtop.h>
476 +#include <glibtop/error.h>
477 +
478 +#include "glibtop_private.h"
479 +
480 +#include <glib.h>
481 +
482 +#include <string.h>
483 +#include <stdlib.h>
484 +#include <stdarg.h>
485 +
486 +#include <fcntl.h>
487 +#include <unistd.h>
488 +
489 +#if 0
490 +unsigned long long
491 +get_scaled(const char *buffer, const char *key)
492 +{
493 + const char *ptr;
494 + char *next;
495 + unsigned long long value = 0;
496 +
497 + if (G_LIKELY((ptr = strstr(buffer, key))))
498 + {
499 + ptr += strlen(key);
500 + value = strtoull(ptr, &next, 0);
501 +
502 + for ( ; *next; ++next) {
503 + if (*next == 'k') {
504 + value *= 1024;
505 + break;
506 + } else if (*next == 'M') {
507 + value *= 1024 * 1024;
508 + break;
509 + }
510 + }
511 + } else
512 + g_warning("Could not read key '%s' in buffer '%s'",
513 + key, buffer);
514 +
515 + return value;
516 +}
517 +
518 +
519 +char *
520 +skip_token (const char *p)
521 +{
522 + p = next_token(p);
523 + while (*p && !isspace(*p)) p++;
524 + p = next_token(p);
525 + return (char *)p;
526 +}
527 +
528 +
529 +/*
530 + * Read functions
531 + */
532 +enum TRY_FILE_TO_BUFFER
533 +{
534 + TRY_FILE_TO_BUFFER_OK = 0,
535 + TRY_FILE_TO_BUFFER_OPEN = -1,
536 + TRY_FILE_TO_BUFFER_READ = -2
537 +};
538 +
539 +int try_file_to_buffer(char *buffer, const char *format, ...)
540 +{
541 + char path[4096];
542 + int fd;
543 + ssize_t len;
544 + va_list pa;
545 +
546 + va_start(pa, format);
547 +
548 + /* C99 also provides vsnprintf */
549 + g_vsnprintf(path, sizeof path, format, pa);
550 +
551 + va_end(pa);
552 +
553 + buffer [0] = '\0';
554 +
555 + if((fd = open (path, O_RDONLY)) < 0)
556 + return TRY_FILE_TO_BUFFER_OPEN;
557 +
558 + len = read (fd, buffer, BUFSIZ-1);
559 + close (fd);
560 +
561 + if (len < 0)
562 + return TRY_FILE_TO_BUFFER_READ;
563 +
564 + buffer [len] = '\0';
565 +
566 + return TRY_FILE_TO_BUFFER_OK;
567 +}
568 +
569 +
570 +void
571 +file_to_buffer(glibtop *server, char *buffer, const char *filename)
572 +{
573 + switch(try_file_to_buffer(buffer, filename))
574 + {
575 + case TRY_FILE_TO_BUFFER_OPEN:
576 + glibtop_error_io_r (server, "open (%s)", filename);
577 + case TRY_FILE_TO_BUFFER_READ:
578 + glibtop_error_io_r (server, "read (%s)", filename);
579 + }
580 +}
581 +
582 +
583 +
584 +
585 +static unsigned long
586 +read_boot_time(glibtop *server)
587 +{
588 + char buffer[BUFSIZ];
589 + char *btime;
590 +
591 + file_to_buffer(server, buffer, "/proc/stat");
592 +
593 + btime = strstr(buffer, "btime");
594 +
595 + if (!btime) {
596 + glibtop_warn_io_r(server, "cannot find btime in /proc/stat");
597 + return 0UL;
598 + }
599 +
600 + btime = skip_token(btime);
601 + return strtoul(btime, NULL, 10);
602 +}
603 +
604 +
605 +
606 +unsigned long
607 +get_boot_time(glibtop *server)
608 +{
609 + static unsigned long boot_time = 0UL;
610 +
611 + if(G_UNLIKELY(!boot_time))
612 + {
613 + boot_time = read_boot_time(server);
614 + }
615 +
616 + return boot_time;
617 +}
618 +
619 +
620 +size_t
621 +get_page_size(void)
622 +{
623 + static size_t pagesize = 0;
624 +
625 + if(G_UNLIKELY(!pagesize))
626 + {
627 + pagesize = getpagesize();
628 + }
629 +
630 + return pagesize;
631 +}
632 +
633 +
634 +
635 +gboolean
636 +check_cpu_line(glibtop *server, const char *line, unsigned i)
637 +{
638 + char start[10];
639 +
640 + g_snprintf(start, sizeof start, "cpu%u", i);
641 +
642 + return g_str_has_prefix(line, start);
643 +}
644 +
645 +
646 +
647 +gboolean
648 +has_sysfs(void)
649 +{
650 + static gboolean init;
651 + static gboolean sysfs;
652 +
653 + if (G_UNLIKELY(!init)) {
654 + sysfs = g_file_test("/sys", G_FILE_TEST_IS_DIR);
655 + init = TRUE;
656 + }
657 +
658 + return sysfs;
659 +}
660 +#endif
661 +
662 +
663 +gboolean safe_readlink(const char *path, char *buf, size_t bufsiz)
664 +{
665 + ssize_t ret;
666 +
667 + ret = readlink(path, buf, bufsiz - 1);
668 +
669 + if (ret == -1) {
670 + g_warning("Could not read link %s : %s", path, strerror(errno));
671 + return FALSE;
672 + }
673 +
674 + buf[ret] = '\0';
675 + return TRUE;
676 +}
677 diff -urN libgtop-2.25.91/sysdeps/solaris/glibtop_private.h ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/glibtop_private.h
678 --- libgtop-2.25.91/sysdeps/solaris/glibtop_private.h 2008-05-23 22:13:24.000000000 +0000
679 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/glibtop_private.h 2009-02-25 17:16:38.057019000 +0000
680 @@ -60,6 +60,8 @@
681 /* Reread kstat chains */
682 void glibtop_get_kstats(glibtop *);
684 +gboolean safe_readlink(const char *path, char *buf, size_t bufsiz);
685 +
686 G_END_DECLS
688 #endif /* __GLIBTOP_PRIVATE_H__ */
689 diff -urN libgtop-2.25.91/sysdeps/solaris/glibtop_server.h ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/glibtop_server.h
690 --- libgtop-2.25.91/sysdeps/solaris/glibtop_server.h 2008-05-23 22:13:24.000000000 +0000
691 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/glibtop_server.h 2009-02-25 17:16:38.057265000 +0000
692 @@ -29,9 +29,15 @@
693 #define GLIBTOP_SUID_SWAP 0
694 #define GLIBTOP_SUID_UPTIME 0
695 #define GLIBTOP_SUID_LOADAVG 0
696 +#if GLIBTOP_SOLARIS_RELEASE < 51000
697 #define GLIBTOP_SUID_SHM_LIMITS (1L << GLIBTOP_SYSDEPS_SHM_LIMITS)
698 #define GLIBTOP_SUID_MSG_LIMITS (1L << GLIBTOP_SYSDEPS_MSG_LIMITS)
699 #define GLIBTOP_SUID_SEM_LIMITS (1L << GLIBTOP_SYSDEPS_SEM_LIMITS)
700 +#else
701 +#define GLIBTOP_SUID_SHM_LIMITS 0
702 +#define GLIBTOP_SUID_MSG_LIMITS 0
703 +#define GLIBTOP_SUID_SEM_LIMITS 0
704 +#endif
705 #define GLIBTOP_SUID_PROCLIST 0
706 #define GLIBTOP_SUID_PROC_STATE 0
707 #define GLIBTOP_SUID_PROC_UID 0
708 @@ -44,7 +50,10 @@
709 #define GLIBTOP_SUID_PROC_MAP 0
710 #define GLIBTOP_SUID_NETLOAD 0
711 #define GLIBTOP_SUID_NETLIST 0
712 +#define GLIBTOP_SUID_PROC_WD 0
713 #define GLIBTOP_SUID_PPP 0
714 +#define GLIBTOP_SUID_PROC_AFFINITY 0
715 +
717 G_END_DECLS
719 diff -urN libgtop-2.25.91/sysdeps/solaris/msg_limits.c ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/msg_limits.c
720 --- libgtop-2.25.91/sysdeps/solaris/msg_limits.c 2008-05-23 22:13:24.000000000 +0000
721 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/msg_limits.c 2009-02-25 17:16:38.058081000 +0000
722 @@ -37,14 +37,24 @@
723 (1L << GLIBTOP_IPC_MSGMNB) + (1L << GLIBTOP_IPC_MSGMNI) +
724 (1L << GLIBTOP_IPC_MSGTQL);
725 #else
726 -static const unsigned long _glibtop_sysdeps_msg_limits = 0;
727 +static const unsigned long _glibtop_sysdeps_msg_limits =
728 +(1L << GLIBTOP_IPC_MSGMNB) +
729 +(1L << GLIBTOP_IPC_MSGMNI) +
730 +(1L << GLIBTOP_IPC_MSGMAX) +
731 +(1L << GLIBTOP_IPC_MSGPOOL) +
732 +(1L << GLIBTOP_IPC_MSGTQL);
733 #endif
736 /* Init function. */
738 +#if GLIBTOP_SUID_MSG_LIMITS
739 void
740 _glibtop_init_msg_limits_p (glibtop *server)
741 +#else
742 +void
743 +_glibtop_init_msg_limits_s (glibtop *server)
744 +#endif
745 {
746 #if GLIBTOP_SOLARIS_RELEASE < 51000
748 @@ -59,8 +69,13 @@
750 /* Provides information about sysv ipc limits. */
752 +#if GLIBTOP_SUID_MSG_LIMITS
753 void
754 glibtop_get_msg_limits_p (glibtop *server, glibtop_msg_limits *buf)
755 +#else
756 +void
757 +glibtop_get_msg_limits_s (glibtop *server, glibtop_msg_limits *buf)
758 +#endif
759 {
760 #if GLIBTOP_SOLARIS_RELEASE < 51000
762 diff -urN libgtop-2.25.91/sysdeps/solaris/netload.c ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/netload.c
763 --- libgtop-2.25.91/sysdeps/solaris/netload.c 2008-05-23 22:13:24.000000000 +0000
764 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/netload.c 2009-02-25 17:16:38.059013000 +0000
765 @@ -37,6 +37,17 @@
767 #include <net/if.h>
769 +#ifdef HAVE_IFADDRS_H
770 +/* needed for IPV6 support */
771 +
772 +#include <ifaddrs.h>
773 +
774 +#ifndef IN6_IS_ADDR_GLOBAL
775 +#define IN6_IS_ADDR_GLOBAL(a) \
776 + (((((__const uint8_t *) (a))[0] & 0xff) == 0x3f \
777 + || (((__const uint8_t *) (a))[0] & 0xff) == 0x20))
778 +#endif
779 +#endif /* HAVE_IFADDRS_H */
781 static const unsigned long _glibtop_sysdeps_netload =
782 (1L << GLIBTOP_NETLOAD_ERRORS_IN) +
783 @@ -89,6 +100,72 @@
784 _glibtop_sysdeps_netload_packets;
785 }
787 +#ifdef HAVE_IFADDRS_H
788 +
789 +static void get_ipv6(glibtop *server, glibtop_netload *buf,
790 + const char *interface)
791 +{
792 +/*
793 + * remove this code, because they are not available at Solaris, but keep them here for reference.
794 + * in fact, the function will not be called at Solaris, because HAVE_IFADDRS_H don't def.
795 + *
796 +*/
797 +#if 0
798 + struct ifaddrs *ifa0, *ifr6;
799 +
800 + if(getifaddrs (&ifa0) != 0)
801 + {
802 + glibtop_warn_r(server, "getifaddrs failed : %s", g_strerror(errno));
803 + return;
804 + }
805 +
806 + for (ifr6 = ifa0; ifr6; ifr6 = ifr6->ifa_next) {
807 + if (strcmp (ifr6->ifa_name, interface) == 0
808 + && ifr6->ifa_addr != NULL
809 + && ifr6->ifa_addr->sa_family == AF_INET6)
810 + break;
811 + }
812 +
813 + if(!ifr6) goto free_ipv6;
814 +
815 + memcpy(buf->address6,
816 + &((struct sockaddr_in6 *) ifr6->ifa_addr)->sin6_addr,
817 + 16);
818 +
819 + memcpy(buf->prefix6,
820 + &((struct sockaddr_in6 *) ifr6->ifa_netmask)->sin6_addr,
821 + 16);
822 +
823 +
824 + if (IN6_IS_ADDR_LINKLOCAL (buf->address6))
825 + buf->scope6 = GLIBTOP_IF_IN6_SCOPE_LINK;
826 +
827 + else if (IN6_IS_ADDR_SITELOCAL (buf->address6))
828 + buf->scope6 = GLIBTOP_IF_IN6_SCOPE_SITE;
829 +
830 + else if (IN6_IS_ADDR_GLOBAL (buf->address6)
831 + || IN6_IS_ADDR_MC_ORGLOCAL (buf->address6)
832 + || IN6_IS_ADDR_V4COMPAT (buf->address6)
833 + || IN6_IS_ADDR_MULTICAST (buf->address6)
834 + || IN6_IS_ADDR_UNSPECIFIED (buf->address6)
835 + )
836 + buf->scope6 = GLIBTOP_IF_IN6_SCOPE_GLOBAL;
837 +
838 + else if (IN6_IS_ADDR_LOOPBACK (buf->address6))
839 + buf->scope6 = GLIBTOP_IF_IN6_SCOPE_HOST;
840 +
841 + else
842 + buf->scope6 = GLIBTOP_IF_IN6_SCOPE_UNKNOWN;
843 +
844 + buf->flags |= _glibtop_sysdeps_netload_6;
845 +
846 + free_ipv6:
847 + freeifaddrs(ifa0);
848 +#endif
849 +}
850 +
851 +#endif /* HAVE_IFADDRS_H */
852 +
853 static int
854 solaris_stats(glibtop *server,
855 glibtop_netload *buf,
856 @@ -245,6 +322,13 @@
857 buf->subnet = ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr;
858 buf->flags |= (1L << GLIBTOP_NETLOAD_SUBNET);
859 }
860 +
861 +/* g_strlcpy (ifr.ifr_name, interface, sizeof ifr.ifr_name);
862 + if (!ioctl (skfd, SIOCGIFHWADDR, &ifr)) {
863 + memcpy(buf->hwaddress, &ifr.ifr_hwaddr.sa_data, 8);
864 + buf->flags |= (1L << GLIBTOP_NETLOAD_HWADDRESS);
865 + }*/
866 +
867 close (skfd);
868 }
870 @@ -254,4 +338,7 @@
872 solaris_stats(server, buf, interface);
874 +#ifdef HAVE_IFADDRS_H
875 + get_ipv6(server, buf, interface);
876 +#endif /* HAVE_IFADDRS_H */
877 }
878 diff -urN libgtop-2.25.91/sysdeps/solaris/procaffinity.c ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/procaffinity.c
879 --- libgtop-2.25.91/sysdeps/solaris/procaffinity.c 1970-01-01 00:00:00.000000000 +0000
880 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/procaffinity.c 2009-02-25 17:16:38.060320000 +0000
881 @@ -0,0 +1,84 @@
882 +/* Copyright (C) 2007 Joe Marcus Clarke <marcus@FreeBSD.org>
883 + This file is part of LibGTop 2.
884 +
885 + LibGTop is free software; you can redistribute it and/or modify it
886 + under the terms of the GNU General Public License as published by
887 + the Free Software Foundation; either version 2 of the License,
888 + or (at your option) any later version.
889 +
890 + LibGTop is distributed in the hope that it will be useful, but WITHOUT
891 + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
892 + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
893 + for more details.
894 +
895 + You should have received a copy of the GNU General Public License
896 + along with LibGTop; see the file COPYING. If not, write to the
897 + Free Software Foundation, Inc., 59 Temple Place - Suite 330,
898 + Boston, MA 02111-1307, USA.
899 +*/
900 +
901 +#include <config.h>
902 +#include <glibtop/procaffinity.h>
903 +#include <glibtop/error.h>
904 +
905 +#include <glibtop_private.h>
906 +
907 +#include <sys/param.h>
908 +
909 +void
910 +_glibtop_init_proc_affinity_s(glibtop *server)
911 +{
912 +/*
913 + server->sysdeps.proc_affinity =
914 + (1 << GLIBTOP_PROC_AFFINITY_NUMBER) |
915 + (1 << GLIBTOP_PROC_AFFINITY_ALL);
916 +*/
917 +}
918 +
919 +
920 +guint16 *
921 +glibtop_get_proc_affinity_s(glibtop *server, glibtop_proc_affinity *buf, pid_t pid)
922 +{
923 +/*
924 +#if __FreeBSD_version > 800024
925 + id_t id;
926 + cpulevel_t level;
927 + cpuwhich_t which;
928 + cpuset_t mask;
929 + size_t i;
930 + GArray* cpus;
931 +
932 + memset(buf, 0, sizeof *buf);
933 +
934 + which = CPU_WHICH_PID;
935 + level = CPU_LEVEL_WHICH;
936 + id = pid;
937 +
938 + if (cpuset_getaffinity(level, which, id, sizeof(mask), &mask) != 0) {
939 + glibtop_error_r(server, "cpuset_getaffinity failed");
940 + return NULL;
941 + }
942 +
943 + cpus = g_array_new(FALSE, FALSE, sizeof(guint16));
944 +
945 + for (i = 0; i < MIN(CPU_SETSIZE, (size_t)(server->ncpu + 1)); i++) {
946 + if (CPU_ISSET(i, &mask)) {
947 + guint16 n = i;
948 + g_array_append_val(cpus, n);
949 + }
950 + }
951 +
952 + buf->number = cpus->len;
953 + buf->all = (cpus->len == (size_t)(server->ncpu + 1));
954 + buf->flags = (1 << GLIBTOP_PROC_AFFINITY_NUMBER)
955 + | (1 << GLIBTOP_PROC_AFFINITY_ALL);
956 +
957 + return (guint16*) g_array_free(cpus, FALSE);
958 +#else
959 + memset(buf, 0, sizeof *buf);
960 +
961 + return NULL;
962 +#endif
963 +*/
964 +}
965 +
966 diff -urN libgtop-2.25.91/sysdeps/solaris/procmem.c ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/procmem.c
967 --- libgtop-2.25.91/sysdeps/solaris/procmem.c 2008-05-23 22:13:24.000000000 +0000
968 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/procmem.c 2009-02-25 17:16:38.061600000 +0000
969 @@ -22,12 +22,14 @@
970 #include <config.h>
971 #include <glibtop.h>
972 #include <glibtop/procmem.h>
973 +#include <glibtop/procmap.h>
975 #include "glibtop_private.h"
977 static const unsigned long _glibtop_sysdeps_proc_mem =
978 (1L << GLIBTOP_PROC_MEM_SIZE) + (1L << GLIBTOP_PROC_MEM_VSIZE) +
979 -(1L << GLIBTOP_PROC_MEM_RESIDENT) + (1L << GLIBTOP_PROC_MEM_RSS);
980 +(1L << GLIBTOP_PROC_MEM_RESIDENT) + (1L << GLIBTOP_PROC_MEM_RSS) +
981 +(1L << GLIBTOP_PROC_MEM_SHARE);
983 /* Init function. */
985 @@ -61,5 +63,31 @@
986 buf->size = buf->vsize = psinfo.pr_size << pagesize << 10;
987 buf->resident = buf->rss = psinfo.pr_rssize << pagesize << 10;
988 #endif
989 +/* get Shared Memory */
990 + glibtop_proc_map mapbuf;
991 + glibtop_map_entry *maps;
992 + unsigned i;
993 + buf->share = 0;
994 +
995 + /* we have to optimize the performance of libgtop, because update the information will occupy too much cpu.
996 +
997 + here I would like to make a little update:set glibtop_proc_map.flags=1,so as to let glibtop_get_proc_map_s()
998 + only return the ones this function need: memwritable
999 +
1000 + we do the check in glibtop_get_proc_map_s(), don't run the others part which don't need by this function,
1001 + I think this will accelerate the transaction lots,
1002 + Also this will not affect the existing codes, because when nobody set glibtop_proc_map.flags,
1003 + glibtop_get_proc_map() will return all as before. zhua
1004 + */
1005 + mapbuf.flags = 2;
1006 +
1007 + maps = glibtop_get_proc_map_s(server, &mapbuf, pid);
1008 +
1009 + for (i = 0; i < mapbuf.number; ++i) {
1010 + if (maps[i].perm & GLIBTOP_MAP_PERM_SHARED)
1011 + buf->share += maps[i].shared_clean;
1012 + }
1013 + g_free(maps);
1014 +
1015 buf->flags = _glibtop_sysdeps_proc_mem;
1016 }
1017 diff -urN libgtop-2.25.91/sysdeps/solaris/procstate.c ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/procstate.c
1018 --- libgtop-2.25.91/sysdeps/solaris/procstate.c 2008-05-23 22:13:24.000000000 +0000
1019 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/procstate.c 2009-02-25 17:16:38.062411000 +0000
1020 @@ -62,6 +62,26 @@
1021 buf->gid = psinfo.pr_egid;
1022 buf->ruid = psinfo.pr_uid;
1023 buf->rgid = psinfo.pr_gid;
1024 + /* zhua: get some value here, so that we don't need run open/pread/close psinfo later,
1025 + and can delete some other call for psinfo open/pread/close. it will save lots of time*/
1026 +#ifdef HAVE_PROCFS_H
1027 + buf->nice = psinfo.pr_lwp.pr_nice - NZERO;
1028 +#else
1029 + buf->nice = psinfo.pr_nice - NZERO;
1030 +#endif
1031 + buf->start_time = psinfo.pr_start.tv_sec;
1032 + buf->ppid = psinfo.pr_ppid;
1033 +
1034 +#ifdef HAVE_PROCFS_H
1035 + buf->vsize = psinfo.pr_size << 10;
1036 + buf->resident= psinfo.pr_rssize << 10;
1037 + buf->load = (guint) psinfo.pr_lwp.pr_pctcpu * 100 / (guint) 0x8000;
1038 +#else
1039 + buf->vsize = psinfo.pr_size << pagesize << 10;
1040 + buf->resident = psinfo.pr_rssize << pagesize << 10;
1041 + buf->load = (guint) psinfo.pr_lwp.pr_pctcpu * 100 / (guint) 0x8000;
1042 +#endif
1043 +
1045 #ifdef HAVE_PROCFS_H
1046 switch(psinfo.pr_lwp.pr_state)
1047 diff -urN libgtop-2.25.91/sysdeps/solaris/proctime.c ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/proctime.c
1048 --- libgtop-2.25.91/sysdeps/solaris/proctime.c 2008-05-23 22:13:24.000000000 +0000
1049 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/proctime.c 2009-02-25 17:16:38.062715000 +0000
1050 @@ -43,6 +43,11 @@
1051 glibtop_get_proc_time_s (glibtop *server, glibtop_proc_time *buf,
1052 pid_t pid)
1053 {
1054 +#ifdef HAVE_PROCFS_H
1055 + struct psinfo pinfo;
1056 +#else
1057 + struct prpsinfo pinfo;
1058 +#endif
1059 struct prusage prusage;
1060 GTimeVal time;
1062 @@ -52,19 +57,27 @@
1064 if(pid)
1065 {
1066 + /* zhua remove this function call, because we can change to get start_time in
1067 + glibtop_get_proc_state(), it don't need open psinfo again here */
1068 +
1069 + if (glibtop_get_proc_data_psinfo_s(server, &pinfo, pid))
1070 + return;
1071 + buf->start_time = pinfo.pr_start.tv_sec;
1072 +
1073 if (glibtop_get_proc_data_usage_s (server, &prusage, pid))
1074 return;
1076 - g_get_current_time (&time);
1077 - /* prusage.pr_rtime.tv_sec is the during that the process existed */
1078 - buf->start_time = time.tv_sec - prusage.pr_rtime.tv_sec;
1079 +// g_get_current_time (&time);
1080 +// /* prusage.pr_rtime.tv_sec is the during that the process existed */
1081 + // buf->start_time = time.tv_sec - prusage.pr_rtime.tv_sec;
1083 - buf->rtime = prusage.pr_rtime.tv_sec * 1E+6 +
1084 - prusage.pr_rtime.tv_nsec / 1E+3;
1085 +// buf->rtime = prusage.pr_rtime.tv_sec * 1E+6 +
1086 +// prusage.pr_rtime.tv_nsec / 1E+3;
1087 buf->utime = prusage.pr_utime.tv_sec * 1E+6 +
1088 prusage.pr_utime.tv_nsec / 1E+3;
1089 buf->stime = prusage.pr_stime.tv_sec * 1E+6 +
1090 prusage.pr_stime.tv_nsec / 1E+3;
1091 + buf->rtime = (buf->utime + buf->stime) / 10000;
1092 }
1094 buf->flags = _glibtop_sysdeps_proc_time;
1095 diff -urN libgtop-2.25.91/sysdeps/solaris/procwd.c ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/procwd.c
1096 --- libgtop-2.25.91/sysdeps/solaris/procwd.c 1970-01-01 00:00:00.000000000 +0000
1097 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/procwd.c 2009-02-25 17:16:38.062977000 +0000
1098 @@ -0,0 +1,98 @@
1099 +/* Copyright (C) 2007 Benoît Dejean
1100 + This file is part of LibGTop 2.
1101 +
1102 + LibGTop is free software; you can redistribute it and/or modify it
1103 + under the terms of the GNU General Public License as published by
1104 + the Free Software Foundation; either version 2 of the License,
1105 + or (at your option) any later version.
1106 +
1107 + LibGTop is distributed in the hope that it will be useful, but WITHOUT
1108 + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
1109 + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
1110 + for more details.
1111 +
1112 + You should have received a copy of the GNU General Public License
1113 + along with LibGTop; see the file COPYING. If not, write to the
1114 + Free Software Foundation, Inc., 59 Temple Place - Suite 330,
1115 + Boston, MA 02111-1307, USA.
1116 +*/
1117 +
1118 +#include <config.h>
1119 +#include <glibtop/procwd.h>
1120 +#include <glibtop/error.h>
1121 +
1122 +#include <glibtop_private.h>
1123 +
1124 +#include <unistd.h>
1125 +#include <dirent.h>
1126 +#include <sys/types.h>
1127 +
1128 +
1129 +void
1130 +_glibtop_init_proc_wd_s(glibtop *server)
1131 +{
1132 + server->sysdeps.proc_wd =
1133 + (1 << GLIBTOP_PROC_WD_EXE) +
1134 + (1 << GLIBTOP_PROC_WD_ROOT) +
1135 + (1 << GLIBTOP_PROC_WD_NUMBER);
1136 +
1137 +}
1138 +
1139 +static gboolean is_in(GPtrArray *array, const char *str)
1140 +{
1141 + guint i;
1142 +
1143 + for (i = 0; i != array->len; ++i) {
1144 + if (strcmp(g_ptr_array_index(array, i), str) == 0)
1145 + return TRUE;
1146 + }
1147 +
1148 + return FALSE;
1149 +}
1150 +
1151 +
1152 +char**
1153 +glibtop_get_proc_wd_s(glibtop *server, glibtop_proc_wd *buf, pid_t pid)
1154 +{
1155 + GPtrArray *dirs;
1156 + char path[80];
1157 + char dir[256];
1158 + DIR *task;
1159 +
1160 + glibtop_init_s(&server, GLIBTOP_SYSDEPS_PROC_WD, 0);
1161 +
1162 + memset(buf, 0, sizeof(glibtop_proc_wd));
1163 +
1164 + g_snprintf(path, sizeof path, "/proc/%u/root", pid);
1165 + if (safe_readlink(path, buf->root, sizeof buf->root))
1166 + buf->flags |= (1 << GLIBTOP_PROC_WD_ROOT);
1167 +
1168 + g_snprintf(path, sizeof path, "/proc/%u/exe", pid);
1169 + if (safe_readlink(path, buf->exe, sizeof buf->exe))
1170 + buf->flags |= (1 << GLIBTOP_PROC_WD_EXE);
1171 +
1172 + dirs = g_ptr_array_sized_new(2);
1173 +
1174 + g_snprintf(path, sizeof path, "/proc/%u/cwd", pid);
1175 + if (safe_readlink(path, dir, sizeof dir))
1176 + g_ptr_array_add(dirs, g_strdup(dir));
1177 +
1178 + g_snprintf(path, sizeof path, "/proc/%u/task", pid);
1179 + if ((task = opendir(path)) != NULL) {
1180 + struct dirent *sub;
1181 + while ((sub = readdir(task)) != NULL) {
1182 + g_snprintf(path, sizeof path, "/proc/%u/task/%s/cwd", pid, sub->d_name);
1183 + if (safe_readlink(path, dir, sizeof dir) && !is_in(dirs, dir))
1184 + g_ptr_array_add(dirs, g_strdup(dir));
1185 + }
1186 + closedir(task);
1187 + }
1188 +
1189 + buf->number = dirs->len;
1190 + buf->flags |= (1 << GLIBTOP_PROC_WD_NUMBER);
1191 +
1192 + g_ptr_array_add(dirs, NULL);
1193 +
1194 + return (char**) g_ptr_array_free(dirs, FALSE);
1195 +}
1196 +
1197 diff -urN libgtop-2.25.91/sysdeps/solaris/sem_limits.c ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/sem_limits.c
1198 --- libgtop-2.25.91/sysdeps/solaris/sem_limits.c 2008-05-23 22:13:24.000000000 +0000
1199 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/sem_limits.c 2009-02-25 17:16:38.063802000 +0000
1200 @@ -39,14 +39,22 @@
1201 (1L << GLIBTOP_IPC_SEMUSZ) + (1L << GLIBTOP_IPC_SEMVMX) +
1202 (1L << GLIBTOP_IPC_SEMAEM);
1203 #else
1204 -static const unsigned long _glibtop_sysdeps_sem_limits = 0;
1205 +static const unsigned long _glibtop_sysdeps_sem_limits =
1206 +(1L << GLIBTOP_IPC_SEMMNI) +
1207 +(1L << GLIBTOP_IPC_SEMMSL) +
1208 +(1L << GLIBTOP_IPC_SEMOPM);
1209 #endif
1212 /* Init function. */
1214 +#if GLIBTOP_SUID_SEM_LIMITS
1215 void
1216 _glibtop_init_sem_limits_p (glibtop *server)
1217 +#else
1218 +void
1219 +_glibtop_init_sem_limits_s (glibtop *server)
1220 +#endif
1221 {
1222 #if GLIBTOP_SOLARIS_RELEASE < 51000
1224 @@ -61,8 +69,13 @@
1226 /* Provides information about sysv sem limits. */
1228 +#if GLIBTOP_SUID_SEM_LIMITS
1229 void
1230 glibtop_get_sem_limits_p (glibtop *server, glibtop_sem_limits *buf)
1231 +#else
1232 +void
1233 +glibtop_get_sem_limits_s (glibtop *server, glibtop_sem_limits *buf)
1234 +#endif
1235 {
1236 #if GLIBTOP_SOLARIS_RELEASE < 51000
1237 kvm_t *kd = server->machine.kd;
1238 diff -urN libgtop-2.25.91/sysdeps/solaris/shm_limits.c ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/shm_limits.c
1239 --- libgtop-2.25.91/sysdeps/solaris/shm_limits.c 2008-05-23 22:13:24.000000000 +0000
1240 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/shm_limits.c 2009-02-25 17:16:38.064069000 +0000
1241 @@ -30,7 +30,9 @@
1242 static const struct nlist nlst[] = { {"glibtop_shm_limits"}, {NULL} };
1244 #if GLIBTOP_SOLARIS_RELEASE >=51000
1245 -static const unsigned long _glibtop_sysdeps_shm_limits = 0;
1246 +static const unsigned long _glibtop_sysdeps_shm_limits =
1247 +(1L << GLIBTOP_IPC_SHMMAX) +
1248 +(1L << GLIBTOP_IPC_SHMMIN);
1249 #else
1250 # if GLIBTOP_SOLARIS_RELEASE < 50900
1251 static const unsigned long _glibtop_sysdeps_shm_limits =
1252 @@ -45,8 +47,13 @@
1254 /* Init function. */
1256 +#if GLIBTOP_SUID_SHM_LIMITS
1257 void
1258 _glibtop_init_shm_limits_p (glibtop *server)
1259 +#else
1260 +void
1261 +_glibtop_init_shm_limits_s (glibtop *server)
1262 +#endif
1263 {
1264 #if GLIBTOP_SOLARIS_RELEASE < 51000
1266 @@ -61,8 +68,13 @@
1268 /* Provides information about sysv ipc limits. */
1270 +#if GLIBTOP_SUID_SHM_LIMITS
1271 void
1272 glibtop_get_shm_limits_p (glibtop *server, glibtop_shm_limits *buf)
1273 +#else
1274 +void
1275 +glibtop_get_shm_limits_s (glibtop *server, glibtop_shm_limits *buf)
1276 +#endif
1277 {
1278 #if GLIBTOP_SOLARIS_RELEASE < 51000
1280 diff -urN libgtop-2.25.91/sysdeps/solaris/siglist.c ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/siglist.c
1281 --- libgtop-2.25.91/sysdeps/solaris/siglist.c 2008-05-23 22:13:24.000000000 +0000
1282 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/siglist.c 2009-02-25 17:16:38.064867000 +0000
1283 @@ -61,6 +61,7 @@
1284 { 35, "SIGTHAW", "Checkpoint Thaw" },
1285 { 36, "SIGCANCEL","Thread Cancelation" },
1286 { 37, "SIGLOST", "Resource Lost" },
1287 +#if GLIBTOP_SOLARIS_RELEASE < 50900 /* S8 */
1288 { 38, "SIGRTMIN","First Realtime Signal" },
1289 { 39, "SIGRTMIN+1", "Second Realtime Signal" },
1290 { 40, "SIGRTMIN+2", "Third Realtime Signal" },
1291 @@ -69,5 +70,30 @@
1292 { 43, "SIGRTMAX-2", "Third Last Realtime Signal" },
1293 { 44, "SIGRTMAX-1", "Second Last Realtime Signal" },
1294 { 45, "SIGRTMAX", "Last Realtime Signal" },
1295 +#endif
1296 +#if GLIBTOP_SOLARIS_RELEASE >= 50900
1297 + { 38, "SIGXRES","Resource Control Exceeded" },
1298 +#if GLIBTOP_SOLARIS_RELEASE <51000 /* signal here existed in s9 */
1299 + { 39, "SIGRTMIN","First Realtime Signal" },
1300 + { 40, "SIGRTMIN+1", "Second Realtime Signal" },
1301 + { 41, "SIGRTMIN+2", "Third Realtime Signal" },
1302 + { 42, "SIGRTMIN+3", "Fourth Realtime Signal" },
1303 + { 43, "SIGRTMAX-3", "Fourth Last Realtime Signal" },
1304 + { 44, "SIGRTMAX-2", "Third Last Realtime Signal" },
1305 + { 45, "SIGRTMAX-1", "Second Last Realtime Signal" },
1306 + { 46, "SIGRTMAX", "Last Realtime Signal" },
1307 +#else /* signal here existed in s10 and s11 */
1308 + { 39, "SIGJVM1","Reserved signal for Java Virtual Machine" },
1309 + { 40, "SIGJVM1","Reserved signal for Java Virtual Machine" },
1310 + { 41, "SIGRTMIN","First Realtime Signal" },
1311 + { 42, "SIGRTMIN+1", "Second Realtime Signal" },
1312 + { 43, "SIGRTMIN+2", "Third Realtime Signal" },
1313 + { 44, "SIGRTMIN+3", "Fourth Realtime Signal" },
1314 + { 45, "SIGRTMAX-3", "Fourth Last Realtime Signal" },
1315 + { 46, "SIGRTMAX-2", "Third Last Realtime Signal" },
1316 + { 47, "SIGRTMAX-1", "Second Last Realtime Signal" },
1317 + { 48, "SIGRTMAX", "Last Realtime Signal" },
1318 +#endif
1319 +#endif
1320 { 0, NULL, NULL }
1321 };
1322 diff -urN libgtop-2.25.91/sysdeps/solaris/sysinfo.c ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/sysinfo.c
1323 --- libgtop-2.25.91/sysdeps/solaris/sysinfo.c 1970-01-01 00:00:00.000000000 +0000
1324 +++ ../SUNWlibgtop-2.25.91.hacked/libgtop-2.25.91/sysdeps/solaris/sysinfo.c 2009-02-25 17:16:38.065095000 +0000
1325 @@ -0,0 +1,48 @@
1326 +/* $Id: sysinfo.c,v 1.22 2004/11/28 01:32:55 bdejean Exp $ */
1327 +
1328 +/* Copyright (C) 1998-99 Martin Baulig
1329 + This file is part of LibGTop 1.0.
1330 +
1331 + Contributed by Martin Baulig <martin@home-of-linux.org>, April 1998.
1332 +
1333 + LibGTop is free software; you can redistribute it and/or modify it
1334 + under the terms of the GNU General Public License as published by
1335 + the Free Software Foundation; either version 2 of the License,
1336 + or (at your option) any later version.
1337 +
1338 + LibGTop is distributed in the hope that it will be useful, but WITHOUT
1339 + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
1340 + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
1341 + for more details.
1342 +
1343 + You should have received a copy of the GNU General Public License
1344 + along with LibGTop; see the file COPYING. If not, write to the
1345 + Free Software Foundation, Inc., 59 Temple Place - Suite 330,
1346 + Boston, MA 02111-1307, USA.
1347 +*/
1348 +
1349 +#include <config.h>
1350 +#include <glibtop/error.h>
1351 +#include <glibtop/cpu.h>
1352 +#include <glibtop/sysinfo.h>
1353 +
1354 +#include "glibtop_private.h"
1355 +
1356 +
1357 +static const unsigned long _glibtop_sysdeps_sysinfo =
1358 +(1L << GLIBTOP_SYSINFO_CPUINFO);
1359 +
1360 +static glibtop_sysinfo sysinfo = { .flags = 0 };
1361 +
1362 +static void
1363 +init_sysinfo (glibtop *server)
1364 +{
1365 +
1366 +}
1367 +
1368 +const glibtop_sysinfo *
1369 +glibtop_get_sysinfo_s (glibtop *server)
1370 +{
1371 + init_sysinfo (server);
1372 + return &sysinfo;
1373 +}
1374 --- a/sysdeps/solaris/open.c 2017-10-27 23:27:47.201639710 -0700
1375 +++ b/sysdeps/solaris/open.c 2017-10-27 23:29:13.969490610 -0700
1376 @@ -209,34 +209,34 @@
1377 }
1378 }
1380 - /* Now let's have a bit of magic dust... */
1381 +// /* Now let's have a bit of magic dust... */
1383 -#if GLIBTOP_SOLARIS_RELEASE >= 50600
1384 -
1385 - dl = dlopen("/usr/lib/libproc.so", RTLD_LAZY);
1386 - if(server->machine->libproc)
1387 - dlclose(server->machine->libproc);
1388 - server->machine->libproc = dl;
1389 - if(dl)
1390 - {
1391 - void *func;
1392 -
1393 - func = dlsym(dl, "Pobjname"); /* Solaris 8 */
1394 - if(!func)
1395 - func = dlsym(dl, "proc_objname"); /* Solaris 7 */
1396 - server->machine->objname = (void (*)
1397 - (void *, uintptr_t, const char *, size_t))func;
1398 - server->machine->pgrab = (struct ps_prochandle *(*)(pid_t, int, int *))
1399 - dlsym(dl, "Pgrab");
1400 - server->machine->pfree = (void (*)(void *))dlsym(dl, "Pfree");
1401 -
1402 - }
1403 - else
1404 - {
1405 - server->machine->objname = NULL;
1406 - server->machine->pgrab = NULL;
1407 - server->machine->pfree = NULL;
1408 - }
1409 -#endif
1410 +//#if GLIBTOP_SOLARIS_RELEASE >= 50600
1411 +//
1412 +// dl = dlopen("/usr/lib/libproc.so", RTLD_LAZY);
1413 +// if(server->machine->libproc)
1414 +// dlclose(server->machine->libproc);
1415 +// server->machine->libproc = dl;
1416 +// if(dl)
1417 +// {
1418 +// void *func;
1419 +//
1420 +// func = dlsym(dl, "Pobjname"); /* Solaris 8 */
1421 +// if(!func)
1422 +// func = dlsym(dl, "proc_objname"); /* Solaris 7 */
1423 +// server->machine->objname = (void (*)
1424 +// (void *, uintptr_t, const char *, size_t))func;
1425 +// server->machine->pgrab = (struct ps_prochandle *(*)(pid_t, int, int *))
1426 +// dlsym(dl, "Pgrab");
1427 +// server->machine->pfree = (void (*)(void *))dlsym(dl, "Pfree");
1428 +//
1429 +// }
1430 +// else
1431 +// {
1432 +// server->machine->objname = NULL;
1433 +// server->machine->pgrab = NULL;
1434 +// server->machine->pfree = NULL;
1435 +// }
1436 +//#endif
1437 server->machine->me = getpid();
1438 }
1439 --- a/glibtop.h 2017-10-27 20:32:08.852858820 -0700
1440 +++ b/glibtop.h 2017-10-27 20:32:18.170926960 -0700
1441 @@ -59,6 +59,7 @@
1442 #include <glibtop/global.h>
1444 #include <glibtop_server.h>
1445 +#include <glibtop_machine.h>
1447 #ifndef GLIBTOP_MOUNTENTRY_LEN
1448 #define GLIBTOP_MOUNTENTRY_LEN 79
1449 --- a/sysdeps/solaris/procmap.c 2017-10-26 16:14:15.708456884 -0700
1450 +++ b/sysdeps/solaris/procmap.c 2017-10-26 16:14:36.424701783 -0700
1451 @@ -54,9 +54,16 @@
1452 glibtop_get_proc_map_s (glibtop *server, glibtop_proc_map *buf, pid_t pid)
1453 {
1454 int fd, i, nmaps, pr_err, heap;
1455 +
1456 + char filename [BUFSIZ];
1457 + /* use flags as a check condition, if it is 1, check, or, not check... zhua */
1458 + int check = buf->flags;
1459 + /* set flags back to 0 */
1460 + buf->flags = 0;
1461 +
1462 #if GLIBTOP_SOLARIS_RELEASE >= 50600
1463 prxmap_t *maps;
1464 - struct ps_prochandle *Pr = NULL;
1465 +// struct ps_prochandle *Pr = NULL;
1466 #else
1467 prmap_t *maps;
1468 #endif
1469 @@ -123,16 +130,44 @@
1470 buf->total = nmaps * sizeof(glibtop_map_entry);
1471 entry = g_malloc0(buf->total);
1473 -#if GLIBTOP_SOLARIS_RELEASE >= 50600
1474 +//#if GLIBTOP_SOLARIS_RELEASE >= 50600
1476 - if(server->machine->objname && server->machine->pgrab &&
1477 - server->machine->pfree)
1478 - Pr = (server->machine->pgrab)(pid, 1, &pr_err);
1479 -#endif
1480 +// if(server->machine.objname && server->machine.pgrab &&
1481 +// server->machine.pfree)
1482 +// Pr = (server->machine.pgrab)(pid, 1, &pr_err);
1483 +//#endif
1484 for(heap = 0,i = 0; i < nmaps; ++i)
1485 {
1486 int len;
1488 + /* take a check to see if we need all information, if not, just get what we need..
1489 + Also please see comments in get_process_memory_writable() of gnome-system-monitor zhua */
1490 + if (check == 1)
1491 + {
1492 + if(maps[i].pr_mflags & MA_WRITE){
1493 + entry[i].perm |= GLIBTOP_MAP_PERM_WRITE;
1494 + entry[i].size = maps[i].pr_size;
1495 + }
1496 + if(maps[i].pr_mflags & MA_SHARED){
1497 + entry[i].perm |= GLIBTOP_MAP_PERM_SHARED;
1498 + /* here use shared_clean to store Shared Memory */
1499 + entry[i].shared_clean = maps[i].pr_size;
1500 + }
1501 + }
1502 + else
1503 + if (check == 2)
1504 + {
1505 + if(maps[i].pr_mflags & MA_SHARED){
1506 + entry[i].perm |= GLIBTOP_MAP_PERM_SHARED;
1507 + /* here use shared_clean to store Shared Memory */
1508 + entry[i].shared_clean = maps[i].pr_size;
1509 + }
1510 + }
1511 + else {
1512 +
1513 + int len, rv;
1514 +
1515 +
1516 entry[i].start = maps[i].pr_vaddr;
1517 entry[i].end = maps[i].pr_vaddr + maps[i].pr_size;
1519 @@ -177,25 +212,40 @@
1520 entry[i].flags |= (1L << GLIBTOP_MAP_ENTRY_FILENAME);
1521 }
1522 else
1523 - if(Pr)
1524 - {
1525 - server->machine->objname(Pr, maps[i].pr_vaddr, buffer,
1526 - BUFSIZ);
1527 - if((len = resolvepath(buffer, entry[i].filename,
1528 - GLIBTOP_MAP_FILENAME_LEN)) > 0)
1529 - {
1530 - entry[i].filename[len] = 0;
1531 - entry[i].flags |= (1L << GLIBTOP_MAP_ENTRY_FILENAME);
1532 - }
1533 - }
1534 +// if(Pr)
1535 +// {
1536 +// server->machine.objname(Pr, maps[i].pr_vaddr, buffer,
1537 +// BUFSIZ);
1538 +// if((len = resolvepath(buffer, entry[i].filename,
1539 +// GLIBTOP_MAP_FILENAME_LEN)) > 0)
1540 +// {
1541 +// entry[i].filename[len] = 0;
1542 +// entry[i].flags |= (1L << GLIBTOP_MAP_ENTRY_FILENAME);
1543 +// }
1544 +// }
1545 + {
1546 + g_strlcpy(buffer, maps[i].pr_mapname, sizeof buffer);
1547 + /* from /path get file name */
1548 + g_snprintf(filename, sizeof filename, "/proc/%d/path/%s",
1549 + pid, buffer);
1550 +
1551 + rv = readlink(filename, entry[i].filename, sizeof(entry[i].filename) - 1);
1552 + /* read object, if have not, set it as NULL */
1553 + if(rv < 0)
1554 + rv = 0;
1555 + entry[i].filename[rv] = '\0';
1556 + /* now set the flags */
1557 + entry[i].flags |= (1L << GLIBTOP_MAP_ENTRY_FILENAME);
1558 + }
1559 #endif
1560 }
1561 + }
1563 -#if GLIBTOP_SOLARIS_RELEASE >= 50600
1564 +//#if GLIBTOP_SOLARIS_RELEASE >= 50600
1566 - if(Pr)
1567 - server->machine->pfree(Pr);
1568 -#endif
1569 +// if(Pr)
1570 +// server->machine.pfree(Pr);
1571 +//#endif
1572 buf->flags = _glibtop_sysdeps_proc_map;
1573 s_close(fd);
1574 return entry;