cgroup.c 38.7 KB
Newer Older
1 2 3
/*
 * cgroup.c: Tools for managing cgroups
 *
4
 * Copyright (C) 2010-2011 Red Hat, Inc.
5 6 7 8 9 10 11 12 13 14 15
 * Copyright IBM Corp. 2008
 *
 * See COPYING.LIB for the License of this software
 *
 * Authors:
 *  Dan Smith <danms@us.ibm.com>
 */
#include <config.h>

#include <stdio.h>
#include <stdint.h>
16
#if defined HAVE_MNTENT_H && defined HAVE_GETMNTENT_R
17
# include <mntent.h>
D
Daniel P. Berrange 已提交
18
#endif
19 20 21 22 23 24
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
25
#include <signal.h>
26
#include <libgen.h>
27
#include <dirent.h>
28 29 30 31 32

#include "internal.h"
#include "util.h"
#include "memory.h"
#include "cgroup.h"
33
#include "logging.h"
34
#include "files.h"
35
#include "hash.h"
36 37 38

#define CGROUP_MAX_VAL 512

39
VIR_ENUM_IMPL(virCgroupController, VIR_CGROUP_CONTROLLER_LAST,
R
Ryota Ozaki 已提交
40
              "cpu", "cpuacct", "cpuset", "memory", "devices",
41
              "freezer", "blkio");
42 43 44 45 46 47

struct virCgroupController {
    int type;
    char *mountPoint;
    char *placement;
};
48 49 50

struct virCgroup {
    char *path;
51 52

    struct virCgroupController controllers[VIR_CGROUP_CONTROLLER_LAST];
53 54 55 56 57 58 59 60 61
};

/**
 * virCgroupFree:
 *
 * @group: The group structure to free
 */
void virCgroupFree(virCgroupPtr *group)
{
62 63 64 65 66 67 68 69
    int i;

    if (*group == NULL)
        return;

    for (i = 0 ; i < VIR_CGROUP_CONTROLLER_LAST ; i++) {
        VIR_FREE((*group)->controllers[i].mountPoint);
        VIR_FREE((*group)->controllers[i].placement);
70
    }
71 72 73

    VIR_FREE((*group)->path);
    VIR_FREE(*group);
74 75
}

L
Lai Jiangshan 已提交
76 77 78 79 80 81 82 83 84 85 86 87 88
/**
 * virCgroupMounted: query whether a cgroup subsystem is mounted or not
 *
 * @cgroup: The group structure to be queried
 * @controller: cgroup subsystem id
 *
 * Returns true if a cgroup is subsystem is mounted.
 */
bool virCgroupMounted(virCgroupPtr cgroup, int controller)
{
    return cgroup->controllers[controller].mountPoint != NULL;
}

89
#if defined HAVE_MNTENT_H && defined HAVE_GETMNTENT_R
90 91 92 93 94
/*
 * Process /proc/mounts figuring out what controllers are
 * mounted and where
 */
static int virCgroupDetectMounts(virCgroupPtr group)
95
{
96
    int i;
97
    FILE *mounts = NULL;
98 99 100 101 102
    struct mntent entry;
    char buf[CGROUP_MAX_VAL];

    mounts = fopen("/proc/mounts", "r");
    if (mounts == NULL) {
103
        VIR_ERROR0(_("Unable to open /proc/mounts"));
104
        return -ENOENT;
105 106 107
    }

    while (getmntent_r(mounts, &entry, buf, sizeof(buf)) != NULL) {
108 109
        if (STRNEQ(entry.mnt_type, "cgroup"))
            continue;
110

111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129
        for (i = 0 ; i < VIR_CGROUP_CONTROLLER_LAST ; i++) {
            const char *typestr = virCgroupControllerTypeToString(i);
            int typelen = strlen(typestr);
            char *tmp = entry.mnt_opts;
            while (tmp) {
                char *next = strchr(tmp, ',');
                int len;
                if (next) {
                    len = next-tmp;
                    next++;
                } else {
                    len = strlen(tmp);
                }
                if (typelen == len && STREQLEN(typestr, tmp, len) &&
                    !(group->controllers[i].mountPoint = strdup(entry.mnt_dir)))
                    goto no_memory;
                tmp = next;
            }
        }
130 131
    }

132
    VIR_FORCE_FCLOSE(mounts);
133

134
    return 0;
135

136
no_memory:
137
    VIR_FORCE_FCLOSE(mounts);
138
    return -ENOMEM;
139 140
}

141 142 143 144 145

/*
 * Process /proc/self/cgroup figuring out what cgroup
 * sub-path the current process is assigned to. ie not
 * neccessarily in the root
146
 */
147
static int virCgroupDetectPlacement(virCgroupPtr group)
148 149
{
    int i;
150 151
    FILE *mapping  = NULL;
    char line[1024];
152

153 154
    mapping = fopen("/proc/self/cgroup", "r");
    if (mapping == NULL) {
155
        VIR_ERROR0(_("Unable to open /proc/self/cgroup"));
156
        return -ENOENT;
157 158
    }

159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195
    while (fgets(line, sizeof(line), mapping) != NULL) {
        char *controllers = strchr(line, ':');
        char *path = controllers ? strchr(controllers+1, ':') : NULL;
        char *nl = path ? strchr(path, '\n') : NULL;

        if (!controllers || !path)
            continue;

        if (nl)
            *nl = '\0';

        *path = '\0';
        controllers++;
        path++;

        for (i = 0 ; i < VIR_CGROUP_CONTROLLER_LAST ; i++) {
            const char *typestr = virCgroupControllerTypeToString(i);
            int typelen = strlen(typestr);
            char *tmp = controllers;
            while (tmp) {
                char *next = strchr(tmp, ',');
                int len;
                if (next) {
                    len = next-tmp;
                    next++;
                } else {
                    len = strlen(tmp);
                }
                if (typelen == len && STREQLEN(typestr, tmp, len) &&
                    !(group->controllers[i].placement = strdup(STREQ(path, "/") ? "" : path)))
                    goto no_memory;

                tmp = next;
            }
        }
    }

196
    VIR_FORCE_FCLOSE(mapping);
197

198
    return 0;
199 200

no_memory:
201
    VIR_FORCE_FCLOSE(mapping);
202 203
    return -ENOMEM;

204 205
}

