3acf4090c · cryptotaxi247/netdata-1

@@ -6,14 +6,26 @@

6 static int cgroup_enable_cpuacct_stat = CONFIG_ONDEMAND_ONDEMAND;

7 static int cgroup_enable_cpuacct_usage = CONFIG_ONDEMAND_ONDEMAND;

8 static int cgroup_enable_memory = CONFIG_ONDEMAND_ONDEMAND;

9 -static int cgroup_enable_devices = CONFIG_ONDEMAND_ONDEMAND;

10 -static int cgroup_enable_blkio = CONFIG_ONDEMAND_ONDEMAND;

9 +static int cgroup_enable_detailed_memory = CONFIG_ONDEMAND_ONDEMAND;

10 +static int cgroup_enable_memory_failcnt = CONFIG_ONDEMAND_ONDEMAND;

11 +static int cgroup_enable_swap = CONFIG_ONDEMAND_ONDEMAND;

12 +static int cgroup_enable_blkio_io = CONFIG_ONDEMAND_ONDEMAND;

13 +static int cgroup_enable_blkio_ops = CONFIG_ONDEMAND_ONDEMAND;

14 +static int cgroup_enable_blkio_throttle_io = CONFIG_ONDEMAND_ONDEMAND;

15 +static int cgroup_enable_blkio_throttle_ops = CONFIG_ONDEMAND_ONDEMAND;

16 +static int cgroup_enable_blkio_merged_ops = CONFIG_ONDEMAND_ONDEMAND;

17 +static int cgroup_enable_blkio_queued_ops = CONFIG_ONDEMAND_ONDEMAND;

18 static int cgroup_enable_systemd_services = CONFIG_ONDEMAND_YES;

19 +

20 +static int cgroup_search_in_devices = 1;

21 +

22 static int cgroup_enable_new_cgroups_detected_at_runtime = 1;

23 static int cgroup_check_for_new_every = 10;

24 static int cgroup_update_every = 1;

25 +

26 static int cgroup_recheck_zero_blkio_every_iterations = 10;

27 static int cgroup_recheck_zero_mem_failcnt_every_iterations = 10;

28 +static int cgroup_recheck_zero_mem_detailed_every_iterations = 10;

29

30 static char *cgroup_cpuacct_base = NULL;

31 static char *cgroup_blkio_base = NULL;

