@cryptotaxi247 / netdata-1 / commits / fdeacfd8d

HyperV Adjusts (windows.plugin) (#19623)

* adjust_hyperv: Address issue when there is no instances (memory) * adjust_hyperv: Address issue when there is no instances (partition vid) * adjust_hyperv: Address issue when there is no instances (partition root) * adjust_hyperv: Address issue when there is no instances (storage device) * adjust_hyperv: Address issue when there is no instances (switch) * adjust_hyperv: Format * adjust_hyperv: Address issue when there is no instances (network) * adjust_hyperv: Use only one standard * adjust_hyperv: Address issue when there is no instances (processor) * adjust_hyperv: Format (Part II)

thiagoftsm committed Feb 12, 2025 at 12:24 UTC fdeacfd8d9564b78f76036eb8259350934250a02
1 file changed +1131 -929
src/collectors/windows.plugin/perflib-hyperv.c
+1131 -929
@@ -112,14 +112,109 @@ void dict_hyperv_partition_insert_cb(const DICTIONARY_ITEM *item __maybe_unused,
112 initialize_hyperv_partition_keys(p);
113 }
114
115 +static void hyperv_memory_chart(struct hypervisor_memory *p, int update_every)
116 +{
117 + if (!p->collected_metadata) {
118 + p->collected_metadata = true;
119 + }
120 +
121 + if (!p->charts_created) {
122 + p->charts_created = true;
123 + if (!p->st_vm_memory_physical) {
124 + p->st_vm_memory_physical = rrdset_create_localhost(
125 + "vm_memory_physical",
126 + windows_shared_buffer,
127 + NULL,
128 + HYPERV,
129 + HYPERV ".vm_memory_physical",
130 + "VM assigned memory",
131 + "bytes",
132 + _COMMON_PLUGIN_NAME,
133 + _COMMON_PLUGIN_MODULE_NAME,
134 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_MEMORY_PHYSICAL,
135 + update_every,
136 + RRDSET_TYPE_LINE);
137 +
138 + p->st_vm_memory_physical_guest_visible = rrdset_create_localhost(
139 + "vm_memory_physical_guest_visible",
140 + windows_shared_buffer,
141 + NULL,
142 + HYPERV,
143 + HYPERV ".vm_memory_physical_guest_visible",
144 + "VM guest visible memory",
145 + "bytes",
146 + _COMMON_PLUGIN_NAME,
147 + _COMMON_PLUGIN_MODULE_NAME,
148 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_MEMORY_PHYSICAL_GUEST_VISIBLE,
149 + update_every,
150 + RRDSET_TYPE_LINE);
151 +
152 + p->st_pressure = rrdset_create_localhost(
153 + "vm_memory_pressure_current",
154 + windows_shared_buffer,
155 + NULL,
156 + HYPERV,
157 + HYPERV ".vm_memory_pressure_current",
158 + "VM Memory Pressure",
159 + "percentage",
160 + _COMMON_PLUGIN_NAME,
161 + _COMMON_PLUGIN_MODULE_NAME,
162 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_MEMORY_PRESSURE_CURRENT,
163 + update_every,
164 + RRDSET_TYPE_LINE);
165 +
166 + p->rd_CurrentPressure = rrddim_add(p->st_pressure, "pressure", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
167 + p->rd_PhysicalMemory =
168 + rrddim_add(p->st_vm_memory_physical, "assigned", NULL, 1024 * 1024, 1, RRD_ALGORITHM_ABSOLUTE);
169 + p->rd_GuestVisiblePhysicalMemory = rrddim_add(
170 + p->st_vm_memory_physical_guest_visible, "visible", NULL, 1024 * 1024, 1, RRD_ALGORITHM_ABSOLUTE);
171 + p->rd_GuestAvailableMemory = rrddim_add(
172 + p->st_vm_memory_physical_guest_visible, "available", NULL, 1024 * 1024, 1, RRD_ALGORITHM_ABSOLUTE);
173 +
174 + rrdlabels_add(p->st_vm_memory_physical->rrdlabels, "vm_name", windows_shared_buffer, RRDLABEL_SRC_AUTO);
175 + rrdlabels_add(p->st_pressure->rrdlabels, "vm_name", windows_shared_buffer, RRDLABEL_SRC_AUTO);
176 + rrdlabels_add(
177 + p->st_vm_memory_physical_guest_visible->rrdlabels, "vm_name", windows_shared_buffer, RRDLABEL_SRC_AUTO);
178 + }
179 + }
180 +
181 + SETP_DIM_VALUE(st_pressure, CurrentPressure);
182 + SETP_DIM_VALUE(st_vm_memory_physical, PhysicalMemory);
183 + SETP_DIM_VALUE(st_vm_memory_physical_guest_visible, GuestVisiblePhysicalMemory);
184 + SETP_DIM_VALUE(st_vm_memory_physical_guest_visible, GuestAvailableMemory);
185 +
186 + rrdset_done(p->st_pressure);
187 + rrdset_done(p->st_vm_memory_physical);
188 + rrdset_done(p->st_vm_memory_physical_guest_visible);
189 +}
190 +
191 static bool do_hyperv_memory(PERF_DATA_BLOCK *pDataBlock, int update_every, void *data)
192 {
193 hyperv_perf_item *item = data;
194 + struct hypervisor_memory *p;
195
196 PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, item->registry_name);
197 if (!pObjectType)
198 return false;
199
200 + if (!pObjectType->NumInstances) {
201 + static struct hypervisor_memory static_mem = {};
202 + p = &static_mem;
203 +
204 + if (!p->charts_created) {
205 + initialize_hyperv_memory_keys(p);
206 + strncpyz(windows_shared_buffer, "[unknown]", sizeof(windows_shared_buffer) - 1);
207 + }
208 +
209 + GET_OBJECT_COUNTER(CurrentPressure);
210 + GET_OBJECT_COUNTER(PhysicalMemory);
211 + GET_OBJECT_COUNTER(GuestVisiblePhysicalMemory);
212 + GET_OBJECT_COUNTER(GuestAvailableMemory);
213 +
214 + hyperv_memory_chart(p, update_every);
215 + return true;
216 + }
217 +
218 PERF_INSTANCE_DEFINITION *pi = NULL;
219 for (LONG i = 0; i < pObjectType->NumInstances; i++) {
220 pi = perflibForEachInstance(pDataBlock, pObjectType, pi);
@@ -129,99 +224,96 @@ static bool do_hyperv_memory(PERF_DATA_BLOCK *pDataBlock, int update_every, void
224 get_and_sanitize_instance_value(
225 pDataBlock, pObjectType, pi, windows_shared_buffer, sizeof(windows_shared_buffer));
226
132 - struct hypervisor_memory *p = dictionary_set(item->instance, windows_shared_buffer, NULL, sizeof(*p));
133 -
134 - if (!p->collected_metadata) {
135 - p->collected_metadata = true;
136 - }
227 + p = dictionary_set(item->instance, windows_shared_buffer, NULL, sizeof(*p));
228
229 GET_INSTANCE_COUNTER(CurrentPressure);
230 GET_INSTANCE_COUNTER(PhysicalMemory);
231 GET_INSTANCE_COUNTER(GuestVisiblePhysicalMemory);
232 GET_INSTANCE_COUNTER(GuestAvailableMemory);
233 + hyperv_memory_chart(p, update_every);
234 + }
235
143 - if (!p->charts_created) {
144 - p->charts_created = true;
145 - if (!p->st_vm_memory_physical) {
146 - p->st_vm_memory_physical = rrdset_create_localhost(
147 - "vm_memory_physical",
148 - windows_shared_buffer,
149 - NULL,
150 - HYPERV,
151 - HYPERV ".vm_memory_physical",
152 - "VM assigned memory",
153 - "bytes",
154 - _COMMON_PLUGIN_NAME,
155 - _COMMON_PLUGIN_MODULE_NAME,
156 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_MEMORY_PHYSICAL,
157 - update_every,
158 - RRDSET_TYPE_LINE);
159 -
160 - p->st_vm_memory_physical_guest_visible = rrdset_create_localhost(
161 - "vm_memory_physical_guest_visible",
162 - windows_shared_buffer,
163 - NULL,
164 - HYPERV,
165 - HYPERV ".vm_memory_physical_guest_visible",
166 - "VM guest visible memory",
167 - "bytes",
168 - _COMMON_PLUGIN_NAME,
169 - _COMMON_PLUGIN_MODULE_NAME,
170 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_MEMORY_PHYSICAL_GUEST_VISIBLE,
171 - update_every,
172 - RRDSET_TYPE_LINE);
173 -
174 - p->st_pressure = rrdset_create_localhost(
175 - "vm_memory_pressure_current",
176 - windows_shared_buffer,
177 - NULL,
178 - HYPERV,
179 - HYPERV ".vm_memory_pressure_current",
180 - "VM Memory Pressure",
181 - "percentage",
182 - _COMMON_PLUGIN_NAME,
183 - _COMMON_PLUGIN_MODULE_NAME,
184 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_MEMORY_PRESSURE_CURRENT,
185 - update_every,
186 - RRDSET_TYPE_LINE);
187 -
188 - p->rd_CurrentPressure = rrddim_add(p->st_pressure, "pressure", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
189 - p->rd_PhysicalMemory =
190 - rrddim_add(p->st_vm_memory_physical, "assigned", NULL, 1024 * 1024, 1, RRD_ALGORITHM_ABSOLUTE);
191 - p->rd_GuestVisiblePhysicalMemory = rrddim_add(
192 - p->st_vm_memory_physical_guest_visible, "visible", NULL, 1024 * 1024, 1, RRD_ALGORITHM_ABSOLUTE);
193 - p->rd_GuestAvailableMemory = rrddim_add(
194 - p->st_vm_memory_physical_guest_visible, "available", NULL, 1024 * 1024, 1, RRD_ALGORITHM_ABSOLUTE);
195 -
196 - rrdlabels_add(p->st_vm_memory_physical->rrdlabels, "vm_name", windows_shared_buffer, RRDLABEL_SRC_AUTO);
197 - rrdlabels_add(p->st_pressure->rrdlabels, "vm_name", windows_shared_buffer, RRDLABEL_SRC_AUTO);
198 - rrdlabels_add(
199 - p->st_vm_memory_physical_guest_visible->rrdlabels,
200 - "vm_name",
201 - windows_shared_buffer,
202 - RRDLABEL_SRC_AUTO);
203 - }
204 - }
236 + return true;
237 +}
238 +
239 +static void hyperv_vid_partition_chart(struct hypervisor_partition *p, int update_every)
240 +{
241 + if (!p->collected_metadata) {
242 + p->collected_metadata = true;
243 + }
244 +
245 + if (!p->charts_created) {
246 + p->charts_created = true;
247 +
248 + p->st_vm_vid_physical_pages_allocated = rrdset_create_localhost(
249 + "vm_vid_physical_pages_allocated",
250 + windows_shared_buffer,
251 + NULL,
252 + HYPERV,
253 + HYPERV ".vm_vid_physical_pages_allocated",
254 + "VM physical pages allocated",
255 + "pages",
256 + _COMMON_PLUGIN_NAME,
257 + _COMMON_PLUGIN_MODULE_NAME,
258 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_VID_PHYSICAL_PAGES_ALLOCATED,
259 + update_every,
260 + RRDSET_TYPE_LINE);
261 +
262 + p->st_vm_vid_remote_physical_pages = rrdset_create_localhost(
263 + "vm_vid_remote_physical_pages",
264 + windows_shared_buffer,
265 + NULL,
266 + HYPERV,
267 + HYPERV ".vm_vid_remote_physical_pages",
268 + "VM physical pages not allocated from the preferred NUMA node",
269 + "pages",
270 + _COMMON_PLUGIN_NAME,
271 + _COMMON_PLUGIN_MODULE_NAME,
272 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_VID_REMOTE_PHYSICAL_PAGES,
273 + update_every,
274 + RRDSET_TYPE_LINE);
275
206 - SETP_DIM_VALUE(st_pressure, CurrentPressure);
207 - SETP_DIM_VALUE(st_vm_memory_physical, PhysicalMemory);
208 - SETP_DIM_VALUE(st_vm_memory_physical_guest_visible, GuestVisiblePhysicalMemory);
209 - SETP_DIM_VALUE(st_vm_memory_physical_guest_visible, GuestAvailableMemory);
276 + p->rd_PhysicalPagesAllocated =
277 + rrddim_add(p->st_vm_vid_physical_pages_allocated, "allocated", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
278 + p->rd_RemotePhysicalPages =
279 + rrddim_add(p->st_vm_vid_remote_physical_pages, "remote_physical", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
280
211 - rrdset_done(p->st_pressure);
212 - rrdset_done(p->st_vm_memory_physical);
213 - rrdset_done(p->st_vm_memory_physical_guest_visible);
281 + rrdlabels_add(
282 + p->st_vm_vid_physical_pages_allocated->rrdlabels, "vm_name", windows_shared_buffer, RRDLABEL_SRC_AUTO);
283 + rrdlabels_add(
284 + p->st_vm_vid_remote_physical_pages->rrdlabels, "vm_name", windows_shared_buffer, RRDLABEL_SRC_AUTO);
285 }
286
216 - return true;
287 + SETP_DIM_VALUE(st_vm_vid_remote_physical_pages, RemotePhysicalPages);
288 + SETP_DIM_VALUE(st_vm_vid_physical_pages_allocated, PhysicalPagesAllocated);
289 +
290 + rrdset_done(p->st_vm_vid_physical_pages_allocated);
291 + rrdset_done(p->st_vm_vid_remote_physical_pages);
292 }
293
294 static bool do_hyperv_vid_partition(PERF_DATA_BLOCK *pDataBlock, int update_every, void *data)
295 {
296 hyperv_perf_item *item = data;
297 + struct hypervisor_partition *p;
298 PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, item->registry_name);
223 - if (!pObjectType)
299 + if (!pObjectType) {
300 + static struct hypervisor_partition static_partition = {};
301 + p = &static_partition;
302 + if (!p->charts_created) {
303 + initialize_hyperv_partition_keys(p);
304 + strncpyz(windows_shared_buffer, "[unknown]", sizeof(windows_shared_buffer) - 1);
305 + }
306 +
307 + GET_OBJECT_COUNTER(RemotePhysicalPages);
308 + GET_OBJECT_COUNTER(PhysicalPagesAllocated);
309 +
310 + hyperv_vid_partition_chart(p, update_every);
311 + return true;
312 + }
313 +
314 + if (!pObjectType->NumInstances) {
315 return false;
316 + }
317
318 PERF_INSTANCE_DEFINITION *pi = NULL;
319 for (LONG i = 0; i < pObjectType->NumInstances; i++) {
@@ -232,11 +324,7 @@ static bool do_hyperv_vid_partition(PERF_DATA_BLOCK *pDataBlock, int update_ever
324 get_and_sanitize_instance_value(
325 pDataBlock, pObjectType, pi, windows_shared_buffer, sizeof(windows_shared_buffer));
326
235 - struct hypervisor_partition *p = dictionary_set(item->instance, windows_shared_buffer, NULL, sizeof(*p));
236 -
237 - if (!p->collected_metadata) {
238 - p->collected_metadata = true;
239 - }
327 + p = dictionary_set(item->instance, windows_shared_buffer, NULL, sizeof(*p));
328
329 if (strcasecmp(windows_shared_buffer, "_Total") == 0)
330 continue;
@@ -244,53 +332,7 @@ static bool do_hyperv_vid_partition(PERF_DATA_BLOCK *pDataBlock, int update_ever
332 GET_INSTANCE_COUNTER(RemotePhysicalPages);
333 GET_INSTANCE_COUNTER(PhysicalPagesAllocated);
334
247 - if (!p->charts_created) {
248 - p->charts_created = true;
249 -
250 - p->st_vm_vid_physical_pages_allocated = rrdset_create_localhost(
251 - "vm_vid_physical_pages_allocated",
252 - windows_shared_buffer,
253 - NULL,
254 - HYPERV,
255 - HYPERV ".vm_vid_physical_pages_allocated",
256 - "VM physical pages allocated",
257 - "pages",
258 - _COMMON_PLUGIN_NAME,
259 - _COMMON_PLUGIN_MODULE_NAME,
260 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_VID_PHYSICAL_PAGES_ALLOCATED,
261 - update_every,
262 - RRDSET_TYPE_LINE);
263 -
264 - p->st_vm_vid_remote_physical_pages = rrdset_create_localhost(
265 - "vm_vid_remote_physical_pages",
266 - windows_shared_buffer,
267 - NULL,
268 - HYPERV,
269 - HYPERV ".vm_vid_remote_physical_pages",
270 - "VM physical pages not allocated from the preferred NUMA node",
271 - "pages",
272 - _COMMON_PLUGIN_NAME,
273 - _COMMON_PLUGIN_MODULE_NAME,
274 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_VID_REMOTE_PHYSICAL_PAGES,
275 - update_every,
276 - RRDSET_TYPE_LINE);
277 -
278 - p->rd_PhysicalPagesAllocated =
279 - rrddim_add(p->st_vm_vid_physical_pages_allocated, "allocated", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
280 - p->rd_RemotePhysicalPages =
281 - rrddim_add(p->st_vm_vid_remote_physical_pages, "remote_physical", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
282 -
283 - rrdlabels_add(
284 - p->st_vm_vid_physical_pages_allocated->rrdlabels, "vm_name", windows_shared_buffer, RRDLABEL_SRC_AUTO);
285 - rrdlabels_add(
286 - p->st_vm_vid_remote_physical_pages->rrdlabels, "vm_name", windows_shared_buffer, RRDLABEL_SRC_AUTO);
287 - }
288 -
289 - SETP_DIM_VALUE(st_vm_vid_remote_physical_pages, RemotePhysicalPages);
290 - SETP_DIM_VALUE(st_vm_vid_physical_pages_allocated, PhysicalPagesAllocated);
291 -
292 - rrdset_done(p->st_vm_vid_physical_pages_allocated);
293 - rrdset_done(p->st_vm_vid_remote_physical_pages);
335 + hyperv_vid_partition_chart(p, update_every);
336 }
337
338 return true;
@@ -446,14 +488,295 @@ void dict_hyperv_root_partition_insert_cb(
488 }
489
490 // Function to handle "Hyper-V Hypervisor Root Partition" metrics (Device Space and GPA Space)
491 +static void hyperv_root_partition_chart(struct hypervisor_root_partition *p, int update_every)
492 +{
493 + if (!p->collected_metadata) {
494 + p->collected_metadata = true;
495 + }
496 +
497 + // Create charts
498 + if (!p->charts_created) {
499 + p->charts_created = true;
500 + p->st_device_space_pages = rrdset_create_localhost(
501 + "root_partition_device_space_pages",
502 + windows_shared_buffer,
503 + NULL,
504 + HYPERV,
505 + HYPERV ".root_partition_device_space_pages",
506 + "Root partition device space pages",
507 + "pages",
508 + _COMMON_PLUGIN_NAME,
509 + _COMMON_PLUGIN_MODULE_NAME,
510 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_DEVICE_SPACE_PAGES,
511 + update_every,
512 + RRDSET_TYPE_LINE);
513 +
514 + p->rd_DeviceSpacePages4K = rrddim_add(p->st_device_space_pages, "4K", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
515 + p->rd_DeviceSpacePages2M = rrddim_add(p->st_device_space_pages, "2M", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
516 + p->rd_DeviceSpacePages1G = rrddim_add(p->st_device_space_pages, "1G", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
517 +
518 + p->st_gpa_space_pages = rrdset_create_localhost(
519 + "root_partition_gpa_space_pages",
520 + windows_shared_buffer,
521 + NULL,
522 + HYPERV,
523 + HYPERV ".root_partition_gpa_space_pages",
524 + "Root partition GPA space pages",
525 + "pages",
526 + _COMMON_PLUGIN_NAME,
527 + _COMMON_PLUGIN_MODULE_NAME,
528 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_GPA_SPACE_PAGES,
529 + update_every,
530 + RRDSET_TYPE_LINE);
531 +
532 + p->rd_GPASpacePages4K = rrddim_add(p->st_gpa_space_pages, "4K", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
533 + p->rd_GPASpacePages2M = rrddim_add(p->st_gpa_space_pages, "2M", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
534 + p->rd_GPASpacePages1G = rrddim_add(p->st_gpa_space_pages, "1G", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
535 +
536 + p->st_gpa_space_modifications = rrdset_create_localhost(
537 + "root_partition_gpa_space_modifications",
538 + windows_shared_buffer,
539 + NULL,
540 + HYPERV,
541 + HYPERV ".root_partition_gpa_space_modifications",
542 + "Root partition GPA space modifications",
543 + "modifications/s",
544 + _COMMON_PLUGIN_NAME,
545 + _COMMON_PLUGIN_MODULE_NAME,
546 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_GPA_SPACE_MODIFICATIONS,
547 + update_every,
548 + RRDSET_TYPE_LINE);
549 +
550 + p->rd_GPASpaceModifications =
551 + rrddim_add(p->st_gpa_space_modifications, "gpa", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
552 +
553 + p->st_attached_devices = rrdset_create_localhost(
554 + "root_partition_attached_devices",
555 + windows_shared_buffer,
556 + NULL,
557 + HYPERV,
558 + HYPERV ".root_partition_attached_devices",
559 + "Root partition attached devices",
560 + "devices",
561 + _COMMON_PLUGIN_NAME,
562 + _COMMON_PLUGIN_MODULE_NAME,
563 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_ATTACHED_DEVICES,
564 + update_every,
565 + RRDSET_TYPE_LINE);
566 +
567 + p->rd_AttachedDevices = rrddim_add(p->st_attached_devices, "attached", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
568 +
569 + p->st_deposited_pages = rrdset_create_localhost(
570 + "root_partition_deposited_pages",
571 + windows_shared_buffer,
572 + NULL,
573 + HYPERV,
574 + HYPERV ".root_partition_deposited_pages",
575 + "Root partition deposited pages",
576 + "pages",
577 + _COMMON_PLUGIN_NAME,
578 + _COMMON_PLUGIN_MODULE_NAME,
579 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_DEPOSITED_PAGES,
580 + update_every,
581 + RRDSET_TYPE_LINE);
582 +
583 + p->rd_DepositedPages = rrddim_add(p->st_deposited_pages, "gpa", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
584 +
585 + p->st_DeviceDMAErrors = rrdset_create_localhost(
586 + "root_partition_device_dma_errors",
587 + windows_shared_buffer,
588 + NULL,
589 + HYPERV,
590 + HYPERV ".root_partition_device_dma_errors",
591 + "Root partition illegal DMA requests",
592 + "requests",
593 + _COMMON_PLUGIN_NAME,
594 + _COMMON_PLUGIN_MODULE_NAME,
595 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_DEVICE_DMA_ERRORS,
596 + update_every,
597 + RRDSET_TYPE_LINE);
598 +
599 + p->rd_DeviceDMAErrors = rrddim_add(p->st_DeviceDMAErrors, "illegal_dma", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
600 +
601 + p->st_DeviceInterruptErrors = rrdset_create_localhost(
602 + "root_partition_device_interrupt_errors",
603 + windows_shared_buffer,
604 + NULL,
605 + HYPERV,
606 + HYPERV ".root_partition_device_interrupt_errors",
607 + "Root partition illegal interrupt requests",
608 + "requests",
609 + _COMMON_PLUGIN_NAME,
610 + _COMMON_PLUGIN_MODULE_NAME,
611 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_DEVICE_INTERRUPT_ERRORS,
612 + update_every,
613 + RRDSET_TYPE_LINE);
614 +
615 + p->rd_DeviceInterruptErrors =
616 + rrddim_add(p->st_DeviceInterruptErrors, "illegal_interrupt", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
617 +
618 + p->st_DeviceInterruptThrottleEvents = rrdset_create_localhost(
619 + "root_partition_device_interrupt_throttle_events",
620 + windows_shared_buffer,
621 + NULL,
622 + HYPERV,
623 + HYPERV ".root_partition_device_interrupt_throttle_events",
624 + "Root partition throttled interrupts",
625 + "events",
626 + _COMMON_PLUGIN_NAME,
627 + _COMMON_PLUGIN_MODULE_NAME,
628 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_DEVICE_INTERRUPT_THROTTLE_EVENTS,
629 + update_every,
630 + RRDSET_TYPE_LINE);
631 +
632 + p->rd_DeviceInterruptThrottleEvents =
633 + rrddim_add(p->st_DeviceInterruptThrottleEvents, "throttling", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
634 +
635 + p->st_IOΤLBFlushesSec = rrdset_create_localhost(
636 + "root_partition_io_tlb_flush",
637 + windows_shared_buffer,
638 + NULL,
639 + HYPERV,
640 + HYPERV ".root_partition_io_tlb_flush",
641 + "Root partition flushes of I/O TLBs",
642 + "flushes/s",
643 + _COMMON_PLUGIN_NAME,
644 + _COMMON_PLUGIN_MODULE_NAME,
645 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_IO_TLB_FLUSH,
646 + update_every,
647 + RRDSET_TYPE_LINE);
648 +
649 + p->rd_IOΤLBFlushesSec = rrddim_add(p->st_IOΤLBFlushesSec, "gpa", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
650 +
651 + p->st_AddressSpaces = rrdset_create_localhost(
652 + "root_partition_address_space",
653 + windows_shared_buffer,
654 + NULL,
655 + HYPERV,
656 + HYPERV ".root_partition_address_space",
657 + "Root partition address spaces in the virtual TLB",
658 + "address spaces",
659 + _COMMON_PLUGIN_NAME,
660 + _COMMON_PLUGIN_MODULE_NAME,
661 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_ADDRESS_SPACE,
662 + update_every,
663 + RRDSET_TYPE_LINE);
664 +
665 + p->rd_AddressSpaces = rrddim_add(p->st_AddressSpaces, "address_spaces", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
666 +
667 + p->st_VirtualTLBPages = rrdset_create_localhost(
668 + "root_partition_virtual_tlb_pages",
669 + windows_shared_buffer,
670 + NULL,
671 + HYPERV,
672 + HYPERV ".root_partition_virtual_tlb_pages",
673 + "Root partition pages used by the virtual TLB",
674 + "pages",
675 + _COMMON_PLUGIN_NAME,
676 + _COMMON_PLUGIN_MODULE_NAME,
677 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_VIRTUAL_TLB_PAGES,
678 + update_every,
679 + RRDSET_TYPE_LINE);
680 +
681 + p->rd_VirtualTLBPages = rrddim_add(p->st_VirtualTLBPages, "used", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
682 +
683 + p->st_VirtualTLBFlushEntiresSec = rrdset_create_localhost(
684 + "root_partition_virtual_tlb_flush_entries",
685 + windows_shared_buffer,
686 + NULL,
687 + HYPERV,
688 + HYPERV ".root_partition_virtual_tlb_flush_entries",
689 + "Root partition flushes of the entire virtual TLB",
690 + "flushes/s",
691 + _COMMON_PLUGIN_NAME,
692 + _COMMON_PLUGIN_MODULE_NAME,
693 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_VIRTUAL_TLB_FLUSH_ENTRIES,
694 + update_every,
695 + RRDSET_TYPE_LINE);
696 +
697 + p->rd_VirtualTLBFlushEntiresSec =
698 + rrddim_add(p->st_VirtualTLBFlushEntiresSec, "flushes", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
699 + }
700 +
701 + // Set the data for each dimension
702 +
703 + SETP_DIM_VALUE(st_device_space_pages, DeviceSpacePages4K);
704 + SETP_DIM_VALUE(st_device_space_pages, DeviceSpacePages2M);
705 + SETP_DIM_VALUE(st_device_space_pages, DeviceSpacePages1G);
706 +
707 + SETP_DIM_VALUE(st_gpa_space_pages, GPASpacePages4K);
708 + SETP_DIM_VALUE(st_gpa_space_pages, GPASpacePages2M);
709 + SETP_DIM_VALUE(st_gpa_space_pages, GPASpacePages1G);
710 +
711 + SETP_DIM_VALUE(st_gpa_space_modifications, GPASpaceModifications);
712 +
713 + SETP_DIM_VALUE(st_attached_devices, AttachedDevices);
714 + SETP_DIM_VALUE(st_deposited_pages, DepositedPages);
715 +
716 + SETP_DIM_VALUE(st_DeviceDMAErrors, DeviceDMAErrors);
717 + SETP_DIM_VALUE(st_DeviceInterruptErrors, DeviceInterruptErrors);
718 + SETP_DIM_VALUE(st_DeviceInterruptThrottleEvents, DeviceInterruptThrottleEvents);
719 + SETP_DIM_VALUE(st_IOΤLBFlushesSec, IOΤLBFlushesSec);
720 + SETP_DIM_VALUE(st_AddressSpaces, AddressSpaces);
721 + SETP_DIM_VALUE(st_VirtualTLBPages, VirtualTLBPages);
722 + SETP_DIM_VALUE(st_VirtualTLBFlushEntiresSec, VirtualTLBFlushEntiresSec);
723 +
724 + // Mark the charts as done
725 + rrdset_done(p->st_device_space_pages);
726 + rrdset_done(p->st_gpa_space_pages);
727 + rrdset_done(p->st_gpa_space_modifications);
728 + rrdset_done(p->st_attached_devices);
729 + rrdset_done(p->st_deposited_pages);
730 + rrdset_done(p->st_DeviceInterruptErrors);
731 + rrdset_done(p->st_DeviceInterruptThrottleEvents);
732 + rrdset_done(p->st_IOΤLBFlushesSec);
733 + rrdset_done(p->st_AddressSpaces);
734 + rrdset_done(p->st_DeviceDMAErrors);
735 + rrdset_done(p->st_VirtualTLBPages);
736 + rrdset_done(p->st_VirtualTLBFlushEntiresSec);
737 +}
738 +
739 static bool do_hyperv_root_partition(PERF_DATA_BLOCK *pDataBlock, int update_every, void *data)
740 {
741 hyperv_perf_item *item = data;
742 + struct hypervisor_root_partition *p;
743
744 PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, item->registry_name);
745 if (!pObjectType)
746 return false;
747
748 + if (!pObjectType->NumInstances) {
749 + static struct hypervisor_root_partition static_rpartition = {};
750 + p = &static_rpartition;
751 +
752 + if (!p->charts_created) {
753 + initialize_hyperv_root_partition_keys(p);
754 + strncpyz(windows_shared_buffer, "[unknown]", sizeof(windows_shared_buffer) - 1);
755 + }
756 +
757 + // Fetch counters
758 + GET_OBJECT_COUNTER(DeviceSpacePages4K);
759 + GET_OBJECT_COUNTER(DeviceSpacePages2M);
760 + GET_OBJECT_COUNTER(DeviceSpacePages1G);
761 + GET_OBJECT_COUNTER(GPASpacePages4K);
762 + GET_OBJECT_COUNTER(GPASpacePages2M);
763 + GET_OBJECT_COUNTER(GPASpacePages1G);
764 + GET_OBJECT_COUNTER(GPASpaceModifications);
765 + GET_OBJECT_COUNTER(AttachedDevices);
766 + GET_OBJECT_COUNTER(DepositedPages);
767 +
768 + GET_OBJECT_COUNTER(DeviceDMAErrors);
769 + GET_OBJECT_COUNTER(DeviceInterruptErrors);
770 + GET_OBJECT_COUNTER(DeviceInterruptThrottleEvents);
771 + GET_OBJECT_COUNTER(IOΤLBFlushesSec);
772 + GET_OBJECT_COUNTER(AddressSpaces);
773 + GET_OBJECT_COUNTER(VirtualTLBPages);
774 + GET_OBJECT_COUNTER(VirtualTLBFlushEntiresSec);
775 +
776 + hyperv_root_partition_chart(p, update_every);
777 + return true;
778 + }
779 +
780 PERF_INSTANCE_DEFINITION *pi = NULL;
781 for (LONG i = 0; i < pObjectType->NumInstances; i++) {
782 pi = perflibForEachInstance(pDataBlock, pObjectType, pi);
@@ -466,11 +789,7 @@ static bool do_hyperv_root_partition(PERF_DATA_BLOCK *pDataBlock, int update_eve
789 if (strcasecmp(windows_shared_buffer, "_Total") == 0)
790 continue;
791
469 - struct hypervisor_root_partition *p = dictionary_set(item->instance, windows_shared_buffer, NULL, sizeof(*p));
470 -
471 - if (!p->collected_metadata) {
472 - p->collected_metadata = true;
473 - }
792 + p = dictionary_set(item->instance, windows_shared_buffer, NULL, sizeof(*p));
793
794 // Fetch counters
795 GET_INSTANCE_COUNTER(DeviceSpacePages4K);
@@ -491,306 +810,172 @@ static bool do_hyperv_root_partition(PERF_DATA_BLOCK *pDataBlock, int update_eve
810 GET_INSTANCE_COUNTER(VirtualTLBPages);
811 GET_INSTANCE_COUNTER(VirtualTLBFlushEntiresSec);
812
494 - // Create charts
495 - if (!p->charts_created) {
496 - p->charts_created = true;
497 - p->st_device_space_pages = rrdset_create_localhost(
498 - "root_partition_device_space_pages",
499 - windows_shared_buffer,
500 - NULL,
501 - HYPERV,
502 - HYPERV ".root_partition_device_space_pages",
503 - "Root partition device space pages",
504 - "pages",
505 - _COMMON_PLUGIN_NAME,
506 - _COMMON_PLUGIN_MODULE_NAME,
507 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_DEVICE_SPACE_PAGES,
508 - update_every,
509 - RRDSET_TYPE_LINE);
813 + hyperv_root_partition_chart(p, update_every);
814 + }
815
511 - p->rd_DeviceSpacePages4K = rrddim_add(p->st_device_space_pages, "4K", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
512 - p->rd_DeviceSpacePages2M = rrddim_add(p->st_device_space_pages, "2M", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
513 - p->rd_DeviceSpacePages1G = rrddim_add(p->st_device_space_pages, "1G", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
816 + return true;
817 +}
818
515 - p->st_gpa_space_pages = rrdset_create_localhost(
516 - "root_partition_gpa_space_pages",
517 - windows_shared_buffer,
518 - NULL,
519 - HYPERV,
520 - HYPERV ".root_partition_gpa_space_pages",
521 - "Root partition GPA space pages",
522 - "pages",
523 - _COMMON_PLUGIN_NAME,
524 - _COMMON_PLUGIN_MODULE_NAME,
525 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_GPA_SPACE_PAGES,
526 - update_every,
527 - RRDSET_TYPE_LINE);
819 +// Storage DEVICE
820
529 - p->rd_GPASpacePages4K = rrddim_add(p->st_gpa_space_pages, "4K", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
530 - p->rd_GPASpacePages2M = rrddim_add(p->st_gpa_space_pages, "2M", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
531 - p->rd_GPASpacePages1G = rrddim_add(p->st_gpa_space_pages, "1G", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
821 +struct hypervisor_storage_device {
822 + bool collected_metadata;
823 + bool charts_created;
824
533 - p->st_gpa_space_modifications = rrdset_create_localhost(
534 - "root_partition_gpa_space_modifications",
535 - windows_shared_buffer,
536 - NULL,
537 - HYPERV,
538 - HYPERV ".root_partition_gpa_space_modifications",
539 - "Root partition GPA space modifications",
540 - "modifications/s",
541 - _COMMON_PLUGIN_NAME,
542 - _COMMON_PLUGIN_MODULE_NAME,
543 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_GPA_SPACE_MODIFICATIONS,
544 - update_every,
545 - RRDSET_TYPE_LINE);
546 -
547 - p->rd_GPASpaceModifications =
548 - rrddim_add(p->st_gpa_space_modifications, "gpa", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
825 + RRDSET *st_operations;
826 + DEFINE_RD(ReadOperationsSec);
827 + DEFINE_RD(WriteOperationsSec);
828
550 - p->st_attached_devices = rrdset_create_localhost(
551 - "root_partition_attached_devices",
552 - windows_shared_buffer,
553 - NULL,
554 - HYPERV,
555 - HYPERV ".root_partition_attached_devices",
556 - "Root partition attached devices",
557 - "devices",
558 - _COMMON_PLUGIN_NAME,
559 - _COMMON_PLUGIN_MODULE_NAME,
560 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_ATTACHED_DEVICES,
561 - update_every,
562 - RRDSET_TYPE_LINE);
829 + RRDSET *st_bytes;
830 + DEFINE_RD(ReadBytesSec);
831 + DEFINE_RD(WriteBytesSec);
832
564 - p->rd_AttachedDevices = rrddim_add(p->st_attached_devices, "attached", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
833 + RRDSET *st_errors;
834 + DEFINE_RD(ErrorCount);
835
566 - p->st_deposited_pages = rrdset_create_localhost(
567 - "root_partition_deposited_pages",
568 - windows_shared_buffer,
569 - NULL,
570 - HYPERV,
571 - HYPERV ".root_partition_deposited_pages",
572 - "Root partition deposited pages",
573 - "pages",
574 - _COMMON_PLUGIN_NAME,
575 - _COMMON_PLUGIN_MODULE_NAME,
576 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_DEPOSITED_PAGES,
577 - update_every,
578 - RRDSET_TYPE_LINE);
836 + COUNTER_DATA ReadOperationsSec;
837 + COUNTER_DATA WriteOperationsSec;
838
580 - p->rd_DepositedPages = rrddim_add(p->st_deposited_pages, "gpa", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
839 + COUNTER_DATA ReadBytesSec;
840 + COUNTER_DATA WriteBytesSec;
841 + COUNTER_DATA ErrorCount;
842 +};
843
582 - p->st_DeviceDMAErrors = rrdset_create_localhost(
583 - "root_partition_device_dma_errors",
584 - windows_shared_buffer,
585 - NULL,
586 - HYPERV,
587 - HYPERV ".root_partition_device_dma_errors",
588 - "Root partition illegal DMA requests",
589 - "requests",
590 - _COMMON_PLUGIN_NAME,
591 - _COMMON_PLUGIN_MODULE_NAME,
592 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_DEVICE_DMA_ERRORS,
593 - update_every,
594 - RRDSET_TYPE_LINE);
844 +// Initialize the keys for the root partition metrics
845 +void initialize_hyperv_storage_device_keys(struct hypervisor_storage_device *p)
846 +{
847 + p->ReadOperationsSec.key = "Read Operations/Sec";
848 + p->WriteOperationsSec.key = "Write Operations/Sec";
849
596 - p->rd_DeviceDMAErrors =
597 - rrddim_add(p->st_DeviceDMAErrors, "illegal_dma", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
850 + p->ReadBytesSec.key = "Read Bytes/sec";
851 + p->WriteBytesSec.key = "Write Bytes/sec";
852 + p->ErrorCount.key = "Error Count";
853 +}
854
599 - p->st_DeviceInterruptErrors = rrdset_create_localhost(
600 - "root_partition_device_interrupt_errors",
601 - windows_shared_buffer,
602 - NULL,
603 - HYPERV,
604 - HYPERV ".root_partition_device_interrupt_errors",
605 - "Root partition illegal interrupt requests",
606 - "requests",
607 - _COMMON_PLUGIN_NAME,
608 - _COMMON_PLUGIN_MODULE_NAME,
609 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_DEVICE_INTERRUPT_ERRORS,
610 - update_every,
611 - RRDSET_TYPE_LINE);
855 +// Callback function for inserting root partition metrics into the dictionary
856 +void dict_hyperv_storage_device_insert_cb(
857 + const DICTIONARY_ITEM *item __maybe_unused,
858 + void *value,
859 + void *data __maybe_unused)
860 +{
861 + struct hypervisor_storage_device *p = value;
862 + initialize_hyperv_storage_device_keys(p);
863 +}
864
613 - p->rd_DeviceInterruptErrors =
614 - rrddim_add(p->st_DeviceInterruptErrors, "illegal_interrupt", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
865 +static void hyperv_storage_device_chart(struct hypervisor_storage_device *p, int update_every)
866 +{
867 + if (!p->collected_metadata) {
868 + p->collected_metadata = true;
869 + }
870
616 - p->st_DeviceInterruptThrottleEvents = rrdset_create_localhost(
617 - "root_partition_device_interrupt_throttle_events",
871 + if (!p->charts_created) {
872 + p->charts_created = true;
873 + if (!p->st_operations) {
874 + p->st_operations = rrdset_create_localhost(
875 + "vm_storage_device_operations",
876 windows_shared_buffer,
877 NULL,
878 HYPERV,
621 - HYPERV ".root_partition_device_interrupt_throttle_events",
622 - "Root partition throttled interrupts",
623 - "events",
879 + HYPERV ".vm_storage_device_operations",
880 + "VM storage device IOPS",
881 + "operations/s",
882 _COMMON_PLUGIN_NAME,
883 _COMMON_PLUGIN_MODULE_NAME,
626 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_DEVICE_INTERRUPT_THROTTLE_EVENTS,
884 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_STORAGE_DEVICE_OPERATIONS,
885 update_every,
886 RRDSET_TYPE_LINE);
887
630 - p->rd_DeviceInterruptThrottleEvents =
631 - rrddim_add(p->st_DeviceInterruptThrottleEvents, "throttling", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
888 + p->rd_ReadOperationsSec = rrddim_add(p->st_operations, "read", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
889 + p->rd_WriteOperationsSec = rrddim_add(p->st_operations, "write", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
890
633 - p->st_IOΤLBFlushesSec = rrdset_create_localhost(
634 - "root_partition_io_tlb_flush",
635 - windows_shared_buffer,
636 - NULL,
637 - HYPERV,
638 - HYPERV ".root_partition_io_tlb_flush",
639 - "Root partition flushes of I/O TLBs",
640 - "flushes/s",
641 - _COMMON_PLUGIN_NAME,
642 - _COMMON_PLUGIN_MODULE_NAME,
643 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_IO_TLB_FLUSH,
644 - update_every,
645 - RRDSET_TYPE_LINE);
646 -
647 - p->rd_IOΤLBFlushesSec = rrddim_add(p->st_IOΤLBFlushesSec, "gpa", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
891 + rrdlabels_add(p->st_operations->rrdlabels, "vm_storage_device", windows_shared_buffer, RRDLABEL_SRC_AUTO);
892 + }
893
649 - p->st_AddressSpaces = rrdset_create_localhost(
650 - "root_partition_address_space",
894 + if (!p->st_bytes) {
895 + p->st_bytes = rrdset_create_localhost(
896 + "vm_storage_device_bytes",
897 windows_shared_buffer,
898 NULL,
899 HYPERV,
654 - HYPERV ".root_partition_address_space",
655 - "Root partition address spaces in the virtual TLB",
656 - "address spaces",
900 + HYPERV ".vm_storage_device_bytes",
901 + "VM storage device IO",
902 + "bytes/s",
903 _COMMON_PLUGIN_NAME,
904 _COMMON_PLUGIN_MODULE_NAME,
659 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_ADDRESS_SPACE,
905 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_STORAGE_DEVICE_BYTES,
906 update_every,
661 - RRDSET_TYPE_LINE);
662 -
663 - p->rd_AddressSpaces = rrddim_add(p->st_AddressSpaces, "address_spaces", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
907 + RRDSET_TYPE_AREA);
908
665 - p->st_VirtualTLBPages = rrdset_create_localhost(
666 - "root_partition_virtual_tlb_pages",
667 - windows_shared_buffer,
668 - NULL,
669 - HYPERV,
670 - HYPERV ".root_partition_virtual_tlb_pages",
671 - "Root partition pages used by the virtual TLB",
672 - "pages",
673 - _COMMON_PLUGIN_NAME,
674 - _COMMON_PLUGIN_MODULE_NAME,
675 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_VIRTUAL_TLB_PAGES,
676 - update_every,
677 - RRDSET_TYPE_LINE);
909 + p->rd_ReadBytesSec = rrddim_add(p->st_bytes, "read", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
910 + p->rd_WriteBytesSec = rrddim_add(p->st_bytes, "write", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
911
679 - p->rd_VirtualTLBPages = rrddim_add(p->st_VirtualTLBPages, "used", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
912 + rrdlabels_add(p->st_bytes->rrdlabels, "vm_storage_device", windows_shared_buffer, RRDLABEL_SRC_AUTO);
913 + }
914
681 - p->st_VirtualTLBFlushEntiresSec = rrdset_create_localhost(
682 - "root_partition_virtual_tlb_flush_entries",
915 + if (!p->st_errors) {
916 + p->st_errors = rrdset_create_localhost(
917 + "vm_storage_device_errors",
918 windows_shared_buffer,
919 NULL,
920 HYPERV,
686 - HYPERV ".root_partition_virtual_tlb_flush_entries",
687 - "Root partition flushes of the entire virtual TLB",
688 - "flushes/s",
921 + HYPERV ".vm_storage_device_errors",
922 + "VM storage device errors",
923 + "errors/s",
924 _COMMON_PLUGIN_NAME,
925 _COMMON_PLUGIN_MODULE_NAME,
691 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_VIRTUAL_TLB_FLUSH_ENTRIES,
926 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_STORAGE_DEVICE_ERRORS,
927 update_every,
928 RRDSET_TYPE_LINE);
929
695 - p->rd_VirtualTLBFlushEntiresSec =
696 - rrddim_add(p->st_VirtualTLBFlushEntiresSec, "flushes", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
697 - }
930 + p->rd_ErrorCount = rrddim_add(p->st_errors, "errors", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
931
699 - // Set the data for each dimension
700 -
701 - SETP_DIM_VALUE(st_device_space_pages, DeviceSpacePages4K);
702 - SETP_DIM_VALUE(st_device_space_pages, DeviceSpacePages2M);
703 - SETP_DIM_VALUE(st_device_space_pages, DeviceSpacePages1G);
704 -
705 - SETP_DIM_VALUE(st_gpa_space_pages, GPASpacePages4K);
706 - SETP_DIM_VALUE(st_gpa_space_pages, GPASpacePages2M);
707 - SETP_DIM_VALUE(st_gpa_space_pages, GPASpacePages1G);
708 -
709 - SETP_DIM_VALUE(st_gpa_space_modifications, GPASpaceModifications);
710 -
711 - SETP_DIM_VALUE(st_attached_devices, AttachedDevices);
712 - SETP_DIM_VALUE(st_deposited_pages, DepositedPages);
713 -
714 - SETP_DIM_VALUE(st_DeviceDMAErrors, DeviceDMAErrors);
715 - SETP_DIM_VALUE(st_DeviceInterruptErrors, DeviceInterruptErrors);
716 - SETP_DIM_VALUE(st_DeviceInterruptThrottleEvents, DeviceInterruptThrottleEvents);
717 - SETP_DIM_VALUE(st_IOΤLBFlushesSec, IOΤLBFlushesSec);
718 - SETP_DIM_VALUE(st_AddressSpaces, AddressSpaces);
719 - SETP_DIM_VALUE(st_VirtualTLBPages, VirtualTLBPages);
720 - SETP_DIM_VALUE(st_VirtualTLBFlushEntiresSec, VirtualTLBFlushEntiresSec);
721 -
722 - // Mark the charts as done
723 - rrdset_done(p->st_device_space_pages);
724 - rrdset_done(p->st_gpa_space_pages);
725 - rrdset_done(p->st_gpa_space_modifications);
726 - rrdset_done(p->st_attached_devices);
727 - rrdset_done(p->st_deposited_pages);
728 - rrdset_done(p->st_DeviceInterruptErrors);
729 - rrdset_done(p->st_DeviceInterruptThrottleEvents);
730 - rrdset_done(p->st_IOΤLBFlushesSec);
731 - rrdset_done(p->st_AddressSpaces);
732 - rrdset_done(p->st_DeviceDMAErrors);
733 - rrdset_done(p->st_VirtualTLBPages);
734 - rrdset_done(p->st_VirtualTLBFlushEntiresSec);
932 + rrdlabels_add(p->st_errors->rrdlabels, "vm_storage_device", windows_shared_buffer, RRDLABEL_SRC_AUTO);
933 + }
934 }
935
737 - return true;
738 -}
739 -
740 -// Storage DEVICE
741 -
742 -struct hypervisor_storage_device {
743 - bool collected_metadata;
744 - bool charts_created;
745 -
746 - RRDSET *st_operations;
747 - DEFINE_RD(ReadOperationsSec);
748 - DEFINE_RD(WriteOperationsSec);
936 + SETP_DIM_VALUE(st_operations, ReadOperationsSec);
937 + SETP_DIM_VALUE(st_operations, WriteOperationsSec);
938
750 - RRDSET *st_bytes;
751 - DEFINE_RD(ReadBytesSec);
752 - DEFINE_RD(WriteBytesSec);
939 + SETP_DIM_VALUE(st_bytes, ReadBytesSec);
940 + SETP_DIM_VALUE(st_bytes, WriteBytesSec);
941
754 - RRDSET *st_errors;
755 - DEFINE_RD(ErrorCount);
942 + SETP_DIM_VALUE(st_errors, ErrorCount);
943
757 - COUNTER_DATA ReadOperationsSec;
758 - COUNTER_DATA WriteOperationsSec;
759 -
760 - COUNTER_DATA ReadBytesSec;
761 - COUNTER_DATA WriteBytesSec;
762 - COUNTER_DATA ErrorCount;
763 -};
764 -
765 -// Initialize the keys for the root partition metrics
766 -void initialize_hyperv_storage_device_keys(struct hypervisor_storage_device *p)
767 -{
768 - p->ReadOperationsSec.key = "Read Operations/Sec";
769 - p->WriteOperationsSec.key = "Write Operations/Sec";
770 -
771 - p->ReadBytesSec.key = "Read Bytes/sec";
772 - p->WriteBytesSec.key = "Write Bytes/sec";
773 - p->ErrorCount.key = "Error Count";
774 -}
775 -
776 -// Callback function for inserting root partition metrics into the dictionary
777 -void dict_hyperv_storage_device_insert_cb(
778 - const DICTIONARY_ITEM *item __maybe_unused,
779 - void *value,
780 - void *data __maybe_unused)
781 -{
782 - struct hypervisor_storage_device *p = value;
783 - initialize_hyperv_storage_device_keys(p);
944 + // Mark the charts as done
945 + rrdset_done(p->st_operations);
946 + rrdset_done(p->st_bytes);
947 + rrdset_done(p->st_errors);
948 }
949
950 static bool do_hyperv_storage_device(PERF_DATA_BLOCK *pDataBlock, int update_every, void *data)
951 {
952 + struct hypervisor_storage_device *p;
953 hyperv_perf_item *item = data;
954
955 PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, item->registry_name);
956 if (!pObjectType)
957 return false;
958
959 + if (!pObjectType->NumInstances) {
960 + static struct hypervisor_storage_device static_hs_device;
961 + p = &static_hs_device;
962 + if (!p->charts_created) {
963 + initialize_hyperv_storage_device_keys(p);
964 + strncpyz(windows_shared_buffer, "[unknown]", sizeof(windows_shared_buffer) - 1);
965 + }
966 +
967 + // Fetch counters
968 + GET_OBJECT_COUNTER(ReadOperationsSec);
969 + GET_OBJECT_COUNTER(WriteOperationsSec);
970 +
971 + GET_OBJECT_COUNTER(ReadBytesSec);
972 + GET_OBJECT_COUNTER(WriteBytesSec);
973 + GET_OBJECT_COUNTER(ErrorCount);
974 +
975 + hyperv_storage_device_chart(p, update_every);
976 + return true;
977 + }
978 +
979 PERF_INSTANCE_DEFINITION *pi = NULL;
980 for (LONG i = 0; i < pObjectType->NumInstances; i++) {
981 pi = perflibForEachInstance(pDataBlock, pObjectType, pi);
@@ -803,11 +988,7 @@ static bool do_hyperv_storage_device(PERF_DATA_BLOCK *pDataBlock, int update_eve
988 if (strcasecmp(windows_shared_buffer, "_Total") == 0)
989 continue;
990
806 - struct hypervisor_storage_device *p = dictionary_set(item->instance, windows_shared_buffer, NULL, sizeof(*p));
807 -
808 - if (!p->collected_metadata) {
809 - p->collected_metadata = true;
810 - }
991 + p = dictionary_set(item->instance, windows_shared_buffer, NULL, sizeof(*p));
992
993 // Fetch counters
994 GET_INSTANCE_COUNTER(ReadOperationsSec);
@@ -817,85 +998,7 @@ static bool do_hyperv_storage_device(PERF_DATA_BLOCK *pDataBlock, int update_eve
998 GET_INSTANCE_COUNTER(WriteBytesSec);
999 GET_INSTANCE_COUNTER(ErrorCount);
1000
820 - if (!p->charts_created) {
821 - p->charts_created = true;
822 - if (!p->st_operations) {
823 - p->st_operations = rrdset_create_localhost(
824 - "vm_storage_device_operations",
825 - windows_shared_buffer,
826 - NULL,
827 - HYPERV,
828 - HYPERV ".vm_storage_device_operations",
829 - "VM storage device IOPS",
830 - "operations/s",
831 - _COMMON_PLUGIN_NAME,
832 - _COMMON_PLUGIN_MODULE_NAME,
833 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_STORAGE_DEVICE_OPERATIONS,
834 - update_every,
835 - RRDSET_TYPE_LINE);
836 -
837 - p->rd_ReadOperationsSec = rrddim_add(p->st_operations, "read", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
838 - p->rd_WriteOperationsSec =
839 - rrddim_add(p->st_operations, "write", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
840 -
841 - rrdlabels_add(
842 - p->st_operations->rrdlabels, "vm_storage_device", windows_shared_buffer, RRDLABEL_SRC_AUTO);
843 - }
844 -
845 - if (!p->st_bytes) {
846 - p->st_bytes = rrdset_create_localhost(
847 - "vm_storage_device_bytes",
848 - windows_shared_buffer,
849 - NULL,
850 - HYPERV,
851 - HYPERV ".vm_storage_device_bytes",
852 - "VM storage device IO",
853 - "bytes/s",
854 - _COMMON_PLUGIN_NAME,
855 - _COMMON_PLUGIN_MODULE_NAME,
856 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_STORAGE_DEVICE_BYTES,
857 - update_every,
858 - RRDSET_TYPE_AREA);
859 -
860 - p->rd_ReadBytesSec = rrddim_add(p->st_bytes, "read", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
861 - p->rd_WriteBytesSec = rrddim_add(p->st_bytes, "write", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
862 -
863 - rrdlabels_add(p->st_bytes->rrdlabels, "vm_storage_device", windows_shared_buffer, RRDLABEL_SRC_AUTO);
864 - }
865 -
866 - if (!p->st_errors) {
867 - p->st_errors = rrdset_create_localhost(
868 - "vm_storage_device_errors",
869 - windows_shared_buffer,
870 - NULL,
871 - HYPERV,
872 - HYPERV ".vm_storage_device_errors",
873 - "VM storage device errors",
874 - "errors/s",
875 - _COMMON_PLUGIN_NAME,
876 - _COMMON_PLUGIN_MODULE_NAME,
877 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_STORAGE_DEVICE_ERRORS,
878 - update_every,
879 - RRDSET_TYPE_LINE);
880 -
881 - p->rd_ErrorCount = rrddim_add(p->st_errors, "errors", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
882 -
883 - rrdlabels_add(p->st_errors->rrdlabels, "vm_storage_device", windows_shared_buffer, RRDLABEL_SRC_AUTO);
884 - }
885 - }
886 -
887 - SETP_DIM_VALUE(st_operations, ReadOperationsSec);
888 - SETP_DIM_VALUE(st_operations, WriteOperationsSec);
889 -
890 - SETP_DIM_VALUE(st_bytes, ReadBytesSec);
891 - SETP_DIM_VALUE(st_bytes, WriteBytesSec);
892 -
893 - SETP_DIM_VALUE(st_errors, ErrorCount);
894 -
895 - // Mark the charts as done
896 - rrdset_done(p->st_operations);
897 - rrdset_done(p->st_bytes);
898 - rrdset_done(p->st_errors);
1001 + hyperv_storage_device_chart(p, update_every);
1002 }
1003
1004 return true;
@@ -999,287 +1102,333 @@ void dict_hyperv_switch_insert_cb(const DICTIONARY_ITEM *item __maybe_unused, vo
1102 initialize_hyperv_switch_keys(p);
1103 }
1104
1002 -static bool do_hyperv_switch(PERF_DATA_BLOCK *pDataBlock, int update_every, void *data)
1105 +static void hyperv_switch_chart(struct hypervisor_switch *p, int update_every)
1106 {
1004 - hyperv_perf_item *item = data;
1107 + if (!p->collected_metadata) {
1108 + p->collected_metadata = true;
1109 + }
1110
1006 - PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, item->registry_name);
1007 - if (!pObjectType)
1008 - return false;
1111 + if (!p->charts_created) {
1112 + p->charts_created = true;
1113
1010 - PERF_INSTANCE_DEFINITION *pi = NULL;
1011 - for (LONG i = 0; i < pObjectType->NumInstances; i++) {
1012 - pi = perflibForEachInstance(pDataBlock, pObjectType, pi);
1013 - if (!pi)
1014 - break;
1114 + p->st_bytes = rrdset_create_localhost(
1115 + "vswitch_traffic",
1116 + windows_shared_buffer,
1117 + NULL,
1118 + HYPERV,
1119 + HYPERV ".vswitch_traffic",
1120 + "Virtual switch traffic",
1121 + "kilobits/s",
1122 + _COMMON_PLUGIN_NAME,
1123 + _COMMON_PLUGIN_MODULE_NAME,
1124 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_TRAFFIC,
1125 + update_every,
1126 + RRDSET_TYPE_AREA);
1127
1016 - get_and_sanitize_instance_value(
1017 - pDataBlock, pObjectType, pi, windows_shared_buffer, sizeof(windows_shared_buffer));
1128 + p->rd_BytesReceivedSec = rrddim_add(p->st_bytes, "received", NULL, 8, 1000, RRD_ALGORITHM_INCREMENTAL);
1129 + p->rd_BytesSentSec = rrddim_add(p->st_bytes, "sent", NULL, -8, 1000, RRD_ALGORITHM_INCREMENTAL);
1130 + rrdlabels_add(p->st_bytes->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1131
1019 - if (strcasecmp(windows_shared_buffer, "_Total") == 0)
1020 - continue;
1132 + p->st_packets = rrdset_create_localhost(
1133 + "vswitch_packets",
1134 + windows_shared_buffer,
1135 + NULL,
1136 + HYPERV,
1137 + HYPERV ".vswitch_packets",
1138 + "Virtual switch packets",
1139 + "packets/s",
1140 + _COMMON_PLUGIN_NAME,
1141 + _COMMON_PLUGIN_MODULE_NAME,
1142 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_PACKETS,
1143 + update_every,
1144 + RRDSET_TYPE_LINE);
1145
1022 - struct hypervisor_switch *p = dictionary_set(item->instance, windows_shared_buffer, NULL, sizeof(*p));
1146 + p->rd_PacketsReceivedSec = rrddim_add(p->st_packets, "received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1147 + p->rd_PacketsSentSec = rrddim_add(p->st_packets, "sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1148 + rrdlabels_add(p->st_packets->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1149
1024 - if (!p->collected_metadata) {
1025 - p->collected_metadata = true;
1026 - }
1150 + p->st_directed_packets = rrdset_create_localhost(
1151 + "vswitch_directed_packets",
1152 + windows_shared_buffer,
1153 + NULL,
1154 + HYPERV,
1155 + HYPERV ".vswitch_directed_packets",
1156 + "Virtual switch directed packets",
1157 + "packets/s",
1158 + _COMMON_PLUGIN_NAME,
1159 + _COMMON_PLUGIN_MODULE_NAME,
1160 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_DIRECTED_PACKETS,
1161 + update_every,
1162 + RRDSET_TYPE_LINE);
1163
1028 - GET_INSTANCE_COUNTER(BytesReceivedSec);
1029 - GET_INSTANCE_COUNTER(BytesSentSec);
1164 + p->rd_DirectedPacketsReceivedSec =
1165 + rrddim_add(p->st_directed_packets, "received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1166 + p->rd_DirectedPacketsSentSec =
1167 + rrddim_add(p->st_directed_packets, "sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1168 + rrdlabels_add(p->st_directed_packets->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1169
1031 - GET_INSTANCE_COUNTER(PacketsReceivedSec);
1032 - GET_INSTANCE_COUNTER(PacketsSentSec);
1170 + p->st_broadcast_packets = rrdset_create_localhost(
1171 + "vswitch_broadcast_packets",
1172 + windows_shared_buffer,
1173 + NULL,
1174 + HYPERV,
1175 + HYPERV ".vswitch_broadcast_packets",
1176 + "Virtual switch broadcast packets",
1177 + "packets/s",
1178 + _COMMON_PLUGIN_NAME,
1179 + _COMMON_PLUGIN_MODULE_NAME,
1180 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_BROADCAST_PACKETS,
1181 + update_every,
1182 + RRDSET_TYPE_LINE);
1183
1034 - GET_INSTANCE_COUNTER(DirectedPacketsSentSec);
1035 - GET_INSTANCE_COUNTER(DirectedPacketsReceivedSec);
1184 + p->rd_BroadcastPacketsReceivedSec =
1185 + rrddim_add(p->st_broadcast_packets, "received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1186 + p->rd_BroadcastPacketsSentSec =
1187 + rrddim_add(p->st_broadcast_packets, "sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1188 + rrdlabels_add(p->st_broadcast_packets->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1189
1037 - GET_INSTANCE_COUNTER(BroadcastPacketsSentSec);
1038 - GET_INSTANCE_COUNTER(BroadcastPacketsReceivedSec);
1190 + p->st_multicast_packets = rrdset_create_localhost(
1191 + "vswitch_multicast_packets",
1192 + windows_shared_buffer,
1193 + NULL,
1194 + HYPERV,
1195 + HYPERV ".vswitch_multicast_packets",
1196 + "Virtual switch multicast packets",
1197 + "packets/s",
1198 + _COMMON_PLUGIN_NAME,
1199 + _COMMON_PLUGIN_MODULE_NAME,
1200 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_MULTICAST_PACKETS,
1201 + update_every,
1202 + RRDSET_TYPE_LINE);
1203
1040 - GET_INSTANCE_COUNTER(MulticastPacketsSentSec);
1041 - GET_INSTANCE_COUNTER(MulticastPacketsReceivedSec);
1204 + p->rd_MulticastPacketsReceivedSec =
1205 + rrddim_add(p->st_multicast_packets, "received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1206 + p->rd_MulticastPacketsSentSec =
1207 + rrddim_add(p->st_multicast_packets, "sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1208 + rrdlabels_add(p->st_multicast_packets->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1209
1043 - GET_INSTANCE_COUNTER(DroppedPacketsOutgoingSec);
1044 - GET_INSTANCE_COUNTER(DroppedPacketsIncomingSec);
1210 + p->st_dropped_packets = rrdset_create_localhost(
1211 + "vswitch_dropped_packets",
1212 + windows_shared_buffer,
1213 + NULL,
1214 + HYPERV,
1215 + HYPERV ".vswitch_dropped_packets",
1216 + "Virtual switch dropped packets",
1217 + "drops/s",
1218 + _COMMON_PLUGIN_NAME,
1219 + _COMMON_PLUGIN_MODULE_NAME,
1220 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_DROPPED_PACKETS,
1221 + update_every,
1222 + RRDSET_TYPE_LINE);
1223
1046 - GET_INSTANCE_COUNTER(ExtensionsDroppedPacketsOutgoingSec);
1047 - GET_INSTANCE_COUNTER(ExtensionsDroppedPacketsIncomingSec);
1224 + p->rd_DroppedPacketsIncomingSec =
1225 + rrddim_add(p->st_dropped_packets, "incoming", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1226 + p->rd_DroppedPacketsOutgoingSec =
1227 + rrddim_add(p->st_dropped_packets, "outgoing", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1228 + rrdlabels_add(p->st_dropped_packets->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1229
1049 - GET_INSTANCE_COUNTER(PacketsFlooded);
1230 + p->st_ext_dropped_packets = rrdset_create_localhost(
1231 + "vswitch_extensions_dropped_packets",
1232 + windows_shared_buffer,
1233 + NULL,
1234 + HYPERV,
1235 + HYPERV ".vswitch_extensions_dropped_packets",
1236 + "Virtual switch extensions dropped packets",
1237 + "drops/s",
1238 + _COMMON_PLUGIN_NAME,
1239 + _COMMON_PLUGIN_MODULE_NAME,
1240 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_EXTENSIONS_DROPPED_PACKETS,
1241 + update_every,
1242 + RRDSET_TYPE_LINE);
1243
1051 - GET_INSTANCE_COUNTER(LearnedMacAddresses);
1244 + p->rd_ExtensionsDroppedPacketsIncomingSec =
1245 + rrddim_add(p->st_ext_dropped_packets, "incoming", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1246 + p->rd_ExtensionsDroppedPacketsOutgoingSec =
1247 + rrddim_add(p->st_ext_dropped_packets, "outgoing", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1248 + rrdlabels_add(p->st_ext_dropped_packets->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1249
1053 - GET_INSTANCE_COUNTER(PurgedMacAddresses);
1250 + p->st_flooded = rrdset_create_localhost(
1251 + "vswitch_packets_flooded",
1252 + windows_shared_buffer,
1253 + NULL,
1254 + HYPERV,
1255 + HYPERV ".vswitch_packets_flooded",
1256 + "Virtual switch flooded packets",
1257 + "packets/s",
1258 + _COMMON_PLUGIN_NAME,
1259 + _COMMON_PLUGIN_MODULE_NAME,
1260 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_PACKETS_FLOODED,
1261 + update_every,
1262 + RRDSET_TYPE_LINE);
1263
1055 - if (!p->charts_created) {
1056 - p->charts_created = true;
1264 + p->rd_PacketsFlooded = rrddim_add(p->st_flooded, "flooded", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1265 + rrdlabels_add(p->st_flooded->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1266
1058 - p->st_bytes = rrdset_create_localhost(
1059 - "vswitch_traffic",
1060 - windows_shared_buffer,
1061 - NULL,
1062 - HYPERV,
1063 - HYPERV ".vswitch_traffic",
1064 - "Virtual switch traffic",
1065 - "kilobits/s",
1066 - _COMMON_PLUGIN_NAME,
1067 - _COMMON_PLUGIN_MODULE_NAME,
1068 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_TRAFFIC,
1069 - update_every,
1070 - RRDSET_TYPE_AREA);
1267 + p->st_learned_mac = rrdset_create_localhost(
1268 + "vswitch_learned_mac_addresses",
1269 + windows_shared_buffer,
1270 + NULL,
1271 + HYPERV,
1272 + HYPERV ".vswitch_learned_mac_addresses",
1273 + "Virtual switch learned MAC addresses",
1274 + "mac addresses/s",
1275 + _COMMON_PLUGIN_NAME,
1276 + _COMMON_PLUGIN_MODULE_NAME,
1277 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_LEARNED_MAC_ADDRESSES,
1278 + update_every,
1279 + RRDSET_TYPE_LINE);
1280
1072 - p->rd_BytesReceivedSec = rrddim_add(p->st_bytes, "received", NULL, 8, 1000, RRD_ALGORITHM_INCREMENTAL);
1073 - p->rd_BytesSentSec = rrddim_add(p->st_bytes, "sent", NULL, -8, 1000, RRD_ALGORITHM_INCREMENTAL);
1074 - rrdlabels_add(p->st_bytes->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1281 + p->rd_LearnedMacAddresses = rrddim_add(p->st_learned_mac, "learned", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1282 + rrdlabels_add(p->st_learned_mac->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1283
1076 - p->st_packets = rrdset_create_localhost(
1077 - "vswitch_packets",
1078 - windows_shared_buffer,
1079 - NULL,
1080 - HYPERV,
1081 - HYPERV ".vswitch_packets",
1082 - "Virtual switch packets",
1083 - "packets/s",
1084 - _COMMON_PLUGIN_NAME,
1085 - _COMMON_PLUGIN_MODULE_NAME,
1086 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_PACKETS,
1087 - update_every,
1088 - RRDSET_TYPE_LINE);
1284 + p->st_purged_mac = rrdset_create_localhost(
1285 + "vswitch_purged_mac_addresses",
1286 + windows_shared_buffer,
1287 + NULL,
1288 + HYPERV,
1289 + HYPERV ".vswitch_purged_mac_addresses",
1290 + "Virtual switch purged MAC addresses",
1291 + "mac addresses/s",
1292 + _COMMON_PLUGIN_NAME,
1293 + _COMMON_PLUGIN_MODULE_NAME,
1294 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_PURGED_MAC_ADDRESSES,
1295 + update_every,
1296 + RRDSET_TYPE_LINE);
1297
1090 - p->rd_PacketsReceivedSec = rrddim_add(p->st_packets, "received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1091 - p->rd_PacketsSentSec = rrddim_add(p->st_packets, "sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1092 - rrdlabels_add(p->st_packets->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1298 + p->rd_PurgedMacAddresses = rrddim_add(p->st_purged_mac, "purged", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1299 + rrdlabels_add(p->st_purged_mac->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1300 + }
1301
1094 - p->st_directed_packets = rrdset_create_localhost(
1095 - "vswitch_directed_packets",
1096 - windows_shared_buffer,
1097 - NULL,
1098 - HYPERV,
1099 - HYPERV ".vswitch_directed_packets",
1100 - "Virtual switch directed packets",
1101 - "packets/s",
1102 - _COMMON_PLUGIN_NAME,
1103 - _COMMON_PLUGIN_MODULE_NAME,
1104 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_DIRECTED_PACKETS,
1105 - update_every,
1106 - RRDSET_TYPE_LINE);
1302 + SETP_DIM_VALUE(st_packets, PacketsReceivedSec);
1303 + SETP_DIM_VALUE(st_packets, PacketsSentSec);
1304
1108 - p->rd_DirectedPacketsReceivedSec =
1109 - rrddim_add(p->st_directed_packets, "received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1110 - p->rd_DirectedPacketsSentSec =
1111 - rrddim_add(p->st_directed_packets, "sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1112 - rrdlabels_add(p->st_directed_packets->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1305 + SETP_DIM_VALUE(st_bytes, BytesReceivedSec);
1306 + SETP_DIM_VALUE(st_bytes, BytesSentSec);
1307
1114 - p->st_broadcast_packets = rrdset_create_localhost(
1115 - "vswitch_broadcast_packets",
1116 - windows_shared_buffer,
1117 - NULL,
1118 - HYPERV,
1119 - HYPERV ".vswitch_broadcast_packets",
1120 - "Virtual switch broadcast packets",
1121 - "packets/s",
1122 - _COMMON_PLUGIN_NAME,
1123 - _COMMON_PLUGIN_MODULE_NAME,
1124 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_BROADCAST_PACKETS,
1125 - update_every,
1126 - RRDSET_TYPE_LINE);
1308 + SETP_DIM_VALUE(st_directed_packets, DirectedPacketsSentSec);
1309 + SETP_DIM_VALUE(st_directed_packets, DirectedPacketsReceivedSec);
1310
1128 - p->rd_BroadcastPacketsReceivedSec =
1129 - rrddim_add(p->st_broadcast_packets, "received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1130 - p->rd_BroadcastPacketsSentSec =
1131 - rrddim_add(p->st_broadcast_packets, "sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1132 - rrdlabels_add(p->st_broadcast_packets->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1311 + SETP_DIM_VALUE(st_broadcast_packets, BroadcastPacketsSentSec);
1312 + SETP_DIM_VALUE(st_broadcast_packets, BroadcastPacketsReceivedSec);
1313
1134 - p->st_multicast_packets = rrdset_create_localhost(
1135 - "vswitch_multicast_packets",
1136 - windows_shared_buffer,
1137 - NULL,
1138 - HYPERV,
1139 - HYPERV ".vswitch_multicast_packets",
1140 - "Virtual switch multicast packets",
1141 - "packets/s",
1142 - _COMMON_PLUGIN_NAME,
1143 - _COMMON_PLUGIN_MODULE_NAME,
1144 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_MULTICAST_PACKETS,
1145 - update_every,
1146 - RRDSET_TYPE_LINE);
1314 + SETP_DIM_VALUE(st_multicast_packets, MulticastPacketsSentSec);
1315 + SETP_DIM_VALUE(st_multicast_packets, MulticastPacketsReceivedSec);
1316
1148 - p->rd_MulticastPacketsReceivedSec =
1149 - rrddim_add(p->st_multicast_packets, "received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1150 - p->rd_MulticastPacketsSentSec =
1151 - rrddim_add(p->st_multicast_packets, "sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1152 - rrdlabels_add(p->st_multicast_packets->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1317 + SETP_DIM_VALUE(st_dropped_packets, DroppedPacketsOutgoingSec);
1318 + SETP_DIM_VALUE(st_dropped_packets, DroppedPacketsIncomingSec);
1319
1154 - p->st_dropped_packets = rrdset_create_localhost(
1155 - "vswitch_dropped_packets",
1156 - windows_shared_buffer,
1157 - NULL,
1158 - HYPERV,
1159 - HYPERV ".vswitch_dropped_packets",
1160 - "Virtual switch dropped packets",
1161 - "drops/s",
1162 - _COMMON_PLUGIN_NAME,
1163 - _COMMON_PLUGIN_MODULE_NAME,
1164 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_DROPPED_PACKETS,
1165 - update_every,
1166 - RRDSET_TYPE_LINE);
1320 + SETP_DIM_VALUE(st_ext_dropped_packets, ExtensionsDroppedPacketsOutgoingSec);
1321 + SETP_DIM_VALUE(st_ext_dropped_packets, ExtensionsDroppedPacketsIncomingSec);
1322
1168 - p->rd_DroppedPacketsIncomingSec =
1169 - rrddim_add(p->st_dropped_packets, "incoming", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1170 - p->rd_DroppedPacketsOutgoingSec =
1171 - rrddim_add(p->st_dropped_packets, "outgoing", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1172 - rrdlabels_add(p->st_dropped_packets->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1323 + SETP_DIM_VALUE(st_flooded, PacketsFlooded);
1324 + SETP_DIM_VALUE(st_learned_mac, LearnedMacAddresses);
1325 + SETP_DIM_VALUE(st_purged_mac, PurgedMacAddresses);
1326
1174 - p->st_ext_dropped_packets = rrdset_create_localhost(
1175 - "vswitch_extensions_dropped_packets",
1176 - windows_shared_buffer,
1177 - NULL,
1178 - HYPERV,
1179 - HYPERV ".vswitch_extensions_dropped_packets",
1180 - "Virtual switch extensions dropped packets",
1181 - "drops/s",
1182 - _COMMON_PLUGIN_NAME,
1183 - _COMMON_PLUGIN_MODULE_NAME,
1184 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_EXTENSIONS_DROPPED_PACKETS,
1185 - update_every,
1186 - RRDSET_TYPE_LINE);
1327 + // Mark the charts as done
1328 + rrdset_done(p->st_packets);
1329 + rrdset_done(p->st_bytes);
1330
1188 - p->rd_ExtensionsDroppedPacketsIncomingSec =
1189 - rrddim_add(p->st_ext_dropped_packets, "incoming", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1190 - p->rd_ExtensionsDroppedPacketsOutgoingSec =
1191 - rrddim_add(p->st_ext_dropped_packets, "outgoing", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1192 - rrdlabels_add(p->st_ext_dropped_packets->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1331 + rrdset_done(p->st_directed_packets);
1332 + rrdset_done(p->st_broadcast_packets);
1333 + rrdset_done(p->st_multicast_packets);
1334 + rrdset_done(p->st_dropped_packets);
1335 + rrdset_done(p->st_ext_dropped_packets);
1336 + rrdset_done(p->st_flooded);
1337 + rrdset_done(p->st_learned_mac);
1338 + rrdset_done(p->st_purged_mac);
1339 +}
1340
1194 - p->st_flooded = rrdset_create_localhost(
1195 - "vswitch_packets_flooded",
1196 - windows_shared_buffer,
1197 - NULL,
1198 - HYPERV,
1199 - HYPERV ".vswitch_packets_flooded",
1200 - "Virtual switch flooded packets",
1201 - "packets/s",
1202 - _COMMON_PLUGIN_NAME,
1203 - _COMMON_PLUGIN_MODULE_NAME,
1204 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_PACKETS_FLOODED,
1205 - update_every,
1206 - RRDSET_TYPE_LINE);
1341 +static bool do_hyperv_switch(PERF_DATA_BLOCK *pDataBlock, int update_every, void *data)
1342 +{
1343 + struct hypervisor_switch *p;
1344 + hyperv_perf_item *item = data;
1345
1208 - p->rd_PacketsFlooded = rrddim_add(p->st_flooded, "flooded", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1209 - rrdlabels_add(p->st_flooded->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1346 + PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, item->registry_name);
1347 + if (!pObjectType)
1348 + return false;
1349
1211 - p->st_learned_mac = rrdset_create_localhost(
1212 - "vswitch_learned_mac_addresses",
1213 - windows_shared_buffer,
1214 - NULL,
1215 - HYPERV,
1216 - HYPERV ".vswitch_learned_mac_addresses",
1217 - "Virtual switch learned MAC addresses",
1218 - "mac addresses/s",
1219 - _COMMON_PLUGIN_NAME,
1220 - _COMMON_PLUGIN_MODULE_NAME,
1221 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_LEARNED_MAC_ADDRESSES,
1222 - update_every,
1223 - RRDSET_TYPE_LINE);
1350 + if (!pObjectType->NumInstances) {
1351 + struct hypervisor_switch static_switch = {};
1352 + p = &static_switch;
1353 +
1354 + if (!p->charts_created) {
1355 + initialize_hyperv_switch_keys(p);
1356 + strncpyz(windows_shared_buffer, "[unknown]", sizeof(windows_shared_buffer) - 1);
1357 + }
1358 +
1359 + GET_OBJECT_COUNTER(BytesReceivedSec);
1360 + GET_OBJECT_COUNTER(BytesSentSec);
1361 +
1362 + GET_OBJECT_COUNTER(PacketsReceivedSec);
1363 + GET_OBJECT_COUNTER(PacketsSentSec);
1364 +
1365 + GET_OBJECT_COUNTER(DirectedPacketsSentSec);
1366 + GET_OBJECT_COUNTER(DirectedPacketsReceivedSec);
1367 +
1368 + GET_OBJECT_COUNTER(BroadcastPacketsSentSec);
1369 + GET_OBJECT_COUNTER(BroadcastPacketsReceivedSec);
1370 +
1371 + GET_OBJECT_COUNTER(MulticastPacketsSentSec);
1372 + GET_OBJECT_COUNTER(MulticastPacketsReceivedSec);
1373 +
1374 + GET_OBJECT_COUNTER(DroppedPacketsOutgoingSec);
1375 + GET_OBJECT_COUNTER(DroppedPacketsIncomingSec);
1376 +
1377 + GET_OBJECT_COUNTER(ExtensionsDroppedPacketsOutgoingSec);
1378 + GET_OBJECT_COUNTER(ExtensionsDroppedPacketsIncomingSec);
1379 +
1380 + GET_OBJECT_COUNTER(PacketsFlooded);
1381 +
1382 + GET_OBJECT_COUNTER(LearnedMacAddresses);
1383 +
1384 + GET_OBJECT_COUNTER(PurgedMacAddresses);
1385 +
1386 + hyperv_switch_chart(p, update_every);
1387 + return true;
1388 + }
1389 +
1390 + PERF_INSTANCE_DEFINITION *pi = NULL;
1391 + for (LONG i = 0; i < pObjectType->NumInstances; i++) {
1392 + pi = perflibForEachInstance(pDataBlock, pObjectType, pi);
1393 + if (!pi)
1394 + break;
1395
1225 - p->rd_LearnedMacAddresses = rrddim_add(p->st_learned_mac, "learned", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1226 - rrdlabels_add(p->st_learned_mac->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1396 + get_and_sanitize_instance_value(
1397 + pDataBlock, pObjectType, pi, windows_shared_buffer, sizeof(windows_shared_buffer));
1398
1228 - p->st_purged_mac = rrdset_create_localhost(
1229 - "vswitch_purged_mac_addresses",
1230 - windows_shared_buffer,
1231 - NULL,
1232 - HYPERV,
1233 - HYPERV ".vswitch_purged_mac_addresses",
1234 - "Virtual switch purged MAC addresses",
1235 - "mac addresses/s",
1236 - _COMMON_PLUGIN_NAME,
1237 - _COMMON_PLUGIN_MODULE_NAME,
1238 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VSWITCH_PURGED_MAC_ADDRESSES,
1239 - update_every,
1240 - RRDSET_TYPE_LINE);
1399 + if (strcasecmp(windows_shared_buffer, "_Total") == 0)
1400 + continue;
1401
1242 - p->rd_PurgedMacAddresses = rrddim_add(p->st_purged_mac, "purged", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1243 - rrdlabels_add(p->st_purged_mac->rrdlabels, "vswitch", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1244 - }
1402 + p = dictionary_set(item->instance, windows_shared_buffer, NULL, sizeof(*p));
1403 +
1404 + GET_INSTANCE_COUNTER(BytesReceivedSec);
1405 + GET_INSTANCE_COUNTER(BytesSentSec);
1406
1246 - SETP_DIM_VALUE(st_packets, PacketsReceivedSec);
1247 - SETP_DIM_VALUE(st_packets, PacketsSentSec);
1407 + GET_INSTANCE_COUNTER(PacketsReceivedSec);
1408 + GET_INSTANCE_COUNTER(PacketsSentSec);
1409
1249 - SETP_DIM_VALUE(st_bytes, BytesReceivedSec);
1250 - SETP_DIM_VALUE(st_bytes, BytesSentSec);
1410 + GET_INSTANCE_COUNTER(DirectedPacketsSentSec);
1411 + GET_INSTANCE_COUNTER(DirectedPacketsReceivedSec);
1412
1252 - SETP_DIM_VALUE(st_directed_packets, DirectedPacketsSentSec);
1253 - SETP_DIM_VALUE(st_directed_packets, DirectedPacketsReceivedSec);
1413 + GET_INSTANCE_COUNTER(BroadcastPacketsSentSec);
1414 + GET_INSTANCE_COUNTER(BroadcastPacketsReceivedSec);
1415
1255 - SETP_DIM_VALUE(st_broadcast_packets, BroadcastPacketsSentSec);
1256 - SETP_DIM_VALUE(st_broadcast_packets, BroadcastPacketsReceivedSec);
1416 + GET_INSTANCE_COUNTER(MulticastPacketsSentSec);
1417 + GET_INSTANCE_COUNTER(MulticastPacketsReceivedSec);
1418
1258 - SETP_DIM_VALUE(st_multicast_packets, MulticastPacketsSentSec);
1259 - SETP_DIM_VALUE(st_multicast_packets, MulticastPacketsReceivedSec);
1419 + GET_INSTANCE_COUNTER(DroppedPacketsOutgoingSec);
1420 + GET_INSTANCE_COUNTER(DroppedPacketsIncomingSec);
1421
1261 - SETP_DIM_VALUE(st_dropped_packets, DroppedPacketsOutgoingSec);
1262 - SETP_DIM_VALUE(st_dropped_packets, DroppedPacketsIncomingSec);
1422 + GET_INSTANCE_COUNTER(ExtensionsDroppedPacketsOutgoingSec);
1423 + GET_INSTANCE_COUNTER(ExtensionsDroppedPacketsIncomingSec);
1424
1264 - SETP_DIM_VALUE(st_ext_dropped_packets, ExtensionsDroppedPacketsOutgoingSec);
1265 - SETP_DIM_VALUE(st_ext_dropped_packets, ExtensionsDroppedPacketsIncomingSec);
1425 + GET_INSTANCE_COUNTER(PacketsFlooded);
1426
1267 - SETP_DIM_VALUE(st_flooded, PacketsFlooded);
1268 - SETP_DIM_VALUE(st_learned_mac, LearnedMacAddresses);
1269 - SETP_DIM_VALUE(st_purged_mac, PurgedMacAddresses);
1427 + GET_INSTANCE_COUNTER(LearnedMacAddresses);
1428
1271 - // Mark the charts as done
1272 - rrdset_done(p->st_packets);
1273 - rrdset_done(p->st_bytes);
1429 + GET_INSTANCE_COUNTER(PurgedMacAddresses);
1430
1275 - rrdset_done(p->st_directed_packets);
1276 - rrdset_done(p->st_broadcast_packets);
1277 - rrdset_done(p->st_multicast_packets);
1278 - rrdset_done(p->st_dropped_packets);
1279 - rrdset_done(p->st_ext_dropped_packets);
1280 - rrdset_done(p->st_flooded);
1281 - rrdset_done(p->st_learned_mac);
1282 - rrdset_done(p->st_purged_mac);
1431 + hyperv_switch_chart(p, update_every);
1432 }
1433 return true;
1434 }
@@ -1369,14 +1518,229 @@ void dict_hyperv_network_adapter_insert_cb(
1518 initialize_hyperv_network_adapter_keys(p);
1519 }
1520
1521 +static void hyperv_network_adapter_chart(struct hypervisor_network_adapter *p, int update_every)
1522 +{
1523 + if (!p->collected_metadata) {
1524 + p->collected_metadata = true;
1525 + }
1526 +
1527 + if (!p->charts_created) {
1528 + p->charts_created = true;
1529 + p->st_dropped_packets = rrdset_create_localhost(
1530 + "vm_net_interface_packets_dropped",
1531 + windows_shared_buffer,
1532 + NULL,
1533 + HYPERV,
1534 + HYPERV ".vm_net_interface_packets_dropped",
1535 + "VM interface packets dropped",
1536 + "drops/s",
1537 + _COMMON_PLUGIN_NAME,
1538 + _COMMON_PLUGIN_MODULE_NAME,
1539 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_NET_INTERFACE_PACKETS_DROPPED,
1540 + update_every,
1541 + RRDSET_TYPE_LINE);
1542 +
1543 + p->rd_DroppedPacketsIncomingSec =
1544 + rrddim_add(p->st_dropped_packets, "incoming", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1545 + p->rd_DroppedPacketsOutgoingSec =
1546 + rrddim_add(p->st_dropped_packets, "outgoing", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1547 +
1548 + rrdlabels_add(p->st_dropped_packets->rrdlabels, "vm_net_interface", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1549 +
1550 + p->st_send_receive_packets = rrdset_create_localhost(
1551 + "vm_net_interface_packets",
1552 + windows_shared_buffer,
1553 + NULL,
1554 + HYPERV,
1555 + HYPERV ".vm_net_interface_packets",
1556 + "VM interface packets",
1557 + "packets/s",
1558 + _COMMON_PLUGIN_NAME,
1559 + _COMMON_PLUGIN_MODULE_NAME,
1560 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_NET_INTERFACE_PACKETS,
1561 + update_every,
1562 + RRDSET_TYPE_LINE);
1563 +
1564 + p->rd_PacketsReceivedSec =
1565 + rrddim_add(p->st_send_receive_packets, "received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1566 + p->rd_PacketsSentSec = rrddim_add(p->st_send_receive_packets, "sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1567 +
1568 + rrdlabels_add(
1569 + p->st_send_receive_packets->rrdlabels, "vm_net_interface", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1570 +
1571 + p->st_send_receive_bytes = rrdset_create_localhost(
1572 + "vm_net_interface_traffic",
1573 + windows_shared_buffer,
1574 + NULL,
1575 + HYPERV,
1576 + HYPERV ".vm_net_interface_traffic",
1577 + "VM interface traffic",
1578 + "kilobits/s",
1579 + _COMMON_PLUGIN_NAME,
1580 + _COMMON_PLUGIN_MODULE_NAME,
1581 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_NET_INTERFACE_TRAFFIC,
1582 + update_every,
1583 + RRDSET_TYPE_AREA);
1584 +
1585 + p->rd_BytesReceivedSec =
1586 + rrddim_add(p->st_send_receive_bytes, "received", NULL, 8, 1000, RRD_ALGORITHM_INCREMENTAL);
1587 + p->rd_BytesSentSec = rrddim_add(p->st_send_receive_bytes, "sent", NULL, -8, 1000, RRD_ALGORITHM_INCREMENTAL);
1588 + rrdlabels_add(
1589 + p->st_send_receive_bytes->rrdlabels, "vm_net_interface", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1590 +
1591 + p->st_IPsecoffloadBytes = rrdset_create_localhost(
1592 + "vm_net_interface_ipsec_traffic",
1593 + windows_shared_buffer,
1594 + NULL,
1595 + HYPERV,
1596 + HYPERV ".vm_net_interface_ipsec_traffic",
1597 + "VM interface IPSec traffic",
1598 + "kilobits/s",
1599 + _COMMON_PLUGIN_NAME,
1600 + _COMMON_PLUGIN_MODULE_NAME,
1601 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_NET_INTERFACE_IPSEC_TRAFFIC,
1602 + update_every,
1603 + RRDSET_TYPE_AREA);
1604 +
1605 + p->rd_IPsecoffloadBytesReceivedSec =
1606 + rrddim_add(p->st_IPsecoffloadBytes, "received", NULL, 8, 1000, RRD_ALGORITHM_INCREMENTAL);
1607 + p->rd_IPsecoffloadBytesSentSec =
1608 + rrddim_add(p->st_IPsecoffloadBytes, "sent", NULL, -8, 1000, RRD_ALGORITHM_INCREMENTAL);
1609 + rrdlabels_add(p->st_IPsecoffloadBytes->rrdlabels, "vm_net_interface", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1610 +
1611 + p->st_DirectedPackets = rrdset_create_localhost(
1612 + "vm_net_interface_directed_packets",
1613 + windows_shared_buffer,
1614 + NULL,
1615 + HYPERV,
1616 + HYPERV ".vm_net_interface_directed_packets",
1617 + "VM interface directed packets",
1618 + "packets/s",
1619 + _COMMON_PLUGIN_NAME,
1620 + _COMMON_PLUGIN_MODULE_NAME,
1621 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_NET_INTERFACE_DIRECTED_PACKETS,
1622 + update_every,
1623 + RRDSET_TYPE_LINE);
1624 +
1625 + p->rd_DirectedPacketsReceivedSec =
1626 + rrddim_add(p->st_DirectedPackets, "received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1627 + p->rd_DirectedPacketsSentSec =
1628 + rrddim_add(p->st_DirectedPackets, "sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1629 + rrdlabels_add(p->st_DirectedPackets->rrdlabels, "vm_net_interface", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1630 +
1631 + p->st_BroadcastPackets = rrdset_create_localhost(
1632 + "vm_net_interface_broadcast_packets",
1633 + windows_shared_buffer,
1634 + NULL,
1635 + HYPERV,
1636 + HYPERV ".vm_net_interface_broadcast_packets",
1637 + "VM interface broadcast",
1638 + "packets/s",
1639 + _COMMON_PLUGIN_NAME,
1640 + _COMMON_PLUGIN_MODULE_NAME,
1641 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_NET_INTERFACE_PACKETS,
1642 + update_every,
1643 + RRDSET_TYPE_LINE);
1644 +
1645 + p->rd_BroadcastPacketsReceivedSec =
1646 + rrddim_add(p->st_BroadcastPackets, "received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1647 + p->rd_BroadcastPacketsSentSec =
1648 + rrddim_add(p->st_BroadcastPackets, "sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1649 + rrdlabels_add(p->st_BroadcastPackets->rrdlabels, "vm_net_interface", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1650 +
1651 + p->st_MulticastPackets = rrdset_create_localhost(
1652 + "vm_net_interface_multicast_packets",
1653 + windows_shared_buffer,
1654 + NULL,
1655 + HYPERV,
1656 + HYPERV ".vm_net_interface_multicast_packets",
1657 + "VM interface multicast",
1658 + "packets/s",
1659 + _COMMON_PLUGIN_NAME,
1660 + _COMMON_PLUGIN_MODULE_NAME,
1661 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_NET_INTERFACE_MULTICAST_PACKETS,
1662 + update_every,
1663 + RRDSET_TYPE_LINE);
1664 +
1665 + p->rd_MulticastPacketsReceivedSec =
1666 + rrddim_add(p->st_MulticastPackets, "received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1667 + p->rd_MulticastPacketsSentSec =
1668 + rrddim_add(p->st_MulticastPackets, "sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1669 + rrdlabels_add(p->st_MulticastPackets->rrdlabels, "vm_net_interface", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1670 + }
1671 +
1672 + SETP_DIM_VALUE(st_dropped_packets, DroppedPacketsIncomingSec);
1673 + SETP_DIM_VALUE(st_dropped_packets, DroppedPacketsOutgoingSec);
1674 +
1675 + SETP_DIM_VALUE(st_send_receive_packets, PacketsReceivedSec);
1676 + SETP_DIM_VALUE(st_send_receive_packets, PacketsSentSec);
1677 +
1678 + SETP_DIM_VALUE(st_send_receive_bytes, BytesReceivedSec);
1679 + SETP_DIM_VALUE(st_send_receive_bytes, BytesSentSec);
1680 +
1681 + SETP_DIM_VALUE(st_IPsecoffloadBytes, IPsecoffloadBytesReceivedSec);
1682 + SETP_DIM_VALUE(st_IPsecoffloadBytes, IPsecoffloadBytesSentSec);
1683 +
1684 + SETP_DIM_VALUE(st_DirectedPackets, DirectedPacketsSentSec);
1685 + SETP_DIM_VALUE(st_DirectedPackets, DirectedPacketsReceivedSec);
1686 +
1687 + SETP_DIM_VALUE(st_BroadcastPackets, BroadcastPacketsSentSec);
1688 + SETP_DIM_VALUE(st_BroadcastPackets, BroadcastPacketsReceivedSec);
1689 +
1690 + SETP_DIM_VALUE(st_MulticastPackets, MulticastPacketsSentSec);
1691 + SETP_DIM_VALUE(st_MulticastPackets, MulticastPacketsReceivedSec);
1692 +
1693 + rrdset_done(p->st_IPsecoffloadBytes);
1694 + rrdset_done(p->st_DirectedPackets);
1695 + rrdset_done(p->st_BroadcastPackets);
1696 + rrdset_done(p->st_MulticastPackets);
1697 + rrdset_done(p->st_send_receive_bytes);
1698 + rrdset_done(p->st_send_receive_packets);
1699 + rrdset_done(p->st_dropped_packets);
1700 +}
1701 +
1702 static bool do_hyperv_network_adapter(PERF_DATA_BLOCK *pDataBlock, int update_every, void *data)
1703 {
1704 + struct hypervisor_network_adapter *p;
1705 hyperv_perf_item *item = data;
1706
1707 PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, item->registry_name);
1708 if (!pObjectType)
1709 return false;
1710
1711 + if (!pObjectType->NumInstances) {
1712 + struct hypervisor_network_adapter static_network = {};
1713 + p = &static_network;
1714 + if (!p->charts_created) {
1715 + initialize_hyperv_network_adapter_keys(p);
1716 + strncpyz(windows_shared_buffer, "[unknown]", sizeof(windows_shared_buffer) - 1);
1717 + }
1718 +
1719 + GET_OBJECT_COUNTER(DroppedPacketsIncomingSec);
1720 + GET_OBJECT_COUNTER(DroppedPacketsOutgoingSec);
1721 +
1722 + GET_OBJECT_COUNTER(PacketsReceivedSec);
1723 + GET_OBJECT_COUNTER(PacketsSentSec);
1724 +
1725 + GET_OBJECT_COUNTER(BytesReceivedSec);
1726 + GET_OBJECT_COUNTER(BytesSentSec);
1727 +
1728 + GET_OBJECT_COUNTER(IPsecoffloadBytesReceivedSec);
1729 + GET_OBJECT_COUNTER(IPsecoffloadBytesSentSec);
1730 +
1731 + GET_OBJECT_COUNTER(DirectedPacketsSentSec);
1732 + GET_OBJECT_COUNTER(DirectedPacketsReceivedSec);
1733 +
1734 + GET_OBJECT_COUNTER(BroadcastPacketsSentSec);
1735 + GET_OBJECT_COUNTER(BroadcastPacketsReceivedSec);
1736 +
1737 + GET_OBJECT_COUNTER(MulticastPacketsSentSec);
1738 + GET_OBJECT_COUNTER(MulticastPacketsReceivedSec);
1739 +
1740 + hyperv_network_adapter_chart(p, update_every);
1741 + return true;
1742 + }
1743 +
1744 PERF_INSTANCE_DEFINITION *pi = NULL;
1745 for (LONG i = 0; i < pObjectType->NumInstances; i++) {
1746 pi = perflibForEachInstance(pDataBlock, pObjectType, pi);
@@ -1389,11 +1753,7 @@ static bool do_hyperv_network_adapter(PERF_DATA_BLOCK *pDataBlock, int update_ev
1753 if (strcasecmp(windows_shared_buffer, "_Total") == 0)
1754 continue;
1755
1392 - struct hypervisor_network_adapter *p = dictionary_set(item->instance, windows_shared_buffer, NULL, sizeof(*p));
1393 -
1394 - if (!p->collected_metadata) {
1395 - p->collected_metadata = true;
1396 - }
1756 + p = dictionary_set(item->instance, windows_shared_buffer, NULL, sizeof(*p));
1757
1758 GET_INSTANCE_COUNTER(DroppedPacketsIncomingSec);
1759 GET_INSTANCE_COUNTER(DroppedPacketsOutgoingSec);
@@ -1416,186 +1776,7 @@ static bool do_hyperv_network_adapter(PERF_DATA_BLOCK *pDataBlock, int update_ev
1776 GET_INSTANCE_COUNTER(MulticastPacketsSentSec);
1777 GET_INSTANCE_COUNTER(MulticastPacketsReceivedSec);
1778
1419 - if (!p->charts_created) {
1420 - p->charts_created = true;
1421 - p->st_dropped_packets = rrdset_create_localhost(
1422 - "vm_net_interface_packets_dropped",
1423 - windows_shared_buffer,
1424 - NULL,
1425 - HYPERV,
1426 - HYPERV ".vm_net_interface_packets_dropped",
1427 - "VM interface packets dropped",
1428 - "drops/s",
1429 - _COMMON_PLUGIN_NAME,
1430 - _COMMON_PLUGIN_MODULE_NAME,
1431 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_NET_INTERFACE_PACKETS_DROPPED,
1432 - update_every,
1433 - RRDSET_TYPE_LINE);
1434 -
1435 - p->rd_DroppedPacketsIncomingSec =
1436 - rrddim_add(p->st_dropped_packets, "incoming", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1437 - p->rd_DroppedPacketsOutgoingSec =
1438 - rrddim_add(p->st_dropped_packets, "outgoing", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1439 -
1440 - rrdlabels_add(
1441 - p->st_dropped_packets->rrdlabels, "vm_net_interface", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1442 -
1443 - p->st_send_receive_packets = rrdset_create_localhost(
1444 - "vm_net_interface_packets",
1445 - windows_shared_buffer,
1446 - NULL,
1447 - HYPERV,
1448 - HYPERV ".vm_net_interface_packets",
1449 - "VM interface packets",
1450 - "packets/s",
1451 - _COMMON_PLUGIN_NAME,
1452 - _COMMON_PLUGIN_MODULE_NAME,
1453 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_NET_INTERFACE_PACKETS,
1454 - update_every,
1455 - RRDSET_TYPE_LINE);
1456 -
1457 - p->rd_PacketsReceivedSec =
1458 - rrddim_add(p->st_send_receive_packets, "received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1459 - p->rd_PacketsSentSec =
1460 - rrddim_add(p->st_send_receive_packets, "sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1461 -
1462 - rrdlabels_add(
1463 - p->st_send_receive_packets->rrdlabels, "vm_net_interface", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1464 -
1465 - p->st_send_receive_bytes = rrdset_create_localhost(
1466 - "vm_net_interface_traffic",
1467 - windows_shared_buffer,
1468 - NULL,
1469 - HYPERV,
1470 - HYPERV ".vm_net_interface_traffic",
1471 - "VM interface traffic",
1472 - "kilobits/s",
1473 - _COMMON_PLUGIN_NAME,
1474 - _COMMON_PLUGIN_MODULE_NAME,
1475 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_NET_INTERFACE_TRAFFIC,
1476 - update_every,
1477 - RRDSET_TYPE_AREA);
1478 -
1479 - p->rd_BytesReceivedSec =
1480 - rrddim_add(p->st_send_receive_bytes, "received", NULL, 8, 1000, RRD_ALGORITHM_INCREMENTAL);
1481 - p->rd_BytesSentSec =
1482 - rrddim_add(p->st_send_receive_bytes, "sent", NULL, -8, 1000, RRD_ALGORITHM_INCREMENTAL);
1483 - rrdlabels_add(
1484 - p->st_send_receive_bytes->rrdlabels, "vm_net_interface", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1485 -
1486 - p->st_IPsecoffloadBytes = rrdset_create_localhost(
1487 - "vm_net_interface_ipsec_traffic",
1488 - windows_shared_buffer,
1489 - NULL,
1490 - HYPERV,
1491 - HYPERV ".vm_net_interface_ipsec_traffic",
1492 - "VM interface IPSec traffic",
1493 - "kilobits/s",
1494 - _COMMON_PLUGIN_NAME,
1495 - _COMMON_PLUGIN_MODULE_NAME,
1496 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_NET_INTERFACE_IPSEC_TRAFFIC,
1497 - update_every,
1498 - RRDSET_TYPE_AREA);
1499 -
1500 - p->rd_IPsecoffloadBytesReceivedSec =
1501 - rrddim_add(p->st_IPsecoffloadBytes, "received", NULL, 8, 1000, RRD_ALGORITHM_INCREMENTAL);
1502 - p->rd_IPsecoffloadBytesSentSec =
1503 - rrddim_add(p->st_IPsecoffloadBytes, "sent", NULL, -8, 1000, RRD_ALGORITHM_INCREMENTAL);
1504 - rrdlabels_add(
1505 - p->st_IPsecoffloadBytes->rrdlabels, "vm_net_interface", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1506 -
1507 - p->st_DirectedPackets = rrdset_create_localhost(
1508 - "vm_net_interface_directed_packets",
1509 - windows_shared_buffer,
1510 - NULL,
1511 - HYPERV,
1512 - HYPERV ".vm_net_interface_directed_packets",
1513 - "VM interface directed packets",
1514 - "packets/s",
1515 - _COMMON_PLUGIN_NAME,
1516 - _COMMON_PLUGIN_MODULE_NAME,
1517 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_NET_INTERFACE_DIRECTED_PACKETS,
1518 - update_every,
1519 - RRDSET_TYPE_LINE);
1520 -
1521 - p->rd_DirectedPacketsReceivedSec =
1522 - rrddim_add(p->st_DirectedPackets, "received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1523 - p->rd_DirectedPacketsSentSec =
1524 - rrddim_add(p->st_DirectedPackets, "sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1525 - rrdlabels_add(
1526 - p->st_DirectedPackets->rrdlabels, "vm_net_interface", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1527 -
1528 - p->st_BroadcastPackets = rrdset_create_localhost(
1529 - "vm_net_interface_broadcast_packets",
1530 - windows_shared_buffer,
1531 - NULL,
1532 - HYPERV,
1533 - HYPERV ".vm_net_interface_broadcast_packets",
1534 - "VM interface broadcast",
1535 - "packets/s",
1536 - _COMMON_PLUGIN_NAME,
1537 - _COMMON_PLUGIN_MODULE_NAME,
1538 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_NET_INTERFACE_PACKETS,
1539 - update_every,
1540 - RRDSET_TYPE_LINE);
1541 -
1542 - p->rd_BroadcastPacketsReceivedSec =
1543 - rrddim_add(p->st_BroadcastPackets, "received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1544 - p->rd_BroadcastPacketsSentSec =
1545 - rrddim_add(p->st_BroadcastPackets, "sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1546 - rrdlabels_add(
1547 - p->st_BroadcastPackets->rrdlabels, "vm_net_interface", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1548 -
1549 - p->st_MulticastPackets = rrdset_create_localhost(
1550 - "vm_net_interface_multicast_packets",
1551 - windows_shared_buffer,
1552 - NULL,
1553 - HYPERV,
1554 - HYPERV ".vm_net_interface_multicast_packets",
1555 - "VM interface multicast",
1556 - "packets/s",
1557 - _COMMON_PLUGIN_NAME,
1558 - _COMMON_PLUGIN_MODULE_NAME,
1559 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_NET_INTERFACE_MULTICAST_PACKETS,
1560 - update_every,
1561 - RRDSET_TYPE_LINE);
1562 -
1563 - p->rd_MulticastPacketsReceivedSec =
1564 - rrddim_add(p->st_MulticastPackets, "received", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1565 - p->rd_MulticastPacketsSentSec =
1566 - rrddim_add(p->st_MulticastPackets, "sent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1567 - rrdlabels_add(
1568 - p->st_MulticastPackets->rrdlabels, "vm_net_interface", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1569 - }
1570 -
1571 - SETP_DIM_VALUE(st_dropped_packets, DroppedPacketsIncomingSec);
1572 - SETP_DIM_VALUE(st_dropped_packets, DroppedPacketsOutgoingSec);
1573 -
1574 - SETP_DIM_VALUE(st_send_receive_packets, PacketsReceivedSec);
1575 - SETP_DIM_VALUE(st_send_receive_packets, PacketsSentSec);
1576 -
1577 - SETP_DIM_VALUE(st_send_receive_bytes, BytesReceivedSec);
1578 - SETP_DIM_VALUE(st_send_receive_bytes, BytesSentSec);
1579 -
1580 - SETP_DIM_VALUE(st_IPsecoffloadBytes, IPsecoffloadBytesReceivedSec);
1581 - SETP_DIM_VALUE(st_IPsecoffloadBytes, IPsecoffloadBytesSentSec);
1582 -
1583 - SETP_DIM_VALUE(st_DirectedPackets, DirectedPacketsSentSec);
1584 - SETP_DIM_VALUE(st_DirectedPackets, DirectedPacketsReceivedSec);
1585 -
1586 - SETP_DIM_VALUE(st_BroadcastPackets, BroadcastPacketsSentSec);
1587 - SETP_DIM_VALUE(st_BroadcastPackets, BroadcastPacketsReceivedSec);
1588 -
1589 - SETP_DIM_VALUE(st_MulticastPackets, MulticastPacketsSentSec);
1590 - SETP_DIM_VALUE(st_MulticastPackets, MulticastPacketsReceivedSec);
1591 -
1592 - rrdset_done(p->st_IPsecoffloadBytes);
1593 - rrdset_done(p->st_DirectedPackets);
1594 - rrdset_done(p->st_BroadcastPackets);
1595 - rrdset_done(p->st_MulticastPackets);
1596 - rrdset_done(p->st_send_receive_bytes);
1597 - rrdset_done(p->st_send_receive_packets);
1598 - rrdset_done(p->st_dropped_packets);
1779 + hyperv_network_adapter_chart(p, update_every);
1780 }
1781 return true;
1782 }
@@ -1642,14 +1823,84 @@ void dict_hyperv_processor_insert_cb(const DICTIONARY_ITEM *item __maybe_unused,
1823 initialize_hyperv_processor_keys(p);
1824 }
1825
1826 +static void hyperv_processor_chart(struct hypervisor_processor *p, int update_every)
1827 +{
1828 + if (!p->charts_created) {
1829 + p->charts_created = true;
1830 + p->st_HypervisorProcessorTotal = rrdset_create_localhost(
1831 + "vm_cpu_usage",
1832 + windows_shared_buffer,
1833 + NULL,
1834 + HYPERV,
1835 + HYPERV ".vm_cpu_usage",
1836 + "VM CPU usage",
1837 + "percentage",
1838 + _COMMON_PLUGIN_NAME,
1839 + _COMMON_PLUGIN_MODULE_NAME,
1840 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_CPU_USAGE,
1841 + update_every,
1842 + RRDSET_TYPE_AREA);
1843 +
1844 + p->rd_TotalRunTime =
1845 + rrddim_add(p->st_HypervisorProcessorTotal, "usage", NULL, 1, 1000000, RRD_ALGORITHM_INCREMENTAL);
1846 + rrdlabels_add(p->st_HypervisorProcessorTotal->rrdlabels, "vm_name", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1847 +
1848 + p->st_HypervisorProcessor = rrdset_create_localhost(
1849 + "vm_cpu_usage_by_run_context",
1850 + windows_shared_buffer,
1851 + NULL,
1852 + HYPERV,
1853 + HYPERV ".vm_cpu_usage_by_run_context",
1854 + "VM CPU usage by run context",
1855 + "percentage",
1856 + _COMMON_PLUGIN_NAME,
1857 + _COMMON_PLUGIN_MODULE_NAME,
1858 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_CPU_USAGE_BY_RUN_CONTEXT,
1859 + update_every,
1860 + RRDSET_TYPE_STACKED);
1861 +
1862 + p->rd_GuestRunTime =
1863 + rrddim_add(p->st_HypervisorProcessor, "guest", NULL, 1, 1000000, RRD_ALGORITHM_INCREMENTAL);
1864 + p->rd_HypervisorRunTime =
1865 + rrddim_add(p->st_HypervisorProcessor, "hypervisor", NULL, 1, 1000000, RRD_ALGORITHM_INCREMENTAL);
1866 + p->rd_RemoteRunTime =
1867 + rrddim_add(p->st_HypervisorProcessor, "remote", NULL, 1, 1000000, RRD_ALGORITHM_INCREMENTAL);
1868 +
1869 + rrdlabels_add(p->st_HypervisorProcessor->rrdlabels, "vm_name", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1870 + }
1871 +
1872 + p->GuestRunTime_total += (collected_number)p->GuestRunTime.current.Data;
1873 + p->HypervisorRunTime_total += (collected_number)p->HypervisorRunTime.current.Data;
1874 + p->RemoteRunTime_total += (collected_number)p->RemoteRunTime.current.Data;
1875 + p->TotalRunTime_total += (collected_number)p->TotalRunTime.current.Data;
1876 +}
1877 +
1878 static bool do_hyperv_processor(PERF_DATA_BLOCK *pDataBlock, int update_every, void *data)
1879 {
1880 + struct hypervisor_processor *p;
1881 hyperv_perf_item *item = data;
1882
1883 PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, item->registry_name);
1884 if (!pObjectType)
1885 return false;
1886
1887 + if (!pObjectType->NumInstances) {
1888 + struct hypervisor_processor static_processor = {};
1889 + p = &static_processor;
1890 + if (!p->charts_created) {
1891 + initialize_hyperv_processor_keys(p);
1892 + strncpyz(windows_shared_buffer, "[unknown]", sizeof(windows_shared_buffer) - 1);
1893 + }
1894 +
1895 + GET_OBJECT_COUNTER(GuestRunTime);
1896 + GET_OBJECT_COUNTER(HypervisorRunTime);
1897 + GET_OBJECT_COUNTER(RemoteRunTime);
1898 + GET_OBJECT_COUNTER(TotalRunTime);
1899 +
1900 + hyperv_processor_chart(p, update_every);
1901 + return true;
1902 + }
1903 +
1904 PERF_INSTANCE_DEFINITION *pi = NULL;
1905 for (LONG i = 0; i < pObjectType->NumInstances; i++) {
1906 pi = perflibForEachInstance(pDataBlock, pObjectType, pi);
@@ -1677,59 +1928,10 @@ static bool do_hyperv_processor(PERF_DATA_BLOCK *pDataBlock, int update_every, v
1928 GET_INSTANCE_COUNTER(RemoteRunTime);
1929 GET_INSTANCE_COUNTER(TotalRunTime);
1930
1680 - if (!p->charts_created) {
1681 - p->charts_created = true;
1682 - p->st_HypervisorProcessorTotal = rrdset_create_localhost(
1683 - "vm_cpu_usage",
1684 - windows_shared_buffer,
1685 - NULL,
1686 - HYPERV,
1687 - HYPERV ".vm_cpu_usage",
1688 - "VM CPU usage",
1689 - "percentage",
1690 - _COMMON_PLUGIN_NAME,
1691 - _COMMON_PLUGIN_MODULE_NAME,
1692 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_CPU_USAGE,
1693 - update_every,
1694 - RRDSET_TYPE_AREA);
1695 -
1696 - p->rd_TotalRunTime =
1697 - rrddim_add(p->st_HypervisorProcessorTotal, "usage", NULL, 1, 1000000, RRD_ALGORITHM_INCREMENTAL);
1698 - rrdlabels_add(
1699 - p->st_HypervisorProcessorTotal->rrdlabels, "vm_name", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1700 -
1701 - p->st_HypervisorProcessor = rrdset_create_localhost(
1702 - "vm_cpu_usage_by_run_context",
1703 - windows_shared_buffer,
1704 - NULL,
1705 - HYPERV,
1706 - HYPERV ".vm_cpu_usage_by_run_context",
1707 - "VM CPU usage by run context",
1708 - "percentage",
1709 - _COMMON_PLUGIN_NAME,
1710 - _COMMON_PLUGIN_MODULE_NAME,
1711 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_CPU_USAGE_BY_RUN_CONTEXT,
1712 - update_every,
1713 - RRDSET_TYPE_STACKED);
1714 -
1715 - p->rd_GuestRunTime =
1716 - rrddim_add(p->st_HypervisorProcessor, "guest", NULL, 1, 1000000, RRD_ALGORITHM_INCREMENTAL);
1717 - p->rd_HypervisorRunTime =
1718 - rrddim_add(p->st_HypervisorProcessor, "hypervisor", NULL, 1, 1000000, RRD_ALGORITHM_INCREMENTAL);
1719 - p->rd_RemoteRunTime =
1720 - rrddim_add(p->st_HypervisorProcessor, "remote", NULL, 1, 1000000, RRD_ALGORITHM_INCREMENTAL);
1721 -
1722 - rrdlabels_add(p->st_HypervisorProcessor->rrdlabels, "vm_name", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1723 - }
1724 -
1725 - p->GuestRunTime_total += (collected_number)p->GuestRunTime.current.Data;
1726 - p->HypervisorRunTime_total += (collected_number)p->HypervisorRunTime.current.Data;
1727 - p->RemoteRunTime_total += (collected_number)p->RemoteRunTime.current.Data;
1728 - p->TotalRunTime_total += (collected_number)p->TotalRunTime.current.Data;
1931 + hyperv_processor_chart(p, update_every);
1932 }
1933
1934 {
1732 - struct hypervisor_processor *p;
1935 dfe_start_read(item->instance, p)
1936 {
1937 rrddim_set_by_pointer(