206
static int virCgroupDetect(virCgroupPtr group)
207
{
208 209 210
    int any = 0;
    int rc;
    int i;
211

212 213
    rc = virCgroupDetectMounts(group);
    if (rc < 0) {
214
        VIR_ERROR(_("Failed to detect mounts for %s"), group->path);
215
        return rc;
216 217
    }

218 219 220 221 222 223 224
    /* Check that at least 1 controller is available */
    for (i = 0 ; i < VIR_CGROUP_CONTROLLER_LAST ; i++) {
        if (group->controllers[i].mountPoint != NULL)
            any = 1;
    }
    if (!any)
        return -ENXIO;
225 226


227
    rc = virCgroupDetectPlacement(group);
228

229 230 231 232 233
    if (rc == 0) {
        /* Check that for every mounted controller, we found our placement */
        for (i = 0 ; i < VIR_CGROUP_CONTROLLER_LAST ; i++) {
            if (!group->controllers[i].mountPoint)
                continue;
234

235
            if (!group->controllers[i].placement) {
236
                VIR_ERROR(_("Could not find placement for controller %s at %s"),
237 238 239 240 241
                          virCgroupControllerTypeToString(i),
                          group->controllers[i].placement);
                rc = -ENOENT;
                break;
            }
242

243 244 245 246 247 248
            VIR_DEBUG("Detected mount/mapping %i:%s at %s in %s", i,
                      virCgroupControllerTypeToString(i),
                      group->controllers[i].mountPoint,
                      group->controllers[i].placement);
        }
    } else {
249
        VIR_ERROR(_("Failed to detect mapping for %s"), group->path);
250 251 252 253
    }

    return rc;
}
D
Daniel P. Berrange 已提交
254
#endif
255

256 257 258 259 260 261

static int virCgroupPathOfController(virCgroupPtr group,
                                     int controller,
                                     const char *key,
                                     char **path)
{
262 263 264 265 266 267 268 269 270 271 272 273 274
    if (controller == -1) {
        int i;
        for (i = 0 ; i < VIR_CGROUP_CONTROLLER_LAST ; i++) {
            if (group->controllers[i].mountPoint &&
                group->controllers[i].placement) {
                controller = i;
                break;
            }
        }
    }
    if (controller == -1)
        return -ENOSYS;

275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
    if (group->controllers[controller].mountPoint == NULL)
        return -ENOENT;

    if (group->controllers[controller].placement == NULL)
        return -ENOENT;

    if (virAsprintf(path, "%s%s%s/%s",
                    group->controllers[controller].mountPoint,
                    group->controllers[controller].placement,
                    STREQ(group->path, "/") ? "" : group->path,
                    key ? key : "") == -1)
        return -ENOMEM;

    return 0;
}


292
static int virCgroupSetValueStr(virCgroupPtr group,
293
                                int controller,
294 295 296 297 298 299
                                const char *key,
                                const char *value)
{
    int rc = 0;
    char *keypath = NULL;

300
    rc = virCgroupPathOfController(group, controller, key, &keypath);
301 302 303
    if (rc != 0)
        return rc;

304
    VIR_DEBUG("Set value '%s' to '%s'", keypath, value);
305
    rc = virFileWriteStr(keypath, value, 0);
306 307
    if (rc < 0) {
        rc = -errno;
308
        VIR_DEBUG("Failed to write value '%s': %m", value);
309 310
    } else {
        rc = 0;
311 312 313 314 315 316 317 318
    }

    VIR_FREE(keypath);

    return rc;
}

static int virCgroupGetValueStr(virCgroupPtr group,
319
                                int controller,
320 321 322 323 324 325
                                const char *key,
                                char **value)
{
    int rc;
    char *keypath = NULL;

326
    *value = NULL;
327

328
    rc = virCgroupPathOfController(group, controller, key, &keypath);
329
    if (rc != 0) {
330
        VIR_DEBUG("No path of %s, %s", group->path, key);
331 332 333
        return rc;
    }

334
    VIR_DEBUG("Get value %s", keypath);
335

336
    rc = virFileReadAll(keypath, 1024, value);
337 338
    if (rc < 0) {
        rc = -errno;
339
        VIR_DEBUG("Failed to read %s: %m\n", keypath);
340
    } else {
341 342 343 344
        /* Terminated with '\n' has sometimes harmful effects to the caller */
        char *p = strchr(*value, '\n');
        if (p) *p = '\0';

345
        rc = 0;
346 347 348 349 350 351 352
    }

    VIR_FREE(keypath);

    return rc;
}

353
static int virCgroupSetValueU64(virCgroupPtr group,
354
                                int controller,
355
                                const char *key,
D
Daniel P. Berrange 已提交
356
                                unsigned long long int value)
357 358 359 360
{
    char *strval = NULL;
    int rc;

D
Daniel P. Berrange 已提交
361
    if (virAsprintf(&strval, "%llu", value) == -1)
362 363
        return -ENOMEM;

364
    rc = virCgroupSetValueStr(group, controller, key, strval);
365 366 367 368 369 370 371

    VIR_FREE(strval);

    return rc;
}


372 373

static int virCgroupSetValueI64(virCgroupPtr group,
374
                                int controller,
375
                                const char *key,
D
Daniel P. Berrange 已提交
376
                                long long int value)
377 378 379 380
{
    char *strval = NULL;
    int rc;

D
Daniel P. Berrange 已提交
381
    if (virAsprintf(&strval, "%lld", value) == -1)
382 383
        return -ENOMEM;

384
    rc = virCgroupSetValueStr(group, controller, key, strval);
385 386 387 388 389 390

    VIR_FREE(strval);

    return rc;
}

391 392
#if 0
/* This is included for completeness, but not yet used */
393
static int virCgroupGetValueI64(virCgroupPtr group,
394
                                int controller,
395
                                const char *key,
D
Daniel P. Berrange 已提交
396
                                long long int *value)
