nodeinfo.c 46.4 KB
Newer Older
1 2 3
/*
 * nodeinfo.c: Helper routines for OS specific node information
 *
4
 * Copyright (C) 2006-2008, 2010-2012 Red Hat, Inc.
5 6 7 8 9 10 11 12 13 14 15 16 17
 * Copyright (C) 2006 Daniel P. Berrange
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with this library.  If not, see
O
Osier Yang 已提交
19
 * <http://www.gnu.org/licenses/>.
20 21 22 23
 *
 * Author: Daniel P. Berrange <berrange@redhat.com>
 */

24
#include <config.h>
J
Jim Meyering 已提交
25

26 27 28
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
29
#include <stdint.h>
30
#include <errno.h>
31
#include <dirent.h>
E
Eric Blake 已提交
32
#include <sys/utsname.h>
33
#include <sched.h>
34
#include "conf/domain_conf.h"
35

36
#if WITH_NUMACTL
37 38 39
# define NUMA_VERSION1_COMPATIBILITY 1
# include <numa.h>
#endif
40

R
Roman Bogorodskiy 已提交
41 42 43 44 45
#ifdef __FreeBSD__
# include <sys/types.h>
# include <sys/sysctl.h>
#endif

46
#include "c-ctype.h"
47
#include "viralloc.h"
48
#include "nodeinfo.h"
49
#include "physmem.h"
50
#include "virutil.h"
51
#include "virlog.h"
52
#include "virerror.h"
53
#include "count-one-bits.h"
E
Eric Blake 已提交
54
#include "intprops.h"
55
#include "virarch.h"
E
Eric Blake 已提交
56
#include "virfile.h"
57
#include "virtypedparam.h"
58

59 60 61

#define VIR_FROM_THIS VIR_FROM_NONE

R
Roman Bogorodskiy 已提交
62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78
#ifdef __FreeBSD__
static int
freebsdNodeGetCPUCount(void)
{
    int ncpu_mib[2] = { CTL_HW, HW_NCPU };
    unsigned long ncpu;
    size_t ncpu_len = sizeof(ncpu);

    if (sysctl(ncpu_mib, 2, &ncpu, &ncpu_len, NULL, 0) == -1) {
        virReportSystemError(errno, "%s", _("Cannot obtain CPU count"));
        return -1;
    }

    return ncpu;
}
#endif

79
#ifdef __linux__
80
# define CPUINFO_PATH "/proc/cpuinfo"
81
# define SYSFS_SYSTEM_PATH "/sys/devices/system"
82
# define SYSFS_CPU_PATH SYSFS_SYSTEM_PATH"/cpu"
83
# define PROCSTAT_PATH "/proc/stat"
84
# define MEMINFO_PATH "/proc/meminfo"
85
# define SYSFS_MEMORY_SHARED_PATH "/sys/kernel/mm/ksm"
86
# define SYSFS_THREAD_SIBLINGS_LIST_LENGTH_MAX 1024
87 88

# define LINUX_NB_CPU_STATS 4
89 90
# define LINUX_NB_MEMORY_STATS_ALL 4
# define LINUX_NB_MEMORY_STATS_CELL 2
91

92
/* NB, this is not static as we need to call it from the testsuite */
93
int linuxNodeInfoCPUPopulate(FILE *cpuinfo,
94
                             const char *sysfs_dir,
95
                             virNodeInfoPtr nodeinfo);
96

97 98
static int linuxNodeGetCPUStats(FILE *procstat,
                                int cpuNum,
99
                                virNodeCPUStatsPtr params,
100
                                int *nparams);
101 102
static int linuxNodeGetMemoryStats(FILE *meminfo,
                                   int cellNum,
103
                                   virNodeMemoryStatsPtr params,
104
                                   int *nparams);
105

E
Eric Blake 已提交
106
/* Return the positive decimal contents of the given
107 108 109 110 111
 * DIR/cpu%u/FILE, or -1 on error.  If DEFAULT_VALUE is non-negative
 * and the file could not be found, return that instead of an error;
 * this is useful for machines that cannot hot-unplug cpu0, or where
 * hot-unplugging is disabled, or where the kernel is too old
 * to support NUMA cells, etc.  */
E
Eric Blake 已提交
112
static int
E
Eric Blake 已提交
113
virNodeGetCpuValue(const char *dir, unsigned int cpu, const char *file,
114
                   int default_value)
E
Eric Blake 已提交
115 116 117 118 119 120 121
{
    char *path;
    FILE *pathfp;
    int value = -1;
    char value_str[INT_BUFSIZE_BOUND(value)];
    char *tmp;

E
Eric Blake 已提交
122
    if (virAsprintf(&path, "%s/cpu%u/%s", dir, cpu, file) < 0) {
E
Eric Blake 已提交
123 124 125 126 127 128
        virReportOOMError();
        return -1;
    }

    pathfp = fopen(path, "r");
    if (pathfp == NULL) {
129 130
        if (default_value >= 0 && errno == ENOENT)
            value = default_value;
E
Eric Blake 已提交
131 132 133 134 135 136 137 138 139 140
        else
            virReportSystemError(errno, _("cannot open %s"), path);
        goto cleanup;
    }

    if (fgets(value_str, sizeof(value_str), pathfp) == NULL) {
        virReportSystemError(errno, _("cannot read from %s"), path);
        goto cleanup;
    }
    if (virStrToLong_i(value_str, &tmp, 10, &value) < 0) {
141 142 143
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("could not convert '%s' to an integer"),
                       value_str);
E
Eric Blake 已提交
144 145 146 147
        goto cleanup;
    }

cleanup:
148
    VIR_FORCE_FCLOSE(pathfp);
E
Eric Blake 已提交
149 150 151 152 153
    VIR_FREE(path);

    return value;
}

E
Eric Blake 已提交
154 155
static unsigned long
virNodeCountThreadSiblings(const char *dir, unsigned int cpu)
156 157
{
    unsigned long ret = 0;
C
Chris Lalancette 已提交
158 159
    char *path;
    FILE *pathfp;
160 161 162
    char str[1024];
    int i;

163
    if (virAsprintf(&path, "%s/cpu%u/topology/thread_siblings",
E
Eric Blake 已提交
164
                    dir, cpu) < 0) {
165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182
        virReportOOMError();
        return 0;
    }

    pathfp = fopen(path, "r");
    if (pathfp == NULL) {
        virReportSystemError(errno, _("cannot open %s"), path);
        VIR_FREE(path);
        return 0;
    }

    if (fgets(str, sizeof(str), pathfp) == NULL) {
        virReportSystemError(errno, _("cannot read from %s"), path);
        goto cleanup;
    }

    i = 0;
    while (str[i] != '\0') {
C
Chris Lalancette 已提交
183
        if (c_isdigit(str[i]))
184
            ret += count_one_bits(str[i] - '0');
C
Chris Lalancette 已提交
185 186 187 188
        else if (str[i] >= 'A' && str[i] <= 'F')
            ret += count_one_bits(str[i] - 'A' + 10);
        else if (str[i] >= 'a' && str[i] <= 'f')
            ret += count_one_bits(str[i] - 'a' + 10);
189 190 191 192
        i++;
    }

cleanup:
193
    VIR_FORCE_FCLOSE(pathfp);
194 195 196 197 198
    VIR_FREE(path);

    return ret;
}

