vircgroup.h 7.5 KB
Newer Older
1
/*
2
 * vircgroup.h: methods for managing control cgroups
3
 *
H
Hu Tao 已提交
4
 * Copyright (C) 2011-2013 Red Hat, Inc.
5 6
 * Copyright IBM Corp. 2008
 *
O
Osier Yang 已提交
7 8 9 10 11 12 13 14 15 16 17
 * 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 24
 *
 * Authors:
 *  Dan Smith <danms@us.ibm.com>
 */

25 26
#ifndef __VIR_CGROUP_H__
# define __VIR_CGROUP_H__
27

H
Hu Tao 已提交
28 29
# include "virutil.h"

30 31 32
struct virCgroup;
typedef struct virCgroup *virCgroupPtr;

33 34 35 36 37 38
enum {
    VIR_CGROUP_CONTROLLER_CPU,
    VIR_CGROUP_CONTROLLER_CPUACCT,
    VIR_CGROUP_CONTROLLER_CPUSET,
    VIR_CGROUP_CONTROLLER_MEMORY,
    VIR_CGROUP_CONTROLLER_DEVICES,
R
Ryota Ozaki 已提交
39
    VIR_CGROUP_CONTROLLER_FREEZER,
40
    VIR_CGROUP_CONTROLLER_BLKIO,
41 42
    VIR_CGROUP_CONTROLLER_NET_CLS,
    VIR_CGROUP_CONTROLLER_PERF_EVENT,
43 44 45 46 47 48

    VIR_CGROUP_CONTROLLER_LAST
};

VIR_ENUM_DECL(virCgroupController);

49 50
bool virCgroupAvailable(void);

51 52 53 54 55
bool virCgroupIsValidMachineGroup(virCgroupPtr group,
                                  const char *machinename,
                                  const char *drivername);


56 57 58 59 60 61
int virCgroupNewPartition(const char *path,
                          bool create,
                          int controllers,
                          virCgroupPtr *group)
    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4);

62 63
int virCgroupNewSelf(virCgroupPtr *group)
    ATTRIBUTE_NONNULL(1);
G
Gao feng 已提交
64

65 66 67 68 69
int virCgroupNewDomainPartition(virCgroupPtr partition,
                                const char *driver,
                                const char *name,
                                bool create,
                                virCgroupPtr *group)
70
    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(5);
71

72
int virCgroupNewVcpu(virCgroupPtr domain,
73
                     int vcpuid,
74 75 76
                     bool create,
                     virCgroupPtr *group)
    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4);
77

78 79 80 81
int virCgroupNewEmulator(virCgroupPtr domain,
                         bool create,
                         virCgroupPtr *group)
    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3);
82

83 84 85
int virCgroupNewDetect(pid_t pid,
                       virCgroupPtr *group);

86 87 88 89 90 91 92 93 94 95 96 97 98
int virCgroupNewMachine(const char *name,
                        const char *drivername,
                        bool privileged,
                        const unsigned char *uuid,
                        const char *rootdir,
                        pid_t pidleader,
                        bool isContainer,
                        const char *partition,
                        int controllers,
                        virCgroupPtr *group)
    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
    ATTRIBUTE_NONNULL(4);

99 100
bool virCgroupNewIgnoreError(void);

101 102 103 104 105
int virCgroupPathOfController(virCgroupPtr group,
                              int controller,
                              const char *key,
                              char **path);

106 107
int virCgroupAddTask(virCgroupPtr group, pid_t pid);

108 109 110 111 112
int virCgroupAddTaskController(virCgroupPtr group,
                               pid_t pid,
                               int controller);

int virCgroupMoveTask(virCgroupPtr src_group,
113
                      virCgroupPtr dest_group);
114

115 116 117
int virCgroupSetBlkioWeight(virCgroupPtr group, unsigned int weight);
int virCgroupGetBlkioWeight(virCgroupPtr group, unsigned int *weight);

118 119 120 121
int virCgroupSetBlkioDeviceWeight(virCgroupPtr group,
                                  const char *path,
                                  unsigned int weight);

122
int virCgroupSetMemory(virCgroupPtr group, unsigned long long kb);
R
Ryota Ozaki 已提交
123
int virCgroupGetMemoryUsage(virCgroupPtr group, unsigned long *kb);
124

