Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
x86,fs/resctrl: Refactor domain create/remove using struct rdt_domain_hdr
Up until now, all monitoring events were associated with the L3 resource and it
made sense to use the L3 specific "struct rdt_mon_domain *" argument to functions
operating on domains.
Telemetry events will be tied to a new resource with its instances represented
by a new domain structure that, just like struct rdt_mon_domain, starts with
the generic struct rdt_domain_hdr.
Prepare to support domains belonging to different resources by changing the
calling convention of functions operating on domains. Pass the generic header
and use that to find the domain specific structure where needed.
Signed-off-by: Tony Luck <tony.luck@intel.com>
Signed-off-by: Borislav Petkov (AMD) <bp@alien8.de>
Reviewed-by: Reinette Chatre <reinette.chatre@intel.com>
Link: https://lore.kernel.org/20251217172121.12030-1-tony.luck@intel.com
authored by
Tony Luck
and committed by
Borislav Petkov (AMD)
97fec06d
c1b63057
+63
-30
+2
-2
arch/x86/kernel/cpu/resctrl/core.c
+2
-2
arch/x86/kernel/cpu/resctrl/core.c
···
534
534
535
535
list_add_tail_rcu(&d->hdr.list, add_pos);
536
536
537
-
err = resctrl_online_mon_domain(r, d);
537
+
err = resctrl_online_mon_domain(r, &d->hdr);
538
538
if (err) {
539
539
list_del_rcu(&d->hdr.list);
540
540
synchronize_rcu();
···
661
661
662
662
d = container_of(hdr, struct rdt_mon_domain, hdr);
663
663
hw_dom = resctrl_to_arch_mon_dom(d);
664
-
resctrl_offline_mon_domain(r, d);
664
+
resctrl_offline_mon_domain(r, hdr);
665
665
list_del_rcu(&hdr->list);
666
666
synchronize_rcu();
667
667
mon_domain_free(hw_dom);
+10
-4
fs/resctrl/ctrlmondata.c
+10
-4
fs/resctrl/ctrlmondata.c
···
551
551
}
552
552
553
553
void mon_event_read(struct rmid_read *rr, struct rdt_resource *r,
554
-
struct rdt_mon_domain *d, struct rdtgroup *rdtgrp,
554
+
struct rdt_domain_hdr *hdr, struct rdtgroup *rdtgrp,
555
555
cpumask_t *cpumask, int evtid, int first)
556
556
{
557
+
struct rdt_mon_domain *d = NULL;
557
558
int cpu;
558
559
559
560
/* When picking a CPU from cpu_mask, ensure it can't race with cpuhp */
560
561
lockdep_assert_cpus_held();
562
+
563
+
if (hdr) {
564
+
if (!domain_header_is_valid(hdr, RESCTRL_MON_DOMAIN, RDT_RESOURCE_L3))
565
+
return;
566
+
d = container_of(hdr, struct rdt_mon_domain, hdr);
567
+
}
561
568
562
569
/*
563
570
* Setup the parameters to pass to mon_event_count() to read the data.
···
660
653
* the resource to find the domain with "domid".
661
654
*/
662
655
hdr = resctrl_find_domain(&r->mon_domains, domid, NULL);
663
-
if (!hdr || !domain_header_is_valid(hdr, RESCTRL_MON_DOMAIN, resid)) {
656
+
if (!hdr) {
664
657
ret = -ENOENT;
665
658
goto out;
666
659
}
667
-
d = container_of(hdr, struct rdt_mon_domain, hdr);
668
-
mon_event_read(&rr, r, d, rdtgrp, &d->hdr.cpu_mask, evtid, false);
660
+
mon_event_read(&rr, r, hdr, rdtgrp, &hdr->cpu_mask, evtid, false);
669
661
}
670
662
671
663
checkresult:
+1
-1
fs/resctrl/internal.h
+1
-1
fs/resctrl/internal.h
···
362
362
int rdtgroup_mondata_show(struct seq_file *m, void *arg);
363
363
364
364
void mon_event_read(struct rmid_read *rr, struct rdt_resource *r,
365
-
struct rdt_mon_domain *d, struct rdtgroup *rdtgrp,
365
+
struct rdt_domain_hdr *hdr, struct rdtgroup *rdtgrp,
366
366
cpumask_t *cpumask, int evtid, int first);
367
367
368
368
int resctrl_mon_resource_init(void);
+48
-21
fs/resctrl/rdtgroup.c
+48
-21
fs/resctrl/rdtgroup.c
···
3229
3229
* when last domain being summed is removed.
3230
3230
*/
3231
3231
static void rmdir_mondata_subdir_allrdtgrp(struct rdt_resource *r,
3232
-
struct rdt_mon_domain *d)
3232
+
struct rdt_domain_hdr *hdr)
3233
3233
{
3234
3234
struct rdtgroup *prgrp, *crgrp;
3235
+
struct rdt_mon_domain *d;
3235
3236
char subname[32];
3236
3237
bool snc_mode;
3237
3238
char name[32];
3238
3239
3240
+
if (!domain_header_is_valid(hdr, RESCTRL_MON_DOMAIN, RDT_RESOURCE_L3))
3241
+
return;
3242
+
3243
+
d = container_of(hdr, struct rdt_mon_domain, hdr);
3239
3244
snc_mode = r->mon_scope == RESCTRL_L3_NODE;
3240
-
sprintf(name, "mon_%s_%02d", r->name, snc_mode ? d->ci_id : d->hdr.id);
3245
+
sprintf(name, "mon_%s_%02d", r->name, snc_mode ? d->ci_id : hdr->id);
3241
3246
if (snc_mode)
3242
-
sprintf(subname, "mon_sub_%s_%02d", r->name, d->hdr.id);
3247
+
sprintf(subname, "mon_sub_%s_%02d", r->name, hdr->id);
3243
3248
3244
3249
list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) {
3245
3250
mon_rmdir_one_subdir(prgrp->mon.mon_data_kn, name, subname);
···
3254
3249
}
3255
3250
}
3256
3251
3257
-
static int mon_add_all_files(struct kernfs_node *kn, struct rdt_mon_domain *d,
3252
+
static int mon_add_all_files(struct kernfs_node *kn, struct rdt_domain_hdr *hdr,
3258
3253
struct rdt_resource *r, struct rdtgroup *prgrp,
3259
3254
bool do_sum)
3260
3255
{
3261
3256
struct rmid_read rr = {0};
3257
+
struct rdt_mon_domain *d;
3262
3258
struct mon_data *priv;
3263
3259
struct mon_evt *mevt;
3264
3260
int ret, domid;
3265
3261
3262
+
if (!domain_header_is_valid(hdr, RESCTRL_MON_DOMAIN, RDT_RESOURCE_L3))
3263
+
return -EINVAL;
3264
+
3265
+
d = container_of(hdr, struct rdt_mon_domain, hdr);
3266
3266
for_each_mon_event(mevt) {
3267
3267
if (mevt->rid != r->rid || !mevt->enabled)
3268
3268
continue;
···
3281
3271
return ret;
3282
3272
3283
3273
if (!do_sum && resctrl_is_mbm_event(mevt->evtid))
3284
-
mon_event_read(&rr, r, d, prgrp, &d->hdr.cpu_mask, mevt->evtid, true);
3274
+
mon_event_read(&rr, r, hdr, prgrp, &hdr->cpu_mask, mevt->evtid, true);
3285
3275
}
3286
3276
3287
3277
return 0;
3288
3278
}
3289
3279
3290
3280
static int mkdir_mondata_subdir(struct kernfs_node *parent_kn,
3291
-
struct rdt_mon_domain *d,
3281
+
struct rdt_domain_hdr *hdr,
3292
3282
struct rdt_resource *r, struct rdtgroup *prgrp)
3293
3283
{
3294
3284
struct kernfs_node *kn, *ckn;
3285
+
struct rdt_mon_domain *d;
3295
3286
char name[32];
3296
3287
bool snc_mode;
3297
3288
int ret = 0;
3298
3289
3299
3290
lockdep_assert_held(&rdtgroup_mutex);
3300
3291
3292
+
if (!domain_header_is_valid(hdr, RESCTRL_MON_DOMAIN, RDT_RESOURCE_L3))
3293
+
return -EINVAL;
3294
+
3295
+
d = container_of(hdr, struct rdt_mon_domain, hdr);
3301
3296
snc_mode = r->mon_scope == RESCTRL_L3_NODE;
3302
3297
sprintf(name, "mon_%s_%02d", r->name, snc_mode ? d->ci_id : d->hdr.id);
3303
3298
kn = kernfs_find_and_get(parent_kn, name);
···
3320
3305
ret = rdtgroup_kn_set_ugid(kn);
3321
3306
if (ret)
3322
3307
goto out_destroy;
3323
-
ret = mon_add_all_files(kn, d, r, prgrp, snc_mode);
3308
+
ret = mon_add_all_files(kn, hdr, r, prgrp, snc_mode);
3324
3309
if (ret)
3325
3310
goto out_destroy;
3326
3311
}
3327
3312
3328
3313
if (snc_mode) {
3329
-
sprintf(name, "mon_sub_%s_%02d", r->name, d->hdr.id);
3314
+
sprintf(name, "mon_sub_%s_%02d", r->name, hdr->id);
3330
3315
ckn = kernfs_create_dir(kn, name, parent_kn->mode, prgrp);
3331
3316
if (IS_ERR(ckn)) {
3332
3317
ret = -EINVAL;
···
3337
3322
if (ret)
3338
3323
goto out_destroy;
3339
3324
3340
-
ret = mon_add_all_files(ckn, d, r, prgrp, false);
3325
+
ret = mon_add_all_files(ckn, hdr, r, prgrp, false);
3341
3326
if (ret)
3342
3327
goto out_destroy;
3343
3328
}
···
3355
3340
* and "monitor" groups with given domain id.
3356
3341
*/
3357
3342
static void mkdir_mondata_subdir_allrdtgrp(struct rdt_resource *r,
3358
-
struct rdt_mon_domain *d)
3343
+
struct rdt_domain_hdr *hdr)
3359
3344
{
3360
3345
struct kernfs_node *parent_kn;
3361
3346
struct rdtgroup *prgrp, *crgrp;
···
3363
3348
3364
3349
list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) {
3365
3350
parent_kn = prgrp->mon.mon_data_kn;
3366
-
mkdir_mondata_subdir(parent_kn, d, r, prgrp);
3351
+
mkdir_mondata_subdir(parent_kn, hdr, r, prgrp);
3367
3352
3368
3353
head = &prgrp->mon.crdtgrp_list;
3369
3354
list_for_each_entry(crgrp, head, mon.crdtgrp_list) {
3370
3355
parent_kn = crgrp->mon.mon_data_kn;
3371
-
mkdir_mondata_subdir(parent_kn, d, r, crgrp);
3356
+
mkdir_mondata_subdir(parent_kn, hdr, r, crgrp);
3372
3357
}
3373
3358
}
3374
3359
}
···
3377
3362
struct rdt_resource *r,
3378
3363
struct rdtgroup *prgrp)
3379
3364
{
3380
-
struct rdt_mon_domain *dom;
3365
+
struct rdt_domain_hdr *hdr;
3381
3366
int ret;
3382
3367
3383
3368
/* Walking r->domains, ensure it can't race with cpuhp */
3384
3369
lockdep_assert_cpus_held();
3385
3370
3386
-
list_for_each_entry(dom, &r->mon_domains, hdr.list) {
3387
-
ret = mkdir_mondata_subdir(parent_kn, dom, r, prgrp);
3371
+
list_for_each_entry(hdr, &r->mon_domains, list) {
3372
+
ret = mkdir_mondata_subdir(parent_kn, hdr, r, prgrp);
3388
3373
if (ret)
3389
3374
return ret;
3390
3375
}
···
4268
4253
mutex_unlock(&rdtgroup_mutex);
4269
4254
}
4270
4255
4271
-
void resctrl_offline_mon_domain(struct rdt_resource *r, struct rdt_mon_domain *d)
4256
+
void resctrl_offline_mon_domain(struct rdt_resource *r, struct rdt_domain_hdr *hdr)
4272
4257
{
4258
+
struct rdt_mon_domain *d;
4259
+
4273
4260
mutex_lock(&rdtgroup_mutex);
4261
+
4262
+
if (!domain_header_is_valid(hdr, RESCTRL_MON_DOMAIN, RDT_RESOURCE_L3))
4263
+
goto out_unlock;
4264
+
4265
+
d = container_of(hdr, struct rdt_mon_domain, hdr);
4274
4266
4275
4267
/*
4276
4268
* If resctrl is mounted, remove all the
4277
4269
* per domain monitor data directories.
4278
4270
*/
4279
4271
if (resctrl_mounted && resctrl_arch_mon_capable())
4280
-
rmdir_mondata_subdir_allrdtgrp(r, d);
4272
+
rmdir_mondata_subdir_allrdtgrp(r, hdr);
4281
4273
4282
4274
if (resctrl_is_mbm_enabled())
4283
4275
cancel_delayed_work(&d->mbm_over);
···
4302
4280
}
4303
4281
4304
4282
domain_destroy_mon_state(d);
4305
-
4283
+
out_unlock:
4306
4284
mutex_unlock(&rdtgroup_mutex);
4307
4285
}
4308
4286
···
4375
4353
return err;
4376
4354
}
4377
4355
4378
-
int resctrl_online_mon_domain(struct rdt_resource *r, struct rdt_mon_domain *d)
4356
+
int resctrl_online_mon_domain(struct rdt_resource *r, struct rdt_domain_hdr *hdr)
4379
4357
{
4380
-
int err;
4358
+
struct rdt_mon_domain *d;
4359
+
int err = -EINVAL;
4381
4360
4382
4361
mutex_lock(&rdtgroup_mutex);
4383
4362
4363
+
if (!domain_header_is_valid(hdr, RESCTRL_MON_DOMAIN, RDT_RESOURCE_L3))
4364
+
goto out_unlock;
4365
+
4366
+
d = container_of(hdr, struct rdt_mon_domain, hdr);
4384
4367
err = domain_setup_mon_state(r, d);
4385
4368
if (err)
4386
4369
goto out_unlock;
···
4406
4379
* If resctrl is mounted, add per domain monitor data directories.
4407
4380
*/
4408
4381
if (resctrl_mounted && resctrl_arch_mon_capable())
4409
-
mkdir_mondata_subdir_allrdtgrp(r, d);
4382
+
mkdir_mondata_subdir_allrdtgrp(r, hdr);
4410
4383
4411
4384
out_unlock:
4412
4385
mutex_unlock(&rdtgroup_mutex);
+2
-2
include/linux/resctrl.h
+2
-2
include/linux/resctrl.h
···
507
507
u32 resctrl_arch_get_config(struct rdt_resource *r, struct rdt_ctrl_domain *d,
508
508
u32 closid, enum resctrl_conf_type type);
509
509
int resctrl_online_ctrl_domain(struct rdt_resource *r, struct rdt_ctrl_domain *d);
510
-
int resctrl_online_mon_domain(struct rdt_resource *r, struct rdt_mon_domain *d);
510
+
int resctrl_online_mon_domain(struct rdt_resource *r, struct rdt_domain_hdr *hdr);
511
511
void resctrl_offline_ctrl_domain(struct rdt_resource *r, struct rdt_ctrl_domain *d);
512
-
void resctrl_offline_mon_domain(struct rdt_resource *r, struct rdt_mon_domain *d);
512
+
void resctrl_offline_mon_domain(struct rdt_resource *r, struct rdt_domain_hdr *hdr);
513
513
void resctrl_online_cpu(unsigned int cpu);
514
514
void resctrl_offline_cpu(unsigned int cpu);
515
515