397 398 399 400
{
    char *strval = NULL;
    int rc = 0;

401
    rc = virCgroupGetValueStr(group, controller, key, &strval);
402 403 404
    if (rc != 0)
        goto out;

405
    if (virStrToLong_ll(strval, NULL, 10, value) < 0)
406 407 408 409 410 411
        rc = -EINVAL;
out:
    VIR_FREE(strval);

    return rc;
}
412
#endif
413

414
static int virCgroupGetValueU64(virCgroupPtr group,
415
                                int controller,
416
                                const char *key,
D
Daniel P. Berrange 已提交
417
                                unsigned long long int *value)
418 419 420 421
{
    char *strval = NULL;
    int rc = 0;

422
    rc = virCgroupGetValueStr(group, controller, key, &strval);
423 424 425
    if (rc != 0)
        goto out;

D
Daniel P. Berrange 已提交
426
    if (virStrToLong_ull(strval, NULL, 10, value) < 0)
427 428 429 430 431 432 433 434
        rc = -EINVAL;
out:
    VIR_FREE(strval);

    return rc;
}


435
#if defined HAVE_MNTENT_H && defined HAVE_GETMNTENT_R
436
static int virCgroupCpuSetInherit(virCgroupPtr parent, virCgroupPtr group)
437 438 439 440 441 442 443 444
{
    int i;
    int rc = 0;
    const char *inherit_values[] = {
        "cpuset.cpus",
        "cpuset.mems",
    };

445 446 447
    VIR_DEBUG("Setting up inheritance %s -> %s", parent->path, group->path);
    for (i = 0; i < ARRAY_CARDINALITY(inherit_values) ; i++) {
        char *value;
448

449 450 451 452
        rc = virCgroupGetValueStr(parent,
                                  VIR_CGROUP_CONTROLLER_CPUSET,
                                  inherit_values[i],
                                  &value);
453
        if (rc != 0) {
454
            VIR_ERROR(_("Failed to get %s %d"), inherit_values[i], rc);
455 456 457 458 459 460 461 462 463
            break;
        }

        VIR_DEBUG("Inherit %s = %s", inherit_values[i], value);

        rc = virCgroupSetValueStr(group,
                                  VIR_CGROUP_CONTROLLER_CPUSET,
                                  inherit_values[i],
                                  value);
464
        VIR_FREE(value);
465 466

        if (rc != 0) {
467
            VIR_ERROR(_("Failed to set %s %d"), inherit_values[i], rc);
468 469 470 471 472 473 474
            break;
        }
    }

    return rc;
}

475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506
static int virCgroupSetMemoryUseHierarchy(virCgroupPtr group)
{
    int rc = 0;
    unsigned long long value;
    const char *filename = "memory.use_hierarchy";

    rc = virCgroupGetValueU64(group,
                              VIR_CGROUP_CONTROLLER_MEMORY,
                              filename, &value);
    if (rc != 0) {
        VIR_ERROR(_("Failed to read %s/%s (%d)"), group->path, filename, rc);
        return rc;
    }

    /* Setting twice causes error, so if already enabled, skip setting */
    if (value == 1)
        return 0;

    VIR_DEBUG("Setting up %s/%s", group->path, filename);
    rc = virCgroupSetValueU64(group,
                              VIR_CGROUP_CONTROLLER_MEMORY,
                              filename, 1);

    if (rc != 0) {
        VIR_ERROR(_("Failed to set %s/%s (%d)"), group->path, filename, rc);
    }

    return rc;
}

static int virCgroupMakeGroup(virCgroupPtr parent, virCgroupPtr group,
                              int create, bool memory_hierarchy)
507 508 509 510
{
    int i;
    int rc = 0;

511
    VIR_DEBUG("Make group %s", group->path);
512
    for (i = 0 ; i < VIR_CGROUP_CONTROLLER_LAST ; i++) {
513 514
        char *path = NULL;

515 516
        /* Skip over controllers that aren't mounted */
        if (!group->controllers[i].mountPoint)
517 518
            continue;

519 520 521
        rc = virCgroupPathOfController(group, i, "", &path);
        if (rc < 0)
            return rc;
522 523 524
        /* As of Feb 2011, clang can't see that the above function
         * call did not modify group. */
        sa_assert(group->controllers[i].mountPoint);
525

526
        VIR_DEBUG("Make controller %s", path);
527
        if (access(path, F_OK) != 0) {
528 529
            if (!create ||
                mkdir(path, 0755) < 0) {
530 531 532 533
                rc = -errno;
                VIR_FREE(path);
                break;
            }
534 535 536 537
            if (group->controllers[VIR_CGROUP_CONTROLLER_CPUSET].mountPoint != NULL &&
                (i == VIR_CGROUP_CONTROLLER_CPUSET ||
                 STREQ(group->controllers[i].mountPoint, group->controllers[VIR_CGROUP_CONTROLLER_CPUSET].mountPoint))) {
                rc = virCgroupCpuSetInherit(parent, group);
538 539
                if (rc != 0) {
                    VIR_FREE(path);
540
                    break;
541
                }
542
            }
543 544 545 546 547 548 549 550 551 552 553 554 555 556
            /*
             * Note that virCgroupSetMemoryUseHierarchy should always be
             * called prior to creating subcgroups and attaching tasks.
             */
            if (memory_hierarchy &&
                group->controllers[VIR_CGROUP_CONTROLLER_MEMORY].mountPoint != NULL &&
                (i == VIR_CGROUP_CONTROLLER_MEMORY ||
                 STREQ(group->controllers[i].mountPoint, group->controllers[VIR_CGROUP_CONTROLLER_MEMORY].mountPoint))) {
                rc = virCgroupSetMemoryUseHierarchy(group);
                if (rc != 0) {
                    VIR_FREE(path);
                    break;
                }
            }
557 558 559 560 561 562 563 564
        }

        VIR_FREE(path);
    }

    return rc;
}

565 566 567

static int virCgroupNew(const char *path,
                        virCgroupPtr *group)