@@ -122,15 +134,26 @@ void read_cgroup_plugin_configuration() {

134 if(cgroup_check_for_new_every < cgroup_update_every)

135 cgroup_check_for_new_every = cgroup_update_every;

136

125 - cgroup_enable_cpuacct_stat = config_get_boolean_ondemand("plugin:cgroups", "enable cpuacct stat", cgroup_enable_cpuacct_stat);

126 - cgroup_enable_cpuacct_usage = config_get_boolean_ondemand("plugin:cgroups", "enable cpuacct usage", cgroup_enable_cpuacct_usage);

127 - cgroup_enable_memory = config_get_boolean_ondemand("plugin:cgroups", "enable memory", cgroup_enable_memory);

128 - cgroup_enable_blkio = config_get_boolean_ondemand("plugin:cgroups", "enable blkio", cgroup_enable_blkio);

137 + cgroup_enable_cpuacct_stat = config_get_boolean_ondemand("plugin:cgroups", "enable cpuacct stat (total CPU)", cgroup_enable_cpuacct_stat);

138 + cgroup_enable_cpuacct_usage = config_get_boolean_ondemand("plugin:cgroups", "enable cpuacct usage (per core CPU)", cgroup_enable_cpuacct_usage);

139 +

140 + cgroup_enable_memory = config_get_boolean_ondemand("plugin:cgroups", "enable memory (used mem including cache)", cgroup_enable_memory);

141 + cgroup_enable_detailed_memory = config_get_boolean_ondemand("plugin:cgroups", "enable detailed memory", cgroup_enable_detailed_memory);

142 + cgroup_enable_memory_failcnt = config_get_boolean_ondemand("plugin:cgroups", "enable memory limits fail count", cgroup_enable_memory_failcnt);

143 + cgroup_enable_swap = config_get_boolean_ondemand("plugin:cgroups", "enable swap memory", cgroup_enable_swap);

144

130 - cgroup_enable_systemd_services = config_get_boolean_ondemand("plugin:cgroups", "enable systemd services", cgroup_enable_systemd_services);

145 + cgroup_enable_blkio_io = config_get_boolean_ondemand("plugin:cgroups", "enable blkio bandwidth", cgroup_enable_blkio_io);

146 + cgroup_enable_blkio_ops = config_get_boolean_ondemand("plugin:cgroups", "enable blkio operations", cgroup_enable_blkio_ops);

147 + cgroup_enable_blkio_throttle_io = config_get_boolean_ondemand("plugin:cgroups", "enable blkio throttle bandwidth", cgroup_enable_blkio_throttle_io);

148 + cgroup_enable_blkio_throttle_ops = config_get_boolean_ondemand("plugin:cgroups", "enable blkio throttle operations", cgroup_enable_blkio_throttle_ops);

149 + cgroup_enable_blkio_queued_ops = config_get_boolean_ondemand("plugin:cgroups", "enable blkio queued operations", cgroup_enable_blkio_queued_ops);

150 + cgroup_enable_blkio_merged_ops = config_get_boolean_ondemand("plugin:cgroups", "enable blkio merged operations", cgroup_enable_blkio_merged_ops);

151

152 cgroup_recheck_zero_blkio_every_iterations = (int)config_get_number("plugin:cgroups", "recheck zero blkio every iterations", cgroup_recheck_zero_blkio_every_iterations);

153 cgroup_recheck_zero_mem_failcnt_every_iterations = (int)config_get_number("plugin:cgroups", "recheck zero memory failcnt every iterations", cgroup_recheck_zero_mem_failcnt_every_iterations);

154 + cgroup_recheck_zero_mem_detailed_every_iterations = (int)config_get_number("plugin:cgroups", "recheck zero detailed memory every iterations", cgroup_recheck_zero_mem_detailed_every_iterations);

155 +

156 + cgroup_enable_systemd_services = config_get_boolean("plugin:cgroups", "enable systemd services", cgroup_enable_systemd_services);

157

158 char filename[FILENAME_MAX + 1], *s;

159 struct mountinfo *mi, *root = mountinfo_read(0);

@@ -240,6 +263,7 @@ void read_cgroup_plugin_configuration() {

263

264 struct blkio {

265 int updated;

266 + int enabled; // CONFIG_ONDEMAND_YES or CONFIG_ONDEMAND_ONDEMAND

267 int delay_counter;

268

269 char *filename;

@@ -256,6 +280,12 @@ struct blkio {

280 // https://www.kernel.org/doc/Documentation/cgroup-v1/memory.txt

281 struct memory {

282 int updated;

283 + int enabled_usage; // CONFIG_ONDEMAND_YES or CONFIG_ONDEMAND_ONDEMAND

284 + int enabled_detailed; // CONFIG_ONDEMAND_YES or CONFIG_ONDEMAND_ONDEMAND

285 + int enabled_swap; // CONFIG_ONDEMAND_YES or CONFIG_ONDEMAND_ONDEMAND

286 + int enabled_failcnt; // CONFIG_ONDEMAND_YES or CONFIG_ONDEMAND_ONDEMAND

287 +

288 + int delay_counter;

289

290 char *filename;

291

@@ -314,6 +344,7 @@ struct memory {

344 // https://www.kernel.org/doc/Documentation/cgroup-v1/cpuacct.txt

345 struct cpuacct_stat {

346 int updated;

347 + int enabled; // CONFIG_ONDEMAND_YES or CONFIG_ONDEMAND_ONDEMAND

348

349 char *filename;

350

@@ -324,6 +355,7 @@ struct cpuacct_stat {

355 // https://www.kernel.org/doc/Documentation/cgroup-v1/cpuacct.txt

356 struct cpuacct_usage {

357 int updated;

358 + int enabled; // CONFIG_ONDEMAND_YES or CONFIG_ONDEMAND_ONDEMAND

359

360 char *filename;

361

@@ -445,6 +477,9 @@ static inline void cgroup_read_cpuacct_stat(struct cpuacct_stat *cp) {

477 }

478

479 cp->updated = 1;

480 +

481 + if(unlikely(cp->enabled == CONFIG_ONDEMAND_ONDEMAND && (cp->user || cp->system)))

482 + cp->enabled = CONFIG_ONDEMAND_YES;

483 }

484 }

485

@@ -489,17 +524,24 @@ static inline void cgroup_read_cpuacct_usage(struct cpuacct_usage *ca) {

524 ca->cpus = (unsigned int)i;

525 }

526

492 - for(i = 0; i < ca->cpus ;i++)

493 - ca->cpu_percpu[i] = strtoull(procfile_lineword(ff, 0, i), NULL, 10);

527 + unsigned long long total = 0;

528 + for(i = 0; i < ca->cpus ;i++) {

529 + unsigned long long n = strtoull(procfile_lineword(ff, 0, i), NULL, 10);

530 + ca->cpu_percpu[i] = n;

531 + total += n;

532 + }

533

534 ca->updated = 1;

535 +

536 + if(unlikely(ca->enabled == CONFIG_ONDEMAND_ONDEMAND && total))

537 + ca->enabled = CONFIG_ONDEMAND_YES;

538 }

539 }

540

541 static inline void cgroup_read_blkio(struct blkio *io) {

542 static procfile *ff = NULL;

543

502 - if(unlikely(io->delay_counter > 0)) {

544 + if(unlikely(io->enabled == CONFIG_ONDEMAND_ONDEMAND && io->delay_counter > 0)) {

545 io->delay_counter--;

546 return;

547 }

@@ -567,15 +609,25 @@ static inline void cgroup_read_blkio(struct blkio *io) {

609

610 io->updated = 1;

611

570 - if(unlikely(!io->Read && !io->Write))

571 - io->delay_counter = cgroup_recheck_zero_blkio_every_iterations;

612 + if(unlikely(io->enabled == CONFIG_ONDEMAND_ONDEMAND)) {

613 + if(unlikely(io->Read || io->Write))

614 + io->enabled = CONFIG_ONDEMAND_YES;

615 + else

616 + io->delay_counter = cgroup_recheck_zero_blkio_every_iterations;

617 + }

618 }

619 }

620

621 static inline void cgroup_read_memory(struct memory *mem) {

622 static procfile *ff = NULL;

623

624 + // read detailed ram usage

625 if(likely(mem->filename)) {

626 + if(unlikely(mem->enabled_detailed == CONFIG_ONDEMAND_ONDEMAND && mem->delay_counter > 0)) {

627 + mem->delay_counter--;

628 + goto memory_next;

629 + }

630 +

631 ff = procfile_reopen(ff, mem->filename, NULL, PROCFILE_FLAG_DEFAULT);

632 if(unlikely(!ff)) {

633 mem->updated = 0;

@@ -773,33 +825,56 @@ static inline void cgroup_read_memory(struct memory *mem) {

825 // fprintf(stderr, "READ: '%s', cache: %llu, rss: %llu, rss_huge: %llu, mapped_file: %llu, writeback: %llu, dirty: %llu, swap: %llu, pgpgin: %llu, pgpgout: %llu, pgfault: %llu, pgmajfault: %llu, inactive_anon: %llu, active_anon: %llu, inactive_file: %llu, active_file: %llu, unevictable: %llu, hierarchical_memory_limit: %llu, total_cache: %llu, total_rss: %llu, total_rss_huge: %llu, total_mapped_file: %llu, total_writeback: %llu, total_dirty: %llu, total_swap: %llu, total_pgpgin: %llu, total_pgpgout: %llu, total_pgfault: %llu, total_pgmajfault: %llu, total_inactive_anon: %llu, total_active_anon: %llu, total_inactive_file: %llu, total_active_file: %llu, total_unevictable: %llu\n", mem->filename, mem->cache, mem->rss, mem->rss_huge, mem->mapped_file, mem->writeback, mem->dirty, mem->swap, mem->pgpgin, mem->pgpgout, mem->pgfault, mem->pgmajfault, mem->inactive_anon, mem->active_anon, mem->inactive_file, mem->active_file, mem->unevictable, mem->hierarchical_memory_limit, mem->total_cache, mem->total_rss, mem->total_rss_huge, mem->total_mapped_file, mem->total_writeback, mem->total_dirty, mem->total_swap, mem->total_pgpgin, mem->total_pgpgout, mem->total_pgfault, mem->total_pgmajfault, mem->total_inactive_anon, mem->total_active_anon, mem->total_inactive_file, mem->total_active_file, mem->total_unevictable);

826

827 mem->updated = 1;

828 +

829 + if(unlikely(mem->enabled_detailed == CONFIG_ONDEMAND_ONDEMAND)) {

830 + if(mem->cache || mem->dirty || mem->rss || mem->rss_huge || mem->mapped_file || mem->writeback || mem->swap || mem->pgpgin || mem->pgpgout || mem->pgfault || mem->pgmajfault)

831 + mem->enabled_detailed = CONFIG_ONDEMAND_YES;

832 + else

833 + mem->delay_counter = cgroup_recheck_zero_mem_detailed_every_iterations;

834 + }

835 }

836

837 memory_next:

838 +

839 + // read usage_in_bytes

840 if(likely(mem->filename_usage_in_bytes)) {

780 - if(likely(!read_single_number_file(mem->filename_usage_in_bytes, &mem->usage_in_bytes)))

841 + if(likely(!read_single_number_file(mem->filename_usage_in_bytes, &mem->usage_in_bytes))) {

842 mem->usage_in_bytes_updated = 1;

843 +

844 + if(unlikely(mem->enabled_usage == CONFIG_ONDEMAND_ONDEMAND && mem->usage_in_bytes))

845 + mem->enabled_usage = CONFIG_ONDEMAND_YES;

846 + }

847 else

848 mem->usage_in_bytes_updated = 0;

849 }

850

851 + // read msw_usage_in_bytes

852 if(likely(mem->filename_msw_usage_in_bytes)) {

787 - if(likely(!read_single_number_file(mem->filename_msw_usage_in_bytes, &mem->msw_usage_in_bytes)))

853 + if(likely(!read_single_number_file(mem->filename_msw_usage_in_bytes, &mem->msw_usage_in_bytes))) {

854 mem->msw_usage_in_bytes_updated = 1;

855 +

856 + if(unlikely(mem->enabled_swap == CONFIG_ONDEMAND_ONDEMAND && mem->msw_usage_in_bytes))

857 + mem->enabled_swap = CONFIG_ONDEMAND_YES;

858 + }

859 else

860 mem->msw_usage_in_bytes_updated = 0;

861 }

862

863 + // read failcnt

864 if(likely(mem->filename_failcnt)) {

794 - if(unlikely(mem->failcnt_delay_counter > 0)) {

865 + if(unlikely(mem->enabled_failcnt == CONFIG_ONDEMAND_ONDEMAND && mem->failcnt_delay_counter > 0)) {

866 mem->failcnt_updated = 0;

867 mem->failcnt_delay_counter--;

868 }

869 else if(likely(!read_single_number_file(mem->filename_failcnt, &mem->failcnt))) {

870 mem->failcnt_updated = 1;

871

801 - if(unlikely(!mem->failcnt))

802 - mem->failcnt_delay_counter = cgroup_recheck_zero_mem_failcnt_every_iterations;

872 + if(unlikely(mem->enabled_failcnt == CONFIG_ONDEMAND_ONDEMAND)) {

873 + if(unlikely(!mem->failcnt))

874 + mem->failcnt_delay_counter = cgroup_recheck_zero_mem_failcnt_every_iterations;

875 + else

876 + mem->enabled_failcnt = CONFIG_ONDEMAND_YES;

877 + }

878 }

879 }

880 }

@@ -1205,30 +1280,39 @@ static inline void find_all_cgroups() {

1280 mark_all_cgroups_as_not_available();

1281

1282 if(cgroup_enable_cpuacct_stat || cgroup_enable_cpuacct_usage) {

1208 - if (find_dir_in_subdirs(cgroup_cpuacct_base, NULL, found_subdir_in_dir) == -1) {

1209 - cgroup_enable_cpuacct_stat = cgroup_enable_cpuacct_usage = 0;

1210 - error("disabled cgroup cpu statistics.");

1283 + if(find_dir_in_subdirs(cgroup_cpuacct_base, NULL, found_subdir_in_dir) == -1) {

1284 + cgroup_enable_cpuacct_stat =

1285 + cgroup_enable_cpuacct_usage = CONFIG_ONDEMAND_NO;

1286 + error("disabled CGROUP cpu statistics.");

1287 }

1288 }

1289

1214 - if(cgroup_enable_blkio) {

1215 - if (find_dir_in_subdirs(cgroup_blkio_base, NULL, found_subdir_in_dir) == -1) {

1216 - cgroup_enable_blkio = 0;

1217 - error("disabled cgroup blkio statistics.");

1290 + if(cgroup_enable_blkio_io || cgroup_enable_blkio_ops || cgroup_enable_blkio_throttle_io || cgroup_enable_blkio_throttle_ops || cgroup_enable_blkio_merged_ops || cgroup_enable_blkio_queued_ops) {

1291 + if(find_dir_in_subdirs(cgroup_blkio_base, NULL, found_subdir_in_dir) == -1) {

1292 + cgroup_enable_blkio_io =

1293 + cgroup_enable_blkio_ops =

1294 + cgroup_enable_blkio_throttle_io =

1295 + cgroup_enable_blkio_throttle_ops =

1296 + cgroup_enable_blkio_merged_ops =

1297 + cgroup_enable_blkio_queued_ops = CONFIG_ONDEMAND_NO;

1298 + error("disabled CGROUP blkio statistics.");

1299 }

1300 }

1301

1221 - if(cgroup_enable_memory) {

1302 + if(cgroup_enable_memory || cgroup_enable_detailed_memory || cgroup_enable_swap || cgroup_enable_memory_failcnt) {

1303 if(find_dir_in_subdirs(cgroup_memory_base, NULL, found_subdir_in_dir) == -1) {

1223 - cgroup_enable_memory = 0;

1224 - error("disabled cgroup memory statistics.");

1304 + cgroup_enable_memory =

1305 + cgroup_enable_detailed_memory =

1306 + cgroup_enable_swap =

1307 + cgroup_enable_memory_failcnt = CONFIG_ONDEMAND_NO;

1308 + error("disabled CGROUP memory statistics.");

1309 }

1310 }

1311

1228 - if(cgroup_enable_devices) {

1312 + if(cgroup_search_in_devices) {

1313 if(find_dir_in_subdirs(cgroup_devices_base, NULL, found_subdir_in_dir) == -1) {

1230 - cgroup_enable_devices = 0;

1231 - error("disabled cgroup devices statistics.");

1314 + cgroup_search_in_devices = 0;

1315 + error("disabled CGROUP devices statistics.");

1316 }

1317 }

1318

@@ -1252,119 +1336,132 @@ static inline void find_all_cgroups() {

1336 snprintfz(filename, FILENAME_MAX, "%s%s/cpuacct.stat", cgroup_cpuacct_base, cg->id);

1337 if(likely(stat(filename, &buf) != -1)) {

1338 cg->cpuacct_stat.filename = strdupz(filename);

1339 + cg->cpuacct_stat.enabled = cgroup_enable_cpuacct_stat;

1340 debug(D_CGROUP, "cpuacct.stat filename for cgroup '%s': '%s'", cg->id, cg->cpuacct_stat.filename);

1341 }

1257 - else debug(D_CGROUP, "cpuacct.stat file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1342 + else

1343 + debug(D_CGROUP, "cpuacct.stat file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1344 }

1345

1346 if(unlikely(cgroup_enable_cpuacct_usage && !cg->cpuacct_usage.filename && !(cg->options & CGROUP_OPTIONS_SYSTEM_SLICE_SERVICE))) {

1347 snprintfz(filename, FILENAME_MAX, "%s%s/cpuacct.usage_percpu", cgroup_cpuacct_base, cg->id);

1348 if(likely(stat(filename, &buf) != -1)) {

1349 cg->cpuacct_usage.filename = strdupz(filename);

1350 + cg->cpuacct_usage.enabled = cgroup_enable_cpuacct_usage;

1351 debug(D_CGROUP, "cpuacct.usage_percpu filename for cgroup '%s': '%s'", cg->id, cg->cpuacct_usage.filename);

1352 }

1266 - else debug(D_CGROUP, "cpuacct.usage_percpu file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1353 + else

1354 + debug(D_CGROUP, "cpuacct.usage_percpu file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1355 }

1356

1269 - if(unlikely(cgroup_enable_memory)) {

1270 - if(unlikely(!cg->memory.filename) && !(cg->options & CGROUP_OPTIONS_SYSTEM_SLICE_SERVICE)) {

1271 - snprintfz(filename, FILENAME_MAX, "%s%s/memory.stat", cgroup_memory_base, cg->id);

1272 - if(likely(stat(filename, &buf) != -1)) {

1273 - cg->memory.filename = strdupz(filename);

1274 - debug(D_CGROUP, "memory.stat filename for cgroup '%s': '%s'", cg->id, cg->memory.filename);

1275 - }

1276 - else

1277 - debug(D_CGROUP, "memory.stat file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1357 + if(unlikely(cgroup_enable_detailed_memory && !cg->memory.filename && !(cg->options & CGROUP_OPTIONS_SYSTEM_SLICE_SERVICE))) {

1358 + snprintfz(filename, FILENAME_MAX, "%s%s/memory.stat", cgroup_memory_base, cg->id);

1359 + if(likely(stat(filename, &buf) != -1)) {

1360 + cg->memory.filename = strdupz(filename);

1361 + cg->memory.enabled_detailed = cgroup_enable_detailed_memory;

1362 + debug(D_CGROUP, "memory.stat filename for cgroup '%s': '%s'", cg->id, cg->memory.filename);

1363 }

1279 - if(unlikely(!cg->memory.filename_usage_in_bytes)) {

1280 - snprintfz(filename, FILENAME_MAX, "%s%s/memory.usage_in_bytes", cgroup_memory_base, cg->id);

1281 - if(likely(stat(filename, &buf) != -1)) {

1282 - cg->memory.filename_usage_in_bytes = strdupz(filename);

1283 - debug(D_CGROUP, "memory.usage_in_bytes filename for cgroup '%s': '%s'", cg->id, cg->memory.filename_usage_in_bytes);

1284 - }

1285 - else

1286 - debug(D_CGROUP, "memory.usage_in_bytes file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1364 + else

1365 + debug(D_CGROUP, "memory.stat file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1366 + }

1367 +

1368 + if(unlikely(cgroup_enable_memory && !cg->memory.filename_usage_in_bytes)) {

1369 + snprintfz(filename, FILENAME_MAX, "%s%s/memory.usage_in_bytes", cgroup_memory_base, cg->id);

1370 + if(likely(stat(filename, &buf) != -1)) {

1371 + cg->memory.filename_usage_in_bytes = strdupz(filename);

1372 + cg->memory.enabled_usage = cgroup_enable_memory;

1373 + debug(D_CGROUP, "memory.usage_in_bytes filename for cgroup '%s': '%s'", cg->id, cg->memory.filename_usage_in_bytes);

1374 }

1288 - if(unlikely(!cg->memory.filename_msw_usage_in_bytes)) {

1289 - snprintfz(filename, FILENAME_MAX, "%s%s/memory.msw_usage_in_bytes", cgroup_memory_base, cg->id);

1290 - if(likely(stat(filename, &buf) != -1)) {

1291 - cg->memory.filename_msw_usage_in_bytes = strdupz(filename);

1292 - debug(D_CGROUP, "memory.msw_usage_in_bytes filename for cgroup '%s': '%s'", cg->id, cg->memory.filename_msw_usage_in_bytes);

1293 - }

1294 - else

1295 - debug(D_CGROUP, "memory.msw_usage_in_bytes file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1375 + else

1376 + debug(D_CGROUP, "memory.usage_in_bytes file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1377 + }

1378 +

1379 + if(unlikely(cgroup_enable_swap && !cg->memory.filename_msw_usage_in_bytes)) {

1380 + snprintfz(filename, FILENAME_MAX, "%s%s/memory.msw_usage_in_bytes", cgroup_memory_base, cg->id);

1381 + if(likely(stat(filename, &buf) != -1)) {

1382 + cg->memory.filename_msw_usage_in_bytes = strdupz(filename);

1383 + cg->memory.enabled_swap = cgroup_enable_swap;

1384 + debug(D_CGROUP, "memory.msw_usage_in_bytes filename for cgroup '%s': '%s'", cg->id, cg->memory.filename_msw_usage_in_bytes);

1385 }

1297 - if(unlikely(!cg->memory.filename_failcnt)) {

1298 - snprintfz(filename, FILENAME_MAX, "%s%s/memory.failcnt", cgroup_memory_base, cg->id);

1299 - if(likely(stat(filename, &buf) != -1)) {

1300 - cg->memory.filename_failcnt = strdupz(filename);

1301 - debug(D_CGROUP, "memory.failcnt filename for cgroup '%s': '%s'", cg->id, cg->memory.filename_failcnt);

1302 - }

1303 - else

1304 - debug(D_CGROUP, "memory.failcnt file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1386 + else

1387 + debug(D_CGROUP, "memory.msw_usage_in_bytes file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1388 + }

1389 +

1390 + if(unlikely(cgroup_enable_memory_failcnt && !cg->memory.filename_failcnt)) {

1391 + snprintfz(filename, FILENAME_MAX, "%s%s/memory.failcnt", cgroup_memory_base, cg->id);

1392 + if(likely(stat(filename, &buf) != -1)) {

1393 + cg->memory.filename_failcnt = strdupz(filename);

1394 + cg->memory.enabled_failcnt = cgroup_enable_memory_failcnt;

1395 + debug(D_CGROUP, "memory.failcnt filename for cgroup '%s': '%s'", cg->id, cg->memory.filename_failcnt);

1396 }

1397 + else

1398 + debug(D_CGROUP, "memory.failcnt file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1399 }

1400

1308 - if(unlikely(cgroup_enable_blkio)) {

1309 - if(unlikely(!cg->io_service_bytes.filename)) {

1310 - snprintfz(filename, FILENAME_MAX, "%s%s/blkio.io_service_bytes", cgroup_blkio_base, cg->id);

1311 - if(likely(stat(filename, &buf) != -1)) {

1312 - cg->io_service_bytes.filename = strdupz(filename);

1313 - debug(D_CGROUP, "io_service_bytes filename for cgroup '%s': '%s'", cg->id, cg->io_service_bytes.filename);

1314 - }

1315 - else

1316 - debug(D_CGROUP, "io_service_bytes file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1401 + if(unlikely(cgroup_enable_blkio_io && !cg->io_service_bytes.filename)) {

1402 + snprintfz(filename, FILENAME_MAX, "%s%s/blkio.io_service_bytes", cgroup_blkio_base, cg->id);

1403 + if(likely(stat(filename, &buf) != -1)) {

1404 + cg->io_service_bytes.filename = strdupz(filename);

1405 + cg->io_service_bytes.enabled = cgroup_enable_blkio_io;

1406 + debug(D_CGROUP, "io_service_bytes filename for cgroup '%s': '%s'", cg->id, cg->io_service_bytes.filename);

1407 }

1408 + else

1409 + debug(D_CGROUP, "io_service_bytes file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1410 + }

1411

1319 - if(unlikely(!cg->io_serviced.filename)) {

1320 - snprintfz(filename, FILENAME_MAX, "%s%s/blkio.io_serviced", cgroup_blkio_base, cg->id);

1321 - if(likely(stat(filename, &buf) != -1)) {

1322 - cg->io_serviced.filename = strdupz(filename);

1323 - debug(D_CGROUP, "io_serviced filename for cgroup '%s': '%s'", cg->id, cg->io_serviced.filename);

1324 - }

1325 - else

1326 - debug(D_CGROUP, "io_serviced file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1412 + if(unlikely(cgroup_enable_blkio_ops && !cg->io_serviced.filename)) {

1413 + snprintfz(filename, FILENAME_MAX, "%s%s/blkio.io_serviced", cgroup_blkio_base, cg->id);

1414 + if(likely(stat(filename, &buf) != -1)) {

1415 + cg->io_serviced.filename = strdupz(filename);

1416 + cg->io_serviced.enabled = cgroup_enable_blkio_ops;

1417 + debug(D_CGROUP, "io_serviced filename for cgroup '%s': '%s'", cg->id, cg->io_serviced.filename);

1418 }

1419 + else

1420 + debug(D_CGROUP, "io_serviced file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1421 + }

1422

1329 - if(unlikely(!cg->throttle_io_service_bytes.filename)) {

1330 - snprintfz(filename, FILENAME_MAX, "%s%s/blkio.throttle.io_service_bytes", cgroup_blkio_base, cg->id);

1331 - if(likely(stat(filename, &buf) != -1)) {

1332 - cg->throttle_io_service_bytes.filename = strdupz(filename);

1333 - debug(D_CGROUP, "throttle_io_service_bytes filename for cgroup '%s': '%s'", cg->id, cg->throttle_io_service_bytes.filename);

1334 - }

1335 - else

1336 - debug(D_CGROUP, "throttle_io_service_bytes file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1423 + if(unlikely(cgroup_enable_blkio_throttle_io && !cg->throttle_io_service_bytes.filename)) {

1424 + snprintfz(filename, FILENAME_MAX, "%s%s/blkio.throttle.io_service_bytes", cgroup_blkio_base, cg->id);

1425 + if(likely(stat(filename, &buf) != -1)) {

1426 + cg->throttle_io_service_bytes.filename = strdupz(filename);

1427 + cg->throttle_io_service_bytes.enabled = cgroup_enable_blkio_throttle_io;

1428 + debug(D_CGROUP, "throttle_io_service_bytes filename for cgroup '%s': '%s'", cg->id, cg->throttle_io_service_bytes.filename);

1429 }

1430 + else

1431 + debug(D_CGROUP, "throttle_io_service_bytes file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1432 + }

1433

1339 - if(unlikely(!cg->throttle_io_serviced.filename)) {

1340 - snprintfz(filename, FILENAME_MAX, "%s%s/blkio.throttle.io_serviced", cgroup_blkio_base, cg->id);

1341 - if(likely(stat(filename, &buf) != -1)) {

1342 - cg->throttle_io_serviced.filename = strdupz(filename);

1343 - debug(D_CGROUP, "throttle_io_serviced filename for cgroup '%s': '%s'", cg->id, cg->throttle_io_serviced.filename);

1344 - }

1345 - else

1346 - debug(D_CGROUP, "throttle_io_serviced file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1434 + if(unlikely(cgroup_enable_blkio_throttle_ops && !cg->throttle_io_serviced.filename)) {

1435 + snprintfz(filename, FILENAME_MAX, "%s%s/blkio.throttle.io_serviced", cgroup_blkio_base, cg->id);

1436 + if(likely(stat(filename, &buf) != -1)) {

1437 + cg->throttle_io_serviced.filename = strdupz(filename);

1438 + cg->throttle_io_serviced.enabled = cgroup_enable_blkio_throttle_ops;

1439 + debug(D_CGROUP, "throttle_io_serviced filename for cgroup '%s': '%s'", cg->id, cg->throttle_io_serviced.filename);

1440 }

1441 + else

1442 + debug(D_CGROUP, "throttle_io_serviced file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1443 + }

1444

1349 - if(unlikely(!cg->io_merged.filename)) {

1350 - snprintfz(filename, FILENAME_MAX, "%s%s/blkio.io_merged", cgroup_blkio_base, cg->id);

1351 - if(likely(stat(filename, &buf) != -1)) {

1352 - cg->io_merged.filename = strdupz(filename);

1353 - debug(D_CGROUP, "io_merged filename for cgroup '%s': '%s'", cg->id, cg->io_merged.filename);

1354 - }

1355 - else

1356 - debug(D_CGROUP, "io_merged file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1445 + if(unlikely(cgroup_enable_blkio_merged_ops && !cg->io_merged.filename)) {

1446 + snprintfz(filename, FILENAME_MAX, "%s%s/blkio.io_merged", cgroup_blkio_base, cg->id);

1447 + if(likely(stat(filename, &buf) != -1)) {

1448 + cg->io_merged.filename = strdupz(filename);

1449 + cg->io_merged.enabled = cgroup_enable_blkio_merged_ops;

1450 + debug(D_CGROUP, "io_merged filename for cgroup '%s': '%s'", cg->id, cg->io_merged.filename);

1451 }

1452 + else

1453 + debug(D_CGROUP, "io_merged file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1454 + }

1455

1359 - if(unlikely(!cg->io_queued.filename)) {

1360 - snprintfz(filename, FILENAME_MAX, "%s%s/blkio.io_queued", cgroup_blkio_base, cg->id);

1361 - if(likely(stat(filename, &buf) != -1)) {

1362 - cg->io_queued.filename = strdupz(filename);

1363 - debug(D_CGROUP, "io_queued filename for cgroup '%s': '%s'", cg->id, cg->io_queued.filename);

1364 - }

1365 - else

1366 - debug(D_CGROUP, "io_queued file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1456 + if(unlikely(cgroup_enable_blkio_queued_ops && !cg->io_queued.filename)) {

1457 + snprintfz(filename, FILENAME_MAX, "%s%s/blkio.io_queued", cgroup_blkio_base, cg->id);

1458 + if(likely(stat(filename, &buf) != -1)) {

1459 + cg->io_queued.filename = strdupz(filename);

1460 + cg->io_queued.enabled = cgroup_enable_blkio_queued_ops;

1461 + debug(D_CGROUP, "io_queued filename for cgroup '%s': '%s'", cg->id, cg->io_queued.filename);

1462 }

1463 + else

1464 + debug(D_CGROUP, "io_queued file for cgroup '%s': '%s' does not exist.", cg->id, filename);

1465 }

1466 }

1467

@@ -1702,6 +1799,16 @@ void update_services_charts(int update_every,

1799 rrdset_done(st_throttle_ops_read);

1800 rrdset_done(st_throttle_ops_write);

1801 }

1802 +

1803 + if(likely(do_queued_ops)) {

1804 + rrdset_done(st_queued_ops_read);

1805 + rrdset_done(st_queued_ops_write);

1806 + }

1807 +

1808 + if(likely(do_merged_ops)) {

1809 + rrdset_done(st_merged_ops_read);

1810 + rrdset_done(st_merged_ops_write);

1811 + }

1812 }

1813

1814 static inline char *cgroup_chart_type(char *buffer, const char *id, size_t len) {

@@ -1739,22 +1846,24 @@ void update_cgroup_charts(int update_every) {

1846 continue;

1847

1848 if(likely(cgroup_enable_systemd_services && cg->options & CGROUP_OPTIONS_SYSTEM_SLICE_SERVICE)) {

1742 - if(cg->cpuacct_stat.updated && (cg->cpuacct_stat.user || cg->cpuacct_stat.system)) services_do_cpu++;

1743 - if(cg->memory.usage_in_bytes_updated && (cg->memory.usage_in_bytes)) services_do_mem_usage++;

1744 - if(cg->memory.failcnt_updated && (cg->memory.failcnt)) services_do_mem_failcnt++;

1745 - if(cg->memory.msw_usage_in_bytes_updated && (cg->memory.msw_usage_in_bytes)) services_do_swap_usage++;

1746 - if(cg->io_service_bytes.updated && (cg->io_service_bytes.Read || cg->io_service_bytes.Write)) services_do_io++;

1747 - if(cg->io_serviced.updated && (cg->io_serviced.Read || cg->io_serviced.Write)) services_do_io_ops++;

1748 - if(cg->throttle_io_service_bytes.updated && (cg->throttle_io_service_bytes.Read || cg->throttle_io_service_bytes.Write)) services_do_throttle_io++;

1749 - if(cg->throttle_io_serviced.updated && (cg->throttle_io_serviced.Read || cg->throttle_io_serviced.Write)) services_do_throttle_ops++;

1750 - if(cg->io_queued.updated && (cg->io_queued.Read || cg->io_queued.Write)) services_do_queued_ops++;

1751 - if(cg->io_merged.updated && (cg->io_merged.Read || cg->io_merged.Write)) services_do_merged_ops++;

1849 + if(cg->cpuacct_stat.updated && cg->cpuacct_stat.enabled == CONFIG_ONDEMAND_YES) services_do_cpu++;

1850 +

1851 + if(cg->memory.usage_in_bytes_updated && cg->memory.enabled_usage == CONFIG_ONDEMAND_YES) services_do_mem_usage++;

1852 + if(cg->memory.failcnt_updated && cg->memory.enabled_failcnt == CONFIG_ONDEMAND_YES) services_do_mem_failcnt++;

1853 + if(cg->memory.msw_usage_in_bytes_updated && cg->memory.enabled_swap == CONFIG_ONDEMAND_YES) services_do_swap_usage++;

1854 +

1855 + if(cg->io_service_bytes.updated && cg->io_service_bytes.enabled == CONFIG_ONDEMAND_YES) services_do_io++;

1856 + if(cg->io_serviced.updated && cg->io_serviced.enabled == CONFIG_ONDEMAND_YES) services_do_io_ops++;

1857 + if(cg->throttle_io_service_bytes.updated && cg->throttle_io_service_bytes.enabled == CONFIG_ONDEMAND_YES) services_do_throttle_io++;

1858 + if(cg->throttle_io_serviced.updated && cg->throttle_io_serviced.enabled == CONFIG_ONDEMAND_YES) services_do_throttle_ops++;

1859 + if(cg->io_queued.updated && cg->io_queued.enabled == CONFIG_ONDEMAND_YES) services_do_queued_ops++;

1860 + if(cg->io_merged.updated && cg->io_merged.enabled == CONFIG_ONDEMAND_YES) services_do_merged_ops++;

1861 continue;

1862 }

1863

1864 type[0] = '\0';

1865

1757 - if(likely(cg->cpuacct_stat.updated)) {

1866 + if(likely(cg->cpuacct_stat.updated && cg->cpuacct_stat.enabled == CONFIG_ONDEMAND_YES)) {

1867 if(unlikely(!cg->st_cpu)) {

1868 cg->st_cpu = rrdset_find_bytype(cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX), "cpu");

1869 if(likely(!cg->st_cpu)) {

@@ -1772,7 +1881,7 @@ void update_cgroup_charts(int update_every) {

1881 rrdset_done(cg->st_cpu);

1882 }

1883

1775 - if(likely(cg->cpuacct_usage.updated)) {

1884 + if(likely(cg->cpuacct_usage.updated && cg->cpuacct_usage.enabled == CONFIG_ONDEMAND_YES)) {

1885 char id[RRD_ID_LENGTH_MAX + 1];

1886 unsigned int i;

1887

@@ -1797,33 +1906,31 @@ void update_cgroup_charts(int update_every) {

1906 rrdset_done(cg->st_cpu_per_core);

1907 }

1908

1800 - if(likely(cg->memory.updated)) {

1801 - if(likely(cg->memory.cache || cg->memory.rss || cg->memory.rss_huge || cg->memory.mapped_file)) {

1802 - if(unlikely(!cg->st_mem)) {

1803 - cg->st_mem = rrdset_find_bytype(cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX), "mem");

1804 - if(likely(!cg->st_mem)) {

1805 - snprintfz(title, CHART_TITLE_MAX, "Memory Usage for cgroup %s", cg->chart_title);

1806 - cg->st_mem = rrdset_create(type, "mem", NULL, "mem", "cgroup.mem", title, "MB", 40210, update_every, RRDSET_TYPE_STACKED);

1807 - }

1808 -

1809 - rrddim_add(cg->st_mem, "cache", NULL, 1, 1024 * 1024, RRDDIM_ABSOLUTE);

1810 - rrddim_add(cg->st_mem, "rss", NULL, 1, 1024 * 1024, RRDDIM_ABSOLUTE);

1811 - if(cg->memory.has_dirty_swap)

1812 - rrddim_add(cg->st_mem, "swap", NULL, 1, 1024 * 1024, RRDDIM_ABSOLUTE);

1813 - rrddim_add(cg->st_mem, "rss_huge", NULL, 1, 1024 * 1024, RRDDIM_ABSOLUTE);

1814 - rrddim_add(cg->st_mem, "mapped_file", NULL, 1, 1024 * 1024, RRDDIM_ABSOLUTE);

1909 + if(likely(cg->memory.updated && cg->memory.enabled_detailed == CONFIG_ONDEMAND_YES)) {

1910 + if(unlikely(!cg->st_mem)) {

1911 + cg->st_mem = rrdset_find_bytype(cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX), "mem");

1912 + if(likely(!cg->st_mem)) {

1913 + snprintfz(title, CHART_TITLE_MAX, "Memory Usage for cgroup %s", cg->chart_title);

1914 + cg->st_mem = rrdset_create(type, "mem", NULL, "mem", "cgroup.mem", title, "MB", 40210, update_every, RRDSET_TYPE_STACKED);

1915 }

1816 - else

1817 - rrdset_next(cg->st_mem);

1916

1819 - rrddim_set(cg->st_mem, "cache", cg->memory.cache);

1820 - rrddim_set(cg->st_mem, "rss", cg->memory.rss);

1917 + rrddim_add(cg->st_mem, "cache", NULL, 1, 1024 * 1024, RRDDIM_ABSOLUTE);

1918 + rrddim_add(cg->st_mem, "rss", NULL, 1, 1024 * 1024, RRDDIM_ABSOLUTE);

1919 if(cg->memory.has_dirty_swap)

1822 - rrddim_set(cg->st_mem, "swap", cg->memory.swap);

1823 - rrddim_set(cg->st_mem, "rss_huge", cg->memory.rss_huge);

1824 - rrddim_set(cg->st_mem, "mapped_file", cg->memory.mapped_file);

1825 - rrdset_done(cg->st_mem);

1920 + rrddim_add(cg->st_mem, "swap", NULL, 1, 1024 * 1024, RRDDIM_ABSOLUTE);

1921 + rrddim_add(cg->st_mem, "rss_huge", NULL, 1, 1024 * 1024, RRDDIM_ABSOLUTE);

1922 + rrddim_add(cg->st_mem, "mapped_file", NULL, 1, 1024 * 1024, RRDDIM_ABSOLUTE);

1923 }

1924 + else

1925 + rrdset_next(cg->st_mem);

1926 +

1927 + rrddim_set(cg->st_mem, "cache", cg->memory.cache);

1928 + rrddim_set(cg->st_mem, "rss", cg->memory.rss);

1929 + if(cg->memory.has_dirty_swap)

1930 + rrddim_set(cg->st_mem, "swap", cg->memory.swap);

1931 + rrddim_set(cg->st_mem, "rss_huge", cg->memory.rss_huge);

1932 + rrddim_set(cg->st_mem, "mapped_file", cg->memory.mapped_file);

1933 + rrdset_done(cg->st_mem);

1934

1935 if(unlikely(!cg->st_writeback)) {

1936 cg->st_writeback = rrdset_find_bytype(cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX), "writeback");

@@ -1844,44 +1951,40 @@ void update_cgroup_charts(int update_every) {

1951 rrddim_set(cg->st_writeback, "writeback", cg->memory.writeback);

1952 rrdset_done(cg->st_writeback);

1953

1847 - if(likely(cg->memory.pgpgin || cg->memory.pgpgout)) {

1848 - if(unlikely(!cg->st_mem_activity)) {

1849 - cg->st_mem_activity = rrdset_find_bytype(cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX), "mem_activity");

1850 - if(likely(!cg->st_mem_activity)) {

1851 - snprintfz(title, CHART_TITLE_MAX, "Memory Activity for cgroup %s", cg->chart_title);

1852 - cg->st_mem_activity = rrdset_create(type, "mem_activity", NULL, "mem", "cgroup.mem_activity", title, "MB/s", 40400, update_every, RRDSET_TYPE_LINE);

1853 - }

1854 - rrddim_add(cg->st_mem_activity, "pgpgin", "in", sysconf(_SC_PAGESIZE), 1024 * 1024, RRDDIM_INCREMENTAL);

1855 - rrddim_add(cg->st_mem_activity, "pgpgout", "out", -sysconf(_SC_PAGESIZE), 1024 * 1024, RRDDIM_INCREMENTAL);

1954 + if(unlikely(!cg->st_mem_activity)) {

1955 + cg->st_mem_activity = rrdset_find_bytype(cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX), "mem_activity");

1956 + if(likely(!cg->st_mem_activity)) {

1957 + snprintfz(title, CHART_TITLE_MAX, "Memory Activity for cgroup %s", cg->chart_title);

1958 + cg->st_mem_activity = rrdset_create(type, "mem_activity", NULL, "mem", "cgroup.mem_activity", title, "MB/s", 40400, update_every, RRDSET_TYPE_LINE);

1959 }

1857 - else

1858 - rrdset_next(cg->st_mem_activity);

1859 -

1860 - rrddim_set(cg->st_mem_activity, "pgpgin", cg->memory.pgpgin);

1861 - rrddim_set(cg->st_mem_activity, "pgpgout", cg->memory.pgpgout);

1862 - rrdset_done(cg->st_mem_activity);

1960 + rrddim_add(cg->st_mem_activity, "pgpgin", "in", sysconf(_SC_PAGESIZE), 1024 * 1024, RRDDIM_INCREMENTAL);

1961 + rrddim_add(cg->st_mem_activity, "pgpgout", "out", -sysconf(_SC_PAGESIZE), 1024 * 1024, RRDDIM_INCREMENTAL);

1962 }

1963 + else

1964 + rrdset_next(cg->st_mem_activity);

1965

1865 - if(likely(cg->memory.pgfault || cg->memory.pgmajfault)) {

1866 - if(unlikely(!cg->st_pgfaults)) {

1867 - cg->st_pgfaults = rrdset_find_bytype(cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX), "pgfaults");

1868 - if(likely(!cg->st_pgfaults)) {

1869 - snprintfz(title, CHART_TITLE_MAX, "Memory Page Faults for cgroup %s", cg->chart_title);

1870 - cg->st_pgfaults = rrdset_create(type, "pgfaults", NULL, "mem", "cgroup.pgfaults", title, "MB/s", 40500, update_every, RRDSET_TYPE_LINE);

1871 - }

1872 - rrddim_add(cg->st_pgfaults, "pgfault", NULL, sysconf(_SC_PAGESIZE), 1024 * 1024, RRDDIM_INCREMENTAL);

1873 - rrddim_add(cg->st_pgfaults, "pgmajfault", "swap", -sysconf(_SC_PAGESIZE), 1024 * 1024, RRDDIM_INCREMENTAL);

1874 - }

1875 - else

1876 - rrdset_next(cg->st_pgfaults);

1966 + rrddim_set(cg->st_mem_activity, "pgpgin", cg->memory.pgpgin);

1967 + rrddim_set(cg->st_mem_activity, "pgpgout", cg->memory.pgpgout);

1968 + rrdset_done(cg->st_mem_activity);

1969

1878 - rrddim_set(cg->st_pgfaults, "pgfault", cg->memory.pgfault);

1879 - rrddim_set(cg->st_pgfaults, "pgmajfault", cg->memory.pgmajfault);

1880 - rrdset_done(cg->st_pgfaults);

1970 + if(unlikely(!cg->st_pgfaults)) {

1971 + cg->st_pgfaults = rrdset_find_bytype(cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX), "pgfaults");

1972 + if(likely(!cg->st_pgfaults)) {

1973 + snprintfz(title, CHART_TITLE_MAX, "Memory Page Faults for cgroup %s", cg->chart_title);

1974 + cg->st_pgfaults = rrdset_create(type, "pgfaults", NULL, "mem", "cgroup.pgfaults", title, "MB/s", 40500, update_every, RRDSET_TYPE_LINE);

1975 + }

1976 + rrddim_add(cg->st_pgfaults, "pgfault", NULL, sysconf(_SC_PAGESIZE), 1024 * 1024, RRDDIM_INCREMENTAL);

1977 + rrddim_add(cg->st_pgfaults, "pgmajfault", "swap", -sysconf(_SC_PAGESIZE), 1024 * 1024, RRDDIM_INCREMENTAL);

1978 }

1979 + else

1980 + rrdset_next(cg->st_pgfaults);

1981 +

1982 + rrddim_set(cg->st_pgfaults, "pgfault", cg->memory.pgfault);

1983 + rrddim_set(cg->st_pgfaults, "pgmajfault", cg->memory.pgmajfault);

1984 + rrdset_done(cg->st_pgfaults);

1985 }

1986

1884 - if(likely(cg->memory.usage_in_bytes_updated)) {

1987 + if(likely(cg->memory.usage_in_bytes_updated && cg->memory.enabled_usage == CONFIG_ONDEMAND_YES)) {

1988 if(unlikely(!cg->st_mem_usage)) {

1989 cg->st_mem_usage = rrdset_find_bytype(cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX), "mem_usage");

1990 if(likely(!cg->st_mem_usage)) {

@@ -1899,7 +2002,7 @@ void update_cgroup_charts(int update_every) {

2002 rrdset_done(cg->st_mem_usage);

2003 }

2004

1902 - if(likely(cg->memory.failcnt_updated && cg->memory.failcnt)) {

2005 + if(likely(cg->memory.failcnt_updated && cg->memory.enabled_failcnt == CONFIG_ONDEMAND_YES)) {

2006 if(unlikely(!cg->st_mem_failcnt)) {

2007 cg->st_mem_failcnt = rrdset_find_bytype(cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX), "mem_failcnt");

2008 if(likely(!cg->st_mem_failcnt)) {

@@ -1915,7 +2018,7 @@ void update_cgroup_charts(int update_every) {

2018 rrdset_done(cg->st_mem_failcnt);

2019 }

2020

1918 - if(likely(cg->io_service_bytes.updated && (cg->io_service_bytes.Read || cg->io_service_bytes.Write))) {

2021 + if(likely(cg->io_service_bytes.updated && cg->io_service_bytes.enabled == CONFIG_ONDEMAND_YES)) {

2022 if(unlikely(!cg->st_io)) {

2023 cg->st_io = rrdset_find_bytype(cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX), "io");

2024 if(likely(!cg->st_io)) {

@@ -1933,7 +2036,7 @@ void update_cgroup_charts(int update_every) {

2036 rrdset_done(cg->st_io);

2037 }

2038

1936 - if(likely(cg->io_serviced.updated && (cg->io_serviced.Read || cg->io_serviced.Write))) {

2039 + if(likely(cg->io_serviced.updated && cg->io_serviced.enabled == CONFIG_ONDEMAND_YES)) {

2040 if(unlikely(!cg->st_serviced_ops)) {

2041 cg->st_serviced_ops = rrdset_find_bytype(cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX), "serviced_ops");

2042 if(likely(!cg->st_serviced_ops)) {

@@ -1951,7 +2054,7 @@ void update_cgroup_charts(int update_every) {

2054 rrdset_done(cg->st_serviced_ops);

2055 }

2056

1954 - if(likely(cg->throttle_io_service_bytes.updated && (cg->throttle_io_service_bytes.Read || cg->throttle_io_service_bytes.Write))) {

2057 + if(likely(cg->throttle_io_service_bytes.updated && cg->throttle_io_service_bytes.enabled == CONFIG_ONDEMAND_YES)) {

2058 if(unlikely(!cg->st_throttle_io)) {

2059 cg->st_throttle_io = rrdset_find_bytype(cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX), "throttle_io");

2060 if(likely(!cg->st_throttle_io)) {

@@ -1969,7 +2072,7 @@ void update_cgroup_charts(int update_every) {

2072 rrdset_done(cg->st_throttle_io);

2073 }

2074

1972 - if(likely(cg->throttle_io_serviced.updated && (cg->throttle_io_serviced.Read || cg->throttle_io_serviced.Write))) {

2075 + if(likely(cg->throttle_io_serviced.updated && cg->throttle_io_serviced.enabled == CONFIG_ONDEMAND_YES)) {

2076 if(unlikely(!cg->st_throttle_serviced_ops)) {

2077 cg->st_throttle_serviced_ops = rrdset_find_bytype(cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX), "throttle_serviced_ops");

2078 if(likely(!cg->st_throttle_serviced_ops)) {

@@ -1987,7 +2090,7 @@ void update_cgroup_charts(int update_every) {

2090 rrdset_done(cg->st_throttle_serviced_ops);

2091 }

2092

1990 - if(likely(cg->io_queued.updated)) {

2093 + if(likely(cg->io_queued.updated && cg->io_queued.enabled == CONFIG_ONDEMAND_YES)) {

2094 if(unlikely(!cg->st_queued_ops)) {

2095 cg->st_queued_ops = rrdset_find_bytype(cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX), "queued_ops");

2096 if(likely(!cg->st_queued_ops)) {

@@ -2005,7 +2108,7 @@ void update_cgroup_charts(int update_every) {

2108 rrdset_done(cg->st_queued_ops);

2109 }

2110

2008 - if(likely(cg->io_merged.updated && (cg->io_merged.Read || cg->io_merged.Write))) {

2111 + if(likely(cg->io_merged.updated && cg->io_merged.enabled == CONFIG_ONDEMAND_YES)) {

2112 if(unlikely(!cg->st_merged_ops)) {

2113 cg->st_merged_ops = rrdset_find_bytype(cgroup_chart_type(type, cg->chart_id, RRD_ID_LENGTH_MAX), "merged_ops");

2114 if(likely(!cg->st_merged_ops)) {

finer control of cgroups aspects