E
Eric Blake 已提交
199 200
static int
virNodeParseSocket(const char *dir, unsigned int cpu)
201
{
E
Eric Blake 已提交
202
    int ret = virNodeGetCpuValue(dir, cpu, "topology/physical_package_id",
203
                                 0);
E
Eric Blake 已提交
204
# if defined(__powerpc__) || \
205 206 207 208
    defined(__powerpc64__) || \
    defined(__s390__) || \
    defined(__s390x__)
    /* ppc and s390(x) has -1 */
209 210
    if (ret < 0)
        ret = 0;
E
Eric Blake 已提交
211
# endif
212
    return ret;
213 214
}

215 216 217 218 219 220 221 222 223 224 225 226 227
# ifndef CPU_COUNT
static int
CPU_COUNT(cpu_set_t *set)
{
    int i, count = 0;

    for (i = 0; i < CPU_SETSIZE; i++)
        if (CPU_ISSET(i, set))
            count++;
    return count;
}
# endif /* !CPU_COUNT */

228 229
/* parses a node entry, returning number of processors in the node and
 * filling arguments */
230
static int
231 232
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4)
233 234 235 236 237 238
ATTRIBUTE_NONNULL(5)
virNodeParseNode(const char *node,
                 int *sockets,
                 int *cores,
                 int *threads,
                 int *offline)
239 240
{
    int ret = -1;
241 242 243 244 245 246 247 248 249 250 251 252
    int processors = 0;
    DIR *cpudir = NULL;
    struct dirent *cpudirent = NULL;
    int sock_max = 0;
    cpu_set_t sock_map;
    int sock;
    cpu_set_t *core_maps = NULL;
    int core;
    int i;
    int siblings;
    unsigned int cpu;
    int online;
253

254 255 256 257 258 259
    *threads = 0;
    *cores = 0;
    *sockets = 0;

    if (!(cpudir = opendir(node))) {
        virReportSystemError(errno, _("cannot opendir %s"), node);
260 261
        goto cleanup;
    }
262 263 264 265 266 267 268 269

    /* enumerate sockets in the node */
    CPU_ZERO(&sock_map);
    errno = 0;
    while ((cpudirent = readdir(cpudir))) {
        if (sscanf(cpudirent->d_name, "cpu%u", &cpu) != 1)
            continue;

270
        if ((online = virNodeGetCpuValue(node, cpu, "online", 1)) < 0)
271 272 273 274 275
            goto cleanup;

        if (!online)
            continue;

276
        /* Parse socket */
277 278
        if ((sock = virNodeParseSocket(node, cpu)) < 0)
            goto cleanup;
279 280 281 282 283 284 285 286 287 288
        CPU_SET(sock, &sock_map);

        if (sock > sock_max)
            sock_max = sock;

        errno = 0;
    }

    if (errno) {
        virReportSystemError(errno, _("problem reading %s"), node);
289 290
        goto cleanup;
    }
291 292 293 294 295 296

    sock_max++;

    /* allocate cpu maps for each socket */
    if (VIR_ALLOC_N(core_maps, sock_max) < 0) {
        virReportOOMError();
297
        goto cleanup;
298 299 300 301 302 303 304 305 306 307 308 309
    }

    for (i = 0; i < sock_max; i++)
        CPU_ZERO(&core_maps[i]);

    /* iterate over all CPU's in the node */
    rewinddir(cpudir);
    errno = 0;
    while ((cpudirent = readdir(cpudir))) {
        if (sscanf(cpudirent->d_name, "cpu%u", &cpu) != 1)
            continue;

310
        if ((online = virNodeGetCpuValue(node, cpu, "online", 1)) < 0)
311 312
            goto cleanup;

313 314
        if (!online) {
            (*offline)++;
315
            continue;
316
        }
317 318 319 320

        processors++;

        /* Parse socket */
321 322
        if ((sock = virNodeParseSocket(node, cpu)) < 0)
            goto cleanup;
323
        if (!CPU_ISSET(sock, &sock_map)) {
324 325
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("CPU socket topology has changed"));
326 327 328 329 330 331 332 333 334
            goto cleanup;
        }

        /* Parse core */
# if defined(__s390__) || \
    defined(__s390x__)
        /* logical cpu is equivalent to a core on s390 */
        core = cpu;
# else
335
        core = virNodeGetCpuValue(node, cpu, "topology/core_id", 0);
336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
# endif

        CPU_SET(core, &core_maps[sock]);

        if (!(siblings = virNodeCountThreadSiblings(node, cpu)))
            goto cleanup;

        if (siblings > *threads)
            *threads = siblings;

        errno = 0;
    }

    if (errno) {
        virReportSystemError(errno, _("problem reading %s"), node);
351 352
        goto cleanup;
    }
353 354 355 356 357 358 359 360 361 362 363 364 365 366

    /* finalize the returned data */
    *sockets = CPU_COUNT(&sock_map);

    for (i = 0; i < sock_max; i++) {
        if (!CPU_ISSET(i, &sock_map))
            continue;

        core = CPU_COUNT(&core_maps[i]);
        if (core > *cores)
            *cores = core;
    }

    ret = processors;
367 368

cleanup:
369 370 371 372 373 374 375
    /* don't shadow a more serious error */
    if (cpudir && closedir(cpudir) < 0 && ret >= 0) {
        virReportSystemError(errno, _("problem closing %s"), node);
        ret = -1;
    }
    VIR_FREE(core_maps);

376 377 378
    return ret;
}

379
int linuxNodeInfoCPUPopulate(FILE *cpuinfo,
380
                             const char *sysfs_dir,
381
                             virNodeInfoPtr nodeinfo)
382
{
383
    char line[1024];
384 385
    DIR *nodedir = NULL;
    struct dirent *nodedirent = NULL;
386
    int cpus, cores, socks, threads, offline = 0;
387
    unsigned int node;
388
    int ret = -1;
389
    char *sysfs_nodedir = NULL;
390
    char *sysfs_cpudir = NULL;
391

392
    /* Start with parsing CPU clock speed from /proc/cpuinfo */
393
    while (fgets(line, sizeof(line), cpuinfo) != NULL) {
E
Eric Blake 已提交
394
# if defined(__x86_64__) || \
395 396
    defined(__amd64__)  || \
    defined(__i386__)
E
Eric Blake 已提交
397
        char *buf = line;
398
        if (STRPREFIX(buf, "cpu MHz")) {
399 400
            char *p;
            unsigned int ui;
401

402
            buf += 7;
403
            while (*buf && c_isspace(*buf))
404
                buf++;
405

406
            if (*buf != ':' || !buf[1]) {
407 408
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("parsing cpu MHz from cpuinfo"));
409
                goto cleanup;
410
            }
411

412
            if (virStrToLong_ui(buf+1, &p, 10, &ui) == 0 &&
413
                /* Accept trailing fractional part.  */
414
                (*p == '\0' || *p == '.' || c_isspace(*p)))
415
                nodeinfo->mhz = ui;
416
        }
417

E
Eric Blake 已提交
418
# elif defined(__powerpc__) || \
419
      defined(__powerpc64__)
E
Eric Blake 已提交
420
        char *buf = line;
421
        if (STRPREFIX(buf, "clock")) {
422 423
            char *p;
            unsigned int ui;
424

425 426 427
            buf += 5;
            while (*buf && c_isspace(*buf))
                buf++;
428

429
            if (*buf != ':' || !buf[1]) {
430 431
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("parsing cpu MHz from cpuinfo"));
432
                goto cleanup;
433
            }
434

435
            if (virStrToLong_ui(buf+1, &p, 10, &ui) == 0 &&
436
                /* Accept trailing fractional part.  */
437
                (*p == '\0' || *p == '.' || c_isspace(*p)))
438
                nodeinfo->mhz = ui;
439 440 441 442 443
            /* No other interesting infos are available in /proc/cpuinfo.
             * However, there is a line identifying processor's version,
             * identification and machine, but we don't want it to be caught
             * and parsed in next iteration, because it is not in expected
             * format and thus lead to error. */
444
        }
