1 /*
2  * vircgroup.h: methods for managing control cgroups
3  *
4  * Copyright (C) 2011-2015 Red Hat, Inc.
5  * Copyright IBM Corp. 2008
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library.  If not, see
19  * <http://www.gnu.org/licenses/>.
20  */
21 
22 #pragma once
23 
24 #include "virbitmap.h"
25 #include "virenum.h"
26 
27 struct _virCgroup;
28 typedef struct _virCgroup virCgroup;
29 
30 enum {
31     VIR_CGROUP_CONTROLLER_CPU,
32     VIR_CGROUP_CONTROLLER_CPUACCT,
33     VIR_CGROUP_CONTROLLER_CPUSET,
34     VIR_CGROUP_CONTROLLER_MEMORY,
35     VIR_CGROUP_CONTROLLER_DEVICES,
36     VIR_CGROUP_CONTROLLER_FREEZER,
37     VIR_CGROUP_CONTROLLER_BLKIO,
38     VIR_CGROUP_CONTROLLER_NET_CLS,
39     VIR_CGROUP_CONTROLLER_PERF_EVENT,
40     VIR_CGROUP_CONTROLLER_SYSTEMD,
41 
42     VIR_CGROUP_CONTROLLER_LAST
43 };
44 
45 VIR_ENUM_DECL(virCgroupController);
46 /* Items of this enum are used later in virCgroupNew to create
47  * bit array stored in int. Like this:
48  *   1 << VIR_CGROUP_CONTROLLER_CPU
49  * Make sure we will not overflow */
50 G_STATIC_ASSERT(VIR_CGROUP_CONTROLLER_LAST < 8 * sizeof(int));
51 
52 typedef enum {
53     VIR_CGROUP_THREAD_VCPU = 0,
54     VIR_CGROUP_THREAD_EMULATOR,
55     VIR_CGROUP_THREAD_IOTHREAD,
56 
57     VIR_CGROUP_THREAD_LAST
58 } virCgroupThreadName;
59 
60 bool virCgroupAvailable(void);
61 
62 int virCgroupNew(const char *path,
63                  int controllers,
64                  virCgroup **group);
65 
66 int virCgroupNewSelf(virCgroup **group)
67     ATTRIBUTE_NONNULL(1);
68 
69 int virCgroupNewThread(virCgroup *domain,
70                        virCgroupThreadName nameval,
71                        int id,
72                        bool create,
73                        virCgroup **group)
74     ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(5);
75 
76 int virCgroupDelThread(virCgroup *cgroup,
77                        virCgroupThreadName nameval,
78                        int idx);
79 
80 int virCgroupNewDetect(pid_t pid,
81                        int controllers,
82                        virCgroup **group);
83 
84 int
85 virCgroupNewDetectMachine(const char *name,
86                           const char *drivername,
87                           pid_t pid,
88                           int controllers,
89                           char *machinename,
90                           virCgroup **group)
91     ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
92 
93 int virCgroupNewMachine(const char *name,
94                         const char *drivername,
95                         const unsigned char *uuid,
96                         const char *rootdir,
97                         pid_t pidleader,
98                         bool isContainer,
99                         size_t nnicindexes,
100                         int *nicindexes,
101                         const char *partition,
102                         int controllers,
103                         unsigned int maxthreads,
104                         virCgroup **group)
105     ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
106     ATTRIBUTE_NONNULL(3);
107 
108 int virCgroupTerminateMachine(const char *name)
109     ATTRIBUTE_NONNULL(1);
110 
111 bool virCgroupNewIgnoreError(void);
112 
113 void virCgroupFree(virCgroup *group);
114 
115 G_DEFINE_AUTOPTR_CLEANUP_FUNC(virCgroup, virCgroupFree);
116 
117 bool virCgroupHasController(virCgroup *cgroup, int controller);
118 int virCgroupPathOfController(virCgroup *group,
119                               unsigned int controller,
120                               const char *key,
121                               char **path);
122 
123 int virCgroupAddProcess(virCgroup *group, pid_t pid);
124 int virCgroupAddMachineProcess(virCgroup *group, pid_t pid);
125 int virCgroupAddThread(virCgroup *group, pid_t pid);
126 
127 int virCgroupSetBlkioWeight(virCgroup *group, unsigned int weight);
128 int virCgroupGetBlkioWeight(virCgroup *group, unsigned int *weight);
129 
130 int virCgroupGetBlkioIoServiced(virCgroup *group,
131                                 long long *bytes_read,
132                                 long long *bytes_write,
133                                 long long *requests_read,
134                                 long long *requests_write);
135 int virCgroupGetBlkioIoDeviceServiced(virCgroup *group,
136                                       const char *path,
137                                       long long *bytes_read,
138                                       long long *bytes_write,
139                                       long long *requests_read,
140                                       long long *requests_write);
141 
142 int virCgroupSetupBlkioDeviceWeight(virCgroup *cgroup,
143                                     const char *path,
144                                     unsigned int *weight);
145 
146 int virCgroupSetupBlkioDeviceReadIops(virCgroup *cgroup,
147                                       const char *path,
148                                       unsigned int *riops);
149 
150 int virCgroupSetupBlkioDeviceWriteIops(virCgroup *cgroup,
151                                        const char *path,
152                                        unsigned int *wiops);
153 
154 int virCgroupSetupBlkioDeviceReadBps(virCgroup *cgroup,
155                                      const char *path,
156                                      unsigned long long *rbps);
157 
158 int virCgroupSetupBlkioDeviceWriteBps(virCgroup *cgroup,
159                                       const char *path,
160                                       unsigned long long *wbps);
161 
162 int virCgroupSetMemory(virCgroup *group, unsigned long long kb);
163 int virCgroupGetMemoryStat(virCgroup *group,
164                            unsigned long long *cache,
165                            unsigned long long *activeAnon,
166                            unsigned long long *inactiveAnon,
167                            unsigned long long *activeFile,
168                            unsigned long long *inactiveFile,
169                            unsigned long long *unevictable);
170 int virCgroupGetMemoryUsage(virCgroup *group, unsigned long *kb);
171 
172 int virCgroupSetMemoryHardLimit(virCgroup *group, unsigned long long kb);
173 int virCgroupGetMemoryHardLimit(virCgroup *group, unsigned long long *kb);
174 int virCgroupSetMemorySoftLimit(virCgroup *group, unsigned long long kb);
175 int virCgroupGetMemorySoftLimit(virCgroup *group, unsigned long long *kb);
176 int virCgroupSetMemSwapHardLimit(virCgroup *group, unsigned long long kb);
177 int virCgroupGetMemSwapHardLimit(virCgroup *group, unsigned long long *kb);
178 int virCgroupGetMemSwapUsage(virCgroup *group, unsigned long long *kb);
179 
180 enum {
181     VIR_CGROUP_DEVICE_READ  = 1,
182     VIR_CGROUP_DEVICE_WRITE = 2,
183     VIR_CGROUP_DEVICE_MKNOD = 4,
184     VIR_CGROUP_DEVICE_RW    = VIR_CGROUP_DEVICE_READ | VIR_CGROUP_DEVICE_WRITE,
185     VIR_CGROUP_DEVICE_RWM   = VIR_CGROUP_DEVICE_RW | VIR_CGROUP_DEVICE_MKNOD,
186 };
187 
188 const char *virCgroupGetDevicePermsString(int perms);
189 
190 int virCgroupDenyAllDevices(virCgroup *group);
191 
192 int virCgroupAllowAllDevices(virCgroup *group, int perms);
193 
194 int virCgroupAllowDevice(virCgroup *group,
195                          char type,
196                          int major,
197                          int minor,
198                          int perms);
199 int virCgroupAllowDevicePath(virCgroup *group,
200                              const char *path,
201                              int perms,
202                              bool ignoreEacces);
203 
204 int virCgroupDenyDevice(virCgroup *group,
205                         char type,
206                         int major,
207                         int minor,
208                         int perms);
209 int virCgroupDenyDevicePath(virCgroup *group,
210                             const char *path,
211                             int perms,
212                             bool ignoreEacces);
213 
214 int
215 virCgroupGetPercpuStats(virCgroup *group,
216                         virTypedParameterPtr params,
217                         unsigned int nparams,
218                         int start_cpu,
219                         unsigned int ncpus,
220                         virBitmap *guestvcpus);
221 
222 int
223 virCgroupGetDomainTotalCpuStats(virCgroup *group,
224                                 virTypedParameterPtr params,
225                                 int nparams);
226 
227 int virCgroupSetCpuShares(virCgroup *group, unsigned long long shares);
228 int virCgroupGetCpuShares(virCgroup *group, unsigned long long *shares);
229 
230 #define VIR_CGROUP_CPU_SHARES_MIN 2LL
231 #define VIR_CGROUP_CPU_SHARES_MAX 262144LL
232 #define VIR_CGROUP_CPU_PERIOD_MIN 1000LL
233 #define VIR_CGROUP_CPU_PERIOD_MAX 1000000LL
234 #define VIR_CGROUP_CPU_QUOTA_MIN 1000LL
235 /* Based on kernel code ((1ULL << MAX_BW_BITS) - 1) where MAX_BW_BITS is
236  * (64 - BW_SHIFT) and BW_SHIFT is 20 */
237 #define VIR_CGROUP_CPU_QUOTA_MAX 17592186044415LL
238 
239 int virCgroupSetCpuCfsPeriod(virCgroup *group, unsigned long long cfs_period);
240 int virCgroupGetCpuCfsPeriod(virCgroup *group, unsigned long long *cfs_period);
241 int virCgroupGetCpuPeriodQuota(virCgroup *cgroup, unsigned long long *period,
242                                long long *quota);
243 int virCgroupSetupCpuPeriodQuota(virCgroup *cgroup, unsigned long long period,
244                                  long long quota);
245 
246 int virCgroupSetCpuCfsQuota(virCgroup *group, long long cfs_quota);
247 int virCgroupGetCpuCfsQuota(virCgroup *group, long long *cfs_quota);
248 
249 int virCgroupGetCpuacctUsage(virCgroup *group, unsigned long long *usage);
250 int virCgroupGetCpuacctPercpuUsage(virCgroup *group, char **usage);
251 int virCgroupGetCpuacctStat(virCgroup *group, unsigned long long *user,
252                             unsigned long long *sys);
253 
254 int virCgroupSetFreezerState(virCgroup *group, const char *state);
255 int virCgroupGetFreezerState(virCgroup *group, char **state);
256 
257 int virCgroupSetCpusetMems(virCgroup *group, const char *mems);
258 int virCgroupGetCpusetMems(virCgroup *group, char **mems);
259 
260 int virCgroupSetCpusetMemoryMigrate(virCgroup *group, bool migrate);
261 int virCgroupGetCpusetMemoryMigrate(virCgroup *group, bool *migrate);
262 
263 int virCgroupSetCpusetCpus(virCgroup *group, const char *cpus);
264 int virCgroupGetCpusetCpus(virCgroup *group, char **cpus);
265 int virCgroupSetupCpusetCpus(virCgroup *cgroup, virBitmap *cpumask);
266 
267 int virCgroupRemove(virCgroup *group);
268 
269 int virCgroupKillRecursive(virCgroup *group, int signum);
270 int virCgroupKillPainfully(virCgroup *group);
271 
272 int virCgroupBindMount(virCgroup *group,
273                        const char *oldroot,
274                        const char *mountopts);
275 
276 bool virCgroupSupportsCpuBW(virCgroup *cgroup);
277 
278 int virCgroupSetOwner(virCgroup *cgroup,
279                       uid_t uid,
280                       gid_t gid,
281                       int controllers);
282 
283 int virCgroupHasEmptyTasks(virCgroup *cgroup, int controller);
284 
285 bool virCgroupControllerAvailable(int controller);
286 
287 int virCgroupGetInode(virCgroup *cgroup);
288