[libvirt] [PATCH v2 2/5] cgroup: refactor virCgroup

Monday, 4 February 2013

This patch adds a new structure, virCgroupItem, to represent
a cgroup directory(named cgroup item). cgroup directory is
created when needed and removed if no one is using it.
---
 src/libvirt_private.syms |   2 +
 src/util/vircgroup.c     | 541 ++++++++++++++++++++++++++++++++++++++++++++++-
 src/util/vircgroup.h     |   8 +
 3 files changed, 545 insertions(+), 6 deletions(-)

diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index c589236..f5138af 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -73,6 +73,8 @@ virCapabilitiesSetMacPrefix;
 
 
 # cgroup.h
+virCgroup2Free;
+virCgroup2New;
 virCgroupAddTask;
 virCgroupAddTaskController;
 virCgroupAllowDevice;
diff --git a/src/util/vircgroup.c b/src/util/vircgroup.c
index 71d46c5..dbc9688 100644
--- a/src/util/vircgroup.c
+++ b/src/util/vircgroup.c
@@ -37,6 +37,7 @@
 #include <libgen.h>
 #include <dirent.h>
 
+#include "virobject.h"
 #include "internal.h"
 #include "virutil.h"
 #include "viralloc.h"
@@ -45,6 +46,7 @@
 #include "virfile.h"
 #include "virhash.h"
 #include "virhashcode.h"
+#include "virthread.h"
 
 #define CGROUP_MAX_VAL 512
 
@@ -58,6 +60,91 @@ struct virCgroupController {
     char *placement;
 };
 
