diff --git a/src/zabbix_server/poller/checks_simple_vmware.c b/src/zabbix_server/poller/checks_simple_vmware.c
index 20db7d2886..7ff4e4a5e4 100644
--- a/src/zabbix_server/poller/checks_simple_vmware.c
+++ b/src/zabbix_server/poller/checks_simple_vmware.c
@@ -1504,13 +1504,14 @@ out:
 }
 
 static int	check_vcenter_hv_datastore_latency(AGENT_REQUEST *request, const char *username, const char *password,
-		const char *perfcounter, AGENT_RESULT *result)
+		const char *perfcounter, zbx_uint64_t access_filter, AGENT_RESULT *result)
 {
 	char			*url, *mode, *uuid, *name;
 	zbx_vmware_service_t	*service;
 	zbx_vmware_hv_t		*hv;
 	zbx_vmware_datastore_t	*datastore;
-	int			ret = SYSINFO_RET_FAIL;
+	int			i, ret = SYSINFO_RET_FAIL;
+	zbx_str_uint64_pair_t	uuid_cmp = {.value = 0};
 
 	zabbix_log(LOG_LEVEL_DEBUG, "In %s() perfcounter:%s", __func__, perfcounter);
 
@@ -1563,6 +1564,28 @@ static int	check_vcenter_hv_datastore_latency(AGENT_REQUEST *request, const char
 		goto unlock;
 	}
 
+	uuid_cmp.name = hv->uuid;
+
+	if (FAIL == (i = zbx_vector_str_uint64_pair_bsearch(&datastore->hv_uuids_access, uuid_cmp,
+			zbx_str_uint64_pair_name_compare)))
+	{
+		SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Unknown hypervisor \"%s\" for datastore \"%s\".",
+				hv->props[ZBX_VMWARE_HVPROP_NAME], datastore->name));
+		goto unlock;
+	}
+
+	if (access_filter != (datastore->hv_uuids_access.values[i].value & access_filter))
+	{
+		zbx_uint64_t	mi = datastore->hv_uuids_access.values[i].value;
+
+		SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Datastore is not available for hypervisor: %s",
+				0 == (ZBX_VMWARE_DS_MOUNTED & mi) ? "unmounted" : (
+				0 == (ZBX_VMWARE_DS_ACCESSIBLE & mi) ? "inaccessible" : (
+				ZBX_VMWARE_DS_READ == (ZBX_VMWARE_DS_READWRITE & mi)? "readOnly" :
+				"unknown"))));
+		goto unlock;
+	}
+
 	ret = vmware_service_get_counter_value_by_path(service, "HostSystem", hv->id, perfcounter, datastore->uuid, 1,
 			result);
 unlock:
