@cryptotaxi247 / netdata-1 / commits / 0453c3aed

Revert "HyperV Adjusts (windows.plugin)" (#19630)

Revert "HyperV Adjusts (windows.plugin) (#19623)" This reverts commit fdeacfd8d9564b78f76036eb8259350934250a02.

Ilya Mashchenko committed Feb 12, 2025 at 20:36 UTC 0453c3aed9ab45006ecff948ea3b56c324246e9b
1 file changed +929 -1131
src/collectors/windows.plugin/perflib-hyperv.c
+929 -1131
@@ -112,109 +112,14 @@ 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 -
115 static bool do_hyperv_memory(PERF_DATA_BLOCK *pDataBlock, int update_every, void *data)
116 {
117 hyperv_perf_item *item = data;
194 - struct hypervisor_memory *p;
118
119 PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, item->registry_name);
120 if (!pObjectType)
121 return false;
122
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 -
123 PERF_INSTANCE_DEFINITION *pi = NULL;
124 for (LONG i = 0; i < pObjectType->NumInstances; i++) {
125 pi = perflibForEachInstance(pDataBlock, pObjectType, pi);
@@ -224,96 +129,99 @@ static bool do_hyperv_memory(PERF_DATA_BLOCK *pDataBlock, int update_every, void
129 get_and_sanitize_instance_value(
130 pDataBlock, pObjectType, pi, windows_shared_buffer, sizeof(windows_shared_buffer));
131
227 - p = dictionary_set(item->instance, windows_shared_buffer, NULL, sizeof(*p));
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 + }
137
138 GET_INSTANCE_COUNTER(CurrentPressure);
139 GET_INSTANCE_COUNTER(PhysicalMemory);
140 GET_INSTANCE_COUNTER(GuestVisiblePhysicalMemory);
141 GET_INSTANCE_COUNTER(GuestAvailableMemory);
233 - hyperv_memory_chart(p, update_every);
234 - }
235 -
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);
142
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);
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 + }
205
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);
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);
210
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);
211 + rrdset_done(p->st_pressure);
212 + rrdset_done(p->st_vm_memory_physical);
213 + rrdset_done(p->st_vm_memory_physical_guest_visible);
214 }
215
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);
216 + return true;
217 }
218
219 static bool do_hyperv_vid_partition(PERF_DATA_BLOCK *pDataBlock, int update_every, void *data)
220 {
221 hyperv_perf_item *item = data;
297 - struct hypervisor_partition *p;
222 PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, item->registry_name);
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) {
223 + if (!pObjectType)
224 return false;
316 - }
225
226 PERF_INSTANCE_DEFINITION *pi = NULL;
227 for (LONG i = 0; i < pObjectType->NumInstances; i++) {
@@ -324,7 +232,11 @@ static bool do_hyperv_vid_partition(PERF_DATA_BLOCK *pDataBlock, int update_ever
232 get_and_sanitize_instance_value(
233 pDataBlock, pObjectType, pi, windows_shared_buffer, sizeof(windows_shared_buffer));
234
327 - p = dictionary_set(item->instance, windows_shared_buffer, NULL, sizeof(*p));
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 + }
240
241 if (strcasecmp(windows_shared_buffer, "_Total") == 0)
242 continue;
@@ -332,7 +244,53 @@ static bool do_hyperv_vid_partition(PERF_DATA_BLOCK *pDataBlock, int update_ever
244 GET_INSTANCE_COUNTER(RemotePhysicalPages);
245 GET_INSTANCE_COUNTER(PhysicalPagesAllocated);
246
335 - hyperv_vid_partition_chart(p, update_every);
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);
294 }
295
296 return true;
@@ -488,295 +446,14 @@ void dict_hyperv_root_partition_insert_cb(
446 }
447
448 // 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 -
449 static bool do_hyperv_root_partition(PERF_DATA_BLOCK *pDataBlock, int update_every, void *data)
450 {
451 hyperv_perf_item *item = data;
742 - struct hypervisor_root_partition *p;
452
453 PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, item->registry_name);
454 if (!pObjectType)
455 return false;
456
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 -
457 PERF_INSTANCE_DEFINITION *pi = NULL;
458 for (LONG i = 0; i < pObjectType->NumInstances; i++) {
459 pi = perflibForEachInstance(pDataBlock, pObjectType, pi);
@@ -789,7 +466,11 @@ static bool do_hyperv_root_partition(PERF_DATA_BLOCK *pDataBlock, int update_eve
466 if (strcasecmp(windows_shared_buffer, "_Total") == 0)
467 continue;
468
792 - p = dictionary_set(item->instance, windows_shared_buffer, NULL, sizeof(*p));
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 + }
474
475 // Fetch counters
476 GET_INSTANCE_COUNTER(DeviceSpacePages4K);
@@ -810,172 +491,306 @@ static bool do_hyperv_root_partition(PERF_DATA_BLOCK *pDataBlock, int update_eve
491 GET_INSTANCE_COUNTER(VirtualTLBPages);
492 GET_INSTANCE_COUNTER(VirtualTLBFlushEntiresSec);
493
813 - hyperv_root_partition_chart(p, update_every);
814 - }
815 -
816 - return true;
817 -}
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);
510
819 -// Storage DEVICE
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);
514
821 -struct hypervisor_storage_device {
822 - bool collected_metadata;
823 - bool charts_created;
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);
528
825 - RRDSET *st_operations;
826 - DEFINE_RD(ReadOperationsSec);
827 - DEFINE_RD(WriteOperationsSec);
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);
532
829 - RRDSET *st_bytes;
830 - DEFINE_RD(ReadBytesSec);
831 - DEFINE_RD(WriteBytesSec);
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
833 - RRDSET *st_errors;
834 - DEFINE_RD(ErrorCount);
547 + p->rd_GPASpaceModifications =
548 + rrddim_add(p->st_gpa_space_modifications, "gpa", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
549
836 - COUNTER_DATA ReadOperationsSec;
837 - COUNTER_DATA WriteOperationsSec;
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);
563
839 - COUNTER_DATA ReadBytesSec;
840 - COUNTER_DATA WriteBytesSec;
841 - COUNTER_DATA ErrorCount;
842 -};
564 + p->rd_AttachedDevices = rrddim_add(p->st_attached_devices, "attached", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
565
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";
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);
579
850 - p->ReadBytesSec.key = "Read Bytes/sec";
851 - p->WriteBytesSec.key = "Write Bytes/sec";
852 - p->ErrorCount.key = "Error Count";
853 -}
580 + p->rd_DepositedPages = rrddim_add(p->st_deposited_pages, "gpa", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
581
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 -}
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);
595
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 - }
596 + p->rd_DeviceDMAErrors =
597 + rrddim_add(p->st_DeviceDMAErrors, "illegal_dma", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
598
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",
599 + p->st_DeviceInterruptErrors = rrdset_create_localhost(
600 + "root_partition_device_interrupt_errors",
601 windows_shared_buffer,
602 NULL,
603 HYPERV,
879 - HYPERV ".vm_storage_device_operations",
880 - "VM storage device IOPS",
881 - "operations/s",
604 + HYPERV ".root_partition_device_interrupt_errors",
605 + "Root partition illegal interrupt requests",
606 + "requests",
607 _COMMON_PLUGIN_NAME,
608 _COMMON_PLUGIN_MODULE_NAME,
884 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_STORAGE_DEVICE_OPERATIONS,
609 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_DEVICE_INTERRUPT_ERRORS,
610 update_every,
611 RRDSET_TYPE_LINE);
612
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);
613 + p->rd_DeviceInterruptErrors =
614 + rrddim_add(p->st_DeviceInterruptErrors, "illegal_interrupt", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
615
891 - rrdlabels_add(p->st_operations->rrdlabels, "vm_storage_device", windows_shared_buffer, RRDLABEL_SRC_AUTO);
892 - }
616 + p->st_DeviceInterruptThrottleEvents = rrdset_create_localhost(
617 + "root_partition_device_interrupt_throttle_events",
618 + windows_shared_buffer,
619 + NULL,
620 + HYPERV,
621 + HYPERV ".root_partition_device_interrupt_throttle_events",
622 + "Root partition throttled interrupts",
623 + "events",
624 + _COMMON_PLUGIN_NAME,
625 + _COMMON_PLUGIN_MODULE_NAME,
626 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_DEVICE_INTERRUPT_THROTTLE_EVENTS,
627 + update_every,
628 + RRDSET_TYPE_LINE);
629
894 - if (!p->st_bytes) {
895 - p->st_bytes = rrdset_create_localhost(
896 - "vm_storage_device_bytes",
630 + p->rd_DeviceInterruptThrottleEvents =
631 + rrddim_add(p->st_DeviceInterruptThrottleEvents, "throttling", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
632 +
633 + p->st_IOΤLBFlushesSec = rrdset_create_localhost(
634 + "root_partition_io_tlb_flush",
635 windows_shared_buffer,
636 NULL,
637 HYPERV,
900 - HYPERV ".vm_storage_device_bytes",
901 - "VM storage device IO",
902 - "bytes/s",
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,
905 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_STORAGE_DEVICE_BYTES,
643 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_IO_TLB_FLUSH,
644 update_every,
907 - RRDSET_TYPE_AREA);
645 + RRDSET_TYPE_LINE);
646
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);
647 + p->rd_IOΤLBFlushesSec = rrddim_add(p->st_IOΤLBFlushesSec, "gpa", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
648
912 - rrdlabels_add(p->st_bytes->rrdlabels, "vm_storage_device", windows_shared_buffer, RRDLABEL_SRC_AUTO);
913 - }
649 + p->st_AddressSpaces = rrdset_create_localhost(
650 + "root_partition_address_space",
651 + windows_shared_buffer,
652 + NULL,
653 + HYPERV,
654 + HYPERV ".root_partition_address_space",
655 + "Root partition address spaces in the virtual TLB",
656 + "address spaces",
657 + _COMMON_PLUGIN_NAME,
658 + _COMMON_PLUGIN_MODULE_NAME,
659 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_ADDRESS_SPACE,
660 + update_every,
661 + RRDSET_TYPE_LINE);
662
915 - if (!p->st_errors) {
916 - p->st_errors = rrdset_create_localhost(
917 - "vm_storage_device_errors",
663 + p->rd_AddressSpaces = rrddim_add(p->st_AddressSpaces, "address_spaces", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
664 +
665 + p->st_VirtualTLBPages = rrdset_create_localhost(
666 + "root_partition_virtual_tlb_pages",
667 windows_shared_buffer,
668 NULL,
669 HYPERV,
921 - HYPERV ".vm_storage_device_errors",
922 - "VM storage device errors",
923 - "errors/s",
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,
926 - NETDATA_CHART_PRIO_WINDOWS_HYPERV_VM_STORAGE_DEVICE_ERRORS,
675 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_VIRTUAL_TLB_PAGES,
676 update_every,
677 RRDSET_TYPE_LINE);
678
930 - p->rd_ErrorCount = rrddim_add(p->st_errors, "errors", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
679 + p->rd_VirtualTLBPages = rrddim_add(p->st_VirtualTLBPages, "used", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
680 +
681 + p->st_VirtualTLBFlushEntiresSec = rrdset_create_localhost(
682 + "root_partition_virtual_tlb_flush_entries",
683 + windows_shared_buffer,
684 + NULL,
685 + HYPERV,
686 + HYPERV ".root_partition_virtual_tlb_flush_entries",
687 + "Root partition flushes of the entire virtual TLB",
688 + "flushes/s",
689 + _COMMON_PLUGIN_NAME,
690 + _COMMON_PLUGIN_MODULE_NAME,
691 + NETDATA_CHART_PRIO_WINDOWS_HYPERV_ROOT_PARTITION_VIRTUAL_TLB_FLUSH_ENTRIES,
692 + update_every,
693 + RRDSET_TYPE_LINE);
694
932 - rrdlabels_add(p->st_errors->rrdlabels, "vm_storage_device", windows_shared_buffer, RRDLABEL_SRC_AUTO);
695 + p->rd_VirtualTLBFlushEntiresSec =
696 + rrddim_add(p->st_VirtualTLBFlushEntiresSec, "flushes", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
697 }
698 +
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);
735 }
736
936 - SETP_DIM_VALUE(st_operations, ReadOperationsSec);
937 - SETP_DIM_VALUE(st_operations, WriteOperationsSec);
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);
749
939 - SETP_DIM_VALUE(st_bytes, ReadBytesSec);
940 - SETP_DIM_VALUE(st_bytes, WriteBytesSec);
750 + RRDSET *st_bytes;
751 + DEFINE_RD(ReadBytesSec);
752 + DEFINE_RD(WriteBytesSec);
753
942 - SETP_DIM_VALUE(st_errors, ErrorCount);
754 + RRDSET *st_errors;
755 + DEFINE_RD(ErrorCount);
756
944 - // Mark the charts as done
945 - rrdset_done(p->st_operations);
946 - rrdset_done(p->st_bytes);
947 - rrdset_done(p->st_errors);
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);
784 }
785
786 static bool do_hyperv_storage_device(PERF_DATA_BLOCK *pDataBlock, int update_every, void *data)
787 {
952 - struct hypervisor_storage_device *p;
788 hyperv_perf_item *item = data;
789
790 PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, item->registry_name);
791 if (!pObjectType)
792 return false;
793
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 -
794 PERF_INSTANCE_DEFINITION *pi = NULL;
795 for (LONG i = 0; i < pObjectType->NumInstances; i++) {
796 pi = perflibForEachInstance(pDataBlock, pObjectType, pi);
@@ -988,7 +803,11 @@ static bool do_hyperv_storage_device(PERF_DATA_BLOCK *pDataBlock, int update_eve
803 if (strcasecmp(windows_shared_buffer, "_Total") == 0)
804 continue;
805
991 - p = dictionary_set(item->instance, windows_shared_buffer, NULL, sizeof(*p));
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 + }
811
812 // Fetch counters
813 GET_INSTANCE_COUNTER(ReadOperationsSec);
@@ -998,7 +817,85 @@ static bool do_hyperv_storage_device(PERF_DATA_BLOCK *pDataBlock, int update_eve
817 GET_INSTANCE_COUNTER(WriteBytesSec);
818 GET_INSTANCE_COUNTER(ErrorCount);
819
1001 - hyperv_storage_device_chart(p, update_every);
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);
899 }
900
901 return true;
@@ -1102,333 +999,287 @@ void dict_hyperv_switch_insert_cb(const DICTIONARY_ITEM *item __maybe_unused, vo
999 initialize_hyperv_switch_keys(p);
1000 }
1001
1105 -static void hyperv_switch_chart(struct hypervisor_switch *p, int update_every)
1002 +static bool do_hyperv_switch(PERF_DATA_BLOCK *pDataBlock, int update_every, void *data)
1003 {
1107 - if (!p->collected_metadata) {
1108 - p->collected_metadata = true;
1109 - }
1110 -
1111 - if (!p->charts_created) {
1112 - p->charts_created = true;
1113 -
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 -
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 -
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 -
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 -
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 -
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 -
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 -
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 -
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 -
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 -
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 -
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 -
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);
1004 + hyperv_perf_item *item = data;
1005
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);
1006 + PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, item->registry_name);
1007 + if (!pObjectType)
1008 + return false;
1009
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);
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;
1015
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);
1016 + get_and_sanitize_instance_value(
1017 + pDataBlock, pObjectType, pi, windows_shared_buffer, sizeof(windows_shared_buffer));
1018
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);
1019 + if (strcasecmp(windows_shared_buffer, "_Total") == 0)
1020 + continue;
1021
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);
1022 + struct hypervisor_switch *p = dictionary_set(item->instance, windows_shared_buffer, NULL, sizeof(*p));
1023
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);
1024 + if (!p->collected_metadata) {
1025 + p->collected_metadata = true;
1026 + }
1027
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 - }
1028 + GET_INSTANCE_COUNTER(BytesReceivedSec);
1029 + GET_INSTANCE_COUNTER(BytesSentSec);
1030
1302 - SETP_DIM_VALUE(st_packets, PacketsReceivedSec);
1303 - SETP_DIM_VALUE(st_packets, PacketsSentSec);
1031 + GET_INSTANCE_COUNTER(PacketsReceivedSec);
1032 + GET_INSTANCE_COUNTER(PacketsSentSec);
1033
1305 - SETP_DIM_VALUE(st_bytes, BytesReceivedSec);
1306 - SETP_DIM_VALUE(st_bytes, BytesSentSec);
1034 + GET_INSTANCE_COUNTER(DirectedPacketsSentSec);
1035 + GET_INSTANCE_COUNTER(DirectedPacketsReceivedSec);
1036
1308 - SETP_DIM_VALUE(st_directed_packets, DirectedPacketsSentSec);
1309 - SETP_DIM_VALUE(st_directed_packets, DirectedPacketsReceivedSec);
1037 + GET_INSTANCE_COUNTER(BroadcastPacketsSentSec);
1038 + GET_INSTANCE_COUNTER(BroadcastPacketsReceivedSec);
1039
1311 - SETP_DIM_VALUE(st_broadcast_packets, BroadcastPacketsSentSec);
1312 - SETP_DIM_VALUE(st_broadcast_packets, BroadcastPacketsReceivedSec);
1040 + GET_INSTANCE_COUNTER(MulticastPacketsSentSec);
1041 + GET_INSTANCE_COUNTER(MulticastPacketsReceivedSec);
1042
1314 - SETP_DIM_VALUE(st_multicast_packets, MulticastPacketsSentSec);
1315 - SETP_DIM_VALUE(st_multicast_packets, MulticastPacketsReceivedSec);
1043 + GET_INSTANCE_COUNTER(DroppedPacketsOutgoingSec);
1044 + GET_INSTANCE_COUNTER(DroppedPacketsIncomingSec);
1045
1317 - SETP_DIM_VALUE(st_dropped_packets, DroppedPacketsOutgoingSec);
1318 - SETP_DIM_VALUE(st_dropped_packets, DroppedPacketsIncomingSec);
1046 + GET_INSTANCE_COUNTER(ExtensionsDroppedPacketsOutgoingSec);
1047 + GET_INSTANCE_COUNTER(ExtensionsDroppedPacketsIncomingSec);
1048
1320 - SETP_DIM_VALUE(st_ext_dropped_packets, ExtensionsDroppedPacketsOutgoingSec);
1321 - SETP_DIM_VALUE(st_ext_dropped_packets, ExtensionsDroppedPacketsIncomingSec);
1049 + GET_INSTANCE_COUNTER(PacketsFlooded);
1050
1323 - SETP_DIM_VALUE(st_flooded, PacketsFlooded);
1324 - SETP_DIM_VALUE(st_learned_mac, LearnedMacAddresses);
1325 - SETP_DIM_VALUE(st_purged_mac, PurgedMacAddresses);
1051 + GET_INSTANCE_COUNTER(LearnedMacAddresses);
1052
1327 - // Mark the charts as done
1328 - rrdset_done(p->st_packets);
1329 - rrdset_done(p->st_bytes);
1053 + GET_INSTANCE_COUNTER(PurgedMacAddresses);
1054
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 -}
1055 + if (!p->charts_created) {
1056 + p->charts_created = true;
1057
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;
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);
1071
1346 - PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, item->registry_name);
1347 - if (!pObjectType)
1348 - return false;
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);
1075
1350 - if (!pObjectType->NumInstances) {
1351 - struct hypervisor_switch static_switch = {};
1352 - p = &static_switch;
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);
1089
1354 - if (!p->charts_created) {
1355 - initialize_hyperv_switch_keys(p);
1356 - strncpyz(windows_shared_buffer, "[unknown]", sizeof(windows_shared_buffer) - 1);
1357 - }
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);
1093
1359 - GET_OBJECT_COUNTER(BytesReceivedSec);
1360 - GET_OBJECT_COUNTER(BytesSentSec);
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);
1107
1362 - GET_OBJECT_COUNTER(PacketsReceivedSec);
1363 - GET_OBJECT_COUNTER(PacketsSentSec);
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);
1113
1365 - GET_OBJECT_COUNTER(DirectedPacketsSentSec);
1366 - GET_OBJECT_COUNTER(DirectedPacketsReceivedSec);
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);
1127
1368 - GET_OBJECT_COUNTER(BroadcastPacketsSentSec);
1369 - GET_OBJECT_COUNTER(BroadcastPacketsReceivedSec);
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);
1133
1371 - GET_OBJECT_COUNTER(MulticastPacketsSentSec);
1372 - GET_OBJECT_COUNTER(MulticastPacketsReceivedSec);
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);
1147
1374 - GET_OBJECT_COUNTER(DroppedPacketsOutgoingSec);
1375 - GET_OBJECT_COUNTER(DroppedPacketsIncomingSec);
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);
1153
1377 - GET_OBJECT_COUNTER(ExtensionsDroppedPacketsOutgoingSec);
1378 - GET_OBJECT_COUNTER(ExtensionsDroppedPacketsIncomingSec);
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);
1167
1380 - GET_OBJECT_COUNTER(PacketsFlooded);
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);
1173
1382 - GET_OBJECT_COUNTER(LearnedMacAddresses);
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);
1187
1384 - GET_OBJECT_COUNTER(PurgedMacAddresses);
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);
1193
1386 - hyperv_switch_chart(p, update_every);
1387 - return true;
1388 - }
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);
1207
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;
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);
1210
1396 - get_and_sanitize_instance_value(
1397 - pDataBlock, pObjectType, pi, windows_shared_buffer, sizeof(windows_shared_buffer));
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);
1224
1399 - if (strcasecmp(windows_shared_buffer, "_Total") == 0)
1400 - continue;
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);
1227
1402 - p = dictionary_set(item->instance, windows_shared_buffer, NULL, sizeof(*p));
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);
1241
1404 - GET_INSTANCE_COUNTER(BytesReceivedSec);
1405 - GET_INSTANCE_COUNTER(BytesSentSec);
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 + }
1245
1407 - GET_INSTANCE_COUNTER(PacketsReceivedSec);
1408 - GET_INSTANCE_COUNTER(PacketsSentSec);
1246 + SETP_DIM_VALUE(st_packets, PacketsReceivedSec);
1247 + SETP_DIM_VALUE(st_packets, PacketsSentSec);
1248
1410 - GET_INSTANCE_COUNTER(DirectedPacketsSentSec);
1411 - GET_INSTANCE_COUNTER(DirectedPacketsReceivedSec);
1249 + SETP_DIM_VALUE(st_bytes, BytesReceivedSec);
1250 + SETP_DIM_VALUE(st_bytes, BytesSentSec);
1251
1413 - GET_INSTANCE_COUNTER(BroadcastPacketsSentSec);
1414 - GET_INSTANCE_COUNTER(BroadcastPacketsReceivedSec);
1252 + SETP_DIM_VALUE(st_directed_packets, DirectedPacketsSentSec);
1253 + SETP_DIM_VALUE(st_directed_packets, DirectedPacketsReceivedSec);
1254
1416 - GET_INSTANCE_COUNTER(MulticastPacketsSentSec);
1417 - GET_INSTANCE_COUNTER(MulticastPacketsReceivedSec);
1255 + SETP_DIM_VALUE(st_broadcast_packets, BroadcastPacketsSentSec);
1256 + SETP_DIM_VALUE(st_broadcast_packets, BroadcastPacketsReceivedSec);
1257
1419 - GET_INSTANCE_COUNTER(DroppedPacketsOutgoingSec);
1420 - GET_INSTANCE_COUNTER(DroppedPacketsIncomingSec);
1258 + SETP_DIM_VALUE(st_multicast_packets, MulticastPacketsSentSec);
1259 + SETP_DIM_VALUE(st_multicast_packets, MulticastPacketsReceivedSec);
1260
1422 - GET_INSTANCE_COUNTER(ExtensionsDroppedPacketsOutgoingSec);
1423 - GET_INSTANCE_COUNTER(ExtensionsDroppedPacketsIncomingSec);
1261 + SETP_DIM_VALUE(st_dropped_packets, DroppedPacketsOutgoingSec);
1262 + SETP_DIM_VALUE(st_dropped_packets, DroppedPacketsIncomingSec);
1263
1425 - GET_INSTANCE_COUNTER(PacketsFlooded);
1264 + SETP_DIM_VALUE(st_ext_dropped_packets, ExtensionsDroppedPacketsOutgoingSec);
1265 + SETP_DIM_VALUE(st_ext_dropped_packets, ExtensionsDroppedPacketsIncomingSec);
1266
1427 - GET_INSTANCE_COUNTER(LearnedMacAddresses);
1267 + SETP_DIM_VALUE(st_flooded, PacketsFlooded);
1268 + SETP_DIM_VALUE(st_learned_mac, LearnedMacAddresses);
1269 + SETP_DIM_VALUE(st_purged_mac, PurgedMacAddresses);
1270
1429 - GET_INSTANCE_COUNTER(PurgedMacAddresses);
1271 + // Mark the charts as done
1272 + rrdset_done(p->st_packets);
1273 + rrdset_done(p->st_bytes);
1274
1431 - hyperv_switch_chart(p, update_every);
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);
1283 }
1284 return true;
1285 }
@@ -1518,229 +1369,14 @@ void dict_hyperv_network_adapter_insert_cb(
1369 initialize_hyperv_network_adapter_keys(p);
1370 }
1371
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 -
1372 static bool do_hyperv_network_adapter(PERF_DATA_BLOCK *pDataBlock, int update_every, void *data)
1373 {
1704 - struct hypervisor_network_adapter *p;
1374 hyperv_perf_item *item = data;
1375
1376 PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, item->registry_name);
1377 if (!pObjectType)
1378 return false;
1379
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 -
1380 PERF_INSTANCE_DEFINITION *pi = NULL;
1381 for (LONG i = 0; i < pObjectType->NumInstances; i++) {
1382 pi = perflibForEachInstance(pDataBlock, pObjectType, pi);
@@ -1753,7 +1389,11 @@ static bool do_hyperv_network_adapter(PERF_DATA_BLOCK *pDataBlock, int update_ev
1389 if (strcasecmp(windows_shared_buffer, "_Total") == 0)
1390 continue;
1391
1756 - p = dictionary_set(item->instance, windows_shared_buffer, NULL, sizeof(*p));
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 + }
1397
1398 GET_INSTANCE_COUNTER(DroppedPacketsIncomingSec);
1399 GET_INSTANCE_COUNTER(DroppedPacketsOutgoingSec);
@@ -1776,7 +1416,186 @@ static bool do_hyperv_network_adapter(PERF_DATA_BLOCK *pDataBlock, int update_ev
1416 GET_INSTANCE_COUNTER(MulticastPacketsSentSec);
1417 GET_INSTANCE_COUNTER(MulticastPacketsReceivedSec);
1418
1779 - hyperv_network_adapter_chart(p, update_every);
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);
1599 }
1600 return true;
1601 }
@@ -1823,84 +1642,14 @@ void dict_hyperv_processor_insert_cb(const DICTIONARY_ITEM *item __maybe_unused,
1642 initialize_hyperv_processor_keys(p);
1643 }
1644
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 -
1645 static bool do_hyperv_processor(PERF_DATA_BLOCK *pDataBlock, int update_every, void *data)
1646 {
1880 - struct hypervisor_processor *p;
1647 hyperv_perf_item *item = data;
1648
1649 PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, item->registry_name);
1650 if (!pObjectType)
1651 return false;
1652
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 -
1653 PERF_INSTANCE_DEFINITION *pi = NULL;
1654 for (LONG i = 0; i < pObjectType->NumInstances; i++) {
1655 pi = perflibForEachInstance(pDataBlock, pObjectType, pi);
@@ -1928,10 +1677,59 @@ static bool do_hyperv_processor(PERF_DATA_BLOCK *pDataBlock, int update_every, v
1677 GET_INSTANCE_COUNTER(RemoteRunTime);
1678 GET_INSTANCE_COUNTER(TotalRunTime);
1679
1931 - hyperv_processor_chart(p, update_every);
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;
1729 }
1730
1731 {
1732 + struct hypervisor_processor *p;
1733 dfe_start_read(item->instance, p)
1734 {
1735 rrddim_set_by_pointer(