568 569 570 571
{
    int rc = 0;
    char *typpath = NULL;

572 573
    VIR_DEBUG("New group %s", path);
    *group = NULL;
574

575
    if (VIR_ALLOC((*group)) != 0) {
576 577 578 579
        rc = -ENOMEM;
        goto err;
    }

580
    if (!((*group)->path = strdup(path))) {
581 582 583 584
        rc = -ENOMEM;
        goto err;
    }

585 586 587
    rc = virCgroupDetect(*group);
    if (rc < 0)
        goto err;
588 589 590

    return rc;
err:
591 592
    virCgroupFree(group);
    *group = NULL;
593 594 595 596 597 598

    VIR_FREE(typpath);

    return rc;
}

599
static int virCgroupAppRoot(int privileged,
600 601
                            virCgroupPtr *group,
                            int create)
602
{
603 604
    virCgroupPtr rootgrp = NULL;
    int rc;
605

606 607 608
    rc = virCgroupNew("/", &rootgrp);
    if (rc != 0)
        return rc;
609

610 611 612 613 614
    if (privileged) {
        rc = virCgroupNew("/libvirt", group);
    } else {
        char *rootname;
        char *username;
615
        username = virGetUserName(getuid());
616 617 618 619 620 621 622 623 624 625
        if (!username) {
            rc = -ENOMEM;
            goto cleanup;
        }
        rc = virAsprintf(&rootname, "/libvirt-%s", username);
        VIR_FREE(username);
        if (rc < 0) {
            rc = -ENOMEM;
            goto cleanup;
        }
626

627 628
        rc = virCgroupNew(rootname, group);
        VIR_FREE(rootname);
629 630
    }
    if (rc != 0)
631
        goto cleanup;
632

633
    rc = virCgroupMakeGroup(rootgrp, *group, create, false);
634

635 636
cleanup:
    virCgroupFree(&rootgrp);
637 638
    return rc;
}
D
Daniel P. Berrange 已提交
639
#endif
640

641
#if defined _DIRENT_HAVE_D_TYPE
642 643 644 645 646 647 648 649
static int virCgroupRemoveRecursively(char *grppath)
{
    DIR *grpdir;
    struct dirent *ent;
    int rc = 0;

    grpdir = opendir(grppath);
    if (grpdir == NULL) {
650 651
        if (errno == ENOENT)
            return 0;
652
        rc = -errno;
653
        VIR_ERROR(_("Unable to open %s (%d)"), grppath, errno);
654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
        return rc;
    }

    for (;;) {
        char *path;

        errno = 0;
        ent = readdir(grpdir);
        if (ent == NULL) {
            if ((rc = -errno))
                VIR_ERROR(_("Failed to readdir for %s (%d)"), grppath, errno);
            break;
        }

        if (ent->d_name[0] == '.') continue;
        if (ent->d_type != DT_DIR) continue;

        if (virAsprintf(&path, "%s/%s", grppath, ent->d_name) == -1) {
            rc = -ENOMEM;
            break;
        }
        rc = virCgroupRemoveRecursively(path);
        VIR_FREE(path);
        if (rc != 0)
            break;
    }
    closedir(grpdir);

682
    VIR_DEBUG("Removing cgroup %s", grppath);
683 684 685 686 687 688 689
    if (rmdir(grppath) != 0 && errno != ENOENT) {
        rc = -errno;
        VIR_ERROR(_("Unable to remove %s (%d)"), grppath, errno);
    }

    return rc;
}
690 691 692 693 694 695 696
#else
static int virCgroupRemoveRecursively(char *grppath ATTRIBUTE_UNUSED)
{
    /* Claim no support */
    return -ENXIO;
}
#endif
697

698 699 700 701 702
/**
 * virCgroupRemove:
 *
 * @group: The group to be removed
 *
703 704 705 706 707
 * It first removes all child groups recursively
 * in depth first order and then removes @group
 * because the presence of the child groups
 * prevents removing @group.
 *
708 709 710 711 712 713 714 715
 * Returns: 0 on success
 */
int virCgroupRemove(virCgroupPtr group)
{
    int rc = 0;
    int i;
    char *grppath = NULL;

716
    for (i = 0 ; i < VIR_CGROUP_CONTROLLER_LAST ; i++) {
717 718
        /* Skip over controllers not mounted */
        if (!group->controllers[i].mountPoint)
719 720
            continue;

721 722 723 724 725
        if (virCgroupPathOfController(group,
                                      i,
                                      NULL,
                                      &grppath) != 0)
            continue;
726

727
        VIR_DEBUG("Removing cgroup %s and all child cgroups", grppath);
728
        rc = virCgroupRemoveRecursively(grppath);
729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
        VIR_FREE(grppath);
    }

    return rc;
}

/**
 * virCgroupAddTask:
 *
 * @group: The cgroup to add a task to
 * @pid: The pid of the task to add
 *
 * Returns: 0 on success
 */
int virCgroupAddTask(virCgroupPtr group, pid_t pid)
{
    int rc = 0;
    int i;

748
    for (i = 0 ; i < VIR_CGROUP_CONTROLLER_LAST ; i++) {
749 750 751
        /* Skip over controllers not mounted */
        if (!group->controllers[i].mountPoint)
            continue;
752

753
        rc = virCgroupSetValueU64(group, i, "tasks", (unsigned long long)pid);
754 755 756 757 758 759 760
        if (rc != 0)
            break;
    }

    return rc;
}

761

762
/**
763
 * virCgroupForDriver:
764
 *
765
 * @name: name of this driver (e.g., xen, qemu, lxc)
766 767 768 769
 * @group: Pointer to returned virCgroupPtr
 *
 * Returns 0 on success
 */
770
#if defined HAVE_MNTENT_H && defined HAVE_GETMNTENT_R
771 772 773 774
int virCgroupForDriver(const char *name,
                       virCgroupPtr *group,
                       int privileged,
                       int create)
