lkml.org 
[lkml]   [2023]   [Jan]   [27]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 01/30] cgroup: Implement cgroup_show_cftypes()
    Date
    Implement cgroup_show_cftypes() which shows and hides all cgroup files
    associated with the specified set of cgroup file types. CFTYPE_HIDDEN flag
    is added so that files can be created hidden from the get-go.

    cgroup_show_cftypes() can be used whether the cftypes are added or not. It
    also combines with cgroup_show_file() so that a given file is visible iff
    both its cftype and cfile are visible.

    This will be used by a new sched_class to selectively show and hide CPU
    controller interface files depending on whether they're supported.

    Signed-off-by: Tejun Heo <tj@kernel.org>
    Reviewed-by: David Vernet <dvernet@meta.com>
    Acked-by: Josh Don <joshdon@google.com>
    Acked-by: Hao Luo <haoluo@google.com>
    Acked-by: Barret Rhoden <brho@google.com>
    ---
    include/linux/cgroup-defs.h | 8 +++
    include/linux/cgroup.h | 1 +
    kernel/cgroup/cgroup.c | 97 ++++++++++++++++++++++++++++++++++---
    3 files changed, 99 insertions(+), 7 deletions(-)

    diff --git a/include/linux/cgroup-defs.h b/include/linux/cgroup-defs.h
    index 8a0d5466c7be..8af1e7d487cb 100644
    --- a/include/linux/cgroup-defs.h
    +++ b/include/linux/cgroup-defs.h
    @@ -127,12 +127,18 @@ enum {
    CFTYPE_WORLD_WRITABLE = (1 << 4), /* (DON'T USE FOR NEW FILES) S_IWUGO */
    CFTYPE_DEBUG = (1 << 5), /* create when cgroup_debug */

    + CFTYPE_HIDDEN = (1 << 6), /* file type hidden, see cgroup_show_cftypes() */
    +
    /* internal flags, do not use outside cgroup core proper */
    __CFTYPE_ONLY_ON_DFL = (1 << 16), /* only on default hierarchy */
    __CFTYPE_NOT_ON_DFL = (1 << 17), /* not on default hierarchy */
    __CFTYPE_ADDED = (1 << 18),
    };

    +enum cfile_flags {
    + CFILE_HIDDEN = (1 << 0), /* file instance hidden */
    +};
    +
    /*
    * cgroup_file is the handle for a file instance created in a cgroup which
    * is used, for example, to generate file changed notifications. This can
    @@ -140,7 +146,9 @@ enum {
    */
    struct cgroup_file {
    /* do not access any fields from outside cgroup core */
    + struct cftype *cft;
    struct kernfs_node *kn;
    + unsigned int flags;
    unsigned long notified_at;
    struct timer_list notify_timer;
    };
    diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
    index 3410aecffdb4..a8c6982c2c24 100644
    --- a/include/linux/cgroup.h
    +++ b/include/linux/cgroup.h
    @@ -115,6 +115,7 @@ int cgroup_transfer_tasks(struct cgroup *to, struct cgroup *from);
    int cgroup_add_dfl_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
    int cgroup_add_legacy_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
    int cgroup_rm_cftypes(struct cftype *cfts);
    +void cgroup_show_cftype(struct cftype *cft, bool show);
    void cgroup_file_notify(struct cgroup_file *cfile);
    void cgroup_file_show(struct cgroup_file *cfile, bool show);

    diff --git a/kernel/cgroup/cgroup.c b/kernel/cgroup/cgroup.c
    index c099cf3fa02d..27bafb2732c5 100644
    --- a/kernel/cgroup/cgroup.c
    +++ b/kernel/cgroup/cgroup.c
    @@ -4196,10 +4196,13 @@ static int cgroup_add_file(struct cgroup_subsys_state *css, struct cgroup *cgrp,
    return ret;
    }

    + kernfs_show(kn, !(cft->flags & CFTYPE_HIDDEN));
    +
    if (cft->file_offset) {
    struct cgroup_file *cfile = (void *)css + cft->file_offset;

    timer_setup(&cfile->notify_timer, cgroup_file_notify_timer, 0);
    + cfile->cft = cft;

    spin_lock_irq(&cgroup_file_kn_lock);
    cfile->kn = kn;
    @@ -4478,6 +4481,24 @@ void cgroup_file_notify(struct cgroup_file *cfile)
    spin_unlock_irqrestore(&cgroup_file_kn_lock, flags);
    }

    +static struct kernfs_node *cfile_kn_get(struct cgroup_file *cfile)
    +{
    + struct kernfs_node *kn;
    +
    + spin_lock_irq(&cgroup_file_kn_lock);
    + kn = cfile->kn;
    + kernfs_get(kn);
    + spin_unlock_irq(&cgroup_file_kn_lock);
    +
    + return kn;
    +}
    +
    +static bool cfile_visible(struct cgroup_file *cfile)
    +{
    + return !(cfile->cft->flags & CFTYPE_HIDDEN) &&
    + !(cfile->flags & CFILE_HIDDEN);
    +}
    +
    /**
    * cgroup_file_show - show or hide a hidden cgroup file
    * @cfile: target cgroup_file obtained by setting cftype->file_offset
    @@ -4487,15 +4508,20 @@ void cgroup_file_show(struct cgroup_file *cfile, bool show)
    {
    struct kernfs_node *kn;

    - spin_lock_irq(&cgroup_file_kn_lock);
    - kn = cfile->kn;
    - kernfs_get(kn);
    - spin_unlock_irq(&cgroup_file_kn_lock);
    + mutex_lock(&cgroup_mutex);

    - if (kn)
    - kernfs_show(kn, show);
    + if (show)
    + cfile->flags &= ~CFILE_HIDDEN;
    + else
    + cfile->flags |= CFILE_HIDDEN;

    - kernfs_put(kn);
    + kn = cfile_kn_get(cfile);
    + if (kn) {
    + kernfs_show(kn, cfile_visible(cfile));
    + kernfs_put(kn);
    + }
    +
    + mutex_unlock(&cgroup_mutex);
    }

    /**
    @@ -5509,6 +5535,63 @@ static void offline_css(struct cgroup_subsys_state *css)
    wake_up_all(&css->cgroup->offline_waitq);
    }

    +/**
    + * cgroup_show_cftype - show or hide a cgroup file type
    + * @cft: cftype to show or hide
    + * @show: whether to show or hide
    + *
    + * Sets %CFTYPE_HIDDEN and shows/hides the matching files according to @show.
    + * @cft may or may not be added at the time of this call. After hiding, it's
    + * guaranteed that there are no in-flight operations on the hidden files.
    + */
    +void cgroup_show_cftype(struct cftype *cft, bool show)
    +{
    + struct cgroup_subsys *ss = cft->ss;
    + struct cgroup *root = ss ? &ss->root->cgrp : &cgrp_dfl_root.cgrp;
    + struct cgroup_subsys_state *css;
    +
    + mutex_lock(&cgroup_mutex);
    +
    + if (show)
    + cft->flags &= ~CFTYPE_HIDDEN;
    + else
    + cft->flags |= CFTYPE_HIDDEN;
    +
    + if (!(cft->flags & __CFTYPE_ADDED))
    + goto out_unlock;
    +
    + css_for_each_descendant_pre(css, cgroup_css(root, ss)) {
    + struct cgroup *cgrp = css->cgroup;
    + struct kernfs_node *kn;
    +
    + if (!(css->flags & CSS_VISIBLE))
    + continue;
    +
    + if (cft->file_offset) {
    + struct cgroup_file *cfile =
    + (void *)css + cft->file_offset;
    +
    + kn = cfile_kn_get(cfile);
    + if (kn) {
    + kernfs_show(kn, cfile_visible(cfile));
    + kernfs_put(kn);
    + }
    + } else {
    + char buf[CGROUP_FILE_NAME_MAX];
    +
    + kn = kernfs_find_and_get(cgrp->kn,
    + cgroup_file_name(cgrp, cft, buf));
    + if (kn) {
    + kernfs_show(kn, show);
    + kernfs_put(kn);
    + }
    + }
    + }
    +
    +out_unlock:
    + mutex_unlock(&cgroup_mutex);
    +}
    +
    /**
    * css_create - create a cgroup_subsys_state
    * @cgrp: the cgroup new css will be associated with
    --
    2.39.1
    \
     
     \ /
      Last update: 2023-03-27 00:00    [W:4.086 / U:0.092 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site