445 446 447 448 449 450 451 452 453 454 455
# elif defined(__arm__)
        char *buf = line;
        if (STRPREFIX(buf, "BogoMIPS")) {
            char *p;
            unsigned int ui;

            buf += 8;
            while (*buf && c_isspace(*buf))
                buf++;

            if (*buf != ':' || !buf[1]) {
456 457
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               "%s", _("parsing cpu MHz from cpuinfo"));
458 459 460 461 462 463 464 465
                goto cleanup;
            }

            if (virStrToLong_ui(buf+1, &p, 10, &ui) == 0
                /* Accept trailing fractional part.  */
                && (*p == '\0' || *p == '.' || c_isspace(*p)))
                nodeinfo->mhz = ui;
        }
466 467 468 469 470
# elif defined(__s390__) || \
      defined(__s390x__)
        /* s390x has no realistic value for CPU speed,
         * assign a value of zero to signify this */
        nodeinfo->mhz = 0;
E
Eric Blake 已提交
471 472 473
# else
#  warning Parser for /proc/cpuinfo needs to be adapted for your architecture
# endif
474 475
    }

476 477
    /* OK, we've parsed clock speed out of /proc/cpuinfo. Get the
     * core, node, socket, thread and topology information from /sys
478
     */
479
    if (virAsprintf(&sysfs_nodedir, "%s/node", sysfs_dir) < 0) {
480 481 482
        virReportOOMError();
        goto cleanup;
    }
483

484 485 486 487
    if (!(nodedir = opendir(sysfs_nodedir))) {
        /* the host isn't probably running a NUMA architecture */
        goto fallback;
    }
488

489 490 491
    errno = 0;
    while ((nodedirent = readdir(nodedir))) {
        if (sscanf(nodedirent->d_name, "node%u", &node) != 1)
492 493
            continue;

494 495 496 497 498
        nodeinfo->nodes++;

        if (virAsprintf(&sysfs_cpudir, "%s/node/%s",
                        sysfs_dir, nodedirent->d_name) < 0) {
            virReportOOMError();
499
            goto cleanup;
E
Eric Blake 已提交
500 501
        }

502 503
        if ((cpus = virNodeParseNode(sysfs_cpudir, &socks, &cores,
                                     &threads, &offline)) < 0)
504
            goto cleanup;
505

506
        VIR_FREE(sysfs_cpudir);
507

508 509 510 511 512 513 514 515 516 517 518 519
        nodeinfo->cpus += cpus;

        if (socks > nodeinfo->sockets)
            nodeinfo->sockets = socks;

        if (cores > nodeinfo->cores)
            nodeinfo->cores = cores;

        if (threads > nodeinfo->threads)
            nodeinfo->threads = threads;

        errno = 0;
520
    }
521

E
Eric Blake 已提交
522
    if (errno) {
523
        virReportSystemError(errno, _("problem reading %s"), sysfs_nodedir);
524 525
        goto cleanup;
    }
526 527 528 529 530 531 532 533 534

    if (nodeinfo->cpus && nodeinfo->nodes)
        goto done;

fallback:
    VIR_FREE(sysfs_cpudir);

    if (virAsprintf(&sysfs_cpudir, "%s/cpu", sysfs_dir) < 0) {
        virReportOOMError();
535
        goto cleanup;
E
Eric Blake 已提交
536
    }
537

538 539
    if ((cpus = virNodeParseNode(sysfs_cpudir, &socks, &cores,
                                 &threads, &offline)) < 0)
540
        goto cleanup;
541

542 543 544 545 546 547 548
    nodeinfo->nodes = 1;
    nodeinfo->cpus = cpus;
    nodeinfo->sockets = socks;
    nodeinfo->cores = cores;
    nodeinfo->threads = threads;

done:
549
    /* There should always be at least one cpu, socket, node, and thread. */
550
    if (nodeinfo->cpus == 0) {
551
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("no CPUs found"));
552
        goto cleanup;
553
    }
554

C
Chris Lalancette 已提交
555
    if (nodeinfo->sockets == 0) {
556
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("no sockets found"));
557
        goto cleanup;
C
Chris Lalancette 已提交
558
    }
559

C
Chris Lalancette 已提交
560
    if (nodeinfo->threads == 0) {
561
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("no threads found"));
562
        goto cleanup;
C
Chris Lalancette 已提交
563 564
    }

565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581
    /* Now check if the topology makes sense. There are machines that don't
     * expose their real number of nodes or for example the AMD Bulldozer
     * architecture that exposes their Clustered integer core modules as both
     * threads and cores. This approach throws off our detection. Unfortunately
     * the nodeinfo structure isn't designed to carry the full topology so
     * we're going to lie about the detected topology to notify the user
     * to check the host capabilities for the actual topology. */
    if ((nodeinfo->nodes *
         nodeinfo->sockets *
         nodeinfo->cores *
         nodeinfo->threads) != (nodeinfo->cpus + offline)) {
        nodeinfo->nodes = 1;
        nodeinfo->sockets = 1;
        nodeinfo->cores = nodeinfo->cpus + offline;
        nodeinfo->threads = 1;
    }

582 583 584
    ret = 0;

cleanup:
585 586 587 588 589 590 591
    /* don't shadow a more serious error */
    if (nodedir && closedir(nodedir) < 0 && ret >= 0) {
        virReportSystemError(errno, _("problem closing %s"), sysfs_nodedir);
        ret = -1;
    }

    VIR_FREE(sysfs_nodedir);
592 593
    VIR_FREE(sysfs_cpudir);
    return ret;
594 595
}

596 597 598 599
# define TICK_TO_NSEC (1000ull * 1000ull * 1000ull / sysconf(_SC_CLK_TCK))