775 776
{
    int rc;
777
    char *path = NULL;
778
    virCgroupPtr rootgrp = NULL;
779

780
    rc = virCgroupAppRoot(privileged, &rootgrp, create);
781
    if (rc != 0)
782 783
        goto out;

784 785
    if (virAsprintf(&path, "%s/%s", rootgrp->path, name) < 0) {
        rc = -ENOMEM;
786
        goto out;
787
    }
788

789 790 791
    rc = virCgroupNew(path, group);
    VIR_FREE(path);

792
    if (rc == 0) {
793
        rc = virCgroupMakeGroup(rootgrp, *group, create, false);
794 795 796
        if (rc != 0)
            virCgroupFree(group);
    }
797

798
out:
799
    virCgroupFree(&rootgrp);
800 801 802

    return rc;
}
D
Daniel P. Berrange 已提交
803 804 805 806 807 808 809 810 811 812
#else
int virCgroupForDriver(const char *name ATTRIBUTE_UNUSED,
                       virCgroupPtr *group ATTRIBUTE_UNUSED,
                       int privileged ATTRIBUTE_UNUSED,
                       int create ATTRIBUTE_UNUSED)
{
    /* Claim no support */
    return -ENXIO;
}
#endif
813

814 815 816 817 818 819 820 821 822 823

/**
 * virCgroupForDomain:
 *
 * @driver: group for driver owning the domain
 * @name: name of the domain
 * @group: Pointer to returned virCgroupPtr
 *
 * Returns 0 on success
 */
824
#if defined HAVE_MNTENT_H && defined HAVE_GETMNTENT_R
825 826 827 828 829 830 831 832
int virCgroupForDomain(virCgroupPtr driver,
                       const char *name,
                       virCgroupPtr *group,
                       int create)
{
    int rc;
    char *path;

833 834 835
    if (driver == NULL)
        return -EINVAL;

836 837 838 839 840 841
    if (virAsprintf(&path, "%s/%s", driver->path, name) < 0)
        return -ENOMEM;

    rc = virCgroupNew(path, group);
    VIR_FREE(path);

842
    if (rc == 0) {
843 844 845 846 847 848 849 850 851 852 853
        /*
         * Create a cgroup with memory.use_hierarchy enabled to
         * surely account memory usage of lxc with ns subsystem
         * enabled. (To be exact, memory and ns subsystems are
         * enabled at the same time.)
         *
         * The reason why doing it here, not a upper group, say
         * a group for driver, is to avoid overhead to track
         * cumulative usage that we don't need.
         */
        rc = virCgroupMakeGroup(driver, *group, create, true);
854 855 856 857 858 859
        if (rc != 0)
            virCgroupFree(group);
    }

    return rc;
}
D
Daniel P. Berrange 已提交
860 861 862 863 864 865 866 867 868
#else
int virCgroupForDomain(virCgroupPtr driver ATTRIBUTE_UNUSED,
                       const char *name ATTRIBUTE_UNUSED,
                       virCgroupPtr *group ATTRIBUTE_UNUSED,
                       int create ATTRIBUTE_UNUSED)
{
    return -ENXIO;
}
#endif
869

870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908
/**
 * virCgroupSetBlkioWeight:
 *
 * @group: The cgroup to change io weight for
 * @weight: The Weight for this cgroup
 *
 * Returns: 0 on success
 */
int virCgroupSetBlkioWeight(virCgroupPtr group, unsigned int weight)
{
    if (weight > 1000 || weight < 100)
        return -EINVAL;

    return virCgroupSetValueU64(group,
                                VIR_CGROUP_CONTROLLER_BLKIO,
                                "blkio.weight",
                                weight);
}

/**
 * virCgroupGetBlkioWeight:
 *
 * @group: The cgroup to get weight for
 * @Weight: Pointer to returned weight
 *
 * Returns: 0 on success
 */
int virCgroupGetBlkioWeight(virCgroupPtr group, unsigned int *weight)
{
    unsigned long long tmp;
    int ret;
    ret = virCgroupGetValueU64(group,
                               VIR_CGROUP_CONTROLLER_BLKIO,
                               "blkio.weight", &tmp);
    if (ret == 0)
        *weight = tmp;
    return ret;
}

909 910 911 912 913 914 915 916
/**
 * virCgroupSetMemory:
 *
 * @group: The cgroup to change memory for
 * @kb: The memory amount in kilobytes
 *
 * Returns: 0 on success
 */
917
int virCgroupSetMemory(virCgroupPtr group, unsigned long long kb)
918
{
919 920 921 922 923 924 925 926 927 928 929 930 931 932
    unsigned long long maxkb = VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;

    if (kb > maxkb)
        return -EINVAL;
    else if (kb == maxkb)
        return virCgroupSetValueI64(group,
                                    VIR_CGROUP_CONTROLLER_MEMORY,
                                    "memory.limit_in_bytes",
                                    -1);
    else
        return virCgroupSetValueU64(group,
                                    VIR_CGROUP_CONTROLLER_MEMORY,
                                    "memory.limit_in_bytes",
                                    kb << 10);
933 934
}

R
Ryota Ozaki 已提交
935 936 937 938 939 940 941 942 943 944
/**
 * virCgroupGetMemoryUsage:
 *
 * @group: The cgroup to change memory for
 * @kb: Pointer to returned used memory in kilobytes
 *
 * Returns: 0 on success
 */
int virCgroupGetMemoryUsage(virCgroupPtr group, unsigned long *kb)
{
C
Cole Robinson 已提交
945
    long long unsigned int usage_in_bytes;
R
Ryota Ozaki 已提交
946 947 948 949 950 951 952 953 954
    int ret;
    ret = virCgroupGetValueU64(group,
                               VIR_CGROUP_CONTROLLER_MEMORY,
                               "memory.usage_in_bytes", &usage_in_bytes);
    if (ret == 0)
        *kb = (unsigned long) usage_in_bytes >> 10;
    return ret;
}

955 956 957 958 959 960 961 962
/**
 * virCgroupSetMemoryHardLimit:
 *
 * @group: The cgroup to change memory hard limit for
 * @kb: The memory amount in kilobytes
 *
 * Returns: 0 on success
 */
963
int virCgroupSetMemoryHardLimit(virCgroupPtr group, unsigned long long kb)
964 965 966 967 968 969 970 971 972 973 974 975
{
    return virCgroupSetMemory(group, kb);
}

