src/proc_cpuview.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include "config.h"
   4
   5 #include <dirent.h>
   6 #include <errno.h>
   7 #include <fcntl.h>
   8 #include <inttypes.h>
   9 #include <libgen.h>
  10 #include <pthread.h>
  11 #include <sched.h>
  12 #include <stdarg.h>
  13 #include <stdbool.h>
  14 #include <stdint.h>
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <time.h>
  19 #include <unistd.h>
  20 #include <wait.h>
  21 #include <linux/magic.h>
  22 #include <linux/sched.h>
  23 #include <sys/epoll.h>
  24 #include <sys/mman.h>
  25 #include <sys/mount.h>
  26 #include <sys/param.h>
  27 #include <sys/socket.h>
  28 #include <sys/syscall.h>
  29 #include <sys/sysinfo.h>
  30 #include <sys/vfs.h>
  31
  32 #include "proc_cpuview.h"
  33
  34 #include "bindings.h"
  35 #include "cgroup_fuse.h"
  36 #include "cpuset_parse.h"
  37 #include "cgroups/cgroup.h"
  38 #include "cgroups/cgroup_utils.h"
  39 #include "memory_utils.h"
  40 #include "proc_loadavg.h"
  41 #include "utils.h"
  42
  43 /* Data for CPU view */
  44 struct cg_proc_stat {
  45         char *cg;
  46         struct cpuacct_usage *usage;    /* Real usage as read from the host's /proc/stat. */
  47         struct cpuacct_usage *view;     /* Usage stats reported to the container. */
  48         int cpu_count;
  49         pthread_mutex_t lock;           /* For node manipulation. */
  50         struct cg_proc_stat *next;
  51 };
  52
  53 struct cg_proc_stat_head {
  54         struct cg_proc_stat *next;
  55         time_t lastcheck;
  56
  57         /*
  58          * For access to the list. Reading can be parallel, pruning is exclusive.
  59          */
  60         pthread_rwlock_t lock;
  61 };
  62
  63 #define CPUVIEW_HASH_SIZE 100
  64 static struct cg_proc_stat_head *proc_stat_history[CPUVIEW_HASH_SIZE];
  65
  66 static void reset_proc_stat_node(struct cg_proc_stat *node,
  67                                  struct cpuacct_usage *usage, int cpu_count)
  68 {
  69         lxcfs_debug("Resetting stat node for %s\n", node->cg);
  70         memcpy(node->usage, usage, sizeof(struct cpuacct_usage) * cpu_count);
  71
  72         for (int i = 0; i < cpu_count; i++) {
  73                 node->view[i].user = 0;
  74                 node->view[i].system = 0;
  75                 node->view[i].idle = 0;
  76         }
  77
  78         node->cpu_count = cpu_count;
  79 }
  80
  81 static bool expand_proc_stat_node(struct cg_proc_stat *node, int cpu_count)
  82 {
  83         __do_free struct cpuacct_usage *new_usage = NULL, *new_view = NULL;
  84
  85         /* Allocate new memory */
  86         new_usage = zalloc(sizeof(struct cpuacct_usage) * cpu_count);
  87         if (!new_usage)
  88                 return false;
  89
  90         new_view = zalloc(sizeof(struct cpuacct_usage) * cpu_count);
  91         if (!new_view)
  92                 return false;
  93
  94         /* Copy existing data & initialize new elements */
  95         for (int i = 0; i < cpu_count; i++) {
  96                 if (i < node->cpu_count) {
  97                         new_usage[i].user       = node->usage[i].user;
  98                         new_usage[i].system     = node->usage[i].system;
  99                         new_usage[i].idle       = node->usage[i].idle;
 100
 101                         new_view[i].user        = node->view[i].user;
 102                         new_view[i].system      = node->view[i].system;
 103                         new_view[i].idle        = node->view[i].idle;
 104                 }
 105         }
 106
 107         free(node->usage);
 108         node->usage = move_ptr(new_usage);
 109
 110         free(node->view);
 111         node->view = move_ptr(new_view);
 112         node->cpu_count = cpu_count;
 113
 114         return true;
 115 }
 116
 117 static void free_proc_stat_node(struct cg_proc_stat *node)
 118 {
 119         if (node) {
 120                 /*
 121                  * We're abusing the usage pointer to indicate that
 122                  * pthread_mutex_init() was successful. Don't judge me.
 123                  */
 124                 if (node->usage)
 125                         pthread_mutex_destroy(&node->lock);
 126                 free_disarm(node->cg);
 127                 free_disarm(node->usage);
 128                 free_disarm(node->view);
 129                 free_disarm(node);
 130         }
 131 }
 132
 133 define_cleanup_function(struct cg_proc_stat *, free_proc_stat_node);
 134
 135 static struct cg_proc_stat *add_proc_stat_node(struct cg_proc_stat *new_node)
 136 {
 137         call_cleaner(free_proc_stat_node) struct cg_proc_stat *new = new_node;
 138         struct cg_proc_stat *rv = new_node;
 139         int hash = calc_hash(new->cg) % CPUVIEW_HASH_SIZE;
 140         struct cg_proc_stat_head *head = proc_stat_history[hash];
 141         struct cg_proc_stat *cur;
 142
 143         pthread_rwlock_wrlock(&head->lock);
 144
 145         if (!head->next) {
 146                 head->next = move_ptr(new);
 147                 goto out_rwlock_unlock;
 148         }
 149
 150         cur = head->next;
 151
 152         for (;;) {
 153                 /*
 154                  * The node to be added is already present in the list, so
 155                  * free the newly allocated one and return the one we found.
 156                  */
 157                 if (strcmp(cur->cg, new->cg) == 0) {
 158                         rv = cur;
 159                         goto out_rwlock_unlock;
 160                 }
 161
 162                 /* Keep walking. */
 163                 if (cur->next) {
 164                         cur = cur->next;
 165                         continue;
 166                 }
 167
 168                 /* Add new node to end of list. */
 169                 cur->next = move_ptr(new);
 170                 goto out_rwlock_unlock;
 171         }
 172
 173 out_rwlock_unlock:
 174         pthread_rwlock_unlock(&head->lock);
 175         return move_ptr(rv);
 176 }
 177
 178 static struct cg_proc_stat *new_proc_stat_node(struct cpuacct_usage *usage,
 179                                                int cpu_count, const char *cg)
 180 {
 181         call_cleaner(free_proc_stat_node) struct cg_proc_stat *node = NULL;
 182         __do_free struct cpuacct_usage *new_usage = NULL;
 183
 184         node = zalloc(sizeof(struct cg_proc_stat));
 185         if (!node)
 186                 return NULL;
 187
 188         node->cg = strdup(cg);
 189         if (!node->cg)
 190                 return NULL;
 191
 192         new_usage = memdup(usage, sizeof(struct cpuacct_usage) * cpu_count);
 193         if (!new_usage)
 194                 return NULL;
 195
 196         node->view = zalloc(sizeof(struct cpuacct_usage) * cpu_count);
 197         if (!node->view)
 198                 return NULL;
 199
 200         node->cpu_count = cpu_count;
 201
 202         if (pthread_mutex_init(&node->lock, NULL))
 203                 return NULL;
 204         /*
 205          * We're abusing the usage pointer to indicate that
 206          * pthread_mutex_init() was successful. Don't judge me.
 207          */
 208         node->usage = move_ptr(new_usage);
 209
 210         return move_ptr(node);
 211 }
 212
 213 static bool cgroup_supports(const char *controller, const char *cgroup,
 214                             const char *file)
 215 {
 216         __do_free char *path = NULL;
 217         int cfd;
 218
 219         cfd = get_cgroup_fd(controller);
 220         if (cfd < 0)
 221                 return false;
 222
 223         path = must_make_path_relative(cgroup, file, NULL);
 224         return faccessat(cfd, path, F_OK, 0) == 0;
 225 }
 226
 227 static struct cg_proc_stat *prune_proc_stat_list(struct cg_proc_stat *node)
 228 {
 229         struct cg_proc_stat *first = NULL;
 230
 231         for (struct cg_proc_stat *prev = NULL; node; ) {
 232                 if (!cgroup_supports("cpu", node->cg, "cpu.shares")) {
 233                         struct cg_proc_stat *cur = node;
 234
 235                         if (prev)
 236                                 prev->next = node->next;
 237                         else
 238                                 first = node->next;
 239
 240                         node = node->next;
 241                         lxcfs_debug("Removing stat node for %s\n", cur);
 242
 243                         free_proc_stat_node(cur);
 244                 } else {
 245                         if (!first)
 246                                 first = node;
 247                         prev = node;
 248                         node = node->next;
 249                 }
 250         }
 251
 252         return first;
 253 }
 254
 255 #define PROC_STAT_PRUNE_INTERVAL 10
 256 static void prune_proc_stat_history(void)
 257 {
 258         time_t now = time(NULL);
 259
 260         for (int i = 0; i < CPUVIEW_HASH_SIZE; i++) {
 261                 pthread_rwlock_wrlock(&proc_stat_history[i]->lock);
 262
 263                 if ((proc_stat_history[i]->lastcheck + PROC_STAT_PRUNE_INTERVAL) > now) {
 264                         pthread_rwlock_unlock(&proc_stat_history[i]->lock);
 265                         return;
 266                 }
 267
 268                 if (proc_stat_history[i]->next) {
 269                         proc_stat_history[i]->next = prune_proc_stat_list(proc_stat_history[i]->next);
 270                         proc_stat_history[i]->lastcheck = now;
 271                 }
 272
 273                 pthread_rwlock_unlock(&proc_stat_history[i]->lock);
 274         }
 275 }
 276
 277 static struct cg_proc_stat *find_proc_stat_node(struct cg_proc_stat_head *head,
 278                                                 const char *cg)
 279 {
 280         struct cg_proc_stat *node;
 281
 282         pthread_rwlock_rdlock(&head->lock);
 283
 284         if (!head->next) {
 285                 pthread_rwlock_unlock(&head->lock);
 286                 return NULL;
 287         }
 288
 289         node = head->next;
 290
 291         do {
 292                 if (strcmp(cg, node->cg) == 0)
 293                         goto out;
 294         } while ((node = node->next));
 295
 296         node = NULL;
 297
 298 out:
 299         pthread_rwlock_unlock(&head->lock);
 300         prune_proc_stat_history();
 301         return node;
 302 }
 303
 304 static struct cg_proc_stat *find_or_create_proc_stat_node(struct cpuacct_usage *usage,
 305                                                           int cpu_count, const char *cg)
 306 {
 307         int hash = calc_hash(cg) % CPUVIEW_HASH_SIZE;
 308         struct cg_proc_stat_head *head = proc_stat_history[hash];
 309         struct cg_proc_stat *node;
 310
 311         node = find_proc_stat_node(head, cg);
 312         if (!node) {
 313                 node = new_proc_stat_node(usage, cpu_count, cg);
 314                 if (!node)
 315                         return NULL;
 316
 317                 node = add_proc_stat_node(node);
 318                 lxcfs_debug("New stat node (%d) for %s\n", cpu_count, cg);
 319         }
 320
 321         pthread_mutex_lock(&node->lock);
 322
 323         /*
 324          * If additional CPUs on the host have been enabled, CPU usage counter
 325          * arrays have to be expanded.
 326          */
 327         if (node->cpu_count < cpu_count) {
 328                 lxcfs_debug("Expanding stat node %d->%d for %s\n",
 329                             node->cpu_count, cpu_count, cg);
 330
 331                 if (!expand_proc_stat_node(node, cpu_count)) {
 332                         pthread_mutex_unlock(&node->lock);
 333                         return log_debug(NULL, "Unable to expand stat node %d->%d for %s", node->cpu_count, cpu_count, cg);
 334                 }
 335         }
 336
 337         return node;
 338 }
 339
 340 static void add_cpu_usage(uint64_t *surplus, struct cpuacct_usage *usage,
 341                           uint64_t *counter, uint64_t threshold)
 342 {
 343         uint64_t free_space, to_add;
 344
 345         free_space = threshold - usage->user - usage->system;
 346
 347         if (free_space > usage->idle)
 348                 free_space = usage->idle;
 349
 350         if (free_space > *surplus)
 351                 to_add = *surplus;
 352         else
 353                 to_add = free_space;
 354
 355         *counter += to_add;
 356         usage->idle -= to_add;
 357         *surplus -= to_add;
 358 }
 359
 360 static uint64_t diff_cpu_usage(struct cpuacct_usage *older,
 361                                struct cpuacct_usage *newer,
 362                                struct cpuacct_usage *diff, int cpu_count)
 363 {
 364         uint64_t sum = 0;
 365
 366         for (int i = 0; i < cpu_count; i++) {
 367                 if (!newer[i].online)
 368                         continue;
 369
 370                 /*
 371                  * When cpuset is changed on the fly, the CPUs might get
 372                  * reordered. We could either reset all counters, or check
 373                  * that the substractions below will return expected results.
 374                  */
 375                 if (newer[i].user > older[i].user)
 376                         diff[i].user = newer[i].user - older[i].user;
 377                 else
 378                         diff[i].user = 0;
 379
 380                 if (newer[i].system > older[i].system)
 381                         diff[i].system = newer[i].system - older[i].system;
 382                 else
 383                         diff[i].system = 0;
 384
 385                 if (newer[i].idle > older[i].idle)
 386                         diff[i].idle = newer[i].idle - older[i].idle;
 387                 else
 388                         diff[i].idle = 0;
 389
 390                 sum += diff[i].user;
 391                 sum += diff[i].system;
 392                 sum += diff[i].idle;
 393         }
 394
 395         return sum;
 396 }
 397
 398 /*
 399  * Read cgroup CPU quota parameters from `cpu.cfs_quota_us` or
 400  * `cpu.cfs_period_us`, depending on `param`. Parameter value is returned
 401  * through `value`.
 402  */
 403 static bool read_cpu_cfs_param(const char *cg, const char *param, int64_t *value)
 404 {
 405         __do_free char *str = NULL;
 406         char file[STRLITERALLEN("cpu.cfs_period_us") + 1];
 407         bool first = true;
 408         int ret;
 409
 410         if (pure_unified_layout(cgroup_ops)) {
 411                 first = !strcmp(param, "quota");
 412                 ret = snprintf(file, sizeof(file), "cpu.max");
 413         } else {
 414                 ret = snprintf(file, sizeof(file), "cpu.cfs_%s_us", param);
 415         }
 416         if (ret < 0 || (size_t)ret >= sizeof(file))
 417                 return false;
 418
 419         if (!cgroup_ops->get(cgroup_ops, "cpu", cg, file, &str))
 420                 return false;
 421
 422         return sscanf(str, first ? "%" PRId64 : "%*d %" PRId64, value) == 1;
 423 }
 424
 425 /*
 426  * Return the exact number of visible CPUs based on CPU quotas.
 427  * If there is no quota set, zero is returned.
 428  */
 429 static double exact_cpu_count(const char *cg)
 430 {
 431         double rv;
 432         int nprocs;
 433         int64_t cfs_quota, cfs_period;
 434
 435         if (!read_cpu_cfs_param(cg, "quota", &cfs_quota))
 436                 return 0;
 437
 438         if (!read_cpu_cfs_param(cg, "period", &cfs_period))
 439                 return 0;
 440
 441         if (cfs_quota <= 0 || cfs_period <= 0)
 442                 return 0;
 443
 444         rv = (double)cfs_quota / (double)cfs_period;
 445
 446         nprocs = get_nprocs();
 447
 448         if (rv > nprocs)
 449                 rv = nprocs;
 450
 451         return rv;
 452 }
 453
 454 /*
 455  * Return true if cfs quota of the cgroup is neg / not set
 456  */
 457 static bool cfs_quota_disabled(const char *cg)
 458 {
 459         int64_t cfs_quota;
 460
 461         if (!read_cpu_cfs_param(cg, "quota", &cfs_quota))
 462                 return true;
 463
 464         return cfs_quota < 0;
 465 }
 466
 467 /*
 468  * Return the maximum number of visible CPUs based on CPU quotas.
 469  * If there is no quota set, zero is returned.
 470  */
 471 int max_cpu_count(const char *cg)
 472 {
 473         __do_free char *cpuset = NULL;
 474         int rv, nprocs;
 475         int64_t cfs_quota, cfs_period;
 476         int nr_cpus_in_cpuset = 0;
 477
 478         if (!read_cpu_cfs_param(cg, "quota", &cfs_quota))
 479                 return 0;
 480
 481         if (!read_cpu_cfs_param(cg, "period", &cfs_period))
 482                 return 0;
 483
 484         cpuset = get_cpuset(cg);
 485         if (cpuset)
 486                 nr_cpus_in_cpuset = cpu_number_in_cpuset(cpuset);
 487
 488         if (cfs_quota <= 0 || cfs_period <= 0) {
 489                 if (nr_cpus_in_cpuset > 0)
 490                         return nr_cpus_in_cpuset;
 491
 492                 return 0;
 493         }
 494
 495         rv = cfs_quota / cfs_period;
 496
 497         /*
 498          * In case quota/period does not yield a whole number, add one CPU for
 499          * the remainder.
 500          */
 501         if ((cfs_quota % cfs_period) > 0)
 502                 rv += 1;
 503
 504         nprocs = get_nprocs();
 505         if (rv > nprocs)
 506                 rv = nprocs;
 507
 508         /* Use min value in cpu quota and cpuset. */
 509         if (nr_cpus_in_cpuset > 0 && nr_cpus_in_cpuset < rv)
 510                 rv = nr_cpus_in_cpuset;
 511
 512         return rv;
 513 }
 514
 515 int cpuview_proc_stat(const char *cg, const char *cpuset,
 516                       struct cpuacct_usage *cg_cpu_usage, int cg_cpu_usage_size,
 517                       FILE *f, char *buf, size_t buf_size)
 518 {
 519         __do_free char *line = NULL;
 520         __do_free struct cpuacct_usage *diff = NULL;
 521         size_t linelen = 0, total_len = 0;
 522         int curcpu = -1; /* cpu numbering starts at 0 */
 523         int physcpu, i;
 524         int cpu_cnt = 0;
 525         uint64_t user = 0, nice = 0, system = 0, idle = 0, iowait = 0, irq = 0,
 526                  softirq = 0, steal = 0, guest = 0, guest_nice = 0;
 527         uint64_t user_sum = 0, system_sum = 0, idle_sum = 0;
 528         uint64_t user_surplus = 0, system_surplus = 0;
 529         int nprocs, max_cpus;
 530         ssize_t l;
 531         uint64_t total_sum, threshold;
 532         struct cg_proc_stat *stat_node;
 533
 534         nprocs = get_nprocs_conf();
 535         if (cg_cpu_usage_size < nprocs)
 536                 nprocs = cg_cpu_usage_size;
 537
 538         /* Read all CPU stats and stop when we've encountered other lines */
 539         while (getline(&line, &linelen, f) != -1) {
 540                 int ret;
 541                 char cpu_char[10]; /* That's a lot of cores */
 542                 uint64_t all_used, cg_used;
 543
 544                 if (strlen(line) == 0)
 545                         continue;
 546
 547                 /* not a ^cpuN line containing a number N */
 548                 if (sscanf(line, "cpu%9[^ ]", cpu_char) != 1)
 549                         break;
 550
 551                 if (sscanf(cpu_char, "%d", &physcpu) != 1)
 552                         continue;
 553
 554                 if (physcpu >= cg_cpu_usage_size)
 555                         continue;
 556
 557                 curcpu++;
 558                 cpu_cnt++;
 559
 560                 if (!cpu_in_cpuset(physcpu, cpuset)) {
 561                         for (i = curcpu; i <= physcpu; i++)
 562                                 cg_cpu_usage[i].online = false;
 563                         continue;
 564                 }
 565
 566                 if (curcpu < physcpu) {
 567                         /* Some CPUs may be disabled */
 568                         for (i = curcpu; i < physcpu; i++)
 569                                 cg_cpu_usage[i].online = false;
 570
 571                         curcpu = physcpu;
 572                 }
 573
 574                 cg_cpu_usage[curcpu].online = true;
 575
 576                 ret = sscanf(line, "%*s %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 "lu",
 577                            &user,
 578                            &nice,
 579                            &system,
 580                            &idle,
 581                            &iowait,
 582                            &irq,
 583                            &softirq,
 584                            &steal,
 585                            &guest,
 586                            &guest_nice);
 587                 if (ret != 10)
 588                         continue;
 589
 590                 all_used = user + nice + system + iowait + irq + softirq + steal + guest + guest_nice;
 591                 cg_used = cg_cpu_usage[curcpu].user + cg_cpu_usage[curcpu].system;
 592
 593                 if (all_used >= cg_used) {
 594                         cg_cpu_usage[curcpu].idle = idle + (all_used - cg_used);
 595                 } else {
 596                         lxcfs_v("cpu%d from %s has unexpected cpu time: %" PRIu64 " in /proc/stat, %" PRIu64 " in cpuacct.usage_all; unable to determine idle time",
 597                                 curcpu, cg, all_used, cg_used);
 598                         cg_cpu_usage[curcpu].idle = idle;
 599                 }
 600         }
 601
 602         /* Cannot use more CPUs than is available in cpuset. */
 603         max_cpus = max_cpu_count(cg);
 604         if (max_cpus > cpu_cnt || !max_cpus)
 605                 max_cpus = cpu_cnt;
 606
 607         /* takes lock pthread_mutex_lock(&node->lock) */
 608         stat_node = find_or_create_proc_stat_node(cg_cpu_usage, nprocs, cg);
 609         if (!stat_node)
 610                 return log_error(0, "Failed to find/create stat node for %s", cg);
 611
 612         diff = zalloc(sizeof(struct cpuacct_usage) * nprocs);
 613         if (!diff)
 614                 goto out_pthread_mutex_unlock;
 615
 616         /*
 617          * If the new values are LOWER than values stored in memory, it means
 618          * the cgroup has been reset/recreated and we should reset too.
 619          */
 620         for (curcpu = 0; curcpu < nprocs; curcpu++) {
 621                 if (!cg_cpu_usage[curcpu].online)
 622                         continue;
 623
 624                 if (cg_cpu_usage[curcpu].user < stat_node->usage[curcpu].user)
 625                         reset_proc_stat_node(stat_node, cg_cpu_usage, nprocs);
 626
 627                 break;
 628         }
 629
 630         total_sum = diff_cpu_usage(stat_node->usage, cg_cpu_usage, diff, nprocs);
 631
 632         for (curcpu = 0, i = -1; curcpu < nprocs; curcpu++) {
 633                 stat_node->usage[curcpu].online = cg_cpu_usage[curcpu].online;
 634
 635                 if (!stat_node->usage[curcpu].online)
 636                         continue;
 637
 638                 i++;
 639
 640                 stat_node->usage[curcpu].user   += diff[curcpu].user;
 641                 stat_node->usage[curcpu].system += diff[curcpu].system;
 642                 stat_node->usage[curcpu].idle   += diff[curcpu].idle;
 643
 644                 if (max_cpus > 0 && i >= max_cpus) {
 645                         user_surplus    += diff[curcpu].user;
 646                         system_surplus  += diff[curcpu].system;
 647                 }
 648         }
 649
 650         /* Calculate usage counters of visible CPUs */
 651         if (max_cpus > 0) {
 652                 uint64_t diff_user = 0;
 653                 uint64_t diff_system = 0;
 654                 uint64_t diff_idle = 0;
 655                 uint64_t max_diff_idle = 0;
 656                 uint64_t max_diff_idle_index = 0;
 657                 double exact_cpus;
 658                 /* threshold = maximum usage per cpu, including idle */
 659                 threshold = total_sum / cpu_cnt * max_cpus;
 660
 661                 for (curcpu = 0, i = -1; curcpu < nprocs; curcpu++) {
 662                         if (!stat_node->usage[curcpu].online)
 663                                 continue;
 664
 665                         i++;
 666
 667                         if (i == max_cpus)
 668                                 break;
 669
 670                         if (diff[curcpu].user + diff[curcpu].system >= threshold)
 671                                 continue;
 672
 673                         /* Add user */
 674                         add_cpu_usage(&user_surplus, &diff[curcpu],
 675                                       &diff[curcpu].user, threshold);
 676
 677                         if (diff[curcpu].user + diff[curcpu].system >= threshold)
 678                                 continue;
 679
 680                         /* If there is still room, add system */
 681                         add_cpu_usage(&system_surplus, &diff[curcpu],
 682                                       &diff[curcpu].system, threshold);
 683                 }
 684
 685                 if (user_surplus > 0)
 686                         lxcfs_debug("leftover user: %lu for %s\n", user_surplus, cg);
 687                 if (system_surplus > 0)
 688                         lxcfs_debug("leftover system: %lu for %s\n", system_surplus, cg);
 689
 690                 for (curcpu = 0, i = -1; curcpu < nprocs; curcpu++) {
 691                         if (!stat_node->usage[curcpu].online)
 692                                 continue;
 693
 694                         i++;
 695
 696                         if (i == max_cpus)
 697                                 break;
 698
 699                         stat_node->view[curcpu].user    += diff[curcpu].user;
 700                         stat_node->view[curcpu].system  += diff[curcpu].system;
 701                         stat_node->view[curcpu].idle    += diff[curcpu].idle;
 702
 703                         user_sum        += stat_node->view[curcpu].user;
 704                         system_sum      += stat_node->view[curcpu].system;
 705                         idle_sum        += stat_node->view[curcpu].idle;
 706
 707                         diff_user       += diff[curcpu].user;
 708                         diff_system     += diff[curcpu].system;
 709                         diff_idle       += diff[curcpu].idle;
 710                         if (diff[curcpu].idle > max_diff_idle) {
 711                                 max_diff_idle           = diff[curcpu].idle;
 712                                 max_diff_idle_index     = curcpu;
 713                         }
 714
 715                         lxcfs_v("curcpu: %d, diff_user: %lu, diff_system: %lu, diff_idle: %lu\n", curcpu, diff[curcpu].user, diff[curcpu].system, diff[curcpu].idle);
 716                 }
 717                 lxcfs_v("total. diff_user: %lu, diff_system: %lu, diff_idle: %lu\n", diff_user, diff_system, diff_idle);
 718
 719                 /* revise cpu usage view to support partial cpu case. */
 720                 exact_cpus = exact_cpu_count(cg);
 721
 722                 /* skip revise cpu when cfs quota is disabled (exact_cpus == 0) */
 723                 if (!cfs_quota_disabled(cg) && exact_cpus < (double)max_cpus){
 724                         uint64_t delta = (uint64_t)((double)(diff_user + diff_system + diff_idle) * (1 - exact_cpus / (double)max_cpus));
 725
 726                         lxcfs_v("revising cpu usage view to match the exact cpu count [%f]\n", exact_cpus);
 727                         lxcfs_v("delta: %lu\n", delta);
 728                         lxcfs_v("idle_sum before: %lu\n", idle_sum);
 729                         if (idle_sum > delta)
 730                                 idle_sum = idle_sum - delta;
 731                         else
 732                                 idle_sum = 0;
 733                         lxcfs_v("idle_sum after: %lu\n", idle_sum);
 734
 735                         curcpu = max_diff_idle_index;
 736                         lxcfs_v("curcpu: %d, idle before: %lu\n", curcpu, stat_node->view[curcpu].idle);
 737                         if (stat_node->view[curcpu].idle > delta)
 738                                 stat_node->view[curcpu].idle = stat_node->view[curcpu].idle - delta;
 739                         else
 740                                 stat_node->view[curcpu].idle = 0;
 741                         lxcfs_v("curcpu: %d, idle after: %lu\n", curcpu, stat_node->view[curcpu].idle);
 742                 }
 743         } else {
 744                 for (curcpu = 0; curcpu < nprocs; curcpu++) {
 745                         if (!stat_node->usage[curcpu].online)
 746                                 continue;
 747
 748                         stat_node->view[curcpu].user    = stat_node->usage[curcpu].user;
 749                         stat_node->view[curcpu].system  = stat_node->usage[curcpu].system;
 750                         stat_node->view[curcpu].idle    = stat_node->usage[curcpu].idle;
 751
 752                         user_sum        += stat_node->view[curcpu].user;
 753                         system_sum      += stat_node->view[curcpu].system;
 754                         idle_sum        += stat_node->view[curcpu].idle;
 755                 }
 756         }
 757
 758         /* Render the file */
 759         /* cpu-all */
 760         l = snprintf(buf, buf_size,
 761                      "cpu  %" PRIu64 " 0 %" PRIu64 " %" PRIu64 " 0 0 0 0 0 0\n",
 762                      user_sum, system_sum, idle_sum);
 763         lxcfs_v("cpu-all: %s\n", buf);
 764         if (l < 0) {
 765                 lxcfs_error("Failed to write cache");
 766                 total_len = 0;
 767                 goto out_pthread_mutex_unlock;
 768         }
 769         if ((size_t)l >= buf_size) {
 770                 lxcfs_error("Write to cache was truncated");
 771                 total_len = 0;
 772                 goto out_pthread_mutex_unlock;
 773         }
 774
 775         buf += l;
 776         buf_size -= l;
 777         total_len += l;
 778
 779         /* Render visible CPUs */
 780         for (curcpu = 0, i = -1; curcpu < nprocs; curcpu++) {
 781                 if (!stat_node->usage[curcpu].online)
 782                         continue;
 783
 784                 i++;
 785
 786                 if (max_cpus > 0 && i == max_cpus)
 787                         break;
 788
 789                 l = snprintf(buf, buf_size, "cpu%d %" PRIu64 " 0 %" PRIu64 " %" PRIu64 " 0 0 0 0 0 0\n",
 790                              i,
 791                              stat_node->view[curcpu].user,
 792                              stat_node->view[curcpu].system,
 793                              stat_node->view[curcpu].idle);
 794                 lxcfs_v("cpu: %s\n", buf);
 795                 if (l < 0) {
 796                         lxcfs_error("Failed to write cache");
 797                         total_len = 0;
 798                         goto out_pthread_mutex_unlock;
 799                 }
 800                 if ((size_t)l >= buf_size) {
 801                         lxcfs_error("Write to cache was truncated");
 802                         total_len = 0;
 803                         goto out_pthread_mutex_unlock;
 804                 }
 805
 806                 buf += l;
 807                 buf_size -= l;
 808                 total_len += l;
 809         }
 810
 811         /* Pass the rest of /proc/stat, start with the last line read */
 812         l = snprintf(buf, buf_size, "%s", line);
 813         if (l < 0) {
 814                 lxcfs_error("Failed to write cache");
 815                 total_len = 0;
 816                 goto out_pthread_mutex_unlock;
 817         }
 818         if ((size_t)l >= buf_size) {
 819                 lxcfs_error("Write to cache was truncated");
 820                 total_len = 0;
 821                 goto out_pthread_mutex_unlock;
 822         }
 823
 824         buf += l;
 825         buf_size -= l;
 826         total_len += l;
 827
 828         /* Pass the rest of the host's /proc/stat */
 829         while (getline(&line, &linelen, f) != -1) {
 830                 l = snprintf(buf, buf_size, "%s", line);
 831                 if (l < 0) {
 832                         lxcfs_error("Failed to write cache");
 833                         total_len = 0;
 834                         goto out_pthread_mutex_unlock;
 835                 }
 836                 if ((size_t)l >= buf_size) {
 837                         lxcfs_error("Write to cache was truncated");
 838                         total_len = 0;
 839                         goto out_pthread_mutex_unlock;
 840                 }
 841
 842                 buf += l;
 843                 buf_size -= l;
 844                 total_len += l;
 845         }
 846
 847 out_pthread_mutex_unlock:
 848         if (stat_node)
 849                 pthread_mutex_unlock(&stat_node->lock);
 850
 851         return total_len;
 852 }
 853
 854 /*
 855  * check whether this is a '^processor" line in /proc/cpuinfo
 856  */
 857 static inline bool is_processor_line(const char *line)
 858 {
 859         int cpu;
 860         return sscanf(line, "processor       : %d", &cpu) == 1;
 861 }
 862
 863 static inline bool cpuline_in_cpuset(const char *line, const char *cpuset)
 864 {
 865         int cpu;
 866
 867         if (sscanf(line, "processor       : %d", &cpu) == 1)
 868                 return cpu_in_cpuset(cpu, cpuset);
 869
 870         return false;
 871 }
 872
 873 int proc_cpuinfo_read(char *buf, size_t size, off_t offset,
 874                       struct fuse_file_info *fi)
 875 {
 876         __do_free char *cg = NULL, *cpuset = NULL, *line = NULL;
 877         __do_free void *fopen_cache = NULL;
 878         __do_fclose FILE *f = NULL;
 879         struct fuse_context *fc = fuse_get_context();
 880         struct lxcfs_opts *opts = (struct lxcfs_opts *)fc->private_data;
 881         struct file_info *d = INTTYPE_TO_PTR(fi->fh);
 882         size_t linelen = 0, total_len = 0;
 883         bool am_printing = false, firstline = true, is_s390x = false;
 884         int curcpu = -1, cpu, max_cpus = 0;
 885         bool use_view;
 886         char *cache = d->buf;
 887         size_t cache_size = d->buflen;
 888
 889         if (offset) {
 890                 size_t left;
 891
 892                 if (offset > d->size)
 893                         return -EINVAL;
 894
 895                 if (!d->cached)
 896                         return 0;
 897
 898                 left = d->size - offset;
 899                 total_len = left > size ? size: left;
 900                 memcpy(buf, cache + offset, total_len);
 901
 902                 return total_len;
 903         }
 904
 905         pid_t initpid = lookup_initpid_in_store(fc->pid);
 906         if (initpid <= 1 || is_shared_pidns(initpid))
 907                 initpid = fc->pid;
 908
 909         cg = get_pid_cgroup(initpid, "cpuset");
 910         if (!cg)
 911                 return read_file_fuse("proc/cpuinfo", buf, size, d);
 912         prune_init_slice(cg);
 913
 914         cpuset = get_cpuset(cg);
 915         if (!cpuset)
 916                 return 0;
 917
 918         if (cgroup_ops->can_use_cpuview(cgroup_ops) && opts && opts->use_cfs)
 919                 use_view = true;
 920         else
 921                 use_view = false;
 922         if (use_view)
 923                 max_cpus = max_cpu_count(cg);
 924
 925         f = fopen_cached("/proc/cpuinfo", "re", &fopen_cache);
 926         if (!f)
 927                 return 0;
 928
 929         while (getline(&line, &linelen, f) != -1) {
 930                 ssize_t l;
 931                 if (firstline) {
 932                         firstline = false;
 933                         if (strstr(line, "IBM/S390") != NULL) {
 934                                 is_s390x = true;
 935                                 am_printing = true;
 936                                 continue;
 937                         }
 938                 }
 939
 940                 if (strncmp(line, "# processors:", 12) == 0)
 941                         continue;
 942
 943                 if (is_processor_line(line)) {
 944                         if (use_view && max_cpus > 0 && (curcpu + 1) == max_cpus)
 945                                 break;
 946
 947                         am_printing = cpuline_in_cpuset(line, cpuset);
 948                         if (am_printing) {
 949                                 curcpu++;
 950                                 l = snprintf(cache, cache_size, "processor      : %d\n", curcpu);
 951                                 if (l < 0)
 952                                         return log_error(0, "Failed to write cache");
 953                                 if ((size_t)l >= cache_size)
 954                                         return log_error(0, "Write to cache was truncated");
 955                                 cache += l;
 956                                 cache_size -= l;
 957                                 total_len += l;
 958                         }
 959                         continue;
 960                 } else if (is_s390x && sscanf(line, "processor %d:", &cpu) == 1) {
 961                         char *p;
 962
 963                         if (use_view && max_cpus > 0 && (curcpu + 1) == max_cpus)
 964                                 break;
 965
 966                         if (!cpu_in_cpuset(cpu, cpuset))
 967                                 continue;
 968
 969                         curcpu ++;
 970                         p = strchr(line, ':');
 971                         if (!p || !*p)
 972                                 return 0;
 973                         p++;
 974
 975                         l = snprintf(cache, cache_size, "processor %d:%s", curcpu, p);
 976                         if (l < 0)
 977                                 return log_error(0, "Failed to write cache");
 978                         if ((size_t)l >= cache_size)
 979                                 return log_error(0, "Write to cache was truncated");
 980
 981                         cache += l;
 982                         cache_size -= l;
 983                         total_len += l;
 984                         continue;
 985
 986                 }
 987                 if (am_printing) {
 988                         l = snprintf(cache, cache_size, "%s", line);
 989                         if (l < 0)
 990                                 return log_error(0, "Failed to write cache");
 991                         if ((size_t)l >= cache_size)
 992                                 return log_error(0, "Write to cache was truncated");
 993
 994                         cache += l;
 995                         cache_size -= l;
 996                         total_len += l;
 997                 }
 998         }
 999
1000         if (is_s390x) {
1001                 __do_free char *origcache = d->buf;
1002                 ssize_t l;
1003
1004                 d->buf = malloc(d->buflen);
1005                 if (!d->buf) {
1006                         d->buf = move_ptr(origcache);
1007                         return 0;
1008                 }
1009
1010                 cache = d->buf;
1011                 cache_size = d->buflen;
1012                 total_len = 0;
1013                 l = snprintf(cache, cache_size, "vendor_id       : IBM/S390\n");
1014                 if (l < 0 || (size_t)l >= cache_size)
1015                         return 0;
1016
1017                 cache_size -= l;
1018                 cache += l;
1019                 total_len += l;
1020                 l = snprintf(cache, cache_size, "# processors    : %d\n", curcpu + 1);
1021                 if (l < 0 || (size_t)l >= cache_size)
1022                         return 0;
1023
1024                 cache_size -= l;
1025                 cache += l;
1026                 total_len += l;
1027                 l = snprintf(cache, cache_size, "%s", origcache);
1028                 if (l < 0 || (size_t)l >= cache_size)
1029                         return 0;
1030                 total_len += l;
1031         }
1032
1033         d->cached = 1;
1034         d->size = total_len;
1035         if (total_len > size)
1036                 total_len = size;
1037
1038         /* read from off 0 */
1039         memcpy(buf, d->buf, total_len);
1040
1041         return total_len;
1042 }
1043
1044 /*
1045  * Returns 0 on success.
1046  * It is the caller's responsibility to free `return_usage`, unless this
1047  * function returns an error.
1048  */
1049 int read_cpuacct_usage_all(char *cg, char *cpuset,
1050                            struct cpuacct_usage **return_usage, int *size)
1051 {
1052         __do_free char *usage_str = NULL;
1053         __do_free struct cpuacct_usage *cpu_usage = NULL;
1054         int i = 0, j = 0, read_pos = 0, read_cnt = 0;
1055         int cpucount;
1056         int ret;
1057         int cg_cpu;
1058         uint64_t cg_user, cg_system;
1059         int64_t ticks_per_sec;
1060
1061         ticks_per_sec = sysconf(_SC_CLK_TCK);
1062         if (ticks_per_sec < 0 && errno == EINVAL) {
1063                 lxcfs_debug("%m - Failed to determine number of ticks per second");
1064                 return -1;
1065         }
1066
1067         cpucount = get_nprocs_conf();
1068         cpu_usage = malloc(sizeof(struct cpuacct_usage) * cpucount);
1069         if (!cpu_usage)
1070                 return -ENOMEM;
1071
1072         memset(cpu_usage, 0, sizeof(struct cpuacct_usage) * cpucount);
1073         if (!cgroup_ops->get(cgroup_ops, "cpuacct", cg, "cpuacct.usage_all", &usage_str)) {
1074                 char *sep = " \t\n";
1075                 char *tok;
1076
1077                 /* Read cpuacct.usage_percpu instead. */
1078                 lxcfs_debug("Falling back to cpuacct.usage_percpu");
1079                 if (!cgroup_ops->get(cgroup_ops, "cpuacct", cg, "cpuacct.usage_percpu", &usage_str))
1080                         return -1;
1081
1082                 lxc_iterate_parts(tok, usage_str, sep) {
1083                         uint64_t percpu_user;
1084
1085                         if (i >= cpucount)
1086                                 break;
1087
1088                         tok = trim_whitespace_in_place(tok);
1089                         ret = safe_uint64(tok, &percpu_user, 10);
1090                         if (ret)
1091                                 return -1;
1092
1093                         /* Convert the time from nanoseconds to USER_HZ */
1094                         cpu_usage[i].user = percpu_user / 1000.0 / 1000 / 1000 * ticks_per_sec;
1095                         cpu_usage[i].system = cpu_usage[i].user;
1096                         i++;
1097                         lxcfs_debug("cpu%d with time %s", i, tok);
1098                 }
1099         } else {
1100                 if (sscanf(usage_str, "cpu user system\n%n", &read_cnt) != 0)
1101                         return log_error(-1, "read_cpuacct_usage_all reading first line from %s/cpuacct.usage_all failed", cg);
1102
1103                 read_pos += read_cnt;
1104
1105                 for (i = 0, j = 0; i < cpucount; i++) {
1106                         ret = sscanf(usage_str + read_pos,
1107                                         "%d %" PRIu64 " %" PRIu64 "\n%n", &cg_cpu,
1108                                         &cg_user, &cg_system, &read_cnt);
1109
1110                         if (ret == EOF)
1111                                 break;
1112
1113                         if (ret != 3)
1114                                 return log_error(-EINVAL, "Failed to parse cpuacct.usage_all line %s from cgroup %s",
1115                                                 usage_str + read_pos, cg);
1116
1117                         read_pos += read_cnt;
1118
1119                         /* Convert the time from nanoseconds to USER_HZ */
1120                         cpu_usage[j].user = cg_user / 1000.0 / 1000 / 1000 * ticks_per_sec;
1121                         cpu_usage[j].system = cg_system / 1000.0 / 1000 / 1000 * ticks_per_sec;
1122                         j++;
1123                 }
1124         }
1125
1126         *return_usage = move_ptr(cpu_usage);
1127         *size = cpucount;
1128         return 0;
1129 }
1130
1131 static bool cpuview_init_head(struct cg_proc_stat_head **head)
1132 {
1133         __do_free struct cg_proc_stat_head *h;
1134
1135         h = zalloc(sizeof(struct cg_proc_stat_head));
1136         if (!h)
1137                 return false;
1138
1139         if (pthread_rwlock_init(&h->lock, NULL))
1140                 return false;
1141
1142         h->lastcheck = time(NULL);
1143
1144         *head = move_ptr(h);
1145         return true;
1146 }
1147
1148 bool init_cpuview(void)
1149 {
1150         int i;
1151
1152         for (i = 0; i < CPUVIEW_HASH_SIZE; i++)
1153                 proc_stat_history[i] = NULL;
1154
1155         for (i = 0; i < CPUVIEW_HASH_SIZE; i++) {
1156                 if (!cpuview_init_head(&proc_stat_history[i]))
1157                         goto err;
1158         }
1159
1160         return true;
1161
1162 err:
1163         for (i = 0; i < CPUVIEW_HASH_SIZE; i++) {
1164                 if (proc_stat_history[i])
1165                         free_disarm(proc_stat_history[i]);
1166         }
1167
1168         return false;
1169 }
1170
1171 static void cpuview_free_head(struct cg_proc_stat_head *head)
1172 {
1173         struct cg_proc_stat *node;
1174
1175         if (head->next) {
1176                 node = head->next;
1177
1178                 for (;;) {
1179                         struct cg_proc_stat *cur = node;
1180                         node = node->next;
1181                         free_proc_stat_node(cur);
1182                         if (!node)
1183                                 break;
1184                 }
1185         }
1186
1187         pthread_rwlock_destroy(&head->lock);
1188         free_disarm(head);
1189 }
1190
1191 void free_cpuview(void)
1192 {
1193         for (int i = 0; i < CPUVIEW_HASH_SIZE; i++)
1194                 if (proc_stat_history[i])
1195                         cpuview_free_head(proc_stat_history[i]);
1196 }