+struct _virCgroupItem;
+typedef struct _virCgroupItem virCgroupItem;
+typedef virCgroupItem *virCgroupItemPtr;
+
+struct _virCgroupItem {
+    virObjectLockable object;
+
+    char *name;
+    char *path;
+
+    bool created;          /* the path is created or not */
+
+    virCgroupItemPtr next;
+    virCgroupItemPtr parent;
+    virCgroupItemPtr children;
+
+    int type;
+    struct virCgroupController controllers[VIR_CGROUP_CONTROLLER_LAST];
+};
+
+struct virCgroup2 {
+    virCgroupItemPtr items[VIR_CGROUP_CONTROLLER_LAST];
+};
+
+static virClassPtr cgroupItemClass;
+
+static void cgroupItemDispose(void *obj);
+
+static int virCgroupItemOnceInit(void)
+{
+    if (!(cgroupItemClass = virClassNew(virClassForObjectLockable(),
+                                        "cgroupItem",
+                                        sizeof(virCgroupItem),
+                                        cgroupItemDispose)))
+        return -1;
+
+    return 0;
+}
+VIR_ONCE_GLOBAL_INIT(virCgroupItem);
+
+static virCgroupItemPtr rootCgroupItems[VIR_CGROUP_CONTROLLER_LAST];
+
+static virCgroupItemPtr virCgroupItemRootNew(int type);
+static int virCgroupDetectMounts(struct virCgroupController
(*controllers)[VIR_CGROUP_CONTROLLER_LAST]);
+static int virCgroupDetectPlacement(struct virCgroupController
(*controllers)[VIR_CGROUP_CONTROLLER_LAST]);
+
+static int virCgroupControllersInit(struct virCgroupController
(*controllers)[VIR_CGROUP_CONTROLLER_LAST])
+{
+    int rc;
+    int i;
+
+    rc = virCgroupDetectMounts(controllers);
+    if (rc < 0) {
+        VIR_ERROR(_("Failed to initialize cgroup controllers"));
+        return rc;
+    }
+
+    rc = virCgroupDetectPlacement(controllers);
+
+    if (rc == 0) {
+        /* Check that for every mounted controller, we found our placement */
+        for (i = 0 ; i < VIR_CGROUP_CONTROLLER_LAST ; i++) {
+            if (!(*controllers)[i].mountPoint)
+                continue;
+
+            if (!(*controllers)[i].placement) {
+                VIR_ERROR(_("Could not find placement for controller %s at
%s"),
+                          virCgroupControllerTypeToString(i),
+                          (*controllers)[i].placement);
+                rc = -ENOENT;
+                break;
+            }
+
+            VIR_DEBUG("Detected mount/mapping %i:%s at %s in %s", i,
+                      virCgroupControllerTypeToString(i),
+                      (*controllers)[i].mountPoint,
+                      (*controllers)[i].placement);
+        }
+    } else {
+        VIR_ERROR(_("Failed to initialize cgroup controllers"));
+    }
+
+    return rc;
+}
+
 struct virCgroup {
     char *path;
 
@@ -74,6 +161,362 @@ typedef enum {
                                * cpuacct and cpuset if possible. */
 } virCgroupFlags;
 
+static virCgroupItemPtr virCgroupItemRootNew(int type)
+{
+    virCgroupItemPtr rootItem = NULL;
+
+    if (type >= VIR_CGROUP_CONTROLLER_LAST || type < 0)
+        return NULL;
+
+    if (virCgroupItemInitialize() < 0)
+        return NULL;
+
+    if (!(rootItem = virObjectNew(cgroupItemClass)))
+        return NULL;
+
+    if (virCgroupControllersInit(&rootItem->controllers) != 0) {
+        virObjectUnref(rootItem);
+        rootItem = NULL;
+        return NULL;
+    }
+
+    rootItem->name = strdup("/");
+    rootItem->next = NULL;
+    rootItem->parent = NULL;
+    rootItem->children = NULL;
+    rootItem->created = 1;
+    rootItem->type = type;
+    if (virAsprintf(&rootItem->path, "%s%s",
+                    rootItem->controllers[rootItem->type].mountPoint,
+                    rootItem->controllers[rootItem->type].placement) < 0) {
+        virObjectUnref(rootItem);
+        rootItem = NULL;
+    }
+
+    return rootItem;
+}
+
+static virCgroupItemPtr virCgroupHasChildByName(virCgroupItemPtr item,
+                                                const char *name)
+{
+    virCgroupItemPtr child;
+
+    virObjectLock(item);
+
+    child = item->children;
+
+    while (child) {
+        if (STREQ(child->name, name)) {
+            virObjectRef(child);
+            goto out;
+        }
+
+        child = child->next;
+    }
+
+out:
+    virObjectUnlock(item);
+    return child;
+}
+
+static virCgroupItemPtr virCgroupItemNew(const char *name,
+                                         virCgroupItemPtr parent)
+{
+    virCgroupItemPtr cgroupItem = NULL;
+    virCgroupItemPtr *next = NULL;
+
+    if (!parent)
+        return NULL;
+
+    if (virCgroupItemInitialize() < 0)
+        return NULL;
+
+    cgroupItem = virCgroupHasChildByName(parent, name);
+    if (cgroupItem)
+        return cgroupItem;
+
+    if (!(cgroupItem = virObjectNew(cgroupItemClass)))
+        return NULL;
+
+    cgroupItem->name = strdup(name);
+    cgroupItem->parent = parent;
+    cgroupItem->next = NULL;
+    cgroupItem->children = NULL;
+    cgroupItem->created = false;
+    cgroupItem->type = parent->type;
+
+    if (virAsprintf(&cgroupItem->path, "%s/%s",
+                    parent->path,
+                    cgroupItem->name) == -1) {
+        virObjectUnref(cgroupItem);
+        cgroupItem = NULL;
+        return NULL;
+    }
+
+    virObjectRef(parent);
+
+    virObjectLock(parent);
+
+    next = &parent->children;
+
+    while (*next)
+        next = &(*next)->next;
+
+    *next = cgroupItem;
+
+    virObjectUnlock(parent);
+
+    return cgroupItem;
+}
+
+static void virCgroupItemFree(virCgroupItemPtr *cgroupItem)
+{
+    if (!virObjectUnref(*cgroupItem))
+        *cgroupItem = NULL;
+}
+
+static void cgroupItemDispose(void *obj)
+{
+    virCgroupItemPtr cgroupItem = obj;
+    virCgroupItemPtr parent = cgroupItem->parent;
+    virCgroupItemPtr *next;
+
+    sa_assert(cgroupItem->children == NULL);
+
+    if (cgroupItem->created &&
+        access(cgroupItem->path, F_OK) == 0)
+        rmdir(cgroupItem->path);
+    VIR_FREE(cgroupItem->path);
+
+    if (parent) {
+        virObjectLock(parent);
+
+        next = &parent->children;
+
+        while (*next && *next != cgroupItem)
+            next = &(*next)->next;
+
+        if (*next == cgroupItem) {
+            *next = cgroupItem->next;
+            cgroupItem->next = NULL;
+            cgroupItem->parent = NULL;
+        } else {
+            /* BUG */
+        }
+
+        virObjectUnlock(parent);
+        virObjectUnref(parent);
+    }
+
+    VIR_FREE(cgroupItem->name);
+}
+
+static int virCgroupItemKeyPath(virCgroupItemPtr cgroupItem,
+                                const char *key,
+                                char **path);
+
+static int virCgroupItemGetValueStr(virCgroupItemPtr cgroupItem,
+                                    const char *key,
+                                    char **value)
+{
+    int rc;
+    char *keypath = NULL;
+
+    *value = NULL;
+
+    rc = virCgroupItemKeyPath(cgroupItem, key, &keypath);
+    if (rc != 0)
+        return rc;
+
+    VIR_DEBUG("Get value %s", keypath);
+
+    rc = virFileReadAll(keypath, 1024*1024, value);
+    if (rc < 0) {
+        rc = -errno;
+        VIR_DEBUG("Failed to read %s: %m\n", keypath);
+    } else {
+        /* Terminated with '\n' has sometimes harmful effects to the caller */
+        if ((*value)[rc - 1] == '\n')
+            (*value)[rc - 1] = '\0';
+
+        rc = 0;
+    }
+
+    VIR_FREE(keypath);
+
+    return rc;
+}
+
+static int virCgroupItemSetValueStr(virCgroupItemPtr cgroupItem,
+                                    const char *key,
+                                    const char *value)
+{
+    int rc = 0;
+    char *keypath = NULL;
+
+    rc = virCgroupItemKeyPath(cgroupItem, key, &keypath);
+    if (rc != 0)
+        return rc;
+
+    VIR_DEBUG("Set value '%s' to '%s'", keypath, value);
+    rc = virFileWriteStr(keypath, value, 0);
+    if (rc < 0) {
+        rc = -errno;
+        VIR_DEBUG("Failed to write value '%s': %m", value);
+    } else {
+        rc = 0;
+    }
+
+    VIR_FREE(keypath);
+    return rc;
+}
+
+static int virCgroupRemoveRecursively(char *grppath);
+static int virCgroupItemCpusetInherit(virCgroupItemPtr cgroupItem);
+static int virCgroupItemSetMemoryUseHierarchy(virCgroupItemPtr item);
+
+static int virCgroupItemMakePath(virCgroupItemPtr cgroupItem)
+{
+    int ret = 0;
+
+    if (!cgroupItem->created && access(cgroupItem->path, F_OK) == 0) {
+        VIR_WARN(_("removing historical cgroup directory: %s"),
+                 cgroupItem->path);
+
+        if (virCgroupRemoveRecursively(cgroupItem->path) != 0) {
+            VIR_WARN(_("failed to remove historical cgroup directory: %s"),
+                     cgroupItem->path);
+        }
+    }
+
+    cgroupItem->created = true;
+
+    if (access(cgroupItem->path, F_OK) != 0) {
+        if (cgroupItem->parent &&
+            (ret = virCgroupItemMakePath(cgroupItem->parent)) < 0)
+            return ret;
+
+        if (mkdir(cgroupItem->path, 0755) < 0) {
+            return -errno;
+        }
+
+        if (cgroupItem->type == VIR_CGROUP_CONTROLLER_CPUSET)
+            virCgroupItemCpusetInherit(cgroupItem);
+
+        if (cgroupItem->type == VIR_CGROUP_CONTROLLER_MEMORY)
+            virCgroupItemSetMemoryUseHierarchy(cgroupItem);
+    }
+
+    return ret;
+}
+
+static int virCgroupItemPath(virCgroupItemPtr cgroupItem,
+                             bool create,
+                             char **path)
+{
+    if (path) {
+        if (virAsprintf(path, "%s", cgroupItem->path) == -1)
+            return -ENOMEM;
+    }
+
+    if (create && virCgroupItemMakePath(cgroupItem) < 0) {
+        if (path)
+            VIR_FREE(*path);
+
+        return -1;
+    }
+
+    return 0;
+}
+
+static int virCgroupItemKeyPath(virCgroupItemPtr cgroupItem,
+                                const char *key,
+                                char **path)
+{
+    int ret = 0;
+    char *cgroupItemPath = NULL;
+
+    ret = virCgroupItemPath(cgroupItem, true, &cgroupItemPath);
+    if (ret < 0)
+        return ret;
+
+    if (virAsprintf(path, "%s/%s", cgroupItemPath, key) == -1)
+        ret = -ENOMEM;
+
+    VIR_FREE(cgroupItemPath);
+    return ret;
+}
+
+int virCgroup2New(const char *name, virCgroup2Ptr parent, virCgroup2Ptr *cgroup)
+{
+    virCgroup2Ptr newCgroup = NULL;
+    virCgroupItemPtr *parentCgroupItems;
+    int ret = -1;
+    int i = 0;
+
+    if (VIR_ALLOC(newCgroup) < 0) {
+        ret = -ENOMEM;
+        goto error;
+    }
+
+    if (!parent) {
+        for (i = 0; i < VIR_CGROUP_CONTROLLER_LAST; i++) {
+            if (!rootCgroupItems[i])
+                rootCgroupItems[i] = virCgroupItemRootNew(i);
+            if (!rootCgroupItems[i])
+                goto error;
+            virObjectRef(rootCgroupItems[i]);
+        }
+
+        parentCgroupItems = rootCgroupItems;
+    } else {
+        parentCgroupItems = parent->items;
+    }
+
+    for (i = 0; i < VIR_CGROUP_CONTROLLER_LAST; i++) {
+        newCgroup->items[i] = virCgroupItemNew(name, parentCgroupItems[i]);
+        if (!newCgroup->items[i])
+            goto error;
+    }
+
+    *cgroup = newCgroup;
+    newCgroup = NULL;
+    ret = 0;
+
+error:
+    if (!parent) {
+        for (i = 0; i < VIR_CGROUP_CONTROLLER_LAST; i++) {
+            if (rootCgroupItems[i])
+                virCgroupItemFree(&rootCgroupItems[i]);
+        }
+    }
+
+    if (newCgroup) {
+        for (i = 0; i < VIR_CGROUP_CONTROLLER_LAST; i++) {
+            if (newCgroup->items[i])
+                virCgroupItemFree(&newCgroup->items[i]);
+        }
+        VIR_FREE(newCgroup);
+    }
+
+    return ret;
+}
+
+void virCgroup2Free(virCgroup2Ptr *cgroup)
+{
+    int i;
+
+    if (!cgroup || !*cgroup)
+        return;
+
+    for (i = 0; i < VIR_CGROUP_CONTROLLER_LAST; i++) {
+        virCgroupItemFree(&(*cgroup)->items[i]);
+    }
+
+    VIR_FREE(*cgroup);
+    *cgroup = NULL;
+}
+
 /**
  * virCgroupFree:
  *
@@ -109,6 +552,7 @@ bool virCgroupMounted(virCgroupPtr cgroup, int controller)
 }
 
 #if defined HAVE_MNTENT_H && defined HAVE_GETMNTENT_R
+
 /*
  * Process /proc/mounts figuring out what controllers are
  * mounted and where
@@ -134,6 +578,7 @@ static int virCgroupDetectMounts(struct virCgroupController
(*controllers)[VIR_C
             const char *typestr = virCgroupControllerTypeToString(i);
             int typelen = strlen(typestr);
             char *tmp = entry.mnt_opts;
+            (*controllers)[i].type = i;
             while (tmp) {
                 char *next = strchr(tmp, ',');
                 int len;
@@ -184,24 +629,24 @@ static int virCgroupDetectPlacement(struct virCgroupController
(*cgroupControlle
     }
 
     while (fgets(line, sizeof(line), mapping) != NULL) {
-        char *controllers = strchr(line, ':');
-        char *path = controllers ? strchr(controllers+1, ':') : NULL;
+        char *controllersStr = strchr(line, ':');
+        char *path = controllersStr ? strchr(controllersStr+1, ':') : NULL;
         char *nl = path ? strchr(path, '\n') : NULL;
 
-        if (!controllers || !path)
+        if (!controllersStr || !path)
             continue;
 
         if (nl)
             *nl = '\0';
 
         *path = '\0';
-        controllers++;
+        controllersStr++;
         path++;
 
         for (i = 0 ; i < VIR_CGROUP_CONTROLLER_LAST ; i++) {
             const char *typestr = virCgroupControllerTypeToString(i);
             int typelen = strlen(typestr);
-            char *tmp = controllers;
+            char *tmp = controllersStr;
             while (tmp) {
                 char *next = strchr(tmp, ',');
                 int len;
@@ -230,6 +675,7 @@ no_memory:
 
 }
 
+
 static int virCgroupDetect(virCgroupPtr group)
 {
     int any = 0;
@@ -315,6 +761,23 @@ int virCgroupPathOfController(virCgroupPtr group,
     return 0;
 }
 
+static int virCgroup2SetValueStr(virCgroup2Ptr group,
+                                 int controller,
+                                 const char *key,
+                                 const char *value)
+{
+    return virCgroupItemSetValueStr(group->items[controller],
+                                    key, value);
+}
+
+static int virCgroup2GetValueStr(virCgroup2Ptr group,
+                                int controller,
+                                const char *key,
+                                char **value)
+{
+    return virCgroupItemGetValueStr(group->items[controller],
+                                    key, value);
+}
 
 static int virCgroupSetValueStr(virCgroupPtr group,
                                 int controller,
@@ -455,7 +918,6 @@ out:
     return rc;
 }
 
-
 #if defined HAVE_MNTENT_H && defined HAVE_GETMNTENT_R
 static int virCgroupCpuSetInherit(virCgroupPtr parent, virCgroupPtr group)
 {
@@ -496,6 +958,41 @@ static int virCgroupCpuSetInherit(virCgroupPtr parent, virCgroupPtr
group)
     return rc;
 }
 
+static int virCgroupItemCpusetInherit(virCgroupItemPtr cgroupItem)
+{
+    int i;
+    char *value;
+    int rc = 0;
+    const char *inherit_values[] = {
+        "cpuset.cpus",
+        "cpuset.mems",
+    };
+
+    for (i = 0; i < ARRAY_CARDINALITY(inherit_values) ; i++) {
+        rc = virCgroupItemGetValueStr(cgroupItem->parent,
+                                      inherit_values[i],
+                                      &value);
+        if (rc != 0) {
+            VIR_ERROR(_("Failed to get %s %d"), inherit_values[i], rc);
+            break;
+        }
+
+        VIR_DEBUG("Inherit %s = %s", inherit_values[i], value);
+
+        rc = virCgroupItemSetValueStr(cgroupItem,
+                                      inherit_values[i],
+                                      value);
+        VIR_FREE(value);
+
+        if (rc != 0) {
+            VIR_ERROR(_("Failed to set %s %d"), inherit_values[i], rc);
+            break;
+        }
+    }
+
+    return rc;
+}
+
 static int virCgroupSetMemoryUseHierarchy(virCgroupPtr group)
 {
     int rc = 0;
@@ -526,6 +1023,38 @@ static int virCgroupSetMemoryUseHierarchy(virCgroupPtr group)
     return rc;
 }
 
+static int virCgroupItemSetMemoryUseHierarchy(virCgroupItemPtr item)
+{
+    int rc = 0;
+    char *value = NULL;
+    const char *filename = "memory.use_hierarchy";
+
+    rc = virCgroupItemGetValueStr(item,
+                                  filename, &value);
+    if (rc != 0) {
+        VIR_ERROR(_("Failed to read %s/%s (%d)"), item->path, filename,
rc);
+        return rc;
+    }
+
+    /* Setting twice causes error, so if already enabled, skip setting */
+    if (STREQ(value, "1")) {
+        rc = 0;
+        goto out;
+    }
+
+    VIR_DEBUG("Setting up %s/%s", item->path, filename);
+    rc = virCgroupItemSetValueStr(item,
+                                  filename, "1");
+
+    if (rc != 0) {
+        VIR_ERROR(_("Failed to set %s/%s (%d)"), item->path, filename, rc);
+    }
+
+out:
+    VIR_FREE(value);
+    return rc;
+}
+
 static int virCgroupMakeGroup(virCgroupPtr parent,
                               virCgroupPtr group,
                               bool create,
diff --git a/src/util/vircgroup.h b/src/util/vircgroup.h
index 2ed6ff9..f93c185 100644
--- a/src/util/vircgroup.h
+++ b/src/util/vircgroup.h
@@ -30,6 +30,10 @@
 struct virCgroup;
 typedef struct virCgroup *virCgroupPtr;
 
+struct virCgroup2;
+typedef struct virCgroup2 virCgroup2;
+typedef virCgroup2 *virCgroup2Ptr;
+
 enum {
     VIR_CGROUP_CONTROLLER_CPU,
     VIR_CGROUP_CONTROLLER_CPUACCT,
@@ -166,4 +170,8 @@ int virCgroupKill(virCgroupPtr group, int signum);
 int virCgroupKillRecursive(virCgroupPtr group, int signum);
 int virCgroupKillPainfully(virCgroupPtr group);
 
+
+int virCgroup2New(const char *name, virCgroup2Ptr parent, virCgroup2Ptr *cgroup);
+void virCgroup2Free(virCgroup2Ptr *cgroup);
+
 #endif /* __VIR_CGROUP_H__ */
-- 
1.8.0.1.240.ge8a1f5a


    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

[libvirt] [PATCH v2 2/5] cgroup: refactor virCgroup