1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Miscellaneous cgroup controller 4 * 5 * Copyright 2020 Google LLC 6 * Author: Vipin Sharma <vipinsh@google.com> 7 */ 8 9 #include <linux/limits.h> 10 #include <linux/cgroup.h> 11 #include <linux/errno.h> 12 #include <linux/atomic.h> 13 #include <linux/slab.h> 14 #include <linux/misc_cgroup.h> 15 16 #define MAX_STR "max" 17 #define MAX_NUM ULONG_MAX 18 19 /* Miscellaneous res name, keep it in sync with enum misc_res_type */ 20 static const char *const misc_res_name[] = { 21 #ifdef CONFIG_KVM_AMD_SEV 22 /* AMD SEV ASIDs resource */ 23 "sev", 24 /* AMD SEV-ES ASIDs resource */ 25 "sev_es", 26 #endif 27 }; 28 29 /* Root misc cgroup */ 30 static struct misc_cg root_cg; 31 32 /* 33 * Miscellaneous resources capacity for the entire machine. 0 capacity means 34 * resource is not initialized or not present in the host. 35 * 36 * root_cg.max and capacity are independent of each other. root_cg.max can be 37 * more than the actual capacity. We are using Limits resource distribution 38 * model of cgroup for miscellaneous controller. 39 */ 40 static unsigned long misc_res_capacity[MISC_CG_RES_TYPES]; 41 42 /** 43 * parent_misc() - Get the parent of the passed misc cgroup. 44 * @cgroup: cgroup whose parent needs to be fetched. 45 * 46 * Context: Any context. 47 * Return: 48 * * struct misc_cg* - Parent of the @cgroup. 49 * * %NULL - If @cgroup is null or the passed cgroup does not have a parent. 50 */ 51 static struct misc_cg *parent_misc(struct misc_cg *cgroup) 52 { 53 return cgroup ? css_misc(cgroup->css.parent) : NULL; 54 } 55 56 /** 57 * valid_type() - Check if @type is valid or not. 58 * @type: misc res type. 59 * 60 * Context: Any context. 61 * Return: 62 * * true - If valid type. 63 * * false - If not valid type. 64 */ 65 static inline bool valid_type(enum misc_res_type type) 66 { 67 return type >= 0 && type < MISC_CG_RES_TYPES; 68 } 69 70 /** 71 * misc_cg_res_total_usage() - Get the current total usage of the resource. 72 * @type: misc res type. 73 * 74 * Context: Any context. 75 * Return: Current total usage of the resource. 76 */ 77 unsigned long misc_cg_res_total_usage(enum misc_res_type type) 78 { 79 if (valid_type(type)) 80 return atomic_long_read(&root_cg.res[type].usage); 81 82 return 0; 83 } 84 EXPORT_SYMBOL_GPL(misc_cg_res_total_usage); 85 86 /** 87 * misc_cg_set_capacity() - Set the capacity of the misc cgroup res. 88 * @type: Type of the misc res. 89 * @capacity: Supported capacity of the misc res on the host. 90 * 91 * If capacity is 0 then the charging a misc cgroup fails for that type. 92 * 93 * Context: Any context. 94 * Return: 95 * * %0 - Successfully registered the capacity. 96 * * %-EINVAL - If @type is invalid. 97 */ 98 int misc_cg_set_capacity(enum misc_res_type type, unsigned long capacity) 99 { 100 if (!valid_type(type)) 101 return -EINVAL; 102 103 WRITE_ONCE(misc_res_capacity[type], capacity); 104 return 0; 105 } 106 EXPORT_SYMBOL_GPL(misc_cg_set_capacity); 107 108 /** 109 * misc_cg_cancel_charge() - Cancel the charge from the misc cgroup. 110 * @type: Misc res type in misc cg to cancel the charge from. 111 * @cg: Misc cgroup to cancel charge from. 112 * @amount: Amount to cancel. 113 * 114 * Context: Any context. 115 */ 116 static void misc_cg_cancel_charge(enum misc_res_type type, struct misc_cg *cg, 117 unsigned long amount) 118 { 119 WARN_ONCE(atomic_long_add_negative(-amount, &cg->res[type].usage), 120 "misc cgroup resource %s became less than 0", 121 misc_res_name[type]); 122 } 123 124 /** 125 * misc_cg_try_charge() - Try charging the misc cgroup. 126 * @type: Misc res type to charge. 127 * @cg: Misc cgroup which will be charged. 128 * @amount: Amount to charge. 129 * 130 * Charge @amount to the misc cgroup. Caller must use the same cgroup during 131 * the uncharge call. 132 * 133 * Context: Any context. 134 * Return: 135 * * %0 - If successfully charged. 136 * * -EINVAL - If @type is invalid or misc res has 0 capacity. 137 * * -EBUSY - If max limit will be crossed or total usage will be more than the 138 * capacity. 139 */ 140 int misc_cg_try_charge(enum misc_res_type type, struct misc_cg *cg, 141 unsigned long amount) 142 { 143 struct misc_cg *i, *j; 144 int ret; 145 struct misc_res *res; 146 int new_usage; 147 148 if (!(valid_type(type) && cg && READ_ONCE(misc_res_capacity[type]))) 149 return -EINVAL; 150 151 if (!amount) 152 return 0; 153 154 for (i = cg; i; i = parent_misc(i)) { 155 res = &i->res[type]; 156 157 new_usage = atomic_long_add_return(amount, &res->usage); 158 if (new_usage > READ_ONCE(res->max) || 159 new_usage > READ_ONCE(misc_res_capacity[type])) { 160 ret = -EBUSY; 161 goto err_charge; 162 } 163 } 164 return 0; 165 166 err_charge: 167 for (j = i; j; j = parent_misc(j)) { 168 atomic_long_inc(&j->res[type].events); 169 cgroup_file_notify(&j->events_file); 170 } 171 172 for (j = cg; j != i; j = parent_misc(j)) 173 misc_cg_cancel_charge(type, j, amount); 174 misc_cg_cancel_charge(type, i, amount); 175 return ret; 176 } 177 EXPORT_SYMBOL_GPL(misc_cg_try_charge); 178 179 /** 180 * misc_cg_uncharge() - Uncharge the misc cgroup. 181 * @type: Misc res type which was charged. 182 * @cg: Misc cgroup which will be uncharged. 183 * @amount: Charged amount. 184 * 185 * Context: Any context. 186 */ 187 void misc_cg_uncharge(enum misc_res_type type, struct misc_cg *cg, 188 unsigned long amount) 189 { 190 struct misc_cg *i; 191 192 if (!(amount && valid_type(type) && cg)) 193 return; 194 195 for (i = cg; i; i = parent_misc(i)) 196 misc_cg_cancel_charge(type, i, amount); 197 } 198 EXPORT_SYMBOL_GPL(misc_cg_uncharge); 199 200 /** 201 * misc_cg_max_show() - Show the misc cgroup max limit. 202 * @sf: Interface file 203 * @v: Arguments passed 204 * 205 * Context: Any context. 206 * Return: 0 to denote successful print. 207 */ 208 static int misc_cg_max_show(struct seq_file *sf, void *v) 209 { 210 int i; 211 struct misc_cg *cg = css_misc(seq_css(sf)); 212 unsigned long max; 213 214 for (i = 0; i < MISC_CG_RES_TYPES; i++) { 215 if (READ_ONCE(misc_res_capacity[i])) { 216 max = READ_ONCE(cg->res[i].max); 217 if (max == MAX_NUM) 218 seq_printf(sf, "%s max\n", misc_res_name[i]); 219 else 220 seq_printf(sf, "%s %lu\n", misc_res_name[i], 221 max); 222 } 223 } 224 225 return 0; 226 } 227 228 /** 229 * misc_cg_max_write() - Update the maximum limit of the cgroup. 230 * @of: Handler for the file. 231 * @buf: Data from the user. It should be either "max", 0, or a positive 232 * integer. 233 * @nbytes: Number of bytes of the data. 234 * @off: Offset in the file. 235 * 236 * User can pass data like: 237 * echo sev 23 > misc.max, OR 238 * echo sev max > misc.max 239 * 240 * Context: Any context. 241 * Return: 242 * * >= 0 - Number of bytes processed in the input. 243 * * -EINVAL - If buf is not valid. 244 * * -ERANGE - If number is bigger than the unsigned long capacity. 245 */ 246 static ssize_t misc_cg_max_write(struct kernfs_open_file *of, char *buf, 247 size_t nbytes, loff_t off) 248 { 249 struct misc_cg *cg; 250 unsigned long max; 251 int ret = 0, i; 252 enum misc_res_type type = MISC_CG_RES_TYPES; 253 char *token; 254 255 buf = strstrip(buf); 256 token = strsep(&buf, " "); 257 258 if (!token || !buf) 259 return -EINVAL; 260 261 for (i = 0; i < MISC_CG_RES_TYPES; i++) { 262 if (!strcmp(misc_res_name[i], token)) { 263 type = i; 264 break; 265 } 266 } 267 268 if (type == MISC_CG_RES_TYPES) 269 return -EINVAL; 270 271 if (!strcmp(MAX_STR, buf)) { 272 max = MAX_NUM; 273 } else { 274 ret = kstrtoul(buf, 0, &max); 275 if (ret) 276 return ret; 277 } 278 279 cg = css_misc(of_css(of)); 280 281 if (READ_ONCE(misc_res_capacity[type])) 282 WRITE_ONCE(cg->res[type].max, max); 283 else 284 ret = -EINVAL; 285 286 return ret ? ret : nbytes; 287 } 288 289 /** 290 * misc_cg_current_show() - Show the current usage of the misc cgroup. 291 * @sf: Interface file 292 * @v: Arguments passed 293 * 294 * Context: Any context. 295 * Return: 0 to denote successful print. 296 */ 297 static int misc_cg_current_show(struct seq_file *sf, void *v) 298 { 299 int i; 300 unsigned long usage; 301 struct misc_cg *cg = css_misc(seq_css(sf)); 302 303 for (i = 0; i < MISC_CG_RES_TYPES; i++) { 304 usage = atomic_long_read(&cg->res[i].usage); 305 if (READ_ONCE(misc_res_capacity[i]) || usage) 306 seq_printf(sf, "%s %lu\n", misc_res_name[i], usage); 307 } 308 309 return 0; 310 } 311 312 /** 313 * misc_cg_capacity_show() - Show the total capacity of misc res on the host. 314 * @sf: Interface file 315 * @v: Arguments passed 316 * 317 * Only present in the root cgroup directory. 318 * 319 * Context: Any context. 320 * Return: 0 to denote successful print. 321 */ 322 static int misc_cg_capacity_show(struct seq_file *sf, void *v) 323 { 324 int i; 325 unsigned long cap; 326 327 for (i = 0; i < MISC_CG_RES_TYPES; i++) { 328 cap = READ_ONCE(misc_res_capacity[i]); 329 if (cap) 330 seq_printf(sf, "%s %lu\n", misc_res_name[i], cap); 331 } 332 333 return 0; 334 } 335 336 static int misc_events_show(struct seq_file *sf, void *v) 337 { 338 struct misc_cg *cg = css_misc(seq_css(sf)); 339 unsigned long events, i; 340 341 for (i = 0; i < MISC_CG_RES_TYPES; i++) { 342 events = atomic_long_read(&cg->res[i].events); 343 if (READ_ONCE(misc_res_capacity[i]) || events) 344 seq_printf(sf, "%s.max %lu\n", misc_res_name[i], events); 345 } 346 return 0; 347 } 348 349 /* Misc cgroup interface files */ 350 static struct cftype misc_cg_files[] = { 351 { 352 .name = "max", 353 .write = misc_cg_max_write, 354 .seq_show = misc_cg_max_show, 355 .flags = CFTYPE_NOT_ON_ROOT, 356 }, 357 { 358 .name = "current", 359 .seq_show = misc_cg_current_show, 360 }, 361 { 362 .name = "capacity", 363 .seq_show = misc_cg_capacity_show, 364 .flags = CFTYPE_ONLY_ON_ROOT, 365 }, 366 { 367 .name = "events", 368 .flags = CFTYPE_NOT_ON_ROOT, 369 .file_offset = offsetof(struct misc_cg, events_file), 370 .seq_show = misc_events_show, 371 }, 372 {} 373 }; 374 375 /** 376 * misc_cg_alloc() - Allocate misc cgroup. 377 * @parent_css: Parent cgroup. 378 * 379 * Context: Process context. 380 * Return: 381 * * struct cgroup_subsys_state* - css of the allocated cgroup. 382 * * ERR_PTR(-ENOMEM) - No memory available to allocate. 383 */ 384 static struct cgroup_subsys_state * 385 misc_cg_alloc(struct cgroup_subsys_state *parent_css) 386 { 387 enum misc_res_type i; 388 struct misc_cg *cg; 389 390 if (!parent_css) { 391 cg = &root_cg; 392 } else { 393 cg = kzalloc(sizeof(*cg), GFP_KERNEL); 394 if (!cg) 395 return ERR_PTR(-ENOMEM); 396 } 397 398 for (i = 0; i < MISC_CG_RES_TYPES; i++) { 399 WRITE_ONCE(cg->res[i].max, MAX_NUM); 400 atomic_long_set(&cg->res[i].usage, 0); 401 } 402 403 return &cg->css; 404 } 405 406 /** 407 * misc_cg_free() - Free the misc cgroup. 408 * @css: cgroup subsys object. 409 * 410 * Context: Any context. 411 */ 412 static void misc_cg_free(struct cgroup_subsys_state *css) 413 { 414 kfree(css_misc(css)); 415 } 416 417 /* Cgroup controller callbacks */ 418 struct cgroup_subsys misc_cgrp_subsys = { 419 .css_alloc = misc_cg_alloc, 420 .css_free = misc_cg_free, 421 .legacy_cftypes = misc_cg_files, 422 .dfl_cftypes = misc_cg_files, 423 }; 424