/**
 * virCgroupGetMemoryHardLimit:
 *
 * @group: The cgroup to get the memory hard limit for
 * @kb: The memory amount in kilobytes
 *
 * Returns: 0 on success
 */
976
int virCgroupGetMemoryHardLimit(virCgroupPtr group, unsigned long long *kb)
977 978 979 980 981 982 983
{
    long long unsigned int limit_in_bytes;
    int ret;
    ret = virCgroupGetValueU64(group,
                               VIR_CGROUP_CONTROLLER_MEMORY,
                               "memory.limit_in_bytes", &limit_in_bytes);
    if (ret == 0)
984
        *kb = limit_in_bytes >> 10;
985 986 987 988 989 990 991 992 993 994 995
    return ret;
}

/**
 * virCgroupSetMemorySoftLimit:
 *
 * @group: The cgroup to change memory soft limit for
 * @kb: The memory amount in kilobytes
 *
 * Returns: 0 on success
 */
996
int virCgroupSetMemorySoftLimit(virCgroupPtr group, unsigned long long kb)
997
{
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
    unsigned long long maxkb = VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;

    if (kb > maxkb)
        return -EINVAL;
    else if (kb == maxkb)
        return virCgroupSetValueI64(group,
                                    VIR_CGROUP_CONTROLLER_MEMORY,
                                    "memory.soft_limit_in_bytes",
                                    -1);
    else
        return virCgroupSetValueU64(group,
                                    VIR_CGROUP_CONTROLLER_MEMORY,
                                    "memory.soft_limit_in_bytes",
                                    kb << 10);
1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
}


/**
 * virCgroupGetMemorySoftLimit:
 *
 * @group: The cgroup to get the memory soft limit for
 * @kb: The memory amount in kilobytes
 *
 * Returns: 0 on success
 */
1023
int virCgroupGetMemorySoftLimit(virCgroupPtr group, unsigned long long *kb)
1024 1025 1026 1027 1028 1029 1030
{
    long long unsigned int limit_in_bytes;
    int ret;
    ret = virCgroupGetValueU64(group,
                               VIR_CGROUP_CONTROLLER_MEMORY,
                               "memory.soft_limit_in_bytes", &limit_in_bytes);
    if (ret == 0)
1031
        *kb = limit_in_bytes >> 10;
1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042
    return ret;
}

/**
 * virCgroupSetSwapHardLimit:
 *
 * @group: The cgroup to change swap hard limit for
 * @kb: The swap amount in kilobytes
 *
 * Returns: 0 on success
 */
1043
int virCgroupSetSwapHardLimit(virCgroupPtr group, unsigned long long kb)
1044
{
1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
    unsigned long long maxkb = VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;

    if (kb > maxkb)
        return -EINVAL;
    else if (kb == maxkb)
        return virCgroupSetValueI64(group,
                                    VIR_CGROUP_CONTROLLER_MEMORY,
                                    "memory.memsw.limit_in_bytes",
                                    -1);
    else
        return virCgroupSetValueU64(group,
                                    VIR_CGROUP_CONTROLLER_MEMORY,
                                    "memory.memsw.limit_in_bytes",
                                    kb << 10);
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068
}

/**
 * virCgroupGetSwapHardLimit:
 *
 * @group: The cgroup to get swap hard limit for
 * @kb: The swap amount in kilobytes
 *
 * Returns: 0 on success
 */
1069
int virCgroupGetSwapHardLimit(virCgroupPtr group, unsigned long long *kb)
1070 1071 1072 1073 1074 1075 1076
{
    long long unsigned int limit_in_bytes;
    int ret;
    ret = virCgroupGetValueU64(group,
                               VIR_CGROUP_CONTROLLER_MEMORY,
                               "memory.memsw.limit_in_bytes", &limit_in_bytes);
    if (ret == 0)
1077
        *kb = limit_in_bytes >> 10;
1078 1079 1080
    return ret;
}

1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
/**
 * virCgroupDenyAllDevices:
 *
 * @group: The cgroup to deny devices for
 *
 * Returns: 0 on success
 */
int virCgroupDenyAllDevices(virCgroupPtr group)
{
    return virCgroupSetValueStr(group,
1091 1092 1093
                                VIR_CGROUP_CONTROLLER_DEVICES,
                                "devices.deny",
                                "a");
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105
}

/**
 * virCgroupAllowDevice:
 *
 * @group: The cgroup to allow a device for
 * @type: The device type (i.e., 'c' or 'b')
 * @major: The major number of the device
 * @minor: The minor number of the device
 *
 * Returns: 0 on success
 */
1106
int virCgroupAllowDevice(virCgroupPtr group, char type, int major, int minor)
1107 1108 1109 1110
{
    int rc;
    char *devstr = NULL;

1111
    if (virAsprintf(&devstr, "%c %i:%i rwm", type, major, minor) == -1) {
1112 1113 1114 1115 1116
        rc = -ENOMEM;
        goto out;
    }

    rc = virCgroupSetValueStr(group,
1117
                              VIR_CGROUP_CONTROLLER_DEVICES,
1118 1119 1120 1121 1122 1123 1124
                              "devices.allow",
                              devstr);
out:
    VIR_FREE(devstr);

    return rc;
}
1125

1126 1127 1128 1129 1130 1131 1132 1133 1134
/**
 * virCgroupAllowDeviceMajor:
 *
 * @group: The cgroup to allow an entire device major type for
 * @type: The device type (i.e., 'c' or 'b')
 * @major: The major number of the device type
 *
 * Returns: 0 on success
 */
1135
int virCgroupAllowDeviceMajor(virCgroupPtr group, char type, int major)
1136 1137 1138 1139
{
    int rc;
    char *devstr = NULL;

1140
    if (virAsprintf(&devstr, "%c %i:* rwm", type, major) == -1) {
1141 1142 1143 1144 1145
        rc = -ENOMEM;
        goto out;
    }

    rc = virCgroupSetValueStr(group,
1146
                              VIR_CGROUP_CONTROLLER_DEVICES,
1147 1148 1149 1150 1151 1152 1153 1154
                              "devices.allow",
                              devstr);
 out:
    VIR_FREE(devstr);

    return rc;
}