int linuxNodeGetCPUStats(FILE *procstat,
                         int cpuNum,
600
                         virNodeCPUStatsPtr params,
601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616
                         int *nparams)
{
    int ret = -1;
    char line[1024];
    unsigned long long usr, ni, sys, idle, iowait;
    unsigned long long irq, softirq, steal, guest, guest_nice;
    char cpu_header[3 + INT_BUFSIZE_BOUND(cpuNum)];

    if ((*nparams) == 0) {
        /* Current number of cpu stats supported by linux */
        *nparams = LINUX_NB_CPU_STATS;
        ret = 0;
        goto cleanup;
    }

    if ((*nparams) != LINUX_NB_CPU_STATS) {
617 618 619
        virReportInvalidArg(*nparams,
                            _("nparams in %s must be equal to %d"),
                            __FUNCTION__, LINUX_NB_CPU_STATS);
620 621 622
        goto cleanup;
    }

623
    if (cpuNum == VIR_NODE_CPU_STATS_ALL_CPUS) {
624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643
        strcpy(cpu_header, "cpu");
    } else {
        snprintf(cpu_header, sizeof(cpu_header), "cpu%d", cpuNum);
    }

    while (fgets(line, sizeof(line), procstat) != NULL) {
        char *buf = line;

        if (STRPREFIX(buf, cpu_header)) { /* aka logical CPU time */
            int i;

            if (sscanf(buf,
                       "%*s %llu %llu %llu %llu %llu" // user ~ iowait
                       "%llu %llu %llu %llu %llu",    // irq  ~ guest_nice
                       &usr, &ni, &sys, &idle, &iowait,
                       &irq, &softirq, &steal, &guest, &guest_nice) < 4) {
                continue;
            }

            for (i = 0; i < *nparams; i++) {
644
                virNodeCPUStatsPtr param = &params[i];
645 646 647

                switch (i) {
                case 0: /* fill kernel cpu time here */
648
                    if (virStrcpyStatic(param->field, VIR_NODE_CPU_STATS_KERNEL) == NULL) {
649 650
                        virReportError(VIR_ERR_INTERNAL_ERROR,
                                       "%s", _("Field kernel cpu time too long for destination"));
651 652 653 654 655 656
                        goto cleanup;
                    }
                    param->value = (sys + irq + softirq) * TICK_TO_NSEC;
                    break;

                case 1: /* fill user cpu time here */
657
                    if (virStrcpyStatic(param->field, VIR_NODE_CPU_STATS_USER) == NULL) {
658 659
                        virReportError(VIR_ERR_INTERNAL_ERROR,
                                       "%s", _("Field kernel cpu time too long for destination"));
660 661 662 663 664 665
                        goto cleanup;
                    }
                    param->value = (usr + ni) * TICK_TO_NSEC;
                    break;

                case 2: /* fill idle cpu time here */
666
                    if (virStrcpyStatic(param->field, VIR_NODE_CPU_STATS_IDLE) == NULL) {
667 668
                        virReportError(VIR_ERR_INTERNAL_ERROR,
                                       "%s", _("Field kernel cpu time too long for destination"));
669 670 671 672 673 674
                        goto cleanup;
                    }
                    param->value = idle * TICK_TO_NSEC;
                    break;

                case 3: /* fill iowait cpu time here */
675
                    if (virStrcpyStatic(param->field, VIR_NODE_CPU_STATS_IOWAIT) == NULL) {
676 677
                        virReportError(VIR_ERR_INTERNAL_ERROR,
                                       "%s", _("Field kernel cpu time too long for destination"));
678 679 680 681 682 683 684 685 686 687 688 689 690 691 692
                        goto cleanup;
                    }
                    param->value = iowait * TICK_TO_NSEC;
                    break;

                default:
                    break;
                    /* should not hit here */
                }
            }
            ret = 0;
            goto cleanup;
        }
    }

693 694 695
    virReportInvalidArg(cpuNum,
                        _("Invalid cpuNum in %s"),
                        __FUNCTION__);
696

697 698 699 700 701 702
cleanup:
    return ret;
}

int linuxNodeGetMemoryStats(FILE *meminfo,
                            int cellNum,
703
                            virNodeMemoryStatsPtr params,
704 705 706 707 708 709 710
                            int *nparams)
{
    int ret = -1;
    int i = 0, j = 0, k = 0;
    int found = 0;
    int nr_param;
    char line[1024];
711
    char meminfo_hdr[VIR_NODE_MEMORY_STATS_FIELD_LENGTH];
712 713 714 715 716
    unsigned long val;
    struct field_conv {
        const char *meminfo_hdr;  // meminfo header
        const char *field;        // MemoryStats field name
    } field_conv[] = {
717 718 719 720
        {"MemTotal:", VIR_NODE_MEMORY_STATS_TOTAL},
        {"MemFree:",  VIR_NODE_MEMORY_STATS_FREE},
        {"Buffers:",  VIR_NODE_MEMORY_STATS_BUFFERS},
        {"Cached:",   VIR_NODE_MEMORY_STATS_CACHED},
721 722 723
        {NULL,        NULL}
    };

724
    if (cellNum == VIR_NODE_MEMORY_STATS_ALL_CELLS) {
725 726 727 728 729 730 731 732 733 734 735 736 737
        nr_param = LINUX_NB_MEMORY_STATS_ALL;
    } else {
        nr_param = LINUX_NB_MEMORY_STATS_CELL;
    }

    if ((*nparams) == 0) {
        /* Current number of memory stats supported by linux */
        *nparams = nr_param;
        ret = 0;
        goto cleanup;
    }

    if ((*nparams) != nr_param) {
738 739 740
        virReportInvalidArg(nparams,
                            _("nparams in %s must be %d"),
                            __FUNCTION__, nr_param);
741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761
        goto cleanup;
    }

    while (fgets(line, sizeof(line), meminfo) != NULL) {
        char *buf = line;

        if (STRPREFIX(buf, "Node ")) {
            /*
             * /sys/devices/system/node/nodeX/meminfo format is below.
             * So, skip prefix "Node XX ".
             *
             * Node 0 MemTotal:        8386980 kB
             * Node 0 MemFree:         5300920 kB
             *         :
             */
            char *p;

            p = buf;
            for (i = 0; i < 2; i++) {
                p = strchr(p, ' ');
                if (p == NULL) {
762 763
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   "%s", _("no prefix found"));
764 765 766 767 768 769 770 771 772 773 774 775 776 777
                    goto cleanup;
                }
                p++;
            }
            buf = p;
        }

        if (sscanf(buf, "%s %lu kB", meminfo_hdr, &val) < 2)
            continue;

        for (j = 0; field_conv[j].meminfo_hdr != NULL; j++) {
            struct field_conv *convp = &field_conv[j];

            if (STREQ(meminfo_hdr, convp->meminfo_hdr)) {
778
                virNodeMemoryStatsPtr param = &params[k++];
779 780

                if (virStrcpyStatic(param->field, convp->field) == NULL) {
781 782
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   "%s", _("Field kernel memory too long for destination"));
783 784 785 786 787 788 789 790 791 792 793 794
                    goto cleanup;
                }
                param->value = val;
                found++;
                break;
            }
        }
        if (found >= nr_param)
            break;
    }

    if (found == 0) {
795 796
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("no available memory line found"));
797 798 799 800 801
        goto cleanup;
    }

    ret = 0;

802 803 804
cleanup:
    return ret;
}
805

806 807 808 809 810 811 812 813 814

/* Determine the maximum cpu id from a Linux sysfs cpu/present file. */
static int
linuxParseCPUmax(const char *path)
{
    char *str = NULL;
    char *tmp;
    int ret = -1;

E
Eric Blake 已提交
815
    if (virFileReadAll(path, 5 * VIR_DOMAIN_CPUMASK_LEN, &str) < 0)
816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834
        goto cleanup;

    tmp = str;
    do {
        if (virStrToLong_i(tmp, &tmp, 10, &ret) < 0 ||
            !strchr(",-\n", *tmp)) {
            virReportError(VIR_ERR_NO_SUPPORT,
                           _("failed to parse %s"), path);
            ret = -1;
            goto cleanup;
        }
    } while (*tmp++ != '\n');
    ret++;

cleanup:
    VIR_FREE(str);
    return ret;
}

835
/*
836 837 838
 * Linux maintains cpu bit map under cpu/online. For example, if
 * cpuid=5's flag is not set and max cpu is 7, the map file shows
 * 0-4,6-7. This function parses it and returns cpumap.
839
 */
