source: src/linux/universal/linux-3.18/kernel/padata.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 3 months ago

update

File size: 26.9 KB
Line 
1/*
2 * padata.c - generic interface to process data streams in parallel
3 *
4 * See Documentation/padata.txt for an api documentation.
5 *
6 * Copyright (C) 2008, 2009 secunet Security Networks AG
7 * Copyright (C) 2008, 2009 Steffen Klassert <steffen.klassert@secunet.com>
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms and conditions of the GNU General Public License,
11 * version 2, as published by the Free Software Foundation.
12 *
13 * This program is distributed in the hope it will be useful, but WITHOUT
14 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16 * more details.
17 *
18 * You should have received a copy of the GNU General Public License along with
19 * this program; if not, write to the Free Software Foundation, Inc.,
20 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
21 */
22
23#include <linux/export.h>
24#include <linux/cpumask.h>
25#include <linux/err.h>
26#include <linux/cpu.h>
27#include <linux/padata.h>
28#include <linux/mutex.h>
29#include <linux/sched.h>
30#include <linux/slab.h>
31#include <linux/sysfs.h>
32#include <linux/rcupdate.h>
33
34#define MAX_OBJ_NUM 1000
35
36static int padata_index_to_cpu(struct parallel_data *pd, int cpu_index)
37{
38        int cpu, target_cpu;
39
40        target_cpu = cpumask_first(pd->cpumask.pcpu);
41        for (cpu = 0; cpu < cpu_index; cpu++)
42                target_cpu = cpumask_next(target_cpu, pd->cpumask.pcpu);
43
44        return target_cpu;
45}
46
47static int padata_cpu_hash(struct parallel_data *pd)
48{
49        unsigned int seq_nr;
50        int cpu_index;
51
52        /*
53         * Hash the sequence numbers to the cpus by taking
54         * seq_nr mod. number of cpus in use.
55         */
56
57        seq_nr = atomic_inc_return(&pd->seq_nr);
58        cpu_index = seq_nr % cpumask_weight(pd->cpumask.pcpu);
59
60        return padata_index_to_cpu(pd, cpu_index);
61}
62
63static void padata_parallel_worker(struct work_struct *parallel_work)
64{
65        struct padata_parallel_queue *pqueue;
66        struct parallel_data *pd;
67        struct padata_instance *pinst;
68        LIST_HEAD(local_list);
69
70        local_bh_disable();
71        pqueue = container_of(parallel_work,
72                              struct padata_parallel_queue, work);
73        pd = pqueue->pd;
74        pinst = pd->pinst;
75
76        spin_lock(&pqueue->parallel.lock);
77        list_replace_init(&pqueue->parallel.list, &local_list);
78        spin_unlock(&pqueue->parallel.lock);
79
80        while (!list_empty(&local_list)) {
81                struct padata_priv *padata;
82
83                padata = list_entry(local_list.next,
84                                    struct padata_priv, list);
85
86                list_del_init(&padata->list);
87
88                padata->parallel(padata);
89        }
90
91        local_bh_enable();
92}
93
94/**
95 * padata_do_parallel - padata parallelization function
96 *
97 * @pinst: padata instance
98 * @padata: object to be parallelized
99 * @cb_cpu: cpu the serialization callback function will run on,
100 *          must be in the serial cpumask of padata(i.e. cpumask.cbcpu).
101 *
102 * The parallelization callback function will run with BHs off.
103 * Note: Every object which is parallelized by padata_do_parallel
104 * must be seen by padata_do_serial.
105 */
106int padata_do_parallel(struct padata_instance *pinst,
107                       struct padata_priv *padata, int cb_cpu)
108{
109        int target_cpu, err;
110        struct padata_parallel_queue *queue;
111        struct parallel_data *pd;
112
113        rcu_read_lock_bh();
114
115        pd = rcu_dereference_bh(pinst->pd);
116
117        err = -EINVAL;
118        if (!(pinst->flags & PADATA_INIT) || pinst->flags & PADATA_INVALID)
119                goto out;
120
121        if (!cpumask_test_cpu(cb_cpu, pd->cpumask.cbcpu))
122                goto out;
123
124        err =  -EBUSY;
125        if ((pinst->flags & PADATA_RESET))
126                goto out;
127
128        if (atomic_read(&pd->refcnt) >= MAX_OBJ_NUM)
129                goto out;
130
131        err = 0;
132        atomic_inc(&pd->refcnt);
133        padata->pd = pd;
134        padata->cb_cpu = cb_cpu;
135
136        target_cpu = padata_cpu_hash(pd);
137        queue = per_cpu_ptr(pd->pqueue, target_cpu);
138
139        spin_lock(&queue->parallel.lock);
140        list_add_tail(&padata->list, &queue->parallel.list);
141        spin_unlock(&queue->parallel.lock);
142
143        queue_work_on(target_cpu, pinst->wq, &queue->work);
144
145out:
146        rcu_read_unlock_bh();
147
148        return err;
149}
150EXPORT_SYMBOL(padata_do_parallel);
151
152/*
153 * padata_get_next - Get the next object that needs serialization.
154 *
155 * Return values are:
156 *
157 * A pointer to the control struct of the next object that needs
158 * serialization, if present in one of the percpu reorder queues.
159 *
160 * NULL, if all percpu reorder queues are empty.
161 *
162 * -EINPROGRESS, if the next object that needs serialization will
163 *  be parallel processed by another cpu and is not yet present in
164 *  the cpu's reorder queue.
165 *
166 * -ENODATA, if this cpu has to do the parallel processing for
167 *  the next object.
168 */
169static struct padata_priv *padata_get_next(struct parallel_data *pd)
170{
171        int cpu, num_cpus;
172        unsigned int next_nr, next_index;
173        struct padata_parallel_queue *next_queue;
174        struct padata_priv *padata;
175        struct padata_list *reorder;
176
177        num_cpus = cpumask_weight(pd->cpumask.pcpu);
178
179        /*
180         * Calculate the percpu reorder queue and the sequence
181         * number of the next object.
182         */
183        next_nr = pd->processed;
184        next_index = next_nr % num_cpus;
185        cpu = padata_index_to_cpu(pd, next_index);
186        next_queue = per_cpu_ptr(pd->pqueue, cpu);
187
188        padata = NULL;
189
190        reorder = &next_queue->reorder;
191
192        spin_lock(&reorder->lock);
193        if (!list_empty(&reorder->list)) {
194                padata = list_entry(reorder->list.next,
195                                    struct padata_priv, list);
196
197                list_del_init(&padata->list);
198                atomic_dec(&pd->reorder_objects);
199
200                pd->processed++;
201
202                spin_unlock(&reorder->lock);
203                goto out;
204        }
205        spin_unlock(&reorder->lock);
206
207        if (__this_cpu_read(pd->pqueue->cpu_index) == next_queue->cpu_index) {
208                padata = ERR_PTR(-ENODATA);
209                goto out;
210        }
211
212        padata = ERR_PTR(-EINPROGRESS);
213out:
214        return padata;
215}
216
217static void padata_reorder(struct parallel_data *pd)
218{
219        int cb_cpu;
220        struct padata_priv *padata;
221        struct padata_serial_queue *squeue;
222        struct padata_instance *pinst = pd->pinst;
223
224        /*
225         * We need to ensure that only one cpu can work on dequeueing of
226         * the reorder queue the time. Calculating in which percpu reorder
227         * queue the next object will arrive takes some time. A spinlock
228         * would be highly contended. Also it is not clear in which order
229         * the objects arrive to the reorder queues. So a cpu could wait to
230         * get the lock just to notice that there is nothing to do at the
231         * moment. Therefore we use a trylock and let the holder of the lock
232         * care for all the objects enqueued during the holdtime of the lock.
233         */
234        if (!spin_trylock_bh(&pd->lock))
235                return;
236
237        while (1) {
238                padata = padata_get_next(pd);
239
240                /*
241                 * All reorder queues are empty, or the next object that needs
242                 * serialization is parallel processed by another cpu and is
243                 * still on it's way to the cpu's reorder queue, nothing to
244                 * do for now.
245                 */
246                if (!padata || PTR_ERR(padata) == -EINPROGRESS)
247                        break;
248
249                /*
250                 * This cpu has to do the parallel processing of the next
251                 * object. It's waiting in the cpu's parallelization queue,
252                 * so exit immediately.
253                 */
254                if (PTR_ERR(padata) == -ENODATA) {
255                        del_timer(&pd->timer);
256                        spin_unlock_bh(&pd->lock);
257                        return;
258                }
259
260                cb_cpu = padata->cb_cpu;
261                squeue = per_cpu_ptr(pd->squeue, cb_cpu);
262
263                spin_lock(&squeue->serial.lock);
264                list_add_tail(&padata->list, &squeue->serial.list);
265                spin_unlock(&squeue->serial.lock);
266
267                queue_work_on(cb_cpu, pinst->wq, &squeue->work);
268        }
269
270        spin_unlock_bh(&pd->lock);
271
272        /*
273         * The next object that needs serialization might have arrived to
274         * the reorder queues in the meantime, we will be called again
275         * from the timer function if no one else cares for it.
276         */
277        if (atomic_read(&pd->reorder_objects)
278                        && !(pinst->flags & PADATA_RESET))
279                mod_timer(&pd->timer, jiffies + HZ);
280        else
281                del_timer(&pd->timer);
282
283        return;
284}
285
286static void padata_reorder_timer(unsigned long arg)
287{
288        struct parallel_data *pd = (struct parallel_data *)arg;
289
290        padata_reorder(pd);
291}
292
293static void padata_serial_worker(struct work_struct *serial_work)
294{
295        struct padata_serial_queue *squeue;
296        struct parallel_data *pd;
297        LIST_HEAD(local_list);
298
299        local_bh_disable();
300        squeue = container_of(serial_work, struct padata_serial_queue, work);
301        pd = squeue->pd;
302
303        spin_lock(&squeue->serial.lock);
304        list_replace_init(&squeue->serial.list, &local_list);
305        spin_unlock(&squeue->serial.lock);
306
307        while (!list_empty(&local_list)) {
308                struct padata_priv *padata;
309
310                padata = list_entry(local_list.next,
311                                    struct padata_priv, list);
312
313                list_del_init(&padata->list);
314
315                padata->serial(padata);
316                atomic_dec(&pd->refcnt);
317        }
318        local_bh_enable();
319}
320
321/**
322 * padata_do_serial - padata serialization function
323 *
324 * @padata: object to be serialized.
325 *
326 * padata_do_serial must be called for every parallelized object.
327 * The serialization callback function will run with BHs off.
328 */
329void padata_do_serial(struct padata_priv *padata)
330{
331        int cpu;
332        struct padata_parallel_queue *pqueue;
333        struct parallel_data *pd;
334
335        pd = padata->pd;
336
337        cpu = get_cpu();
338        pqueue = per_cpu_ptr(pd->pqueue, cpu);
339
340        spin_lock(&pqueue->reorder.lock);
341        atomic_inc(&pd->reorder_objects);
342        list_add_tail(&padata->list, &pqueue->reorder.list);
343        spin_unlock(&pqueue->reorder.lock);
344
345        put_cpu();
346
347        padata_reorder(pd);
348}
349EXPORT_SYMBOL(padata_do_serial);
350
351static int padata_setup_cpumasks(struct parallel_data *pd,
352                                 const struct cpumask *pcpumask,
353                                 const struct cpumask *cbcpumask)
354{
355        if (!alloc_cpumask_var(&pd->cpumask.pcpu, GFP_KERNEL))
356                return -ENOMEM;
357
358        cpumask_and(pd->cpumask.pcpu, pcpumask, cpu_online_mask);
359        if (!alloc_cpumask_var(&pd->cpumask.cbcpu, GFP_KERNEL)) {
360                free_cpumask_var(pd->cpumask.cbcpu);
361                return -ENOMEM;
362        }
363
364        cpumask_and(pd->cpumask.cbcpu, cbcpumask, cpu_online_mask);
365        return 0;
366}
367
368static void __padata_list_init(struct padata_list *pd_list)
369{
370        INIT_LIST_HEAD(&pd_list->list);
371        spin_lock_init(&pd_list->lock);
372}
373
374/* Initialize all percpu queues used by serial workers */
375static void padata_init_squeues(struct parallel_data *pd)
376{
377        int cpu;
378        struct padata_serial_queue *squeue;
379
380        for_each_cpu(cpu, pd->cpumask.cbcpu) {
381                squeue = per_cpu_ptr(pd->squeue, cpu);
382                squeue->pd = pd;
383                __padata_list_init(&squeue->serial);
384                INIT_WORK(&squeue->work, padata_serial_worker);
385        }
386}
387
388/* Initialize all percpu queues used by parallel workers */
389static void padata_init_pqueues(struct parallel_data *pd)
390{
391        int cpu_index, cpu;
392        struct padata_parallel_queue *pqueue;
393
394        cpu_index = 0;
395        for_each_cpu(cpu, pd->cpumask.pcpu) {
396                pqueue = per_cpu_ptr(pd->pqueue, cpu);
397                pqueue->pd = pd;
398                pqueue->cpu_index = cpu_index;
399                cpu_index++;
400
401                __padata_list_init(&pqueue->reorder);
402                __padata_list_init(&pqueue->parallel);
403                INIT_WORK(&pqueue->work, padata_parallel_worker);
404                atomic_set(&pqueue->num_obj, 0);
405        }
406}
407
408/* Allocate and initialize the internal cpumask dependend resources. */
409static struct parallel_data *padata_alloc_pd(struct padata_instance *pinst,
410                                             const struct cpumask *pcpumask,
411                                             const struct cpumask *cbcpumask)
412{
413        struct parallel_data *pd;
414
415        pd = kzalloc(sizeof(struct parallel_data), GFP_KERNEL);
416        if (!pd)
417                goto err;
418
419        pd->pqueue = alloc_percpu(struct padata_parallel_queue);
420        if (!pd->pqueue)
421                goto err_free_pd;
422
423        pd->squeue = alloc_percpu(struct padata_serial_queue);
424        if (!pd->squeue)
425                goto err_free_pqueue;
426        if (padata_setup_cpumasks(pd, pcpumask, cbcpumask) < 0)
427                goto err_free_squeue;
428
429        padata_init_pqueues(pd);
430        padata_init_squeues(pd);
431        setup_timer(&pd->timer, padata_reorder_timer, (unsigned long)pd);
432        atomic_set(&pd->seq_nr, -1);
433        atomic_set(&pd->reorder_objects, 0);
434        atomic_set(&pd->refcnt, 0);
435        pd->pinst = pinst;
436        spin_lock_init(&pd->lock);
437
438        return pd;
439
440err_free_squeue:
441        free_percpu(pd->squeue);
442err_free_pqueue:
443        free_percpu(pd->pqueue);
444err_free_pd:
445        kfree(pd);
446err:
447        return NULL;
448}
449
450static void padata_free_pd(struct parallel_data *pd)
451{
452        free_cpumask_var(pd->cpumask.pcpu);
453        free_cpumask_var(pd->cpumask.cbcpu);
454        free_percpu(pd->pqueue);
455        free_percpu(pd->squeue);
456        kfree(pd);
457}
458
459/* Flush all objects out of the padata queues. */
460static void padata_flush_queues(struct parallel_data *pd)
461{
462        int cpu;
463        struct padata_parallel_queue *pqueue;
464        struct padata_serial_queue *squeue;
465
466        for_each_cpu(cpu, pd->cpumask.pcpu) {
467                pqueue = per_cpu_ptr(pd->pqueue, cpu);
468                flush_work(&pqueue->work);
469        }
470
471        del_timer_sync(&pd->timer);
472
473        if (atomic_read(&pd->reorder_objects))
474                padata_reorder(pd);
475
476        for_each_cpu(cpu, pd->cpumask.cbcpu) {
477                squeue = per_cpu_ptr(pd->squeue, cpu);
478                flush_work(&squeue->work);
479        }
480
481        BUG_ON(atomic_read(&pd->refcnt) != 0);
482}
483
484static void __padata_start(struct padata_instance *pinst)
485{
486        pinst->flags |= PADATA_INIT;
487}
488
489static void __padata_stop(struct padata_instance *pinst)
490{
491        if (!(pinst->flags & PADATA_INIT))
492                return;
493
494        pinst->flags &= ~PADATA_INIT;
495
496        synchronize_rcu();
497
498        get_online_cpus();
499        padata_flush_queues(pinst->pd);
500        put_online_cpus();
501}
502
503/* Replace the internal control structure with a new one. */
504static void padata_replace(struct padata_instance *pinst,
505                           struct parallel_data *pd_new)
506{
507        struct parallel_data *pd_old = pinst->pd;
508        int notification_mask = 0;
509
510        pinst->flags |= PADATA_RESET;
511
512        rcu_assign_pointer(pinst->pd, pd_new);
513
514        synchronize_rcu();
515
516        if (!cpumask_equal(pd_old->cpumask.pcpu, pd_new->cpumask.pcpu))
517                notification_mask |= PADATA_CPU_PARALLEL;
518        if (!cpumask_equal(pd_old->cpumask.cbcpu, pd_new->cpumask.cbcpu))
519                notification_mask |= PADATA_CPU_SERIAL;
520
521        padata_flush_queues(pd_old);
522        padata_free_pd(pd_old);
523
524        if (notification_mask)
525                blocking_notifier_call_chain(&pinst->cpumask_change_notifier,
526                                             notification_mask,
527                                             &pd_new->cpumask);
528
529        pinst->flags &= ~PADATA_RESET;
530}
531
532/**
533 * padata_register_cpumask_notifier - Registers a notifier that will be called
534 *                             if either pcpu or cbcpu or both cpumasks change.
535 *
536 * @pinst: A poineter to padata instance
537 * @nblock: A pointer to notifier block.
538 */
539int padata_register_cpumask_notifier(struct padata_instance *pinst,
540                                     struct notifier_block *nblock)
541{
542        return blocking_notifier_chain_register(&pinst->cpumask_change_notifier,
543                                                nblock);
544}
545EXPORT_SYMBOL(padata_register_cpumask_notifier);
546
547/**
548 * padata_unregister_cpumask_notifier - Unregisters cpumask notifier
549 *        registered earlier  using padata_register_cpumask_notifier
550 *
551 * @pinst: A pointer to data instance.
552 * @nlock: A pointer to notifier block.
553 */
554int padata_unregister_cpumask_notifier(struct padata_instance *pinst,
555                                       struct notifier_block *nblock)
556{
557        return blocking_notifier_chain_unregister(
558                &pinst->cpumask_change_notifier,
559                nblock);
560}
561EXPORT_SYMBOL(padata_unregister_cpumask_notifier);
562
563
564/* If cpumask contains no active cpu, we mark the instance as invalid. */
565static bool padata_validate_cpumask(struct padata_instance *pinst,
566                                    const struct cpumask *cpumask)
567{
568        if (!cpumask_intersects(cpumask, cpu_online_mask)) {
569                pinst->flags |= PADATA_INVALID;
570                return false;
571        }
572
573        pinst->flags &= ~PADATA_INVALID;
574        return true;
575}
576
577static int __padata_set_cpumasks(struct padata_instance *pinst,
578                                 cpumask_var_t pcpumask,
579                                 cpumask_var_t cbcpumask)
580{
581        int valid;
582        struct parallel_data *pd;
583
584        valid = padata_validate_cpumask(pinst, pcpumask);
585        if (!valid) {
586                __padata_stop(pinst);
587                goto out_replace;
588        }
589
590        valid = padata_validate_cpumask(pinst, cbcpumask);
591        if (!valid)
592                __padata_stop(pinst);
593
594out_replace:
595        pd = padata_alloc_pd(pinst, pcpumask, cbcpumask);
596        if (!pd)
597                return -ENOMEM;
598
599        cpumask_copy(pinst->cpumask.pcpu, pcpumask);
600        cpumask_copy(pinst->cpumask.cbcpu, cbcpumask);
601
602        padata_replace(pinst, pd);
603
604        if (valid)
605                __padata_start(pinst);
606
607        return 0;
608}
609
610/**
611 * padata_set_cpumasks - Set both parallel and serial cpumasks. The first
612 *                       one is used by parallel workers and the second one
613 *                       by the wokers doing serialization.
614 *
615 * @pinst: padata instance
616 * @pcpumask: the cpumask to use for parallel workers
617 * @cbcpumask: the cpumsak to use for serial workers
618 */
619int padata_set_cpumasks(struct padata_instance *pinst, cpumask_var_t pcpumask,
620                        cpumask_var_t cbcpumask)
621{
622        int err;
623
624        mutex_lock(&pinst->lock);
625        get_online_cpus();
626
627        err = __padata_set_cpumasks(pinst, pcpumask, cbcpumask);
628
629        put_online_cpus();
630        mutex_unlock(&pinst->lock);
631
632        return err;
633
634}
635EXPORT_SYMBOL(padata_set_cpumasks);
636
637/**
638 * padata_set_cpumask: Sets specified by @cpumask_type cpumask to the value
639 *                     equivalent to @cpumask.
640 *
641 * @pinst: padata instance
642 * @cpumask_type: PADATA_CPU_SERIAL or PADATA_CPU_PARALLEL corresponding
643 *                to parallel and serial cpumasks respectively.
644 * @cpumask: the cpumask to use
645 */
646int padata_set_cpumask(struct padata_instance *pinst, int cpumask_type,
647                       cpumask_var_t cpumask)
648{
649        struct cpumask *serial_mask, *parallel_mask;
650        int err = -EINVAL;
651
652        mutex_lock(&pinst->lock);
653        get_online_cpus();
654
655        switch (cpumask_type) {
656        case PADATA_CPU_PARALLEL:
657                serial_mask = pinst->cpumask.cbcpu;
658                parallel_mask = cpumask;
659                break;
660        case PADATA_CPU_SERIAL:
661                parallel_mask = pinst->cpumask.pcpu;
662                serial_mask = cpumask;
663                break;
664        default:
665                 goto out;
666        }
667
668        err =  __padata_set_cpumasks(pinst, parallel_mask, serial_mask);
669
670out:
671        put_online_cpus();
672        mutex_unlock(&pinst->lock);
673
674        return err;
675}
676EXPORT_SYMBOL(padata_set_cpumask);
677
678static int __padata_add_cpu(struct padata_instance *pinst, int cpu)
679{
680        struct parallel_data *pd;
681
682        if (cpumask_test_cpu(cpu, cpu_online_mask)) {
683                pd = padata_alloc_pd(pinst, pinst->cpumask.pcpu,
684                                     pinst->cpumask.cbcpu);
685                if (!pd)
686                        return -ENOMEM;
687
688                padata_replace(pinst, pd);
689
690                if (padata_validate_cpumask(pinst, pinst->cpumask.pcpu) &&
691                    padata_validate_cpumask(pinst, pinst->cpumask.cbcpu))
692                        __padata_start(pinst);
693        }
694
695        return 0;
696}
697
698 /**
699 * padata_add_cpu - add a cpu to one or both(parallel and serial)
700 *                  padata cpumasks.
701 *
702 * @pinst: padata instance
703 * @cpu: cpu to add
704 * @mask: bitmask of flags specifying to which cpumask @cpu shuld be added.
705 *        The @mask may be any combination of the following flags:
706 *          PADATA_CPU_SERIAL   - serial cpumask
707 *          PADATA_CPU_PARALLEL - parallel cpumask
708 */
709
710int padata_add_cpu(struct padata_instance *pinst, int cpu, int mask)
711{
712        int err;
713
714        if (!(mask & (PADATA_CPU_SERIAL | PADATA_CPU_PARALLEL)))
715                return -EINVAL;
716
717        mutex_lock(&pinst->lock);
718
719        get_online_cpus();
720        if (mask & PADATA_CPU_SERIAL)
721                cpumask_set_cpu(cpu, pinst->cpumask.cbcpu);
722        if (mask & PADATA_CPU_PARALLEL)
723                cpumask_set_cpu(cpu, pinst->cpumask.pcpu);
724
725        err = __padata_add_cpu(pinst, cpu);
726        put_online_cpus();
727
728        mutex_unlock(&pinst->lock);
729
730        return err;
731}
732EXPORT_SYMBOL(padata_add_cpu);
733
734static int __padata_remove_cpu(struct padata_instance *pinst, int cpu)
735{
736        struct parallel_data *pd = NULL;
737
738        if (cpumask_test_cpu(cpu, cpu_online_mask)) {
739
740                if (!padata_validate_cpumask(pinst, pinst->cpumask.pcpu) ||
741                    !padata_validate_cpumask(pinst, pinst->cpumask.cbcpu))
742                        __padata_stop(pinst);
743
744                pd = padata_alloc_pd(pinst, pinst->cpumask.pcpu,
745                                     pinst->cpumask.cbcpu);
746                if (!pd)
747                        return -ENOMEM;
748
749                padata_replace(pinst, pd);
750
751                cpumask_clear_cpu(cpu, pd->cpumask.cbcpu);
752                cpumask_clear_cpu(cpu, pd->cpumask.pcpu);
753        }
754
755        return 0;
756}
757
758 /**
759 * padata_remove_cpu - remove a cpu from the one or both(serial and parallel)
760 *                     padata cpumasks.
761 *
762 * @pinst: padata instance
763 * @cpu: cpu to remove
764 * @mask: bitmask specifying from which cpumask @cpu should be removed
765 *        The @mask may be any combination of the following flags:
766 *          PADATA_CPU_SERIAL   - serial cpumask
767 *          PADATA_CPU_PARALLEL - parallel cpumask
768 */
769int padata_remove_cpu(struct padata_instance *pinst, int cpu, int mask)
770{
771        int err;
772
773        if (!(mask & (PADATA_CPU_SERIAL | PADATA_CPU_PARALLEL)))
774                return -EINVAL;
775
776        mutex_lock(&pinst->lock);
777
778        get_online_cpus();
779        if (mask & PADATA_CPU_SERIAL)
780                cpumask_clear_cpu(cpu, pinst->cpumask.cbcpu);
781        if (mask & PADATA_CPU_PARALLEL)
782                cpumask_clear_cpu(cpu, pinst->cpumask.pcpu);
783
784        err = __padata_remove_cpu(pinst, cpu);
785        put_online_cpus();
786
787        mutex_unlock(&pinst->lock);
788
789        return err;
790}
791EXPORT_SYMBOL(padata_remove_cpu);
792
793/**
794 * padata_start - start the parallel processing
795 *
796 * @pinst: padata instance to start
797 */
798int padata_start(struct padata_instance *pinst)
799{
800        int err = 0;
801
802        mutex_lock(&pinst->lock);
803
804        if (pinst->flags & PADATA_INVALID)
805                err =-EINVAL;
806
807         __padata_start(pinst);
808
809        mutex_unlock(&pinst->lock);
810
811        return err;
812}
813EXPORT_SYMBOL(padata_start);
814
815/**
816 * padata_stop - stop the parallel processing
817 *
818 * @pinst: padata instance to stop
819 */
820void padata_stop(struct padata_instance *pinst)
821{
822        mutex_lock(&pinst->lock);
823        __padata_stop(pinst);
824        mutex_unlock(&pinst->lock);
825}
826EXPORT_SYMBOL(padata_stop);
827
828#ifdef CONFIG_HOTPLUG_CPU
829
830static inline int pinst_has_cpu(struct padata_instance *pinst, int cpu)
831{
832        return cpumask_test_cpu(cpu, pinst->cpumask.pcpu) ||
833                cpumask_test_cpu(cpu, pinst->cpumask.cbcpu);
834}
835
836
837static int padata_cpu_callback(struct notifier_block *nfb,
838                               unsigned long action, void *hcpu)
839{
840        int err;
841        struct padata_instance *pinst;
842        int cpu = (unsigned long)hcpu;
843
844        pinst = container_of(nfb, struct padata_instance, cpu_notifier);
845
846        switch (action) {
847        case CPU_ONLINE:
848        case CPU_ONLINE_FROZEN:
849        case CPU_DOWN_FAILED:
850        case CPU_DOWN_FAILED_FROZEN:
851                if (!pinst_has_cpu(pinst, cpu))
852                        break;
853                mutex_lock(&pinst->lock);
854                err = __padata_add_cpu(pinst, cpu);
855                mutex_unlock(&pinst->lock);
856                if (err)
857                        return notifier_from_errno(err);
858                break;
859
860        case CPU_DOWN_PREPARE:
861        case CPU_DOWN_PREPARE_FROZEN:
862        case CPU_UP_CANCELED:
863        case CPU_UP_CANCELED_FROZEN:
864                if (!pinst_has_cpu(pinst, cpu))
865                        break;
866                mutex_lock(&pinst->lock);
867                err = __padata_remove_cpu(pinst, cpu);
868                mutex_unlock(&pinst->lock);
869                if (err)
870                        return notifier_from_errno(err);
871                break;
872        }
873
874        return NOTIFY_OK;
875}
876#endif
877
878static void __padata_free(struct padata_instance *pinst)
879{
880#ifdef CONFIG_HOTPLUG_CPU
881        unregister_hotcpu_notifier(&pinst->cpu_notifier);
882#endif
883
884        padata_stop(pinst);
885        padata_free_pd(pinst->pd);
886        free_cpumask_var(pinst->cpumask.pcpu);
887        free_cpumask_var(pinst->cpumask.cbcpu);
888        kfree(pinst);
889}
890
891#define kobj2pinst(_kobj)                                       \
892        container_of(_kobj, struct padata_instance, kobj)
893#define attr2pentry(_attr)                                      \
894        container_of(_attr, struct padata_sysfs_entry, attr)
895
896static void padata_sysfs_release(struct kobject *kobj)
897{
898        struct padata_instance *pinst = kobj2pinst(kobj);
899        __padata_free(pinst);
900}
901
902struct padata_sysfs_entry {
903        struct attribute attr;
904        ssize_t (*show)(struct padata_instance *, struct attribute *, char *);
905        ssize_t (*store)(struct padata_instance *, struct attribute *,
906                         const char *, size_t);
907};
908
909static ssize_t show_cpumask(struct padata_instance *pinst,
910                            struct attribute *attr,  char *buf)
911{
912        struct cpumask *cpumask;
913        ssize_t len;
914
915        mutex_lock(&pinst->lock);
916        if (!strcmp(attr->name, "serial_cpumask"))
917                cpumask = pinst->cpumask.cbcpu;
918        else
919                cpumask = pinst->cpumask.pcpu;
920
921        len = bitmap_scnprintf(buf, PAGE_SIZE, cpumask_bits(cpumask),
922                               nr_cpu_ids);
923        if (PAGE_SIZE - len < 2)
924                len = -EINVAL;
925        else
926                len += sprintf(buf + len, "\n");
927
928        mutex_unlock(&pinst->lock);
929        return len;
930}
931
932static ssize_t store_cpumask(struct padata_instance *pinst,
933                             struct attribute *attr,
934                             const char *buf, size_t count)
935{
936        cpumask_var_t new_cpumask;
937        ssize_t ret;
938        int mask_type;
939
940        if (!alloc_cpumask_var(&new_cpumask, GFP_KERNEL))
941                return -ENOMEM;
942
943        ret = bitmap_parse(buf, count, cpumask_bits(new_cpumask),
944                           nr_cpumask_bits);
945        if (ret < 0)
946                goto out;
947
948        mask_type = !strcmp(attr->name, "serial_cpumask") ?
949                PADATA_CPU_SERIAL : PADATA_CPU_PARALLEL;
950        ret = padata_set_cpumask(pinst, mask_type, new_cpumask);
951        if (!ret)
952                ret = count;
953
954out:
955        free_cpumask_var(new_cpumask);
956        return ret;
957}
958
959#define PADATA_ATTR_RW(_name, _show_name, _store_name)          \
960        static struct padata_sysfs_entry _name##_attr =         \
961                __ATTR(_name, 0644, _show_name, _store_name)
962#define PADATA_ATTR_RO(_name, _show_name)               \
963        static struct padata_sysfs_entry _name##_attr = \
964                __ATTR(_name, 0400, _show_name, NULL)
965
966PADATA_ATTR_RW(serial_cpumask, show_cpumask, store_cpumask);
967PADATA_ATTR_RW(parallel_cpumask, show_cpumask, store_cpumask);
968
969/*
970 * Padata sysfs provides the following objects:
971 * serial_cpumask   [RW] - cpumask for serial workers
972 * parallel_cpumask [RW] - cpumask for parallel workers
973 */
974static struct attribute *padata_default_attrs[] = {
975        &serial_cpumask_attr.attr,
976        &parallel_cpumask_attr.attr,
977        NULL,
978};
979
980static ssize_t padata_sysfs_show(struct kobject *kobj,
981                                 struct attribute *attr, char *buf)
982{
983        struct padata_instance *pinst;
984        struct padata_sysfs_entry *pentry;
985        ssize_t ret = -EIO;
986
987        pinst = kobj2pinst(kobj);
988        pentry = attr2pentry(attr);
989        if (pentry->show)
990                ret = pentry->show(pinst, attr, buf);
991
992        return ret;
993}
994
995static ssize_t padata_sysfs_store(struct kobject *kobj, struct attribute *attr,
996                                  const char *buf, size_t count)
997{
998        struct padata_instance *pinst;
999        struct padata_sysfs_entry *pentry;
1000        ssize_t ret = -EIO;
1001
1002        pinst = kobj2pinst(kobj);
1003        pentry = attr2pentry(attr);
1004        if (pentry->show)
1005                ret = pentry->store(pinst, attr, buf, count);
1006
1007        return ret;
1008}
1009
1010static const struct sysfs_ops padata_sysfs_ops = {
1011        .show = padata_sysfs_show,
1012        .store = padata_sysfs_store,
1013};
1014
1015static struct kobj_type padata_attr_type = {
1016        .sysfs_ops = &padata_sysfs_ops,
1017        .default_attrs = padata_default_attrs,
1018        .release = padata_sysfs_release,
1019};
1020
1021/**
1022 * padata_alloc_possible - Allocate and initialize padata instance.
1023 *                         Use the cpu_possible_mask for serial and
1024 *                         parallel workers.
1025 *
1026 * @wq: workqueue to use for the allocated padata instance
1027 */
1028struct padata_instance *padata_alloc_possible(struct workqueue_struct *wq)
1029{
1030        return padata_alloc(wq, cpu_possible_mask, cpu_possible_mask);
1031}
1032EXPORT_SYMBOL(padata_alloc_possible);
1033
1034/**
1035 * padata_alloc - allocate and initialize a padata instance and specify
1036 *                cpumasks for serial and parallel workers.
1037 *
1038 * @wq: workqueue to use for the allocated padata instance
1039 * @pcpumask: cpumask that will be used for padata parallelization
1040 * @cbcpumask: cpumask that will be used for padata serialization
1041 */
1042struct padata_instance *padata_alloc(struct workqueue_struct *wq,
1043                                     const struct cpumask *pcpumask,
1044                                     const struct cpumask *cbcpumask)
1045{
1046        struct padata_instance *pinst;
1047        struct parallel_data *pd = NULL;
1048
1049        pinst = kzalloc(sizeof(struct padata_instance), GFP_KERNEL);
1050        if (!pinst)
1051                goto err;
1052
1053        get_online_cpus();
1054        if (!alloc_cpumask_var(&pinst->cpumask.pcpu, GFP_KERNEL))
1055                goto err_free_inst;
1056        if (!alloc_cpumask_var(&pinst->cpumask.cbcpu, GFP_KERNEL)) {
1057                free_cpumask_var(pinst->cpumask.pcpu);
1058                goto err_free_inst;
1059        }
1060        if (!padata_validate_cpumask(pinst, pcpumask) ||
1061            !padata_validate_cpumask(pinst, cbcpumask))
1062                goto err_free_masks;
1063
1064        pd = padata_alloc_pd(pinst, pcpumask, cbcpumask);
1065        if (!pd)
1066                goto err_free_masks;
1067
1068        rcu_assign_pointer(pinst->pd, pd);
1069
1070        pinst->wq = wq;
1071
1072        cpumask_copy(pinst->cpumask.pcpu, pcpumask);
1073        cpumask_copy(pinst->cpumask.cbcpu, cbcpumask);
1074
1075        pinst->flags = 0;
1076
1077        put_online_cpus();
1078
1079        BLOCKING_INIT_NOTIFIER_HEAD(&pinst->cpumask_change_notifier);
1080        kobject_init(&pinst->kobj, &padata_attr_type);
1081        mutex_init(&pinst->lock);
1082
1083#ifdef CONFIG_HOTPLUG_CPU
1084        pinst->cpu_notifier.notifier_call = padata_cpu_callback;
1085        pinst->cpu_notifier.priority = 0;
1086        register_hotcpu_notifier(&pinst->cpu_notifier);
1087#endif
1088
1089        return pinst;
1090
1091err_free_masks:
1092        free_cpumask_var(pinst->cpumask.pcpu);
1093        free_cpumask_var(pinst->cpumask.cbcpu);
1094err_free_inst:
1095        kfree(pinst);
1096        put_online_cpus();
1097err:
1098        return NULL;
1099}
1100EXPORT_SYMBOL(padata_alloc);
1101
1102/**
1103 * padata_free - free a padata instance
1104 *
1105 * @padata_inst: padata instance to free
1106 */
1107void padata_free(struct padata_instance *pinst)
1108{
1109        kobject_put(&pinst->kobj);
1110}
1111EXPORT_SYMBOL(padata_free);
Note: See TracBrowser for help on using the repository browser.