1155 1156 1157 1158 1159 1160 1161 1162 1163
/**
 * virCgroupAllowDevicePath:
 *
 * @group: The cgroup to allow the device for
 * @path: the device to allow
 *
 * Queries the type of device and its major/minor number, and
 * adds that to the cgroup ACL
 *
1164 1165
 * Returns: 0 on success, 1 if path exists but is not a device, or
 * negative errno value on failure
1166
 */
D
Daniel P. Berrange 已提交
1167
#if defined(major) && defined(minor)
1168 1169 1170 1171 1172 1173 1174 1175
int virCgroupAllowDevicePath(virCgroupPtr group, const char *path)
{
    struct stat sb;

    if (stat(path, &sb) < 0)
        return -errno;

    if (!S_ISCHR(sb.st_mode) && !S_ISBLK(sb.st_mode))
1176
        return 1;
1177 1178 1179 1180 1181 1182

    return virCgroupAllowDevice(group,
                                S_ISCHR(sb.st_mode) ? 'c' : 'b',
                                major(sb.st_rdev),
                                minor(sb.st_rdev));
}
D
Daniel P. Berrange 已提交
1183 1184 1185 1186 1187 1188 1189 1190
#else
int virCgroupAllowDevicePath(virCgroupPtr group ATTRIBUTE_UNUSED,
                             const char *path ATTRIBUTE_UNUSED)
{
    return -ENOSYS;
}
#endif

1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250

/**
 * virCgroupDenyDevice:
 *
 * @group: The cgroup to deny a device for
 * @type: The device type (i.e., 'c' or 'b')
 * @major: The major number of the device
 * @minor: The minor number of the device
 *
 * Returns: 0 on success
 */
int virCgroupDenyDevice(virCgroupPtr group, char type, int major, int minor)
{
    int rc;
    char *devstr = NULL;

    if (virAsprintf(&devstr, "%c %i:%i rwm", type, major, minor) == -1) {
        rc = -ENOMEM;
        goto out;
    }

    rc = virCgroupSetValueStr(group,
                              VIR_CGROUP_CONTROLLER_DEVICES,
                              "devices.deny",
                              devstr);
out:
    VIR_FREE(devstr);

    return rc;
}

/**
 * virCgroupDenyDeviceMajor:
 *
 * @group: The cgroup to deny an entire device major type for
 * @type: The device type (i.e., 'c' or 'b')
 * @major: The major number of the device type
 *
 * Returns: 0 on success
 */
int virCgroupDenyDeviceMajor(virCgroupPtr group, char type, int major)
{
    int rc;
    char *devstr = NULL;

    if (virAsprintf(&devstr, "%c %i:* rwm", type, major) == -1) {
        rc = -ENOMEM;
        goto out;
    }

    rc = virCgroupSetValueStr(group,
                              VIR_CGROUP_CONTROLLER_DEVICES,
                              "devices.deny",
                              devstr);
 out:
    VIR_FREE(devstr);

    return rc;
}

D
Daniel P. Berrange 已提交
1251
#if defined(major) && defined(minor)
1252 1253 1254 1255 1256 1257 1258 1259
int virCgroupDenyDevicePath(virCgroupPtr group, const char *path)
{
    struct stat sb;

    if (stat(path, &sb) < 0)
        return -errno;

    if (!S_ISCHR(sb.st_mode) && !S_ISBLK(sb.st_mode))
1260
        return 1;
1261 1262 1263 1264 1265 1266

    return virCgroupDenyDevice(group,
                               S_ISCHR(sb.st_mode) ? 'c' : 'b',
                               major(sb.st_rdev),
                               minor(sb.st_rdev));
}
D
Daniel P. Berrange 已提交
1267 1268 1269 1270 1271 1272 1273
#else
int virCgroupDenyDevicePath(virCgroupPtr group ATTRIBUTE_UNUSED,
                            const char *path ATTRIBUTE_UNUSED)
{
    return -ENOSYS;
}
#endif
1274

1275
int virCgroupSetCpuShares(virCgroupPtr group, unsigned long long shares)
1276
{
1277 1278
    return virCgroupSetValueU64(group,
                                VIR_CGROUP_CONTROLLER_CPU,
D
Daniel P. Berrange 已提交
1279
                                "cpu.shares", shares);
1280 1281
}

1282
int virCgroupGetCpuShares(virCgroupPtr group, unsigned long long *shares)
1283
{
1284 1285
    return virCgroupGetValueU64(group,
                                VIR_CGROUP_CONTROLLER_CPU,
D
Daniel P. Berrange 已提交
1286
                                "cpu.shares", shares);
1287
}
1288 1289 1290

int virCgroupGetCpuacctUsage(virCgroupPtr group, unsigned long long *usage)
{
1291 1292
    return virCgroupGetValueU64(group,
                                VIR_CGROUP_CONTROLLER_CPUACCT,
D
Daniel P. Berrange 已提交
1293
                                "cpuacct.usage", usage);
1294
}
R
Ryota Ozaki 已提交
1295 1296 1297 1298 1299 1300 1301 1302 1303 1304

int virCgroupSetFreezerState(virCgroupPtr group, const char *state)
{
    return virCgroupSetValueStr(group,
                                VIR_CGROUP_CONTROLLER_CPU,
                                "freezer.state", state);
}

int virCgroupGetFreezerState(virCgroupPtr group, char **state)
{
1305
    return virCgroupGetValueStr(group,
R
Ryota Ozaki 已提交
1306 1307 1308
                                VIR_CGROUP_CONTROLLER_CPU,
                                "freezer.state", state);
}
1309

1310 1311