H
Hu Tao 已提交
840
static virBitmapPtr
841
linuxParseCPUmap(int max_cpuid, const char *path)
842
{
H
Hu Tao 已提交
843
    virBitmapPtr map = NULL;
844 845 846 847 848 849 850
    char *str = NULL;

    if (virFileReadAll(path, 5 * VIR_DOMAIN_CPUMASK_LEN, &str) < 0) {
        virReportOOMError();
        goto error;
    }

851
    if (virBitmapParse(str, 0, &map, max_cpuid) < 0)
852 853
        goto error;

H
Hu Tao 已提交
854
    VIR_FREE(str);
855 856 857 858
    return map;

error:
    VIR_FREE(str);
H
Hu Tao 已提交
859
    virBitmapFree(map);
860 861
    return NULL;
}
862 863
#endif

864 865 866
int nodeGetInfo(virConnectPtr conn ATTRIBUTE_UNUSED, virNodeInfoPtr nodeinfo)
{
    virArch hostarch = virArchFromHost();
867

868 869
    memset(nodeinfo, 0, sizeof(*nodeinfo));

870
    if (virStrcpyStatic(nodeinfo->model, virArchToString(hostarch)) == NULL)
C
Chris Lalancette 已提交
871
        return -1;
872

873
#ifdef __linux__
874
    {
875
    int ret = -1;
876
    FILE *cpuinfo = fopen(CPUINFO_PATH, "r");
877
    if (!cpuinfo) {
878
        virReportSystemError(errno,
879
                             _("cannot open %s"), CPUINFO_PATH);
880 881
        return -1;
    }
882

883
    ret = linuxNodeInfoCPUPopulate(cpuinfo, SYSFS_SYSTEM_PATH, nodeinfo);
884 885
    if (ret < 0)
        goto cleanup;
886

887
    /* Convert to KB. */
888
    nodeinfo->memory = physmem_total() / 1024;
889

890 891
cleanup:
    VIR_FORCE_FCLOSE(cpuinfo);
892
    return ret;
893
    }
R
Roman Bogorodskiy 已提交
894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929
#elif defined(__FreeBSD__)
    {
    nodeinfo->nodes = 1;
    nodeinfo->sockets = 1;
    nodeinfo->threads = 1;

    nodeinfo->cpus = freebsdNodeGetCPUCount();
    if (nodeinfo->cpus == -1)
        return -1;

    nodeinfo->cores = nodeinfo->cpus;

    unsigned long cpu_freq;
    size_t cpu_freq_len = sizeof(cpu_freq);

    if (sysctlbyname("dev.cpu.0.freq", &cpu_freq, &cpu_freq_len, NULL, 0) < 0) {
        virReportSystemError(errno, "%s", _("cannot obtain CPU freq"));
        return -1;
    }

    nodeinfo->mhz = cpu_freq;

    /* get memory information */
    int mib[2] = { CTL_HW, HW_PHYSMEM };
    unsigned long physmem;
    size_t len = sizeof(physmem);

    if (sysctl(mib, 2, &physmem, &len, NULL, 0) == -1) {
        virReportSystemError(errno, "%s", _("cannot obtain memory size"));
        return -1;
    }

    nodeinfo->memory = (unsigned long)(physmem / 1024);

    return 0;
    }
930 931
#else
    /* XXX Solaris will need an impl later if they port QEMU driver */
932 933
    virReportError(VIR_ERR_NO_SUPPORT, "%s",
                   _("node info not implemented on this platform"));
934 935 936
    return -1;
#endif
}
937

938
int nodeGetCPUStats(virConnectPtr conn ATTRIBUTE_UNUSED,
939
                    int cpuNum ATTRIBUTE_UNUSED,
940
                    virNodeCPUStatsPtr params ATTRIBUTE_UNUSED,
941
                    int *nparams ATTRIBUTE_UNUSED,
942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960
                    unsigned int flags)
{
    virCheckFlags(0, -1);

#ifdef __linux__
    {
        int ret;
        FILE *procstat = fopen(PROCSTAT_PATH, "r");
        if (!procstat) {
            virReportSystemError(errno,
                                 _("cannot open %s"), PROCSTAT_PATH);
            return -1;
        }
        ret = linuxNodeGetCPUStats(procstat, cpuNum, params, nparams);
        VIR_FORCE_FCLOSE(procstat);

        return ret;
    }
#else
961 962
    virReportError(VIR_ERR_NO_SUPPORT, "%s",
                   _("node CPU stats not implemented on this platform"));
963 964 965 966
    return -1;
#endif
}

967
int nodeGetMemoryStats(virConnectPtr conn ATTRIBUTE_UNUSED,
968
                       int cellNum ATTRIBUTE_UNUSED,
969
                       virNodeMemoryStatsPtr params ATTRIBUTE_UNUSED,
970
                       int *nparams ATTRIBUTE_UNUSED,
971 972 973 974 975 976 977 978 979 980
                       unsigned int flags)
{
    virCheckFlags(0, -1);

#ifdef __linux__
    {
        int ret;
        char *meminfo_path = NULL;
        FILE *meminfo;

981
        if (cellNum == VIR_NODE_MEMORY_STATS_ALL_CELLS) {
982 983 984 985 986 987
            meminfo_path = strdup(MEMINFO_PATH);
            if (!meminfo_path) {
                virReportOOMError();
                return -1;
            }
        } else {
988
# if WITH_NUMACTL
989
            if (numa_available() < 0) {
990
# endif
991 992
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               "%s", _("NUMA not supported on this host"));
993
                return -1;
994
# if WITH_NUMACTL
995
            }
996
# endif
997

998
# if WITH_NUMACTL
999
            if (cellNum > numa_max_node()) {
1000 1001 1002
                virReportInvalidArg(cellNum,
                                    _("cellNum in %s must be less than or equal to %d"),
                                    __FUNCTION__, numa_max_node());
1003 1004
                return -1;
            }
1005
# endif
1006

1007 1008
            if (virAsprintf(&meminfo_path, "%s/node/node%d/meminfo",
                            SYSFS_SYSTEM_PATH, cellNum) < 0) {
1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
                virReportOOMError();
                return -1;
            }
        }
        meminfo = fopen(meminfo_path, "r");

        if (!meminfo) {
            virReportSystemError(errno,
                                 _("cannot open %s"), meminfo_path);
            VIR_FREE(meminfo_path);
            return -1;
        }
        ret = linuxNodeGetMemoryStats(meminfo, cellNum, params, nparams);
        VIR_FORCE_FCLOSE(meminfo);
        VIR_FREE(meminfo_path);

        return ret;
    }
#else
1028 1029
    virReportError(VIR_ERR_NO_SUPPORT, "%s",
                   _("node memory stats not implemented on this platform"));
1030 1031 1032 1033
    return -1;
#endif
}

