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 */
 20static 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 */
 30static 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 */
 40static 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 */
 51static 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 */
 65static 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 */
 77unsigned 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}
 84EXPORT_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 */
 98int 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}
106EXPORT_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 */
116static 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 */
140int 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
166err_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}
177EXPORT_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 */
187void 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}
198EXPORT_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 */
208static 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 */
246static 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 */
297static 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 */
322static 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
336static 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 */
350static 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		.flags = CFTYPE_NOT_ON_ROOT,
361	},
362	{
363		.name = "capacity",
364		.seq_show = misc_cg_capacity_show,
365		.flags = CFTYPE_ONLY_ON_ROOT,
366	},
367	{
368		.name = "events",
369		.flags = CFTYPE_NOT_ON_ROOT,
370		.file_offset = offsetof(struct misc_cg, events_file),
371		.seq_show = misc_events_show,
372	},
373	{}
374};
375
376/**
377 * misc_cg_alloc() - Allocate misc cgroup.
378 * @parent_css: Parent cgroup.
379 *
380 * Context: Process context.
381 * Return:
382 * * struct cgroup_subsys_state* - css of the allocated cgroup.
383 * * ERR_PTR(-ENOMEM) - No memory available to allocate.
384 */
385static struct cgroup_subsys_state *
386misc_cg_alloc(struct cgroup_subsys_state *parent_css)
387{
388	enum misc_res_type i;
389	struct misc_cg *cg;
390
391	if (!parent_css) {
392		cg = &root_cg;
393	} else {
394		cg = kzalloc(sizeof(*cg), GFP_KERNEL);
395		if (!cg)
396			return ERR_PTR(-ENOMEM);
397	}
398
399	for (i = 0; i < MISC_CG_RES_TYPES; i++) {
400		WRITE_ONCE(cg->res[i].max, MAX_NUM);
401		atomic_long_set(&cg->res[i].usage, 0);
402	}
403
404	return &cg->css;
405}
406
407/**
408 * misc_cg_free() - Free the misc cgroup.
409 * @css: cgroup subsys object.
410 *
411 * Context: Any context.
412 */
413static void misc_cg_free(struct cgroup_subsys_state *css)
414{
415	kfree(css_misc(css));
416}
417
418/* Cgroup controller callbacks */
419struct cgroup_subsys misc_cgrp_subsys = {
420	.css_alloc = misc_cg_alloc,
421	.css_free = misc_cg_free,
422	.legacy_cftypes = misc_cg_files,
423	.dfl_cftypes = misc_cg_files,
424};