- [DEV-147] Support of network and disk stats under OpenBSD

git-svn-id: svn://svn.zabbix.com/trunk@5652 97f52cf1-0a1b-0410-bd0e-c28be96e8082

9 files changed, 948 insertions, 1449 deletions

diff --git a/src/libs/zbxsysinfo/common/net.c b/src/libs/zbxsysinfo/common/net.c
index 818a19cd..5d3c7708 100644
--- a/src/libs/zbxsysinfo/common/net.c
+++ b/src/libs/zbxsysinfo/common/net.c
@@ -181,10 +181,8 @@ int	CHECK_PORT(const char *cmd, const char *param, unsigned flags, AGENT_RESULT
 	return ret;
 }
 
-
 int	CHECK_DNS(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
 {
-#if !defined(_WINDOWS)
 #ifdef HAVE_RES_QUERY
 
 #if !defined(PACKETSZ)
@@ -195,71 +193,51 @@ int	CHECK_DNS(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *
 #	define C_IN 	ns_c_in
 #endif /* C_IN */
 
-#if !defined(T_SOA)
-#	define T_SOA	ns_t_soa
-#endif /* T_SOA */
-
+#if !defined(T_ANY)
+#	define T_ANY	ns_t_any
+#endif /* T_ANY */
 
-	int	res;
-	char	ip[MAX_STRING_LEN];
-	char	zone[MAX_STRING_LEN];
+	int		res;
+	char		ip[MAX_STRING_LEN];
+	char		zone[MAX_STRING_LEN];
 #ifdef	PACKETSZ
-	char	respbuf[PACKETSZ];
+	unsigned char	respbuf[PACKETSZ];
 #else
-	char	respbuf[NS_PACKETSZ];
+	unsigned char	respbuf[NS_PACKETSZ];
 #endif
-	struct	in_addr in;
+	char	buf[MAX_STRING_LEN];
+	char	data[MAX_STRING_LEN];
 
-	/* extern char *h_errlist[]; */
-
-        assert(result);
+	assert(result);
 
         init_result(result);
 	
-        if(num_param(param) > 2)
-        {
+        if (num_param(param) > 2)
                 return SYSINFO_RET_FAIL;
-        }
         
-	if(get_param(param, 1, ip, MAX_STRING_LEN) != 0)
-        {
-               ip[0] = '\0';
-        }
-	
-	if(ip[0] == '\0')
-	{
+	if (0 != get_param(param, 1, ip, MAX_STRING_LEN))
+               *ip = '\0';
+
+	/* default parameter */
+	if (*ip == '\0')
 		strscpy(ip, "127.0.0.1");
-	}
 
-	if(get_param(param, 2, zone, MAX_STRING_LEN) != 0)
-        {
-                zone[0] = '\0';
-        }
+	if (0 != get_param(param, 2, zone, MAX_STRING_LEN))
+		*zone = '\0';
 
-	if(zone[0] == '\0')
-	{
+	/* default parameter */
+	if (*zone == '\0')
 		strscpy(zone, "localhost");
-	}
-
-	res = inet_aton(ip, &in);
-	if(res != 1)
-	{
-		SET_UI64_RESULT(result,0);
-		return SYSINFO_RET_FAIL;
-	}
 
-	res_init();
+	if (!(_res.options & RES_INIT))
+		res_init();
 
-	res = res_query(zone, C_IN, T_SOA, (unsigned char *)respbuf, sizeof(respbuf));
+	res = res_query(zone, C_IN, T_ANY, respbuf, sizeof(respbuf));
 
 	SET_UI64_RESULT(result, res != -1 ? 1 : 0);
 
 	return SYSINFO_RET_OK;
-#else
-	return SYSINFO_RET_FAIL;
-#endif /* not HAVE_RES_QUERY */
-	return SYSINFO_RET_FAIL;
-#else
+#endif /* HAVE_RES_QUERY */
+
 	return SYSINFO_RET_FAIL;
-#endif /* not WINDOWS */
 }
diff --git a/src/libs/zbxsysinfo/openbsd/cpu.c b/src/libs/zbxsysinfo/openbsd/cpu.c
index 2f679929..31189034 100644
--- a/src/libs/zbxsysinfo/openbsd/cpu.c
+++ b/src/libs/zbxsysinfo/openbsd/cpu.c
@@ -34,18 +34,21 @@ int	SYSTEM_CPU_NUM(const char *cmd, const char *param, unsigned flags, AGENT_RES
 	if (num_param(param) > 1)
 		return SYSINFO_RET_FAIL;
 
-	if (0 == get_param(param, 1, mode, sizeof(mode))) {
-		if (*mode != '\0') {
-			if (0 != strcmp(mode, "online"))
-				return SYSINFO_RET_FAIL;
-		}
-	}
+	if (0 != get_param(param, 1, mode, sizeof(mode)))
+		*mode = '\0';
+
+	if (*mode == '\0')
+		zbx_snprintf(mode, sizeof(mode), "online");
+
+	if (0 != strcmp(mode, "online"))
+		return SYSINFO_RET_FAIL;
 
 	mib[0] = CTL_HW;
 	mib[1] = HW_NCPU;
 
 	len = sizeof(ncpu);
-	if (-1 == sysctl(mib, 2, &ncpu, &len, NULL, 0))
+
+	if (0 != sysctl(mib, 2, &ncpu, &len, NULL, 0))
 		return SYSINFO_RET_FAIL;
 
 	SET_UI64_RESULT(result, ncpu);
diff --git a/src/libs/zbxsysinfo/openbsd/diskio.c b/src/libs/zbxsysinfo/openbsd/diskio.c
index 15c3f0db..96c05d8a 100644
--- a/src/libs/zbxsysinfo/openbsd/diskio.c
+++ b/src/libs/zbxsysinfo/openbsd/diskio.c
@@ -21,174 +21,114 @@
 
 #include "sysinfo.h"
 
-/*
-static int get_disk_stats(const char *device, struct diskstats *result)
+static int get_disk_stats(const char *devname, zbx_uint64_t *rbytes, zbx_uint64_t *wbytes, zbx_uint64_t *roper, zbx_uint64_t *woper)
 {
-	int ret = SYSINFO_RET_FAIL;
-	int mib[2];
-	int drive_count;
-	size_t l; 
-	struct diskstats *stats;
-	int i;
+	int			ret = SYSINFO_RET_FAIL, mib[2], drive_count;
+	size_t			len;
+	struct diskstats	*stats;
+	int			i;
 
 	mib[0] = CTL_HW;
 	mib[1] = HW_DISKCOUNT;
 
-	l = sizeof(drive_count);
+	len = sizeof(drive_count);
 
-	if (sysctl(mib, 2, &drive_count, &l, NULL, 0) == 0 ) 
-	{
-		l = (drive_count * sizeof(struct diskstats));
-		stats = calloc(drive_count, l);
-		if (stats)
-		{
-			mib[0] = CTL_HW;
-			mib[1] = HW_DISKSTATS;
- 
-			if (sysctl(mib, 2, stats, &l, NULL, 0) == 0)
-			{
-				for (i = 0; i < drive_count; i++)
-				{
-					if (strcmp(device, stats[i].ds_name) == 0)
-					{
-						memmove(result, &stats[i], sizeof(struct diskstats));
-						ret = SYSINFO_RET_OK;
-						break;
-					}
-				}
-			}
+	if (0 != sysctl(mib, 2, &drive_count, &len, NULL, 0)) 
+		return SYSINFO_RET_FAIL;
+
+	len = (drive_count * sizeof(struct diskstats));
+
+	if (NULL == (stats = calloc(drive_count, len)))
+		return SYSINFO_RET_FAIL;
 
-			free(stats);
+	mib[0] = CTL_HW;
+	mib[1] = HW_DISKSTATS;
+
+	if (rbytes)
+		*rbytes = 0;
+	if (wbytes)
+		*wbytes = 0;
+	if (roper)
+		*roper = 0;
+	if (woper)
+		*woper = 0;
+
+	if (0 == sysctl(mib, 2, stats, &len, NULL, 0)) {
+		for (i = 0; i < drive_count; i++) {
+			if (0 == strcmp(devname, "all") || 0 == strcmp(devname, stats[i].ds_name)) {
+				if (rbytes)
+					*rbytes += stats[i].ds_rbytes;
+				if (wbytes)
+					*wbytes += stats[i].ds_wbytes;
+				if (roper)
+					*roper += stats[i].ds_rxfer;
+				if (woper)
+					*woper += stats[i].ds_wxfer;
+				ret = SYSINFO_RET_OK;
+			}
 		}
 	}
+
+	free(stats);
+
 	return ret;
 }
-*/
 
-static int	VFS_DEV_READ_BYTES(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	VFS_DEV_READ_BYTES(const char *devname, AGENT_RESULT *result)
 {
-/*	char devname[MAX_STRING_LEN];
-	struct diskstats ds;*/
-	int ret = SYSINFO_RET_FAIL;
-        
-	assert(result);
+	zbx_uint64_t	value;
 
-        init_result(result);
-/*	
-        if(num_param(param) > 1)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-
-        if(get_param(param, 1, devname, MAX_STRING_LEN) != 0)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-	
-	if(get_disk_stats(devname, &ds) == SYSINFO_RET_OK)
-	{
-		SET_UI64_RESULT(result,  ds.ds_rbytes);
-		ret = SYSINFO_RET_OK;
-	}
-*/
-	return ret;
+	if (SYSINFO_RET_OK != get_disk_stats(devname, &value, NULL, NULL, NULL))
+		return SYSINFO_RET_FAIL;
+
+	SET_UI64_RESULT(result, value);
+
+	return SYSINFO_RET_OK;
 }
 
-static int	VFS_DEV_READ_OPERATIONS(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	VFS_DEV_READ_OPERATIONS(const char *devname, AGENT_RESULT *result)
 {
-/*	char devname[MAX_STRING_LEN];
-	struct diskstats ds;*/
-	int ret = SYSINFO_RET_FAIL;
-        
-	assert(result);
+	zbx_uint64_t	value;
 
-        init_result(result);
-/*	
-        if(num_param(param) > 1)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-
-        if(get_param(param, 1, devname, MAX_STRING_LEN) != 0)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-	
-	if(get_disk_stats(devname, &ds) == SYSINFO_RET_OK)
-	{
-		SET_UI64_RESULT(result, ds.ds_rxfer);
-		ret = SYSINFO_RET_OK;
-	}
-*/	
-	return ret;
+	if (SYSINFO_RET_OK != get_disk_stats(devname, NULL, NULL, &value, NULL))
+		return SYSINFO_RET_FAIL;
+
+	SET_UI64_RESULT(result, value);
+
+	return SYSINFO_RET_OK;
 }
 
-static int	VFS_DEV_WRITE_BYTES(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	VFS_DEV_WRITE_BYTES(const char *devname, AGENT_RESULT *result)
 {
-/*	char devname[MAX_STRING_LEN];
-	struct diskstats ds;*/
-	int ret = SYSINFO_RET_FAIL;
-        
-	assert(result);
+	zbx_uint64_t	value;
 
-        init_result(result);
-/*	
-        if(num_param(param) > 1)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-
-        if(get_param(param, 1, devname, MAX_STRING_LEN) != 0)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-	
-	if(get_disk_stats(devname, &ds) == SYSINFO_RET_OK)
-	{
-		SET_UI64_RESULT(result, ds.ds_wbytes);
-		ret = SYSINFO_RET_OK;
-	}
-*/	
-	return ret;
+	if (SYSINFO_RET_OK != get_disk_stats(devname, NULL, &value, NULL, NULL))
+		return SYSINFO_RET_FAIL;
+
+	SET_UI64_RESULT(result, value);
+
+	return SYSINFO_RET_OK;
 }
 
-static int	VFS_DEV_WRITE_OPERATIONS(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	VFS_DEV_WRITE_OPERATIONS(const char *devname, AGENT_RESULT *result)
 {
-/*	char devname[MAX_STRING_LEN];
-	struct diskstats ds; */
-	int ret = SYSINFO_RET_FAIL;
-/*       
-	assert(result);
+	zbx_uint64_t	value;
 
-        init_result(result);
-	
-        if(num_param(param) > 1)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-
-        if(get_param(param, 1, devname, MAX_STRING_LEN) != 0)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-	
-	if(get_disk_stats(devname, &ds) == SYSINFO_RET_OK)
-	{
-		SET_UI64_RESULT(result, ds.ds_wxfer);
-		ret = SYSINFO_RET_OK;
-	}
-*/	
-	return ret;
+	if (SYSINFO_RET_OK != get_disk_stats(devname, NULL, NULL, NULL, &value))
+		return SYSINFO_RET_FAIL;
+
+	SET_UI64_RESULT(result, value);
+
+	return SYSINFO_RET_OK;
 }
 
 int	VFS_DEV_WRITE(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
 {
-
 #define DEV_FNCLIST struct dev_fnclist_s
 DEV_FNCLIST
 {
-	char *mode;
-	int (*function)();
+	char	*mode;
+	int	(*function)();
 };
 
 	DEV_FNCLIST fl[] = 
@@ -198,49 +138,40 @@ DEV_FNCLIST
 		{0,		0}
 	};
 
-	char devname[MAX_STRING_LEN];
-	char mode[MAX_STRING_LEN];
-	int i;
+	char	devname[MAX_STRING_LEN];
+	char	mode[MAX_STRING_LEN];
+	int	i;
 	
-        assert(result);
+	assert(result);
 
-        init_result(result);
+	init_result(result);
 	
-        if(num_param(param) > 3)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-
-        if(get_param(param, 1, devname, sizeof(devname)) != 0)
-        {
-                return SYSINFO_RET_FAIL;
-        }
+	if (num_param(param) > 3)
+		return SYSINFO_RET_FAIL;
+
+	if (0 != get_param(param, 1, devname, sizeof(devname)))
+		*devname = '\0';
 	
-	if(get_param(param, 2, mode, sizeof(mode)) != 0)
-        {
-                mode[0] = '\0';
-        }
+	/* default parameter */
+	if (*devname == '\0')
+		zbx_snprintf(devname, sizeof(devname), "all");
+
+	if (0 != get_param(param, 2, mode, sizeof(mode)))
+		*mode = '\0';
+
+	/* default parameter */
+	if (*mode == '\0')
+		zbx_snprintf(mode, sizeof(mode), "operations");
 	
-        if(mode[0] == '\0')
-	{
-		/* default parameter */
-		zbx_snprintf(mode, sizeof(mode), "%s", fl[0].mode);
-	}
-	
-	for(i=0; fl[i].mode!=0; i++)
-	{
-		if(strncmp(mode, fl[i].mode, MAX_STRING_LEN)==0)
-		{
-			return (fl[i].function)(cmd, devname, flags, result);
-		}
-	}
+	for (i = 0; fl[i].mode != 0; i++)
+		if (0 == strncmp(mode, fl[i].mode, MAX_STRING_LEN))
+			return (fl[i].function)(devname, result);
 	
 	return SYSINFO_RET_FAIL;
 }
 
 int	VFS_DEV_READ(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
 {
-
 #define DEV_FNCLIST struct dev_fnclist_s
 DEV_FNCLIST
 {
@@ -255,135 +186,34 @@ DEV_FNCLIST
 		{0,		0}
 	};
 
-	char devname[MAX_STRING_LEN];
-	char mode[MAX_STRING_LEN];
-	int i;
+	char	devname[MAX_STRING_LEN];
+	char	mode[MAX_STRING_LEN];
+	int	i;
 	
-        assert(result);
+	assert(result);
 
-        init_result(result);
-	
-        if(num_param(param) > 3)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-
-        if(get_param(param, 1, devname, sizeof(devname)) != 0)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-	
-	if(get_param(param, 2, mode, sizeof(mode)) != 0)
-        {
-                mode[0] = '\0';
-        }
-	
-        if(mode[0] == '\0')
-	{
-		/* default parameter */
-		zbx_snprintf(mode, sizeof(mode), "%s", fl[0].mode);
-	}
-	
-	for(i=0; fl[i].mode!=0; i++)
-	{
-		if(strncmp(mode, fl[i].mode, MAX_STRING_LEN)==0)
-		{
-			return (fl[i].function)(cmd, devname, flags, result);
-		}
-	}
+	init_result(result);
 	
-	return SYSINFO_RET_FAIL;
-}
-
-static int	DISK_IO(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
-{
-#ifdef	HAVE_PROC
-	return	getPROC("/proc/stat",2,2, flags, result);
-#else
-	return	SYSINFO_RET_FAIL;
-#endif
-}
-
-static int	DISK_RIO(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
-{
-#ifdef	HAVE_PROC
-	return	getPROC("/proc/stat",3,2, flags, result);
-#else
-	return	SYSINFO_RET_FAIL;
-#endif
-}
-
-static int	DISK_WIO(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
-{
-#ifdef	HAVE_PROC
-	return	getPROC("/proc/stat",4,2, flags, result);
-#else
-	return	SYSINFO_RET_FAIL;
-#endif
-}
-
-static int	DISK_RBLK(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
-{
-#ifdef	HAVE_PROC
-	return	getPROC("/proc/stat",5,2, flags, result);
-#else
-	return	SYSINFO_RET_FAIL;
-#endif
-}
-
-static int	DISK_WBLK(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
-{
-#ifdef	HAVE_PROC
-	return	getPROC("/proc/stat",6,2, flags, result);
-#else
-	return	SYSINFO_RET_FAIL;
-#endif
-}
-
-int	OLD_IO(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
-{
-	char    key[MAX_STRING_LEN];
-	int 	ret;
+	if (num_param(param) > 3)
+		return SYSINFO_RET_FAIL;
 
-	assert(result);
+	if (0 != get_param(param, 1, devname, sizeof(devname)))
+		*devname = '\0';
 
-        init_result(result);
+	/* default parameter */
+	if (*devname == '\0')
+		zbx_snprintf(devname, sizeof(devname), "all");
 
-        if(num_param(param) > 1)
-        {
-                return SYSINFO_RET_FAIL;
-        }
+	if (0 != get_param(param, 2, mode, sizeof(mode)) != 0)
+		*mode = '\0';
 
-        if(get_param(param, 1, key, MAX_STRING_LEN) != 0)
-        {
-                return SYSINFO_RET_FAIL;
-        }
+	/* default parameter */
+	if (*mode == '\0')
+		zbx_snprintf(mode, sizeof(mode), "operations");
 
-	if(strcmp(key,"disk_io") == 0)
-	{
-		ret = DISK_IO(cmd, param, flags, result);
-	}
-	else if(strcmp(key,"disk_rio") == 0)
-	{
-		ret = DISK_RIO(cmd, param, flags, result);
-	}
-	else if(strcmp(key,"disk_wio") == 0)
-	{
-		ret = DISK_WIO(cmd, param, flags, result);
-	}
-    	else if(strcmp(key,"disk_rblk") == 0)
-	{
-		ret = DISK_RBLK(cmd, param, flags, result);
-	}
-    	else if(strcmp(key,"disk_wblk") == 0)
-	{
-		ret = DISK_WBLK(cmd, param, flags, result);
-	}
-	else
-	{
-		ret = SYSINFO_RET_FAIL;
-	}
-    
-	return ret;
+	for (i = 0; fl[i].mode != 0; i++)
+		if (0 == strncmp(mode, fl[i].mode, MAX_STRING_LEN))
+			return (fl[i].function)(devname, result);
+	
+	return SYSINFO_RET_FAIL;
 }
-
diff --git a/src/libs/zbxsysinfo/openbsd/diskspace.c b/src/libs/zbxsysinfo/openbsd/diskspace.c
index 6d0afd00..73d0d467 100644
--- a/src/libs/zbxsysinfo/openbsd/diskspace.c
+++ b/src/libs/zbxsysinfo/openbsd/diskspace.c
@@ -21,219 +21,156 @@
 
 #include "sysinfo.h"
 
-int	get_fs_size_stat(char *fs, double *total, double *free, double *usage)
+int	get_fs_size_stat(const char *fs, zbx_uint64_t *total, zbx_uint64_t *free, zbx_uint64_t *used, double *pfree, double *pused)
 {
 #ifdef HAVE_SYS_STATVFS_H
-        struct statvfs   s;
+	struct statvfs	s;
 #else
-        struct statfs   s;
+	struct statfs	s;
 #endif
 
-        assert(fs);
+	assert(fs);
 
 #ifdef HAVE_SYS_STATVFS_H
-        if ( statvfs( fs, &s) != 0 )
+	if (0 != statvfs(fs, &s))
 #else
-        if ( statfs( fs, &s) != 0 )
+	if (0 != statfs(fs, &s))
 #endif
-        {
-                return  SYSINFO_RET_FAIL;
-        }
+	{
+		return SYSINFO_RET_FAIL;
+	}
 
 #ifdef HAVE_SYS_STATVFS_H
-        if(total)
-                (*total) = (double)(s.f_blocks * (s.f_frsize / 1024.0));
-        if(free)
-                (*free)  = (double)(s.f_bavail * (s.f_frsize / 1024.0));
-        if(usage)
-                (*usage) = (double)((s.f_blocks - s.f_bavail) * (s.f_frsize / 1024.0));
+	if (total)
+		*total = (zbx_uint64_t)s.f_blocks * s.f_frsize;
+	if (free)
+		*free = (zbx_uint64_t)s.f_bfree * s.f_frsize;
+	if (used)
+		*used = (zbx_uint64_t)(s.f_blocks - s.f_bfree) * s.f_frsize;
+	if (pfree)
+		*pfree = (double)(100.0 * s.f_bfree) / s.f_blocks;
+	if (pused)
+		*pused = (double)(100.0 * (s.f_blocks - s.f_bfree)) / s.f_blocks;
 #else
-        if(total)
-                (*total) = (double)(s.f_blocks * (s.f_bsize / 1024.0));
-        if(free)
-                (*free)  = (double)(s.f_bfree * (s.f_bsize / 1024.0));
-        if(usage)
-                (*usage) = (double)((s.f_blocks - s.f_bfree) * (s.f_bsize / 1024.0));
+	if (total)
+		*total = (zbx_uint64_t)s.f_blocks * s.f_bsize;
+	if (free)
+		*free = (zbx_uint64_t)s.f_bfree * s.f_bsize;
+	if (used)
+		*used = (zbx_uint64_t)(s.f_blocks - s.f_bfree) * s.f_bsize;
+	if (pfree)
+		*pfree = (double)(100.0 * s.f_bfree) / s.f_blocks;
+	if (pused)
+		*pused = (double)(100.0 * (s.f_blocks - s.f_bfree)) / s.f_blocks;
 #endif
-        return SYSINFO_RET_OK;
+	return SYSINFO_RET_OK;
 }
 
-static int	VFS_FS_USED(const char *cmd, char *param, unsigned flags, AGENT_RESULT *result)
+static int	VFS_FS_USED(const char *fs, AGENT_RESULT *result)
 {
-/*        char    mountPoint[MAX_STRING_LEN];*/
-        double  value = 0;
-
-        assert(result);
-
-        init_result(result);
-
-/*        if(num_param(param) > 1)
-                return SYSINFO_RET_FAIL;
+	zbx_uint64_t	value = 0;
 
-        if(get_param(param, 1, mountPoint, MAX_STRING_LEN) != 0)
-                return SYSINFO_RET_FAIL;*/
+	if (SYSINFO_RET_OK != get_fs_size_stat(fs, NULL, NULL, &value, NULL, NULL))
+		return SYSINFO_RET_FAIL;
 
-        if(get_fs_size_stat(param, NULL, NULL, &value) != SYSINFO_RET_OK)
-                return  SYSINFO_RET_FAIL;
+	SET_UI64_RESULT(result, value);
 
-        SET_UI64_RESULT(result, value);
-
-        return SYSINFO_RET_OK;
+	return SYSINFO_RET_OK;
 }
 
-static int	VFS_FS_FREE(const char *cmd, char *param, unsigned flags, AGENT_RESULT *result)
+static int	VFS_FS_FREE(const char *fs, AGENT_RESULT *result)
 {
-/*        char    mountPoint[MAX_STRING_LEN];*/
-        double  value = 0;
-
-        assert(result);
-
-        init_result(result);
-
-/*        if(num_param(param) > 1)
-                return SYSINFO_RET_FAIL;
+	zbx_uint64_t	value = 0;
 
-        if(get_param(param, 1, mountPoint, MAX_STRING_LEN) != 0)
-                return SYSINFO_RET_FAIL;*/
+	if (SYSINFO_RET_OK != get_fs_size_stat(fs, NULL, &value, NULL, NULL, NULL))
+		return SYSINFO_RET_FAIL;
 
-        if(get_fs_size_stat(param, NULL, &value, NULL) != SYSINFO_RET_OK)
-                return  SYSINFO_RET_FAIL;
+	SET_UI64_RESULT(result, value);
 
-        SET_UI64_RESULT(result, value);
-
-        return SYSINFO_RET_OK;
+	return SYSINFO_RET_OK;
 }
 
-static int	VFS_FS_TOTAL(const char *cmd, char *param, unsigned flags, AGENT_RESULT *result)
+static int	VFS_FS_TOTAL(const char *fs, AGENT_RESULT *result)
 {
-/*        char    mountPoint[MAX_STRING_LEN];*/
-        double  value = 0;
-
-        assert(result);
-
-        init_result(result);
-
-/*        if(num_param(param) > 1)
-                return SYSINFO_RET_FAIL;
-
-        if(get_param(param, 1, mountPoint, MAX_STRING_LEN) != 0)
-        {
-                return SYSINFO_RET_FAIL;
-        }*/
+	zbx_uint64_t	value = 0;
 
-        if(get_fs_size_stat(param, &value, NULL, NULL) != SYSINFO_RET_OK)
-                return  SYSINFO_RET_FAIL;
+	if (SYSINFO_RET_OK != get_fs_size_stat(fs, &value, NULL, NULL, NULL, NULL))
+		return SYSINFO_RET_FAIL;
 
-        SET_UI64_RESULT(result, value);
+	SET_UI64_RESULT(result, value);
 
-        return SYSINFO_RET_OK;
+	return SYSINFO_RET_OK;
 
 }
 
-static int	VFS_FS_PFREE(const char *cmd, char *param, unsigned flags, AGENT_RESULT *result)
+static int	VFS_FS_PFREE(const char *fs, AGENT_RESULT *result)
 {
-/*        char    mountPoint[MAX_STRING_LEN];*/
-        double  tot_val = 0;
-        double  free_val = 0;
-
-        assert(result);
-
-        init_result(result);
-
-/*        if(num_param(param) > 1)
-                return SYSINFO_RET_FAIL;
-
-        if(get_param(param, 1, mountPoint, MAX_STRING_LEN) != 0)
-                return SYSINFO_RET_FAIL;*/
+	double	value = 0;
 
-        if(get_fs_size_stat(param, &tot_val, &free_val, NULL) != SYSINFO_RET_OK)
-                return  SYSINFO_RET_FAIL;
+	if (SYSINFO_RET_OK != get_fs_size_stat(fs, NULL, NULL, NULL, &value, NULL))
+		return SYSINFO_RET_FAIL;
 
-        SET_DBL_RESULT(result, (100.0 * free_val) / tot_val);
+	SET_DBL_RESULT(result, value);
 
-        return SYSINFO_RET_OK;
+	return SYSINFO_RET_OK;
 }
 
-static int	VFS_FS_PUSED(const char *cmd, char *param, unsigned flags, AGENT_RESULT *result)
+static int	VFS_FS_PUSED(const char *fs, AGENT_RESULT *result)
 {
-/*        char    mountPoint[MAX_STRING_LEN];*/
-        double  tot_val = 0;
-        double  usg_val = 0;
+	double	value = 0;
 
-        assert(result);
+	if (SYSINFO_RET_OK != get_fs_size_stat(fs, NULL, NULL, NULL, NULL, &value))
+		return SYSINFO_RET_FAIL;
 
-        init_result(result);
+	SET_DBL_RESULT(result, value);
 
-/*        if(num_param(param) > 1)
-                return SYSINFO_RET_FAIL;
-
-        if(get_param(param, 1, mountPoint, MAX_STRING_LEN) != 0)
-                return SYSINFO_RET_FAIL;*/
-
-        if(get_fs_size_stat(param, &tot_val, NULL, &usg_val) != SYSINFO_RET_OK)
-                return  SYSINFO_RET_FAIL;
-
-        SET_DBL_RESULT(result, (100.0 * usg_val) / tot_val);
-
-        return SYSINFO_RET_OK;
+	return SYSINFO_RET_OK;
 }
 
 int	VFS_FS_SIZE(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
 {
-
 #define FS_FNCLIST struct fs_fnclist_s
 FS_FNCLIST
 {
-	char *mode;
-	int (*function)();
+	char	*mode;
+	int	(*function)();
 };
 
-	FS_FNCLIST fl[] = 
+	FS_FNCLIST fl[] =
 	{
-		{"free" ,	VFS_FS_FREE},
-		{"total" ,	VFS_FS_TOTAL},
+		{"free",	VFS_FS_FREE},
+		{"total",	VFS_FS_TOTAL},
 		{"used",	VFS_FS_USED},
-		{"pfree" ,	VFS_FS_PFREE},
-		{"pused" ,	VFS_FS_PUSED},
+		{"pfree",	VFS_FS_PFREE},
+		{"pused",	VFS_FS_PUSED},
 		{0,		0}
 	};
 
-	char fsname[MAX_STRING_LEN];
-	char mode[MAX_STRING_LEN];
-	int i;
-	
-        assert(result);
-
-        init_result(result);
-	
-        if(num_param(param) > 2)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-
-        if(get_param(param, 1, fsname, sizeof(fsname)) != 0)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-	
-	if(get_param(param, 2, mode, sizeof(mode)) != 0)
-        {
-                mode[0] = '\0';
-        }
-        if(mode[0] == '\0')
-	{
-		/* default parameter */
+	char	fsname[MAX_STRING_LEN];
+	char	mode[MAX_STRING_LEN];
+	int	i;
+
+	assert(result);
+
+	init_result(result);
+
+	if (num_param(param) > 2)
+		return SYSINFO_RET_FAIL;
+
+	if (0 != get_param(param, 1, fsname, sizeof(fsname)))
+		return SYSINFO_RET_FAIL;
+
+	if (0 != get_param(param, 2, mode, sizeof(mode)))
+		*mode = '\0';
+
+	/* default parameter */
+	if (*mode == '\0')
 		zbx_snprintf(mode, sizeof(mode), "total");
-	}
-	
-	for(i=0; fl[i].mode!=0; i++)
-	{
-		if(strncmp(mode, fl[i].mode, MAX_STRING_LEN)==0)
-		{
-			return (fl[i].function)(cmd, fsname, flags, result);
-		}
-	}
-	
+
+	for (i = 0; fl[i].mode != 0; i++)
+		if (0 == strncmp(mode, fl[i].mode, MAX_STRING_LEN))
+			return (fl[i].function)(fsname, result);
+
 	return SYSINFO_RET_FAIL;
 }
 
diff --git a/src/libs/zbxsysinfo/openbsd/inodes.c b/src/libs/zbxsysinfo/openbsd/inodes.c
index f2a9993e..9f240b08 100644
--- a/src/libs/zbxsysinfo/openbsd/inodes.c
+++ b/src/libs/zbxsysinfo/openbsd/inodes.c
@@ -23,201 +23,154 @@
 
 #include "md5.h"
 
-static int	get_fs_inodes_stat(char *fs, double *total, double *free, double *usage)
+static int	get_fs_inodes_stat(const char *fs, zbx_uint64_t *total, zbx_uint64_t *free, zbx_uint64_t *used, double *pfree, double *pused)
 {
-	struct statfs   s;
-	
+#ifdef HAVE_SYS_STATVFS_H
+	struct statvfs	s;
+#else
+	struct statfs	s;
+#endif
+
 	assert(fs);
-	
-	if ( statfs( fs, &s) != 0 ) 
+
+#ifdef HAVE_SYS_STATVFS_H
+	if (0 != statvfs(fs, &s))
+#else
+	if (0 != statfs(fs, &s))
+#endif
 	{
-		return	SYSINFO_RET_FAIL;
+		return SYSINFO_RET_FAIL;
 	}
-        
-	if(total)
-		(*total) = (double)(s.f_files);
-	if(free)
-		(*free)  = (double)(s.f_ffree);
-	if(usage)
-		(*usage) = (double)(s.f_files - s.f_ffree);
 
+#ifdef HAVE_SYS_STATVFS_H
+	if (total)
+		*total = (zbx_uint64_t)s.f_files;
+	if (free)
+		*free = (zbx_uint64_t)s.f_ffree;
+	if (used)
+		*used = (zbx_uint64_t)(s.f_files - s.f_ffree);
+	if (pfree)
+		*pfree = (double)(100.0 * s.f_ffree) / s.f_files;
+	if (pused)
+		*pused = (double)(100.0 * (s.f_files - s.f_ffree)) / s.f_files;
+#else
+	if (total)
+		*total = (zbx_uint64_t)s.f_files;
+	if (free)
+		*free = (zbx_uint64_t)s.f_ffree;
+	if (used)
+		*used = (zbx_uint64_t)(s.f_files - s.f_ffree);
+	if (pfree)
+		*pfree = (double)(100.0 * s.f_ffree) / s.f_files;
+	if (pused)
+		*pused = (double)(100.0 * (s.f_files - s.f_ffree)) / s.f_files;
+#endif
 	return SYSINFO_RET_OK;
 }
 
-static int	VFS_FS_INODE_USED(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	VFS_FS_INODE_USED(const char *fs, AGENT_RESULT *result)
 {
-	char 	mountPoint[MAX_STRING_LEN];
-	double	value = 0;
+	zbx_uint64_t	value = 0;
 	
-	assert(result);
-
-	init_result(result);
-
-        if(num_param(param) > 1)
-                return SYSINFO_RET_FAIL;
-
-        if(get_param(param, 1, mountPoint, MAX_STRING_LEN) != 0)
-                return SYSINFO_RET_FAIL;
-
-	if(get_fs_inodes_stat(mountPoint, NULL, NULL, &value) != SYSINFO_RET_OK)
-		return  SYSINFO_RET_FAIL;
+	if (SYSINFO_RET_OK != get_fs_inodes_stat(fs, NULL, NULL, &value, NULL, NULL))
+		return SYSINFO_RET_FAIL;
 	
 	SET_UI64_RESULT(result, value);
 		
 	return SYSINFO_RET_OK;
 }
 
-static int	VFS_FS_INODE_FREE(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	VFS_FS_INODE_FREE(const char *fs, AGENT_RESULT *result)
 {
-	char 	mountPoint[MAX_STRING_LEN];
-	double	value = 0;
+	zbx_uint64_t	value = 0;
 	
-	assert(result);
-
-	init_result(result);
-
-        if(num_param(param) > 1)
-                return SYSINFO_RET_FAIL;
-
-        if(get_param(param, 1, mountPoint, MAX_STRING_LEN) != 0)
-                return SYSINFO_RET_FAIL;
-
-	if(get_fs_inodes_stat(mountPoint, NULL, &value, NULL) != SYSINFO_RET_OK)
-		return  SYSINFO_RET_FAIL;
+	if (SYSINFO_RET_OK != get_fs_inodes_stat(fs, NULL, &value, NULL, NULL, NULL))
+		return SYSINFO_RET_FAIL;
 	
 	SET_UI64_RESULT(result, value);
 		
 	return SYSINFO_RET_OK;
 }
 
-static int	VFS_FS_INODE_TOTAL(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	VFS_FS_INODE_TOTAL(const char *fs, AGENT_RESULT *result)
 {
-	char 	mountPoint[MAX_STRING_LEN];
-	double	value = 0;
+	zbx_uint64_t	value = 0;
 	
-	assert(result);
-
-	init_result(result);
-
-        if(num_param(param) > 1)
-                return SYSINFO_RET_FAIL;
-
-        if(get_param(param, 1, mountPoint, MAX_STRING_LEN) != 0)
-        {
-                return SYSINFO_RET_FAIL;
-        }	
-
-	if(get_fs_inodes_stat(mountPoint, &value, NULL, NULL) != SYSINFO_RET_OK)
-		return  SYSINFO_RET_FAIL;
+	if (SYSINFO_RET_OK != get_fs_inodes_stat(fs, &value, NULL, NULL, NULL, NULL))
+		return SYSINFO_RET_FAIL;
 	
 	SET_UI64_RESULT(result, value);
 		
 	return SYSINFO_RET_OK;
 }
 
-static int	VFS_FS_INODE_PFREE(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	VFS_FS_INODE_PFREE(const char *fs, AGENT_RESULT *result)
 {
-	char 	mountPoint[MAX_STRING_LEN];
-	double	tot_val = 0;
-	double	free_val = 0;
+	double	value = 0;
 	
-	assert(result);
-
-	init_result(result);
-
-        if(num_param(param) > 1)
-                return SYSINFO_RET_FAIL;
-
-        if(get_param(param, 1, mountPoint, MAX_STRING_LEN) != 0)
-                return SYSINFO_RET_FAIL;
-
-	if(get_fs_inodes_stat(mountPoint, &tot_val, &free_val, NULL) != SYSINFO_RET_OK)
-		return  SYSINFO_RET_FAIL;
+	if (SYSINFO_RET_OK != get_fs_inodes_stat(fs, NULL, NULL, NULL, &value, NULL))
+		return SYSINFO_RET_FAIL;
 	
-	SET_DBL_RESULT(result, (100.0 * free_val) / tot_val);
+	SET_DBL_RESULT(result, value);
 		
 	return SYSINFO_RET_OK;
 }
 
-static int	VFS_FS_INODE_PUSED(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	VFS_FS_INODE_PUSED(const char *fs, AGENT_RESULT *result)
 {
-	char 	mountPoint[MAX_STRING_LEN];
-	double	tot_val = 0;
-	double	usg_val = 0;
+	double	value = 0;
 	
-	assert(result);
-
-	init_result(result);
-
-        if(num_param(param) > 1)
-                return SYSINFO_RET_FAIL;
-
-        if(get_param(param, 1, mountPoint, MAX_STRING_LEN) != 0)
-                return SYSINFO_RET_FAIL;
-
-	if(get_fs_inodes_stat(mountPoint, &tot_val, NULL, &usg_val) != SYSINFO_RET_OK)
-		return  SYSINFO_RET_FAIL;
+	if (SYSINFO_RET_OK != get_fs_inodes_stat(fs, NULL, NULL, NULL, NULL, &value))
+		return SYSINFO_RET_FAIL;
 	
-	SET_DBL_RESULT(result, (100.0 * usg_val) / tot_val);
+	SET_DBL_RESULT(result, value);
 		
 	return SYSINFO_RET_OK;
 }
 
 int	VFS_FS_INODE(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
 {
-
 #define FS_FNCLIST struct fs_fnclist_s
 FS_FNCLIST
 {
-	char *mode;
-	int (*function)();
+	char	*mode;
+	int	(*function)();
 };
 
 	FS_FNCLIST fl[] = 
 	{
-		{"free" ,	VFS_FS_INODE_FREE},
-		{"total" ,	VFS_FS_INODE_TOTAL},
+		{"free",	VFS_FS_INODE_FREE},
+		{"total",	VFS_FS_INODE_TOTAL},
 		{"used",	VFS_FS_INODE_USED},
-		{"pfree" ,	VFS_FS_INODE_PFREE},
-		{"pused" ,	VFS_FS_INODE_PUSED},
+		{"pfree",	VFS_FS_INODE_PFREE},
+		{"pused",	VFS_FS_INODE_PUSED},
 		{0,		0}
 	};
 
-	char fsname[MAX_STRING_LEN];
-	char mode[MAX_STRING_LEN];
-	int i;
+	char	fsname[MAX_STRING_LEN];
+	char	mode[MAX_STRING_LEN];
+	int	i;
 	
-        assert(result);
+	assert(result);
 
-        init_result(result);
+	init_result(result);
 	
-        if(num_param(param) > 2)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-
-        if(get_param(param, 1, fsname, sizeof(mode)) != 0)
-        {
-                return SYSINFO_RET_FAIL;
-        }
+	if (num_param(param) > 2)
+		return SYSINFO_RET_FAIL;
+
+	if (0 != get_param(param, 1, fsname, sizeof(mode)))
+		return SYSINFO_RET_FAIL;
 	
-	if(get_param(param, 2, mode, sizeof(mode)) != 0)
-        {
-                mode[0] = '\0';
-        }
-        if(mode[0] == '\0')
-	{
-		/* default parameter */
+	if (0 != get_param(param, 2, mode, sizeof(mode)))
+		*mode = '\0';
+
+	/* default parameter */
+	if (*mode == '\0')
 		zbx_snprintf(mode, sizeof(mode), "total");
-	}
 	
-	for(i=0; fl[i].mode!=0; i++)
-	{
-		if(strncmp(mode, fl[i].mode, MAX_STRING_LEN)==0)
-		{
-			return (fl[i].function)(cmd, fsname, flags, result);
-		}
-	}
+	for (i = 0; fl[i].mode != 0; i++)
+		if (0 == strncmp(mode, fl[i].mode, MAX_STRING_LEN))
+			return (fl[i].function)(fsname, result);
 	
 	return SYSINFO_RET_FAIL;
 }
diff --git a/src/libs/zbxsysinfo/openbsd/kernel.c b/src/libs/zbxsysinfo/openbsd/kernel.c
index 9b40434a..cbe738db 100644
--- a/src/libs/zbxsysinfo/openbsd/kernel.c
+++ b/src/libs/zbxsysinfo/openbsd/kernel.c
@@ -23,83 +23,46 @@
 
 int	KERNEL_MAXFILES(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
 {
-	int	mib[2],len;
+	int	mib[2];
+	size_t	len;
 	int	maxfiles;
 
 	assert(result);
 
-        init_result(result);	
+	init_result(result);
 
-	mib[0]=CTL_KERN;
-	mib[1]=KERN_MAXFILES;
+	mib[0] = CTL_KERN;
+	mib[1] = KERN_MAXFILES;
 
-	len=sizeof(maxfiles);
+	len = sizeof(maxfiles);
 
-	if(sysctl(mib,2,&maxfiles,(size_t *)&len,NULL,0) != 0)
-	{
-		return	SYSINFO_RET_FAIL;
-	}
+	if (0 != sysctl(mib, 2, &maxfiles, &len, NULL, 0))
+		return SYSINFO_RET_FAIL;
 
 	SET_UI64_RESULT(result, maxfiles);
+
 	return SYSINFO_RET_OK;
 }
 
 int	KERNEL_MAXPROC(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
 {
-	int	mib[2],len;
+	int	mib[2];
+	size_t	len;
 	int	maxproc;
 
 	assert(result);
 
-        init_result(result);	
+	init_result(result);	
 	
-	mib[0]=CTL_KERN;
-	mib[1]=KERN_MAXPROC;
+	mib[0] = CTL_KERN;
+	mib[1] = KERN_MAXPROC;
 
-	len=sizeof(maxproc);
+	len = sizeof(maxproc);
 
-	if(sysctl(mib,2,&maxproc,(size_t *)&len,NULL,0) != 0)
-	{
-		return	SYSINFO_RET_FAIL;
-/*		printf("Errno [%m]");*/
-	}
+	if (0 != sysctl(mib, 2, &maxproc, &len, NULL, 0))
+		return SYSINFO_RET_FAIL;
 
 	SET_UI64_RESULT(result, maxproc);
-	return SYSINFO_RET_OK;
-}
 
-int     OLD_KERNEL(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
-{
-	char    key[MAX_STRING_LEN];
-        int     ret;
-
-        assert(result);
-
-        init_result(result);	
-
-        if(num_param(param) > 1)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-
-        if(get_param(param, 1, key, MAX_STRING_LEN) != 0)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-
-        if(strcmp(key,"maxfiles") == 0)
-        {
-                ret = KERNEL_MAXFILES(cmd, param, flags, result);
-        }
-        else if(strcmp(key,"maxproc") == 0)
-        {
-                ret = KERNEL_MAXPROC(cmd, param, flags, result);
-        }
-        else
-        {
-                ret = SYSINFO_RET_FAIL;
-        }
-
-        return ret;
+	return SYSINFO_RET_OK;
 }
-
diff --git a/src/libs/zbxsysinfo/openbsd/memory.c b/src/libs/zbxsysinfo/openbsd/memory.c
index dc115705..443f6d57 100644
--- a/src/libs/zbxsysinfo/openbsd/memory.c
+++ b/src/libs/zbxsysinfo/openbsd/memory.c
@@ -21,50 +21,146 @@
 
 #include "sysinfo.h"
 
-static int	VM_MEMORY_TOTAL(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	get_vmmemory_stat(zbx_uint64_t *total, zbx_uint64_t *free, zbx_uint64_t *used, zbx_uint64_t *shared, double *pfree, double *pused)
 {
-	int 	mib[2];
-	size_t len;
-	struct vmtotal v;
-	int ret=SYSINFO_RET_FAIL;
-	
-	assert(result);
+	int		mib[2];
+	struct vmtotal	v;
+	size_t		len;
+
+	len = sizeof(v);
+	mib[0] = CTL_VM;
+	mib[1] = VM_METER;
+
+	if (0 != sysctl(mib, 2, &v, &len, NULL, 0))
+		return SYSINFO_RET_FAIL;
+
+	if (total)
+		*total = (zbx_uint64_t)(v.t_rm + v.t_free) * sysconf(_SC_PAGESIZE);
+	if (free)
+		*free = (zbx_uint64_t)v.t_free * sysconf(_SC_PAGESIZE);
+	if (used)
+		*used = (zbx_uint64_t)v.t_rm * sysconf(_SC_PAGESIZE);
+	if (shared)
+		*shared = (zbx_uint64_t)(v.t_vmshr + v.t_rmshr) * sysconf(_SC_PAGESIZE);
+	if (pfree)
+		*pfree = (double)(100.0 * v.t_free) / (v.t_rm + v.t_free);
+	if (pused)
+		*pused = (double)(100.0 * v.t_rm) / (v.t_rm + v.t_free);
+
+	return SYSINFO_RET_OK;
+}
 
-        init_result(result);
-		
-	len=sizeof(v);
-	mib[0]=CTL_VM;
-	mib[1]=VM_METER;
+static int	VM_MEMORY_TOTAL(AGENT_RESULT *result)
+{
+	zbx_uint64_t	value;
 
-	if(0==sysctl(mib,2,&v,&len,NULL,0))
-	{
-		SET_UI64_RESULT(result, (zbx_uint64_t)(v.t_rm+v.t_free) * (zbx_uint64_t)sysconf(_SC_PAGESIZE));
-		ret=SYSINFO_RET_OK;
-	}
-	return ret;
+	if (SYSINFO_RET_OK != get_vmmemory_stat(&value, NULL, NULL, NULL, NULL, NULL))
+		return SYSINFO_RET_FAIL;
+
+	SET_UI64_RESULT(result, value);
+
+	return SYSINFO_RET_OK;
 }
 
-static int	VM_MEMORY_FREE(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	VM_MEMORY_FREE(AGENT_RESULT *result)
 {
-	int 	mib[2];
-	size_t len;
-	struct vmtotal v;
-	int ret=SYSINFO_RET_FAIL;
-	
-	assert(result);
+	zbx_uint64_t	value;
 
-        init_result(result);
-		
-	len=sizeof(v);
-	mib[0]=CTL_VM;
-	mib[1]=VM_METER;
+	if (SYSINFO_RET_OK != get_vmmemory_stat(NULL, &value, NULL, NULL, NULL, NULL))
+		return SYSINFO_RET_FAIL;
 
-	if(0==sysctl(mib,2,&v,&len,NULL,0))
-	{
-		SET_UI64_RESULT(result, (zbx_uint64_t)v.t_free * (zbx_uint64_t)sysconf(_SC_PAGESIZE));
-		ret=SYSINFO_RET_OK;
-	}
-	return ret;
+	SET_UI64_RESULT(result, value);
+
+	return SYSINFO_RET_OK;
+}
+
+static int	VM_MEMORY_USED(AGENT_RESULT *result)
+{
+	zbx_uint64_t	value;
+
+	if (SYSINFO_RET_OK != get_vmmemory_stat(NULL, NULL, &value, NULL, NULL, NULL))
+		return SYSINFO_RET_FAIL;
+
+	SET_UI64_RESULT(result, value);
+
+	return SYSINFO_RET_OK;
+}
+
+static int	VM_MEMORY_SHARED(AGENT_RESULT *result)
+{
+	zbx_uint64_t	value;
+
+	if (SYSINFO_RET_OK != get_vmmemory_stat(NULL, NULL, NULL, &value, NULL, NULL))
+		return SYSINFO_RET_FAIL;
+
+	SET_UI64_RESULT(result, value);
+
+	return SYSINFO_RET_OK;
+}
+
+static int	VM_MEMORY_PFREE(AGENT_RESULT *result)
+{
+	double	value;
+
+	if (SYSINFO_RET_OK != get_vmmemory_stat(NULL, NULL, NULL, NULL, &value, NULL))
+		return SYSINFO_RET_FAIL;
+
+	SET_DBL_RESULT(result, value);
+
+	return SYSINFO_RET_OK;
+}
+
+static int	VM_MEMORY_PUSED(AGENT_RESULT *result)
+{
+	double	value;
+
+	if (SYSINFO_RET_OK != get_vmmemory_stat(NULL, NULL, NULL, NULL, NULL, &value))
+		return SYSINFO_RET_FAIL;
+
+	SET_DBL_RESULT(result, value);
+
+	return SYSINFO_RET_OK;
+}
+
+static int	VM_MEMORY_BUFFERS(AGENT_RESULT *result)
+{
+	int		mib[2], pages;
+	size_t		len;
+	zbx_uint64_t	value;
+
+	len = sizeof(pages);
+	mib[0] = CTL_VM;
+	mib[1] = VM_NKMEMPAGES;
+
+	if (0 != sysctl(mib, 2, &pages, &len, NULL, 0))
+		return SYSINFO_RET_FAIL;
+
+	value = (zbx_uint64_t)pages * sysconf(_SC_PAGESIZE);
+
+	SET_UI64_RESULT(result, value);
+
+	return SYSINFO_RET_OK;
+}
+
+static int	VM_MEMORY_CACHED(AGENT_RESULT *result)
+{
+	int		mib[2];
+	struct uvmexp	v;
+	size_t		len;
+	zbx_uint64_t	value;
+
+	len = sizeof(v);
+	mib[0] = CTL_VM;
+	mib[1] = VM_UVMEXP;
+
+	if (0 != sysctl(mib, 2, &v, &len, NULL, 0))
+		return SYSINFO_RET_FAIL;
+
+	value = (zbx_uint64_t)(v.vnodepages + v.vtextpages) * v.pagesize;
+
+	SET_UI64_RESULT(result, value);
+
+	return SYSINFO_RET_OK;
 }
 
 int     VM_MEMORY_SIZE(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
@@ -72,49 +168,43 @@ int     VM_MEMORY_SIZE(const char *cmd, const char *param, unsigned flags, AGENT
 #define MEM_FNCLIST struct mem_fnclist_s
 MEM_FNCLIST
 {
-	char *mode;
-	int (*function)();
+	char	*mode;
+	int	(*function)();
 };
 
 	MEM_FNCLIST fl[] = 
 	{
-		{"free",	VM_MEMORY_FREE},
 		{"total",	VM_MEMORY_TOTAL},
+		{"free",	VM_MEMORY_FREE},
+		{"used",	VM_MEMORY_USED},
+		{"shared",	VM_MEMORY_SHARED},
+		{"pfree",	VM_MEMORY_PFREE},
+		{"pused",	VM_MEMORY_PUSED},
+		{"buffers",	VM_MEMORY_BUFFERS},
+		{"cached",	VM_MEMORY_CACHED},
 		{0,	0}
 	};
-        char    mode[MAX_STRING_LEN];
-	int 	ret = SYSINFO_RET_FAIL;
+	char    mode[MAX_STRING_LEN];
 	int 	i;
 
-        assert(result);
+	assert(result);
+
+	init_result(result);
 
-        init_result(result);
+	if(num_param(param) > 1)
+		return SYSINFO_RET_FAIL;
 
-        if(num_param(param) > 1)
-        {
-                ret = SYSINFO_RET_FAIL;
-        }
-	else
-	{
-		if(get_param(param, 1, mode, sizeof(mode)) != 0)
-		{
-			mode[0] = '\0';
-		}
-
-		if(mode[0] == '\0')
-		{
-			/* default parameter */
-			zbx_snprintf(mode, sizeof(mode), "total");
-		}
-
-		for(i=0; fl[i].mode!=0; i++)
-		{
-			if(strncmp(mode, fl[i].mode, MAX_STRING_LEN)==0)
-			{
-				ret = (fl[i].function)(cmd, param, flags, result);
-			}
-		}
-	}
-	return ret;
+	if (0 != get_param(param, 1, mode, sizeof(mode)))
+		*mode = '\0';
+
+	/* default parameter */
+	if (*mode == '\0')
+		zbx_snprintf(mode, sizeof(mode), "total");
+
+	for (i = 0; fl[i].mode != 0; i++)
+		if (0 == strncmp(mode, fl[i].mode, MAX_STRING_LEN))
+			return (fl[i].function)(result);
+
+	return SYSINFO_RET_FAIL;
 }
 
diff --git a/src/libs/zbxsysinfo/openbsd/net.c b/src/libs/zbxsysinfo/openbsd/net.c
index 29608831..284ae94f 100644
--- a/src/libs/zbxsysinfo/openbsd/net.c
+++ b/src/libs/zbxsysinfo/openbsd/net.c
@@ -30,50 +30,98 @@ static struct nlist kernel_symbols[] =
 
 #define IFNET_ID 0
 
-static int get_ifdata(const char *device, struct ifnet *result)
+static int	get_ifdata(const char *if_name, zbx_uint64_t *ibytes, zbx_uint64_t *ipackets, zbx_uint64_t *ierrors, zbx_uint64_t *idropped,
+						zbx_uint64_t *obytes, zbx_uint64_t *opackets, zbx_uint64_t *oerrors,
+						zbx_uint64_t *tbytes, zbx_uint64_t *tpackets, zbx_uint64_t *terrors, zbx_uint64_t *tdropped,
+						zbx_uint64_t *icollisions)
 {
 	struct ifnet_head	head;
 	struct ifnet 		*ifp;
+	struct ifnet		v;
 	
-	char 	ifname[IFNAMSIZ+1];
 	kvm_t 	*kp;
 	int	len = 0;
 	int 	ret = SYSINFO_RET_FAIL;
-	
+
 	kp = kvm_open(NULL, NULL, NULL, O_RDONLY, NULL);
 
-	if(kp)
-	{
-		if(kernel_symbols[IFNET_ID].n_type == N_UNDF)
-		{
-			if(kvm_nlist(kp, &kernel_symbols[0]) != 0)
-			{
+	if (kp) {
+		if (N_UNDF == kernel_symbols[IFNET_ID].n_type)
+			if (0 != kvm_nlist(kp, &kernel_symbols[0]))
 				kernel_symbols[IFNET_ID].n_type = N_UNDF;
-			}
-		}
 		
-		if(kernel_symbols[IFNET_ID].n_type != N_UNDF)
-		{
+		if (N_UNDF != kernel_symbols[IFNET_ID].n_type) {
 			len = sizeof(struct ifnet_head);
-			if(kvm_read(kp, kernel_symbols[IFNET_ID].n_value, &head, len) >= len)
-			{
+
+			if (kvm_read(kp, kernel_symbols[IFNET_ID].n_value, &head, len) >= len) {
 				len = sizeof(struct ifnet);
-				for(ifp = head.tqh_first; ifp; ifp = result->if_list.tqe_next)
-				{
-					if(kvm_read(kp, (u_long) ifp, result, len) < len)
+
+				/* if_ibytes;		total number of octets received */
+				/* if_ipackets;		packets received on interface */
+				/* if_ierrors;		input errors on interface */
+				/* if_iqdrops;		dropped on input, this interface */
+				/* if_obytes;		total number of octets sent */
+				/* if_opackets;		packets sent on interface */
+				/* if_oerrors;		output errors on interface */
+				/* if_collisions;	collisions on csma interfaces */
+
+				if (ibytes)
+					*ibytes = 0;
+				if (ipackets)
+					*ipackets = 0;
+				if (ierrors)
+					*ierrors = 0;
+				if (idropped)
+					*idropped = 0;
+				if (obytes)
+					*obytes = 0;
+				if (opackets)
+					*opackets = 0;
+				if (oerrors)
+					*oerrors = 0;
+				if (tbytes)
+					*tbytes = 0;
+				if (tpackets)
+					*tpackets = 0;
+				if (terrors)
+					*terrors = 0;
+				if (tdropped)
+					*tdropped = 0;
+				if (icollisions)
+					*icollisions = 0;
+
+				for(ifp = head.tqh_first; ifp; ifp = v.if_list.tqe_next) {
+					if (kvm_read(kp, (u_long)ifp, &v, len) < len)
 						break;
-					
-					memcpy(
-						ifname, 
-						result->if_xname, 
-						MIN(sizeof(ifname)- 1, IFNAMSIZ)
-					);
-					ifname[IFNAMSIZ] = '\0';
-
-					if(strcmp(device, ifname) == 0)
-					{
+
+					if (0 == strcmp(if_name, "all") || 0 == strcmp(if_name, v.if_xname)) {
+					fprintf(stderr, "----- %s\n", v.if_xname);
+
+						if (ibytes)
+							*ibytes += v.if_ibytes;
+						if (ipackets)
+							*ipackets += v.if_ipackets;
+						if (ierrors)
+							*ierrors += v.if_ierrors;
+						if (idropped)
+							*idropped += v.if_iqdrops;
+						if (obytes)
+							*obytes += v.if_obytes;
+						if (opackets)
+							*opackets += v.if_opackets;
+						if (oerrors)
+							*oerrors += v.if_oerrors;
+						if (tbytes)
+							*tbytes += v.if_ibytes + v.if_obytes;
+						if (tpackets)
+							*tpackets += v.if_ipackets + v.if_opackets;
+						if (terrors)
+							*terrors += v.if_ierrors + v.if_oerrors;
+						if (tdropped)
+							*tdropped += v.if_iqdrops;
+						if (icollisions)
+							*icollisions += v.if_collisions;
 						ret = SYSINFO_RET_OK;
-						break;
 					}
 				}
 			}
@@ -81,100 +129,55 @@ static int get_ifdata(const char *device, struct ifnet *result)
 		kvm_close(kp);
 	}
 
-   return ret;
+	return ret;
 }
 
-static int      NET_IF_IN_BYTES(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	NET_IF_IN_BYTES(const char *if_name, AGENT_RESULT *result)
 {
-	struct ifnet value;
-	char    if_name[MAX_STRING_LEN];
-	int     ret = SYSINFO_RET_FAIL;
-
-	assert(result);
+	zbx_uint64_t	value;
 
-	init_result(result);
-
-	if(num_param(param) > 1)
-	{
+	if (SYSINFO_RET_OK != get_ifdata(if_name, &value, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL))
 		return SYSINFO_RET_FAIL;
-	}
 
-	if(get_param(param, 1, if_name, MAX_STRING_LEN) != 0)
-	{
-		return SYSINFO_RET_FAIL;
-	}
+	SET_UI64_RESULT(result, value);
 
-	ret = get_ifdata(if_name, &value);
-	
-	if(ret == SYSINFO_RET_OK)
-	{
-		SET_UI64_RESULT(result, value.if_ibytes);
-		ret = SYSINFO_RET_OK;
-	}
-	
-	return ret;
+	return SYSINFO_RET_OK;
 }
 
-static int      NET_IF_IN_PACKETS(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	NET_IF_IN_PACKETS(const char *if_name, AGENT_RESULT *result)
 {
-	struct ifnet value;
-	char    if_name[MAX_STRING_LEN];
-	int     ret = SYSINFO_RET_FAIL;
+	zbx_uint64_t	value;
 
-	assert(result);
-
-	init_result(result);
-
-	if(num_param(param) > 1)
-	{
+	if (SYSINFO_RET_OK != get_ifdata(if_name, NULL, &value, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL))
 		return SYSINFO_RET_FAIL;
-	}
 
-	if(get_param(param, 1, if_name, MAX_STRING_LEN) != 0)
-	{
-		return SYSINFO_RET_FAIL;
-	}
+	SET_UI64_RESULT(result, value);
 
-	ret = get_ifdata(if_name, &value);
-	
-	if(ret == SYSINFO_RET_OK)
-	{
-		SET_UI64_RESULT(result, value.if_ipackets);
-		ret = SYSINFO_RET_OK;
-	}
-	
-	return ret;
+	return SYSINFO_RET_OK;
 }
 
-static int      NET_IF_IN_ERRORS(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	NET_IF_IN_ERRORS(const char *if_name, AGENT_RESULT *result)
 {
-	struct ifnet value;
-	char    if_name[MAX_STRING_LEN];
-	int     ret = SYSINFO_RET_FAIL;
+	zbx_uint64_t	value;
 
-	assert(result);
+	if (SYSINFO_RET_OK != get_ifdata(if_name, NULL, NULL, &value, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL))
+		return SYSINFO_RET_FAIL;
 
-	init_result(result);
+	SET_UI64_RESULT(result, value);
 
-	if(num_param(param) > 1)
-	{
-		return SYSINFO_RET_FAIL;
-	}
+	return SYSINFO_RET_OK;
+}
 
-	if(get_param(param, 1, if_name, MAX_STRING_LEN) != 0)
-	{
+static int	NET_IF_IN_DROPPED(const char *if_name, AGENT_RESULT *result)
+{
+	zbx_uint64_t	value;
+
+	if (SYSINFO_RET_OK != get_ifdata(if_name, NULL, NULL, NULL, &value, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL))
 		return SYSINFO_RET_FAIL;
-	}
 
-	ret = get_ifdata(if_name, &value);
-	
-	if(ret == SYSINFO_RET_OK)
-	{
-		SET_UI64_RESULT(result, value.if_ierrors);
-		ret = SYSINFO_RET_OK;
-	}
-	
-	return ret;
+	SET_UI64_RESULT(result, value);
+
+	return SYSINFO_RET_OK;
 }
 
 int	NET_IF_IN(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
@@ -182,148 +185,85 @@ int	NET_IF_IN(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *
 #define NET_FNCLIST struct net_fnclist_s
 NET_FNCLIST
 {
-        char *mode;
-        int (*function)();
+	char	*mode;
+	int	(*function)();
 };
 
-        NET_FNCLIST fl[] =
-        {
-                {"bytes",   NET_IF_IN_BYTES},
-                {"packets", NET_IF_IN_PACKETS},
-                {"errors",  NET_IF_IN_ERRORS},
-                {0,         0}
-        };
-
-        char if_name[MAX_STRING_LEN];
-        char mode[MAX_STRING_LEN];
-        int i;
-
-        assert(result);
-
-        init_result(result);
-
-        if(num_param(param) > 2)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-
-        if(get_param(param, 1, if_name, sizeof(if_name)) != 0)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-
-        if(get_param(param, 2, mode, sizeof(mode)) != 0)
-        {
-                mode[0] = '\0';
-        }
-        if(mode[0] == '\0')
-        {
-                /* default parameter */
-                zbx_snprintf(mode, sizeof(mode), "bytes");
-        }
-
-        for(i=0; fl[i].mode!=0; i++)
-        {
-                if(strncmp(mode, fl[i].mode, MAX_STRING_LEN)==0)
-                {
-                        return (fl[i].function)(cmd, if_name, flags, result);
-                }
-        }
-
-        return SYSINFO_RET_FAIL;
-}
+	NET_FNCLIST fl[] =
+	{
+		{"bytes",	NET_IF_IN_BYTES},
+		{"packets",	NET_IF_IN_PACKETS},
+		{"errors",	NET_IF_IN_ERRORS},
+		{"dropped",	NET_IF_IN_DROPPED},
+		{0,		0}
+	};
 
-static int      NET_IF_OUT_BYTES(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
-{
-	struct ifnet value;
-	char    if_name[MAX_STRING_LEN];
-	int     ret = SYSINFO_RET_FAIL;
+	char	if_name[MAX_STRING_LEN];
+	char	mode[MAX_STRING_LEN];
+	int	i;
 
 	assert(result);
 
 	init_result(result);
 
-	if(num_param(param) > 1)
-	{
+	if (num_param(param) > 2)
 		return SYSINFO_RET_FAIL;
-	}
 
-	if(get_param(param, 1, if_name, MAX_STRING_LEN) != 0)
-	{
-		return SYSINFO_RET_FAIL;
-	}
+	if (0 != get_param(param, 1, if_name, sizeof(if_name)))
+		*if_name = '\0';
 
-	ret = get_ifdata(if_name, &value);
-	
-	if(ret == SYSINFO_RET_OK)
-	{
-		SET_UI64_RESULT(result, value.if_obytes);
-		ret = SYSINFO_RET_OK;
-	}
-	
-	return ret;
-}
+	/* default parameter */
+	if (*if_name == '\0')
+		zbx_snprintf(if_name, sizeof(if_name), "all");
 
-static int      NET_IF_OUT_PACKETS(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
-{
-	struct ifnet value;
-	char    if_name[MAX_STRING_LEN];
-	int     ret = SYSINFO_RET_FAIL;
+	if (0 != get_param(param, 2, mode, sizeof(mode)))
+		*mode = '\0';
 
-	assert(result);
+	/* default parameter */
+	if (*mode == '\0')
+		zbx_snprintf(mode, sizeof(mode), "bytes");
 
-	init_result(result);
+	for (i = 0; fl[i].mode != 0; i++)
+		if (0 == strncmp(mode, fl[i].mode, MAX_STRING_LEN))
+			return (fl[i].function)(if_name, result);
 
-	if(num_param(param) > 1)
-	{
-		return SYSINFO_RET_FAIL;
-	}
+	return SYSINFO_RET_FAIL;
+}
 
-	if(get_param(param, 1, if_name, MAX_STRING_LEN) != 0)
-	{
+static int	NET_IF_OUT_BYTES(const char *if_name, AGENT_RESULT *result)
+{
+	zbx_uint64_t	value;
+
+	if (SYSINFO_RET_OK != get_ifdata(if_name, NULL, NULL, NULL, NULL, &value, NULL, NULL, NULL, NULL, NULL, NULL, NULL))
 		return SYSINFO_RET_FAIL;
-	}
 
-	ret = get_ifdata(if_name, &value);
-	
-	if(ret == SYSINFO_RET_OK)
-	{
-		SET_UI64_RESULT(result, value.if_opackets);
-		ret = SYSINFO_RET_OK;
-	}
-	
-	return ret;
+	SET_UI64_RESULT(result, value);
+
+	return SYSINFO_RET_OK;
 }
 
-static int      NET_IF_OUT_ERRORS(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int      NET_IF_OUT_PACKETS(const char *if_name, AGENT_RESULT *result)
 {
-	struct ifnet value;
-	char    if_name[MAX_STRING_LEN];
-	int     ret = SYSINFO_RET_FAIL;
+	zbx_uint64_t	value;
 
-	assert(result);
+	if (SYSINFO_RET_OK != get_ifdata(if_name, NULL, NULL, NULL, NULL, NULL, &value, NULL, NULL, NULL, NULL, NULL, NULL))
+		return SYSINFO_RET_FAIL;
 
-	init_result(result);
+	SET_UI64_RESULT(result, value);
 
-	if(num_param(param) > 1)
-	{
-		return SYSINFO_RET_FAIL;
-	}
+	return SYSINFO_RET_OK;
+}
 
-	if(get_param(param, 1, if_name, MAX_STRING_LEN) != 0)
-	{
+static int      NET_IF_OUT_ERRORS(const char *if_name, AGENT_RESULT *result)
+{
+	zbx_uint64_t	value;
+
+	if (SYSINFO_RET_OK != get_ifdata(if_name, NULL, NULL, NULL, NULL, NULL, NULL, &value, NULL, NULL, NULL, NULL, NULL))
 		return SYSINFO_RET_FAIL;
-	}
 
-	ret = get_ifdata(if_name, &value);
-	
-	if(ret == SYSINFO_RET_OK)
-	{
-		SET_UI64_RESULT(result, value.if_oerrors);
-		ret = SYSINFO_RET_OK;
-	}
-	
-	return ret;
+	SET_UI64_RESULT(result, value);
+
+	return SYSINFO_RET_OK;
 }
 
 int	NET_IF_OUT(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
@@ -331,148 +271,97 @@ int	NET_IF_OUT(const char *cmd, const char *param, unsigned flags, AGENT_RESULT
 #define NET_FNCLIST struct net_fnclist_s
 NET_FNCLIST
 {
-        char *mode;
-        int (*function)();
+	char	*mode;
+	int	(*function)();
 };
 
-        NET_FNCLIST fl[] =
-        {
-                {"bytes",   NET_IF_OUT_BYTES},
-                {"packets", NET_IF_OUT_PACKETS},
-                {"errors",  NET_IF_OUT_ERRORS},
-                {0,         0}
-        };
-
-        char if_name[MAX_STRING_LEN];
-        char mode[MAX_STRING_LEN];
-        int i;
-
-        assert(result);
-
-        init_result(result);
-
-        if(num_param(param) > 2)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-
-        if(get_param(param, 1, if_name, sizeof(if_name)) != 0)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-
-        if(get_param(param, 2, mode, sizeof(mode)) != 0)
-        {
-                mode[0] = '\0';
-        }
-        if(mode[0] == '\0')
-        {
-                /* default parameter */
-                zbx_snprintf(mode, sizeof(mode), "bytes");
-        }
-
-        for(i=0; fl[i].mode!=0; i++)
-        {
-                if(strncmp(mode, fl[i].mode, MAX_STRING_LEN)==0)
-                {
-                        return (fl[i].function)(cmd, if_name, flags, result);
-                }
-        }
-
-        return SYSINFO_RET_FAIL;
-}
+	NET_FNCLIST fl[] =
+	{
+		{"bytes",	NET_IF_OUT_BYTES},
+		{"packets",	NET_IF_OUT_PACKETS},
+		{"errors",	NET_IF_OUT_ERRORS},
+/*		{"dropped",	NET_IF_OUT_DROPPED},*/
+		{0,		0}
+	};
 
-static int      NET_IF_TOTAL_BYTES(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
-{
-	struct ifnet value;
-	char    if_name[MAX_STRING_LEN];
-	int     ret = SYSINFO_RET_FAIL;
+	char	if_name[MAX_STRING_LEN];
+	char	mode[MAX_STRING_LEN];
+	int	i;
 
 	assert(result);
 
 	init_result(result);
 
-	if(num_param(param) > 1)
-	{
+	if (num_param(param) > 2)
 		return SYSINFO_RET_FAIL;
-	}
 
-	if(get_param(param, 1, if_name, MAX_STRING_LEN) != 0)
-	{
-		return SYSINFO_RET_FAIL;
-	}
+	if (0 != get_param(param, 1, if_name, sizeof(if_name)))
+		*if_name = '\0';
 
-	ret = get_ifdata(if_name, &value);
-	
-	if(ret == SYSINFO_RET_OK)
-	{
-		SET_UI64_RESULT(result, value.if_obytes + value.if_ibytes);
-		ret = SYSINFO_RET_OK;
-	}
-	
-	return ret;
+	/* default parameter */
+	if (*if_name == '\0')
+		zbx_snprintf(if_name, sizeof(if_name), "all");
+
+	if (0 != get_param(param, 2, mode, sizeof(mode)))
+		*mode = '\0';
+
+	/* default parameter */
+	if (*mode == '\0')
+		zbx_snprintf(mode, sizeof(mode), "bytes");
+
+	for (i = 0; fl[i].mode != 0; i++)
+		if (0 == strncmp(mode, fl[i].mode, MAX_STRING_LEN))
+			return (fl[i].function)(if_name, result);
+
+	return SYSINFO_RET_FAIL;
 }
 
-static int      NET_IF_TOTAL_PACKETS(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	NET_IF_TOTAL_BYTES(const char *if_name, AGENT_RESULT *result)
 {
-	struct ifnet value;
-	char    if_name[MAX_STRING_LEN];
-	int     ret = SYSINFO_RET_FAIL;
+	zbx_uint64_t	value;
 
-	assert(result);
+	if (SYSINFO_RET_OK != get_ifdata(if_name, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &value, NULL, NULL, NULL, NULL))
+		return SYSINFO_RET_FAIL;
 
-	init_result(result);
+	SET_UI64_RESULT(result, value);
 
-	if(num_param(param) > 1)
-	{
-		return SYSINFO_RET_FAIL;
-	}
+	return SYSINFO_RET_OK;
+}
 
-	if(get_param(param, 1, if_name, MAX_STRING_LEN) != 0)
-	{
+static int	NET_IF_TOTAL_PACKETS(const char *if_name, AGENT_RESULT *result)
+{
+	zbx_uint64_t	value;
+
+	if (SYSINFO_RET_OK != get_ifdata(if_name, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &value, NULL, NULL, NULL))
 		return SYSINFO_RET_FAIL;
-	}
 
-	ret = get_ifdata(if_name, &value);
-	
-	if(ret == SYSINFO_RET_OK)
-	{
-		SET_UI64_RESULT(result, value.if_opackets + value.if_ipackets);
-		ret = SYSINFO_RET_OK;
-	}
-	
-	return ret;
+	SET_UI64_RESULT(result, value);
+
+	return SYSINFO_RET_OK;
 }
 
-static int      NET_IF_TOTAL_ERRORS(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	NET_IF_TOTAL_ERRORS(const char *if_name, AGENT_RESULT *result)
 {
-	struct ifnet value;
-	char    if_name[MAX_STRING_LEN];
-	int     ret = SYSINFO_RET_FAIL;
+	zbx_uint64_t	value;
 
-	assert(result);
+	if (SYSINFO_RET_OK != get_ifdata(if_name, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &value, NULL, NULL))
+		return SYSINFO_RET_FAIL;
 
-	init_result(result);
+	SET_UI64_RESULT(result, value);
 
-	if(num_param(param) > 1)
-	{
-		return SYSINFO_RET_FAIL;
-	}
+	return SYSINFO_RET_OK;
+}
 
-	if(get_param(param, 1, if_name, MAX_STRING_LEN) != 0)
-	{
+static int	NET_IF_TOTAL_DROPPED(const char *if_name, AGENT_RESULT *result)
+{
+	zbx_uint64_t	value;
+
+	if (SYSINFO_RET_OK != get_ifdata(if_name, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &value, NULL))
 		return SYSINFO_RET_FAIL;
-	}
 
-	ret = get_ifdata(if_name, &value);
-	
-	if(ret == SYSINFO_RET_OK)
-	{
-		SET_UI64_RESULT(result, value.if_oerrors + value.if_ierrors);
-		ret = SYSINFO_RET_OK;
-	}
-	
-	return ret;
+	SET_UI64_RESULT(result, value);
+
+	return SYSINFO_RET_OK;
 }
 
 int	NET_IF_TOTAL(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
@@ -480,94 +369,83 @@ int	NET_IF_TOTAL(const char *cmd, const char *param, unsigned flags, AGENT_RESUL
 #define NET_FNCLIST struct net_fnclist_s
 NET_FNCLIST
 {
-        char *mode;
-        int (*function)();
+	char	*mode;
+	int	(*function)();
 };
 
-        NET_FNCLIST fl[] =
-        {
-                {"bytes",   NET_IF_TOTAL_BYTES},
-                {"packets", NET_IF_TOTAL_PACKETS},
-                {"errors",  NET_IF_TOTAL_ERRORS},
-                {0,         0}
-        };
-
-        char if_name[MAX_STRING_LEN];
-        char mode[MAX_STRING_LEN];
-        int i;
-
-        assert(result);
-
-        init_result(result);
-
-        if(num_param(param) > 2)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-
-        if(get_param(param, 1, if_name, sizeof(if_name)) != 0)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-
-        if(get_param(param, 2, mode, sizeof(mode)) != 0)
-        {
-                mode[0] = '\0';
-        }
-        if(mode[0] == '\0')
-        {
-                /* default parameter */
-                zbx_snprintf(mode, sizeof(mode), "bytes");
-        }
-
-        for(i=0; fl[i].mode!=0; i++)
-        {
-                if(strncmp(mode, fl[i].mode, MAX_STRING_LEN)==0)
-                {
-                        return (fl[i].function)(cmd, if_name, flags, result);
-                }
-        }
-
-        return SYSINFO_RET_FAIL;
+	NET_FNCLIST fl[] =
+	{
+		{"bytes",	NET_IF_TOTAL_BYTES},
+		{"packets",	NET_IF_TOTAL_PACKETS},
+		{"errors",	NET_IF_TOTAL_ERRORS},
+		{"dropped",	NET_IF_TOTAL_DROPPED},
+		{0,		0}
+	};
+
+	char	if_name[MAX_STRING_LEN];
+	char	mode[MAX_STRING_LEN];
+	int	i;
+
+	assert(result);
+
+	init_result(result);
+
+	if (num_param(param) > 2)
+		return SYSINFO_RET_FAIL;
+
+	if (0 != get_param(param, 1, if_name, sizeof(if_name)))
+		*if_name = '\0';
+
+	/* default parameter */
+	if (*if_name == '\0')
+		zbx_snprintf(if_name, sizeof(if_name), "all");
+
+	if (0 != get_param(param, 2, mode, sizeof(mode)))
+		*mode = '\0';
+
+	/* default parameter */
+	if (*mode == '\0')
+		zbx_snprintf(mode, sizeof(mode), "bytes");
+
+	for (i = 0; fl[i].mode != 0; i++)
+		if (0 == strncmp(mode, fl[i].mode, MAX_STRING_LEN))
+			return (fl[i].function)(if_name, result);
+
+	return SYSINFO_RET_FAIL;
 }
 
 int     NET_TCP_LISTEN(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
 {
-        assert(result);
+	assert(result);
 
-        init_result(result);
+	init_result(result);
 	
 	return SYSINFO_RET_FAIL;
 }
 
 int     NET_IF_COLLISIONS(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
 {
-	struct ifnet value;
-	char    if_name[MAX_STRING_LEN];
-	int     ret = SYSINFO_RET_FAIL;
+	zbx_uint64_t	value;
+	char		if_name[MAX_STRING_LEN];
 
 	assert(result);
 
 	init_result(result);
 
-	if(num_param(param) > 1)
-	{
+	if (num_param(param) > 1)
 		return SYSINFO_RET_FAIL;
-	}
 
-	if(get_param(param, 1, if_name, MAX_STRING_LEN) != 0)
-	{
+	if (0 != get_param(param, 1, if_name, sizeof(if_name)))
+		*if_name = '\0';
+
+	/* default parameter */
+	if (*if_name == '\0')
+		zbx_snprintf(if_name, sizeof(if_name), "all");
+
+	if (SYSINFO_RET_OK != get_ifdata(if_name, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &value))
 		return SYSINFO_RET_FAIL;
-	}
 
-	ret = get_ifdata(if_name, &value);
-	
-	if(ret == SYSINFO_RET_OK)
-	{
-		SET_UI64_RESULT(result, value.if_collisions);
-		ret = SYSINFO_RET_OK;
-	}
-	
-	return ret;
-}
+	SET_UI64_RESULT(result, value);
 
+	return SYSINFO_RET_OK;
+}
diff --git a/src/libs/zbxsysinfo/openbsd/swap.c b/src/libs/zbxsysinfo/openbsd/swap.c
index 37c88b95..281a308f 100644
--- a/src/libs/zbxsysinfo/openbsd/swap.c
+++ b/src/libs/zbxsysinfo/openbsd/swap.c
@@ -24,400 +24,267 @@
 #include "md5.h"
 
 
-static int get_swap_size(double *total, double *free)
+static int get_swap_size(zbx_uint64_t *total, zbx_uint64_t *free, zbx_uint64_t *used, double *pfree, double *pused)
 {
-	int	mib[2];
-        size_t  len;
-        struct uvmexp vm;
+	int		mib[2];
+	size_t		len;
+	struct uvmexp	v;
 
-	mib[0]=CTL_VM;
-	mib[1]=VM_UVMEXP;
+	mib[0] = CTL_VM;
+	mib[1] = VM_UVMEXP;
 
-	len=sizeof vm;
+	len = sizeof(v);
 
-	if(sysctl(mib,2,&vm,&len,NULL,0) == -1)
-	{
+	if (0 != sysctl(mib, 2, &v, &len, NULL, 0))
 		return SYSINFO_RET_FAIL;
-	}
 
-	if(total)
-	{
-		/* int swpages;    number of PAGE_SIZE'ed swap pages */
-		/* int pagesize;   size of a page (PAGE_SIZE): must be power of 2 */
-		(*total) = (double)(((long) vm.swpages) * vm.pagesize);
-	}
-	if(free)
-	{
-		/* int swpages;    number of PAGE_SIZE'ed swap pages */
-		/* int swpginuse;  number of swap pages in use */
-		/* int pagesize;   size of a page (PAGE_SIZE): must be power of 2 */
-		(*free) = (double)(((long) (vm.swpages - vm.swpginuse)) * vm.pagesize);
-	}
+	/* int pagesize;	size of a page (PAGE_SIZE): must be power of 2 */
+	/* int swpages;		number of PAGE_SIZE'ed swap pages */
+	/* int swpginuse;	number of swap pages in use */
+
+	if (total)
+		*total = (zbx_uint64_t)v.swpages * v.pagesize;
+	if (free)
+		*free = (zbx_uint64_t)(v.swpages - v.swpginuse) * v.pagesize;
+	if (used)
+		*used = (zbx_uint64_t)v.swpginuse * v.pagesize;
+	if (pfree)
+		*pfree = v.swpages ? (double)(100.0 * (v.swpages - v.swpginuse)) / v.swpages : 100;
+	if (pused)
+		*pused = v.swpages ? (double)(100.0 * v.swpginuse) / v.swpages : 0;
 
 	return SYSINFO_RET_OK;
 }
 
-static int	SYSTEM_SWAP_FREE(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	SYSTEM_SWAP_TOTAL(AGENT_RESULT *result)
 {
-	double value;
-	int ret = SYSINFO_RET_FAIL;
+	zbx_uint64_t	value;
 
-        assert(result);
-
-        init_result(result);
-	
-	ret = get_swap_size(NULL, &value);
-	
-	if(ret != SYSINFO_RET_OK)
-		return ret;
+	if (SYSINFO_RET_OK != get_swap_size(&value, NULL, NULL, NULL, NULL))
+		return SYSINFO_RET_FAIL;
 
 	SET_UI64_RESULT(result, value);
-	return ret;
+
+	return SYSINFO_RET_OK;
 }
 
-static int	SYSTEM_SWAP_TOTAL(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	SYSTEM_SWAP_FREE(AGENT_RESULT *result)
 {
-	double value;
-	int ret = SYSINFO_RET_FAIL;
+	zbx_uint64_t	value;
 
-        assert(result);
-
-        init_result(result);
-	
-	ret = get_swap_size(&value, NULL);
-	
-	if(ret != SYSINFO_RET_OK)
-		return ret;
+	if (SYSINFO_RET_OK != get_swap_size(NULL, &value, NULL, NULL, NULL))
+		return SYSINFO_RET_FAIL;
 
 	SET_UI64_RESULT(result, value);
-	return ret;
+
+	return SYSINFO_RET_OK;
 }
 
-static int	SYSTEM_SWAP_PFREE(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	SYSTEM_SWAP_USED(AGENT_RESULT *result)
 {
-	AGENT_RESULT	result_tmp;
-        zbx_uint64_t  tot_val = 0;
-        zbx_uint64_t  free_val = 0;
-
-        assert(result);
-
-        init_result(result);
-        init_result(&result_tmp);
+	zbx_uint64_t	value;
 
-	if(SYSTEM_SWAP_TOTAL(cmd, param, flags, &result_tmp) != SYSINFO_RET_OK ||
-		!(result_tmp.type & AR_UINT64))
-	                return  SYSINFO_RET_FAIL;
-	tot_val = result_tmp.ui64;
-
-	/* Check fot division by zero */
-	if(tot_val == 0)
-	{
-		free_result(&result_tmp);
-                return  SYSINFO_RET_FAIL;
-	}
-
-	if(SYSTEM_SWAP_FREE(cmd, param, flags, &result_tmp) != SYSINFO_RET_OK ||
-		!(result_tmp.type & AR_UINT64))
-                	return  SYSINFO_RET_FAIL;
-	free_val = result_tmp.ui64;
-
-	free_result(&result_tmp);
+	if (SYSINFO_RET_OK != get_swap_size(NULL, NULL, &value, NULL, NULL))
+		return SYSINFO_RET_FAIL;
 
-	SET_DBL_RESULT(result, (100.0 * (double)free_val) / (double)tot_val);
+	SET_UI64_RESULT(result, value);
 
-        return SYSINFO_RET_OK;
+	return SYSINFO_RET_OK;
 }
 
-static int	SYSTEM_SWAP_PUSED(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
+static int	SYSTEM_SWAP_PFREE(AGENT_RESULT *result)
 {
-	AGENT_RESULT	result_tmp;
-        zbx_uint64_t  tot_val = 0;
-        zbx_uint64_t  free_val = 0;
-
-        assert(result);
+	double	value;
 
-        init_result(result);
-        init_result(&result_tmp);
+	if (SYSINFO_RET_OK != get_swap_size(NULL, NULL, NULL, &value, NULL))
+		return SYSINFO_RET_FAIL;
 
-	if(SYSTEM_SWAP_TOTAL(cmd, param, flags, &result_tmp) != SYSINFO_RET_OK ||
-		!(result_tmp.type & AR_UINT64))
-                	return  SYSINFO_RET_FAIL;
-	tot_val = result_tmp.ui64;
+	SET_DBL_RESULT(result, value);
 
-	/* Check fot division by zero */
-	if(tot_val == 0)
-	{
-		free_result(&result_tmp);
-                return  SYSINFO_RET_FAIL;
-	}
+	return SYSINFO_RET_OK;
+}
 
-	if(SYSTEM_SWAP_FREE(cmd, param, flags, &result_tmp) != SYSINFO_RET_OK ||
-		!(result_tmp.type & AR_UINT64))
-                	return  SYSINFO_RET_FAIL;
-	free_val = result_tmp.ui64;
+static int	SYSTEM_SWAP_PUSED(AGENT_RESULT *result)
+{
+	double	value;
 
-	free_result(&result_tmp);
+	if (SYSINFO_RET_OK != get_swap_size(NULL, NULL, NULL, NULL, &value))
+		return SYSINFO_RET_FAIL;
 
-	SET_DBL_RESULT(result, 100.0-(100.0 * (double)free_val) / (double)tot_val);
+	SET_DBL_RESULT(result, value);
 
-        return SYSINFO_RET_OK;
+	return SYSINFO_RET_OK;
 }
 
 int	SYSTEM_SWAP_SIZE(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
 {
-
 #define SWP_FNCLIST struct swp_fnclist_s
 SWP_FNCLIST
 {
-	char *mode;
-	int (*function)();
+	char	*mode;
+	int	(*function)();
 };
 
 	SWP_FNCLIST fl[] = 
 	{
 		{"total",	SYSTEM_SWAP_TOTAL},
 		{"free",	SYSTEM_SWAP_FREE},
+		{"used",	SYSTEM_SWAP_USED},
 		{"pfree",	SYSTEM_SWAP_PFREE},
 		{"pused",	SYSTEM_SWAP_PUSED},
 		{0,		0}
 	};
 
-	char swapdev[MAX_STRING_LEN];
-	char mode[MAX_STRING_LEN];
-	int i;
-	
-        assert(result);
+	char	swapdev[MAX_STRING_LEN];
+	char	mode[MAX_STRING_LEN];
+	int	i;
 
-        init_result(result);
-	
-        if(num_param(param) > 2)
-        {
-                return SYSINFO_RET_FAIL;
-        }
+	assert(result);
 
-        if(get_param(param, 1, swapdev, sizeof(swapdev)) != 0)
-        {
-                return SYSINFO_RET_FAIL;
-        }
+	init_result(result);
 
-        if(swapdev[0] == '\0')
-	{
-		/* default parameter */
+	if (num_param(param) > 2)
+		return SYSINFO_RET_FAIL;
+
+	if (0 != get_param(param, 1, swapdev, sizeof(swapdev)))
+		*swapdev = '\0';
+
+	/* default parameter */
+	if (*swapdev == '\0')
 		zbx_snprintf(swapdev, sizeof(swapdev), "all");
-	}
 
-	if(strncmp(swapdev, "all", sizeof(swapdev)))
-	{
+	if (0 != strcmp(swapdev, "all"))
 		return SYSINFO_RET_FAIL;
-	}
-	
-	if(get_param(param, 2, mode, sizeof(mode)) != 0)
-        {
-                mode[0] = '\0';
-        }
+
+	if (0 != get_param(param, 2, mode, sizeof(mode)))
+		*mode = '\0';
 	
-        if(mode[0] == '\0')
-	{
-		/* default parameter */
+	/* default parameter */
+	if (*mode == '\0')
 		zbx_snprintf(mode, sizeof(mode), "free");
-	}
 
-	for(i=0; fl[i].mode!=0; i++)
-	{
-		if(strncmp(mode, fl[i].mode, MAX_STRING_LEN)==0)
-		{
-			return (fl[i].function)(cmd, param, flags, result);
-		}
-	}
+	for (i = 0; fl[i].mode != 0; i++)
+		if (0 == strncmp(mode, fl[i].mode, MAX_STRING_LEN))
+			return (fl[i].function)(result);
 	
 	return SYSINFO_RET_FAIL;
 }
 
-int     OLD_SWAP(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
-{
-        char    key[MAX_STRING_LEN];
-        int     ret;
-
-        assert(result);
-
-        init_result(result);
-
-        if(num_param(param) > 1)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-
-        if(get_param(param, 1, key, MAX_STRING_LEN) != 0)
-        {
-                return SYSINFO_RET_FAIL;
-        }
-
-        if(strcmp(key,"free") == 0)
-        {
-                ret = SYSTEM_SWAP_FREE(cmd, param, flags, result);
-        }
-        else if(strcmp(key,"total") == 0)
-        {
-                ret = SYSTEM_SWAP_TOTAL(cmd, param, flags, result);
-        }
-        else
-        {
-                ret = SYSINFO_RET_FAIL;
-        }
-
-        return ret;
-}
-
-int	get_swap_io(double *swapin, double *pgswapin, double *swapout, double *pgswapout)
+int	get_swap_io(zbx_uint64_t *icount, zbx_uint64_t *ipages, zbx_uint64_t *ocount, zbx_uint64_t *opages)
 {
-	int	mib[2];
-        size_t len;
-        struct uvmexp vm;
+	int		mib[2];
+	size_t		len;
+	struct uvmexp	v;
 
-	mib[0]=CTL_VM;
-	mib[1]=VM_UVMEXP;
+	mib[0] = CTL_VM;
+	mib[1] = VM_UVMEXP;
 
-	len = sizeof(vm);
+	len = sizeof(v);
 
-	if(sysctl(mib,2,&vm,&len,NULL,0) == -1)
-	{
+	if (0 != sysctl(mib, 2, &v, &len, NULL, 0))
 		return SYSINFO_RET_FAIL;
-	}
-	    
-	if(swapin)
-	{
-		/* int swapins;           swapins */
-		(*swapin) = (double) vm.swapins;
-	}
-	if(pgswapin)
-	{
-		/* int pgswapin;           pages swapped in  */
-		(*pgswapin) = (double) vm.pgswapin;
-	}
-	if(swapout)
-	{
-		/* int swapouts;           swapouts */
-		(*swapout) = (double) vm.swapouts;
-	}
-	if(pgswapout)
-	{
-		/* int pgswapout;          pages swapped out  */
-		(*pgswapout) = (double) vm.pgswapout;
-	}
+
+	/* int swapins;		swapins */
+	/* int swapouts;	swapouts */
+	/* int pgswapin;	pages swapped in */
+	/* int pgswapout;	pages swapped out */
+
+	if (icount)
+		*icount = (zbx_uint64_t)v.swapins;
+	if (ipages)
+		*ipages = (zbx_uint64_t)v.pgswapin;
+	if (ocount)
+		*ocount = (zbx_uint64_t)v.swapouts;
+	if (opages)
+		*opages = (zbx_uint64_t)v.pgswapout;
 	
 	return SYSINFO_RET_OK;
 }
 
 int	SYSTEM_SWAP_IN(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
 {
-    int	    ret = SYSINFO_RET_FAIL;
-    char    swapdev[MAX_STRING_LEN];
-    char    mode[MAX_STRING_LEN];
-    double  value = 0;
-        
-    assert(result);
-
-    init_result(result);
-	
-    if(num_param(param) > 2)
-    {
-        return SYSINFO_RET_FAIL;
-    }
+	char		swapdev[MAX_STRING_LEN];
+	char		mode[MAX_STRING_LEN];
+	zbx_uint64_t	value = 0;
 
-    if(get_param(param, 1, swapdev, sizeof(swapdev)) != 0)
-    {
-	return SYSINFO_RET_FAIL;
-    }
+	assert(result);
+
+	init_result(result);
+
+	if (num_param(param) > 2)
+		return SYSINFO_RET_FAIL;
+
+	if (0 != get_param(param, 1, swapdev, sizeof(swapdev)))
+		*swapdev = '\0';
 
-    if(swapdev[0] == '\0')
-    {
 	/* default parameter */
-	zbx_snprintf(swapdev, sizeof(swapdev), "all");
-    }
+	if (*swapdev == '\0')
+		zbx_snprintf(swapdev, sizeof(swapdev), "all");
 
-    if(strncmp(swapdev, "all", sizeof(swapdev)))
-    {
-	return SYSINFO_RET_FAIL;
-    }
-    
-    if(get_param(param, 2, mode, sizeof(mode)) != 0)
-    {
-        return SYSINFO_RET_FAIL;
-    }
-    
-    if(strcmp(mode,"count") == 0)
-    {
-	ret = get_swap_io(&value, NULL, NULL, NULL);
-    }
-    else if(strcmp(mode,"pages") == 0)
-    {
-	ret = get_swap_io(NULL, &value, NULL, NULL);
-    }
-    else
-    {
-	return SYSINFO_RET_FAIL;
-    }
+	if (0 != strcmp(swapdev, "all"))
+		return SYSINFO_RET_FAIL;
 
-    if(ret != SYSINFO_RET_OK)
-	return ret;
+	if (0 != get_param(param, 2, mode, sizeof(mode)))
+		*mode = '\0';
+	
+	/* default parameter */
+	if (*mode == '\0')
+		zbx_snprintf(mode, sizeof(mode), "count");
+
+	if (0 == strcmp(mode, "count")) {
+		if (SYSINFO_RET_OK != get_swap_io(&value, NULL, NULL, NULL))
+			return SYSINFO_RET_FAIL;
+	} else if (0 == strcmp(mode,"pages")) {
+		if (SYSINFO_RET_OK != get_swap_io(NULL, &value, NULL, NULL))
+			return SYSINFO_RET_FAIL;
+	} else
+		return SYSINFO_RET_FAIL;
 
 	SET_UI64_RESULT(result, value);
-    return ret;
+
+	return SYSINFO_RET_OK;
 }
 
 int	SYSTEM_SWAP_OUT(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
 {
-    int	    ret = SYSINFO_RET_FAIL;
-    char    swapdev[MAX_STRING_LEN];
-    char    mode[MAX_STRING_LEN];
-    double  value = 0;
-        
-    assert(result);
-
-    init_result(result);
-	
-    if(num_param(param) > 2)
-    {
-        return SYSINFO_RET_FAIL;
-    }
+	char		swapdev[MAX_STRING_LEN];
+	char		mode[MAX_STRING_LEN];
+	zbx_uint64_t	value = 0;
 
-    if(get_param(param, 1, swapdev, sizeof(swapdev)) != 0)
-    {
-	return SYSINFO_RET_FAIL;
-    }
+	assert(result);
+
+	init_result(result);
+
+	if (num_param(param) > 2)
+		return SYSINFO_RET_FAIL;
+
+	if (0 != get_param(param, 1, swapdev, sizeof(swapdev)))
+		*swapdev = '\0';
 
-    if(swapdev[0] == '\0')
-    {
 	/* default parameter */
-	zbx_snprintf(swapdev, sizeof(swapdev), "all");
-    }
+	if (*swapdev == '\0')
+		zbx_snprintf(swapdev, sizeof(swapdev), "all");
 
-    if(strncmp(swapdev, "all", sizeof(swapdev)))
-    {
-	return SYSINFO_RET_FAIL;
-    }
-    
-    if(get_param(param, 2, mode, sizeof(mode)) != 0)
-    {
-        return SYSINFO_RET_FAIL;
-    }
-    
-    if(strcmp(mode,"count") == 0)
-    {
-	ret = get_swap_io(NULL, NULL, &value, NULL);
-    }
-    else if(strcmp(mode,"pages") == 0)
-    {
-	ret = get_swap_io(NULL, NULL, NULL, &value);
-    }
-    else
-    {
-	return SYSINFO_RET_FAIL;
-    }
+	if (0 != strcmp(swapdev, "all"))
+		return SYSINFO_RET_FAIL;
 
-    if(ret != SYSINFO_RET_OK)
-	return ret;
+	if (0 != get_param(param, 2, mode, sizeof(mode)))
+		*mode = '\0';
+	
+	/* default parameter */
+	if (*mode == '\0')
+		zbx_snprintf(mode, sizeof(mode), "count");
+
+	if (0 == strcmp(mode, "count")) {
+		if (SYSINFO_RET_OK != get_swap_io(NULL, NULL, &value, NULL))
+			return SYSINFO_RET_FAIL;
+	} else if (0 == strcmp(mode,"pages")) {
+		if (SYSINFO_RET_OK != get_swap_io(NULL, NULL, NULL, &value))
+			return SYSINFO_RET_FAIL;
+	} else
+		return SYSINFO_RET_FAIL;
 
 	SET_UI64_RESULT(result, value);
-    return ret;
+
+	return SYSINFO_RET_OK;
 }