1034 1035 1036
int
nodeGetCPUCount(void)
{
R
Roman Bogorodskiy 已提交
1037
#if defined(__linux__)
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066
    /* To support older kernels that lack cpu/present, such as 2.6.18
     * in RHEL5, we fall back to count cpu/cpuNN entries; this assumes
     * that such kernels also lack hotplug, and therefore cpu/cpuNN
     * will be consecutive.
     */
    char *cpupath = NULL;
    int i = 0;

    if (virFileExists(SYSFS_SYSTEM_PATH "/cpu/present")) {
        i = linuxParseCPUmax(SYSFS_SYSTEM_PATH "/cpu/present");
    } else if (virFileExists(SYSFS_SYSTEM_PATH "/cpu/cpu0")) {
        do {
            i++;
            VIR_FREE(cpupath);
            if (virAsprintf(&cpupath, "%s/cpu/cpu%d",
                            SYSFS_SYSTEM_PATH, i) < 0) {
                virReportOOMError();
                return -1;
            }
        } while (virFileExists(cpupath));
    } else {
        /* no cpu/cpu0: we give up */
        virReportError(VIR_ERR_NO_SUPPORT, "%s",
                       _("host cpu counting not supported on this node"));
        return -1;
    }

    VIR_FREE(cpupath);
    return i;
R
Roman Bogorodskiy 已提交
1067 1068
#elif defined(__FreeBSD__)
    return freebsdNodeGetCPUCount();
1069 1070 1071 1072 1073 1074 1075
#else
    virReportError(VIR_ERR_NO_SUPPORT, "%s",
                   _("host cpu counting not implemented on this platform"));
    return -1;
#endif
}

H
Hu Tao 已提交
1076
virBitmapPtr
1077
nodeGetCPUBitmap(int *max_id ATTRIBUTE_UNUSED)
1078 1079
{
#ifdef __linux__
H
Hu Tao 已提交
1080
    virBitmapPtr cpumap;
1081 1082
    int present;

E
Eric Blake 已提交
1083
    present = nodeGetCPUCount();
1084
    if (present < 0)
1085
        return NULL;
E
Eric Blake 已提交
1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106

    if (virFileExists(SYSFS_SYSTEM_PATH "/cpu/online")) {
        cpumap = linuxParseCPUmap(present, SYSFS_SYSTEM_PATH "/cpu/online");
    } else {
        int i;

        cpumap = virBitmapNew(present);
        if (!cpumap) {
            virReportOOMError();
            return NULL;
        }
        for (i = 0; i < present; i++) {
            int online = virNodeGetCpuValue(SYSFS_SYSTEM_PATH, i, "online", 1);
            if (online < 0) {
                virBitmapFree(cpumap);
                return NULL;
            }
            if (online)
                ignore_value(virBitmapSetBit(cpumap, i));
        }
    }
1107 1108
    if (max_id && cpumap)
        *max_id = present;
1109 1110
    return cpumap;
#else
1111 1112
    virReportError(VIR_ERR_NO_SUPPORT, "%s",
                   _("node cpumap not implemented on this platform"));
1113 1114 1115 1116
    return NULL;
#endif
}

1117
#ifdef __linux__
1118
static int
1119
nodeSetMemoryParameterValue(virTypedParameterPtr param)
1120 1121 1122 1123 1124 1125
{
    char *path = NULL;
    char *strval = NULL;
    int ret = -1;
    int rc = -1;

1126
    char *field = strchr(param->field, '_');
1127
    sa_assert(field);
1128
    field++;
1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
    if (virAsprintf(&path, "%s/%s",
                    SYSFS_MEMORY_SHARED_PATH, field) < 0) {
        virReportOOMError();
        ret = -2;
        goto cleanup;
    }

    if (virAsprintf(&strval, "%u", param->value.ui) == -1) {
        virReportOOMError();
        ret = -2;
        goto cleanup;
    }

    if ((rc = virFileWriteStr(path, strval, 0)) < 0) {
1143
        virReportSystemError(-rc, _("failed to set %s"), param->field);
1144 1145 1146 1147 1148 1149 1150 1151 1152
        goto cleanup;
    }

    ret = 0;
cleanup:
    VIR_FREE(path);
    VIR_FREE(strval);
    return ret;
}
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164

static bool
nodeMemoryParametersIsAllSupported(virTypedParameterPtr params,
                                   int nparams)
{
    char *path = NULL;
    int i;

    for (i = 0; i < nparams; i++) {
        virTypedParameterPtr param = &params[i];

        char *field = strchr(param->field, '_');
1165
        sa_assert(field);
1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
        field++;
        if (virAsprintf(&path, "%s/%s",
                        SYSFS_MEMORY_SHARED_PATH, field) < 0) {
            virReportOOMError();
            return false;
        }

        if (!virFileExists(path)) {
            virReportError(VIR_ERR_OPERATION_INVALID,
                           _("Parameter '%s' is not supported by "
                             "this kernel"), param->field);
            VIR_FREE(path);
            return false;
        }

        VIR_FREE(path);
    }

    return true;
}
1186
#endif
1187 1188 1189

int
nodeSetMemoryParameters(virConnectPtr conn ATTRIBUTE_UNUSED,
1190 1191
                        virTypedParameterPtr params ATTRIBUTE_UNUSED,
                        int nparams ATTRIBUTE_UNUSED,
1192 1193 1194 1195 1196 1197
                        unsigned int flags)
{
    virCheckFlags(0, -1);

#ifdef __linux__
    int i;
1198
    int rc;
1199 1200 1201 1202 1203 1204

    if (virTypedParameterArrayValidate(params, nparams,
                                       VIR_NODE_MEMORY_SHARED_PAGES_TO_SCAN,
                                       VIR_TYPED_PARAM_UINT,
                                       VIR_NODE_MEMORY_SHARED_SLEEP_MILLISECS,
                                       VIR_TYPED_PARAM_UINT,
1205 1206
                                       VIR_NODE_MEMORY_SHARED_MERGE_ACROSS_NODES,
                                       VIR_TYPED_PARAM_UINT,
1207 1208 1209
                                       NULL) < 0)
        return -1;

1210 1211
    if (!nodeMemoryParametersIsAllSupported(params, nparams))
        return -1;
1212

1213 1214
    for (i = 0; i < nparams; i++) {
        rc = nodeSetMemoryParameterValue(&params[i]);
1215

1216 1217 1218
        /* Out of memory */
        if (rc == -2)
            return -1;
1219 1220
    }

1221
    return 0;
1222 1223 1224 1225 1226 1227 1228 1229
#else
    virReportError(VIR_ERR_NO_SUPPORT, "%s",
                   _("node set memory parameters not implemented"
                     " on this platform"));
    return -1;
#endif
}

1230
#ifdef __linux__
1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246
static int
nodeGetMemoryParameterValue(const char *field,
                            void *value)
{
    char *path = NULL;
    char *buf = NULL;
    char *tmp = NULL;
    int ret = -1;
    int rc = -1;

    if (virAsprintf(&path, "%s/%s",
                    SYSFS_MEMORY_SHARED_PATH, field) < 0) {
        virReportOOMError();
        goto cleanup;
    }

1247 1248 1249 1250 1251
    if (!virFileExists(path)) {
        ret = -2;
        goto cleanup;
    }

1252 1253 1254 1255 1256 1257
    if (virFileReadAll(path, 1024, &buf) < 0)
        goto cleanup;

    if ((tmp = strchr(buf, '\n')))
        *tmp = '\0';

1258 1259 1260
    if (STREQ(field, "pages_to_scan")   ||
        STREQ(field, "sleep_millisecs") ||
        STREQ(field, "merge_across_nodes"))
1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280
        rc = virStrToLong_ui(buf, NULL, 10, (unsigned int *)value);
    else if (STREQ(field, "pages_shared")    ||
             STREQ(field, "pages_sharing")   ||
             STREQ(field, "pages_unshared")  ||
             STREQ(field, "pages_volatile")  ||
             STREQ(field, "full_scans"))
        rc = virStrToLong_ull(buf, NULL, 10, (unsigned long long *)value);

    if (rc < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("failed to parse %s"), field);
        goto cleanup;
    }

    ret = 0;
