1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * User interface for Resource Allocation in Resource Director Technology(RDT)
4  *
5  * Copyright (C) 2016 Intel Corporation
6  *
7  * Author: Fenghua Yu <fenghua.yu@intel.com>
8  *
9  * More information about RDT be found in the Intel (R) x86 Architecture
10  * Software Developer Manual.
11  */
12 
13 #define pr_fmt(fmt)	KBUILD_MODNAME ": " fmt
14 
15 #include <linux/cacheinfo.h>
16 #include <linux/cpu.h>
17 #include <linux/debugfs.h>
18 #include <linux/fs.h>
19 #include <linux/fs_parser.h>
20 #include <linux/sysfs.h>
21 #include <linux/kernfs.h>
22 #include <linux/seq_buf.h>
23 #include <linux/seq_file.h>
24 #include <linux/sched/signal.h>
25 #include <linux/sched/task.h>
26 #include <linux/slab.h>
27 #include <linux/task_work.h>
28 #include <linux/user_namespace.h>
29 
30 #include <uapi/linux/magic.h>
31 
32 #include <asm/resctrl.h>
33 #include "internal.h"
34 
35 DEFINE_STATIC_KEY_FALSE(rdt_enable_key);
36 DEFINE_STATIC_KEY_FALSE(rdt_mon_enable_key);
37 DEFINE_STATIC_KEY_FALSE(rdt_alloc_enable_key);
38 static struct kernfs_root *rdt_root;
39 struct rdtgroup rdtgroup_default;
40 LIST_HEAD(rdt_all_groups);
41 
42 /* Kernel fs node for "info" directory under root */
43 static struct kernfs_node *kn_info;
44 
45 /* Kernel fs node for "mon_groups" directory under root */
46 static struct kernfs_node *kn_mongrp;
47 
48 /* Kernel fs node for "mon_data" directory under root */
49 static struct kernfs_node *kn_mondata;
50 
51 static struct seq_buf last_cmd_status;
52 static char last_cmd_status_buf[512];
53 
54 struct dentry *debugfs_resctrl;
55 
56 void rdt_last_cmd_clear(void)
57 {
58 	lockdep_assert_held(&rdtgroup_mutex);
59 	seq_buf_clear(&last_cmd_status);
60 }
61 
62 void rdt_last_cmd_puts(const char *s)
63 {
64 	lockdep_assert_held(&rdtgroup_mutex);
65 	seq_buf_puts(&last_cmd_status, s);
66 }
67 
68 void rdt_last_cmd_printf(const char *fmt, ...)
69 {
70 	va_list ap;
71 
72 	va_start(ap, fmt);
73 	lockdep_assert_held(&rdtgroup_mutex);
74 	seq_buf_vprintf(&last_cmd_status, fmt, ap);
75 	va_end(ap);
76 }
77 
78 /*
79  * Trivial allocator for CLOSIDs. Since h/w only supports a small number,
80  * we can keep a bitmap of free CLOSIDs in a single integer.
81  *
82  * Using a global CLOSID across all resources has some advantages and
83  * some drawbacks:
84  * + We can simply set "current->closid" to assign a task to a resource
85  *   group.
86  * + Context switch code can avoid extra memory references deciding which
87  *   CLOSID to load into the PQR_ASSOC MSR
88  * - We give up some options in configuring resource groups across multi-socket
89  *   systems.
90  * - Our choices on how to configure each resource become progressively more
91  *   limited as the number of resources grows.
92  */
93 static int closid_free_map;
94 static int closid_free_map_len;
95 
96 int closids_supported(void)
97 {
98 	return closid_free_map_len;
99 }
100 
101 static void closid_init(void)
102 {
103 	struct rdt_resource *r;
104 	int rdt_min_closid = 32;
105 
106 	/* Compute rdt_min_closid across all resources */
107 	for_each_alloc_enabled_rdt_resource(r)
108 		rdt_min_closid = min(rdt_min_closid, r->num_closid);
109 
110 	closid_free_map = BIT_MASK(rdt_min_closid) - 1;
111 
112 	/* CLOSID 0 is always reserved for the default group */
113 	closid_free_map &= ~1;
114 	closid_free_map_len = rdt_min_closid;
115 }
116 
117 static int closid_alloc(void)
118 {
119 	u32 closid = ffs(closid_free_map);
120 
121 	if (closid == 0)
122 		return -ENOSPC;
123 	closid--;
124 	closid_free_map &= ~(1 << closid);
125 
126 	return closid;
127 }
128 
129 void closid_free(int closid)
130 {
131 	closid_free_map |= 1 << closid;
132 }
133 
134 /**
135  * closid_allocated - test if provided closid is in use
136  * @closid: closid to be tested
137  *
138  * Return: true if @closid is currently associated with a resource group,
139  * false if @closid is free
140  */
141 static bool closid_allocated(unsigned int closid)
142 {
143 	return (closid_free_map & (1 << closid)) == 0;
144 }
145 
146 /**
147  * rdtgroup_mode_by_closid - Return mode of resource group with closid
148  * @closid: closid if the resource group
149  *
150  * Each resource group is associated with a @closid. Here the mode
151  * of a resource group can be queried by searching for it using its closid.
152  *
153  * Return: mode as &enum rdtgrp_mode of resource group with closid @closid
154  */
155 enum rdtgrp_mode rdtgroup_mode_by_closid(int closid)
156 {
157 	struct rdtgroup *rdtgrp;
158 
159 	list_for_each_entry(rdtgrp, &rdt_all_groups, rdtgroup_list) {
160 		if (rdtgrp->closid == closid)
161 			return rdtgrp->mode;
162 	}
163 
164 	return RDT_NUM_MODES;
165 }
166 
167 static const char * const rdt_mode_str[] = {
168 	[RDT_MODE_SHAREABLE]		= "shareable",
169 	[RDT_MODE_EXCLUSIVE]		= "exclusive",
170 	[RDT_MODE_PSEUDO_LOCKSETUP]	= "pseudo-locksetup",
171 	[RDT_MODE_PSEUDO_LOCKED]	= "pseudo-locked",
172 };
173 
174 /**
175  * rdtgroup_mode_str - Return the string representation of mode
176  * @mode: the resource group mode as &enum rdtgroup_mode
177  *
178  * Return: string representation of valid mode, "unknown" otherwise
179  */
180 static const char *rdtgroup_mode_str(enum rdtgrp_mode mode)
181 {
182 	if (mode < RDT_MODE_SHAREABLE || mode >= RDT_NUM_MODES)
183 		return "unknown";
184 
185 	return rdt_mode_str[mode];
186 }
187 
188 /* set uid and gid of rdtgroup dirs and files to that of the creator */
189 static int rdtgroup_kn_set_ugid(struct kernfs_node *kn)
190 {
191 	struct iattr iattr = { .ia_valid = ATTR_UID | ATTR_GID,
192 				.ia_uid = current_fsuid(),
193 				.ia_gid = current_fsgid(), };
194 
195 	if (uid_eq(iattr.ia_uid, GLOBAL_ROOT_UID) &&
196 	    gid_eq(iattr.ia_gid, GLOBAL_ROOT_GID))
197 		return 0;
198 
199 	return kernfs_setattr(kn, &iattr);
200 }
201 
202 static int rdtgroup_add_file(struct kernfs_node *parent_kn, struct rftype *rft)
203 {
204 	struct kernfs_node *kn;
205 	int ret;
206 
207 	kn = __kernfs_create_file(parent_kn, rft->name, rft->mode,
208 				  GLOBAL_ROOT_UID, GLOBAL_ROOT_GID,
209 				  0, rft->kf_ops, rft, NULL, NULL);
210 	if (IS_ERR(kn))
211 		return PTR_ERR(kn);
212 
213 	ret = rdtgroup_kn_set_ugid(kn);
214 	if (ret) {
215 		kernfs_remove(kn);
216 		return ret;
217 	}
218 
219 	return 0;
220 }
221 
222 static int rdtgroup_seqfile_show(struct seq_file *m, void *arg)
223 {
224 	struct kernfs_open_file *of = m->private;
225 	struct rftype *rft = of->kn->priv;
226 
227 	if (rft->seq_show)
228 		return rft->seq_show(of, m, arg);
229 	return 0;
230 }
231 
232 static ssize_t rdtgroup_file_write(struct kernfs_open_file *of, char *buf,
233 				   size_t nbytes, loff_t off)
234 {
235 	struct rftype *rft = of->kn->priv;
236 
237 	if (rft->write)
238 		return rft->write(of, buf, nbytes, off);
239 
240 	return -EINVAL;
241 }
242 
243 static const struct kernfs_ops rdtgroup_kf_single_ops = {
244 	.atomic_write_len	= PAGE_SIZE,
245 	.write			= rdtgroup_file_write,
246 	.seq_show		= rdtgroup_seqfile_show,
247 };
248 
249 static const struct kernfs_ops kf_mondata_ops = {
250 	.atomic_write_len	= PAGE_SIZE,
251 	.seq_show		= rdtgroup_mondata_show,
252 };
253 
254 static bool is_cpu_list(struct kernfs_open_file *of)
255 {
256 	struct rftype *rft = of->kn->priv;
257 
258 	return rft->flags & RFTYPE_FLAGS_CPUS_LIST;
259 }
260 
261 static int rdtgroup_cpus_show(struct kernfs_open_file *of,
262 			      struct seq_file *s, void *v)
263 {
264 	struct rdtgroup *rdtgrp;
265 	struct cpumask *mask;
266 	int ret = 0;
267 
268 	rdtgrp = rdtgroup_kn_lock_live(of->kn);
269 
270 	if (rdtgrp) {
271 		if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) {
272 			if (!rdtgrp->plr->d) {
273 				rdt_last_cmd_clear();
274 				rdt_last_cmd_puts("Cache domain offline\n");
275 				ret = -ENODEV;
276 			} else {
277 				mask = &rdtgrp->plr->d->cpu_mask;
278 				seq_printf(s, is_cpu_list(of) ?
279 					   "%*pbl\n" : "%*pb\n",
280 					   cpumask_pr_args(mask));
281 			}
282 		} else {
283 			seq_printf(s, is_cpu_list(of) ? "%*pbl\n" : "%*pb\n",
284 				   cpumask_pr_args(&rdtgrp->cpu_mask));
285 		}
286 	} else {
287 		ret = -ENOENT;
288 	}
289 	rdtgroup_kn_unlock(of->kn);
290 
291 	return ret;
292 }
293 
294 /*
295  * This is safe against resctrl_sched_in() called from __switch_to()
296  * because __switch_to() is executed with interrupts disabled. A local call
297  * from update_closid_rmid() is protected against __switch_to() because
298  * preemption is disabled.
299  */
300 static void update_cpu_closid_rmid(void *info)
301 {
302 	struct rdtgroup *r = info;
303 
304 	if (r) {
305 		this_cpu_write(pqr_state.default_closid, r->closid);
306 		this_cpu_write(pqr_state.default_rmid, r->mon.rmid);
307 	}
308 
309 	/*
310 	 * We cannot unconditionally write the MSR because the current
311 	 * executing task might have its own closid selected. Just reuse
312 	 * the context switch code.
313 	 */
314 	resctrl_sched_in();
315 }
316 
317 /*
318  * Update the PGR_ASSOC MSR on all cpus in @cpu_mask,
319  *
320  * Per task closids/rmids must have been set up before calling this function.
321  */
322 static void
323 update_closid_rmid(const struct cpumask *cpu_mask, struct rdtgroup *r)
324 {
325 	int cpu = get_cpu();
326 
327 	if (cpumask_test_cpu(cpu, cpu_mask))
328 		update_cpu_closid_rmid(r);
329 	smp_call_function_many(cpu_mask, update_cpu_closid_rmid, r, 1);
330 	put_cpu();
331 }
332 
333 static int cpus_mon_write(struct rdtgroup *rdtgrp, cpumask_var_t newmask,
334 			  cpumask_var_t tmpmask)
335 {
336 	struct rdtgroup *prgrp = rdtgrp->mon.parent, *crgrp;
337 	struct list_head *head;
338 
339 	/* Check whether cpus belong to parent ctrl group */
340 	cpumask_andnot(tmpmask, newmask, &prgrp->cpu_mask);
341 	if (cpumask_weight(tmpmask)) {
342 		rdt_last_cmd_puts("Can only add CPUs to mongroup that belong to parent\n");
343 		return -EINVAL;
344 	}
345 
346 	/* Check whether cpus are dropped from this group */
347 	cpumask_andnot(tmpmask, &rdtgrp->cpu_mask, newmask);
348 	if (cpumask_weight(tmpmask)) {
349 		/* Give any dropped cpus to parent rdtgroup */
350 		cpumask_or(&prgrp->cpu_mask, &prgrp->cpu_mask, tmpmask);
351 		update_closid_rmid(tmpmask, prgrp);
352 	}
353 
354 	/*
355 	 * If we added cpus, remove them from previous group that owned them
356 	 * and update per-cpu rmid
357 	 */
358 	cpumask_andnot(tmpmask, newmask, &rdtgrp->cpu_mask);
359 	if (cpumask_weight(tmpmask)) {
360 		head = &prgrp->mon.crdtgrp_list;
361 		list_for_each_entry(crgrp, head, mon.crdtgrp_list) {
362 			if (crgrp == rdtgrp)
363 				continue;
364 			cpumask_andnot(&crgrp->cpu_mask, &crgrp->cpu_mask,
365 				       tmpmask);
366 		}
367 		update_closid_rmid(tmpmask, rdtgrp);
368 	}
369 
370 	/* Done pushing/pulling - update this group with new mask */
371 	cpumask_copy(&rdtgrp->cpu_mask, newmask);
372 
373 	return 0;
374 }
375 
376 static void cpumask_rdtgrp_clear(struct rdtgroup *r, struct cpumask *m)
377 {
378 	struct rdtgroup *crgrp;
379 
380 	cpumask_andnot(&r->cpu_mask, &r->cpu_mask, m);
381 	/* update the child mon group masks as well*/
382 	list_for_each_entry(crgrp, &r->mon.crdtgrp_list, mon.crdtgrp_list)
383 		cpumask_and(&crgrp->cpu_mask, &r->cpu_mask, &crgrp->cpu_mask);
384 }
385 
386 static int cpus_ctrl_write(struct rdtgroup *rdtgrp, cpumask_var_t newmask,
387 			   cpumask_var_t tmpmask, cpumask_var_t tmpmask1)
388 {
389 	struct rdtgroup *r, *crgrp;
390 	struct list_head *head;
391 
392 	/* Check whether cpus are dropped from this group */
393 	cpumask_andnot(tmpmask, &rdtgrp->cpu_mask, newmask);
394 	if (cpumask_weight(tmpmask)) {
395 		/* Can't drop from default group */
396 		if (rdtgrp == &rdtgroup_default) {
397 			rdt_last_cmd_puts("Can't drop CPUs from default group\n");
398 			return -EINVAL;
399 		}
400 
401 		/* Give any dropped cpus to rdtgroup_default */
402 		cpumask_or(&rdtgroup_default.cpu_mask,
403 			   &rdtgroup_default.cpu_mask, tmpmask);
404 		update_closid_rmid(tmpmask, &rdtgroup_default);
405 	}
406 
407 	/*
408 	 * If we added cpus, remove them from previous group and
409 	 * the prev group's child groups that owned them
410 	 * and update per-cpu closid/rmid.
411 	 */
412 	cpumask_andnot(tmpmask, newmask, &rdtgrp->cpu_mask);
413 	if (cpumask_weight(tmpmask)) {
414 		list_for_each_entry(r, &rdt_all_groups, rdtgroup_list) {
415 			if (r == rdtgrp)
416 				continue;
417 			cpumask_and(tmpmask1, &r->cpu_mask, tmpmask);
418 			if (cpumask_weight(tmpmask1))
419 				cpumask_rdtgrp_clear(r, tmpmask1);
420 		}
421 		update_closid_rmid(tmpmask, rdtgrp);
422 	}
423 
424 	/* Done pushing/pulling - update this group with new mask */
425 	cpumask_copy(&rdtgrp->cpu_mask, newmask);
426 
427 	/*
428 	 * Clear child mon group masks since there is a new parent mask
429 	 * now and update the rmid for the cpus the child lost.
430 	 */
431 	head = &rdtgrp->mon.crdtgrp_list;
432 	list_for_each_entry(crgrp, head, mon.crdtgrp_list) {
433 		cpumask_and(tmpmask, &rdtgrp->cpu_mask, &crgrp->cpu_mask);
434 		update_closid_rmid(tmpmask, rdtgrp);
435 		cpumask_clear(&crgrp->cpu_mask);
436 	}
437 
438 	return 0;
439 }
440 
441 static ssize_t rdtgroup_cpus_write(struct kernfs_open_file *of,
442 				   char *buf, size_t nbytes, loff_t off)
443 {
444 	cpumask_var_t tmpmask, newmask, tmpmask1;
445 	struct rdtgroup *rdtgrp;
446 	int ret;
447 
448 	if (!buf)
449 		return -EINVAL;
450 
451 	if (!zalloc_cpumask_var(&tmpmask, GFP_KERNEL))
452 		return -ENOMEM;
453 	if (!zalloc_cpumask_var(&newmask, GFP_KERNEL)) {
454 		free_cpumask_var(tmpmask);
455 		return -ENOMEM;
456 	}
457 	if (!zalloc_cpumask_var(&tmpmask1, GFP_KERNEL)) {
458 		free_cpumask_var(tmpmask);
459 		free_cpumask_var(newmask);
460 		return -ENOMEM;
461 	}
462 
463 	rdtgrp = rdtgroup_kn_lock_live(of->kn);
464 	if (!rdtgrp) {
465 		ret = -ENOENT;
466 		goto unlock;
467 	}
468 
469 	if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED ||
470 	    rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) {
471 		ret = -EINVAL;
472 		rdt_last_cmd_puts("Pseudo-locking in progress\n");
473 		goto unlock;
474 	}
475 
476 	if (is_cpu_list(of))
477 		ret = cpulist_parse(buf, newmask);
478 	else
479 		ret = cpumask_parse(buf, newmask);
480 
481 	if (ret) {
482 		rdt_last_cmd_puts("Bad CPU list/mask\n");
483 		goto unlock;
484 	}
485 
486 	/* check that user didn't specify any offline cpus */
487 	cpumask_andnot(tmpmask, newmask, cpu_online_mask);
488 	if (cpumask_weight(tmpmask)) {
489 		ret = -EINVAL;
490 		rdt_last_cmd_puts("Can only assign online CPUs\n");
491 		goto unlock;
492 	}
493 
494 	if (rdtgrp->type == RDTCTRL_GROUP)
495 		ret = cpus_ctrl_write(rdtgrp, newmask, tmpmask, tmpmask1);
496 	else if (rdtgrp->type == RDTMON_GROUP)
497 		ret = cpus_mon_write(rdtgrp, newmask, tmpmask);
498 	else
499 		ret = -EINVAL;
500 
501 unlock:
502 	rdtgroup_kn_unlock(of->kn);
503 	free_cpumask_var(tmpmask);
504 	free_cpumask_var(newmask);
505 	free_cpumask_var(tmpmask1);
506 
507 	return ret ?: nbytes;
508 }
509 
510 /**
511  * rdtgroup_remove - the helper to remove resource group safely
512  * @rdtgrp: resource group to remove
513  *
514  * On resource group creation via a mkdir, an extra kernfs_node reference is
515  * taken to ensure that the rdtgroup structure remains accessible for the
516  * rdtgroup_kn_unlock() calls where it is removed.
517  *
518  * Drop the extra reference here, then free the rdtgroup structure.
519  *
520  * Return: void
521  */
522 static void rdtgroup_remove(struct rdtgroup *rdtgrp)
523 {
524 	kernfs_put(rdtgrp->kn);
525 	kfree(rdtgrp);
526 }
527 
528 static void _update_task_closid_rmid(void *task)
529 {
530 	/*
531 	 * If the task is still current on this CPU, update PQR_ASSOC MSR.
532 	 * Otherwise, the MSR is updated when the task is scheduled in.
533 	 */
534 	if (task == current)
535 		resctrl_sched_in();
536 }
537 
538 static void update_task_closid_rmid(struct task_struct *t)
539 {
540 	if (IS_ENABLED(CONFIG_SMP) && task_curr(t))
541 		smp_call_function_single(task_cpu(t), _update_task_closid_rmid, t, 1);
542 	else
543 		_update_task_closid_rmid(t);
544 }
545 
546 static int __rdtgroup_move_task(struct task_struct *tsk,
547 				struct rdtgroup *rdtgrp)
548 {
549 	/* If the task is already in rdtgrp, no need to move the task. */
550 	if ((rdtgrp->type == RDTCTRL_GROUP && tsk->closid == rdtgrp->closid &&
551 	     tsk->rmid == rdtgrp->mon.rmid) ||
552 	    (rdtgrp->type == RDTMON_GROUP && tsk->rmid == rdtgrp->mon.rmid &&
553 	     tsk->closid == rdtgrp->mon.parent->closid))
554 		return 0;
555 
556 	/*
557 	 * Set the task's closid/rmid before the PQR_ASSOC MSR can be
558 	 * updated by them.
559 	 *
560 	 * For ctrl_mon groups, move both closid and rmid.
561 	 * For monitor groups, can move the tasks only from
562 	 * their parent CTRL group.
563 	 */
564 
565 	if (rdtgrp->type == RDTCTRL_GROUP) {
566 		WRITE_ONCE(tsk->closid, rdtgrp->closid);
567 		WRITE_ONCE(tsk->rmid, rdtgrp->mon.rmid);
568 	} else if (rdtgrp->type == RDTMON_GROUP) {
569 		if (rdtgrp->mon.parent->closid == tsk->closid) {
570 			WRITE_ONCE(tsk->rmid, rdtgrp->mon.rmid);
571 		} else {
572 			rdt_last_cmd_puts("Can't move task to different control group\n");
573 			return -EINVAL;
574 		}
575 	}
576 
577 	/*
578 	 * Ensure the task's closid and rmid are written before determining if
579 	 * the task is current that will decide if it will be interrupted.
580 	 */
581 	barrier();
582 
583 	/*
584 	 * By now, the task's closid and rmid are set. If the task is current
585 	 * on a CPU, the PQR_ASSOC MSR needs to be updated to make the resource
586 	 * group go into effect. If the task is not current, the MSR will be
587 	 * updated when the task is scheduled in.
588 	 */
589 	update_task_closid_rmid(tsk);
590 
591 	return 0;
592 }
593 
594 static bool is_closid_match(struct task_struct *t, struct rdtgroup *r)
595 {
596 	return (rdt_alloc_capable &&
597 	       (r->type == RDTCTRL_GROUP) && (t->closid == r->closid));
598 }
599 
600 static bool is_rmid_match(struct task_struct *t, struct rdtgroup *r)
601 {
602 	return (rdt_mon_capable &&
603 	       (r->type == RDTMON_GROUP) && (t->rmid == r->mon.rmid));
604 }
605 
606 /**
607  * rdtgroup_tasks_assigned - Test if tasks have been assigned to resource group
608  * @r: Resource group
609  *
610  * Return: 1 if tasks have been assigned to @r, 0 otherwise
611  */
612 int rdtgroup_tasks_assigned(struct rdtgroup *r)
613 {
614 	struct task_struct *p, *t;
615 	int ret = 0;
616 
617 	lockdep_assert_held(&rdtgroup_mutex);
618 
619 	rcu_read_lock();
620 	for_each_process_thread(p, t) {
621 		if (is_closid_match(t, r) || is_rmid_match(t, r)) {
622 			ret = 1;
623 			break;
624 		}
625 	}
626 	rcu_read_unlock();
627 
628 	return ret;
629 }
630 
631 static int rdtgroup_task_write_permission(struct task_struct *task,
632 					  struct kernfs_open_file *of)
633 {
634 	const struct cred *tcred = get_task_cred(task);
635 	const struct cred *cred = current_cred();
636 	int ret = 0;
637 
638 	/*
639 	 * Even if we're attaching all tasks in the thread group, we only
640 	 * need to check permissions on one of them.
641 	 */
642 	if (!uid_eq(cred->euid, GLOBAL_ROOT_UID) &&
643 	    !uid_eq(cred->euid, tcred->uid) &&
644 	    !uid_eq(cred->euid, tcred->suid)) {
645 		rdt_last_cmd_printf("No permission to move task %d\n", task->pid);
646 		ret = -EPERM;
647 	}
648 
649 	put_cred(tcred);
650 	return ret;
651 }
652 
653 static int rdtgroup_move_task(pid_t pid, struct rdtgroup *rdtgrp,
654 			      struct kernfs_open_file *of)
655 {
656 	struct task_struct *tsk;
657 	int ret;
658 
659 	rcu_read_lock();
660 	if (pid) {
661 		tsk = find_task_by_vpid(pid);
662 		if (!tsk) {
663 			rcu_read_unlock();
664 			rdt_last_cmd_printf("No task %d\n", pid);
665 			return -ESRCH;
666 		}
667 	} else {
668 		tsk = current;
669 	}
670 
671 	get_task_struct(tsk);
672 	rcu_read_unlock();
673 
674 	ret = rdtgroup_task_write_permission(tsk, of);
675 	if (!ret)
676 		ret = __rdtgroup_move_task(tsk, rdtgrp);
677 
678 	put_task_struct(tsk);
679 	return ret;
680 }
681 
682 static ssize_t rdtgroup_tasks_write(struct kernfs_open_file *of,
683 				    char *buf, size_t nbytes, loff_t off)
684 {
685 	struct rdtgroup *rdtgrp;
686 	int ret = 0;
687 	pid_t pid;
688 
689 	if (kstrtoint(strstrip(buf), 0, &pid) || pid < 0)
690 		return -EINVAL;
691 	rdtgrp = rdtgroup_kn_lock_live(of->kn);
692 	if (!rdtgrp) {
693 		rdtgroup_kn_unlock(of->kn);
694 		return -ENOENT;
695 	}
696 	rdt_last_cmd_clear();
697 
698 	if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED ||
699 	    rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) {
700 		ret = -EINVAL;
701 		rdt_last_cmd_puts("Pseudo-locking in progress\n");
702 		goto unlock;
703 	}
704 
705 	ret = rdtgroup_move_task(pid, rdtgrp, of);
706 
707 unlock:
708 	rdtgroup_kn_unlock(of->kn);
709 
710 	return ret ?: nbytes;
711 }
712 
713 static void show_rdt_tasks(struct rdtgroup *r, struct seq_file *s)
714 {
715 	struct task_struct *p, *t;
716 
717 	rcu_read_lock();
718 	for_each_process_thread(p, t) {
719 		if (is_closid_match(t, r) || is_rmid_match(t, r))
720 			seq_printf(s, "%d\n", t->pid);
721 	}
722 	rcu_read_unlock();
723 }
724 
725 static int rdtgroup_tasks_show(struct kernfs_open_file *of,
726 			       struct seq_file *s, void *v)
727 {
728 	struct rdtgroup *rdtgrp;
729 	int ret = 0;
730 
731 	rdtgrp = rdtgroup_kn_lock_live(of->kn);
732 	if (rdtgrp)
733 		show_rdt_tasks(rdtgrp, s);
734 	else
735 		ret = -ENOENT;
736 	rdtgroup_kn_unlock(of->kn);
737 
738 	return ret;
739 }
740 
741 #ifdef CONFIG_PROC_CPU_RESCTRL
742 
743 /*
744  * A task can only be part of one resctrl control group and of one monitor
745  * group which is associated to that control group.
746  *
747  * 1)   res:
748  *      mon:
749  *
750  *    resctrl is not available.
751  *
752  * 2)   res:/
753  *      mon:
754  *
755  *    Task is part of the root resctrl control group, and it is not associated
756  *    to any monitor group.
757  *
758  * 3)  res:/
759  *     mon:mon0
760  *
761  *    Task is part of the root resctrl control group and monitor group mon0.
762  *
763  * 4)  res:group0
764  *     mon:
765  *
766  *    Task is part of resctrl control group group0, and it is not associated
767  *    to any monitor group.
768  *
769  * 5) res:group0
770  *    mon:mon1
771  *
772  *    Task is part of resctrl control group group0 and monitor group mon1.
773  */
774 int proc_resctrl_show(struct seq_file *s, struct pid_namespace *ns,
775 		      struct pid *pid, struct task_struct *tsk)
776 {
777 	struct rdtgroup *rdtg;
778 	int ret = 0;
779 
780 	mutex_lock(&rdtgroup_mutex);
781 
782 	/* Return empty if resctrl has not been mounted. */
783 	if (!static_branch_unlikely(&rdt_enable_key)) {
784 		seq_puts(s, "res:\nmon:\n");
785 		goto unlock;
786 	}
787 
788 	list_for_each_entry(rdtg, &rdt_all_groups, rdtgroup_list) {
789 		struct rdtgroup *crg;
790 
791 		/*
792 		 * Task information is only relevant for shareable
793 		 * and exclusive groups.
794 		 */
795 		if (rdtg->mode != RDT_MODE_SHAREABLE &&
796 		    rdtg->mode != RDT_MODE_EXCLUSIVE)
797 			continue;
798 
799 		if (rdtg->closid != tsk->closid)
800 			continue;
801 
802 		seq_printf(s, "res:%s%s\n", (rdtg == &rdtgroup_default) ? "/" : "",
803 			   rdtg->kn->name);
804 		seq_puts(s, "mon:");
805 		list_for_each_entry(crg, &rdtg->mon.crdtgrp_list,
806 				    mon.crdtgrp_list) {
807 			if (tsk->rmid != crg->mon.rmid)
808 				continue;
809 			seq_printf(s, "%s", crg->kn->name);
810 			break;
811 		}
812 		seq_putc(s, '\n');
813 		goto unlock;
814 	}
815 	/*
816 	 * The above search should succeed. Otherwise return
817 	 * with an error.
818 	 */
819 	ret = -ENOENT;
820 unlock:
821 	mutex_unlock(&rdtgroup_mutex);
822 
823 	return ret;
824 }
825 #endif
826 
827 static int rdt_last_cmd_status_show(struct kernfs_open_file *of,
828 				    struct seq_file *seq, void *v)
829 {
830 	int len;
831 
832 	mutex_lock(&rdtgroup_mutex);
833 	len = seq_buf_used(&last_cmd_status);
834 	if (len)
835 		seq_printf(seq, "%.*s", len, last_cmd_status_buf);
836 	else
837 		seq_puts(seq, "ok\n");
838 	mutex_unlock(&rdtgroup_mutex);
839 	return 0;
840 }
841 
842 static int rdt_num_closids_show(struct kernfs_open_file *of,
843 				struct seq_file *seq, void *v)
844 {
845 	struct rdt_resource *r = of->kn->parent->priv;
846 
847 	seq_printf(seq, "%d\n", r->num_closid);
848 	return 0;
849 }
850 
851 static int rdt_default_ctrl_show(struct kernfs_open_file *of,
852 			     struct seq_file *seq, void *v)
853 {
854 	struct rdt_resource *r = of->kn->parent->priv;
855 
856 	seq_printf(seq, "%x\n", r->default_ctrl);
857 	return 0;
858 }
859 
860 static int rdt_min_cbm_bits_show(struct kernfs_open_file *of,
861 			     struct seq_file *seq, void *v)
862 {
863 	struct rdt_resource *r = of->kn->parent->priv;
864 
865 	seq_printf(seq, "%u\n", r->cache.min_cbm_bits);
866 	return 0;
867 }
868 
869 static int rdt_shareable_bits_show(struct kernfs_open_file *of,
870 				   struct seq_file *seq, void *v)
871 {
872 	struct rdt_resource *r = of->kn->parent->priv;
873 
874 	seq_printf(seq, "%x\n", r->cache.shareable_bits);
875 	return 0;
876 }
877 
878 /**
879  * rdt_bit_usage_show - Display current usage of resources
880  *
881  * A domain is a shared resource that can now be allocated differently. Here
882  * we display the current regions of the domain as an annotated bitmask.
883  * For each domain of this resource its allocation bitmask
884  * is annotated as below to indicate the current usage of the corresponding bit:
885  *   0 - currently unused
886  *   X - currently available for sharing and used by software and hardware
887  *   H - currently used by hardware only but available for software use
888  *   S - currently used and shareable by software only
889  *   E - currently used exclusively by one resource group
890  *   P - currently pseudo-locked by one resource group
891  */
892 static int rdt_bit_usage_show(struct kernfs_open_file *of,
893 			      struct seq_file *seq, void *v)
894 {
895 	struct rdt_resource *r = of->kn->parent->priv;
896 	/*
897 	 * Use unsigned long even though only 32 bits are used to ensure
898 	 * test_bit() is used safely.
899 	 */
900 	unsigned long sw_shareable = 0, hw_shareable = 0;
901 	unsigned long exclusive = 0, pseudo_locked = 0;
902 	struct rdt_domain *dom;
903 	int i, hwb, swb, excl, psl;
904 	enum rdtgrp_mode mode;
905 	bool sep = false;
906 	u32 *ctrl;
907 
908 	mutex_lock(&rdtgroup_mutex);
909 	hw_shareable = r->cache.shareable_bits;
910 	list_for_each_entry(dom, &r->domains, list) {
911 		if (sep)
912 			seq_putc(seq, ';');
913 		ctrl = dom->ctrl_val;
914 		sw_shareable = 0;
915 		exclusive = 0;
916 		seq_printf(seq, "%d=", dom->id);
917 		for (i = 0; i < closids_supported(); i++, ctrl++) {
918 			if (!closid_allocated(i))
919 				continue;
920 			mode = rdtgroup_mode_by_closid(i);
921 			switch (mode) {
922 			case RDT_MODE_SHAREABLE:
923 				sw_shareable |= *ctrl;
924 				break;
925 			case RDT_MODE_EXCLUSIVE:
926 				exclusive |= *ctrl;
927 				break;
928 			case RDT_MODE_PSEUDO_LOCKSETUP:
929 			/*
930 			 * RDT_MODE_PSEUDO_LOCKSETUP is possible
931 			 * here but not included since the CBM
932 			 * associated with this CLOSID in this mode
933 			 * is not initialized and no task or cpu can be
934 			 * assigned this CLOSID.
935 			 */
936 				break;
937 			case RDT_MODE_PSEUDO_LOCKED:
938 			case RDT_NUM_MODES:
939 				WARN(1,
940 				     "invalid mode for closid %d\n", i);
941 				break;
942 			}
943 		}
944 		for (i = r->cache.cbm_len - 1; i >= 0; i--) {
945 			pseudo_locked = dom->plr ? dom->plr->cbm : 0;
946 			hwb = test_bit(i, &hw_shareable);
947 			swb = test_bit(i, &sw_shareable);
948 			excl = test_bit(i, &exclusive);
949 			psl = test_bit(i, &pseudo_locked);
950 			if (hwb && swb)
951 				seq_putc(seq, 'X');
952 			else if (hwb && !swb)
953 				seq_putc(seq, 'H');
954 			else if (!hwb && swb)
955 				seq_putc(seq, 'S');
956 			else if (excl)
957 				seq_putc(seq, 'E');
958 			else if (psl)
959 				seq_putc(seq, 'P');
960 			else /* Unused bits remain */
961 				seq_putc(seq, '0');
962 		}
963 		sep = true;
964 	}
965 	seq_putc(seq, '\n');
966 	mutex_unlock(&rdtgroup_mutex);
967 	return 0;
968 }
969 
970 static int rdt_min_bw_show(struct kernfs_open_file *of,
971 			     struct seq_file *seq, void *v)
972 {
973 	struct rdt_resource *r = of->kn->parent->priv;
974 
975 	seq_printf(seq, "%u\n", r->membw.min_bw);
976 	return 0;
977 }
978 
979 static int rdt_num_rmids_show(struct kernfs_open_file *of,
980 			      struct seq_file *seq, void *v)
981 {
982 	struct rdt_resource *r = of->kn->parent->priv;
983 
984 	seq_printf(seq, "%d\n", r->num_rmid);
985 
986 	return 0;
987 }
988 
989 static int rdt_mon_features_show(struct kernfs_open_file *of,
990 				 struct seq_file *seq, void *v)
991 {
992 	struct rdt_resource *r = of->kn->parent->priv;
993 	struct mon_evt *mevt;
994 
995 	list_for_each_entry(mevt, &r->evt_list, list)
996 		seq_printf(seq, "%s\n", mevt->name);
997 
998 	return 0;
999 }
1000 
1001 static int rdt_bw_gran_show(struct kernfs_open_file *of,
1002 			     struct seq_file *seq, void *v)
1003 {
1004 	struct rdt_resource *r = of->kn->parent->priv;
1005 
1006 	seq_printf(seq, "%u\n", r->membw.bw_gran);
1007 	return 0;
1008 }
1009 
1010 static int rdt_delay_linear_show(struct kernfs_open_file *of,
1011 			     struct seq_file *seq, void *v)
1012 {
1013 	struct rdt_resource *r = of->kn->parent->priv;
1014 
1015 	seq_printf(seq, "%u\n", r->membw.delay_linear);
1016 	return 0;
1017 }
1018 
1019 static int max_threshold_occ_show(struct kernfs_open_file *of,
1020 				  struct seq_file *seq, void *v)
1021 {
1022 	struct rdt_resource *r = of->kn->parent->priv;
1023 
1024 	seq_printf(seq, "%u\n", resctrl_cqm_threshold * r->mon_scale);
1025 
1026 	return 0;
1027 }
1028 
1029 static int rdt_thread_throttle_mode_show(struct kernfs_open_file *of,
1030 					 struct seq_file *seq, void *v)
1031 {
1032 	struct rdt_resource *r = of->kn->parent->priv;
1033 
1034 	if (r->membw.throttle_mode == THREAD_THROTTLE_PER_THREAD)
1035 		seq_puts(seq, "per-thread\n");
1036 	else
1037 		seq_puts(seq, "max\n");
1038 
1039 	return 0;
1040 }
1041 
1042 static ssize_t max_threshold_occ_write(struct kernfs_open_file *of,
1043 				       char *buf, size_t nbytes, loff_t off)
1044 {
1045 	struct rdt_resource *r = of->kn->parent->priv;
1046 	unsigned int bytes;
1047 	int ret;
1048 
1049 	ret = kstrtouint(buf, 0, &bytes);
1050 	if (ret)
1051 		return ret;
1052 
1053 	if (bytes > (boot_cpu_data.x86_cache_size * 1024))
1054 		return -EINVAL;
1055 
1056 	resctrl_cqm_threshold = bytes / r->mon_scale;
1057 
1058 	return nbytes;
1059 }
1060 
1061 /*
1062  * rdtgroup_mode_show - Display mode of this resource group
1063  */
1064 static int rdtgroup_mode_show(struct kernfs_open_file *of,
1065 			      struct seq_file *s, void *v)
1066 {
1067 	struct rdtgroup *rdtgrp;
1068 
1069 	rdtgrp = rdtgroup_kn_lock_live(of->kn);
1070 	if (!rdtgrp) {
1071 		rdtgroup_kn_unlock(of->kn);
1072 		return -ENOENT;
1073 	}
1074 
1075 	seq_printf(s, "%s\n", rdtgroup_mode_str(rdtgrp->mode));
1076 
1077 	rdtgroup_kn_unlock(of->kn);
1078 	return 0;
1079 }
1080 
1081 /**
1082  * rdt_cdp_peer_get - Retrieve CDP peer if it exists
1083  * @r: RDT resource to which RDT domain @d belongs
1084  * @d: Cache instance for which a CDP peer is requested
1085  * @r_cdp: RDT resource that shares hardware with @r (RDT resource peer)
1086  *         Used to return the result.
1087  * @d_cdp: RDT domain that shares hardware with @d (RDT domain peer)
1088  *         Used to return the result.
1089  *
1090  * RDT resources are managed independently and by extension the RDT domains
1091  * (RDT resource instances) are managed independently also. The Code and
1092  * Data Prioritization (CDP) RDT resources, while managed independently,
1093  * could refer to the same underlying hardware. For example,
1094  * RDT_RESOURCE_L2CODE and RDT_RESOURCE_L2DATA both refer to the L2 cache.
1095  *
1096  * When provided with an RDT resource @r and an instance of that RDT
1097  * resource @d rdt_cdp_peer_get() will return if there is a peer RDT
1098  * resource and the exact instance that shares the same hardware.
1099  *
1100  * Return: 0 if a CDP peer was found, <0 on error or if no CDP peer exists.
1101  *         If a CDP peer was found, @r_cdp will point to the peer RDT resource
1102  *         and @d_cdp will point to the peer RDT domain.
1103  */
1104 static int rdt_cdp_peer_get(struct rdt_resource *r, struct rdt_domain *d,
1105 			    struct rdt_resource **r_cdp,
1106 			    struct rdt_domain **d_cdp)
1107 {
1108 	struct rdt_resource *_r_cdp = NULL;
1109 	struct rdt_domain *_d_cdp = NULL;
1110 	int ret = 0;
1111 
1112 	switch (r->rid) {
1113 	case RDT_RESOURCE_L3DATA:
1114 		_r_cdp = &rdt_resources_all[RDT_RESOURCE_L3CODE];
1115 		break;
1116 	case RDT_RESOURCE_L3CODE:
1117 		_r_cdp =  &rdt_resources_all[RDT_RESOURCE_L3DATA];
1118 		break;
1119 	case RDT_RESOURCE_L2DATA:
1120 		_r_cdp =  &rdt_resources_all[RDT_RESOURCE_L2CODE];
1121 		break;
1122 	case RDT_RESOURCE_L2CODE:
1123 		_r_cdp =  &rdt_resources_all[RDT_RESOURCE_L2DATA];
1124 		break;
1125 	default:
1126 		ret = -ENOENT;
1127 		goto out;
1128 	}
1129 
1130 	/*
1131 	 * When a new CPU comes online and CDP is enabled then the new
1132 	 * RDT domains (if any) associated with both CDP RDT resources
1133 	 * are added in the same CPU online routine while the
1134 	 * rdtgroup_mutex is held. It should thus not happen for one
1135 	 * RDT domain to exist and be associated with its RDT CDP
1136 	 * resource but there is no RDT domain associated with the
1137 	 * peer RDT CDP resource. Hence the WARN.
1138 	 */
1139 	_d_cdp = rdt_find_domain(_r_cdp, d->id, NULL);
1140 	if (WARN_ON(IS_ERR_OR_NULL(_d_cdp))) {
1141 		_r_cdp = NULL;
1142 		_d_cdp = NULL;
1143 		ret = -EINVAL;
1144 	}
1145 
1146 out:
1147 	*r_cdp = _r_cdp;
1148 	*d_cdp = _d_cdp;
1149 
1150 	return ret;
1151 }
1152 
1153 /**
1154  * __rdtgroup_cbm_overlaps - Does CBM for intended closid overlap with other
1155  * @r: Resource to which domain instance @d belongs.
1156  * @d: The domain instance for which @closid is being tested.
1157  * @cbm: Capacity bitmask being tested.
1158  * @closid: Intended closid for @cbm.
1159  * @exclusive: Only check if overlaps with exclusive resource groups
1160  *
1161  * Checks if provided @cbm intended to be used for @closid on domain
1162  * @d overlaps with any other closids or other hardware usage associated
1163  * with this domain. If @exclusive is true then only overlaps with
1164  * resource groups in exclusive mode will be considered. If @exclusive
1165  * is false then overlaps with any resource group or hardware entities
1166  * will be considered.
1167  *
1168  * @cbm is unsigned long, even if only 32 bits are used, to make the
1169  * bitmap functions work correctly.
1170  *
1171  * Return: false if CBM does not overlap, true if it does.
1172  */
1173 static bool __rdtgroup_cbm_overlaps(struct rdt_resource *r, struct rdt_domain *d,
1174 				    unsigned long cbm, int closid, bool exclusive)
1175 {
1176 	enum rdtgrp_mode mode;
1177 	unsigned long ctrl_b;
1178 	u32 *ctrl;
1179 	int i;
1180 
1181 	/* Check for any overlap with regions used by hardware directly */
1182 	if (!exclusive) {
1183 		ctrl_b = r->cache.shareable_bits;
1184 		if (bitmap_intersects(&cbm, &ctrl_b, r->cache.cbm_len))
1185 			return true;
1186 	}
1187 
1188 	/* Check for overlap with other resource groups */
1189 	ctrl = d->ctrl_val;
1190 	for (i = 0; i < closids_supported(); i++, ctrl++) {
1191 		ctrl_b = *ctrl;
1192 		mode = rdtgroup_mode_by_closid(i);
1193 		if (closid_allocated(i) && i != closid &&
1194 		    mode != RDT_MODE_PSEUDO_LOCKSETUP) {
1195 			if (bitmap_intersects(&cbm, &ctrl_b, r->cache.cbm_len)) {
1196 				if (exclusive) {
1197 					if (mode == RDT_MODE_EXCLUSIVE)
1198 						return true;
1199 					continue;
1200 				}
1201 				return true;
1202 			}
1203 		}
1204 	}
1205 
1206 	return false;
1207 }
1208 
1209 /**
1210  * rdtgroup_cbm_overlaps - Does CBM overlap with other use of hardware
1211  * @r: Resource to which domain instance @d belongs.
1212  * @d: The domain instance for which @closid is being tested.
1213  * @cbm: Capacity bitmask being tested.
1214  * @closid: Intended closid for @cbm.
1215  * @exclusive: Only check if overlaps with exclusive resource groups
1216  *
1217  * Resources that can be allocated using a CBM can use the CBM to control
1218  * the overlap of these allocations. rdtgroup_cmb_overlaps() is the test
1219  * for overlap. Overlap test is not limited to the specific resource for
1220  * which the CBM is intended though - when dealing with CDP resources that
1221  * share the underlying hardware the overlap check should be performed on
1222  * the CDP resource sharing the hardware also.
1223  *
1224  * Refer to description of __rdtgroup_cbm_overlaps() for the details of the
1225  * overlap test.
1226  *
1227  * Return: true if CBM overlap detected, false if there is no overlap
1228  */
1229 bool rdtgroup_cbm_overlaps(struct rdt_resource *r, struct rdt_domain *d,
1230 			   unsigned long cbm, int closid, bool exclusive)
1231 {
1232 	struct rdt_resource *r_cdp;
1233 	struct rdt_domain *d_cdp;
1234 
1235 	if (__rdtgroup_cbm_overlaps(r, d, cbm, closid, exclusive))
1236 		return true;
1237 
1238 	if (rdt_cdp_peer_get(r, d, &r_cdp, &d_cdp) < 0)
1239 		return false;
1240 
1241 	return  __rdtgroup_cbm_overlaps(r_cdp, d_cdp, cbm, closid, exclusive);
1242 }
1243 
1244 /**
1245  * rdtgroup_mode_test_exclusive - Test if this resource group can be exclusive
1246  *
1247  * An exclusive resource group implies that there should be no sharing of
1248  * its allocated resources. At the time this group is considered to be
1249  * exclusive this test can determine if its current schemata supports this
1250  * setting by testing for overlap with all other resource groups.
1251  *
1252  * Return: true if resource group can be exclusive, false if there is overlap
1253  * with allocations of other resource groups and thus this resource group
1254  * cannot be exclusive.
1255  */
1256 static bool rdtgroup_mode_test_exclusive(struct rdtgroup *rdtgrp)
1257 {
1258 	int closid = rdtgrp->closid;
1259 	struct rdt_resource *r;
1260 	bool has_cache = false;
1261 	struct rdt_domain *d;
1262 
1263 	for_each_alloc_enabled_rdt_resource(r) {
1264 		if (r->rid == RDT_RESOURCE_MBA)
1265 			continue;
1266 		has_cache = true;
1267 		list_for_each_entry(d, &r->domains, list) {
1268 			if (rdtgroup_cbm_overlaps(r, d, d->ctrl_val[closid],
1269 						  rdtgrp->closid, false)) {
1270 				rdt_last_cmd_puts("Schemata overlaps\n");
1271 				return false;
1272 			}
1273 		}
1274 	}
1275 
1276 	if (!has_cache) {
1277 		rdt_last_cmd_puts("Cannot be exclusive without CAT/CDP\n");
1278 		return false;
1279 	}
1280 
1281 	return true;
1282 }
1283 
1284 /**
1285  * rdtgroup_mode_write - Modify the resource group's mode
1286  *
1287  */
1288 static ssize_t rdtgroup_mode_write(struct kernfs_open_file *of,
1289 				   char *buf, size_t nbytes, loff_t off)
1290 {
1291 	struct rdtgroup *rdtgrp;
1292 	enum rdtgrp_mode mode;
1293 	int ret = 0;
1294 
1295 	/* Valid input requires a trailing newline */
1296 	if (nbytes == 0 || buf[nbytes - 1] != '\n')
1297 		return -EINVAL;
1298 	buf[nbytes - 1] = '\0';
1299 
1300 	rdtgrp = rdtgroup_kn_lock_live(of->kn);
1301 	if (!rdtgrp) {
1302 		rdtgroup_kn_unlock(of->kn);
1303 		return -ENOENT;
1304 	}
1305 
1306 	rdt_last_cmd_clear();
1307 
1308 	mode = rdtgrp->mode;
1309 
1310 	if ((!strcmp(buf, "shareable") && mode == RDT_MODE_SHAREABLE) ||
1311 	    (!strcmp(buf, "exclusive") && mode == RDT_MODE_EXCLUSIVE) ||
1312 	    (!strcmp(buf, "pseudo-locksetup") &&
1313 	     mode == RDT_MODE_PSEUDO_LOCKSETUP) ||
1314 	    (!strcmp(buf, "pseudo-locked") && mode == RDT_MODE_PSEUDO_LOCKED))
1315 		goto out;
1316 
1317 	if (mode == RDT_MODE_PSEUDO_LOCKED) {
1318 		rdt_last_cmd_puts("Cannot change pseudo-locked group\n");
1319 		ret = -EINVAL;
1320 		goto out;
1321 	}
1322 
1323 	if (!strcmp(buf, "shareable")) {
1324 		if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) {
1325 			ret = rdtgroup_locksetup_exit(rdtgrp);
1326 			if (ret)
1327 				goto out;
1328 		}
1329 		rdtgrp->mode = RDT_MODE_SHAREABLE;
1330 	} else if (!strcmp(buf, "exclusive")) {
1331 		if (!rdtgroup_mode_test_exclusive(rdtgrp)) {
1332 			ret = -EINVAL;
1333 			goto out;
1334 		}
1335 		if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) {
1336 			ret = rdtgroup_locksetup_exit(rdtgrp);
1337 			if (ret)
1338 				goto out;
1339 		}
1340 		rdtgrp->mode = RDT_MODE_EXCLUSIVE;
1341 	} else if (!strcmp(buf, "pseudo-locksetup")) {
1342 		ret = rdtgroup_locksetup_enter(rdtgrp);
1343 		if (ret)
1344 			goto out;
1345 		rdtgrp->mode = RDT_MODE_PSEUDO_LOCKSETUP;
1346 	} else {
1347 		rdt_last_cmd_puts("Unknown or unsupported mode\n");
1348 		ret = -EINVAL;
1349 	}
1350 
1351 out:
1352 	rdtgroup_kn_unlock(of->kn);
1353 	return ret ?: nbytes;
1354 }
1355 
1356 /**
1357  * rdtgroup_cbm_to_size - Translate CBM to size in bytes
1358  * @r: RDT resource to which @d belongs.
1359  * @d: RDT domain instance.
1360  * @cbm: bitmask for which the size should be computed.
1361  *
1362  * The bitmask provided associated with the RDT domain instance @d will be
1363  * translated into how many bytes it represents. The size in bytes is
1364  * computed by first dividing the total cache size by the CBM length to
1365  * determine how many bytes each bit in the bitmask represents. The result
1366  * is multiplied with the number of bits set in the bitmask.
1367  *
1368  * @cbm is unsigned long, even if only 32 bits are used to make the
1369  * bitmap functions work correctly.
1370  */
1371 unsigned int rdtgroup_cbm_to_size(struct rdt_resource *r,
1372 				  struct rdt_domain *d, unsigned long cbm)
1373 {
1374 	struct cpu_cacheinfo *ci;
1375 	unsigned int size = 0;
1376 	int num_b, i;
1377 
1378 	num_b = bitmap_weight(&cbm, r->cache.cbm_len);
1379 	ci = get_cpu_cacheinfo(cpumask_any(&d->cpu_mask));
1380 	for (i = 0; i < ci->num_leaves; i++) {
1381 		if (ci->info_list[i].level == r->cache_level) {
1382 			size = ci->info_list[i].size / r->cache.cbm_len * num_b;
1383 			break;
1384 		}
1385 	}
1386 
1387 	return size;
1388 }
1389 
1390 /**
1391  * rdtgroup_size_show - Display size in bytes of allocated regions
1392  *
1393  * The "size" file mirrors the layout of the "schemata" file, printing the
1394  * size in bytes of each region instead of the capacity bitmask.
1395  *
1396  */
1397 static int rdtgroup_size_show(struct kernfs_open_file *of,
1398 			      struct seq_file *s, void *v)
1399 {
1400 	struct rdtgroup *rdtgrp;
1401 	struct rdt_resource *r;
1402 	struct rdt_domain *d;
1403 	unsigned int size;
1404 	int ret = 0;
1405 	bool sep;
1406 	u32 ctrl;
1407 
1408 	rdtgrp = rdtgroup_kn_lock_live(of->kn);
1409 	if (!rdtgrp) {
1410 		rdtgroup_kn_unlock(of->kn);
1411 		return -ENOENT;
1412 	}
1413 
1414 	if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) {
1415 		if (!rdtgrp->plr->d) {
1416 			rdt_last_cmd_clear();
1417 			rdt_last_cmd_puts("Cache domain offline\n");
1418 			ret = -ENODEV;
1419 		} else {
1420 			seq_printf(s, "%*s:", max_name_width,
1421 				   rdtgrp->plr->r->name);
1422 			size = rdtgroup_cbm_to_size(rdtgrp->plr->r,
1423 						    rdtgrp->plr->d,
1424 						    rdtgrp->plr->cbm);
1425 			seq_printf(s, "%d=%u\n", rdtgrp->plr->d->id, size);
1426 		}
1427 		goto out;
1428 	}
1429 
1430 	for_each_alloc_enabled_rdt_resource(r) {
1431 		sep = false;
1432 		seq_printf(s, "%*s:", max_name_width, r->name);
1433 		list_for_each_entry(d, &r->domains, list) {
1434 			if (sep)
1435 				seq_putc(s, ';');
1436 			if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) {
1437 				size = 0;
1438 			} else {
1439 				ctrl = (!is_mba_sc(r) ?
1440 						d->ctrl_val[rdtgrp->closid] :
1441 						d->mbps_val[rdtgrp->closid]);
1442 				if (r->rid == RDT_RESOURCE_MBA)
1443 					size = ctrl;
1444 				else
1445 					size = rdtgroup_cbm_to_size(r, d, ctrl);
1446 			}
1447 			seq_printf(s, "%d=%u", d->id, size);
1448 			sep = true;
1449 		}
1450 		seq_putc(s, '\n');
1451 	}
1452 
1453 out:
1454 	rdtgroup_kn_unlock(of->kn);
1455 
1456 	return ret;
1457 }
1458 
1459 /* rdtgroup information files for one cache resource. */
1460 static struct rftype res_common_files[] = {
1461 	{
1462 		.name		= "last_cmd_status",
1463 		.mode		= 0444,
1464 		.kf_ops		= &rdtgroup_kf_single_ops,
1465 		.seq_show	= rdt_last_cmd_status_show,
1466 		.fflags		= RF_TOP_INFO,
1467 	},
1468 	{
1469 		.name		= "num_closids",
1470 		.mode		= 0444,
1471 		.kf_ops		= &rdtgroup_kf_single_ops,
1472 		.seq_show	= rdt_num_closids_show,
1473 		.fflags		= RF_CTRL_INFO,
1474 	},
1475 	{
1476 		.name		= "mon_features",
1477 		.mode		= 0444,
1478 		.kf_ops		= &rdtgroup_kf_single_ops,
1479 		.seq_show	= rdt_mon_features_show,
1480 		.fflags		= RF_MON_INFO,
1481 	},
1482 	{
1483 		.name		= "num_rmids",
1484 		.mode		= 0444,
1485 		.kf_ops		= &rdtgroup_kf_single_ops,
1486 		.seq_show	= rdt_num_rmids_show,
1487 		.fflags		= RF_MON_INFO,
1488 	},
1489 	{
1490 		.name		= "cbm_mask",
1491 		.mode		= 0444,
1492 		.kf_ops		= &rdtgroup_kf_single_ops,
1493 		.seq_show	= rdt_default_ctrl_show,
1494 		.fflags		= RF_CTRL_INFO | RFTYPE_RES_CACHE,
1495 	},
1496 	{
1497 		.name		= "min_cbm_bits",
1498 		.mode		= 0444,
1499 		.kf_ops		= &rdtgroup_kf_single_ops,
1500 		.seq_show	= rdt_min_cbm_bits_show,
1501 		.fflags		= RF_CTRL_INFO | RFTYPE_RES_CACHE,
1502 	},
1503 	{
1504 		.name		= "shareable_bits",
1505 		.mode		= 0444,
1506 		.kf_ops		= &rdtgroup_kf_single_ops,
1507 		.seq_show	= rdt_shareable_bits_show,
1508 		.fflags		= RF_CTRL_INFO | RFTYPE_RES_CACHE,
1509 	},
1510 	{
1511 		.name		= "bit_usage",
1512 		.mode		= 0444,
1513 		.kf_ops		= &rdtgroup_kf_single_ops,
1514 		.seq_show	= rdt_bit_usage_show,
1515 		.fflags		= RF_CTRL_INFO | RFTYPE_RES_CACHE,
1516 	},
1517 	{
1518 		.name		= "min_bandwidth",
1519 		.mode		= 0444,
1520 		.kf_ops		= &rdtgroup_kf_single_ops,
1521 		.seq_show	= rdt_min_bw_show,
1522 		.fflags		= RF_CTRL_INFO | RFTYPE_RES_MB,
1523 	},
1524 	{
1525 		.name		= "bandwidth_gran",
1526 		.mode		= 0444,
1527 		.kf_ops		= &rdtgroup_kf_single_ops,
1528 		.seq_show	= rdt_bw_gran_show,
1529 		.fflags		= RF_CTRL_INFO | RFTYPE_RES_MB,
1530 	},
1531 	{
1532 		.name		= "delay_linear",
1533 		.mode		= 0444,
1534 		.kf_ops		= &rdtgroup_kf_single_ops,
1535 		.seq_show	= rdt_delay_linear_show,
1536 		.fflags		= RF_CTRL_INFO | RFTYPE_RES_MB,
1537 	},
1538 	/*
1539 	 * Platform specific which (if any) capabilities are provided by
1540 	 * thread_throttle_mode. Defer "fflags" initialization to platform
1541 	 * discovery.
1542 	 */
1543 	{
1544 		.name		= "thread_throttle_mode",
1545 		.mode		= 0444,
1546 		.kf_ops		= &rdtgroup_kf_single_ops,
1547 		.seq_show	= rdt_thread_throttle_mode_show,
1548 	},
1549 	{
1550 		.name		= "max_threshold_occupancy",
1551 		.mode		= 0644,
1552 		.kf_ops		= &rdtgroup_kf_single_ops,
1553 		.write		= max_threshold_occ_write,
1554 		.seq_show	= max_threshold_occ_show,
1555 		.fflags		= RF_MON_INFO | RFTYPE_RES_CACHE,
1556 	},
1557 	{
1558 		.name		= "cpus",
1559 		.mode		= 0644,
1560 		.kf_ops		= &rdtgroup_kf_single_ops,
1561 		.write		= rdtgroup_cpus_write,
1562 		.seq_show	= rdtgroup_cpus_show,
1563 		.fflags		= RFTYPE_BASE,
1564 	},
1565 	{
1566 		.name		= "cpus_list",
1567 		.mode		= 0644,
1568 		.kf_ops		= &rdtgroup_kf_single_ops,
1569 		.write		= rdtgroup_cpus_write,
1570 		.seq_show	= rdtgroup_cpus_show,
1571 		.flags		= RFTYPE_FLAGS_CPUS_LIST,
1572 		.fflags		= RFTYPE_BASE,
1573 	},
1574 	{
1575 		.name		= "tasks",
1576 		.mode		= 0644,
1577 		.kf_ops		= &rdtgroup_kf_single_ops,
1578 		.write		= rdtgroup_tasks_write,
1579 		.seq_show	= rdtgroup_tasks_show,
1580 		.fflags		= RFTYPE_BASE,
1581 	},
1582 	{
1583 		.name		= "schemata",
1584 		.mode		= 0644,
1585 		.kf_ops		= &rdtgroup_kf_single_ops,
1586 		.write		= rdtgroup_schemata_write,
1587 		.seq_show	= rdtgroup_schemata_show,
1588 		.fflags		= RF_CTRL_BASE,
1589 	},
1590 	{
1591 		.name		= "mode",
1592 		.mode		= 0644,
1593 		.kf_ops		= &rdtgroup_kf_single_ops,
1594 		.write		= rdtgroup_mode_write,
1595 		.seq_show	= rdtgroup_mode_show,
1596 		.fflags		= RF_CTRL_BASE,
1597 	},
1598 	{
1599 		.name		= "size",
1600 		.mode		= 0444,
1601 		.kf_ops		= &rdtgroup_kf_single_ops,
1602 		.seq_show	= rdtgroup_size_show,
1603 		.fflags		= RF_CTRL_BASE,
1604 	},
1605 
1606 };
1607 
1608 static int rdtgroup_add_files(struct kernfs_node *kn, unsigned long fflags)
1609 {
1610 	struct rftype *rfts, *rft;
1611 	int ret, len;
1612 
1613 	rfts = res_common_files;
1614 	len = ARRAY_SIZE(res_common_files);
1615 
1616 	lockdep_assert_held(&rdtgroup_mutex);
1617 
1618 	for (rft = rfts; rft < rfts + len; rft++) {
1619 		if (rft->fflags && ((fflags & rft->fflags) == rft->fflags)) {
1620 			ret = rdtgroup_add_file(kn, rft);
1621 			if (ret)
1622 				goto error;
1623 		}
1624 	}
1625 
1626 	return 0;
1627 error:
1628 	pr_warn("Failed to add %s, err=%d\n", rft->name, ret);
1629 	while (--rft >= rfts) {
1630 		if ((fflags & rft->fflags) == rft->fflags)
1631 			kernfs_remove_by_name(kn, rft->name);
1632 	}
1633 	return ret;
1634 }
1635 
1636 static struct rftype *rdtgroup_get_rftype_by_name(const char *name)
1637 {
1638 	struct rftype *rfts, *rft;
1639 	int len;
1640 
1641 	rfts = res_common_files;
1642 	len = ARRAY_SIZE(res_common_files);
1643 
1644 	for (rft = rfts; rft < rfts + len; rft++) {
1645 		if (!strcmp(rft->name, name))
1646 			return rft;
1647 	}
1648 
1649 	return NULL;
1650 }
1651 
1652 void __init thread_throttle_mode_init(void)
1653 {
1654 	struct rftype *rft;
1655 
1656 	rft = rdtgroup_get_rftype_by_name("thread_throttle_mode");
1657 	if (!rft)
1658 		return;
1659 
1660 	rft->fflags = RF_CTRL_INFO | RFTYPE_RES_MB;
1661 }
1662 
1663 /**
1664  * rdtgroup_kn_mode_restrict - Restrict user access to named resctrl file
1665  * @r: The resource group with which the file is associated.
1666  * @name: Name of the file
1667  *
1668  * The permissions of named resctrl file, directory, or link are modified
1669  * to not allow read, write, or execute by any user.
1670  *
1671  * WARNING: This function is intended to communicate to the user that the
1672  * resctrl file has been locked down - that it is not relevant to the
1673  * particular state the system finds itself in. It should not be relied
1674  * on to protect from user access because after the file's permissions
1675  * are restricted the user can still change the permissions using chmod
1676  * from the command line.
1677  *
1678  * Return: 0 on success, <0 on failure.
1679  */
1680 int rdtgroup_kn_mode_restrict(struct rdtgroup *r, const char *name)
1681 {
1682 	struct iattr iattr = {.ia_valid = ATTR_MODE,};
1683 	struct kernfs_node *kn;
1684 	int ret = 0;
1685 
1686 	kn = kernfs_find_and_get_ns(r->kn, name, NULL);
1687 	if (!kn)
1688 		return -ENOENT;
1689 
1690 	switch (kernfs_type(kn)) {
1691 	case KERNFS_DIR:
1692 		iattr.ia_mode = S_IFDIR;
1693 		break;
1694 	case KERNFS_FILE:
1695 		iattr.ia_mode = S_IFREG;
1696 		break;
1697 	case KERNFS_LINK:
1698 		iattr.ia_mode = S_IFLNK;
1699 		break;
1700 	}
1701 
1702 	ret = kernfs_setattr(kn, &iattr);
1703 	kernfs_put(kn);
1704 	return ret;
1705 }
1706 
1707 /**
1708  * rdtgroup_kn_mode_restore - Restore user access to named resctrl file
1709  * @r: The resource group with which the file is associated.
1710  * @name: Name of the file
1711  * @mask: Mask of permissions that should be restored
1712  *
1713  * Restore the permissions of the named file. If @name is a directory the
1714  * permissions of its parent will be used.
1715  *
1716  * Return: 0 on success, <0 on failure.
1717  */
1718 int rdtgroup_kn_mode_restore(struct rdtgroup *r, const char *name,
1719 			     umode_t mask)
1720 {
1721 	struct iattr iattr = {.ia_valid = ATTR_MODE,};
1722 	struct kernfs_node *kn, *parent;
1723 	struct rftype *rfts, *rft;
1724 	int ret, len;
1725 
1726 	rfts = res_common_files;
1727 	len = ARRAY_SIZE(res_common_files);
1728 
1729 	for (rft = rfts; rft < rfts + len; rft++) {
1730 		if (!strcmp(rft->name, name))
1731 			iattr.ia_mode = rft->mode & mask;
1732 	}
1733 
1734 	kn = kernfs_find_and_get_ns(r->kn, name, NULL);
1735 	if (!kn)
1736 		return -ENOENT;
1737 
1738 	switch (kernfs_type(kn)) {
1739 	case KERNFS_DIR:
1740 		parent = kernfs_get_parent(kn);
1741 		if (parent) {
1742 			iattr.ia_mode |= parent->mode;
1743 			kernfs_put(parent);
1744 		}
1745 		iattr.ia_mode |= S_IFDIR;
1746 		break;
1747 	case KERNFS_FILE:
1748 		iattr.ia_mode |= S_IFREG;
1749 		break;
1750 	case KERNFS_LINK:
1751 		iattr.ia_mode |= S_IFLNK;
1752 		break;
1753 	}
1754 
1755 	ret = kernfs_setattr(kn, &iattr);
1756 	kernfs_put(kn);
1757 	return ret;
1758 }
1759 
1760 static int rdtgroup_mkdir_info_resdir(struct rdt_resource *r, char *name,
1761 				      unsigned long fflags)
1762 {
1763 	struct kernfs_node *kn_subdir;
1764 	int ret;
1765 
1766 	kn_subdir = kernfs_create_dir(kn_info, name,
1767 				      kn_info->mode, r);
1768 	if (IS_ERR(kn_subdir))
1769 		return PTR_ERR(kn_subdir);
1770 
1771 	ret = rdtgroup_kn_set_ugid(kn_subdir);
1772 	if (ret)
1773 		return ret;
1774 
1775 	ret = rdtgroup_add_files(kn_subdir, fflags);
1776 	if (!ret)
1777 		kernfs_activate(kn_subdir);
1778 
1779 	return ret;
1780 }
1781 
1782 static int rdtgroup_create_info_dir(struct kernfs_node *parent_kn)
1783 {
1784 	struct rdt_resource *r;
1785 	unsigned long fflags;
1786 	char name[32];
1787 	int ret;
1788 
1789 	/* create the directory */
1790 	kn_info = kernfs_create_dir(parent_kn, "info", parent_kn->mode, NULL);
1791 	if (IS_ERR(kn_info))
1792 		return PTR_ERR(kn_info);
1793 
1794 	ret = rdtgroup_add_files(kn_info, RF_TOP_INFO);
1795 	if (ret)
1796 		goto out_destroy;
1797 
1798 	for_each_alloc_enabled_rdt_resource(r) {
1799 		fflags =  r->fflags | RF_CTRL_INFO;
1800 		ret = rdtgroup_mkdir_info_resdir(r, r->name, fflags);
1801 		if (ret)
1802 			goto out_destroy;
1803 	}
1804 
1805 	for_each_mon_enabled_rdt_resource(r) {
1806 		fflags =  r->fflags | RF_MON_INFO;
1807 		sprintf(name, "%s_MON", r->name);
1808 		ret = rdtgroup_mkdir_info_resdir(r, name, fflags);
1809 		if (ret)
1810 			goto out_destroy;
1811 	}
1812 
1813 	ret = rdtgroup_kn_set_ugid(kn_info);
1814 	if (ret)
1815 		goto out_destroy;
1816 
1817 	kernfs_activate(kn_info);
1818 
1819 	return 0;
1820 
1821 out_destroy:
1822 	kernfs_remove(kn_info);
1823 	return ret;
1824 }
1825 
1826 static int
1827 mongroup_create_dir(struct kernfs_node *parent_kn, struct rdtgroup *prgrp,
1828 		    char *name, struct kernfs_node **dest_kn)
1829 {
1830 	struct kernfs_node *kn;
1831 	int ret;
1832 
1833 	/* create the directory */
1834 	kn = kernfs_create_dir(parent_kn, name, parent_kn->mode, prgrp);
1835 	if (IS_ERR(kn))
1836 		return PTR_ERR(kn);
1837 
1838 	if (dest_kn)
1839 		*dest_kn = kn;
1840 
1841 	ret = rdtgroup_kn_set_ugid(kn);
1842 	if (ret)
1843 		goto out_destroy;
1844 
1845 	kernfs_activate(kn);
1846 
1847 	return 0;
1848 
1849 out_destroy:
1850 	kernfs_remove(kn);
1851 	return ret;
1852 }
1853 
1854 static void l3_qos_cfg_update(void *arg)
1855 {
1856 	bool *enable = arg;
1857 
1858 	wrmsrl(MSR_IA32_L3_QOS_CFG, *enable ? L3_QOS_CDP_ENABLE : 0ULL);
1859 }
1860 
1861 static void l2_qos_cfg_update(void *arg)
1862 {
1863 	bool *enable = arg;
1864 
1865 	wrmsrl(MSR_IA32_L2_QOS_CFG, *enable ? L2_QOS_CDP_ENABLE : 0ULL);
1866 }
1867 
1868 static inline bool is_mba_linear(void)
1869 {
1870 	return rdt_resources_all[RDT_RESOURCE_MBA].membw.delay_linear;
1871 }
1872 
1873 static int set_cache_qos_cfg(int level, bool enable)
1874 {
1875 	void (*update)(void *arg);
1876 	struct rdt_resource *r_l;
1877 	cpumask_var_t cpu_mask;
1878 	struct rdt_domain *d;
1879 	int cpu;
1880 
1881 	if (level == RDT_RESOURCE_L3)
1882 		update = l3_qos_cfg_update;
1883 	else if (level == RDT_RESOURCE_L2)
1884 		update = l2_qos_cfg_update;
1885 	else
1886 		return -EINVAL;
1887 
1888 	if (!zalloc_cpumask_var(&cpu_mask, GFP_KERNEL))
1889 		return -ENOMEM;
1890 
1891 	r_l = &rdt_resources_all[level];
1892 	list_for_each_entry(d, &r_l->domains, list) {
1893 		if (r_l->cache.arch_has_per_cpu_cfg)
1894 			/* Pick all the CPUs in the domain instance */
1895 			for_each_cpu(cpu, &d->cpu_mask)
1896 				cpumask_set_cpu(cpu, cpu_mask);
1897 		else
1898 			/* Pick one CPU from each domain instance to update MSR */
1899 			cpumask_set_cpu(cpumask_any(&d->cpu_mask), cpu_mask);
1900 	}
1901 	cpu = get_cpu();
1902 	/* Update QOS_CFG MSR on this cpu if it's in cpu_mask. */
1903 	if (cpumask_test_cpu(cpu, cpu_mask))
1904 		update(&enable);
1905 	/* Update QOS_CFG MSR on all other cpus in cpu_mask. */
1906 	smp_call_function_many(cpu_mask, update, &enable, 1);
1907 	put_cpu();
1908 
1909 	free_cpumask_var(cpu_mask);
1910 
1911 	return 0;
1912 }
1913 
1914 /* Restore the qos cfg state when a domain comes online */
1915 void rdt_domain_reconfigure_cdp(struct rdt_resource *r)
1916 {
1917 	if (!r->alloc_capable)
1918 		return;
1919 
1920 	if (r == &rdt_resources_all[RDT_RESOURCE_L2DATA])
1921 		l2_qos_cfg_update(&r->alloc_enabled);
1922 
1923 	if (r == &rdt_resources_all[RDT_RESOURCE_L3DATA])
1924 		l3_qos_cfg_update(&r->alloc_enabled);
1925 }
1926 
1927 /*
1928  * Enable or disable the MBA software controller
1929  * which helps user specify bandwidth in MBps.
1930  * MBA software controller is supported only if
1931  * MBM is supported and MBA is in linear scale.
1932  */
1933 static int set_mba_sc(bool mba_sc)
1934 {
1935 	struct rdt_resource *r = &rdt_resources_all[RDT_RESOURCE_MBA];
1936 	struct rdt_domain *d;
1937 
1938 	if (!is_mbm_enabled() || !is_mba_linear() ||
1939 	    mba_sc == is_mba_sc(r))
1940 		return -EINVAL;
1941 
1942 	r->membw.mba_sc = mba_sc;
1943 	list_for_each_entry(d, &r->domains, list)
1944 		setup_default_ctrlval(r, d->ctrl_val, d->mbps_val);
1945 
1946 	return 0;
1947 }
1948 
1949 static int cdp_enable(int level, int data_type, int code_type)
1950 {
1951 	struct rdt_resource *r_ldata = &rdt_resources_all[data_type];
1952 	struct rdt_resource *r_lcode = &rdt_resources_all[code_type];
1953 	struct rdt_resource *r_l = &rdt_resources_all[level];
1954 	int ret;
1955 
1956 	if (!r_l->alloc_capable || !r_ldata->alloc_capable ||
1957 	    !r_lcode->alloc_capable)
1958 		return -EINVAL;
1959 
1960 	ret = set_cache_qos_cfg(level, true);
1961 	if (!ret) {
1962 		r_l->alloc_enabled = false;
1963 		r_ldata->alloc_enabled = true;
1964 		r_lcode->alloc_enabled = true;
1965 	}
1966 	return ret;
1967 }
1968 
1969 static int cdpl3_enable(void)
1970 {
1971 	return cdp_enable(RDT_RESOURCE_L3, RDT_RESOURCE_L3DATA,
1972 			  RDT_RESOURCE_L3CODE);
1973 }
1974 
1975 static int cdpl2_enable(void)
1976 {
1977 	return cdp_enable(RDT_RESOURCE_L2, RDT_RESOURCE_L2DATA,
1978 			  RDT_RESOURCE_L2CODE);
1979 }
1980 
1981 static void cdp_disable(int level, int data_type, int code_type)
1982 {
1983 	struct rdt_resource *r = &rdt_resources_all[level];
1984 
1985 	r->alloc_enabled = r->alloc_capable;
1986 
1987 	if (rdt_resources_all[data_type].alloc_enabled) {
1988 		rdt_resources_all[data_type].alloc_enabled = false;
1989 		rdt_resources_all[code_type].alloc_enabled = false;
1990 		set_cache_qos_cfg(level, false);
1991 	}
1992 }
1993 
1994 static void cdpl3_disable(void)
1995 {
1996 	cdp_disable(RDT_RESOURCE_L3, RDT_RESOURCE_L3DATA, RDT_RESOURCE_L3CODE);
1997 }
1998 
1999 static void cdpl2_disable(void)
2000 {
2001 	cdp_disable(RDT_RESOURCE_L2, RDT_RESOURCE_L2DATA, RDT_RESOURCE_L2CODE);
2002 }
2003 
2004 static void cdp_disable_all(void)
2005 {
2006 	if (rdt_resources_all[RDT_RESOURCE_L3DATA].alloc_enabled)
2007 		cdpl3_disable();
2008 	if (rdt_resources_all[RDT_RESOURCE_L2DATA].alloc_enabled)
2009 		cdpl2_disable();
2010 }
2011 
2012 /*
2013  * We don't allow rdtgroup directories to be created anywhere
2014  * except the root directory. Thus when looking for the rdtgroup
2015  * structure for a kernfs node we are either looking at a directory,
2016  * in which case the rdtgroup structure is pointed at by the "priv"
2017  * field, otherwise we have a file, and need only look to the parent
2018  * to find the rdtgroup.
2019  */
2020 static struct rdtgroup *kernfs_to_rdtgroup(struct kernfs_node *kn)
2021 {
2022 	if (kernfs_type(kn) == KERNFS_DIR) {
2023 		/*
2024 		 * All the resource directories use "kn->priv"
2025 		 * to point to the "struct rdtgroup" for the
2026 		 * resource. "info" and its subdirectories don't
2027 		 * have rdtgroup structures, so return NULL here.
2028 		 */
2029 		if (kn == kn_info || kn->parent == kn_info)
2030 			return NULL;
2031 		else
2032 			return kn->priv;
2033 	} else {
2034 		return kn->parent->priv;
2035 	}
2036 }
2037 
2038 struct rdtgroup *rdtgroup_kn_lock_live(struct kernfs_node *kn)
2039 {
2040 	struct rdtgroup *rdtgrp = kernfs_to_rdtgroup(kn);
2041 
2042 	if (!rdtgrp)
2043 		return NULL;
2044 
2045 	atomic_inc(&rdtgrp->waitcount);
2046 	kernfs_break_active_protection(kn);
2047 
2048 	mutex_lock(&rdtgroup_mutex);
2049 
2050 	/* Was this group deleted while we waited? */
2051 	if (rdtgrp->flags & RDT_DELETED)
2052 		return NULL;
2053 
2054 	return rdtgrp;
2055 }
2056 
2057 void rdtgroup_kn_unlock(struct kernfs_node *kn)
2058 {
2059 	struct rdtgroup *rdtgrp = kernfs_to_rdtgroup(kn);
2060 
2061 	if (!rdtgrp)
2062 		return;
2063 
2064 	mutex_unlock(&rdtgroup_mutex);
2065 
2066 	if (atomic_dec_and_test(&rdtgrp->waitcount) &&
2067 	    (rdtgrp->flags & RDT_DELETED)) {
2068 		if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP ||
2069 		    rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED)
2070 			rdtgroup_pseudo_lock_remove(rdtgrp);
2071 		kernfs_unbreak_active_protection(kn);
2072 		rdtgroup_remove(rdtgrp);
2073 	} else {
2074 		kernfs_unbreak_active_protection(kn);
2075 	}
2076 }
2077 
2078 static int mkdir_mondata_all(struct kernfs_node *parent_kn,
2079 			     struct rdtgroup *prgrp,
2080 			     struct kernfs_node **mon_data_kn);
2081 
2082 static int rdt_enable_ctx(struct rdt_fs_context *ctx)
2083 {
2084 	int ret = 0;
2085 
2086 	if (ctx->enable_cdpl2)
2087 		ret = cdpl2_enable();
2088 
2089 	if (!ret && ctx->enable_cdpl3)
2090 		ret = cdpl3_enable();
2091 
2092 	if (!ret && ctx->enable_mba_mbps)
2093 		ret = set_mba_sc(true);
2094 
2095 	return ret;
2096 }
2097 
2098 static int rdt_get_tree(struct fs_context *fc)
2099 {
2100 	struct rdt_fs_context *ctx = rdt_fc2context(fc);
2101 	struct rdt_domain *dom;
2102 	struct rdt_resource *r;
2103 	int ret;
2104 
2105 	cpus_read_lock();
2106 	mutex_lock(&rdtgroup_mutex);
2107 	/*
2108 	 * resctrl file system can only be mounted once.
2109 	 */
2110 	if (static_branch_unlikely(&rdt_enable_key)) {
2111 		ret = -EBUSY;
2112 		goto out;
2113 	}
2114 
2115 	ret = rdt_enable_ctx(ctx);
2116 	if (ret < 0)
2117 		goto out_cdp;
2118 
2119 	closid_init();
2120 
2121 	ret = rdtgroup_create_info_dir(rdtgroup_default.kn);
2122 	if (ret < 0)
2123 		goto out_mba;
2124 
2125 	if (rdt_mon_capable) {
2126 		ret = mongroup_create_dir(rdtgroup_default.kn,
2127 					  &rdtgroup_default, "mon_groups",
2128 					  &kn_mongrp);
2129 		if (ret < 0)
2130 			goto out_info;
2131 
2132 		ret = mkdir_mondata_all(rdtgroup_default.kn,
2133 					&rdtgroup_default, &kn_mondata);
2134 		if (ret < 0)
2135 			goto out_mongrp;
2136 		rdtgroup_default.mon.mon_data_kn = kn_mondata;
2137 	}
2138 
2139 	ret = rdt_pseudo_lock_init();
2140 	if (ret)
2141 		goto out_mondata;
2142 
2143 	ret = kernfs_get_tree(fc);
2144 	if (ret < 0)
2145 		goto out_psl;
2146 
2147 	if (rdt_alloc_capable)
2148 		static_branch_enable_cpuslocked(&rdt_alloc_enable_key);
2149 	if (rdt_mon_capable)
2150 		static_branch_enable_cpuslocked(&rdt_mon_enable_key);
2151 
2152 	if (rdt_alloc_capable || rdt_mon_capable)
2153 		static_branch_enable_cpuslocked(&rdt_enable_key);
2154 
2155 	if (is_mbm_enabled()) {
2156 		r = &rdt_resources_all[RDT_RESOURCE_L3];
2157 		list_for_each_entry(dom, &r->domains, list)
2158 			mbm_setup_overflow_handler(dom, MBM_OVERFLOW_INTERVAL);
2159 	}
2160 
2161 	goto out;
2162 
2163 out_psl:
2164 	rdt_pseudo_lock_release();
2165 out_mondata:
2166 	if (rdt_mon_capable)
2167 		kernfs_remove(kn_mondata);
2168 out_mongrp:
2169 	if (rdt_mon_capable)
2170 		kernfs_remove(kn_mongrp);
2171 out_info:
2172 	kernfs_remove(kn_info);
2173 out_mba:
2174 	if (ctx->enable_mba_mbps)
2175 		set_mba_sc(false);
2176 out_cdp:
2177 	cdp_disable_all();
2178 out:
2179 	rdt_last_cmd_clear();
2180 	mutex_unlock(&rdtgroup_mutex);
2181 	cpus_read_unlock();
2182 	return ret;
2183 }
2184 
2185 enum rdt_param {
2186 	Opt_cdp,
2187 	Opt_cdpl2,
2188 	Opt_mba_mbps,
2189 	nr__rdt_params
2190 };
2191 
2192 static const struct fs_parameter_spec rdt_fs_parameters[] = {
2193 	fsparam_flag("cdp",		Opt_cdp),
2194 	fsparam_flag("cdpl2",		Opt_cdpl2),
2195 	fsparam_flag("mba_MBps",	Opt_mba_mbps),
2196 	{}
2197 };
2198 
2199 static int rdt_parse_param(struct fs_context *fc, struct fs_parameter *param)
2200 {
2201 	struct rdt_fs_context *ctx = rdt_fc2context(fc);
2202 	struct fs_parse_result result;
2203 	int opt;
2204 
2205 	opt = fs_parse(fc, rdt_fs_parameters, param, &result);
2206 	if (opt < 0)
2207 		return opt;
2208 
2209 	switch (opt) {
2210 	case Opt_cdp:
2211 		ctx->enable_cdpl3 = true;
2212 		return 0;
2213 	case Opt_cdpl2:
2214 		ctx->enable_cdpl2 = true;
2215 		return 0;
2216 	case Opt_mba_mbps:
2217 		if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL)
2218 			return -EINVAL;
2219 		ctx->enable_mba_mbps = true;
2220 		return 0;
2221 	}
2222 
2223 	return -EINVAL;
2224 }
2225 
2226 static void rdt_fs_context_free(struct fs_context *fc)
2227 {
2228 	struct rdt_fs_context *ctx = rdt_fc2context(fc);
2229 
2230 	kernfs_free_fs_context(fc);
2231 	kfree(ctx);
2232 }
2233 
2234 static const struct fs_context_operations rdt_fs_context_ops = {
2235 	.free		= rdt_fs_context_free,
2236 	.parse_param	= rdt_parse_param,
2237 	.get_tree	= rdt_get_tree,
2238 };
2239 
2240 static int rdt_init_fs_context(struct fs_context *fc)
2241 {
2242 	struct rdt_fs_context *ctx;
2243 
2244 	ctx = kzalloc(sizeof(struct rdt_fs_context), GFP_KERNEL);
2245 	if (!ctx)
2246 		return -ENOMEM;
2247 
2248 	ctx->kfc.root = rdt_root;
2249 	ctx->kfc.magic = RDTGROUP_SUPER_MAGIC;
2250 	fc->fs_private = &ctx->kfc;
2251 	fc->ops = &rdt_fs_context_ops;
2252 	put_user_ns(fc->user_ns);
2253 	fc->user_ns = get_user_ns(&init_user_ns);
2254 	fc->global = true;
2255 	return 0;
2256 }
2257 
2258 static int reset_all_ctrls(struct rdt_resource *r)
2259 {
2260 	struct msr_param msr_param;
2261 	cpumask_var_t cpu_mask;
2262 	struct rdt_domain *d;
2263 	int i, cpu;
2264 
2265 	if (!zalloc_cpumask_var(&cpu_mask, GFP_KERNEL))
2266 		return -ENOMEM;
2267 
2268 	msr_param.res = r;
2269 	msr_param.low = 0;
2270 	msr_param.high = r->num_closid;
2271 
2272 	/*
2273 	 * Disable resource control for this resource by setting all
2274 	 * CBMs in all domains to the maximum mask value. Pick one CPU
2275 	 * from each domain to update the MSRs below.
2276 	 */
2277 	list_for_each_entry(d, &r->domains, list) {
2278 		cpumask_set_cpu(cpumask_any(&d->cpu_mask), cpu_mask);
2279 
2280 		for (i = 0; i < r->num_closid; i++)
2281 			d->ctrl_val[i] = r->default_ctrl;
2282 	}
2283 	cpu = get_cpu();
2284 	/* Update CBM on this cpu if it's in cpu_mask. */
2285 	if (cpumask_test_cpu(cpu, cpu_mask))
2286 		rdt_ctrl_update(&msr_param);
2287 	/* Update CBM on all other cpus in cpu_mask. */
2288 	smp_call_function_many(cpu_mask, rdt_ctrl_update, &msr_param, 1);
2289 	put_cpu();
2290 
2291 	free_cpumask_var(cpu_mask);
2292 
2293 	return 0;
2294 }
2295 
2296 /*
2297  * Move tasks from one to the other group. If @from is NULL, then all tasks
2298  * in the systems are moved unconditionally (used for teardown).
2299  *
2300  * If @mask is not NULL the cpus on which moved tasks are running are set
2301  * in that mask so the update smp function call is restricted to affected
2302  * cpus.
2303  */
2304 static void rdt_move_group_tasks(struct rdtgroup *from, struct rdtgroup *to,
2305 				 struct cpumask *mask)
2306 {
2307 	struct task_struct *p, *t;
2308 
2309 	read_lock(&tasklist_lock);
2310 	for_each_process_thread(p, t) {
2311 		if (!from || is_closid_match(t, from) ||
2312 		    is_rmid_match(t, from)) {
2313 			WRITE_ONCE(t->closid, to->closid);
2314 			WRITE_ONCE(t->rmid, to->mon.rmid);
2315 
2316 			/*
2317 			 * If the task is on a CPU, set the CPU in the mask.
2318 			 * The detection is inaccurate as tasks might move or
2319 			 * schedule before the smp function call takes place.
2320 			 * In such a case the function call is pointless, but
2321 			 * there is no other side effect.
2322 			 */
2323 			if (IS_ENABLED(CONFIG_SMP) && mask && task_curr(t))
2324 				cpumask_set_cpu(task_cpu(t), mask);
2325 		}
2326 	}
2327 	read_unlock(&tasklist_lock);
2328 }
2329 
2330 static void free_all_child_rdtgrp(struct rdtgroup *rdtgrp)
2331 {
2332 	struct rdtgroup *sentry, *stmp;
2333 	struct list_head *head;
2334 
2335 	head = &rdtgrp->mon.crdtgrp_list;
2336 	list_for_each_entry_safe(sentry, stmp, head, mon.crdtgrp_list) {
2337 		free_rmid(sentry->mon.rmid);
2338 		list_del(&sentry->mon.crdtgrp_list);
2339 
2340 		if (atomic_read(&sentry->waitcount) != 0)
2341 			sentry->flags = RDT_DELETED;
2342 		else
2343 			rdtgroup_remove(sentry);
2344 	}
2345 }
2346 
2347 /*
2348  * Forcibly remove all of subdirectories under root.
2349  */
2350 static void rmdir_all_sub(void)
2351 {
2352 	struct rdtgroup *rdtgrp, *tmp;
2353 
2354 	/* Move all tasks to the default resource group */
2355 	rdt_move_group_tasks(NULL, &rdtgroup_default, NULL);
2356 
2357 	list_for_each_entry_safe(rdtgrp, tmp, &rdt_all_groups, rdtgroup_list) {
2358 		/* Free any child rmids */
2359 		free_all_child_rdtgrp(rdtgrp);
2360 
2361 		/* Remove each rdtgroup other than root */
2362 		if (rdtgrp == &rdtgroup_default)
2363 			continue;
2364 
2365 		if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP ||
2366 		    rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED)
2367 			rdtgroup_pseudo_lock_remove(rdtgrp);
2368 
2369 		/*
2370 		 * Give any CPUs back to the default group. We cannot copy
2371 		 * cpu_online_mask because a CPU might have executed the
2372 		 * offline callback already, but is still marked online.
2373 		 */
2374 		cpumask_or(&rdtgroup_default.cpu_mask,
2375 			   &rdtgroup_default.cpu_mask, &rdtgrp->cpu_mask);
2376 
2377 		free_rmid(rdtgrp->mon.rmid);
2378 
2379 		kernfs_remove(rdtgrp->kn);
2380 		list_del(&rdtgrp->rdtgroup_list);
2381 
2382 		if (atomic_read(&rdtgrp->waitcount) != 0)
2383 			rdtgrp->flags = RDT_DELETED;
2384 		else
2385 			rdtgroup_remove(rdtgrp);
2386 	}
2387 	/* Notify online CPUs to update per cpu storage and PQR_ASSOC MSR */
2388 	update_closid_rmid(cpu_online_mask, &rdtgroup_default);
2389 
2390 	kernfs_remove(kn_info);
2391 	kernfs_remove(kn_mongrp);
2392 	kernfs_remove(kn_mondata);
2393 }
2394 
2395 static void rdt_kill_sb(struct super_block *sb)
2396 {
2397 	struct rdt_resource *r;
2398 
2399 	cpus_read_lock();
2400 	mutex_lock(&rdtgroup_mutex);
2401 
2402 	set_mba_sc(false);
2403 
2404 	/*Put everything back to default values. */
2405 	for_each_alloc_enabled_rdt_resource(r)
2406 		reset_all_ctrls(r);
2407 	cdp_disable_all();
2408 	rmdir_all_sub();
2409 	rdt_pseudo_lock_release();
2410 	rdtgroup_default.mode = RDT_MODE_SHAREABLE;
2411 	static_branch_disable_cpuslocked(&rdt_alloc_enable_key);
2412 	static_branch_disable_cpuslocked(&rdt_mon_enable_key);
2413 	static_branch_disable_cpuslocked(&rdt_enable_key);
2414 	kernfs_kill_sb(sb);
2415 	mutex_unlock(&rdtgroup_mutex);
2416 	cpus_read_unlock();
2417 }
2418 
2419 static struct file_system_type rdt_fs_type = {
2420 	.name			= "resctrl",
2421 	.init_fs_context	= rdt_init_fs_context,
2422 	.parameters		= rdt_fs_parameters,
2423 	.kill_sb		= rdt_kill_sb,
2424 };
2425 
2426 static int mon_addfile(struct kernfs_node *parent_kn, const char *name,
2427 		       void *priv)
2428 {
2429 	struct kernfs_node *kn;
2430 	int ret = 0;
2431 
2432 	kn = __kernfs_create_file(parent_kn, name, 0444,
2433 				  GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, 0,
2434 				  &kf_mondata_ops, priv, NULL, NULL);
2435 	if (IS_ERR(kn))
2436 		return PTR_ERR(kn);
2437 
2438 	ret = rdtgroup_kn_set_ugid(kn);
2439 	if (ret) {
2440 		kernfs_remove(kn);
2441 		return ret;
2442 	}
2443 
2444 	return ret;
2445 }
2446 
2447 /*
2448  * Remove all subdirectories of mon_data of ctrl_mon groups
2449  * and monitor groups with given domain id.
2450  */
2451 void rmdir_mondata_subdir_allrdtgrp(struct rdt_resource *r, unsigned int dom_id)
2452 {
2453 	struct rdtgroup *prgrp, *crgrp;
2454 	char name[32];
2455 
2456 	if (!r->mon_enabled)
2457 		return;
2458 
2459 	list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) {
2460 		sprintf(name, "mon_%s_%02d", r->name, dom_id);
2461 		kernfs_remove_by_name(prgrp->mon.mon_data_kn, name);
2462 
2463 		list_for_each_entry(crgrp, &prgrp->mon.crdtgrp_list, mon.crdtgrp_list)
2464 			kernfs_remove_by_name(crgrp->mon.mon_data_kn, name);
2465 	}
2466 }
2467 
2468 static int mkdir_mondata_subdir(struct kernfs_node *parent_kn,
2469 				struct rdt_domain *d,
2470 				struct rdt_resource *r, struct rdtgroup *prgrp)
2471 {
2472 	union mon_data_bits priv;
2473 	struct kernfs_node *kn;
2474 	struct mon_evt *mevt;
2475 	struct rmid_read rr;
2476 	char name[32];
2477 	int ret;
2478 
2479 	sprintf(name, "mon_%s_%02d", r->name, d->id);
2480 	/* create the directory */
2481 	kn = kernfs_create_dir(parent_kn, name, parent_kn->mode, prgrp);
2482 	if (IS_ERR(kn))
2483 		return PTR_ERR(kn);
2484 
2485 	ret = rdtgroup_kn_set_ugid(kn);
2486 	if (ret)
2487 		goto out_destroy;
2488 
2489 	if (WARN_ON(list_empty(&r->evt_list))) {
2490 		ret = -EPERM;
2491 		goto out_destroy;
2492 	}
2493 
2494 	priv.u.rid = r->rid;
2495 	priv.u.domid = d->id;
2496 	list_for_each_entry(mevt, &r->evt_list, list) {
2497 		priv.u.evtid = mevt->evtid;
2498 		ret = mon_addfile(kn, mevt->name, priv.priv);
2499 		if (ret)
2500 			goto out_destroy;
2501 
2502 		if (is_mbm_event(mevt->evtid))
2503 			mon_event_read(&rr, r, d, prgrp, mevt->evtid, true);
2504 	}
2505 	kernfs_activate(kn);
2506 	return 0;
2507 
2508 out_destroy:
2509 	kernfs_remove(kn);
2510 	return ret;
2511 }
2512 
2513 /*
2514  * Add all subdirectories of mon_data for "ctrl_mon" groups
2515  * and "monitor" groups with given domain id.
2516  */
2517 void mkdir_mondata_subdir_allrdtgrp(struct rdt_resource *r,
2518 				    struct rdt_domain *d)
2519 {
2520 	struct kernfs_node *parent_kn;
2521 	struct rdtgroup *prgrp, *crgrp;
2522 	struct list_head *head;
2523 
2524 	if (!r->mon_enabled)
2525 		return;
2526 
2527 	list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) {
2528 		parent_kn = prgrp->mon.mon_data_kn;
2529 		mkdir_mondata_subdir(parent_kn, d, r, prgrp);
2530 
2531 		head = &prgrp->mon.crdtgrp_list;
2532 		list_for_each_entry(crgrp, head, mon.crdtgrp_list) {
2533 			parent_kn = crgrp->mon.mon_data_kn;
2534 			mkdir_mondata_subdir(parent_kn, d, r, crgrp);
2535 		}
2536 	}
2537 }
2538 
2539 static int mkdir_mondata_subdir_alldom(struct kernfs_node *parent_kn,
2540 				       struct rdt_resource *r,
2541 				       struct rdtgroup *prgrp)
2542 {
2543 	struct rdt_domain *dom;
2544 	int ret;
2545 
2546 	list_for_each_entry(dom, &r->domains, list) {
2547 		ret = mkdir_mondata_subdir(parent_kn, dom, r, prgrp);
2548 		if (ret)
2549 			return ret;
2550 	}
2551 
2552 	return 0;
2553 }
2554 
2555 /*
2556  * This creates a directory mon_data which contains the monitored data.
2557  *
2558  * mon_data has one directory for each domain which are named
2559  * in the format mon_<domain_name>_<domain_id>. For ex: A mon_data
2560  * with L3 domain looks as below:
2561  * ./mon_data:
2562  * mon_L3_00
2563  * mon_L3_01
2564  * mon_L3_02
2565  * ...
2566  *
2567  * Each domain directory has one file per event:
2568  * ./mon_L3_00/:
2569  * llc_occupancy
2570  *
2571  */
2572 static int mkdir_mondata_all(struct kernfs_node *parent_kn,
2573 			     struct rdtgroup *prgrp,
2574 			     struct kernfs_node **dest_kn)
2575 {
2576 	struct rdt_resource *r;
2577 	struct kernfs_node *kn;
2578 	int ret;
2579 
2580 	/*
2581 	 * Create the mon_data directory first.
2582 	 */
2583 	ret = mongroup_create_dir(parent_kn, prgrp, "mon_data", &kn);
2584 	if (ret)
2585 		return ret;
2586 
2587 	if (dest_kn)
2588 		*dest_kn = kn;
2589 
2590 	/*
2591 	 * Create the subdirectories for each domain. Note that all events
2592 	 * in a domain like L3 are grouped into a resource whose domain is L3
2593 	 */
2594 	for_each_mon_enabled_rdt_resource(r) {
2595 		ret = mkdir_mondata_subdir_alldom(kn, r, prgrp);
2596 		if (ret)
2597 			goto out_destroy;
2598 	}
2599 
2600 	return 0;
2601 
2602 out_destroy:
2603 	kernfs_remove(kn);
2604 	return ret;
2605 }
2606 
2607 /**
2608  * cbm_ensure_valid - Enforce validity on provided CBM
2609  * @_val:	Candidate CBM
2610  * @r:		RDT resource to which the CBM belongs
2611  *
2612  * The provided CBM represents all cache portions available for use. This
2613  * may be represented by a bitmap that does not consist of contiguous ones
2614  * and thus be an invalid CBM.
2615  * Here the provided CBM is forced to be a valid CBM by only considering
2616  * the first set of contiguous bits as valid and clearing all bits.
2617  * The intention here is to provide a valid default CBM with which a new
2618  * resource group is initialized. The user can follow this with a
2619  * modification to the CBM if the default does not satisfy the
2620  * requirements.
2621  */
2622 static u32 cbm_ensure_valid(u32 _val, struct rdt_resource *r)
2623 {
2624 	unsigned int cbm_len = r->cache.cbm_len;
2625 	unsigned long first_bit, zero_bit;
2626 	unsigned long val = _val;
2627 
2628 	if (!val)
2629 		return 0;
2630 
2631 	first_bit = find_first_bit(&val, cbm_len);
2632 	zero_bit = find_next_zero_bit(&val, cbm_len, first_bit);
2633 
2634 	/* Clear any remaining bits to ensure contiguous region */
2635 	bitmap_clear(&val, zero_bit, cbm_len - zero_bit);
2636 	return (u32)val;
2637 }
2638 
2639 /*
2640  * Initialize cache resources per RDT domain
2641  *
2642  * Set the RDT domain up to start off with all usable allocations. That is,
2643  * all shareable and unused bits. All-zero CBM is invalid.
2644  */
2645 static int __init_one_rdt_domain(struct rdt_domain *d, struct rdt_resource *r,
2646 				 u32 closid)
2647 {
2648 	struct rdt_resource *r_cdp = NULL;
2649 	struct rdt_domain *d_cdp = NULL;
2650 	u32 used_b = 0, unused_b = 0;
2651 	unsigned long tmp_cbm;
2652 	enum rdtgrp_mode mode;
2653 	u32 peer_ctl, *ctrl;
2654 	int i;
2655 
2656 	rdt_cdp_peer_get(r, d, &r_cdp, &d_cdp);
2657 	d->have_new_ctrl = false;
2658 	d->new_ctrl = r->cache.shareable_bits;
2659 	used_b = r->cache.shareable_bits;
2660 	ctrl = d->ctrl_val;
2661 	for (i = 0; i < closids_supported(); i++, ctrl++) {
2662 		if (closid_allocated(i) && i != closid) {
2663 			mode = rdtgroup_mode_by_closid(i);
2664 			if (mode == RDT_MODE_PSEUDO_LOCKSETUP)
2665 				/*
2666 				 * ctrl values for locksetup aren't relevant
2667 				 * until the schemata is written, and the mode
2668 				 * becomes RDT_MODE_PSEUDO_LOCKED.
2669 				 */
2670 				continue;
2671 			/*
2672 			 * If CDP is active include peer domain's
2673 			 * usage to ensure there is no overlap
2674 			 * with an exclusive group.
2675 			 */
2676 			if (d_cdp)
2677 				peer_ctl = d_cdp->ctrl_val[i];
2678 			else
2679 				peer_ctl = 0;
2680 			used_b |= *ctrl | peer_ctl;
2681 			if (mode == RDT_MODE_SHAREABLE)
2682 				d->new_ctrl |= *ctrl | peer_ctl;
2683 		}
2684 	}
2685 	if (d->plr && d->plr->cbm > 0)
2686 		used_b |= d->plr->cbm;
2687 	unused_b = used_b ^ (BIT_MASK(r->cache.cbm_len) - 1);
2688 	unused_b &= BIT_MASK(r->cache.cbm_len) - 1;
2689 	d->new_ctrl |= unused_b;
2690 	/*
2691 	 * Force the initial CBM to be valid, user can
2692 	 * modify the CBM based on system availability.
2693 	 */
2694 	d->new_ctrl = cbm_ensure_valid(d->new_ctrl, r);
2695 	/*
2696 	 * Assign the u32 CBM to an unsigned long to ensure that
2697 	 * bitmap_weight() does not access out-of-bound memory.
2698 	 */
2699 	tmp_cbm = d->new_ctrl;
2700 	if (bitmap_weight(&tmp_cbm, r->cache.cbm_len) < r->cache.min_cbm_bits) {
2701 		rdt_last_cmd_printf("No space on %s:%d\n", r->name, d->id);
2702 		return -ENOSPC;
2703 	}
2704 	d->have_new_ctrl = true;
2705 
2706 	return 0;
2707 }
2708 
2709 /*
2710  * Initialize cache resources with default values.
2711  *
2712  * A new RDT group is being created on an allocation capable (CAT)
2713  * supporting system. Set this group up to start off with all usable
2714  * allocations.
2715  *
2716  * If there are no more shareable bits available on any domain then
2717  * the entire allocation will fail.
2718  */
2719 static int rdtgroup_init_cat(struct rdt_resource *r, u32 closid)
2720 {
2721 	struct rdt_domain *d;
2722 	int ret;
2723 
2724 	list_for_each_entry(d, &r->domains, list) {
2725 		ret = __init_one_rdt_domain(d, r, closid);
2726 		if (ret < 0)
2727 			return ret;
2728 	}
2729 
2730 	return 0;
2731 }
2732 
2733 /* Initialize MBA resource with default values. */
2734 static void rdtgroup_init_mba(struct rdt_resource *r)
2735 {
2736 	struct rdt_domain *d;
2737 
2738 	list_for_each_entry(d, &r->domains, list) {
2739 		d->new_ctrl = is_mba_sc(r) ? MBA_MAX_MBPS : r->default_ctrl;
2740 		d->have_new_ctrl = true;
2741 	}
2742 }
2743 
2744 /* Initialize the RDT group's allocations. */
2745 static int rdtgroup_init_alloc(struct rdtgroup *rdtgrp)
2746 {
2747 	struct rdt_resource *r;
2748 	int ret;
2749 
2750 	for_each_alloc_enabled_rdt_resource(r) {
2751 		if (r->rid == RDT_RESOURCE_MBA) {
2752 			rdtgroup_init_mba(r);
2753 		} else {
2754 			ret = rdtgroup_init_cat(r, rdtgrp->closid);
2755 			if (ret < 0)
2756 				return ret;
2757 		}
2758 
2759 		ret = update_domains(r, rdtgrp->closid);
2760 		if (ret < 0) {
2761 			rdt_last_cmd_puts("Failed to initialize allocations\n");
2762 			return ret;
2763 		}
2764 
2765 	}
2766 
2767 	rdtgrp->mode = RDT_MODE_SHAREABLE;
2768 
2769 	return 0;
2770 }
2771 
2772 static int mkdir_rdt_prepare(struct kernfs_node *parent_kn,
2773 			     const char *name, umode_t mode,
2774 			     enum rdt_group_type rtype, struct rdtgroup **r)
2775 {
2776 	struct rdtgroup *prdtgrp, *rdtgrp;
2777 	struct kernfs_node *kn;
2778 	uint files = 0;
2779 	int ret;
2780 
2781 	prdtgrp = rdtgroup_kn_lock_live(parent_kn);
2782 	if (!prdtgrp) {
2783 		ret = -ENODEV;
2784 		goto out_unlock;
2785 	}
2786 
2787 	if (rtype == RDTMON_GROUP &&
2788 	    (prdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP ||
2789 	     prdtgrp->mode == RDT_MODE_PSEUDO_LOCKED)) {
2790 		ret = -EINVAL;
2791 		rdt_last_cmd_puts("Pseudo-locking in progress\n");
2792 		goto out_unlock;
2793 	}
2794 
2795 	/* allocate the rdtgroup. */
2796 	rdtgrp = kzalloc(sizeof(*rdtgrp), GFP_KERNEL);
2797 	if (!rdtgrp) {
2798 		ret = -ENOSPC;
2799 		rdt_last_cmd_puts("Kernel out of memory\n");
2800 		goto out_unlock;
2801 	}
2802 	*r = rdtgrp;
2803 	rdtgrp->mon.parent = prdtgrp;
2804 	rdtgrp->type = rtype;
2805 	INIT_LIST_HEAD(&rdtgrp->mon.crdtgrp_list);
2806 
2807 	/* kernfs creates the directory for rdtgrp */
2808 	kn = kernfs_create_dir(parent_kn, name, mode, rdtgrp);
2809 	if (IS_ERR(kn)) {
2810 		ret = PTR_ERR(kn);
2811 		rdt_last_cmd_puts("kernfs create error\n");
2812 		goto out_free_rgrp;
2813 	}
2814 	rdtgrp->kn = kn;
2815 
2816 	/*
2817 	 * kernfs_remove() will drop the reference count on "kn" which
2818 	 * will free it. But we still need it to stick around for the
2819 	 * rdtgroup_kn_unlock(kn) call. Take one extra reference here,
2820 	 * which will be dropped by kernfs_put() in rdtgroup_remove().
2821 	 */
2822 	kernfs_get(kn);
2823 
2824 	ret = rdtgroup_kn_set_ugid(kn);
2825 	if (ret) {
2826 		rdt_last_cmd_puts("kernfs perm error\n");
2827 		goto out_destroy;
2828 	}
2829 
2830 	files = RFTYPE_BASE | BIT(RF_CTRLSHIFT + rtype);
2831 	ret = rdtgroup_add_files(kn, files);
2832 	if (ret) {
2833 		rdt_last_cmd_puts("kernfs fill error\n");
2834 		goto out_destroy;
2835 	}
2836 
2837 	if (rdt_mon_capable) {
2838 		ret = alloc_rmid();
2839 		if (ret < 0) {
2840 			rdt_last_cmd_puts("Out of RMIDs\n");
2841 			goto out_destroy;
2842 		}
2843 		rdtgrp->mon.rmid = ret;
2844 
2845 		ret = mkdir_mondata_all(kn, rdtgrp, &rdtgrp->mon.mon_data_kn);
2846 		if (ret) {
2847 			rdt_last_cmd_puts("kernfs subdir error\n");
2848 			goto out_idfree;
2849 		}
2850 	}
2851 	kernfs_activate(kn);
2852 
2853 	/*
2854 	 * The caller unlocks the parent_kn upon success.
2855 	 */
2856 	return 0;
2857 
2858 out_idfree:
2859 	free_rmid(rdtgrp->mon.rmid);
2860 out_destroy:
2861 	kernfs_put(rdtgrp->kn);
2862 	kernfs_remove(rdtgrp->kn);
2863 out_free_rgrp:
2864 	kfree(rdtgrp);
2865 out_unlock:
2866 	rdtgroup_kn_unlock(parent_kn);
2867 	return ret;
2868 }
2869 
2870 static void mkdir_rdt_prepare_clean(struct rdtgroup *rgrp)
2871 {
2872 	kernfs_remove(rgrp->kn);
2873 	free_rmid(rgrp->mon.rmid);
2874 	rdtgroup_remove(rgrp);
2875 }
2876 
2877 /*
2878  * Create a monitor group under "mon_groups" directory of a control
2879  * and monitor group(ctrl_mon). This is a resource group
2880  * to monitor a subset of tasks and cpus in its parent ctrl_mon group.
2881  */
2882 static int rdtgroup_mkdir_mon(struct kernfs_node *parent_kn,
2883 			      const char *name, umode_t mode)
2884 {
2885 	struct rdtgroup *rdtgrp, *prgrp;
2886 	int ret;
2887 
2888 	ret = mkdir_rdt_prepare(parent_kn, name, mode, RDTMON_GROUP, &rdtgrp);
2889 	if (ret)
2890 		return ret;
2891 
2892 	prgrp = rdtgrp->mon.parent;
2893 	rdtgrp->closid = prgrp->closid;
2894 
2895 	/*
2896 	 * Add the rdtgrp to the list of rdtgrps the parent
2897 	 * ctrl_mon group has to track.
2898 	 */
2899 	list_add_tail(&rdtgrp->mon.crdtgrp_list, &prgrp->mon.crdtgrp_list);
2900 
2901 	rdtgroup_kn_unlock(parent_kn);
2902 	return ret;
2903 }
2904 
2905 /*
2906  * These are rdtgroups created under the root directory. Can be used
2907  * to allocate and monitor resources.
2908  */
2909 static int rdtgroup_mkdir_ctrl_mon(struct kernfs_node *parent_kn,
2910 				   const char *name, umode_t mode)
2911 {
2912 	struct rdtgroup *rdtgrp;
2913 	struct kernfs_node *kn;
2914 	u32 closid;
2915 	int ret;
2916 
2917 	ret = mkdir_rdt_prepare(parent_kn, name, mode, RDTCTRL_GROUP, &rdtgrp);
2918 	if (ret)
2919 		return ret;
2920 
2921 	kn = rdtgrp->kn;
2922 	ret = closid_alloc();
2923 	if (ret < 0) {
2924 		rdt_last_cmd_puts("Out of CLOSIDs\n");
2925 		goto out_common_fail;
2926 	}
2927 	closid = ret;
2928 	ret = 0;
2929 
2930 	rdtgrp->closid = closid;
2931 	ret = rdtgroup_init_alloc(rdtgrp);
2932 	if (ret < 0)
2933 		goto out_id_free;
2934 
2935 	list_add(&rdtgrp->rdtgroup_list, &rdt_all_groups);
2936 
2937 	if (rdt_mon_capable) {
2938 		/*
2939 		 * Create an empty mon_groups directory to hold the subset
2940 		 * of tasks and cpus to monitor.
2941 		 */
2942 		ret = mongroup_create_dir(kn, rdtgrp, "mon_groups", NULL);
2943 		if (ret) {
2944 			rdt_last_cmd_puts("kernfs subdir error\n");
2945 			goto out_del_list;
2946 		}
2947 	}
2948 
2949 	goto out_unlock;
2950 
2951 out_del_list:
2952 	list_del(&rdtgrp->rdtgroup_list);
2953 out_id_free:
2954 	closid_free(closid);
2955 out_common_fail:
2956 	mkdir_rdt_prepare_clean(rdtgrp);
2957 out_unlock:
2958 	rdtgroup_kn_unlock(parent_kn);
2959 	return ret;
2960 }
2961 
2962 /*
2963  * We allow creating mon groups only with in a directory called "mon_groups"
2964  * which is present in every ctrl_mon group. Check if this is a valid
2965  * "mon_groups" directory.
2966  *
2967  * 1. The directory should be named "mon_groups".
2968  * 2. The mon group itself should "not" be named "mon_groups".
2969  *   This makes sure "mon_groups" directory always has a ctrl_mon group
2970  *   as parent.
2971  */
2972 static bool is_mon_groups(struct kernfs_node *kn, const char *name)
2973 {
2974 	return (!strcmp(kn->name, "mon_groups") &&
2975 		strcmp(name, "mon_groups"));
2976 }
2977 
2978 static int rdtgroup_mkdir(struct kernfs_node *parent_kn, const char *name,
2979 			  umode_t mode)
2980 {
2981 	/* Do not accept '\n' to avoid unparsable situation. */
2982 	if (strchr(name, '\n'))
2983 		return -EINVAL;
2984 
2985 	/*
2986 	 * If the parent directory is the root directory and RDT
2987 	 * allocation is supported, add a control and monitoring
2988 	 * subdirectory
2989 	 */
2990 	if (rdt_alloc_capable && parent_kn == rdtgroup_default.kn)
2991 		return rdtgroup_mkdir_ctrl_mon(parent_kn, name, mode);
2992 
2993 	/*
2994 	 * If RDT monitoring is supported and the parent directory is a valid
2995 	 * "mon_groups" directory, add a monitoring subdirectory.
2996 	 */
2997 	if (rdt_mon_capable && is_mon_groups(parent_kn, name))
2998 		return rdtgroup_mkdir_mon(parent_kn, name, mode);
2999 
3000 	return -EPERM;
3001 }
3002 
3003 static int rdtgroup_rmdir_mon(struct rdtgroup *rdtgrp, cpumask_var_t tmpmask)
3004 {
3005 	struct rdtgroup *prdtgrp = rdtgrp->mon.parent;
3006 	int cpu;
3007 
3008 	/* Give any tasks back to the parent group */
3009 	rdt_move_group_tasks(rdtgrp, prdtgrp, tmpmask);
3010 
3011 	/* Update per cpu rmid of the moved CPUs first */
3012 	for_each_cpu(cpu, &rdtgrp->cpu_mask)
3013 		per_cpu(pqr_state.default_rmid, cpu) = prdtgrp->mon.rmid;
3014 	/*
3015 	 * Update the MSR on moved CPUs and CPUs which have moved
3016 	 * task running on them.
3017 	 */
3018 	cpumask_or(tmpmask, tmpmask, &rdtgrp->cpu_mask);
3019 	update_closid_rmid(tmpmask, NULL);
3020 
3021 	rdtgrp->flags = RDT_DELETED;
3022 	free_rmid(rdtgrp->mon.rmid);
3023 
3024 	/*
3025 	 * Remove the rdtgrp from the parent ctrl_mon group's list
3026 	 */
3027 	WARN_ON(list_empty(&prdtgrp->mon.crdtgrp_list));
3028 	list_del(&rdtgrp->mon.crdtgrp_list);
3029 
3030 	kernfs_remove(rdtgrp->kn);
3031 
3032 	return 0;
3033 }
3034 
3035 static int rdtgroup_ctrl_remove(struct rdtgroup *rdtgrp)
3036 {
3037 	rdtgrp->flags = RDT_DELETED;
3038 	list_del(&rdtgrp->rdtgroup_list);
3039 
3040 	kernfs_remove(rdtgrp->kn);
3041 	return 0;
3042 }
3043 
3044 static int rdtgroup_rmdir_ctrl(struct rdtgroup *rdtgrp, cpumask_var_t tmpmask)
3045 {
3046 	int cpu;
3047 
3048 	/* Give any tasks back to the default group */
3049 	rdt_move_group_tasks(rdtgrp, &rdtgroup_default, tmpmask);
3050 
3051 	/* Give any CPUs back to the default group */
3052 	cpumask_or(&rdtgroup_default.cpu_mask,
3053 		   &rdtgroup_default.cpu_mask, &rdtgrp->cpu_mask);
3054 
3055 	/* Update per cpu closid and rmid of the moved CPUs first */
3056 	for_each_cpu(cpu, &rdtgrp->cpu_mask) {
3057 		per_cpu(pqr_state.default_closid, cpu) = rdtgroup_default.closid;
3058 		per_cpu(pqr_state.default_rmid, cpu) = rdtgroup_default.mon.rmid;
3059 	}
3060 
3061 	/*
3062 	 * Update the MSR on moved CPUs and CPUs which have moved
3063 	 * task running on them.
3064 	 */
3065 	cpumask_or(tmpmask, tmpmask, &rdtgrp->cpu_mask);
3066 	update_closid_rmid(tmpmask, NULL);
3067 
3068 	closid_free(rdtgrp->closid);
3069 	free_rmid(rdtgrp->mon.rmid);
3070 
3071 	rdtgroup_ctrl_remove(rdtgrp);
3072 
3073 	/*
3074 	 * Free all the child monitor group rmids.
3075 	 */
3076 	free_all_child_rdtgrp(rdtgrp);
3077 
3078 	return 0;
3079 }
3080 
3081 static int rdtgroup_rmdir(struct kernfs_node *kn)
3082 {
3083 	struct kernfs_node *parent_kn = kn->parent;
3084 	struct rdtgroup *rdtgrp;
3085 	cpumask_var_t tmpmask;
3086 	int ret = 0;
3087 
3088 	if (!zalloc_cpumask_var(&tmpmask, GFP_KERNEL))
3089 		return -ENOMEM;
3090 
3091 	rdtgrp = rdtgroup_kn_lock_live(kn);
3092 	if (!rdtgrp) {
3093 		ret = -EPERM;
3094 		goto out;
3095 	}
3096 
3097 	/*
3098 	 * If the rdtgroup is a ctrl_mon group and parent directory
3099 	 * is the root directory, remove the ctrl_mon group.
3100 	 *
3101 	 * If the rdtgroup is a mon group and parent directory
3102 	 * is a valid "mon_groups" directory, remove the mon group.
3103 	 */
3104 	if (rdtgrp->type == RDTCTRL_GROUP && parent_kn == rdtgroup_default.kn &&
3105 	    rdtgrp != &rdtgroup_default) {
3106 		if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP ||
3107 		    rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) {
3108 			ret = rdtgroup_ctrl_remove(rdtgrp);
3109 		} else {
3110 			ret = rdtgroup_rmdir_ctrl(rdtgrp, tmpmask);
3111 		}
3112 	} else if (rdtgrp->type == RDTMON_GROUP &&
3113 		 is_mon_groups(parent_kn, kn->name)) {
3114 		ret = rdtgroup_rmdir_mon(rdtgrp, tmpmask);
3115 	} else {
3116 		ret = -EPERM;
3117 	}
3118 
3119 out:
3120 	rdtgroup_kn_unlock(kn);
3121 	free_cpumask_var(tmpmask);
3122 	return ret;
3123 }
3124 
3125 static int rdtgroup_show_options(struct seq_file *seq, struct kernfs_root *kf)
3126 {
3127 	if (rdt_resources_all[RDT_RESOURCE_L3DATA].alloc_enabled)
3128 		seq_puts(seq, ",cdp");
3129 
3130 	if (rdt_resources_all[RDT_RESOURCE_L2DATA].alloc_enabled)
3131 		seq_puts(seq, ",cdpl2");
3132 
3133 	if (is_mba_sc(&rdt_resources_all[RDT_RESOURCE_MBA]))
3134 		seq_puts(seq, ",mba_MBps");
3135 
3136 	return 0;
3137 }
3138 
3139 static struct kernfs_syscall_ops rdtgroup_kf_syscall_ops = {
3140 	.mkdir		= rdtgroup_mkdir,
3141 	.rmdir		= rdtgroup_rmdir,
3142 	.show_options	= rdtgroup_show_options,
3143 };
3144 
3145 static int __init rdtgroup_setup_root(void)
3146 {
3147 	int ret;
3148 
3149 	rdt_root = kernfs_create_root(&rdtgroup_kf_syscall_ops,
3150 				      KERNFS_ROOT_CREATE_DEACTIVATED |
3151 				      KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK,
3152 				      &rdtgroup_default);
3153 	if (IS_ERR(rdt_root))
3154 		return PTR_ERR(rdt_root);
3155 
3156 	mutex_lock(&rdtgroup_mutex);
3157 
3158 	rdtgroup_default.closid = 0;
3159 	rdtgroup_default.mon.rmid = 0;
3160 	rdtgroup_default.type = RDTCTRL_GROUP;
3161 	INIT_LIST_HEAD(&rdtgroup_default.mon.crdtgrp_list);
3162 
3163 	list_add(&rdtgroup_default.rdtgroup_list, &rdt_all_groups);
3164 
3165 	ret = rdtgroup_add_files(rdt_root->kn, RF_CTRL_BASE);
3166 	if (ret) {
3167 		kernfs_destroy_root(rdt_root);
3168 		goto out;
3169 	}
3170 
3171 	rdtgroup_default.kn = rdt_root->kn;
3172 	kernfs_activate(rdtgroup_default.kn);
3173 
3174 out:
3175 	mutex_unlock(&rdtgroup_mutex);
3176 
3177 	return ret;
3178 }
3179 
3180 /*
3181  * rdtgroup_init - rdtgroup initialization
3182  *
3183  * Setup resctrl file system including set up root, create mount point,
3184  * register rdtgroup filesystem, and initialize files under root directory.
3185  *
3186  * Return: 0 on success or -errno
3187  */
3188 int __init rdtgroup_init(void)
3189 {
3190 	int ret = 0;
3191 
3192 	seq_buf_init(&last_cmd_status, last_cmd_status_buf,
3193 		     sizeof(last_cmd_status_buf));
3194 
3195 	ret = rdtgroup_setup_root();
3196 	if (ret)
3197 		return ret;
3198 
3199 	ret = sysfs_create_mount_point(fs_kobj, "resctrl");
3200 	if (ret)
3201 		goto cleanup_root;
3202 
3203 	ret = register_filesystem(&rdt_fs_type);
3204 	if (ret)
3205 		goto cleanup_mountpoint;
3206 
3207 	/*
3208 	 * Adding the resctrl debugfs directory here may not be ideal since
3209 	 * it would let the resctrl debugfs directory appear on the debugfs
3210 	 * filesystem before the resctrl filesystem is mounted.
3211 	 * It may also be ok since that would enable debugging of RDT before
3212 	 * resctrl is mounted.
3213 	 * The reason why the debugfs directory is created here and not in
3214 	 * rdt_get_tree() is because rdt_get_tree() takes rdtgroup_mutex and
3215 	 * during the debugfs directory creation also &sb->s_type->i_mutex_key
3216 	 * (the lockdep class of inode->i_rwsem). Other filesystem
3217 	 * interactions (eg. SyS_getdents) have the lock ordering:
3218 	 * &sb->s_type->i_mutex_key --> &mm->mmap_lock
3219 	 * During mmap(), called with &mm->mmap_lock, the rdtgroup_mutex
3220 	 * is taken, thus creating dependency:
3221 	 * &mm->mmap_lock --> rdtgroup_mutex for the latter that can cause
3222 	 * issues considering the other two lock dependencies.
3223 	 * By creating the debugfs directory here we avoid a dependency
3224 	 * that may cause deadlock (even though file operations cannot
3225 	 * occur until the filesystem is mounted, but I do not know how to
3226 	 * tell lockdep that).
3227 	 */
3228 	debugfs_resctrl = debugfs_create_dir("resctrl", NULL);
3229 
3230 	return 0;
3231 
3232 cleanup_mountpoint:
3233 	sysfs_remove_mount_point(fs_kobj, "resctrl");
3234 cleanup_root:
3235 	kernfs_destroy_root(rdt_root);
3236 
3237 	return ret;
3238 }
3239 
3240 void __exit rdtgroup_exit(void)
3241 {
3242 	debugfs_remove_recursive(debugfs_resctrl);
3243 	unregister_filesystem(&rdt_fs_type);
3244 	sysfs_remove_mount_point(fs_kobj, "resctrl");
3245 	kernfs_destroy_root(rdt_root);
3246 }
3247