lkml.org 
[lkml]   [2018]   [Apr]   [25]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH V3 35/39] x86/intel_rdt: Create character device exposing pseudo-locked region
    Date
    After a pseudo-locked region is created it needs to be made
    available to user space for usage.

    A character device supporting mmap() is created for each pseudo-locked
    region. A user space application can now use mmap() system call to map
    pseudo-locked region into its virtual address space.

    Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
    ---
    arch/x86/kernel/cpu/intel_rdt.h | 5 +
    arch/x86/kernel/cpu/intel_rdt_pseudo_lock.c | 282 +++++++++++++++++++++++++++-
    arch/x86/kernel/cpu/intel_rdt_rdtgroup.c | 11 +-
    3 files changed, 296 insertions(+), 2 deletions(-)

    diff --git a/arch/x86/kernel/cpu/intel_rdt.h b/arch/x86/kernel/cpu/intel_rdt.h
    index be62c39e18f6..db3aa956cd1c 100644
    --- a/arch/x86/kernel/cpu/intel_rdt.h
    +++ b/arch/x86/kernel/cpu/intel_rdt.h
    @@ -137,6 +137,8 @@ struct mongroup {
    * @line_size: size of the cache lines
    * @size: size of pseudo-locked region in bytes
    * @kmem: the kernel memory associated with pseudo-locked region
    + * @minor: minor number of character device associated with this
    + * region
    * @debugfs_dir: pointer to this region's directory in the debugfs
    * filesystem
    */
    @@ -150,6 +152,7 @@ struct pseudo_lock_region {
    unsigned int line_size;
    unsigned int size;
    void *kmem;
    + unsigned int minor;
    #ifdef CONFIG_INTEL_RDT_DEBUGFS
    struct dentry *debugfs_dir;
    #endif
    @@ -513,6 +516,8 @@ int rdtgroup_locksetup_enter(struct rdtgroup *rdtgrp);
    int rdtgroup_locksetup_exit(struct rdtgroup *rdtgrp);
    bool rdtgroup_cbm_overlaps_pseudo_locked(struct rdt_domain *d, u32 _cbm);
    bool rdtgroup_pseudo_locked_in_hierarchy(struct rdt_domain *d);
    +int rdt_pseudo_lock_init(void);
    +void rdt_pseudo_lock_release(void);
    int rdtgroup_pseudo_lock_create(struct rdtgroup *rdtgrp);
    void rdtgroup_pseudo_lock_remove(struct rdtgroup *rdtgrp);
    struct rdt_domain *get_domain_from_cpu(int cpu, struct rdt_resource *r);
    diff --git a/arch/x86/kernel/cpu/intel_rdt_pseudo_lock.c b/arch/x86/kernel/cpu/intel_rdt_pseudo_lock.c
    index 8a52e5e61f3e..cc51a2c653bb 100644
    --- a/arch/x86/kernel/cpu/intel_rdt_pseudo_lock.c
    +++ b/arch/x86/kernel/cpu/intel_rdt_pseudo_lock.c
    @@ -24,6 +24,7 @@
    #include <linux/cpumask.h>
    #include <linux/debugfs.h>
    #include <linux/kthread.h>
    +#include <linux/mman.h>
    #include <linux/slab.h>
    #include <asm/cacheflush.h>
    #include <asm/intel-family.h>
    @@ -48,6 +49,14 @@
    */
    static u64 prefetch_disable_bits;

    +/*
    + * Major number assigned to and shared by all devices exposing
    + * pseudo-locked regions.
    + */
    +static unsigned int pseudo_lock_major;
    +static unsigned long pseudo_lock_minor_avail = GENMASK(MINORBITS, 0);
    +static struct class *pseudo_lock_class;
    +
    /**
    * get_prefetch_disable_bits - prefetch disable bits of supported platforms
    *
    @@ -100,6 +109,66 @@ static u64 get_prefetch_disable_bits(void)
    }

    /**
    + * pseudo_lock_minor_get - Obtain available minor number
    + * @minor: Pointer to where new minor number will be stored
    + *
    + * A bitmask is used to track available minor numbers. Here the next free
    + * minor number is marked as unavailable and returned.
    + *
    + * Return: 0 on success, <0 on failure.
    + */
    +static int pseudo_lock_minor_get(unsigned int *minor)
    +{
    + unsigned long first_bit;
    +
    + first_bit = find_first_bit(&pseudo_lock_minor_avail, MINORBITS);
    +
    + if (first_bit == MINORBITS)
    + return -ENOSPC;
    +
    + __clear_bit(first_bit, &pseudo_lock_minor_avail);
    + *minor = first_bit;
    +
    + return 0;
    +}
    +
    +/**
    + * pseudo_lock_minor_release - Return minor number to available
    + * @minor: The minor number made available
    + */
    +static void pseudo_lock_minor_release(unsigned int minor)
    +{
    + __set_bit(minor, &pseudo_lock_minor_avail);
    +}
    +
    +/**
    + * region_find_by_minor - Locate a pseudo-lock region by inode minor number
    + * @minor: The minor number of the device representing pseudo-locked region
    + *
    + * When the character device is accessed we need to determine which
    + * pseudo-locked region it belongs to. This is done by matching the minor
    + * number of the device to the pseudo-locked region it belongs.
    + *
    + * Minor numbers are assigned at the time a pseudo-locked region is associated
    + * with a cache instance.
    + *
    + * Return: On success return pointer to resource group owning the pseudo-locked
    + * region, NULL on failure.
    + */
    +static struct rdtgroup *region_find_by_minor(unsigned int minor)
    +{
    + struct rdtgroup *rdtgrp, *rdtgrp_match = NULL;
    +
    + list_for_each_entry(rdtgrp, &rdt_all_groups, rdtgroup_list) {
    + if (rdtgrp->plr && rdtgrp->plr->minor == minor) {
    + rdtgrp_match = rdtgrp;
    + break;
    + }
    + }
    + return rdtgrp_match;
    +}
    +
    +/**
    * pseudo_lock_region_init - Initialize pseudo-lock region information
    * @plr: pseudo-lock region
    *
    @@ -866,9 +935,11 @@ int rdtgroup_pseudo_lock_create(struct rdtgroup *rdtgrp)
    {
    struct pseudo_lock_region *plr = rdtgrp->plr;
    struct task_struct *thread;
    + unsigned int new_minor;
    #ifdef CONFIG_INTEL_RDT_DEBUGFS
    struct dentry *entry;
    #endif
    + struct device *dev;
    int ret;

    ret = pseudo_lock_region_alloc(plr);
    @@ -922,13 +993,55 @@ int rdtgroup_pseudo_lock_create(struct rdtgroup *rdtgrp)
    }
    #endif

    + ret = pseudo_lock_minor_get(&new_minor);
    + if (ret < 0) {
    + rdt_last_cmd_puts("unable to obtain a new minor number\n");
    + goto out_debugfs;
    + }
    +
    + /*
    + * Unlock access but do not release the reference. The
    + * pseudo-locked region will still be here on return.
    + *
    + * The mutex has to be released temporarily to avoid a potential
    + * deadlock with the mm->mmap_sem semaphore which is obtained in
    + * the device_create() callpath below as well as before the mmap()
    + * callback is called.
    + */
    + mutex_unlock(&rdtgroup_mutex);
    +
    + dev = device_create(pseudo_lock_class, NULL,
    + MKDEV(pseudo_lock_major, new_minor),
    + rdtgrp, "%s", rdtgrp->kn->name);
    +
    + mutex_lock(&rdtgroup_mutex);
    +
    + if (IS_ERR(dev)) {
    + ret = PTR_ERR(dev);
    + rdt_last_cmd_printf("failed to create character device: %d\n",
    + ret);
    + goto out_minor;
    + }
    +
    + /* We released the mutex - check if group was removed while we did so */
    + if (rdtgrp->flags & RDT_DELETED) {
    + ret = -ENODEV;
    + goto out_device;
    + }
    +
    + plr->minor = new_minor;
    +
    rdtgrp->mode = RDT_MODE_PSEUDO_LOCKED;
    closid_free(rdtgrp->closid);
    ret = 0;
    goto out;

    -#ifdef CONFIG_INTEL_RDT_DEBUGFS
    +out_device:
    + device_destroy(pseudo_lock_class, MKDEV(pseudo_lock_major, new_minor));
    +out_minor:
    + pseudo_lock_minor_release(new_minor);
    out_debugfs:
    +#ifdef CONFIG_INTEL_RDT_DEBUGFS
    debugfs_remove_recursive(plr->debugfs_dir);
    #endif
    out_region:
    @@ -953,6 +1066,8 @@ int rdtgroup_pseudo_lock_create(struct rdtgroup *rdtgrp)
    */
    void rdtgroup_pseudo_lock_remove(struct rdtgroup *rdtgrp)
    {
    + struct pseudo_lock_region *plr = rdtgrp->plr;
    +
    if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKSETUP) {
    /*
    * Default group cannot be a pseudo-locked region so we can
    @@ -965,7 +1080,172 @@ void rdtgroup_pseudo_lock_remove(struct rdtgroup *rdtgrp)
    #ifdef CONFIG_INTEL_RDT_DEBUGFS
    debugfs_remove_recursive(rdtgrp->plr->debugfs_dir);
    #endif
    + device_destroy(pseudo_lock_class, MKDEV(pseudo_lock_major, plr->minor));
    + pseudo_lock_minor_release(plr->minor);

    free:
    pseudo_lock_free(rdtgrp);
    }
    +
    +static int pseudo_lock_dev_open(struct inode *inode, struct file *filp)
    +{
    + struct rdtgroup *rdtgrp;
    +
    + mutex_lock(&rdtgroup_mutex);
    +
    + rdtgrp = region_find_by_minor(iminor(inode));
    + if (!rdtgrp) {
    + mutex_unlock(&rdtgroup_mutex);
    + return -ENODEV;
    + }
    +
    + filp->private_data = rdtgrp;
    + atomic_inc(&rdtgrp->waitcount);
    + /* Perform a non-seekable open - llseek is not supported */
    + filp->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
    +
    + mutex_unlock(&rdtgroup_mutex);
    +
    + return 0;
    +}
    +
    +static int pseudo_lock_dev_release(struct inode *inode, struct file *filp)
    +{
    + struct rdtgroup *rdtgrp;
    +
    + mutex_lock(&rdtgroup_mutex);
    + rdtgrp = filp->private_data;
    + WARN_ON(!rdtgrp);
    + if (!rdtgrp) {
    + mutex_unlock(&rdtgroup_mutex);
    + return -ENODEV;
    + }
    + filp->private_data = NULL;
    + atomic_dec(&rdtgrp->waitcount);
    + mutex_unlock(&rdtgroup_mutex);
    + return 0;
    +}
    +
    +static int pseudo_lock_dev_mremap(struct vm_area_struct *area)
    +{
    + /* Not supported */
    + return -EINVAL;
    +}
    +
    +static const struct vm_operations_struct pseudo_mmap_ops = {
    + .mremap = pseudo_lock_dev_mremap,
    +};
    +
    +static int pseudo_lock_dev_mmap(struct file *filp, struct vm_area_struct *vma)
    +{
    + unsigned long vsize = vma->vm_end - vma->vm_start;
    + unsigned long off = vma->vm_pgoff << PAGE_SHIFT;
    + struct pseudo_lock_region *plr;
    + struct rdtgroup *rdtgrp;
    + unsigned long physical;
    + unsigned long psize;
    +
    + mutex_lock(&rdtgroup_mutex);
    +
    + rdtgrp = filp->private_data;
    + WARN_ON(!rdtgrp);
    + if (!rdtgrp) {
    + mutex_unlock(&rdtgroup_mutex);
    + return -ENODEV;
    + }
    +
    + plr = rdtgrp->plr;
    +
    + /*
    + * Task is required to run with affinity to the cpus associated
    + * with the pseudo-locked region. If this is not the case the task
    + * may be scheduled elsewhere and invalidate entries in the
    + * pseudo-locked region.
    + */
    + if (!cpumask_subset(&current->cpus_allowed, &plr->d->cpu_mask)) {
    + mutex_unlock(&rdtgroup_mutex);
    + return -EINVAL;
    + }
    +
    + physical = __pa(plr->kmem) >> PAGE_SHIFT;
    + psize = plr->size - off;
    +
    + if (off > plr->size) {
    + mutex_unlock(&rdtgroup_mutex);
    + return -ENOSPC;
    + }
    +
    + /*
    + * Ensure changes are carried directly to the memory being mapped,
    + * do not allow copy-on-write mapping.
    + */
    + if (!(vma->vm_flags & VM_SHARED)) {
    + mutex_unlock(&rdtgroup_mutex);
    + return -EINVAL;
    + }
    +
    + if (vsize > psize) {
    + mutex_unlock(&rdtgroup_mutex);
    + return -ENOSPC;
    + }
    +
    + memset(plr->kmem + off, 0, vsize);
    +
    + if (remap_pfn_range(vma, vma->vm_start, physical + vma->vm_pgoff,
    + vsize, vma->vm_page_prot)) {
    + mutex_unlock(&rdtgroup_mutex);
    + return -EAGAIN;
    + }
    + vma->vm_ops = &pseudo_mmap_ops;
    + mutex_unlock(&rdtgroup_mutex);
    + return 0;
    +}
    +
    +static const struct file_operations pseudo_lock_dev_fops = {
    + .owner = THIS_MODULE,
    + .llseek = no_llseek,
    + .read = NULL,
    + .write = NULL,
    + .open = pseudo_lock_dev_open,
    + .release = pseudo_lock_dev_release,
    + .mmap = pseudo_lock_dev_mmap,
    +};
    +
    +static char *pseudo_lock_devnode(struct device *dev, umode_t *mode)
    +{
    + struct rdtgroup *rdtgrp;
    +
    + rdtgrp = dev_get_drvdata(dev);
    + if (mode)
    + *mode = 0600;
    + return kasprintf(GFP_KERNEL, "pseudo_lock/%s", rdtgrp->kn->name);
    +}
    +
    +int rdt_pseudo_lock_init(void)
    +{
    + int ret;
    +
    + ret = register_chrdev(0, "pseudo_lock", &pseudo_lock_dev_fops);
    + if (ret < 0)
    + return ret;
    +
    + pseudo_lock_major = ret;
    +
    + pseudo_lock_class = class_create(THIS_MODULE, "pseudo_lock");
    + if (IS_ERR(pseudo_lock_class)) {
    + ret = PTR_ERR(pseudo_lock_class);
    + unregister_chrdev(pseudo_lock_major, "pseudo_lock");
    + return ret;
    + }
    +
    + pseudo_lock_class->devnode = pseudo_lock_devnode;
    + return 0;
    +}
    +
    +void rdt_pseudo_lock_release(void)
    +{
    + class_destroy(pseudo_lock_class);
    + pseudo_lock_class = NULL;
    + unregister_chrdev(pseudo_lock_major, "pseudo_lock");
    + pseudo_lock_major = 0;
    +}
    diff --git a/arch/x86/kernel/cpu/intel_rdt_rdtgroup.c b/arch/x86/kernel/cpu/intel_rdt_rdtgroup.c
    index 0d8dbe11b8dd..a38ddfe7d552 100644
    --- a/arch/x86/kernel/cpu/intel_rdt_rdtgroup.c
    +++ b/arch/x86/kernel/cpu/intel_rdt_rdtgroup.c
    @@ -1831,10 +1831,16 @@ static struct dentry *rdt_mount(struct file_system_type *fs_type,
    rdtgroup_default.mon.mon_data_kn = kn_mondata;
    }

    + ret = rdt_pseudo_lock_init();
    + if (ret) {
    + dentry = ERR_PTR(ret);
    + goto out_mondata;
    + }
    +
    dentry = kernfs_mount(fs_type, flags, rdt_root,
    RDTGROUP_SUPER_MAGIC, NULL);
    if (IS_ERR(dentry))
    - goto out_mondata;
    + goto out_psl;

    if (rdt_alloc_capable)
    static_branch_enable_cpuslocked(&rdt_alloc_enable_key);
    @@ -1852,6 +1858,8 @@ static struct dentry *rdt_mount(struct file_system_type *fs_type,

    goto out;

    +out_psl:
    + rdt_pseudo_lock_release();
    out_mondata:
    if (rdt_mon_capable)
    kernfs_remove(kn_mondata);
    @@ -2027,6 +2035,7 @@ static void rdt_kill_sb(struct super_block *sb)
    reset_all_ctrls(r);
    cdp_disable_all();
    rmdir_all_sub();
    + rdt_pseudo_lock_release();
    rdtgroup_default.mode = RDT_MODE_SHAREABLE;
    static_branch_disable_cpuslocked(&rdt_alloc_enable_key);
    static_branch_disable_cpuslocked(&rdt_mon_enable_key);
    --
    2.13.6
    \
     
     \ /
      Last update: 2018-04-25 20:18    [W:6.482 / U:0.008 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site