cleanup:
    VIR_FREE(path);
    VIR_FREE(buf);
    return ret;
}
1281
#endif
1282

1283
#define NODE_MEMORY_PARAMETERS_NUM 8
1284 1285
int
nodeGetMemoryParameters(virConnectPtr conn ATTRIBUTE_UNUSED,
1286 1287
                        virTypedParameterPtr params ATTRIBUTE_UNUSED,
                        int *nparams ATTRIBUTE_UNUSED,
1288 1289 1290 1291 1292 1293 1294
                        unsigned int flags)
{
    virCheckFlags(VIR_TYPED_PARAM_STRING_OKAY, -1);

#ifdef __linux__
    unsigned int pages_to_scan;
    unsigned int sleep_millisecs;
1295
    unsigned int merge_across_nodes;
1296 1297 1298 1299 1300 1301
    unsigned long long pages_shared;
    unsigned long long pages_sharing;
    unsigned long long pages_unshared;
    unsigned long long pages_volatile;
    unsigned long long full_scans = 0;
    int i;
1302
    int ret;
1303 1304 1305 1306 1307 1308 1309 1310 1311

    if ((*nparams) == 0) {
        *nparams = NODE_MEMORY_PARAMETERS_NUM;
        return 0;
    }

    for (i = 0; i < *nparams && i < NODE_MEMORY_PARAMETERS_NUM; i++) {
        virTypedParameterPtr param = &params[i];

1312
        switch (i) {
1313
        case 0:
1314 1315 1316 1317
            ret = nodeGetMemoryParameterValue("pages_to_scan", &pages_to_scan);
            if (ret == -2)
                continue;
            else if (ret == -1)
1318 1319 1320 1321 1322 1323 1324 1325 1326
                return -1;

            if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_PAGES_TO_SCAN,
                                        VIR_TYPED_PARAM_UINT, pages_to_scan) < 0)
                return -1;

            break;

        case 1:
1327 1328 1329 1330
            ret = nodeGetMemoryParameterValue("sleep_millisecs", &sleep_millisecs);
            if (ret == -2)
                continue;
            else if (ret == -1)
1331 1332 1333 1334 1335 1336 1337 1338 1339
                return -1;

            if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_SLEEP_MILLISECS,
                                        VIR_TYPED_PARAM_UINT, sleep_millisecs) < 0)
                return -1;

            break;

        case 2:
1340 1341 1342 1343
            ret = nodeGetMemoryParameterValue("pages_shared", &pages_shared);
            if (ret == -2)
                continue;
            else if (ret == -1)
1344 1345 1346 1347 1348 1349 1350 1351 1352
                return -1;

            if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_PAGES_SHARED,
                                        VIR_TYPED_PARAM_ULLONG, pages_shared) < 0)
                return -1;

            break;

        case 3:
1353 1354 1355 1356
            ret = nodeGetMemoryParameterValue("pages_sharing", &pages_sharing);
            if (ret == -2)
                continue;
            else if (ret == -1)
1357 1358 1359 1360 1361 1362 1363 1364 1365
                return -1;

            if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_PAGES_SHARING,
                                        VIR_TYPED_PARAM_ULLONG, pages_sharing) < 0)
                return -1;

            break;

        case 4:
1366 1367 1368 1369
            ret = nodeGetMemoryParameterValue("pages_unshared", &pages_unshared);
            if (ret == -2)
                continue;
            else if (ret == -1)
1370 1371 1372 1373 1374 1375 1376 1377 1378
                return -1;

            if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_PAGES_UNSHARED,
                                        VIR_TYPED_PARAM_ULLONG, pages_unshared) < 0)
                return -1;

            break;

        case 5:
1379 1380 1381 1382
            ret = nodeGetMemoryParameterValue("pages_volatile", &pages_volatile);
            if (ret == -2)
                continue;
            else if (ret == -1)
1383 1384 1385 1386 1387 1388 1389 1390 1391
                return -1;

            if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_PAGES_VOLATILE,
                                        VIR_TYPED_PARAM_ULLONG, pages_volatile) < 0)
                return -1;

            break;

        case 6:
1392 1393 1394 1395
            ret = nodeGetMemoryParameterValue("full_scans", &full_scans);
            if (ret == -2)
                continue;
            else if (ret == -1)
1396 1397 1398 1399 1400 1401 1402 1403
                return -1;

            if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_FULL_SCANS,
                                        VIR_TYPED_PARAM_ULLONG, full_scans) < 0)
                return -1;

            break;

1404
        case 7:
1405 1406 1407 1408
            ret = nodeGetMemoryParameterValue("merge_across_nodes", &merge_across_nodes);
            if (ret == -2)
                continue;
            else if (ret == -1)
1409 1410 1411 1412 1413 1414 1415 1416
                return -1;

            if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_MERGE_ACROSS_NODES,
                                        VIR_TYPED_PARAM_UINT, merge_across_nodes) < 0)
                return -1;

            break;

1417
        /* coverity[dead_error_begin] */
1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431
        default:
            break;
        }
    }

    return 0;
#else
    virReportError(VIR_ERR_NO_SUPPORT, "%s",
                   _("node get memory parameters not implemented"
                     " on this platform"));
    return -1;
#endif
}

1432 1433 1434 1435 1436
int
nodeGetCPUMap(virConnectPtr conn ATTRIBUTE_UNUSED,
              unsigned char **cpumap,
              unsigned int *online,
              unsigned int flags)
1437 1438 1439 1440 1441 1442 1443 1444
{
    virBitmapPtr cpus = NULL;
    int maxpresent;
    int ret = -1;
    int dummy;

    virCheckFlags(0, -1);

1445 1446 1447
    if (!cpumap && !online)
        return nodeGetCPUCount();

1448
    if (!(cpus = nodeGetCPUBitmap(&maxpresent)))
1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463
        goto cleanup;

    if (cpumap && virBitmapToData(cpus, cpumap, &dummy) < 0)
        goto cleanup;
    if (online)
        *online = virBitmapCountBits(cpus);

    ret = maxpresent;
cleanup:
    if (ret < 0 && cpumap)
        VIR_FREE(*cpumap);
    virBitmapFree(cpus);
    return ret;
}

1464
#if WITH_NUMACTL
1465 1466 1467 1468 1469 1470 1471 1472 1473 1474
# if LIBNUMA_API_VERSION <= 1
#  define NUMA_MAX_N_CPUS 4096
# else
#  define NUMA_MAX_N_CPUS (numa_all_cpus_ptr->size)
# endif

# define n_bits(var) (8 * sizeof(var))
# define MASK_CPU_ISSET(mask, cpu) \
  (((mask)[((cpu) / n_bits(*(mask)))] >> ((cpu) % n_bits(*(mask)))) & 1)

