proc_stat.c 42 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038
  1. // SPDX-License-Identifier: GPL-3.0-or-later
  2. #include "plugin_proc.h"
  3. #define PLUGIN_PROC_MODULE_STAT_NAME "/proc/stat"
  4. struct per_core_single_number_file {
  5. unsigned char found:1;
  6. const char *filename;
  7. int fd;
  8. collected_number value;
  9. RRDDIM *rd;
  10. };
  11. struct last_ticks {
  12. collected_number frequency;
  13. collected_number ticks;
  14. };
  15. // This is an extension of struct per_core_single_number_file at CPU_FREQ_INDEX.
  16. // Either scaling_cur_freq or time_in_state file is used at one time.
  17. struct per_core_time_in_state_file {
  18. const char *filename;
  19. procfile *ff;
  20. size_t last_ticks_len;
  21. struct last_ticks *last_ticks;
  22. };
  23. #define CORE_THROTTLE_COUNT_INDEX 0
  24. #define PACKAGE_THROTTLE_COUNT_INDEX 1
  25. #define CPU_FREQ_INDEX 2
  26. #define PER_CORE_FILES 3
  27. struct cpu_chart {
  28. const char *id;
  29. RRDSET *st;
  30. RRDDIM *rd_user;
  31. RRDDIM *rd_nice;
  32. RRDDIM *rd_system;
  33. RRDDIM *rd_idle;
  34. RRDDIM *rd_iowait;
  35. RRDDIM *rd_irq;
  36. RRDDIM *rd_softirq;
  37. RRDDIM *rd_steal;
  38. RRDDIM *rd_guest;
  39. RRDDIM *rd_guest_nice;
  40. struct per_core_single_number_file files[PER_CORE_FILES];
  41. struct per_core_time_in_state_file time_in_state_files;
  42. };
  43. static int keep_per_core_fds_open = CONFIG_BOOLEAN_YES;
  44. static int keep_cpuidle_fds_open = CONFIG_BOOLEAN_YES;
  45. static int read_per_core_files(struct cpu_chart *all_cpu_charts, size_t len, size_t index) {
  46. char buf[50 + 1];
  47. size_t x, files_read = 0, files_nonzero = 0;
  48. for(x = 0; x < len ; x++) {
  49. struct per_core_single_number_file *f = &all_cpu_charts[x].files[index];
  50. f->found = 0;
  51. if(unlikely(!f->filename))
  52. continue;
  53. if(unlikely(f->fd == -1)) {
  54. f->fd = open(f->filename, O_RDONLY);
  55. if (unlikely(f->fd == -1)) {
  56. error("Cannot open file '%s'", f->filename);
  57. continue;
  58. }
  59. }
  60. ssize_t ret = read(f->fd, buf, 50);
  61. if(unlikely(ret < 0)) {
  62. // cannot read that file
  63. error("Cannot read file '%s'", f->filename);
  64. close(f->fd);
  65. f->fd = -1;
  66. continue;
  67. }
  68. else {
  69. // successful read
  70. // terminate the buffer
  71. buf[ret] = '\0';
  72. if(unlikely(keep_per_core_fds_open != CONFIG_BOOLEAN_YES)) {
  73. close(f->fd);
  74. f->fd = -1;
  75. }
  76. else if(lseek(f->fd, 0, SEEK_SET) == -1) {
  77. error("Cannot seek in file '%s'", f->filename);
  78. close(f->fd);
  79. f->fd = -1;
  80. }
  81. }
  82. files_read++;
  83. f->found = 1;
  84. f->value = str2ll(buf, NULL);
  85. if(likely(f->value != 0))
  86. files_nonzero++;
  87. }
  88. if(files_read == 0)
  89. return -1;
  90. if(files_nonzero == 0)
  91. return 0;
  92. return (int)files_nonzero;
  93. }
  94. static int read_per_core_time_in_state_files(struct cpu_chart *all_cpu_charts, size_t len, size_t index) {
  95. size_t x, files_read = 0, files_nonzero = 0;
  96. for(x = 0; x < len ; x++) {
  97. struct per_core_single_number_file *f = &all_cpu_charts[x].files[index];
  98. struct per_core_time_in_state_file *tsf = &all_cpu_charts[x].time_in_state_files;
  99. f->found = 0;
  100. if(unlikely(!tsf->filename))
  101. continue;
  102. if(unlikely(!tsf->ff)) {
  103. tsf->ff = procfile_open(tsf->filename, " \t:", PROCFILE_FLAG_DEFAULT);
  104. if(unlikely(!tsf->ff))
  105. {
  106. error("Cannot open file '%s'", tsf->filename);
  107. continue;
  108. }
  109. }
  110. tsf->ff = procfile_readall(tsf->ff);
  111. if(unlikely(!tsf->ff)) {
  112. error("Cannot read file '%s'", tsf->filename);
  113. procfile_close(tsf->ff);
  114. tsf->ff = NULL;
  115. continue;
  116. }
  117. else {
  118. // successful read
  119. size_t lines = procfile_lines(tsf->ff), l;
  120. size_t words;
  121. unsigned long long total_ticks_since_last = 0, avg_freq = 0;
  122. // Check if there is at least one frequency in time_in_state
  123. if (procfile_word(tsf->ff, 0)[0] == '\0') {
  124. if(unlikely(keep_per_core_fds_open != CONFIG_BOOLEAN_YES)) {
  125. procfile_close(tsf->ff);
  126. tsf->ff = NULL;
  127. }
  128. // TODO: Is there a better way to avoid spikes than calculating the average over
  129. // the whole period under schedutil governor?
  130. // freez(tsf->last_ticks);
  131. // tsf->last_ticks = NULL;
  132. // tsf->last_ticks_len = 0;
  133. continue;
  134. }
  135. if (unlikely(tsf->last_ticks_len < lines || tsf->last_ticks == NULL)) {
  136. tsf->last_ticks = reallocz(tsf->last_ticks, sizeof(struct last_ticks) * lines);
  137. memset(tsf->last_ticks, 0, sizeof(struct last_ticks) * lines);
  138. tsf->last_ticks_len = lines;
  139. }
  140. f->value = 0;
  141. for(l = 0; l < lines - 1 ;l++) {
  142. unsigned long long frequency = 0, ticks = 0, ticks_since_last = 0;
  143. words = procfile_linewords(tsf->ff, l);
  144. if(unlikely(words < 2)) {
  145. error("Cannot read time_in_state line. Expected 2 params, read %zu.", words);
  146. continue;
  147. }
  148. frequency = str2ull(procfile_lineword(tsf->ff, l, 0));
  149. ticks = str2ull(procfile_lineword(tsf->ff, l, 1));
  150. // It is assumed that frequencies are static and sorted
  151. ticks_since_last = ticks - tsf->last_ticks[l].ticks;
  152. tsf->last_ticks[l].frequency = frequency;
  153. tsf->last_ticks[l].ticks = ticks;
  154. total_ticks_since_last += ticks_since_last;
  155. avg_freq += frequency * ticks_since_last;
  156. }
  157. if (likely(total_ticks_since_last)) {
  158. avg_freq /= total_ticks_since_last;
  159. f->value = avg_freq;
  160. }
  161. if(unlikely(keep_per_core_fds_open != CONFIG_BOOLEAN_YES)) {
  162. procfile_close(tsf->ff);
  163. tsf->ff = NULL;
  164. }
  165. }
  166. files_read++;
  167. f->found = 1;
  168. if(likely(f->value != 0))
  169. files_nonzero++;
  170. }
  171. if(unlikely(files_read == 0))
  172. return -1;
  173. if(unlikely(files_nonzero == 0))
  174. return 0;
  175. return (int)files_nonzero;
  176. }
  177. static void chart_per_core_files(struct cpu_chart *all_cpu_charts, size_t len, size_t index, RRDSET *st, collected_number multiplier, collected_number divisor, RRD_ALGORITHM algorithm) {
  178. size_t x;
  179. for(x = 0; x < len ; x++) {
  180. struct per_core_single_number_file *f = &all_cpu_charts[x].files[index];
  181. if(unlikely(!f->found))
  182. continue;
  183. if(unlikely(!f->rd))
  184. f->rd = rrddim_add(st, all_cpu_charts[x].id, NULL, multiplier, divisor, algorithm);
  185. rrddim_set_by_pointer(st, f->rd, f->value);
  186. }
  187. }
  188. struct cpuidle_state {
  189. char *name;
  190. char *time_filename;
  191. int time_fd;
  192. collected_number value;
  193. RRDDIM *rd;
  194. };
  195. struct per_core_cpuidle_chart {
  196. RRDSET *st;
  197. RRDDIM *active_time_rd;
  198. collected_number active_time;
  199. collected_number last_active_time;
  200. struct cpuidle_state *cpuidle_state;
  201. size_t cpuidle_state_len;
  202. int rescan_cpu_states;
  203. };
  204. static void* wake_cpu_thread(void* core) {
  205. pthread_t thread;
  206. cpu_set_t cpu_set;
  207. static size_t cpu_wakeups = 0;
  208. CPU_ZERO(&cpu_set);
  209. CPU_SET(*(int*)core, &cpu_set);
  210. thread = pthread_self();
  211. if(unlikely(pthread_setaffinity_np(thread, sizeof(cpu_set_t), &cpu_set)))
  212. error("Cannot set CPU affinity");
  213. // Make the CPU core do something
  214. cpu_wakeups++;
  215. return 0;
  216. }
  217. static int read_schedstat(char* schedstat_filename, struct per_core_cpuidle_chart **cpuidle_charts_address, size_t cores_found) {
  218. static size_t cpuidle_charts_len = 0;
  219. static procfile *ff = NULL;
  220. struct per_core_cpuidle_chart *cpuidle_charts = *cpuidle_charts_address;
  221. if(unlikely(!ff)) {
  222. ff = procfile_open(schedstat_filename, " \t:", PROCFILE_FLAG_DEFAULT);
  223. if(unlikely(!ff)) return 1;
  224. }
  225. ff = procfile_readall(ff);
  226. if(unlikely(!ff)) return 1;
  227. size_t lines = procfile_lines(ff), l;
  228. size_t words;
  229. if(unlikely(cpuidle_charts_len < cores_found)) {
  230. cpuidle_charts = reallocz(cpuidle_charts, sizeof(struct per_core_cpuidle_chart) * cores_found);
  231. *cpuidle_charts_address = cpuidle_charts;
  232. memset(cpuidle_charts + cpuidle_charts_len, 0, sizeof(struct per_core_cpuidle_chart) * (cores_found - cpuidle_charts_len));
  233. cpuidle_charts_len = cores_found;
  234. }
  235. for(l = 0; l < lines ;l++) {
  236. char *row_key = procfile_lineword(ff, l, 0);
  237. // faster strncmp(row_key, "cpu", 3) == 0
  238. if(likely(row_key[0] == 'c' && row_key[1] == 'p' && row_key[2] == 'u')) {
  239. words = procfile_linewords(ff, l);
  240. if(unlikely(words < 10)) {
  241. error("Cannot read /proc/schedstat cpu line. Expected 9 params, read %zu.", words);
  242. return 1;
  243. }
  244. size_t core = str2ul(&row_key[3]);
  245. if(unlikely(core >= cores_found)) {
  246. error("Core %zu found but no more than %zu cores were expected.", core, cores_found);
  247. return 1;
  248. }
  249. cpuidle_charts[core].active_time = str2ull(procfile_lineword(ff, l, 7)) / 1000;
  250. }
  251. }
  252. return 0;
  253. }
  254. static int read_one_state(char *buf, const char *filename, int *fd) {
  255. ssize_t ret = read(*fd, buf, 50);
  256. if(unlikely(ret <= 0)) {
  257. // cannot read that file
  258. error("Cannot read file '%s'", filename);
  259. close(*fd);
  260. *fd = -1;
  261. return 0;
  262. }
  263. else {
  264. // successful read
  265. // terminate the buffer
  266. buf[ret - 1] = '\0';
  267. if(unlikely(keep_cpuidle_fds_open != CONFIG_BOOLEAN_YES)) {
  268. close(*fd);
  269. *fd = -1;
  270. }
  271. else if(lseek(*fd, 0, SEEK_SET) == -1) {
  272. error("Cannot seek in file '%s'", filename);
  273. close(*fd);
  274. *fd = -1;
  275. }
  276. }
  277. return 1;
  278. }
  279. static int read_cpuidle_states(char *cpuidle_name_filename , char *cpuidle_time_filename, struct per_core_cpuidle_chart *cpuidle_charts, size_t core) {
  280. char filename[FILENAME_MAX + 1];
  281. static char next_state_filename[FILENAME_MAX + 1];
  282. struct stat stbuf;
  283. struct per_core_cpuidle_chart *cc = &cpuidle_charts[core];
  284. size_t state;
  285. if(unlikely(!cc->cpuidle_state_len || cc->rescan_cpu_states)) {
  286. int state_file_found = 1; // check at least one state
  287. if(cc->cpuidle_state_len) {
  288. for(state = 0; state < cc->cpuidle_state_len; state++) {
  289. freez(cc->cpuidle_state[state].name);
  290. freez(cc->cpuidle_state[state].time_filename);
  291. close(cc->cpuidle_state[state].time_fd);
  292. cc->cpuidle_state[state].time_fd = -1;
  293. }
  294. freez(cc->cpuidle_state);
  295. cc->cpuidle_state = NULL;
  296. cc->cpuidle_state_len = 0;
  297. cc->active_time_rd = NULL;
  298. cc->st = NULL;
  299. }
  300. while(likely(state_file_found)) {
  301. snprintfz(filename, FILENAME_MAX, cpuidle_name_filename, core, cc->cpuidle_state_len);
  302. if (stat(filename, &stbuf) == 0)
  303. cc->cpuidle_state_len++;
  304. else
  305. state_file_found = 0;
  306. }
  307. snprintfz(next_state_filename, FILENAME_MAX, cpuidle_name_filename, core, cc->cpuidle_state_len);
  308. cc->cpuidle_state = callocz(cc->cpuidle_state_len, sizeof(struct cpuidle_state));
  309. memset(cc->cpuidle_state, 0, sizeof(struct cpuidle_state) * cc->cpuidle_state_len);
  310. for(state = 0; state < cc->cpuidle_state_len; state++) {
  311. char name_buf[50 + 1];
  312. snprintfz(filename, FILENAME_MAX, cpuidle_name_filename, core, state);
  313. int fd = open(filename, O_RDONLY, 0666);
  314. if(unlikely(fd == -1)) {
  315. error("Cannot open file '%s'", filename);
  316. cc->rescan_cpu_states = 1;
  317. return 1;
  318. }
  319. ssize_t r = read(fd, name_buf, 50);
  320. if(unlikely(r < 1)) {
  321. error("Cannot read file '%s'", filename);
  322. close(fd);
  323. cc->rescan_cpu_states = 1;
  324. return 1;
  325. }
  326. name_buf[r - 1] = '\0'; // erase extra character
  327. cc->cpuidle_state[state].name = strdupz(name_buf);
  328. close(fd);
  329. snprintfz(filename, FILENAME_MAX, cpuidle_time_filename, core, state);
  330. cc->cpuidle_state[state].time_filename = strdupz(filename);
  331. cc->cpuidle_state[state].time_fd = -1;
  332. }
  333. cc->rescan_cpu_states = 0;
  334. }
  335. for(state = 0; state < cc->cpuidle_state_len; state++) {
  336. struct cpuidle_state *cs = &cc->cpuidle_state[state];
  337. if(unlikely(cs->time_fd == -1)) {
  338. cs->time_fd = open(cs->time_filename, O_RDONLY);
  339. if (unlikely(cs->time_fd == -1)) {
  340. error("Cannot open file '%s'", cs->time_filename);
  341. cc->rescan_cpu_states = 1;
  342. return 1;
  343. }
  344. }
  345. char time_buf[50 + 1];
  346. if(likely(read_one_state(time_buf, cs->time_filename, &cs->time_fd))) {
  347. cs->value = str2ll(time_buf, NULL);
  348. }
  349. else {
  350. cc->rescan_cpu_states = 1;
  351. return 1;
  352. }
  353. }
  354. // check if the number of states was increased
  355. if(unlikely(stat(next_state_filename, &stbuf) == 0)) {
  356. cc->rescan_cpu_states = 1;
  357. return 1;
  358. }
  359. return 0;
  360. }
  361. int do_proc_stat(int update_every, usec_t dt) {
  362. (void)dt;
  363. static struct cpu_chart *all_cpu_charts = NULL;
  364. static size_t all_cpu_charts_size = 0;
  365. static procfile *ff = NULL;
  366. static int do_cpu = -1, do_cpu_cores = -1, do_interrupts = -1, do_context = -1, do_forks = -1, do_processes = -1,
  367. do_core_throttle_count = -1, do_package_throttle_count = -1, do_cpu_freq = -1, do_cpuidle = -1;
  368. static uint32_t hash_intr, hash_ctxt, hash_processes, hash_procs_running, hash_procs_blocked;
  369. static char *core_throttle_count_filename = NULL, *package_throttle_count_filename = NULL, *scaling_cur_freq_filename = NULL,
  370. *time_in_state_filename = NULL, *schedstat_filename = NULL, *cpuidle_name_filename = NULL, *cpuidle_time_filename = NULL;
  371. static RRDVAR *cpus_var = NULL;
  372. static int accurate_freq_avail = 0, accurate_freq_is_used = 0;
  373. size_t cores_found = (size_t)processors;
  374. if(unlikely(do_cpu == -1)) {
  375. do_cpu = config_get_boolean("plugin:proc:/proc/stat", "cpu utilization", CONFIG_BOOLEAN_YES);
  376. do_cpu_cores = config_get_boolean("plugin:proc:/proc/stat", "per cpu core utilization", CONFIG_BOOLEAN_YES);
  377. do_interrupts = config_get_boolean("plugin:proc:/proc/stat", "cpu interrupts", CONFIG_BOOLEAN_YES);
  378. do_context = config_get_boolean("plugin:proc:/proc/stat", "context switches", CONFIG_BOOLEAN_YES);
  379. do_forks = config_get_boolean("plugin:proc:/proc/stat", "processes started", CONFIG_BOOLEAN_YES);
  380. do_processes = config_get_boolean("plugin:proc:/proc/stat", "processes running", CONFIG_BOOLEAN_YES);
  381. // give sane defaults based on the number of processors
  382. if(unlikely(processors > 50)) {
  383. // the system has too many processors
  384. keep_per_core_fds_open = CONFIG_BOOLEAN_NO;
  385. do_core_throttle_count = CONFIG_BOOLEAN_NO;
  386. do_package_throttle_count = CONFIG_BOOLEAN_NO;
  387. do_cpu_freq = CONFIG_BOOLEAN_NO;
  388. do_cpuidle = CONFIG_BOOLEAN_NO;
  389. }
  390. else {
  391. // the system has a reasonable number of processors
  392. keep_per_core_fds_open = CONFIG_BOOLEAN_YES;
  393. do_core_throttle_count = CONFIG_BOOLEAN_AUTO;
  394. do_package_throttle_count = CONFIG_BOOLEAN_NO;
  395. do_cpu_freq = CONFIG_BOOLEAN_YES;
  396. do_cpuidle = CONFIG_BOOLEAN_YES;
  397. }
  398. if(unlikely(processors > 24)) {
  399. // the system has too many processors
  400. keep_cpuidle_fds_open = CONFIG_BOOLEAN_NO;
  401. }
  402. else {
  403. // the system has a reasonable number of processors
  404. keep_cpuidle_fds_open = CONFIG_BOOLEAN_YES;
  405. }
  406. keep_per_core_fds_open = config_get_boolean("plugin:proc:/proc/stat", "keep per core files open", keep_per_core_fds_open);
  407. keep_cpuidle_fds_open = config_get_boolean("plugin:proc:/proc/stat", "keep cpuidle files open", keep_cpuidle_fds_open);
  408. do_core_throttle_count = config_get_boolean_ondemand("plugin:proc:/proc/stat", "core_throttle_count", do_core_throttle_count);
  409. do_package_throttle_count = config_get_boolean_ondemand("plugin:proc:/proc/stat", "package_throttle_count", do_package_throttle_count);
  410. do_cpu_freq = config_get_boolean_ondemand("plugin:proc:/proc/stat", "cpu frequency", do_cpu_freq);
  411. do_cpuidle = config_get_boolean_ondemand("plugin:proc:/proc/stat", "cpu idle states", do_cpuidle);
  412. hash_intr = simple_hash("intr");
  413. hash_ctxt = simple_hash("ctxt");
  414. hash_processes = simple_hash("processes");
  415. hash_procs_running = simple_hash("procs_running");
  416. hash_procs_blocked = simple_hash("procs_blocked");
  417. char filename[FILENAME_MAX + 1];
  418. snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/devices/system/cpu/%s/thermal_throttle/core_throttle_count");
  419. core_throttle_count_filename = config_get("plugin:proc:/proc/stat", "core_throttle_count filename to monitor", filename);
  420. snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/devices/system/cpu/%s/thermal_throttle/package_throttle_count");
  421. package_throttle_count_filename = config_get("plugin:proc:/proc/stat", "package_throttle_count filename to monitor", filename);
  422. snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/devices/system/cpu/%s/cpufreq/scaling_cur_freq");
  423. scaling_cur_freq_filename = config_get("plugin:proc:/proc/stat", "scaling_cur_freq filename to monitor", filename);
  424. snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/devices/system/cpu/%s/cpufreq/stats/time_in_state");
  425. time_in_state_filename = config_get("plugin:proc:/proc/stat", "time_in_state filename to monitor", filename);
  426. snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/proc/schedstat");
  427. schedstat_filename = config_get("plugin:proc:/proc/stat", "schedstat filename to monitor", filename);
  428. snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/devices/system/cpu/cpu%zu/cpuidle/state%zu/name");
  429. cpuidle_name_filename = config_get("plugin:proc:/proc/stat", "cpuidle name filename to monitor", filename);
  430. snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/sys/devices/system/cpu/cpu%zu/cpuidle/state%zu/time");
  431. cpuidle_time_filename = config_get("plugin:proc:/proc/stat", "cpuidle time filename to monitor", filename);
  432. }
  433. if(unlikely(!ff)) {
  434. char filename[FILENAME_MAX + 1];
  435. snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/proc/stat");
  436. ff = procfile_open(config_get("plugin:proc:/proc/stat", "filename to monitor", filename), " \t:", PROCFILE_FLAG_DEFAULT);
  437. if(unlikely(!ff)) return 1;
  438. }
  439. ff = procfile_readall(ff);
  440. if(unlikely(!ff)) return 0; // we return 0, so that we will retry to open it next time
  441. size_t lines = procfile_lines(ff), l;
  442. size_t words;
  443. unsigned long long processes = 0, running = 0 , blocked = 0;
  444. for(l = 0; l < lines ;l++) {
  445. char *row_key = procfile_lineword(ff, l, 0);
  446. uint32_t hash = simple_hash(row_key);
  447. // faster strncmp(row_key, "cpu", 3) == 0
  448. if(likely(row_key[0] == 'c' && row_key[1] == 'p' && row_key[2] == 'u')) {
  449. words = procfile_linewords(ff, l);
  450. if(unlikely(words < 9)) {
  451. error("Cannot read /proc/stat cpu line. Expected 9 params, read %zu.", words);
  452. continue;
  453. }
  454. size_t core = (row_key[3] == '\0') ? 0 : str2ul(&row_key[3]) + 1;
  455. if(likely(core > 0)) cores_found = core;
  456. if(likely((core == 0 && do_cpu) || (core > 0 && do_cpu_cores))) {
  457. char *id;
  458. unsigned long long user = 0, nice = 0, system = 0, idle = 0, iowait = 0, irq = 0, softirq = 0, steal = 0, guest = 0, guest_nice = 0;
  459. id = row_key;
  460. user = str2ull(procfile_lineword(ff, l, 1));
  461. nice = str2ull(procfile_lineword(ff, l, 2));
  462. system = str2ull(procfile_lineword(ff, l, 3));
  463. idle = str2ull(procfile_lineword(ff, l, 4));
  464. iowait = str2ull(procfile_lineword(ff, l, 5));
  465. irq = str2ull(procfile_lineword(ff, l, 6));
  466. softirq = str2ull(procfile_lineword(ff, l, 7));
  467. steal = str2ull(procfile_lineword(ff, l, 8));
  468. guest = str2ull(procfile_lineword(ff, l, 9));
  469. user -= guest;
  470. guest_nice = str2ull(procfile_lineword(ff, l, 10));
  471. nice -= guest_nice;
  472. char *title, *type, *context, *family;
  473. long priority;
  474. if(unlikely(core >= all_cpu_charts_size)) {
  475. size_t old_cpu_charts_size = all_cpu_charts_size;
  476. all_cpu_charts_size = core + 1;
  477. all_cpu_charts = reallocz(all_cpu_charts, sizeof(struct cpu_chart) * all_cpu_charts_size);
  478. memset(&all_cpu_charts[old_cpu_charts_size], 0, sizeof(struct cpu_chart) * (all_cpu_charts_size - old_cpu_charts_size));
  479. }
  480. struct cpu_chart *cpu_chart = &all_cpu_charts[core];
  481. if(unlikely(!cpu_chart->st)) {
  482. cpu_chart->id = strdupz(id);
  483. if(unlikely(core == 0)) {
  484. title = "Total CPU utilization";
  485. type = "system";
  486. context = "system.cpu";
  487. family = id;
  488. priority = NETDATA_CHART_PRIO_SYSTEM_CPU;
  489. }
  490. else {
  491. title = "Core utilization";
  492. type = "cpu";
  493. context = "cpu.cpu";
  494. family = "utilization";
  495. priority = NETDATA_CHART_PRIO_CPU_PER_CORE;
  496. char filename[FILENAME_MAX + 1];
  497. struct stat stbuf;
  498. if(do_core_throttle_count != CONFIG_BOOLEAN_NO) {
  499. snprintfz(filename, FILENAME_MAX, core_throttle_count_filename, id);
  500. if (stat(filename, &stbuf) == 0) {
  501. cpu_chart->files[CORE_THROTTLE_COUNT_INDEX].filename = strdupz(filename);
  502. cpu_chart->files[CORE_THROTTLE_COUNT_INDEX].fd = -1;
  503. do_core_throttle_count = CONFIG_BOOLEAN_YES;
  504. }
  505. }
  506. if(do_package_throttle_count != CONFIG_BOOLEAN_NO) {
  507. snprintfz(filename, FILENAME_MAX, package_throttle_count_filename, id);
  508. if (stat(filename, &stbuf) == 0) {
  509. cpu_chart->files[PACKAGE_THROTTLE_COUNT_INDEX].filename = strdupz(filename);
  510. cpu_chart->files[PACKAGE_THROTTLE_COUNT_INDEX].fd = -1;
  511. do_package_throttle_count = CONFIG_BOOLEAN_YES;
  512. }
  513. }
  514. if(do_cpu_freq != CONFIG_BOOLEAN_NO) {
  515. snprintfz(filename, FILENAME_MAX, scaling_cur_freq_filename, id);
  516. if (stat(filename, &stbuf) == 0) {
  517. cpu_chart->files[CPU_FREQ_INDEX].filename = strdupz(filename);
  518. cpu_chart->files[CPU_FREQ_INDEX].fd = -1;
  519. do_cpu_freq = CONFIG_BOOLEAN_YES;
  520. }
  521. snprintfz(filename, FILENAME_MAX, time_in_state_filename, id);
  522. if (stat(filename, &stbuf) == 0) {
  523. cpu_chart->time_in_state_files.filename = strdupz(filename);
  524. cpu_chart->time_in_state_files.ff = NULL;
  525. do_cpu_freq = CONFIG_BOOLEAN_YES;
  526. accurate_freq_avail = 1;
  527. }
  528. }
  529. }
  530. cpu_chart->st = rrdset_create_localhost(
  531. type
  532. , id
  533. , NULL
  534. , family
  535. , context
  536. , title
  537. , "percentage"
  538. , PLUGIN_PROC_NAME
  539. , PLUGIN_PROC_MODULE_STAT_NAME
  540. , priority + core
  541. , update_every
  542. , RRDSET_TYPE_STACKED
  543. );
  544. long multiplier = 1;
  545. long divisor = 1; // sysconf(_SC_CLK_TCK);
  546. cpu_chart->rd_guest_nice = rrddim_add(cpu_chart->st, "guest_nice", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
  547. cpu_chart->rd_guest = rrddim_add(cpu_chart->st, "guest", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
  548. cpu_chart->rd_steal = rrddim_add(cpu_chart->st, "steal", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
  549. cpu_chart->rd_softirq = rrddim_add(cpu_chart->st, "softirq", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
  550. cpu_chart->rd_irq = rrddim_add(cpu_chart->st, "irq", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
  551. cpu_chart->rd_user = rrddim_add(cpu_chart->st, "user", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
  552. cpu_chart->rd_system = rrddim_add(cpu_chart->st, "system", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
  553. cpu_chart->rd_nice = rrddim_add(cpu_chart->st, "nice", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
  554. cpu_chart->rd_iowait = rrddim_add(cpu_chart->st, "iowait", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
  555. cpu_chart->rd_idle = rrddim_add(cpu_chart->st, "idle", NULL, multiplier, divisor, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
  556. rrddim_hide(cpu_chart->st, "idle");
  557. if(unlikely(core == 0 && cpus_var == NULL))
  558. cpus_var = rrdvar_custom_host_variable_create(localhost, "active_processors");
  559. }
  560. else rrdset_next(cpu_chart->st);
  561. rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_user, user);
  562. rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_nice, nice);
  563. rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_system, system);
  564. rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_idle, idle);
  565. rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_iowait, iowait);
  566. rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_irq, irq);
  567. rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_softirq, softirq);
  568. rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_steal, steal);
  569. rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_guest, guest);
  570. rrddim_set_by_pointer(cpu_chart->st, cpu_chart->rd_guest_nice, guest_nice);
  571. rrdset_done(cpu_chart->st);
  572. }
  573. }
  574. else if(unlikely(hash == hash_intr && strcmp(row_key, "intr") == 0)) {
  575. if(likely(do_interrupts)) {
  576. static RRDSET *st_intr = NULL;
  577. static RRDDIM *rd_interrupts = NULL;
  578. unsigned long long value = str2ull(procfile_lineword(ff, l, 1));
  579. if(unlikely(!st_intr)) {
  580. st_intr = rrdset_create_localhost(
  581. "system"
  582. , "intr"
  583. , NULL
  584. , "interrupts"
  585. , NULL
  586. , "CPU Interrupts"
  587. , "interrupts/s"
  588. , PLUGIN_PROC_NAME
  589. , PLUGIN_PROC_MODULE_STAT_NAME
  590. , NETDATA_CHART_PRIO_SYSTEM_INTR
  591. , update_every
  592. , RRDSET_TYPE_LINE
  593. );
  594. rrdset_flag_set(st_intr, RRDSET_FLAG_DETAIL);
  595. rd_interrupts = rrddim_add(st_intr, "interrupts", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  596. }
  597. else rrdset_next(st_intr);
  598. rrddim_set_by_pointer(st_intr, rd_interrupts, value);
  599. rrdset_done(st_intr);
  600. }
  601. }
  602. else if(unlikely(hash == hash_ctxt && strcmp(row_key, "ctxt") == 0)) {
  603. if(likely(do_context)) {
  604. static RRDSET *st_ctxt = NULL;
  605. static RRDDIM *rd_switches = NULL;
  606. unsigned long long value = str2ull(procfile_lineword(ff, l, 1));
  607. if(unlikely(!st_ctxt)) {
  608. st_ctxt = rrdset_create_localhost(
  609. "system"
  610. , "ctxt"
  611. , NULL
  612. , "processes"
  613. , NULL
  614. , "CPU Context Switches"
  615. , "context switches/s"
  616. , PLUGIN_PROC_NAME
  617. , PLUGIN_PROC_MODULE_STAT_NAME
  618. , NETDATA_CHART_PRIO_SYSTEM_CTXT
  619. , update_every
  620. , RRDSET_TYPE_LINE
  621. );
  622. rd_switches = rrddim_add(st_ctxt, "switches", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  623. }
  624. else rrdset_next(st_ctxt);
  625. rrddim_set_by_pointer(st_ctxt, rd_switches, value);
  626. rrdset_done(st_ctxt);
  627. }
  628. }
  629. else if(unlikely(hash == hash_processes && !processes && strcmp(row_key, "processes") == 0)) {
  630. processes = str2ull(procfile_lineword(ff, l, 1));
  631. }
  632. else if(unlikely(hash == hash_procs_running && !running && strcmp(row_key, "procs_running") == 0)) {
  633. running = str2ull(procfile_lineword(ff, l, 1));
  634. }
  635. else if(unlikely(hash == hash_procs_blocked && !blocked && strcmp(row_key, "procs_blocked") == 0)) {
  636. blocked = str2ull(procfile_lineword(ff, l, 1));
  637. }
  638. }
  639. // --------------------------------------------------------------------
  640. if(likely(do_forks)) {
  641. static RRDSET *st_forks = NULL;
  642. static RRDDIM *rd_started = NULL;
  643. if(unlikely(!st_forks)) {
  644. st_forks = rrdset_create_localhost(
  645. "system"
  646. , "forks"
  647. , NULL
  648. , "processes"
  649. , NULL
  650. , "Started Processes"
  651. , "processes/s"
  652. , PLUGIN_PROC_NAME
  653. , PLUGIN_PROC_MODULE_STAT_NAME
  654. , NETDATA_CHART_PRIO_SYSTEM_FORKS
  655. , update_every
  656. , RRDSET_TYPE_LINE
  657. );
  658. rrdset_flag_set(st_forks, RRDSET_FLAG_DETAIL);
  659. rd_started = rrddim_add(st_forks, "started", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  660. }
  661. else rrdset_next(st_forks);
  662. rrddim_set_by_pointer(st_forks, rd_started, processes);
  663. rrdset_done(st_forks);
  664. }
  665. // --------------------------------------------------------------------
  666. if(likely(do_processes)) {
  667. static RRDSET *st_processes = NULL;
  668. static RRDDIM *rd_running = NULL;
  669. static RRDDIM *rd_blocked = NULL;
  670. if(unlikely(!st_processes)) {
  671. st_processes = rrdset_create_localhost(
  672. "system"
  673. , "processes"
  674. , NULL
  675. , "processes"
  676. , NULL
  677. , "System Processes"
  678. , "processes"
  679. , PLUGIN_PROC_NAME
  680. , PLUGIN_PROC_MODULE_STAT_NAME
  681. , NETDATA_CHART_PRIO_SYSTEM_PROCESSES
  682. , update_every
  683. , RRDSET_TYPE_LINE
  684. );
  685. rd_running = rrddim_add(st_processes, "running", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
  686. rd_blocked = rrddim_add(st_processes, "blocked", NULL, -1, 1, RRD_ALGORITHM_ABSOLUTE);
  687. }
  688. else rrdset_next(st_processes);
  689. rrddim_set_by_pointer(st_processes, rd_running, running);
  690. rrddim_set_by_pointer(st_processes, rd_blocked, blocked);
  691. rrdset_done(st_processes);
  692. }
  693. if(likely(all_cpu_charts_size > 1)) {
  694. if(likely(do_core_throttle_count != CONFIG_BOOLEAN_NO)) {
  695. int r = read_per_core_files(&all_cpu_charts[1], all_cpu_charts_size - 1, CORE_THROTTLE_COUNT_INDEX);
  696. if(likely(r != -1 && (do_core_throttle_count == CONFIG_BOOLEAN_YES || r > 0))) {
  697. do_core_throttle_count = CONFIG_BOOLEAN_YES;
  698. static RRDSET *st_core_throttle_count = NULL;
  699. if (unlikely(!st_core_throttle_count))
  700. st_core_throttle_count = rrdset_create_localhost(
  701. "cpu"
  702. , "core_throttling"
  703. , NULL
  704. , "throttling"
  705. , "cpu.core_throttling"
  706. , "Core Thermal Throttling Events"
  707. , "events/s"
  708. , PLUGIN_PROC_NAME
  709. , PLUGIN_PROC_MODULE_STAT_NAME
  710. , NETDATA_CHART_PRIO_CORE_THROTTLING
  711. , update_every
  712. , RRDSET_TYPE_LINE
  713. );
  714. else
  715. rrdset_next(st_core_throttle_count);
  716. chart_per_core_files(&all_cpu_charts[1], all_cpu_charts_size - 1, CORE_THROTTLE_COUNT_INDEX, st_core_throttle_count, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  717. rrdset_done(st_core_throttle_count);
  718. }
  719. }
  720. if(likely(do_package_throttle_count != CONFIG_BOOLEAN_NO)) {
  721. int r = read_per_core_files(&all_cpu_charts[1], all_cpu_charts_size - 1, PACKAGE_THROTTLE_COUNT_INDEX);
  722. if(likely(r != -1 && (do_package_throttle_count == CONFIG_BOOLEAN_YES || r > 0))) {
  723. do_package_throttle_count = CONFIG_BOOLEAN_YES;
  724. static RRDSET *st_package_throttle_count = NULL;
  725. if(unlikely(!st_package_throttle_count))
  726. st_package_throttle_count = rrdset_create_localhost(
  727. "cpu"
  728. , "package_throttling"
  729. , NULL
  730. , "throttling"
  731. , "cpu.package_throttling"
  732. , "Package Thermal Throttling Events"
  733. , "events/s"
  734. , PLUGIN_PROC_NAME
  735. , PLUGIN_PROC_MODULE_STAT_NAME
  736. , NETDATA_CHART_PRIO_PACKAGE_THROTTLING
  737. , update_every
  738. , RRDSET_TYPE_LINE
  739. );
  740. else
  741. rrdset_next(st_package_throttle_count);
  742. chart_per_core_files(&all_cpu_charts[1], all_cpu_charts_size - 1, PACKAGE_THROTTLE_COUNT_INDEX, st_package_throttle_count, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  743. rrdset_done(st_package_throttle_count);
  744. }
  745. }
  746. if(likely(do_cpu_freq != CONFIG_BOOLEAN_NO)) {
  747. char filename[FILENAME_MAX + 1];
  748. int r = 0;
  749. if (accurate_freq_avail) {
  750. r = read_per_core_time_in_state_files(&all_cpu_charts[1], all_cpu_charts_size - 1, CPU_FREQ_INDEX);
  751. if(r > 0 && !accurate_freq_is_used) {
  752. accurate_freq_is_used = 1;
  753. snprintfz(filename, FILENAME_MAX, time_in_state_filename, "cpu*");
  754. info("cpufreq is using %s", filename);
  755. }
  756. }
  757. if (r < 1) {
  758. r = read_per_core_files(&all_cpu_charts[1], all_cpu_charts_size - 1, CPU_FREQ_INDEX);
  759. if(accurate_freq_is_used) {
  760. accurate_freq_is_used = 0;
  761. snprintfz(filename, FILENAME_MAX, scaling_cur_freq_filename, "cpu*");
  762. info("cpufreq fell back to %s", filename);
  763. }
  764. }
  765. if(likely(r != -1 && (do_cpu_freq == CONFIG_BOOLEAN_YES || r > 0))) {
  766. do_cpu_freq = CONFIG_BOOLEAN_YES;
  767. static RRDSET *st_scaling_cur_freq = NULL;
  768. if(unlikely(!st_scaling_cur_freq))
  769. st_scaling_cur_freq = rrdset_create_localhost(
  770. "cpu"
  771. , "cpufreq"
  772. , NULL
  773. , "cpufreq"
  774. , "cpufreq.cpufreq"
  775. , "Current CPU Frequency"
  776. , "MHz"
  777. , PLUGIN_PROC_NAME
  778. , PLUGIN_PROC_MODULE_STAT_NAME
  779. , NETDATA_CHART_PRIO_CPUFREQ_SCALING_CUR_FREQ
  780. , update_every
  781. , RRDSET_TYPE_LINE
  782. );
  783. else
  784. rrdset_next(st_scaling_cur_freq);
  785. chart_per_core_files(&all_cpu_charts[1], all_cpu_charts_size - 1, CPU_FREQ_INDEX, st_scaling_cur_freq, 1, 1000, RRD_ALGORITHM_ABSOLUTE);
  786. rrdset_done(st_scaling_cur_freq);
  787. }
  788. }
  789. }
  790. // --------------------------------------------------------------------
  791. static struct per_core_cpuidle_chart *cpuidle_charts = NULL;
  792. if(likely(do_cpuidle != CONFIG_BOOLEAN_NO && !read_schedstat(schedstat_filename, &cpuidle_charts, cores_found))) {
  793. int cpu_states_updated = 0;
  794. size_t core, state;
  795. // proc.plugin runs on Linux systems only. Multi-platform compatibility is not needed here,
  796. // so bare pthread functions are used to avoid unneeded overheads.
  797. for(core = 0; core < cores_found; core++) {
  798. if(unlikely(!(cpuidle_charts[core].active_time - cpuidle_charts[core].last_active_time))) {
  799. pthread_t thread;
  800. if(unlikely(pthread_create(&thread, NULL, wake_cpu_thread, (void *)&core)))
  801. error("Cannot create wake_cpu_thread");
  802. else if(unlikely(pthread_join(thread, NULL)))
  803. error("Cannot join wake_cpu_thread");
  804. cpu_states_updated = 1;
  805. }
  806. }
  807. if(unlikely(!cpu_states_updated || !read_schedstat(schedstat_filename, &cpuidle_charts, cores_found))) {
  808. for(core = 0; core < cores_found; core++) {
  809. cpuidle_charts[core].last_active_time = cpuidle_charts[core].active_time;
  810. int r = read_cpuidle_states(cpuidle_name_filename, cpuidle_time_filename, cpuidle_charts, core);
  811. if(likely(r != -1 && (do_cpuidle == CONFIG_BOOLEAN_YES || r > 0))) {
  812. do_cpuidle = CONFIG_BOOLEAN_YES;
  813. char cpuidle_chart_id[RRD_ID_LENGTH_MAX + 1];
  814. snprintfz(cpuidle_chart_id, RRD_ID_LENGTH_MAX, "cpu%zu_cpuidle", core);
  815. if(unlikely(!cpuidle_charts[core].st)) {
  816. cpuidle_charts[core].st = rrdset_create_localhost(
  817. "cpu"
  818. , cpuidle_chart_id
  819. , NULL
  820. , "cpuidle"
  821. , "cpuidle.cpuidle"
  822. , "C-state residency"
  823. , "time%"
  824. , PLUGIN_PROC_NAME
  825. , PLUGIN_PROC_MODULE_STAT_NAME
  826. , NETDATA_CHART_PRIO_CPUIDLE + core
  827. , update_every
  828. , RRDSET_TYPE_STACKED
  829. );
  830. char cpuidle_dim_id[RRD_ID_LENGTH_MAX + 1];
  831. snprintfz(cpuidle_dim_id, RRD_ID_LENGTH_MAX, "cpu%zu_active_time", core);
  832. cpuidle_charts[core].active_time_rd = rrddim_add(cpuidle_charts[core].st, cpuidle_dim_id, "C0 (active)", 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
  833. for(state = 0; state < cpuidle_charts[core].cpuidle_state_len; state++) {
  834. snprintfz(cpuidle_dim_id, RRD_ID_LENGTH_MAX, "cpu%zu_cpuidle_state%zu_time", core, state);
  835. cpuidle_charts[core].cpuidle_state[state].rd = rrddim_add(cpuidle_charts[core].st, cpuidle_dim_id,
  836. cpuidle_charts[core].cpuidle_state[state].name,
  837. 1, 1, RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL);
  838. }
  839. }
  840. else
  841. rrdset_next(cpuidle_charts[core].st);
  842. rrddim_set_by_pointer(cpuidle_charts[core].st, cpuidle_charts[core].active_time_rd, cpuidle_charts[core].active_time);
  843. for(state = 0; state < cpuidle_charts[core].cpuidle_state_len; state++) {
  844. rrddim_set_by_pointer(cpuidle_charts[core].st, cpuidle_charts[core].cpuidle_state[state].rd, cpuidle_charts[core].cpuidle_state[state].value);
  845. }
  846. rrdset_done(cpuidle_charts[core].st);
  847. }
  848. }
  849. }
  850. }
  851. if(cpus_var)
  852. rrdvar_custom_host_variable_set(localhost, cpus_var, cores_found);
  853. return 0;
  854. }