@@ -1577,14 +1600,14 @@ int	check_vcenter_hv_datastore_read(AGENT_REQUEST *request, const char *username
 		AGENT_RESULT *result)
 {
 	return check_vcenter_hv_datastore_latency(request, username, password, "datastore/totalReadLatency[average]",
-			result);
+			ZBX_VMWARE_DS_READ_FILTER, result);
 }
 
 int	check_vcenter_hv_datastore_write(AGENT_REQUEST *request, const char *username, const char *password,
 		AGENT_RESULT *result)
 {
 	return check_vcenter_hv_datastore_latency(request, username, password, "datastore/totalWriteLatency[average]",
-			result);
+			ZBX_VMWARE_DS_WRITE_FILTER, result);
 }
 
 static int	check_vcenter_hv_datastore_size_vsphere(int mode, const zbx_vmware_datastore_t *datastore,
@@ -1672,6 +1695,7 @@ static int	check_vcenter_ds_size(const char *url, const char *hv_uuid, const cha
 	zbx_vmware_datastore_t	*datastore = NULL;
 	zbx_uint64_t		disk_used, disk_provisioned, disk_capacity;
 	unsigned int		flags;
+	zbx_str_uint64_pair_t	uuid_cmp = {.name = (char *)hv_uuid, .value = 0};
 
 	zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__);
 
@@ -1689,7 +1713,8 @@ static int	check_vcenter_ds_size(const char *url, const char *hv_uuid, const cha
 	}
 
 	if (NULL != hv_uuid &&
-			FAIL == zbx_vector_str_bsearch(&datastore->hv_uuids, hv_uuid, ZBX_DEFAULT_STR_COMPARE_FUNC))
+			FAIL == zbx_vector_str_uint64_pair_bsearch(&datastore->hv_uuids_access, uuid_cmp,
+			zbx_str_uint64_pair_name_compare))
 	{
 		SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Hypervisor '%s' not found on this datastore.", hv_uuid));
 		goto unlock;
@@ -1958,9 +1983,9 @@ int	check_vcenter_datastore_hv_list(AGENT_REQUEST *request, const char *username
 		goto unlock;
 	}
 
-	for (i=0; i < datastore->hv_uuids.values_num; i++)
+	for (i=0; i < datastore->hv_uuids_access.values_num; i++)
 	{
-		if (NULL == (hv = hv_get(&service->data->hvs, datastore->hv_uuids.values[i])))
+		if (NULL == (hv = hv_get(&service->data->hvs, datastore->hv_uuids_access.values[i].name)))
 		{
 			SET_MSG_RESULT(result, zbx_strdup(NULL, "Unknown hypervisor uuid."));
 			zbx_free(hv_list);
@@ -1968,7 +1993,7 @@ int	check_vcenter_datastore_hv_list(AGENT_REQUEST *request, const char *username
 		}
 
 		if (NULL == (hv_name = hv->props[ZBX_VMWARE_HVPROP_NAME]))
-			hv_name = datastore->hv_uuids.values[i];
+			hv_name = datastore->hv_uuids_access.values[i].name;
 
 		hv_list = zbx_strdcatf(hv_list, "%s\n", hv_name);
 	}
@@ -2067,13 +2092,13 @@ out:
 }
 
 static int	check_vcenter_datastore_latency(AGENT_REQUEST *request, const char *username, const char *password,
-		const char *perfcounter, AGENT_RESULT *result)
+		const char *perfcounter, zbx_uint64_t access_filter, AGENT_RESULT *result)
 {
 	char			*url, *mode, *name;
 	zbx_vmware_service_t	*service;
 	zbx_vmware_hv_t		*hv;
 	zbx_vmware_datastore_t	*datastore;
-	int			i, ret = SYSINFO_RET_FAIL, count = 0;
+	int			i, ret = SYSINFO_RET_FAIL, count = 0, ds_count = 0;
 	zbx_uint64_t		latency = 0, counterid;
 	unsigned char		is_maxlatency = 0;
 
@@ -2123,9 +2148,22 @@ static int	check_vcenter_datastore_latency(AGENT_REQUEST *request, const char *u
 		goto unlock;
 	}
 
-	for (i = 0; i < datastore->hv_uuids.values_num; i++)
+	for (i = 0; i < datastore->hv_uuids_access.values_num; i++)
 	{
-		if (NULL == (hv = hv_get(&service->data->hvs, datastore->hv_uuids.values[i])))
+		if (access_filter != (datastore->hv_uuids_access.values[i].value & access_filter))
+		{
+			zbx_uint64_t	mi = datastore->hv_uuids_access.values[i].value;
+
+			zabbix_log(LOG_LEVEL_DEBUG, "Datastore %s is not available for hypervisor %s: %s",
+					datastore->name, datastore->hv_uuids_access.values[i].name,
+					0 == (ZBX_VMWARE_DS_MOUNTED & mi) ? "unmounted" : (
+					0 == (ZBX_VMWARE_DS_ACCESSIBLE & mi) ? "inaccessible" : (
+					ZBX_VMWARE_DS_READ == (ZBX_VMWARE_DS_READWRITE & mi)? "readOnly" :
+					"unknown")));
+			continue;
+		}
+
+		if (NULL == (hv = hv_get(&service->data->hvs, datastore->hv_uuids_access.values[i].name)))
 		{
 			SET_MSG_RESULT(result, zbx_strdup(NULL, "Unknown hypervisor uuid."));
 			goto unlock;
@@ -2137,6 +2175,8 @@ static int	check_vcenter_datastore_latency(AGENT_REQUEST *request, const char *u
 			goto unlock;
 		}
 
+		ds_count++;
+
 		if (0 == ISSET_VALUE(result))
 			continue;
 
@@ -2151,6 +2191,12 @@ static int	check_vcenter_datastore_latency(AGENT_REQUEST *request, const char *u
 		UNSET_UI64_RESULT(result);
 	}
 
+	if (0 == ds_count)
+	{
+		SET_MSG_RESULT(result, zbx_strdup(NULL, "No datastores available."));
+		goto unlock;
+	}
+
 	if (0 == is_maxlatency && 0 != count)
 		latency = latency / count;
 
@@ -2167,14 +2213,14 @@ int	check_vcenter_datastore_read(AGENT_REQUEST *request, const char *username, c
 		AGENT_RESULT *result)
 {
 	return check_vcenter_datastore_latency(request, username, password, "datastore/totalReadLatency[average]",
-			result);
+			ZBX_VMWARE_DS_READ_FILTER, result);
 }
 
 int	check_vcenter_datastore_write(AGENT_REQUEST *request, const char *username, const char *password,
 		AGENT_RESULT *result)
 {
 	return check_vcenter_datastore_latency(request, username, password, "datastore/totalWriteLatency[average]",
-			result);
+			ZBX_VMWARE_DS_WRITE_FILTER, result);
 }
 
 int	check_vcenter_vm_cpu_num(AGENT_REQUEST *request, const char *username, const char *password,
diff --git a/src/zabbix_server/vmware/vmware.c b/src/zabbix_server/vmware/vmware.c
index 522d3a9249..bf0daa29f8 100644
--- a/src/zabbix_server/vmware/vmware.c
+++ b/src/zabbix_server/vmware/vmware.c
@@ -107,7 +107,7 @@ static zbx_vmware_t	*vmware = NULL;
 #define ZBX_VPXD_STATS_MAXQUERYMETRICS	64
 #define ZBX_MAXQUERYMETRICS_UNLIMITED	1000
 
-ZBX_VECTOR_IMPL(str_uint64_pair, zbx_str_uint64_pair_t)
+ZBX_PTR_VECTOR_IMPL(str_uint64_pair, zbx_str_uint64_pair_t)
 ZBX_PTR_VECTOR_IMPL(vmware_datastore, zbx_vmware_datastore_t *)
 
 /* VMware service object name mapping for vcenter and vsphere installations */
@@ -215,6 +215,9 @@ ZBX_VECTOR_IMPL(id_xmlnode, zbx_id_xmlnode_t)
 	"/*/*/*/*/*/*[local-name()='propSet'][*[local-name()='name'][text()='datastore']]"		\
 	"/*[local-name()='val']/*[@type='Datastore']"
 
+#define ZBX_XPATH_HV_DATASTORE_MOUNTINFO()								\
+	"/*/*/*/*/*[local-name()='objects'][*[local-name()='obj'][@type='Datastore'][text()='%s']]"
+
 #define ZBX_XPATH_HV_VMS()										\
 	"/*/*/*/*/*/*[local-name()='propSet'][*[local-name()='name'][text()='vm']]"			\
 	"/*[local-name()='val']/*[@type='VirtualMachine']"
@@ -262,6 +265,11 @@ ZBX_VECTOR_IMPL(id_xmlnode, zbx_id_xmlnode_t)
 	"/*/*/*/*/*/*[local-name()='propSet'][*[local-name()='name'][text()='" property "']]"		\
 		"/*[local-name()='val']"
 
+#define ZBX_XPATH_PROP_SUFFIX(property)									\
+	"*[local-name()='propSet'][*[local-name()='name']"						\
+	"[substring(text(),string-length(text())-string-length('" property "')+1)='" property "']]"	\
+	"/*[local-name()='val']"
+
 #define ZBX_VM_NONAME_XML	"noname.xml"
 
 #define ZBX_PROPMAP(property)		{property, ZBX_XPATH_PROP_NAME(property)}
@@ -440,6 +448,33 @@ static size_t	curl_header_cb(void *ptr, size_t size, size_t nmemb, void *userdat
 	return size * nmemb;
 }
 
+/******************************************************************************
+ *                                                                            *
+ * Function: zbx_str_uint64_pair_free                                         *
+ *                                                                            *
+ * Purpose: free memory of vector element                                     *
+ *                                                                            *
+ ******************************************************************************/
+static void	zbx_str_uint64_pair_free(zbx_str_uint64_pair_t data)
+{
+	zbx_free(data.name);
+}
+
+/******************************************************************************
+ *                                                                            *
+ * Function: zbx_str_uint64_pair_name_compare                                 *
+ *                                                                            *
+ * Purpose: sorting function to sort zbx_str_uint64_pair_t vector by name     *
+ *                                                                            *
+ ******************************************************************************/
+int	zbx_str_uint64_pair_name_compare(const void *p1, const void *p2)
+{
+	const zbx_str_uint64_pair_t	*v1 = (const zbx_str_uint64_pair_t *)p1;
+	const zbx_str_uint64_pair_t	*v2 = (const zbx_str_uint64_pair_t *)p2;
+
+	return strcmp(v1->name, v2->name);
+}
+
 /******************************************************************************
  *                                                                            *
  * Function: zbx_http_post                                                    *
@@ -792,8 +827,8 @@ static void	vmware_datastore_shared_free(zbx_vmware_datastore_t *datastore)
 	if (NULL != datastore->uuid)
 		vmware_shared_strfree(datastore->uuid);
 
-	zbx_vector_str_clear_ext(&datastore->hv_uuids, vmware_shared_strfree);
-	zbx_vector_str_destroy(&datastore->hv_uuids);
+	vmware_vector_str_uint64_pair_shared_clean(&datastore->hv_uuids_access);
+	zbx_vector_str_uint64_pair_destroy(&datastore->hv_uuids_access);
 
 	__vm_mem_free_func(datastore);
 }
@@ -1153,15 +1188,21 @@ static zbx_vmware_datastore_t	*vmware_datastore_shared_dup(const zbx_vmware_data
 	datastore->uuid = vmware_shared_strdup(src->uuid);
 	datastore->name = vmware_shared_strdup(src->name);
 	datastore->id = vmware_shared_strdup(src->id);
-	VMWARE_VECTOR_CREATE(&datastore->hv_uuids, str);
-	zbx_vector_str_reserve(&datastore->hv_uuids, src->hv_uuids.values_num);
+	VMWARE_VECTOR_CREATE(&datastore->hv_uuids_access, str_uint64_pair);
+	zbx_vector_str_uint64_pair_reserve(&datastore->hv_uuids_access, src->hv_uuids_access.values_num);
 
 	datastore->capacity = src->capacity;
 	datastore->free_space = src->free_space;
 	datastore->uncommitted = src->uncommitted;
 
-	for (i = 0; i < src->hv_uuids.values_num; i++)
-		zbx_vector_str_append(&datastore->hv_uuids, vmware_shared_strdup(src->hv_uuids.values[i]));
+	for (i = 0; i < src->hv_uuids_access.values_num; i++)
+	{
+		zbx_str_uint64_pair_t	val;
+
+		val.name = vmware_shared_strdup(src->hv_uuids_access.values[i].name);
+		val.value = src->hv_uuids_access.values[i].value;
+		zbx_vector_str_uint64_pair_append_ptr(&datastore->hv_uuids_access, &val);
+	}
 
 	return datastore;
 }
@@ -1390,8 +1431,8 @@ static zbx_vmware_data_t	*vmware_data_shared_dup(zbx_vmware_data_t *src)
  ******************************************************************************/
 static void	vmware_datastore_free(zbx_vmware_datastore_t *datastore)
 {
-	zbx_vector_str_clear_ext(&datastore->hv_uuids, zbx_str_free);
-	zbx_vector_str_destroy(&datastore->hv_uuids);
+	zbx_vector_str_uint64_pair_clear_ext(&datastore->hv_uuids_access, zbx_str_uint64_pair_free);
+	zbx_vector_str_uint64_pair_destroy(&datastore->hv_uuids_access);
 
 	zbx_free(datastore->name);
 	zbx_free(datastore->uuid);
@@ -2586,7 +2627,7 @@ static zbx_vmware_datastore_t	*vmware_service_create_datastore(const zbx_vmware_
 	datastore->capacity = capacity;
 	datastore->free_space = free_space;
 	datastore->uncommitted = uncommitted;
-	zbx_vector_str_create(&datastore->hv_uuids);
+	zbx_vector_str_uint64_pair_create(&datastore->hv_uuids_access);
 out:
 	zbx_xml_free_doc(doc);
 
@@ -2622,24 +2663,37 @@ out:
 static int	vmware_service_get_hv_data(const zbx_vmware_service_t *service, CURL *easyhandle, const char *hvid,
 		const zbx_vmware_propmap_t *propmap, int props_num, xmlDoc **xdoc, char **error)
 {
-#	define ZBX_POST_HV_DETAILS 								\
-		ZBX_POST_VSPHERE_HEADER								\
-		"<ns0:RetrievePropertiesEx>"							\
-			"<ns0:_this type=\"PropertyCollector\">%s</ns0:_this>"			\
-			"<ns0:specSet>"								\
-				"<ns0:propSet>"							\
-					"<ns0:type>HostSystem</ns0:type>"			\
-					"<ns0:pathSet>vm</ns0:pathSet>"				\
-					"<ns0:pathSet>parent</ns0:pathSet>"			\
-					"<ns0:pathSet>datastore</ns0:pathSet>"			\
-					"%s"							\
-				"</ns0:propSet>"						\
-				"<ns0:objectSet>"						\
-					"<ns0:obj type=\"HostSystem\">%s</ns0:obj>"		\
-				"</ns0:objectSet>"						\
-			"</ns0:specSet>"							\
-			"<ns0:options/>"							\
-		"</ns0:RetrievePropertiesEx>"							\
+#	define ZBX_POST_HV_DETAILS 									\
+		ZBX_POST_VSPHERE_HEADER									\
+		"<ns0:RetrievePropertiesEx>"								\
+			"<ns0:_this type=\"PropertyCollector\">%s</ns0:_this>"				\
+			"<ns0:specSet>"									\
+				"<ns0:propSet>"								\
+					"<ns0:type>HostSystem</ns0:type>"				\
+					"<ns0:pathSet>vm</ns0:pathSet>"					\
+					"<ns0:pathSet>parent</ns0:pathSet>"				\
+					"<ns0:pathSet>datastore</ns0:pathSet>"				\
+					"%s"								\
+				"</ns0:propSet>"							\
+				"<ns0:propSet>"								\
+					"<ns0:type>Datastore</ns0:type>"				\
+					"<ns0:pathSet>host[\"%s\"].mountInfo.mounted</ns0:pathSet>"	\
+					"<ns0:pathSet>host[\"%s\"].mountInfo.accessible</ns0:pathSet>"	\
+					"<ns0:pathSet>host[\"%s\"].mountInfo.accessMode</ns0:pathSet>"	\
+				"</ns0:propSet>"							\
+				"<ns0:objectSet>"							\
+					"<ns0:obj type=\"HostSystem\">%s</ns0:obj>"			\
+					"<ns0:skip>false</ns0:skip>"					\
+					"<ns0:selectSet xsi:type=\"ns0:TraversalSpec\">"		\
+						"<ns0:name>DSObject</ns0:name>"				\
+						"<ns0:type>HostSystem</ns0:type>"			\
+						"<ns0:path>datastore</ns0:path>"			\
+						"<ns0:skip>false</ns0:skip>"				\
+					"</ns0:selectSet>"						\
+				"</ns0:objectSet>"							\
+			"</ns0:specSet>"								\
+			"<ns0:options/>"								\
+		"</ns0:RetrievePropertiesEx>"								\
 		ZBX_POST_VSPHERE_FOOTER
 
 	char	tmp[MAX_STRING_LEN], props[MAX_STRING_LEN], *hvid_esc;
@@ -2657,11 +2711,13 @@ static int	vmware_service_get_hv_data(const zbx_vmware_service_t *service, CURL
 
 	hvid_esc = xml_escape_dyn(hvid);
 
-	zbx_snprintf(tmp, sizeof(tmp), ZBX_POST_HV_DETAILS,
-			vmware_service_objects[service->type].property_collector, props, hvid_esc);
+	zbx_snprintf(tmp, sizeof(tmp), ZBX_POST_HV_DETAILS, vmware_service_objects[service->type].property_collector,
+			props, hvid_esc, hvid_esc, hvid_esc, hvid_esc);
 
 	zbx_free(hvid_esc);
 
+	zabbix_log(LOG_LEVEL_TRACE, "%s() SOAP request: %s", __func__, tmp);
+
 	if (SUCCEED != zbx_soap_post(__func__, easyhandle, tmp, xdoc, error))
 		goto out;
 
@@ -2839,6 +2895,91 @@ static int	vmware_ds_id_compare(const void *d1, const void *d2)
 	return strcmp(ds1->id, ds2->id);
 }
 
+/******************************************************************************
+ *                                                                            *
+ * Function: vmware_hv_get_ds_access                                          *
+ *                                                                            *
+ * Purpose: populate array of values from a xml data                          *
+ *                                                                            *
+ * Parameters: xdoc   - [IN] XML document                                     *
+ *             ds_id  - [IN] datastore id                                     *
+ *                                                                            *
+ * Return: Upon successful completion the function return SUCCEED.            *
+ *         Otherwise, FAIL is returned.                                       *
+ *                                                                            *
+ ******************************************************************************/
+static zbx_uint64_t	vmware_hv_get_ds_access(xmlDoc *xdoc, const char *ds_id)
+{
+
+	zbx_uint64_t		mi_access = ZBX_VMWARE_DS_NONE;
+	char			tmp[MAX_STRING_LEN];
+	xmlXPathContext		*xpathCtx;
+	xmlXPathObject		*xpathObj;
+	xmlNode			*xml_node;
+	char			*value;
+
+
+	zabbix_log(LOG_LEVEL_DEBUG, "In %s() for DS:%s", __func__, ds_id);
+
+	zbx_snprintf(tmp, sizeof(tmp), ZBX_XPATH_HV_DATASTORE_MOUNTINFO(), ds_id);
+	xpathCtx = xmlXPathNewContext(xdoc);
+
+	if (NULL == (xpathObj = xmlXPathEvalExpression((xmlChar *)tmp, xpathCtx)))
+	{
+		zabbix_log(LOG_LEVEL_DEBUG, "Cannot make montinfo parsing query for DS:%s", ds_id);
+		goto clean;
+	}
+
+	if (0 != xmlXPathNodeSetIsEmpty(xpathObj->nodesetval))
+	{
+		zabbix_log(LOG_LEVEL_DEBUG, "Cannot find items in mountinfo for DS:%s", ds_id);
+		goto clean;
+	}
+
+	xml_node = xpathObj->nodesetval->nodeTab[0];
+
+	if (NULL != (value = zbx_xml_read_node_value(xdoc, xml_node, ZBX_XPATH_PROP_SUFFIX("mounted"))))
+	{
+		if (0 == strcmp(value, "true"))
+			mi_access |= ZBX_VMWARE_DS_MOUNTED;
+
+		zbx_free(value);
+	}
+	else
+		zabbix_log(LOG_LEVEL_DEBUG, "Cannot find item 'mounted' in mountinfo for DS:%s", ds_id);
+
+	if (NULL != (value = zbx_xml_read_node_value(xdoc, xml_node, ZBX_XPATH_PROP_SUFFIX("accessible"))))
+	{
+		if (0 == strcmp(value, "true"))
+			mi_access |= ZBX_VMWARE_DS_ACCESSIBLE;
+
+		zbx_free(value);
+	}
+	else
+		zabbix_log(LOG_LEVEL_DEBUG, "Cannot find item 'accessible' in accessible for DS:%s", ds_id);
+
+	if (NULL != (value = zbx_xml_read_node_value(xdoc, xml_node, ZBX_XPATH_PROP_SUFFIX("accessMode"))))
+	{
+		if (0 == strcmp(value, "readWrite"))
+			mi_access |= ZBX_VMWARE_DS_READWRITE;
+		else
+			mi_access |= ZBX_VMWARE_DS_READ;
+
+		zbx_free(value);
+	}
+	else
+		zabbix_log(LOG_LEVEL_DEBUG, "Cannot find item 'accessMode' in mountinfo for DS:%s", ds_id);
+
+clean:
+	if (NULL != xpathObj)
+		xmlXPathFreeObject(xpathObj);
+
+	xmlXPathFreeContext(xpathCtx);
+	zabbix_log(LOG_LEVEL_DEBUG, "End of %s() mountinfo:" ZBX_FS_UI64, __func__, mi_access);
+
+	return mi_access;
+}
+
 /******************************************************************************
  *                                                                            *
  * Function: vmware_service_init_hv                                           *
@@ -2900,8 +3041,8 @@ static int	vmware_service_init_hv(zbx_vmware_service_t *service, CURL *easyhandl
 
 	for (i = 0; i < datastores.values_num; i++)
 	{
-		zbx_vmware_datastore_t *ds;
-		zbx_vmware_datastore_t ds_cmp;
+		zbx_vmware_datastore_t	*ds, ds_cmp;
+		zbx_str_uint64_pair_t	hv_ds_access;
 
 		ds_cmp.id = datastores.values[i];
 
@@ -2913,7 +3054,9 @@ static int	vmware_service_init_hv(zbx_vmware_service_t *service, CURL *easyhandl
 		}
 
 		ds = dss->values[j];
-		zbx_vector_str_append(&ds->hv_uuids, zbx_strdup(NULL, hv->uuid));
+		hv_ds_access.name = zbx_strdup(NULL, hv->uuid);
+		hv_ds_access.value = vmware_hv_get_ds_access(details, ds->id);
+		zbx_vector_str_uint64_pair_append_ptr(&ds->hv_uuids_access, &hv_ds_access);
 		zbx_vector_str_append(&hv->ds_names, zbx_strdup(NULL, ds->name));
 	}
 
@@ -4333,7 +4476,8 @@ static void	vmware_service_update(zbx_vmware_service_t *service)
 
 	for (i = 0; i < data->datastores.values_num; i++)
 	{
-		zbx_vector_str_sort(&data->datastores.values[i]->hv_uuids, ZBX_DEFAULT_STR_COMPARE_FUNC);
+		zbx_vector_str_uint64_pair_sort(&data->datastores.values[i]->hv_uuids_access,
+				zbx_str_uint64_pair_name_compare);
 	}
 
 	zbx_vector_vmware_datastore_sort(&data->datastores, vmware_ds_name_compare);
diff --git a/src/zabbix_server/vmware/vmware.h b/src/zabbix_server/vmware/vmware.h
index e74759caff..d9d17f5205 100644
--- a/src/zabbix_server/vmware/vmware.h
+++ b/src/zabbix_server/vmware/vmware.h
@@ -50,7 +50,8 @@ typedef struct
 }
 zbx_str_uint64_pair_t;
 
-ZBX_VECTOR_DECL(str_uint64_pair, zbx_str_uint64_pair_t)
+ZBX_PTR_VECTOR_DECL(str_uint64_pair, zbx_str_uint64_pair_t)
+int	zbx_str_uint64_pair_name_compare(const void *p1, const void *p2);
 
 /* performance counter data */
 typedef struct
@@ -94,15 +95,24 @@ typedef struct
 }
 zbx_vmware_perf_entity_t;
 
+#define ZBX_VMWARE_DS_NONE		0
+#define ZBX_VMWARE_DS_MOUNTED		1
+#define ZBX_VMWARE_DS_ACCESSIBLE	2
+#define ZBX_VMWARE_DS_READ		4
+#define ZBX_VMWARE_DS_WRITE		8
+#define ZBX_VMWARE_DS_READWRITE		(ZBX_VMWARE_DS_READ | ZBX_VMWARE_DS_WRITE)
+#define ZBX_VMWARE_DS_READ_FILTER	(ZBX_VMWARE_DS_MOUNTED | ZBX_VMWARE_DS_ACCESSIBLE | ZBX_VMWARE_DS_READ)
+#define ZBX_VMWARE_DS_WRITE_FILTER	(ZBX_VMWARE_DS_MOUNTED | ZBX_VMWARE_DS_ACCESSIBLE | ZBX_VMWARE_DS_READWRITE)
+
 typedef struct
 {
-	char			*name;
-	char			*uuid;
-	char			*id;
-	zbx_uint64_t		capacity;
-	zbx_uint64_t		free_space;
-	zbx_uint64_t		uncommitted;
-	zbx_vector_str_t	hv_uuids;
+	char				*name;
+	char				*uuid;
+	char				*id;
+	zbx_uint64_t			capacity;
+	zbx_uint64_t			free_space;
+	zbx_uint64_t			uncommitted;
+	zbx_vector_str_uint64_pair_t	hv_uuids_access;
 }
 zbx_vmware_datastore_t;
 