1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527
static virBitmapPtr
virNodeGetSiblingsList(const char *dir, int cpu_id)
{
    char *path = NULL;
    char *buf = NULL;
    virBitmapPtr ret = NULL;

    if (virAsprintf(&path, "%s/cpu%u/topology/thread_siblings_list",
                    dir, cpu_id) < 0) {
        virReportOOMError();
        goto cleanup;
    }

    if (virFileReadAll(path, SYSFS_THREAD_SIBLINGS_LIST_LENGTH_MAX, &buf) < 0)
        goto cleanup;

    if (virBitmapParse(buf, 0, &ret, NUMA_MAX_N_CPUS) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("Failed to parse thread siblings"));
        goto cleanup;
    }

cleanup:
    VIR_FREE(buf);
    VIR_FREE(path);
    return ret;
}

/* returns 1 on success, 0 if the detection failed and -1 on hard error */
static int
virNodeCapsFillCPUInfo(int cpu_id, virCapsHostNUMACellCPUPtr cpu)
{
    int tmp;
    cpu->id = cpu_id;

    if ((tmp = virNodeGetCpuValue(SYSFS_CPU_PATH, cpu_id,
                                  "topology/physical_package_id", -1)) < 0)
        return 0;

    cpu->socket_id = tmp;

    if ((tmp = virNodeGetCpuValue(SYSFS_CPU_PATH, cpu_id,
                                  "topology/core_id", -1)) < 0)
        return 0;

    cpu->core_id = tmp;

    if (!(cpu->siblings = virNodeGetSiblingsList(SYSFS_CPU_PATH, cpu_id)))
        return -1;

    return 0;
}

1528
int
1529
nodeCapsInitNUMA(virCapsPtr caps)
1530 1531
{
    int n;
1532
    unsigned long *mask = NULL;
1533
    unsigned long *allonesmask = NULL;
1534
    virCapsHostNUMACellCPUPtr cpus = NULL;
1535 1536
    int ret = -1;
    int max_n_cpus = NUMA_MAX_N_CPUS;
1537
    int ncpus = 0;
1538
    bool topology_failed = false;
1539 1540 1541 1542 1543

    if (numa_available() < 0)
        return 0;

    int mask_n_bytes = max_n_cpus / 8;
1544
    if (VIR_ALLOC_N(mask, mask_n_bytes / sizeof(*mask)) < 0)
1545
        goto cleanup;
1546
    if (VIR_ALLOC_N(allonesmask, mask_n_bytes / sizeof(*mask)) < 0)
1547 1548
        goto cleanup;
    memset(allonesmask, 0xff, mask_n_bytes);
1549 1550 1551

    for (n = 0 ; n <= numa_max_node() ; n++) {
        int i;
1552
        /* The first time this returns -1, ENOENT if node doesn't exist... */
1553 1554
        if (numa_node_to_cpus(n, mask, mask_n_bytes) < 0) {
            VIR_WARN("NUMA topology for cell %d of %d not available, ignoring",
1555 1556 1557 1558 1559 1560 1561
                     n, numa_max_node()+1);
            continue;
        }
        /* second, third... times it returns an all-1's mask */
        if (memcmp(mask, allonesmask, mask_n_bytes) == 0) {
            VIR_DEBUG("NUMA topology for cell %d of %d is all ones, ignoring",
                      n, numa_max_node()+1);
1562 1563
            continue;
        }
1564 1565 1566 1567 1568 1569 1570 1571

        for (ncpus = 0, i = 0 ; i < max_n_cpus ; i++)
            if (MASK_CPU_ISSET(mask, i))
                ncpus++;

        if (VIR_ALLOC_N(cpus, ncpus) < 0)
            goto cleanup;

1572 1573 1574 1575 1576 1577 1578 1579
        for (ncpus = 0, i = 0 ; i < max_n_cpus ; i++) {
            if (MASK_CPU_ISSET(mask, i)) {
                if (virNodeCapsFillCPUInfo(i, cpus + ncpus++) < 0) {
                    topology_failed = true;
                    virResetLastError();
                }
            }
        }
1580

1581
        if (virCapabilitiesAddHostNUMACell(caps, n, ncpus, cpus) < 0)
1582 1583 1584 1585 1586 1587
            goto cleanup;
    }

    ret = 0;

cleanup:
1588 1589 1590 1591 1592 1593
    if (topology_failed || ret < 0)
        virCapabilitiesClearHostNUMACellCPUTopology(cpus, ncpus);

    if (ret < 0)
        VIR_FREE(cpus);

1594
    VIR_FREE(mask);
1595
    VIR_FREE(allonesmask);
1596 1597
    return ret;
}
1598 1599 1600


int
1601
nodeGetCellsFreeMemory(virConnectPtr conn ATTRIBUTE_UNUSED,
1602 1603 1604 1605 1606 1607 1608 1609 1610
                       unsigned long long *freeMems,
                       int startCell,
                       int maxCells)
{
    int n, lastCell, numCells;
    int ret = -1;
    int maxCell;

    if (numa_available() < 0) {
1611 1612
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("NUMA not supported on this host"));
1613 1614 1615 1616
        goto cleanup;
    }
    maxCell = numa_max_node();
    if (startCell > maxCell) {
1617 1618 1619
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("start cell %d out of range (0-%d)"),
                       startCell, maxCell);
1620 1621 1622 1623 1624 1625 1626 1627 1628
        goto cleanup;
    }
    lastCell = startCell + maxCells - 1;
    if (lastCell > maxCell)
        lastCell = maxCell;

    for (numCells = 0, n = startCell ; n <= lastCell ; n++) {
        long long mem;
        if (numa_node_size64(n, &mem) < 0) {
1629
            virReportError(VIR_ERR_INTERNAL_ERROR,
1630 1631
                           _("Failed to query NUMA free memory for node: %d"),
                           n);
1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642
            goto cleanup;
        }
        freeMems[numCells++] = mem;
    }
    ret = numCells;

cleanup:
    return ret;
}

unsigned long long
1643
nodeGetFreeMemory(virConnectPtr conn ATTRIBUTE_UNUSED)
1644 1645 1646 1647 1648
{
    unsigned long long freeMem = 0;
    int n;

    if (numa_available() < 0) {
1649 1650
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("NUMA not supported on this host"));
1651 1652 1653 1654 1655 1656
        goto cleanup;
    }

    for (n = 0 ; n <= numa_max_node() ; n++) {
        long long mem;
        if (numa_node_size64(n, &mem) < 0) {
1657 1658
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("Failed to query NUMA free memory"));
1659 1660 1661 1662 1663 1664 1665 1666 1667
            goto cleanup;
        }
        freeMem += mem;
    }

cleanup:
    return freeMem;
}

1668
#else
1669 1670 1671 1672
int nodeCapsInitNUMA(virCapsPtr caps ATTRIBUTE_UNUSED) {
    return 0;
}

1673
int nodeGetCellsFreeMemory(virConnectPtr conn ATTRIBUTE_UNUSED,
1674 1675 1676 1677
                              unsigned long long *freeMems ATTRIBUTE_UNUSED,
                              int startCell ATTRIBUTE_UNUSED,
                              int maxCells ATTRIBUTE_UNUSED)
{
1678 1679
    virReportError(VIR_ERR_NO_SUPPORT, "%s",
                   _("NUMA memory information not available on this platform"));
1680 1681 1682
    return -1;
}

1683
unsigned long long nodeGetFreeMemory(virConnectPtr conn ATTRIBUTE_UNUSED)
1684
{
1685 1686
    virReportError(VIR_ERR_NO_SUPPORT, "%s",
                   _("NUMA memory information not available on this platform"));
1687 1688
    return 0;
}
1689
#endif