linux-imx

// SPDX-License-Identifier: GPL-2.0

/*

 * padata.c - generic interface to process data streams in parallel

 *

 * See Documentation/padata.txt for an api documentation.

 *

 * Copyright (C) 2008, 2009 secunet Security Networks AG

 * Copyright (C) 2008, 2009 Steffen Klassert <steffen.klassert@secunet.com>

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms and conditions of the GNU General Public License,

 * version 2, as published by the Free Software Foundation.

 *

 * This program is distributed in the hope it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

 * more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

 */

​

#include <linux/export.h>

#include <linux/cpumask.h>

#include <linux/err.h>

#include <linux/cpu.h>

#include <linux/padata.h>

#include <linux/mutex.h>

#include <linux/sched.h>

#include <linux/slab.h>

#include <linux/sysfs.h>

#include <linux/rcupdate.h>

#include <linux/module.h>

​

#define MAX_OBJ_NUM 1000

​

static int padata_index_to_cpu(struct parallel_data *pd, int cpu_index)

{

    int cpu, target_cpu;

​

    target_cpu = cpumask_first(pd->cpumask.pcpu);

    for (cpu = 0; cpu < cpu_index; cpu++)

        target_cpu = cpumask_next(target_cpu, pd->cpumask.pcpu);

​

    return target_cpu;

}

​

static int padata_cpu_hash(struct parallel_data *pd)

{

    unsigned int seq_nr;

    int cpu_index;

​

    /*

     * Hash the sequence numbers to the cpus by taking

     * seq_nr mod. number of cpus in use.

     */

​

    seq_nr = atomic_inc_return(&pd->seq_nr);

    cpu_index = seq_nr % cpumask_weight(pd->cpumask.pcpu);

​

    return padata_index_to_cpu(pd, cpu_index);

}

​

static void padata_parallel_worker(struct work_struct *parallel_work)

{

    struct padata_parallel_queue *pqueue;

    LIST_HEAD(local_list);

​

    local_bh_disable();

    pqueue = container_of(parallel_work,

                  struct padata_parallel_queue, work);

​

    spin_lock(&pqueue->parallel.lock);

    list_replace_init(&pqueue->parallel.list, &local_list);

    spin_unlock(&pqueue->parallel.lock);

​

    while (!list_empty(&local_list)) {

        struct padata_priv *padata;

​

        padata = list_entry(local_list.next,

                    struct padata_priv, list);

​

        list_del_init(&padata->list);

​

        padata->parallel(padata);

    }

​

    local_bh_enable();

}

​

/**