@cryptotaxi247 / netdata-1 / commits / 06da20465

Split cgroup charts (#15975)

Co-authored-by: ilyam8 <ilya@netdata.cloud>

thiagoftsm committed Oct 2, 2023 at 09:38 UTC 06da204652da549d3a5c94d64c4ffe46fc7b5c15
2 files changed +507 -884
collectors/cgroups.plugin/metadata.yaml
+76 -126
@@ -821,154 +821,104 @@ modules:
821 description: ""
822 availability: []
823 scopes:
824 - - name: global
824 + - name: systemd service
825 description: ""
826 - labels: []
826 + labels:
827 + - name: service_name
828 + description: Service name
829 metrics:
828 - - name: services.cpu
830 + - name: systemd.service.cpu.utilization
831 description: Systemd Services CPU utilization (100% = 1 core)
830 - unit: "percentage"
832 + unit: percentage
833 chart_type: stacked
834 dimensions:
833 - - name: a dimension per systemd service
834 - - name: services.mem_usage
835 + - name: user
836 + - name: system
837 + - name: systemd.service.memory.usage
838 description: Systemd Services Used Memory
836 - unit: "MiB"
837 - chart_type: stacked
838 - dimensions:
839 - - name: a dimension per systemd service
840 - - name: services.mem_rss
841 - description: Systemd Services RSS Memory
842 - unit: "MiB"
843 - chart_type: stacked
844 - dimensions:
845 - - name: a dimension per systemd service
846 - - name: services.mem_mapped
847 - description: Systemd Services Mapped Memory
848 - unit: "MiB"
839 + unit: MiB
840 chart_type: stacked
841 dimensions:
851 - - name: a dimension per systemd service
852 - - name: services.mem_cache
853 - description: Systemd Services Cache Memory
854 - unit: "MiB"
855 - chart_type: stacked
856 - dimensions:
857 - - name: a dimension per systemd service
858 - - name: services.mem_writeback
859 - description: Systemd Services Writeback Memory
860 - unit: "MiB"
861 - chart_type: stacked
862 - dimensions:
863 - - name: a dimension per systemd service
864 - - name: services.mem_pgfault
865 - description: Systemd Services Memory Minor Page Faults
866 - unit: "MiB/s"
867 - chart_type: stacked
868 - dimensions:
869 - - name: a dimension per systemd service
870 - - name: services.mem_pgmajfault
871 - description: Systemd Services Memory Major Page Faults
872 - unit: "MiB/s"
873 - chart_type: stacked
874 - dimensions:
875 - - name: a dimension per systemd service
876 - - name: services.mem_pgpgin
877 - description: Systemd Services Memory Charging Activity
878 - unit: "MiB/s"
879 - chart_type: stacked
880 - dimensions:
881 - - name: a dimension per systemd service
882 - - name: services.mem_pgpgout
883 - description: Systemd Services Memory Uncharging Activity
884 - unit: "MiB/s"
885 - chart_type: stacked
886 - dimensions:
887 - - name: a dimension per systemd service
888 - - name: services.mem_failcnt
842 + - name: ram
843 + - name: swap
844 + - name: systemd.service.memory.failcnt
845 description: Systemd Services Memory Limit Failures
890 - unit: "failures"
891 - chart_type: stacked
892 - dimensions:
893 - - name: a dimension per systemd service
894 - - name: services.swap_usage
895 - description: Systemd Services Swap Memory Used
896 - unit: "MiB"
897 - chart_type: stacked
898 - dimensions:
899 - - name: a dimension per systemd service
900 - - name: services.io_read
901 - description: Systemd Services Disk Read Bandwidth
902 - unit: "KiB/s"
903 - chart_type: stacked
904 - dimensions:
905 - - name: a dimension per systemd service
906 - - name: services.io_write
907 - description: Systemd Services Disk Write Bandwidth
908 - unit: "KiB/s"
909 - chart_type: stacked
846 + unit: failures/s
847 + chart_type: line
848 dimensions:
911 - - name: a dimension per systemd service
912 - - name: services.io_ops_read
913 - description: Systemd Services Disk Read Operations
914 - unit: "operations/s"
849 + - name: fail
850 + - name: systemd.service.memory.ram.usage
851 + description: Systemd Services Memory
852 + unit: MiB
853 chart_type: stacked
854 dimensions:
917 - - name: a dimension per systemd service
918 - - name: services.io_ops_write
919 - description: Systemd Services Disk Write Operations
920 - unit: "operations/s"
855 + - name: rss
856 + - name: cache
857 + - name: mapped_file
858 + - name: rss_huge
859 + - name: systemd.service.memory.writeback
860 + description: Systemd Services Writeback Memory
861 + unit: MiB
862 chart_type: stacked
863 dimensions:
923 - - name: a dimension per systemd service
924 - - name: services.throttle_io_read
925 - description: Systemd Services Throttle Disk Read Bandwidth
926 - unit: "KiB/s"
927 - chart_type: stacked
864 + - name: writeback
865 + - name: dirty
866 + - name: systemd.service.memory.paging.faults
867 + description: Systemd Services Memory Minor and Major Page Faults
868 + unit: MiB/s
869 + chart_type: area
870 dimensions:
929 - - name: a dimension per systemd service
930 - - name: services.services.throttle_io_write
931 - description: Systemd Services Throttle Disk Write Bandwidth
932 - unit: "KiB/s"
933 - chart_type: stacked
871 + - name: minor
872 + - name: major
873 + - name: systemd.service.memory.paging.io
874 + description: Systemd Services Memory Paging IO
875 + unit: MiB/s
876 + chart_type: area
877 dimensions:
935 - - name: a dimension per systemd service
936 - - name: services.throttle_io_ops_read
937 - description: Systemd Services Throttle Disk Read Operations
938 - unit: "operations/s"
939 - chart_type: stacked
878 + - name: in
879 + - name: out
880 + - name: systemd.service.disk.io
881 + description: Systemd Services Disk Read/Write Bandwidth
882 + unit: KiB/s
883 + chart_type: area
884 dimensions:
941 - - name: a dimension per systemd service
942 - - name: throttle_io_ops_write
943 - description: Systemd Services Throttle Disk Write Operations
944 - unit: "operations/s"
945 - chart_type: stacked
885 + - name: read
886 + - name: write
887 + - name: systemd.service.disk.iops
888 + description: Systemd Services Disk Read/Write Operations
889 + unit: operations/s
890 + chart_type: line
891 dimensions:
947 - - name: a dimension per systemd service
948 - - name: services.queued_io_ops_read
949 - description: Systemd Services Queued Disk Read Operations
950 - unit: "operations/s"
951 - chart_type: stacked
892 + - name: read
893 + - name: write
894 + - name: systemd.service.disk.throttle.io
895 + description: Systemd Services Throttle Disk Read/Write Bandwidth
896 + unit: KiB/s
897 + chart_type: area
898 dimensions:
953 - - name: a dimension per systemd service
954 - - name: services.queued_io_ops_write
955 - description: Systemd Services Queued Disk Write Operations
956 - unit: "operations/s"
957 - chart_type: stacked
899 + - name: read
900 + - name: write
901 + - name: systemd.service.disk.throttle.iops
902 + description: Systemd Services Throttle Disk Read/Write Operations
903 + unit: operations/s
904 + chart_type: line
905 dimensions:
959 - - name: a dimension per systemd service
960 - - name: services.merged_io_ops_read
961 - description: Systemd Services Merged Disk Read Operations
962 - unit: "operations/s"
963 - chart_type: stacked
906 + - name: read
907 + - name: write
908 + - name: systemd.service.disk.queued_iops
909 + description: Systemd Services Queued Disk Read/Write Operations
910 + unit: operations/s
911 + chart_type: line
912 dimensions:
965 - - name: a dimension per systemd service
966 - - name: services.merged_io_ops_write
967 - description: Systemd Services Merged Disk Write Operations
968 - unit: "operations/s"
969 - chart_type: stacked
913 + - name: read
914 + - name: write
915 + - name: systemd.service.disk.merged_iops
916 + description: Systemd Services Merged Disk Read/Write Operations
917 + unit: operations/s
918 + chart_type: line
919 dimensions:
971 - - name: a dimension per systemd service
920 + - name: read
921 + - name: write
922 - <<: *module
923 meta:
924 <<: *meta
collectors/cgroups.plugin/sys_fs_cgroup.c
+431 -758
@@ -38,6 +38,7 @@
38 // cgroup globals
39
40 static char cgroup_chart_id_prefix[] = "cgroup_";
41 +static char services_chart_id_prefix[] = "systemd_";
42
43 static int is_inside_k8s = 0;
44
@@ -796,15 +797,18 @@ struct cgroup {
797 char enabled; // enabled in the config
798
799 char pending_renames;
799 - char *intermediate_id; // TODO: remove it when the renaming script is fixed
800
801 char *id;
802 uint32_t hash;
803
804 + char *intermediate_id; // TODO: remove it when the renaming script is fixed
805 +
806 char *chart_id;
805 - uint32_t hash_chart;
807 + uint32_t hash_chart_id;
808
807 - char *chart_title;
809 + // 'cgroup_name' label value.
810 + // By default this is the *id (path), later changed to the resolved name (cgroup-name.sh) or systemd service name.
811 + char *name;
812
813 RRDLABELS *chart_labels;
814
@@ -878,35 +882,6 @@ struct cgroup {
882 unsigned long long memoryswap_limit;
883 const RRDSETVAR_ACQUIRED *chart_var_memoryswap_limit;
884
881 - // services
882 - RRDDIM *rd_cpu;
883 - RRDDIM *rd_mem_usage;
884 - RRDDIM *rd_mem_failcnt;
885 - RRDDIM *rd_swap_usage;
886 -
887 - RRDDIM *rd_mem_detailed_cache;
888 - RRDDIM *rd_mem_detailed_rss;
889 - RRDDIM *rd_mem_detailed_mapped;
890 - RRDDIM *rd_mem_detailed_writeback;
891 - RRDDIM *rd_mem_detailed_pgpgin;
892 - RRDDIM *rd_mem_detailed_pgpgout;
893 - RRDDIM *rd_mem_detailed_pgfault;
894 - RRDDIM *rd_mem_detailed_pgmajfault;
895 -
896 - RRDDIM *rd_io_service_bytes_read;
897 - RRDDIM *rd_io_serviced_read;
898 - RRDDIM *rd_throttle_io_read;
899 - RRDDIM *rd_throttle_io_serviced_read;
900 - RRDDIM *rd_io_queued_read;
901 - RRDDIM *rd_io_merged_read;
902 -
903 - RRDDIM *rd_io_service_bytes_write;
904 - RRDDIM *rd_io_serviced_write;
905 - RRDDIM *rd_throttle_io_write;
906 - RRDDIM *rd_throttle_io_serviced_write;
907 - RRDDIM *rd_io_queued_write;
908 - RRDDIM *rd_io_merged_write;
909 -
885 struct cgroup *next;
886 struct cgroup *discovered_next;
887
@@ -1667,7 +1642,7 @@ static inline void read_all_discovered_cgroups(struct cgroup *root) {
1642
1643 #define CGROUP_NETWORK_INTERFACE_MAX_LINE 2048
1644 static inline void read_cgroup_network_interfaces(struct cgroup *cg) {
1670 - netdata_log_debug(D_CGROUP, "looking for the network interfaces of cgroup '%s' with chart id '%s' and title '%s'", cg->id, cg->chart_id, cg->chart_title);
1645 + netdata_log_debug(D_CGROUP, "looking for the network interfaces of cgroup '%s' with chart id '%s'", cg->id, cg->chart_id);
1646
1647 pid_t cgroup_pid;
1648 char cgroup_identifier[CGROUP_NETWORK_INTERFACE_MAX_LINE + 1];
@@ -1747,17 +1722,6 @@ static inline void free_cgroup_network_interfaces(struct cgroup *cg) {
1722
1723 #define CGROUP_CHARTID_LINE_MAX 1024
1724
1750 -static inline char *cgroup_title_strdupz(const char *s) {
1751 - if(!s || !*s) s = "/";
1752 -
1753 - if(*s == '/' && s[1] != '\0') s++;
1754 -
1755 - char *r = strdupz(s);
1756 - netdata_fix_chart_name(r);
1757 -
1758 - return r;
1759 -}
1760 -
1725 static inline char *cgroup_chart_id_strdupz(const char *s) {
1726 if(!s || !*s) s = "/";
1727
@@ -1866,7 +1830,7 @@ static inline void cgroup_free(struct cgroup *cg) {
1830 freez(cg->id);
1831 freez(cg->intermediate_id);
1832 freez(cg->chart_id);
1869 - freez(cg->chart_title);
1833 + freez(cg->name);
1834
1835 rrdlabels_destroy(cg->chart_labels);
1836
@@ -1883,7 +1847,7 @@ static inline void discovery_rename_cgroup(struct cgroup *cg) {
1847 }
1848 cg->pending_renames--;
1849
1886 - netdata_log_debug(D_CGROUP, "looking for the name of cgroup '%s' with chart id '%s' and title '%s'", cg->id, cg->chart_id, cg->chart_title);
1850 + netdata_log_debug(D_CGROUP, "looking for the name of cgroup '%s' with chart id '%s'", cg->id, cg->chart_id);
1851 netdata_log_debug(D_CGROUP, "executing command %s \"%s\" for cgroup '%s'", cgroups_rename_script, cg->intermediate_id, cg->chart_id);
1852 pid_t cgroup_pid;
1853
@@ -1927,14 +1891,14 @@ static inline void discovery_rename_cgroup(struct cgroup *cg) {
1891 name = cgroup_parse_resolved_name_and_labels(cg->chart_labels, new_name);
1892 rrdlabels_remove_all_unmarked(cg->chart_labels);
1893
1930 - freez(cg->chart_title);
1931 - cg->chart_title = cgroup_title_strdupz(name);
1894 + freez(cg->name);
1895 + cg->name = strdupz(name);
1896
1897 freez(cg->chart_id);
1898 cg->chart_id = cgroup_chart_id_strdupz(name);
1899
1900 substitute_dots_in_id(cg->chart_id);
1937 - cg->hash_chart = simple_hash(cg->chart_id);
1901 + cg->hash_chart_id = simple_hash(cg->chart_id);
1902 }
1903
1904 static void is_cgroup_procs_exist(netdata_ebpf_cgroup_shm_body_t *out, char *id) {
@@ -1992,21 +1956,31 @@ static inline void convert_cgroup_to_systemd_service(struct cgroup *cg) {
1956 s[len] = '\0';
1957 }
1958
1995 - freez(cg->chart_title);
1996 - cg->chart_title = cgroup_title_strdupz(s);
1959 + freez(cg->name);
1960 + cg->name = strdupz(s);
1961 +
1962 + freez(cg->chart_id);
1963 + cg->chart_id = cgroup_chart_id_strdupz(s);
1964 + substitute_dots_in_id(cg->chart_id);
1965 + cg->hash_chart_id = simple_hash(cg->chart_id);
1966 }
1967
1968 static inline struct cgroup *discovery_cgroup_add(const char *id) {
1969 netdata_log_debug(D_CGROUP, "adding to list, cgroup with id '%s'", id);
1970
1971 struct cgroup *cg = callocz(1, sizeof(struct cgroup));
1972 +
1973 cg->id = strdupz(id);
1974 cg->hash = simple_hash(cg->id);
2005 - cg->chart_title = cgroup_title_strdupz(id);
1975 +
1976 + cg->name = strdupz(id);
1977 +
1978 cg->intermediate_id = cgroup_chart_id_strdupz(id);
1979 +
1980 cg->chart_id = cgroup_chart_id_strdupz(id);
1981 substitute_dots_in_id(cg->chart_id);
2009 - cg->hash_chart = simple_hash(cg->chart_id);
1982 + cg->hash_chart_id = simple_hash(cg->chart_id);
1983 +
1984 if (cgroup_use_unified_cgroups) {
1985 cg->options |= CGROUP_OPTIONS_IS_UNIFIED;
1986 }
@@ -2500,8 +2474,10 @@ static inline void discovery_cleanup_all_cgroups() {
2474 // enable the first duplicate cgroup
2475 {
2476 struct cgroup *t;
2503 - for(t = discovered_cgroup_root; t ; t = t->discovered_next) {
2504 - if(t != cg && t->available && !t->enabled && t->options & CGROUP_OPTIONS_DISABLED_DUPLICATE && t->hash_chart == cg->hash_chart && !strcmp(t->chart_id, cg->chart_id)) {
2477 + for (t = discovered_cgroup_root; t; t = t->discovered_next) {
2478 + if (t != cg && t->available && !t->enabled && t->options & CGROUP_OPTIONS_DISABLED_DUPLICATE &&
2479 + (is_cgroup_systemd_service(t) == is_cgroup_systemd_service(cg)) &&
2480 + t->hash_chart_id == cg->hash_chart_id && !strcmp(t->chart_id, cg->chart_id)) {
2481 netdata_log_debug(D_CGROUP, "Enabling duplicate of cgroup '%s' with id '%s', because the original with id '%s' stopped.", t->chart_id, t->id, cg->id);
2482 t->enabled = 1;
2483 t->options &= ~CGROUP_OPTIONS_DISABLED_DUPLICATE;
@@ -2553,8 +2529,8 @@ static inline void discovery_share_cgroups_with_ebpf() {
2529
2530 for (cg = cgroup_root, count = 0; cg; cg = cg->next, count++) {
2531 netdata_ebpf_cgroup_shm_body_t *ptr = &shm_cgroup_ebpf.body[count];
2556 - char *prefix = (is_cgroup_systemd_service(cg)) ? "" : "cgroup_";
2557 - snprintfz(ptr->name, CGROUP_EBPF_NAME_SHARED_LENGTH - 1, "%s%s", prefix, cg->chart_title);
2532 + char *prefix = (is_cgroup_systemd_service(cg)) ? services_chart_id_prefix : cgroup_chart_id_prefix;
2533 + snprintfz(ptr->name, CGROUP_EBPF_NAME_SHARED_LENGTH - 1, "%s%s", prefix, cg->chart_id);
2534 ptr->hash = simple_hash(ptr->name);
2535 ptr->options = cg->options;
2536 ptr->enabled = cg->enabled;
@@ -2658,13 +2634,13 @@ static inline void discovery_process_first_time_seen_cgroup(struct cgroup *cg) {
2634 }
2635
2636 if (cgroup_enable_systemd_services && matches_systemd_services_cgroups(cg->id)) {
2661 - netdata_log_debug(D_CGROUP, "cgroup '%s' (name '%s') matches 'cgroups to match as systemd services'", cg->id, cg->chart_title);
2637 + netdata_log_debug(D_CGROUP, "cgroup '%s' (name '%s') matches 'cgroups to match as systemd services'", cg->id, cg->chart_id);
2638 convert_cgroup_to_systemd_service(cg);
2639 return;
2640 }
2641
2642 if (matches_enabled_cgroup_renames(cg->id)) {
2667 - netdata_log_debug(D_CGROUP, "cgroup '%s' (name '%s') matches 'run script to rename cgroups matching', will try to rename it", cg->id, cg->chart_title);
2643 + netdata_log_debug(D_CGROUP, "cgroup '%s' (name '%s') matches 'run script to rename cgroups matching', will try to rename it", cg->id, cg->chart_id);
2644 if (is_inside_k8s && k8s_is_container(cg->id)) {
2645 // it may take up to a minute for the K8s API to return data for the container
2646 // tested on AWS K8s cluster with 100% CPU utilization
@@ -2676,15 +2652,20 @@ static inline void discovery_process_first_time_seen_cgroup(struct cgroup *cg) {
2652 }
2653
2654 static int discovery_is_cgroup_duplicate(struct cgroup *cg) {
2679 - // https://github.com/netdata/netdata/issues/797#issuecomment-241248884
2680 - struct cgroup *c;
2681 - for (c = discovered_cgroup_root; c; c = c->discovered_next) {
2682 - if (c != cg && c->enabled && c->hash_chart == cg->hash_chart && !strcmp(c->chart_id, cg->chart_id)) {
2683 - collector_error("CGROUP: chart id '%s' already exists with id '%s' and is enabled and available. Disabling cgroup with id '%s'.", cg->chart_id, c->id, cg->id);
2684 - return 1;
2685 - }
2686 - }
2687 - return 0;
2655 + // https://github.com/netdata/netdata/issues/797#issuecomment-241248884
2656 + struct cgroup *c;
2657 + for (c = discovered_cgroup_root; c; c = c->discovered_next) {
2658 + if (c != cg && c->enabled && (is_cgroup_systemd_service(c) == is_cgroup_systemd_service(cg)) &&
2659 + c->hash_chart_id == cg->hash_chart_id && !strcmp(c->chart_id, cg->chart_id)) {
2660 + collector_error(
2661 + "CGROUP: chart id '%s' already exists with id '%s' and is enabled and available. Disabling cgroup with id '%s'.",
2662 + cg->chart_id,
2663 + c->id,
2664 + cg->id);
2665 + return 1;
2666 + }
2667 + }
2668 + return 0;
2669 }
2670
2671 static inline void discovery_process_cgroup(struct cgroup *cg) {
@@ -2720,17 +2701,25 @@ static inline void discovery_process_cgroup(struct cgroup *cg) {
2701 }
2702
2703 if (is_cgroup_systemd_service(cg)) {
2704 + if (discovery_is_cgroup_duplicate(cg)) {
2705 + cg->enabled = 0;
2706 + cg->options |= CGROUP_OPTIONS_DISABLED_DUPLICATE;
2707 + return;
2708 + }
2709 + if (!cg->chart_labels)
2710 + cg->chart_labels = rrdlabels_create();
2711 + rrdlabels_add(cg->chart_labels, "service_name", cg->name, RRDLABEL_SRC_AUTO);
2712 cg->enabled = 1;
2713 return;
2714 }
2715
2727 - if (!(cg->enabled = matches_enabled_cgroup_names(cg->chart_title))) {
2728 - netdata_log_debug(D_CGROUP, "cgroup '%s' (name '%s') disabled by 'enable by default cgroups names matching'", cg->id, cg->chart_title);
2716 + if (!(cg->enabled = matches_enabled_cgroup_names(cg->name))) {
2717 + netdata_log_debug(D_CGROUP, "cgroup '%s' (name '%s') disabled by 'enable by default cgroups names matching'", cg->id, cg->name);
2718 return;
2719 }
2720
2721 if (!(cg->enabled = matches_enabled_cgroup_paths(cg->id))) {
2733 - netdata_log_debug(D_CGROUP, "cgroup '%s' (name '%s') disabled by 'enable by default cgroups matching'", cg->id, cg->chart_title);
2722 + netdata_log_debug(D_CGROUP, "cgroup '%s' (name '%s') disabled by 'enable by default cgroups matching'", cg->id, cg->name);
2723 return;
2724 }
2725
@@ -2744,7 +2733,7 @@ static inline void discovery_process_cgroup(struct cgroup *cg) {
2733 cg->chart_labels = rrdlabels_create();
2734
2735 if (!k8s_is_kubepod(cg)) {
2747 - rrdlabels_add(cg->chart_labels, "cgroup_name", cg->chart_id, RRDLABEL_SRC_AUTO);
2736 + rrdlabels_add(cg->chart_labels, "cgroup_name", cg->name, RRDLABEL_SRC_AUTO);
2737 if (!rrdlabels_exist(cg->chart_labels, "image"))
2738 rrdlabels_add(cg->chart_labels, "image", "", RRDLABEL_SRC_AUTO);
2739 }
@@ -2800,6 +2789,19 @@ static void cgroup_discovery_cleanup(void *ptr) {
2789 service_exits();
2790 }
2791
2792 +static inline char *cgroup_chart_type(char *buffer, struct cgroup *cg) {
2793 + if(buffer[0]) return buffer;
2794 +
2795 + if (cg->chart_id[0] == '\0' || (cg->chart_id[0] == '/' && cg->chart_id[1] == '\0'))
2796 + strncpy(buffer, "cgroup_root", RRD_ID_LENGTH_MAX);
2797 + else if (is_cgroup_systemd_service(cg))
2798 + snprintfz(buffer, RRD_ID_LENGTH_MAX, "%s%s", services_chart_id_prefix, cg->chart_id);
2799 + else
2800 + snprintfz(buffer, RRD_ID_LENGTH_MAX, "%s%s", cgroup_chart_id_prefix, cg->chart_id);
2801 +
2802 + return buffer;
2803 +}
2804 +
2805 void cgroup_discovery_worker(void *ptr)
2806 {
2807 UNUSED(ptr);
@@ -2849,709 +2851,380 @@ void cgroup_discovery_worker(void *ptr)
2851 #define CHART_TITLE_MAX 300
2852
2853 void update_systemd_services_charts(
2852 - int update_every
2853 - , int do_cpu
2854 - , int do_mem_usage
2855 - , int do_mem_detailed
2856 - , int do_mem_failcnt
2857 - , int do_swap_usage
2858 - , int do_io
2859 - , int do_io_ops
2860 - , int do_throttle_io
2861 - , int do_throttle_ops
2862 - , int do_queued_ops
2863 - , int do_merged_ops
2864 -) {
2865 - static RRDSET
2866 - *st_cpu = NULL,
2867 - *st_mem_usage = NULL,
2868 - *st_mem_failcnt = NULL,
2869 - *st_swap_usage = NULL,
2870 -
2871 - *st_mem_detailed_cache = NULL,
2872 - *st_mem_detailed_rss = NULL,
2873 - *st_mem_detailed_mapped = NULL,
2874 - *st_mem_detailed_writeback = NULL,
2875 - *st_mem_detailed_pgfault = NULL,
2876 - *st_mem_detailed_pgmajfault = NULL,
2877 - *st_mem_detailed_pgpgin = NULL,
2878 - *st_mem_detailed_pgpgout = NULL,
2879 -
2880 - *st_io_read = NULL,
2881 - *st_io_serviced_read = NULL,
2882 - *st_throttle_io_read = NULL,
2883 - *st_throttle_ops_read = NULL,
2884 - *st_queued_ops_read = NULL,
2885 - *st_merged_ops_read = NULL,
2886 -
2887 - *st_io_write = NULL,
2888 - *st_io_serviced_write = NULL,
2889 - *st_throttle_io_write = NULL,
2890 - *st_throttle_ops_write = NULL,
2891 - *st_queued_ops_write = NULL,
2892 - *st_merged_ops_write = NULL;
2893 -
2894 - // create the charts
2895 -
2896 - if (unlikely(do_cpu && !st_cpu)) {
2897 - char title[CHART_TITLE_MAX + 1];
2898 - snprintfz(title, CHART_TITLE_MAX, "Systemd Services CPU utilization (100%% = 1 core)");
2899 -
2900 - st_cpu = rrdset_create_localhost(
2901 - "services"
2902 - , "cpu"
2903 - , NULL
2904 - , "cpu"
2905 - , "services.cpu"
2906 - , title
2907 - , "percentage"
2908 - , PLUGIN_CGROUPS_NAME
2909 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
2910 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD
2911 - , update_every
2912 - , RRDSET_TYPE_STACKED
2913 - );
2914 - }
2915 -
2916 - if (unlikely(do_mem_usage && !st_mem_usage)) {
2917 - st_mem_usage = rrdset_create_localhost(
2918 - "services"
2919 - , "mem_usage"
2920 - , NULL
2921 - , "mem"
2922 - , "services.mem_usage"
2923 - , "Systemd Services Used Memory"
2924 - , "MiB"
2925 - , PLUGIN_CGROUPS_NAME
2926 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
2927 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 10
2928 - , update_every
2929 - , RRDSET_TYPE_STACKED
2930 - );
2931 - }
2932 -
2933 - if(likely(do_mem_detailed)) {
2934 - if(unlikely(!st_mem_detailed_rss)) {
2935 - st_mem_detailed_rss = rrdset_create_localhost(
2936 - "services"
2937 - , "mem_rss"
2938 - , NULL
2939 - , "mem"
2940 - , "services.mem_rss"
2941 - , "Systemd Services RSS Memory"
2942 - , "MiB"
2943 - , PLUGIN_CGROUPS_NAME
2944 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
2945 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 20
2946 - , update_every
2947 - , RRDSET_TYPE_STACKED
2948 - );
2949 - }
2950 -
2951 - if(unlikely(!st_mem_detailed_mapped)) {
2952 - st_mem_detailed_mapped = rrdset_create_localhost(
2953 - "services"
2954 - , "mem_mapped"
2955 - , NULL
2956 - , "mem"
2957 - , "services.mem_mapped"
2958 - , "Systemd Services Mapped Memory"
2959 - , "MiB"
2960 - , PLUGIN_CGROUPS_NAME
2961 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
2962 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 30
2963 - , update_every
2964 - , RRDSET_TYPE_STACKED
2965 - );
2966 - }
2967 -
2968 - if(unlikely(!st_mem_detailed_cache)) {
2969 - st_mem_detailed_cache = rrdset_create_localhost(
2970 - "services"
2971 - , "mem_cache"
2972 - , NULL
2973 - , "mem"
2974 - , "services.mem_cache"
2975 - , "Systemd Services Cache Memory"
2976 - , "MiB"
2977 - , PLUGIN_CGROUPS_NAME
2978 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
2979 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 40
2980 - , update_every
2981 - , RRDSET_TYPE_STACKED
2982 - );
2983 - }
2984 -
2985 - if(unlikely(!st_mem_detailed_writeback)) {
2986 - st_mem_detailed_writeback = rrdset_create_localhost(
2987 - "services"
2988 - , "mem_writeback"
2989 - , NULL
2990 - , "mem"
2991 - , "services.mem_writeback"
2992 - , "Systemd Services Writeback Memory"
2993 - , "MiB"
2994 - , PLUGIN_CGROUPS_NAME
2995 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
2996 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 50
2997 - , update_every
2998 - , RRDSET_TYPE_STACKED
2999 - );
3000 -
3001 - }
3002 -
3003 - if(unlikely(!st_mem_detailed_pgfault)) {
3004 - st_mem_detailed_pgfault = rrdset_create_localhost(
3005 - "services"
3006 - , "mem_pgfault"
3007 - , NULL
3008 - , "mem"
3009 - , "services.mem_pgfault"
3010 - , "Systemd Services Memory Minor Page Faults"
3011 - , "MiB/s"
3012 - , PLUGIN_CGROUPS_NAME
3013 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
3014 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 60
3015 - , update_every
3016 - , RRDSET_TYPE_STACKED
3017 - );
3018 - }
3019 -
3020 - if(unlikely(!st_mem_detailed_pgmajfault)) {
3021 - st_mem_detailed_pgmajfault = rrdset_create_localhost(
3022 - "services"
3023 - , "mem_pgmajfault"
3024 - , NULL
3025 - , "mem"
3026 - , "services.mem_pgmajfault"
3027 - , "Systemd Services Memory Major Page Faults"
3028 - , "MiB/s"
3029 - , PLUGIN_CGROUPS_NAME
3030 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
3031 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 70
3032 - , update_every
3033 - , RRDSET_TYPE_STACKED
3034 - );
3035 - }
3036 -
3037 - if(unlikely(!st_mem_detailed_pgpgin)) {
3038 - st_mem_detailed_pgpgin = rrdset_create_localhost(
3039 - "services"
3040 - , "mem_pgpgin"
3041 - , NULL
3042 - , "mem"
3043 - , "services.mem_pgpgin"
3044 - , "Systemd Services Memory Charging Activity"
3045 - , "MiB/s"
3046 - , PLUGIN_CGROUPS_NAME
3047 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
3048 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 80
3049 - , update_every
3050 - , RRDSET_TYPE_STACKED
3051 - );
3052 -
3053 - }
3054 -
3055 - if(unlikely(!st_mem_detailed_pgpgout)) {
3056 - st_mem_detailed_pgpgout = rrdset_create_localhost(
3057 - "services"
3058 - , "mem_pgpgout"
3059 - , NULL
3060 - , "mem"
3061 - , "services.mem_pgpgout"
3062 - , "Systemd Services Memory Uncharging Activity"
3063 - , "MiB/s"
3064 - , PLUGIN_CGROUPS_NAME
3065 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
3066 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 90
3067 - , update_every
3068 - , RRDSET_TYPE_STACKED
3069 - );
3070 - }
3071 - }
3072 -
3073 - if(unlikely(do_mem_failcnt && !st_mem_failcnt)) {
3074 - st_mem_failcnt = rrdset_create_localhost(
3075 - "services"
3076 - , "mem_failcnt"
3077 - , NULL
3078 - , "mem"
3079 - , "services.mem_failcnt"
3080 - , "Systemd Services Memory Limit Failures"
3081 - , "failures"
3082 - , PLUGIN_CGROUPS_NAME
3083 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
3084 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 110
3085 - , update_every
3086 - , RRDSET_TYPE_STACKED
3087 - );
3088 - }
3089 -
3090 - if (do_swap_usage && !st_swap_usage) {
3091 - st_swap_usage = rrdset_create_localhost(
3092 - "services"
3093 - , "swap_usage"
3094 - , NULL
3095 - , "swap"
3096 - , "services.swap_usage"
3097 - , "Systemd Services Swap Memory Used"
3098 - , "MiB"
3099 - , PLUGIN_CGROUPS_NAME
3100 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
3101 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 100
3102 - , update_every
3103 - , RRDSET_TYPE_STACKED
3104 - );
3105 - }
3106 -
3107 - if(likely(do_io)) {
3108 - if(unlikely(!st_io_read)) {
3109 - st_io_read = rrdset_create_localhost(
3110 - "services"
3111 - , "io_read"
3112 - , NULL
3113 - , "disk"
3114 - , "services.io_read"
3115 - , "Systemd Services Disk Read Bandwidth"
3116 - , "KiB/s"
3117 - , PLUGIN_CGROUPS_NAME
3118 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
3119 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 120
3120 - , update_every
3121 - , RRDSET_TYPE_STACKED
3122 - );
3123 - }
3124 -
3125 - if(unlikely(!st_io_write)) {
3126 - st_io_write = rrdset_create_localhost(
3127 - "services"
3128 - , "io_write"
3129 - , NULL
3130 - , "disk"
3131 - , "services.io_write"
3132 - , "Systemd Services Disk Write Bandwidth"
3133 - , "KiB/s"
3134 - , PLUGIN_CGROUPS_NAME
3135 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
3136 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 130
3137 - , update_every
3138 - , RRDSET_TYPE_STACKED
3139 - );
3140 - }
3141 - }
3142 -
3143 - if(likely(do_io_ops)) {
3144 - if(unlikely(!st_io_serviced_read)) {
3145 - st_io_serviced_read = rrdset_create_localhost(
3146 - "services"
3147 - , "io_ops_read"
3148 - , NULL
3149 - , "disk"
3150 - , "services.io_ops_read"
3151 - , "Systemd Services Disk Read Operations"
3152 - , "operations/s"
3153 - , PLUGIN_CGROUPS_NAME
3154 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
3155 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 140
3156 - , update_every
3157 - , RRDSET_TYPE_STACKED
3158 - );
3159 - }
3160 -
3161 - if(unlikely(!st_io_serviced_write)) {
3162 - st_io_serviced_write = rrdset_create_localhost(
3163 - "services"
3164 - , "io_ops_write"
3165 - , NULL
3166 - , "disk"
3167 - , "services.io_ops_write"
3168 - , "Systemd Services Disk Write Operations"
3169 - , "operations/s"
3170 - , PLUGIN_CGROUPS_NAME
3171 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
3172 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 150
3173 - , update_every
3174 - , RRDSET_TYPE_STACKED
3175 - );
3176 - }
3177 - }
3178 -
3179 - if(likely(do_throttle_io)) {
3180 - if(unlikely(!st_throttle_io_read)) {
3181 -
3182 - st_throttle_io_read = rrdset_create_localhost(
3183 - "services"
3184 - , "throttle_io_read"
3185 - , NULL
3186 - , "disk"
3187 - , "services.throttle_io_read"
3188 - , "Systemd Services Throttle Disk Read Bandwidth"
3189 - , "KiB/s"
3190 - , PLUGIN_CGROUPS_NAME
3191 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
3192 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 160
3193 - , update_every
3194 - , RRDSET_TYPE_STACKED
3195 - );
3196 -
3197 - }
3198 -
3199 - if(unlikely(!st_throttle_io_write)) {
3200 - st_throttle_io_write = rrdset_create_localhost(
3201 - "services"
3202 - , "throttle_io_write"
3203 - , NULL
3204 - , "disk"
3205 - , "services.throttle_io_write"
3206 - , "Systemd Services Throttle Disk Write Bandwidth"
3207 - , "KiB/s"
3208 - , PLUGIN_CGROUPS_NAME
3209 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
3210 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 170
3211 - , update_every
3212 - , RRDSET_TYPE_STACKED
3213 - );
3214 - }
3215 - }
3216 -
3217 - if(likely(do_throttle_ops)) {
3218 - if(unlikely(!st_throttle_ops_read)) {
3219 - st_throttle_ops_read = rrdset_create_localhost(
3220 - "services"
3221 - , "throttle_io_ops_read"
3222 - , NULL
3223 - , "disk"
3224 - , "services.throttle_io_ops_read"
3225 - , "Systemd Services Throttle Disk Read Operations"
3226 - , "operations/s"
3227 - , PLUGIN_CGROUPS_NAME
3228 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
3229 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 180
3230 - , update_every
3231 - , RRDSET_TYPE_STACKED
3232 - );
3233 - }
3234 -
3235 - if(unlikely(!st_throttle_ops_write)) {
3236 - st_throttle_ops_write = rrdset_create_localhost(
3237 - "services"
3238 - , "throttle_io_ops_write"
3239 - , NULL
3240 - , "disk"
3241 - , "services.throttle_io_ops_write"
3242 - , "Systemd Services Throttle Disk Write Operations"
3243 - , "operations/s"
3244 - , PLUGIN_CGROUPS_NAME
3245 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
3246 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 190
3247 - , update_every
3248 - , RRDSET_TYPE_STACKED
3249 - );
3250 - }
3251 - }
3252 -
3253 - if(likely(do_queued_ops)) {
3254 - if(unlikely(!st_queued_ops_read)) {
3255 - st_queued_ops_read = rrdset_create_localhost(
3256 - "services"
3257 - , "queued_io_ops_read"
3258 - , NULL
3259 - , "disk"
3260 - , "services.queued_io_ops_read"
3261 - , "Systemd Services Queued Disk Read Operations"
3262 - , "operations/s"
3263 - , PLUGIN_CGROUPS_NAME
3264 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
3265 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 200
3266 - , update_every
3267 - , RRDSET_TYPE_STACKED
3268 - );
3269 - }
3270 -
3271 - if(unlikely(!st_queued_ops_write)) {
3272 -
3273 - st_queued_ops_write = rrdset_create_localhost(
3274 - "services"
3275 - , "queued_io_ops_write"
3276 - , NULL
3277 - , "disk"
3278 - , "services.queued_io_ops_write"
3279 - , "Systemd Services Queued Disk Write Operations"
3280 - , "operations/s"
3281 - , PLUGIN_CGROUPS_NAME
3282 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
3283 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 210
3284 - , update_every
3285 - , RRDSET_TYPE_STACKED
3286 - );
3287 - }
3288 - }
3289 -
3290 - if(likely(do_merged_ops)) {
3291 - if(unlikely(!st_merged_ops_read)) {
3292 - st_merged_ops_read = rrdset_create_localhost(
3293 - "services"
3294 - , "merged_io_ops_read"
3295 - , NULL
3296 - , "disk"
3297 - , "services.merged_io_ops_read"
3298 - , "Systemd Services Merged Disk Read Operations"
3299 - , "operations/s"
3300 - , PLUGIN_CGROUPS_NAME
3301 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
3302 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 220
3303 - , update_every
3304 - , RRDSET_TYPE_STACKED
3305 - );
3306 - }
3307 -
3308 - if(unlikely(!st_merged_ops_write)) {
3309 - st_merged_ops_write = rrdset_create_localhost(
3310 - "services"
3311 - , "merged_io_ops_write"
3312 - , NULL
3313 - , "disk"
3314 - , "services.merged_io_ops_write"
3315 - , "Systemd Services Merged Disk Write Operations"
3316 - , "operations/s"
3317 - , PLUGIN_CGROUPS_NAME
3318 - , PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME
3319 - , NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 230
3320 - , update_every
3321 - , RRDSET_TYPE_STACKED
3322 - );
3323 - }
3324 - }
3325 -
2854 + int update_every,
2855 + int do_cpu,
2856 + int do_mem_usage,
2857 + int do_mem_detailed,
2858 + int do_mem_failcnt,
2859 + int do_swap_usage,
2860 + int do_io,
2861 + int do_io_ops,
2862 + int do_throttle_io,
2863 + int do_throttle_ops,
2864 + int do_queued_ops,
2865 + int do_merged_ops)
2866 +{
2867 // update the values
2868 struct cgroup *cg;
3328 - for(cg = cgroup_root; cg ; cg = cg->next) {
3329 - if(unlikely(!cg->enabled || cg->pending_renames || !is_cgroup_systemd_service(cg)))
3330 - continue;
2869 + int systemd_cgroup_chart_priority = NETDATA_CHART_PRIO_CGROUPS_SYSTEMD;
2870 + char type[RRD_ID_LENGTH_MAX + 1];
2871
3332 - if(likely(do_cpu && cg->cpuacct_stat.updated)) {
3333 - if(unlikely(!cg->rd_cpu)){
2872 + for (cg = cgroup_root; cg; cg = cg->next) {
2873 + if (unlikely(!cg->enabled || cg->pending_renames || !is_cgroup_systemd_service(cg)))
2874 + continue;
2875
2876 + type[0] = '\0';
2877 + if (likely(do_cpu && cg->cpuacct_stat.updated)) {
2878 + if (unlikely(!cg->st_cpu)) {
2879 + cg->st_cpu = rrdset_create_localhost(
2880 + cgroup_chart_type(type, cg),
2881 + "cpu_utilization",
2882 + NULL,
2883 + "cpu",
2884 + "systemd.service.cpu.utilization",
2885 + "Systemd Services CPU utilization (100%% = 1 core)",
2886 + "percentage",
2887 + PLUGIN_CGROUPS_NAME,
2888 + PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME,
2889 + systemd_cgroup_chart_priority,
2890 + update_every,
2891 + RRDSET_TYPE_STACKED);
2892
2893 + rrdset_update_rrdlabels(cg->st_cpu, cg->chart_labels);
2894 if (!(cg->options & CGROUP_OPTIONS_IS_UNIFIED)) {
3337 - cg->rd_cpu = rrddim_add(st_cpu, cg->chart_id, cg->chart_title, 100, system_hz, RRD_ALGORITHM_INCREMENTAL);
2895 + rrddim_add(cg->st_cpu, "user", NULL, 100, system_hz, RRD_ALGORITHM_INCREMENTAL);
2896 + rrddim_add(cg->st_cpu, "system", NULL, 100, system_hz, RRD_ALGORITHM_INCREMENTAL);
2897 } else {
3339 - cg->rd_cpu = rrddim_add(st_cpu, cg->chart_id, cg->chart_title, 100, 1000000, RRD_ALGORITHM_INCREMENTAL);
2898 + rrddim_add(cg->st_cpu, "user", NULL, 100, 1000000, RRD_ALGORITHM_INCREMENTAL);
2899 + rrddim_add(cg->st_cpu, "system", NULL, 100, 1000000, RRD_ALGORITHM_INCREMENTAL);
2900 }
2901 }
2902
3343 - rrddim_set_by_pointer(st_cpu, cg->rd_cpu, cg->cpuacct_stat.user + cg->cpuacct_stat.system);
3344 - }
3345 -
3346 - if(likely(do_mem_usage && cg->memory.updated_usage_in_bytes)) {
3347 - if(unlikely(!cg->rd_mem_usage))
3348 - cg->rd_mem_usage = rrddim_add(st_mem_usage, cg->chart_id, cg->chart_title, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
3349 -
3350 - rrddim_set_by_pointer(st_mem_usage, cg->rd_mem_usage, cg->memory.usage_in_bytes);
2903 + // complete the iteration
2904 + rrddim_set(cg->st_cpu, "user", cg->cpuacct_stat.user);
2905 + rrddim_set(cg->st_cpu, "system", cg->cpuacct_stat.system);
2906 + rrdset_done(cg->st_cpu);
2907 }
2908
3353 - if(likely(do_mem_detailed && cg->memory.updated_detailed)) {
3354 - if(unlikely(!cg->rd_mem_detailed_rss))
3355 - cg->rd_mem_detailed_rss = rrddim_add(st_mem_detailed_rss, cg->chart_id, cg->chart_title, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
3356 -
3357 - rrddim_set_by_pointer(st_mem_detailed_rss, cg->rd_mem_detailed_rss, cg->memory.total_rss);
2909 + if (unlikely(do_mem_usage && cg->memory.updated_usage_in_bytes)) {
2910 + if (unlikely(!cg->st_mem_usage)) {
2911 + cg->st_mem_usage = rrdset_create_localhost(
2912 + cgroup_chart_type(type, cg),
2913 + "mem_usage",
2914 + NULL,
2915 + "mem",
2916 + "systemd.service.memory.usage",
2917 + "Systemd Services Used Memory",
2918 + "MiB",
2919 + PLUGIN_CGROUPS_NAME,
2920 + PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME,
2921 + systemd_cgroup_chart_priority + 5,
2922 + update_every,
2923 + RRDSET_TYPE_STACKED);
2924
3359 - if(unlikely(!cg->rd_mem_detailed_mapped))
3360 - cg->rd_mem_detailed_mapped = rrddim_add(st_mem_detailed_mapped, cg->chart_id, cg->chart_title, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
2925 + rrdset_update_rrdlabels(cg->st_mem_usage, cg->chart_labels);
2926 + rrddim_add(cg->st_mem_usage, "ram", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
2927 + if (likely(do_swap_usage))
2928 + rrddim_add(cg->st_mem_usage, "swap", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
2929 + }
2930
3362 - rrddim_set_by_pointer(st_mem_detailed_mapped, cg->rd_mem_detailed_mapped, cg->memory.total_mapped_file);
2931 + rrddim_set(cg->st_mem_usage, "ram", cg->memory.usage_in_bytes);
2932 + if (likely(do_swap_usage)) {
2933 + if (!(cg->options & CGROUP_OPTIONS_IS_UNIFIED)) {
2934 + rrddim_set(
2935 + cg->st_mem_usage,
2936 + "swap",
2937 + cg->memory.msw_usage_in_bytes > (cg->memory.usage_in_bytes + cg->memory.total_inactive_file) ?
2938 + cg->memory.msw_usage_in_bytes -
2939 + (cg->memory.usage_in_bytes + cg->memory.total_inactive_file) :
2940 + 0);
2941 + } else {
2942 + rrddim_set(cg->st_mem_usage, "swap", cg->memory.msw_usage_in_bytes);
2943 + }
2944 + }
2945 + rrdset_done(cg->st_mem_usage);
2946 + }
2947
3364 - if(unlikely(!cg->rd_mem_detailed_cache))
3365 - cg->rd_mem_detailed_cache = rrddim_add(st_mem_detailed_cache, cg->chart_id, cg->chart_title, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
2948 + if (likely(do_mem_failcnt && cg->memory.updated_failcnt)) {
2949 + if (unlikely(do_mem_failcnt && !cg->st_mem_failcnt)) {
2950 + cg->st_mem_failcnt = rrdset_create_localhost(
2951 + cgroup_chart_type(type, cg),
2952 + "mem_failcnt",
2953 + NULL,
2954 + "mem",
2955 + "systemd.service.memory.failcnt",
2956 + "Systemd Services Memory Limit Failures",
2957 + "failures/s",
2958 + PLUGIN_CGROUPS_NAME,
2959 + PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME,
2960 + systemd_cgroup_chart_priority + 10,
2961 + update_every,
2962 + RRDSET_TYPE_LINE);
2963
3367 - rrddim_set_by_pointer(st_mem_detailed_cache, cg->rd_mem_detailed_cache, cg->memory.total_cache);
2964 + rrdset_update_rrdlabels(cg->st_mem_failcnt, cg->chart_labels);
2965 + rrddim_add(cg->st_mem_failcnt, "fail", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2966 + }
2967
3369 - if(unlikely(!cg->rd_mem_detailed_writeback))
3370 - cg->rd_mem_detailed_writeback = rrddim_add(st_mem_detailed_writeback, cg->chart_id, cg->chart_title, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
2968 + rrddim_set(cg->st_mem_failcnt, "fail", cg->memory.failcnt);
2969 + rrdset_done(cg->st_mem_failcnt);
2970 + }
2971
3372 - rrddim_set_by_pointer(st_mem_detailed_writeback, cg->rd_mem_detailed_writeback, cg->memory.total_writeback);
2972 + if (likely(do_mem_detailed && cg->memory.updated_detailed)) {
2973 + if (unlikely(!cg->st_mem)) {
2974 + cg->st_mem = rrdset_create_localhost(
2975 + cgroup_chart_type(type, cg),
2976 + "mem_ram_usage",
2977 + NULL,
2978 + "mem",
2979 + "systemd.service.memory.ram.usage",
2980 + "Systemd Services Memory",
2981 + "MiB",
2982 + PLUGIN_CGROUPS_NAME,
2983 + PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME,
2984 + systemd_cgroup_chart_priority + 15,
2985 + update_every,
2986 + RRDSET_TYPE_STACKED);
2987
3374 - if(unlikely(!cg->rd_mem_detailed_pgfault))
3375 - cg->rd_mem_detailed_pgfault = rrddim_add(st_mem_detailed_pgfault, cg->chart_id, cg->chart_title, system_page_size, 1024 * 1024, RRD_ALGORITHM_INCREMENTAL);
2988 + rrdset_update_rrdlabels(cg->st_mem, cg->chart_labels);
2989 + rrddim_add(cg->st_mem, "rss", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
2990 + rrddim_add(cg->st_mem, "cache", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
2991 + rrddim_add(cg->st_mem, "mapped_file", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
2992 + rrddim_add(cg->st_mem, "rss_huge", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
2993 + }
2994
3377 - rrddim_set_by_pointer(st_mem_detailed_pgfault, cg->rd_mem_detailed_pgfault, cg->memory.total_pgfault);
2995 + rrddim_set(cg->st_mem, "rss", cg->memory.total_rss);
2996 + rrddim_set(cg->st_mem, "cache", cg->memory.total_cache);
2997 + rrddim_set(cg->st_mem, "mapped_file", cg->memory.total_mapped_file);
2998 + rrddim_set(cg->st_mem, "rss_huge", cg->memory.total_rss_huge);
2999 + rrdset_done(cg->st_mem);
3000
3379 - if(unlikely(!cg->rd_mem_detailed_pgmajfault))
3380 - cg->rd_mem_detailed_pgmajfault = rrddim_add(st_mem_detailed_pgmajfault, cg->chart_id, cg->chart_title, system_page_size, 1024 * 1024, RRD_ALGORITHM_INCREMENTAL);
3001 + if (unlikely(!cg->st_writeback)) {
3002 + cg->st_writeback = rrdset_create_localhost(
3003 + cgroup_chart_type(type, cg),
3004 + "mem_writeback",
3005 + NULL,
3006 + "mem",
3007 + "systemd.service.memory.writeback",
3008 + "Systemd Services Writeback Memory",
3009 + "MiB",
3010 + PLUGIN_CGROUPS_NAME,
3011 + PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME,
3012 + systemd_cgroup_chart_priority + 20,
3013 + update_every,
3014 + RRDSET_TYPE_STACKED);
3015
3382 - rrddim_set_by_pointer(st_mem_detailed_pgmajfault, cg->rd_mem_detailed_pgmajfault, cg->memory.total_pgmajfault);
3016 + rrdset_update_rrdlabels(cg->st_writeback, cg->chart_labels);
3017 + rrddim_add(cg->st_writeback, "writeback", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
3018 + rrddim_add(cg->st_writeback, "dirty", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
3019 + }
3020
3384 - if(unlikely(!cg->rd_mem_detailed_pgpgin))
3385 - cg->rd_mem_detailed_pgpgin = rrddim_add(st_mem_detailed_pgpgin, cg->chart_id, cg->chart_title, system_page_size, 1024 * 1024, RRD_ALGORITHM_INCREMENTAL);
3021 + rrddim_set(cg->st_writeback, "writeback", cg->memory.total_writeback);
3022 + rrddim_set(cg->st_writeback, "dirty", cg->memory.total_dirty);
3023 + rrdset_done(cg->st_writeback);
3024
3387 - rrddim_set_by_pointer(st_mem_detailed_pgpgin, cg->rd_mem_detailed_pgpgin, cg->memory.total_pgpgin);
3025 + if (unlikely(!cg->st_pgfaults)) {
3026 + cg->st_pgfaults = rrdset_create_localhost(
3027 + cgroup_chart_type(type, cg),
3028 + "mem_pgfault",
3029 + NULL,
3030 + "mem",
3031 + "systemd.service.memory.paging.faults",
3032 + "Systemd Services Memory Minor and Major Page Faults",
3033 + "MiB/s",
3034 + PLUGIN_CGROUPS_NAME,
3035 + PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME,
3036 + systemd_cgroup_chart_priority + 25,
3037 + update_every,
3038 + RRDSET_TYPE_AREA);
3039
3389 - if(unlikely(!cg->rd_mem_detailed_pgpgout))
3390 - cg->rd_mem_detailed_pgpgout = rrddim_add(st_mem_detailed_pgpgout, cg->chart_id, cg->chart_title, system_page_size, 1024 * 1024, RRD_ALGORITHM_INCREMENTAL);
3040 + rrdset_update_rrdlabels(cg->st_pgfaults, cg->chart_labels);
3041 + rrddim_add(cg->st_pgfaults, "minor", NULL, system_page_size, 1024 * 1024, RRD_ALGORITHM_INCREMENTAL);
3042 + rrddim_add(cg->st_pgfaults, "major", NULL, system_page_size, 1024 * 1024, RRD_ALGORITHM_INCREMENTAL);
3043 + }
3044
3392 - rrddim_set_by_pointer(st_mem_detailed_pgpgout, cg->rd_mem_detailed_pgpgout, cg->memory.total_pgpgout);
3393 - }
3045 + rrddim_set(cg->st_pgfaults, "minor", cg->memory.total_pgfault);
3046 + rrddim_set(cg->st_pgfaults, "major", cg->memory.total_pgmajfault);
3047 + rrdset_done(cg->st_pgfaults);
3048
3395 - if(likely(do_mem_failcnt && cg->memory.updated_failcnt)) {
3396 - if(unlikely(!cg->rd_mem_failcnt))
3397 - cg->rd_mem_failcnt = rrddim_add(st_mem_failcnt, cg->chart_id, cg->chart_title, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3049 + if (unlikely(!cg->st_mem_activity)) {
3050 + cg->st_mem_activity = rrdset_create_localhost(
3051 + cgroup_chart_type(type, cg),
3052 + "mem_paging_io",
3053 + NULL,
3054 + "mem",
3055 + "systemd.service.memory.paging.io",
3056 + "Systemd Services Memory Paging IO",
3057 + "MiB/s",
3058 + PLUGIN_CGROUPS_NAME,
3059 + PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME,
3060 + systemd_cgroup_chart_priority + 30,
3061 + update_every,
3062 + RRDSET_TYPE_AREA);
3063 +
3064 + rrdset_update_rrdlabels(cg->st_mem_activity, cg->chart_labels);
3065 + rrddim_add(cg->st_mem_activity, "in", NULL, system_page_size, 1024 * 1024, RRD_ALGORITHM_INCREMENTAL);
3066 + rrddim_add(cg->st_mem_activity, "out", NULL, system_page_size, 1024 * 1024, RRD_ALGORITHM_INCREMENTAL);
3067 + }
3068
3399 - rrddim_set_by_pointer(st_mem_failcnt, cg->rd_mem_failcnt, cg->memory.failcnt);
3069 + rrddim_set(cg->st_mem_activity, "in", cg->memory.total_pgpgin);
3070 + rrddim_set(cg->st_mem_activity, "out", cg->memory.total_pgpgout);
3071 + rrdset_done(cg->st_mem_activity);
3072 }
3073
3402 - if(likely(do_swap_usage && cg->memory.updated_msw_usage_in_bytes)) {
3403 - if(unlikely(!cg->rd_swap_usage))
3404 - cg->rd_swap_usage = rrddim_add(st_swap_usage, cg->chart_id, cg->chart_title, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
3074 + if (likely(do_io && cg->io_service_bytes.updated)) {
3075 + if (unlikely(!cg->st_io)) {
3076 + cg->st_io = rrdset_create_localhost(
3077 + cgroup_chart_type(type, cg),
3078 + "disk_io",
3079 + NULL,
3080 + "disk",
3081 + "systemd.service.disk.io",
3082 + "Systemd Services Disk Read/Write Bandwidth",
3083 + "KiB/s",
3084 + PLUGIN_CGROUPS_NAME,
3085 + PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME,
3086 + systemd_cgroup_chart_priority + 35,
3087 + update_every,
3088 + RRDSET_TYPE_AREA);
3089
3406 - if(!(cg->options & CGROUP_OPTIONS_IS_UNIFIED)) {
3407 - rrddim_set_by_pointer(
3408 - st_swap_usage,
3409 - cg->rd_swap_usage,
3410 - cg->memory.msw_usage_in_bytes > (cg->memory.usage_in_bytes + cg->memory.total_inactive_file) ?
3411 - cg->memory.msw_usage_in_bytes - (cg->memory.usage_in_bytes + cg->memory.total_inactive_file) : 0);
3412 - } else {
3413 - rrddim_set_by_pointer(st_swap_usage, cg->rd_swap_usage, cg->memory.msw_usage_in_bytes);
3090 + rrdset_update_rrdlabels(cg->st_io, cg->chart_labels);
3091 + rrddim_add(cg->st_io, "write", NULL, 1, 1024, RRD_ALGORITHM_INCREMENTAL);
3092 + rrddim_add(cg->st_io, "read", NULL, 1, 1024, RRD_ALGORITHM_INCREMENTAL);
3093 }
3415 - }
3416 -
3417 - if(likely(do_io && cg->io_service_bytes.updated)) {
3418 - if(unlikely(!cg->rd_io_service_bytes_read))
3419 - cg->rd_io_service_bytes_read = rrddim_add(st_io_read, cg->chart_id, cg->chart_title, 1, 1024, RRD_ALGORITHM_INCREMENTAL);
3420 -
3421 - rrddim_set_by_pointer(st_io_read, cg->rd_io_service_bytes_read, cg->io_service_bytes.Read);
3094
3423 - if(unlikely(!cg->rd_io_service_bytes_write))
3424 - cg->rd_io_service_bytes_write = rrddim_add(st_io_write, cg->chart_id, cg->chart_title, 1, 1024, RRD_ALGORITHM_INCREMENTAL);
3425 -
3426 - rrddim_set_by_pointer(st_io_write, cg->rd_io_service_bytes_write, cg->io_service_bytes.Write);
3095 + rrddim_set(cg->st_io, "write", cg->io_service_bytes.Write);
3096 + rrddim_set(cg->st_io, "read", cg->io_service_bytes.Read);
3097 + rrdset_done(cg->st_io);
3098 }
3099
3429 - if(likely(do_io_ops && cg->io_serviced.updated)) {
3430 - if(unlikely(!cg->rd_io_serviced_read))
3431 - cg->rd_io_serviced_read = rrddim_add(st_io_serviced_read, cg->chart_id, cg->chart_title, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3432 -
3433 - rrddim_set_by_pointer(st_io_serviced_read, cg->rd_io_serviced_read, cg->io_serviced.Read);
3434 -
3435 - if(unlikely(!cg->rd_io_serviced_write))
3436 - cg->rd_io_serviced_write = rrddim_add(st_io_serviced_write, cg->chart_id, cg->chart_title, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3100 + if (likely(do_io_ops && cg->io_serviced.updated)) {
3101 + if (unlikely(!cg->st_serviced_ops)) {
3102 + cg->st_serviced_ops = rrdset_create_localhost(
3103 + cgroup_chart_type(type, cg),
3104 + "disk_iops",
3105 + NULL,
3106 + "disk",
3107 + "systemd.service.disk.iops",
3108 + "Systemd Services Disk Read/Write Operations",
3109 + "operations/s",
3110 + PLUGIN_CGROUPS_NAME,
3111 + PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME,
3112 + systemd_cgroup_chart_priority + 40,
3113 + update_every,
3114 + RRDSET_TYPE_LINE);
3115
3438 - rrddim_set_by_pointer(st_io_serviced_write, cg->rd_io_serviced_write, cg->io_serviced.Write);
3116 + rrdset_update_rrdlabels(cg->st_serviced_ops, cg->chart_labels);
3117 + rrddim_add(cg->st_serviced_ops, "read", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3118 + rrddim_add(cg->st_serviced_ops, "write", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3119 + }
3120 + rrddim_set(cg->st_serviced_ops, "write", cg->io_serviced.Write);
3121 + rrddim_set(cg->st_serviced_ops, "read", cg->io_serviced.Read);
3122 + rrdset_done(cg->st_serviced_ops);
3123 }
3124
3441 - if(likely(do_throttle_io && cg->throttle_io_service_bytes.updated)) {
3442 - if(unlikely(!cg->rd_throttle_io_read))
3443 - cg->rd_throttle_io_read = rrddim_add(st_throttle_io_read, cg->chart_id, cg->chart_title, 1, 1024, RRD_ALGORITHM_INCREMENTAL);
3444 -
3445 - rrddim_set_by_pointer(st_throttle_io_read, cg->rd_throttle_io_read, cg->throttle_io_service_bytes.Read);
3125 + if (likely(do_throttle_io && cg->throttle_io_service_bytes.updated)) {
3126 + if (unlikely(!cg->st_throttle_io)) {
3127 + cg->st_throttle_io = rrdset_create_localhost(
3128 + cgroup_chart_type(type, cg),
3129 + "disk_throttle_io",
3130 + NULL,
3131 + "disk",
3132 + "systemd.service.disk.throttle.io",
3133 + "Systemd Services Throttle Disk Read/Write Bandwidth",
3134 + "KiB/s",
3135 + PLUGIN_CGROUPS_NAME,
3136 + PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME,
3137 + systemd_cgroup_chart_priority + 45,
3138 + update_every,
3139 + RRDSET_TYPE_AREA);
3140
3447 - if(unlikely(!cg->rd_throttle_io_write))
3448 - cg->rd_throttle_io_write = rrddim_add(st_throttle_io_write, cg->chart_id, cg->chart_title, 1, 1024, RRD_ALGORITHM_INCREMENTAL);
3141 + rrdset_update_rrdlabels(cg->st_throttle_io, cg->chart_labels);
3142 + rrddim_add(cg->st_throttle_io, "read", NULL, 1, 1024, RRD_ALGORITHM_INCREMENTAL);
3143 + rrddim_add(cg->st_throttle_io, "write", NULL, 1, 1024, RRD_ALGORITHM_INCREMENTAL);
3144 + }
3145
3450 - rrddim_set_by_pointer(st_throttle_io_write, cg->rd_throttle_io_write, cg->throttle_io_service_bytes.Write);
3146 + rrddim_set(cg->st_throttle_io, "write", cg->throttle_io_service_bytes.Write);
3147 + rrddim_set(cg->st_throttle_io, "read", cg->throttle_io_service_bytes.Read);
3148 + rrdset_done(cg->st_throttle_io);
3149 }
3150
3453 - if(likely(do_throttle_ops && cg->throttle_io_serviced.updated)) {
3454 - if(unlikely(!cg->rd_throttle_io_serviced_read))
3455 - cg->rd_throttle_io_serviced_read = rrddim_add(st_throttle_ops_read, cg->chart_id, cg->chart_title, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3456 -
3457 - rrddim_set_by_pointer(st_throttle_ops_read, cg->rd_throttle_io_serviced_read, cg->throttle_io_serviced.Read);
3151 + if (likely(do_throttle_ops && cg->throttle_io_serviced.updated)) {
3152 + if (unlikely(!cg->st_throttle_serviced_ops)) {
3153 + cg->st_throttle_serviced_ops = rrdset_create_localhost(
3154 + cgroup_chart_type(type, cg),
3155 + "disk_throttle_iops",
3156 + NULL,
3157 + "disk",
3158 + "systemd.service.disk.throttle.iops",
3159 + "Systemd Services Throttle Disk Read/Write Operations",
3160 + "operations/s",
3161 + PLUGIN_CGROUPS_NAME,
3162 + PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME,
3163 + systemd_cgroup_chart_priority + 50,
3164 + update_every,
3165 + RRDSET_TYPE_LINE);
3166
3459 - if(unlikely(!cg->rd_throttle_io_serviced_write))
3460 - cg->rd_throttle_io_serviced_write = rrddim_add(st_throttle_ops_write, cg->chart_id, cg->chart_title, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3167 + rrdset_update_rrdlabels(cg->st_throttle_serviced_ops, cg->chart_labels);
3168 + rrddim_add(cg->st_throttle_serviced_ops, "read", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3169 + rrddim_add(cg->st_throttle_serviced_ops, "write", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3170 + }
3171
3462 - rrddim_set_by_pointer(st_throttle_ops_write, cg->rd_throttle_io_serviced_write, cg->throttle_io_serviced.Write);
3172 + rrddim_set(cg->st_throttle_serviced_ops, "write", cg->throttle_io_serviced.Write);
3173 + rrddim_set(cg->st_throttle_serviced_ops, "read", cg->throttle_io_serviced.Read);
3174 + rrdset_done(cg->st_throttle_serviced_ops);
3175 }
3176
3465 - if(likely(do_queued_ops && cg->io_queued.updated)) {
3466 - if(unlikely(!cg->rd_io_queued_read))
3467 - cg->rd_io_queued_read = rrddim_add(st_queued_ops_read, cg->chart_id, cg->chart_title, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3468 -
3469 - rrddim_set_by_pointer(st_queued_ops_read, cg->rd_io_queued_read, cg->io_queued.Read);
3470 -
3471 - if(unlikely(!cg->rd_io_queued_write))
3472 - cg->rd_io_queued_write = rrddim_add(st_queued_ops_write, cg->chart_id, cg->chart_title, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3177 + if (likely(do_queued_ops && cg->io_queued.updated)) {
3178 + if (unlikely(!cg->st_queued_ops)) {
3179 + cg->st_queued_ops = rrdset_create_localhost(
3180 + cgroup_chart_type(type, cg),
3181 + "disk_queued_iops",
3182 + NULL,
3183 + "disk",
3184 + "systemd.service.disk.queued_iops",
3185 + "Systemd Services Queued Disk Read/Write Operations",
3186 + "operations/s",
3187 + PLUGIN_CGROUPS_NAME,
3188 + PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME,
3189 + systemd_cgroup_chart_priority + 55,
3190 + update_every,
3191 + RRDSET_TYPE_LINE);
3192
3474 - rrddim_set_by_pointer(st_queued_ops_write, cg->rd_io_queued_write, cg->io_queued.Write);
3193 + rrdset_update_rrdlabels(cg->st_queued_ops, cg->chart_labels);
3194 + rrddim_add(cg->st_queued_ops, "read", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3195 + rrddim_add(cg->st_queued_ops, "write", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3196 + }
3197 + rrddim_set(cg->st_queued_ops, "write", cg->io_queued.Write);
3198 + rrddim_set(cg->st_queued_ops, "read", cg->io_queued.Read);
3199 + rrdset_done(cg->st_queued_ops);
3200 }
3201
3477 - if(likely(do_merged_ops && cg->io_merged.updated)) {
3478 - if(unlikely(!cg->rd_io_merged_read))
3479 - cg->rd_io_merged_read = rrddim_add(st_merged_ops_read, cg->chart_id, cg->chart_title, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3480 -
3481 - rrddim_set_by_pointer(st_merged_ops_read, cg->rd_io_merged_read, cg->io_merged.Read);
3202 + if (likely(do_merged_ops && cg->io_merged.updated)) {
3203 + if (unlikely(!cg->st_merged_ops)) {
3204 + cg->st_merged_ops = rrdset_create_localhost(
3205 + cgroup_chart_type(type, cg),
3206 + "disk_merged_iops",
3207 + NULL,
3208 + "disk",
3209 + "systemd.service.disk.merged_iops",
3210 + "Systemd Services Merged Disk Read/Write Operations",
3211 + "operations/s",
3212 + PLUGIN_CGROUPS_NAME,
3213 + PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME,
3214 + systemd_cgroup_chart_priority + 60,
3215 + update_every,
3216 + RRDSET_TYPE_LINE);
3217
3483 - if(unlikely(!cg->rd_io_merged_write))
3484 - cg->rd_io_merged_write = rrddim_add(st_merged_ops_write, cg->chart_id, cg->chart_title, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3218 + rrdset_update_rrdlabels(cg->st_merged_ops, cg->chart_labels);
3219 + rrddim_add(cg->st_merged_ops, "read", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3220 + rrddim_add(cg->st_merged_ops, "write", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3221 + }
3222
3486 - rrddim_set_by_pointer(st_merged_ops_write, cg->rd_io_merged_write, cg->io_merged.Write);
3223 + rrddim_set(cg->st_merged_ops, "write", cg->io_merged.Write);
3224 + rrddim_set(cg->st_merged_ops, "read", cg->io_merged.Read);
3225 + rrdset_done(cg->st_merged_ops);
3226 }
3227 }
3489 -
3490 - // complete the iteration
3491 - if(likely(do_cpu))
3492 - rrdset_done(st_cpu);
3493 -
3494 - if(likely(do_mem_usage))
3495 - rrdset_done(st_mem_usage);
3496 -
3497 - if(unlikely(do_mem_detailed)) {
3498 - rrdset_done(st_mem_detailed_cache);
3499 - rrdset_done(st_mem_detailed_rss);
3500 - rrdset_done(st_mem_detailed_mapped);
3501 - rrdset_done(st_mem_detailed_writeback);
3502 - rrdset_done(st_mem_detailed_pgfault);
3503 - rrdset_done(st_mem_detailed_pgmajfault);
3504 - rrdset_done(st_mem_detailed_pgpgin);
3505 - rrdset_done(st_mem_detailed_pgpgout);
3506 - }
3507 -
3508 - if(likely(do_mem_failcnt))
3509 - rrdset_done(st_mem_failcnt);
3510 -
3511 - if(likely(do_swap_usage))
3512 - rrdset_done(st_swap_usage);
3513 -
3514 - if(likely(do_io)) {
3515 - rrdset_done(st_io_read);
3516 - rrdset_done(st_io_write);
3517 - }
3518 -
3519 - if(likely(do_io_ops)) {
3520 - rrdset_done(st_io_serviced_read);
3521 - rrdset_done(st_io_serviced_write);
3522 - }
3523 -
3524 - if(likely(do_throttle_io)) {
3525 - rrdset_done(st_throttle_io_read);
3526 - rrdset_done(st_throttle_io_write);
3527 - }
3528 -
3529 - if(likely(do_throttle_ops)) {
3530 - rrdset_done(st_throttle_ops_read);
3531 - rrdset_done(st_throttle_ops_write);
3532 - }
3533 -
3534 - if(likely(do_queued_ops)) {
3535 - rrdset_done(st_queued_ops_read);
3536 - rrdset_done(st_queued_ops_write);
3537 - }
3538 -
3539 - if(likely(do_merged_ops)) {
3540 - rrdset_done(st_merged_ops_read);
3541 - rrdset_done(st_merged_ops_write);
3542 - }
3543 -}
3544 -
3545 -static inline char *cgroup_chart_type(char *buffer, const char *id, size_t len) {
3546 - if(buffer[0]) return buffer;
3547 -
3548 - if(id[0] == '\0' || (id[0] == '/' && id[1] == '\0'))
3549 - strncpy(buffer, "cgroup_root", len);
3550 - else
3551 - snprintfz(buffer, len, "%s%s", cgroup_chart_id_prefix, id);
3552 -
3553 - netdata_fix_chart_id(buffer);
3554 - return buffer;
3228 }
3229
3230 static inline void update_cpu_limits(char **filename, unsigned long long *value, struct cgroup *cg) {
@@ -3718,7 +3391,7 @@ void update_cgroup_charts(int update_every) {
3391 k8s_is_kubepod(cg) ? "CPU Usage (100%% = 1000 mCPU)" : "CPU Usage (100%% = 1 core)");
3392
3393 cg->st_cpu = rrdset_create_localhost(
3721 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
3394 + cgroup_chart_type(type, cg)
3395 , "cpu"
3396 , NULL
3397 , "cpu"
@@ -3787,7 +3460,7 @@ void update_cgroup_charts(int update_every) {
3460 snprintfz(title, CHART_TITLE_MAX, "CPU Usage within the limits");
3461
3462 cg->st_cpu_limit = rrdset_create_localhost(
3790 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
3463 + cgroup_chart_type(type, cg)
3464 , "cpu_limit"
3465 , NULL
3466 , "cpu"
@@ -3839,7 +3512,7 @@ void update_cgroup_charts(int update_every) {
3512 snprintfz(title, CHART_TITLE_MAX, "CPU Throttled Runnable Periods");
3513
3514 cg->st_cpu_nr_throttled = rrdset_create_localhost(
3842 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
3515 + cgroup_chart_type(type, cg)
3516 , "throttled"
3517 , NULL
3518 , "cpu"
@@ -3864,7 +3537,7 @@ void update_cgroup_charts(int update_every) {
3537 snprintfz(title, CHART_TITLE_MAX, "CPU Throttled Time Duration");
3538
3539 cg->st_cpu_throttled_time = rrdset_create_localhost(
3867 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
3540 + cgroup_chart_type(type, cg)
3541 , "throttled_duration"
3542 , NULL
3543 , "cpu"
@@ -3891,7 +3564,7 @@ void update_cgroup_charts(int update_every) {
3564 snprintfz(title, CHART_TITLE_MAX, "CPU Time Relative Share");
3565
3566 cg->st_cpu_shares = rrdset_create_localhost(
3894 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
3567 + cgroup_chart_type(type, cg)
3568 , "cpu_shares"
3569 , NULL
3570 , "cpu"
@@ -3925,7 +3598,7 @@ void update_cgroup_charts(int update_every) {
3598 "CPU Usage (100%% = 1 core) Per Core");
3599
3600 cg->st_cpu_per_core = rrdset_create_localhost(
3928 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
3601 + cgroup_chart_type(type, cg)
3602 , "cpu_per_core"
3603 , NULL
3604 , "cpu"
@@ -3959,7 +3632,7 @@ void update_cgroup_charts(int update_every) {
3632 snprintfz(title, CHART_TITLE_MAX, "Memory Usage");
3633
3634 cg->st_mem = rrdset_create_localhost(
3962 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
3635 + cgroup_chart_type(type, cg)
3636 , "mem"
3637 , NULL
3638 , "mem"
@@ -4017,7 +3690,7 @@ void update_cgroup_charts(int update_every) {
3690 snprintfz(title, CHART_TITLE_MAX, "Writeback Memory");
3691
3692 cg->st_writeback = rrdset_create_localhost(
4020 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
3693 + cgroup_chart_type(type, cg)
3694 , "writeback"
3695 , NULL
3696 , "mem"
@@ -4050,7 +3723,7 @@ void update_cgroup_charts(int update_every) {
3723 snprintfz(title, CHART_TITLE_MAX, "Memory Activity");
3724
3725 cg->st_mem_activity = rrdset_create_localhost(
4053 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
3726 + cgroup_chart_type(type, cg)
3727 , "mem_activity"
3728 , NULL
3729 , "mem"
@@ -4079,7 +3752,7 @@ void update_cgroup_charts(int update_every) {
3752 snprintfz(title, CHART_TITLE_MAX, "Memory Page Faults");
3753
3754 cg->st_pgfaults = rrdset_create_localhost(
4082 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
3755 + cgroup_chart_type(type, cg)
3756 , "pgfaults"
3757 , NULL
3758 , "mem"
@@ -4109,7 +3782,7 @@ void update_cgroup_charts(int update_every) {
3782 snprintfz(title, CHART_TITLE_MAX, "Used Memory");
3783
3784 cg->st_mem_usage = rrdset_create_localhost(
4112 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
3785 + cgroup_chart_type(type, cg)
3786 , "mem_usage"
3787 , NULL
3788 , "mem"
@@ -4174,7 +3847,7 @@ void update_cgroup_charts(int update_every) {
3847 snprintfz(title, CHART_TITLE_MAX, "Used RAM within the limits");
3848
3849 cg->st_mem_usage_limit = rrdset_create_localhost(
4177 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
3850 + cgroup_chart_type(type, cg)
3851 , "mem_usage_limit"
3852 , NULL
3853 , "mem"
@@ -4204,7 +3877,7 @@ void update_cgroup_charts(int update_every) {
3877 snprintfz(title, CHART_TITLE_MAX, "Memory Utilization");
3878
3879 cg->st_mem_utilization = rrdset_create_localhost(
4207 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
3880 + cgroup_chart_type(type, cg)
3881 , "mem_utilization"
3882 , NULL
3883 , "mem"
@@ -4252,7 +3925,7 @@ void update_cgroup_charts(int update_every) {
3925 snprintfz(title, CHART_TITLE_MAX, "Memory Limit Failures");
3926
3927 cg->st_mem_failcnt = rrdset_create_localhost(
4255 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
3928 + cgroup_chart_type(type, cg)
3929 , "mem_failcnt"
3930 , NULL
3931 , "mem"
@@ -4280,7 +3953,7 @@ void update_cgroup_charts(int update_every) {
3953 snprintfz(title, CHART_TITLE_MAX, "I/O Bandwidth (all disks)");
3954
3955 cg->st_io = rrdset_create_localhost(
4283 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
3956 + cgroup_chart_type(type, cg)
3957 , "io"
3958 , NULL
3959 , "disk"
@@ -4310,7 +3983,7 @@ void update_cgroup_charts(int update_every) {
3983 snprintfz(title, CHART_TITLE_MAX, "Serviced I/O Operations (all disks)");
3984
3985 cg->st_serviced_ops = rrdset_create_localhost(
4313 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
3986 + cgroup_chart_type(type, cg)
3987 , "serviced_ops"
3988 , NULL
3989 , "disk"
@@ -4340,7 +4013,7 @@ void update_cgroup_charts(int update_every) {
4013 snprintfz(title, CHART_TITLE_MAX, "Throttle I/O Bandwidth (all disks)");
4014
4015 cg->st_throttle_io = rrdset_create_localhost(
4343 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4016 + cgroup_chart_type(type, cg)
4017 , "throttle_io"
4018 , NULL
4019 , "disk"
@@ -4370,7 +4043,7 @@ void update_cgroup_charts(int update_every) {
4043 snprintfz(title, CHART_TITLE_MAX, "Throttle Serviced I/O Operations (all disks)");
4044
4045 cg->st_throttle_serviced_ops = rrdset_create_localhost(
4373 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4046 + cgroup_chart_type(type, cg)
4047 , "throttle_serviced_ops"
4048 , NULL
4049 , "disk"
@@ -4400,7 +4073,7 @@ void update_cgroup_charts(int update_every) {
4073 snprintfz(title, CHART_TITLE_MAX, "Queued I/O Operations (all disks)");
4074
4075 cg->st_queued_ops = rrdset_create_localhost(
4403 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4076 + cgroup_chart_type(type, cg)
4077 , "queued_ops"
4078 , NULL
4079 , "disk"
@@ -4430,7 +4103,7 @@ void update_cgroup_charts(int update_every) {
4103 snprintfz(title, CHART_TITLE_MAX, "Merged I/O Operations (all disks)");
4104
4105 cg->st_merged_ops = rrdset_create_localhost(
4433 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4106 + cgroup_chart_type(type, cg)
4107 , "merged_ops"
4108 , NULL
4109 , "disk"
@@ -4466,7 +4139,7 @@ void update_cgroup_charts(int update_every) {
4139 RRDSET *chart;
4140 snprintfz(title, CHART_TITLE_MAX, "CPU some pressure");
4141 chart = pcs->share_time.st = rrdset_create_localhost(
4469 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4142 + cgroup_chart_type(type, cg)
4143 , "cpu_some_pressure"
4144 , NULL
4145 , "cpu"
@@ -4489,7 +4162,7 @@ void update_cgroup_charts(int update_every) {
4162 RRDSET *chart;
4163 snprintfz(title, CHART_TITLE_MAX, "CPU some pressure stall time");
4164 chart = pcs->total_time.st = rrdset_create_localhost(
4492 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4165 + cgroup_chart_type(type, cg)
4166 , "cpu_some_pressure_stall_time"
4167 , NULL
4168 , "cpu"
@@ -4516,7 +4189,7 @@ void update_cgroup_charts(int update_every) {
4189 RRDSET *chart;
4190 snprintfz(title, CHART_TITLE_MAX, "CPU full pressure");
4191 chart = pcs->share_time.st = rrdset_create_localhost(
4519 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4192 + cgroup_chart_type(type, cg)
4193 , "cpu_full_pressure"
4194 , NULL
4195 , "cpu"
@@ -4539,7 +4212,7 @@ void update_cgroup_charts(int update_every) {
4212 RRDSET *chart;
4213 snprintfz(title, CHART_TITLE_MAX, "CPU full pressure stall time");
4214 chart = pcs->total_time.st = rrdset_create_localhost(
4542 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4215 + cgroup_chart_type(type, cg)
4216 , "cpu_full_pressure_stall_time"
4217 , NULL
4218 , "cpu"
@@ -4569,7 +4242,7 @@ void update_cgroup_charts(int update_every) {
4242 RRDSET *chart;
4243 snprintfz(title, CHART_TITLE_MAX, "Memory some pressure");
4244 chart = pcs->share_time.st = rrdset_create_localhost(
4572 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4245 + cgroup_chart_type(type, cg)
4246 , "mem_some_pressure"
4247 , NULL
4248 , "mem"
@@ -4592,7 +4265,7 @@ void update_cgroup_charts(int update_every) {
4265 RRDSET *chart;
4266 snprintfz(title, CHART_TITLE_MAX, "Memory some pressure stall time");
4267 chart = pcs->total_time.st = rrdset_create_localhost(
4595 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4268 + cgroup_chart_type(type, cg)
4269 , "memory_some_pressure_stall_time"
4270 , NULL
4271 , "mem"
@@ -4621,7 +4294,7 @@ void update_cgroup_charts(int update_every) {
4294 snprintfz(title, CHART_TITLE_MAX, "Memory full pressure");
4295
4296 chart = pcs->share_time.st = rrdset_create_localhost(
4624 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4297 + cgroup_chart_type(type, cg)
4298 , "mem_full_pressure"
4299 , NULL
4300 , "mem"
@@ -4645,7 +4318,7 @@ void update_cgroup_charts(int update_every) {
4318 RRDSET *chart;
4319 snprintfz(title, CHART_TITLE_MAX, "Memory full pressure stall time");
4320 chart = pcs->total_time.st = rrdset_create_localhost(
4648 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4321 + cgroup_chart_type(type, cg)
4322 , "memory_full_pressure_stall_time"
4323 , NULL
4324 , "mem"
@@ -4675,7 +4348,7 @@ void update_cgroup_charts(int update_every) {
4348 RRDSET *chart;
4349 snprintfz(title, CHART_TITLE_MAX, "IRQ some pressure");
4350 chart = pcs->share_time.st = rrdset_create_localhost(
4678 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4351 + cgroup_chart_type(type, cg)
4352 , "irq_some_pressure"
4353 , NULL
4354 , "interrupts"
@@ -4698,7 +4371,7 @@ void update_cgroup_charts(int update_every) {
4371 RRDSET *chart;
4372 snprintfz(title, CHART_TITLE_MAX, "IRQ some pressure stall time");
4373 chart = pcs->total_time.st = rrdset_create_localhost(
4701 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4374 + cgroup_chart_type(type, cg)
4375 , "irq_some_pressure_stall_time"
4376 , NULL
4377 , "interrupts"
@@ -4727,7 +4400,7 @@ void update_cgroup_charts(int update_every) {
4400 snprintfz(title, CHART_TITLE_MAX, "IRQ full pressure");
4401
4402 chart = pcs->share_time.st = rrdset_create_localhost(
4730 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4403 + cgroup_chart_type(type, cg)
4404 , "irq_full_pressure"
4405 , NULL
4406 , "interrupts"
@@ -4751,7 +4424,7 @@ void update_cgroup_charts(int update_every) {
4424 RRDSET *chart;
4425 snprintfz(title, CHART_TITLE_MAX, "IRQ full pressure stall time");
4426 chart = pcs->total_time.st = rrdset_create_localhost(
4754 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4427 + cgroup_chart_type(type, cg)
4428 , "irq_full_pressure_stall_time"
4429 , NULL
4430 , "interrupts"
@@ -4781,7 +4454,7 @@ void update_cgroup_charts(int update_every) {
4454 RRDSET *chart;
4455 snprintfz(title, CHART_TITLE_MAX, "I/O some pressure");
4456 chart = pcs->share_time.st = rrdset_create_localhost(
4784 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4457 + cgroup_chart_type(type, cg)
4458 , "io_some_pressure"
4459 , NULL
4460 , "disk"
@@ -4804,7 +4477,7 @@ void update_cgroup_charts(int update_every) {
4477 RRDSET *chart;
4478 snprintfz(title, CHART_TITLE_MAX, "I/O some pressure stall time");
4479 chart = pcs->total_time.st = rrdset_create_localhost(
4807 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4480 + cgroup_chart_type(type, cg)
4481 , "io_some_pressure_stall_time"
4482 , NULL
4483 , "disk"
@@ -4832,7 +4505,7 @@ void update_cgroup_charts(int update_every) {
4505 RRDSET *chart;
4506 snprintfz(title, CHART_TITLE_MAX, "I/O full pressure");
4507 chart = pcs->share_time.st = rrdset_create_localhost(
4835 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4508 + cgroup_chart_type(type, cg)
4509 , "io_full_pressure"
4510 , NULL
4511 , "disk"
@@ -4855,7 +4528,7 @@ void update_cgroup_charts(int update_every) {
4528 RRDSET *chart;
4529 snprintfz(title, CHART_TITLE_MAX, "I/O full pressure stall time");
4530 chart = pcs->total_time.st = rrdset_create_localhost(
4858 - cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX)
4531 + cgroup_chart_type(type, cg)
4532 , "io_full_pressure_stall_time"
4533 , NULL
4534 , "disk"