#ifdef HAVE_KILL
1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 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
static int virCgroupKillInternal(virCgroupPtr group, int signum, virHashTablePtr pids)
{
    int rc;
    int killedAny = 0;
    char *keypath = NULL;
    bool done = false;
    VIR_DEBUG("group=%p path=%s signum=%d pids=%p", group, group->path, signum, pids);

    rc = virCgroupPathOfController(group, -1, "tasks", &keypath);
    if (rc != 0) {
        VIR_DEBUG("No path of %s, tasks", group->path);
        return rc;
    }

    /* PIDs may be forking as we kill them, so loop
     * until there are no new PIDs found
     */
    while (!done) {
        done = true;
        FILE *fp;
        if (!(fp = fopen(keypath, "r"))) {
            rc = -errno;
            VIR_DEBUG("Failed to read %s: %m\n", keypath);
            goto cleanup;
        } else {
            while (!feof(fp)) {
                unsigned long pid;
                if (fscanf(fp, "%lu", &pid) != 1) {
                    if (feof(fp))
                        break;
                    rc = -errno;
                    break;
                }
                if (virHashLookup(pids, (void*)pid))
                    continue;

                VIR_DEBUG("pid=%lu", pid);
                if (kill((pid_t)pid, signum) < 0) {
                    if (errno != ESRCH) {
                        rc = -errno;
                        goto cleanup;
                    }
                    /* Leave RC == 0 since we didn't kill one */
                } else {
                    killedAny = 1;
                    done = false;
                }

                virHashAddEntry(pids, (void*)pid, (void*)1);
            }
            VIR_FORCE_FCLOSE(fp);
        }
    }

    rc = killedAny ? 1 : 0;

cleanup:
    VIR_FREE(keypath);

    return rc;
}


static unsigned long virCgroupPidCode(const void *name)
{
    return (unsigned long)name;
}
static bool virCgroupPidEqual(const void *namea, const void *nameb)
{
    return namea == nameb;
}
static void *virCgroupPidCopy(const void *name)
{
    return (void*)name;
}

/*
 * Returns
 *   < 0 : errno that occurred
 *     0 : no PIDs killed
 *     1 : at least one PID killed
 */
int virCgroupKill(virCgroupPtr group, int signum)
{
    VIR_DEBUG("group=%p path=%s signum=%d", group, group->path, signum);
    int rc;
    /* The 'tasks' file in cgroups can contain duplicated
     * pids, so we use a hash to track which we've already
     * killed.
     */
    virHashTablePtr pids = virHashCreateFull(100,
                                             NULL,
                                             virCgroupPidCode,
                                             virCgroupPidEqual,
                                             virCgroupPidCopy,
                                             NULL);

    rc = virCgroupKillInternal(group, signum, pids);

    virHashFree(pids);

    return rc;
}


static int virCgroupKillRecursiveInternal(virCgroupPtr group, int signum, virHashTablePtr pids, bool dormdir)
{
    int rc;
    int killedAny = 0;
    char *keypath = NULL;
    DIR *dp;
    virCgroupPtr subgroup = NULL;
    struct dirent *ent;
    VIR_DEBUG("group=%p path=%s signum=%d pids=%p", group, group->path, signum, pids);

    rc = virCgroupPathOfController(group, -1, "", &keypath);
    if (rc != 0) {
        VIR_DEBUG("No path of %s, tasks", group->path);
        return rc;
    }

    if ((rc = virCgroupKillInternal(group, signum, pids)) != 0)
        return rc;

    VIR_DEBUG("Iterate over children of %s", keypath);
    if (!(dp = opendir(keypath))) {
        rc = -errno;
        return rc;
    }

    while ((ent = readdir(dp))) {
        char *subpath;

        if (STREQ(ent->d_name, "."))
            continue;
        if (STREQ(ent->d_name, ".."))
            continue;
        if (ent->d_type != DT_DIR)
            continue;

        VIR_DEBUG("Process subdir %s", ent->d_name);
        if (virAsprintf(&subpath, "%s/%s", group->path, ent->d_name) < 0) {
            rc = -ENOMEM;
            goto cleanup;
        }

        if ((rc = virCgroupNew(subpath, &subgroup)) != 0)
            goto cleanup;

        if ((rc = virCgroupKillRecursiveInternal(subgroup, signum, pids, true)) < 0)
            goto cleanup;
        if (rc == 1)
            killedAny = 1;

        if (dormdir)
            virCgroupRemove(subgroup);

        virCgroupFree(&subgroup);
    }

    rc = killedAny;

cleanup:
    virCgroupFree(&subgroup);
    closedir(dp);

    return rc;
}

int virCgroupKillRecursive(virCgroupPtr group, int signum)
{
    int rc;
    VIR_DEBUG("group=%p path=%s signum=%d", group, group->path, signum);
    virHashTablePtr pids = virHashCreateFull(100,
                                             NULL,
                                             virCgroupPidCode,
                                             virCgroupPidEqual,
                                             virCgroupPidCopy,
                                             NULL);

    rc = virCgroupKillRecursiveInternal(group, signum, pids, false);

    virHashFree(pids);

    return rc;
}


int virCgroupKillPainfully(virCgroupPtr group)
{
    int i;
    int rc;
    VIR_DEBUG("cgroup=%p path=%s", group, group->path);
    for (i = 0 ; i < 15 ; i++) {
        int signum;
        if (i == 0)
            signum = SIGTERM;
        else if (i == 8)
            signum = SIGKILL;
        else
            signum = 0; /* Just check for existance */

        rc = virCgroupKillRecursive(group, signum);
        VIR_DEBUG("Iteration %d rc=%d", i, rc);
        /* If rc == -1 we hit error, if 0 we ran out of PIDs */
        if (rc <= 0)
            break;

        usleep(200 * 1000);
    }
    VIR_DEBUG("Complete %d", rc);
    return rc;
}
1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542

#else /* HAVE_KILL */
int virCgroupKill(virCgroupPtr group ATTRIBUTE_UNUSED,
                  int signum ATTRIBUTE_UNUSED)
{
    return -ENOSYS;
}
int virCgroupKillRecursive(virCgroupPtr group ATTRIBUTE_UNUSED,
                           int signum ATTRIBUTE_UNUSED)
{
    return -ENOSYS;
}

int virCgroupKillPainfully(virCgroupPtr group ATTRIBUTE_UNUSED)
{
    return -ENOSYS;
}
#endif /* HAVE_KILL */