ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/i-scream/projects/libstatgrab/src/libstatgrab/disk_stats.c

Comparing projects/libstatgrab/src/libstatgrab/disk_stats.c (file contents):
Revision 1.74 by ats, Mon Nov 1 20:36:46 2004 UTC vs.
Revision 1.81 by ats, Wed Apr 13 11:50:31 2005 UTC

#	Line 50 | Line 50
50		"ext3", "vxfs", "hfs", "hfsplus", "hpfs", "jffs", \
51		"jffs2", "minix", "msdos", "ntfs", "qnx4", "ramfs", \
52		"rootfs", "reiserfs", "sysv", "v7", "udf", "ufs", \
53	<	"umsdos", "vfat", "xfs", "jfs"}
53	>	"umsdos", "vfat", "xfs", "jfs", "nfs"}
54		#endif
55
56		#ifdef CYGWIN
#	Line 66 | Line 66
66		#include <sys/dkstat.h>
67		#include <devstat.h>
68		#define VALID_FS_TYPES {"hpfs", "msdosfs", "ntfs", "udf", "ext2fs", \
69	<	"ufs", "mfs"}
69	>	"ufs", "mfs", "nfs"}
70		#endif
71		#if defined(NETBSD) || defined(OPENBSD)
72		#include <sys/param.h>
73		#include <sys/sysctl.h>
74		#include <sys/disk.h>
75		#define VALID_FS_TYPES {"ffs", "mfs", "msdos", "lfs", "adosfs", "ext2fs", \
76	<	"ntfs"}
76	>	"ntfs", "nfs"}
77		#endif
78
79		#ifdef HPUX
#	Line 87 | Line 87
87		#include <stdio.h>
88		#include <time.h>
89		#define VALID_FS_TYPES {"vxfs", "hfs"}
90	+	#define DISK_BATCH 30
91		#endif
92
93		static void disk_stat_init(sg_fs_stats *d) {
#	Line 105 | Line 106 | static int is_valid_fs_type(const char *type) {
106		const char *types[] = VALID_FS_TYPES;
107		int i;
108
109	<	for (i = 0; i < (sizeof types / sizeof *types); i++) {
109	>	for (i = 0; i < (int) (sizeof types / sizeof *types); i++) {
110		if (strcmp(types[i], type) == 0) {
111		return 1;
112		}
#	Line 143 | Line 144 | sg_fs_stats *sg_get_fs_stats(int *entries){
144		#endif
145
146		#ifdef ALLBSD
147	<	nummnt=getmntinfo(&mp , MNT_LOCAL);
147	>	nummnt=getmntinfo(&mp, MNT_WAIT);
148		if (nummnt<=0){
149		sg_set_error_with_errno(SG_ERROR_GETMNTINFO, NULL);
150		return NULL;
#	Line 316 | Line 317 | sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
317		long long rbytes = 0, wbytes = 0;
318		struct dirent *dinfo = NULL;
319		struct stat lstatinfo;
320	<	struct pst_diskinfo pstat_diskinfo;
320	>	struct pst_diskinfo pstat_diskinfo[DISK_BATCH];
321		char fullpathbuf[1024] = {0};
322		dev_t diskid;
323		DIR *dh = NULL;
324	<	int disknum = 0;
324	>	int diskidx = 0;
325	>	int num, i;
326		#endif
327		#ifdef SOLARIS
328		kstat_ctl_t *kc;
#	Line 336 | Line 338 | sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
338		int i, n;
339		time_t now;
340		const char *format;
341	+	static regex_t not_part_re, part_re;
342	+	static int re_compiled = 0;
343		#endif
344		#if defined(FREEBSD) || defined(DFBSD)
345		static struct statinfo stats;
#	Line 370 | Line 374 | sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
374		num_diskio=0;
375
376		#ifdef HPUX
377	<
378	<	/* The "128" here is arbitrary, it can be increased to any number
379	<	at the expense of only more system calls to pstat(). */
380	<	for (disknum = 0; disknum < 128; disknum++) {
381	<	if (pstat_getdisk(&pstat_diskinfo, sizeof(pstat_diskinfo), 1, disknum) == -1) {
377	>	while (1) {
378	>	num = pstat_getdisk(pstat_diskinfo, sizeof pstat_diskinfo[0],
379	>	DISK_BATCH, diskidx);
380	>	if (num == -1) {
381	>	sg_set_error_with_errno(SG_ERROR_PSTAT,
382	>	"pstat_getdisk");
383	>	return NULL;
384	>	} else if (num == 0) {
385		break;
386		}
387
388	<	if (pstat_diskinfo.psd_idx != disknum) {
389	<	continue;
383	<	}
388	>	for (i = 0; i < num; i++) {
389	>	struct pst_diskinfo *di = &pstat_diskinfo[i];
390
391	<	/* Skip "disabled" disks.. */
392	<	if (pstat_diskinfo.psd_status == 0) {
387	<	continue;
388	<	}
389	<
390	<	/* We can't seperate the reads from the writes, we'll
391	<	just give the same to each. */
392	<	rbytes = wbytes = (pstat_diskinfo.psd_dkwds * 64);
393	<
394	<	/* Skip unused disks. */
395	<	if (rbytes == 0 && wbytes == 0) {
396	<	continue;
397	<	}
398	<
399	<	if (VECTOR_RESIZE(diskio_stats, num_diskio + 1) < 0) {
400	<	return NULL;
401	<	}
402	<
403	<	diskio_stats_ptr = diskio_stats + num_diskio;
404	<
405	<	diskio_stats_ptr->read_bytes = rbytes;
406	<	diskio_stats_ptr->write_bytes = wbytes;
407	<
408	<	diskio_stats_ptr->systime = time(NULL);
409	<
410	<	num_diskio++;
411	<
412	<	if (diskio_stats_ptr->disk_name == NULL) {
413	<	dh = opendir("/dev/dsk");
414	<	if (dh == NULL) {
391	>	/* Skip "disabled" disks. */
392	>	if (di->psd_status == 0) {
393		continue;
394		}
395	<
396	<	diskid = (pstat_diskinfo.psd_dev.psd_major << 24) | pstat_diskinfo.psd_dev.psd_minor;
397	<	while (1) {
398	<	dinfo = readdir(dh);
399	<	if (dinfo == NULL) {
400	<	break;
401	<	}
402	<	snprintf(fullpathbuf, sizeof(fullpathbuf), "/dev/dsk/%s", dinfo->d_name);
403	<	if (lstat(fullpathbuf, &lstatinfo) < 0) {
395	>
396	>	/* We can't seperate the reads from the writes, we'll
397	>	* just give the same to each. (This value is in
398	>	* 64-byte chunks according to the pstat header file,
399	>	* and can wrap to be negative.)
400	>	*/
401	>	rbytes = wbytes = ((unsigned long) di->psd_dkwds) * 64LL;
402	>
403	>	/* Skip unused disks. */
404	>	if (rbytes == 0 && wbytes == 0) {
405	>	continue;
406	>	}
407	>
408	>	if (VECTOR_RESIZE(diskio_stats, num_diskio + 1) < 0) {
409	>	return NULL;
410	>	}
411	>
412	>	diskio_stats_ptr = diskio_stats + num_diskio;
413	>
414	>	diskio_stats_ptr->read_bytes = rbytes;
415	>	diskio_stats_ptr->write_bytes = wbytes;
416	>
417	>	diskio_stats_ptr->systime = time(NULL);
418	>
419	>	num_diskio++;
420	>
421	>	/* FIXME This should use a static cache, like the Linux
422	>	* code below. */
423	>	if (diskio_stats_ptr->disk_name == NULL) {
424	>	dh = opendir("/dev/dsk");
425	>	if (dh == NULL) {
426		continue;
427		}
428	<
429	<	if (lstatinfo.st_rdev == diskid) {
430	<	if (sg_update_string(&diskio_stats_ptr->disk_name, dinfo->d_name) < 0) {
428	>
429	>	diskid = (di->psd_dev.psd_major << 24) | di->psd_dev.psd_minor;
430	>	while (1) {
431	>	dinfo = readdir(dh);
432	>	if (dinfo == NULL) {
433	>	break;
434	>	}
435	>	snprintf(fullpathbuf, sizeof(fullpathbuf), "/dev/dsk/%s", dinfo->d_name);
436	>	if (lstat(fullpathbuf, &lstatinfo) < 0) {
437	>	continue;
438	>	}
439	>
440	>	if (lstatinfo.st_rdev == diskid) {
441	>	if (sg_update_string(&diskio_stats_ptr->disk_name, dinfo->d_name) < 0) {
442	>	return NULL;
443	>	}
444	>	break;
445	>	}
446	>	}
447	>	closedir(dh);
448	>
449	>	if (diskio_stats_ptr->disk_name == NULL) {
450	>	if (sg_update_string(&diskio_stats_ptr->disk_name, di->psd_hw_path.psh_name) < 0) {
451		return NULL;
452		}
433	–	break;
453		}
454		}
436	–	closedir(dh);
437	–
438	–	if (diskio_stats_ptr->disk_name == NULL) {
439	–	if (sg_update_string(&diskio_stats_ptr->disk_name, pstat_diskinfo.psd_hw_path.psh_name) < 0) {
440	–	return NULL;
441	–	}
442	–	}
455		}
456	+	diskidx = pstat_diskinfo[num - 1].psd_idx + 1;
457		}
458		#endif
459		#ifdef OPENBSD
#	Line 688 | Line 701 | sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
701		if (f == NULL) goto out;
702		now = time(NULL);
703
704	+	if (!re_compiled) {
705	+	if (regcomp(&part_re, "^(.*/)?[^/]*[0-9]$", REG_EXTENDED | REG_NOSUB) != 0) {
706	+	sg_set_error(SG_ERROR_PARSE, NULL);
707	+	goto out;
708	+	}
709	+	if (regcomp(&not_part_re, "^(.*/)?[^/0-9]+[0-9]+d[0-9]+$", REG_EXTENDED | REG_NOSUB) != 0) {
710	+	sg_set_error(SG_ERROR_PARSE, NULL);
711	+	goto out;
712	+	}
713	+	re_compiled = 1;
714	+	}
715	+
716		while ((line_ptr = sg_f_read_line(f, "")) != NULL) {
717		char name[100];
693	–	char *s;
718		long long rsect, wsect;
719
720		int nr = sscanf(line_ptr, format,
#	Line 698 | Line 722 | sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
722		if (nr < 3) continue;
723
724		/* Skip device names ending in numbers, since they're
725	<	partitions. */
726	<	s = name;
727	<	while (*s != '\0') s++;
728	<	--s;
729	<	if (*s >= '0' && *s <= '9') continue;
725	>	partitions, unless they match the c0d0 pattern that some
726	>	RAID devices use. */
727	>	/* FIXME: For 2.6+, we should probably be using sysfs to detect
728	>	this... */
729	>	if ((regexec(&part_re, name, 0, NULL, 0) == 0)
730	>	&& (regexec(&not_part_re, name, 0, NULL, 0) != 0)) {
731	>	continue;
732	>	}
733
734		if (nr < 5) {
735		has_pp_stats = 0;

Diff Legend

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