125 126 127 128
int virCgroupSetMemoryHardLimit(virCgroupPtr group, unsigned long long kb);
int virCgroupGetMemoryHardLimit(virCgroupPtr group, unsigned long long *kb);
int virCgroupSetMemorySoftLimit(virCgroupPtr group, unsigned long long kb);
int virCgroupGetMemorySoftLimit(virCgroupPtr group, unsigned long long *kb);
129 130
int virCgroupSetMemSwapHardLimit(virCgroupPtr group, unsigned long long kb);
int virCgroupGetMemSwapHardLimit(virCgroupPtr group, unsigned long long *kb);
G
Gao feng 已提交
131
int virCgroupGetMemSwapUsage(virCgroupPtr group, unsigned long long *kb);
132

133 134 135 136 137 138 139 140
enum {
    VIR_CGROUP_DEVICE_READ  = 1,
    VIR_CGROUP_DEVICE_WRITE = 2,
    VIR_CGROUP_DEVICE_MKNOD = 4,
    VIR_CGROUP_DEVICE_RW    = VIR_CGROUP_DEVICE_READ | VIR_CGROUP_DEVICE_WRITE,
    VIR_CGROUP_DEVICE_RWM   = VIR_CGROUP_DEVICE_RW | VIR_CGROUP_DEVICE_MKNOD,
};

141 142 143 144 145
int virCgroupDenyAllDevices(virCgroupPtr group);

int virCgroupAllowDevice(virCgroupPtr group,
                         char type,
                         int major,
146 147
                         int minor,
                         int perms);
148 149
int virCgroupAllowDeviceMajor(virCgroupPtr group,
                              char type,
150 151
                              int major,
                              int perms);
152
int virCgroupAllowDevicePath(virCgroupPtr group,
153 154
                             const char *path,
                             int perms);
155 156 157 158

int virCgroupDenyDevice(virCgroupPtr group,
                        char type,
                        int major,
159 160
                        int minor,
                        int perms);
161 162
int virCgroupDenyDeviceMajor(virCgroupPtr group,
                             char type,
163 164
                             int major,
                             int perms);
165
int virCgroupDenyDevicePath(virCgroupPtr group,
166 167
                            const char *path,
                            int perms);
168

169 170
int virCgroupSetCpuShares(virCgroupPtr group, unsigned long long shares);
int virCgroupGetCpuShares(virCgroupPtr group, unsigned long long *shares);
171

172 173 174 175 176 177
int virCgroupSetCpuCfsPeriod(virCgroupPtr group, unsigned long long cfs_period);
int virCgroupGetCpuCfsPeriod(virCgroupPtr group, unsigned long long *cfs_period);

int virCgroupSetCpuCfsQuota(virCgroupPtr group, long long cfs_quota);
int virCgroupGetCpuCfsQuota(virCgroupPtr group, long long *cfs_quota);

178
int virCgroupGetCpuacctUsage(virCgroupPtr group, unsigned long long *usage);
179
int virCgroupGetCpuacctPercpuUsage(virCgroupPtr group, char **usage);
180 181
int virCgroupGetCpuacctStat(virCgroupPtr group, unsigned long long *user,
                            unsigned long long *sys);
182

R
Ryota Ozaki 已提交
183 184 185
int virCgroupSetFreezerState(virCgroupPtr group, const char *state);
int virCgroupGetFreezerState(virCgroupPtr group, char **state);

186 187 188
int virCgroupSetCpusetMems(virCgroupPtr group, const char *mems);
int virCgroupGetCpusetMems(virCgroupPtr group, char **mems);

189 190 191
int virCgroupSetCpusetCpus(virCgroupPtr group, const char *cpus);
int virCgroupGetCpusetCpus(virCgroupPtr group, char **cpus);

192
int virCgroupRemoveRecursively(char *grppath);
193 194 195
int virCgroupRemove(virCgroupPtr group);

void virCgroupFree(virCgroupPtr *group);
196
bool virCgroupHasController(virCgroupPtr cgroup, int controller);
197

198 199 200 201
int virCgroupKill(virCgroupPtr group, int signum);
int virCgroupKillRecursive(virCgroupPtr group, int signum);
int virCgroupKillPainfully(virCgroupPtr group);

202 203 204 205
int virCgroupIsolateMount(virCgroupPtr group,
                          const char *oldroot,
                          const char *mountopts);

206
#endif /* __VIR_CGROUP_H__ */