Lines Matching refs:pinst
66 struct padata_instance *pinst;
73 pinst = pd->pinst;
96 * @pinst: padata instance
105 int padata_do_parallel(struct padata_instance *pinst,
114 pd = rcu_dereference(pinst->pd);
117 if (!(pinst->flags & PADATA_INIT) || pinst->flags & PADATA_INVALID)
124 if ((pinst->flags & PADATA_RESET))
147 queue_work_on(target_cpu, pinst->wq, &queue->work);
235 struct padata_instance *pinst = pd->pinst;
279 queue_work_on(padata->cb_cpu, pinst->wq, &squeue->work);
290 && !(pinst->flags & PADATA_RESET))
424 static struct parallel_data *padata_alloc_pd(struct padata_instance *pinst,
450 pd->pinst = pinst;
499 static void __padata_start(struct padata_instance *pinst)
501 pinst->flags |= PADATA_INIT;
504 static void __padata_stop(struct padata_instance *pinst)
506 if (!(pinst->flags & PADATA_INIT))
509 pinst->flags &= ~PADATA_INIT;
514 padata_flush_queues(pinst->pd);
519 static void padata_replace(struct padata_instance *pinst,
522 struct parallel_data *pd_old = pinst->pd;
525 pinst->flags |= PADATA_RESET;
527 rcu_assign_pointer(pinst->pd, pd_new);
540 blocking_notifier_call_chain(&pinst->cpumask_change_notifier,
544 pinst->flags &= ~PADATA_RESET;
551 * @pinst: A poineter to padata instance
554 int padata_register_cpumask_notifier(struct padata_instance *pinst,
557 return blocking_notifier_chain_register(&pinst->cpumask_change_notifier,
566 * @pinst: A pointer to data instance.
569 int padata_unregister_cpumask_notifier(struct padata_instance *pinst,
573 &pinst->cpumask_change_notifier,
580 static bool padata_validate_cpumask(struct padata_instance *pinst,
584 pinst->flags |= PADATA_INVALID;
588 pinst->flags &= ~PADATA_INVALID;
592 static int __padata_set_cpumasks(struct padata_instance *pinst,
599 valid = padata_validate_cpumask(pinst, pcpumask);
601 __padata_stop(pinst);
605 valid = padata_validate_cpumask(pinst, cbcpumask);
607 __padata_stop(pinst);
610 pd = padata_alloc_pd(pinst, pcpumask, cbcpumask);
614 cpumask_copy(pinst->cpumask.pcpu, pcpumask);
615 cpumask_copy(pinst->cpumask.cbcpu, cbcpumask);
617 padata_replace(pinst, pd);
620 __padata_start(pinst);
630 * @pinst: padata instance
634 int padata_set_cpumasks(struct padata_instance *pinst, cpumask_var_t pcpumask,
639 mutex_lock(&pinst->lock);
642 err = __padata_set_cpumasks(pinst, pcpumask, cbcpumask);
645 mutex_unlock(&pinst->lock);
656 * @pinst: padata instance
661 int padata_set_cpumask(struct padata_instance *pinst, int cpumask_type,
667 mutex_lock(&pinst->lock);
672 serial_mask = pinst->cpumask.cbcpu;
676 parallel_mask = pinst->cpumask.pcpu;
683 err = __padata_set_cpumasks(pinst, parallel_mask, serial_mask);
687 mutex_unlock(&pinst->lock);
693 static int __padata_add_cpu(struct padata_instance *pinst, int cpu)
698 pd = padata_alloc_pd(pinst, pinst->cpumask.pcpu,
699 pinst->cpumask.cbcpu);
703 padata_replace(pinst, pd);
705 if (padata_validate_cpumask(pinst, pinst->cpumask.pcpu) &&
706 padata_validate_cpumask(pinst, pinst->cpumask.cbcpu))
707 __padata_start(pinst);
717 * @pinst: padata instance
725 int padata_add_cpu(struct padata_instance *pinst, int cpu, int mask)
732 mutex_lock(&pinst->lock);
736 cpumask_set_cpu(cpu, pinst->cpumask.cbcpu);
738 cpumask_set_cpu(cpu, pinst->cpumask.pcpu);
740 err = __padata_add_cpu(pinst, cpu);
743 mutex_unlock(&pinst->lock);
749 static int __padata_remove_cpu(struct padata_instance *pinst, int cpu)
755 if (!padata_validate_cpumask(pinst, pinst->cpumask.pcpu) ||
756 !padata_validate_cpumask(pinst, pinst->cpumask.cbcpu))
757 __padata_stop(pinst);
759 pd = padata_alloc_pd(pinst, pinst->cpumask.pcpu,
760 pinst->cpumask.cbcpu);
764 padata_replace(pinst, pd);
774 * @pinst: padata instance
781 int padata_remove_cpu(struct padata_instance *pinst, int cpu, int mask)
788 mutex_lock(&pinst->lock);
792 cpumask_clear_cpu(cpu, pinst->cpumask.cbcpu);
794 cpumask_clear_cpu(cpu, pinst->cpumask.pcpu);
796 err = __padata_remove_cpu(pinst, cpu);
799 mutex_unlock(&pinst->lock);
808 * @pinst: padata instance to start
810 int padata_start(struct padata_instance *pinst)
814 mutex_lock(&pinst->lock);
816 if (pinst->flags & PADATA_INVALID)
819 __padata_start(pinst);
821 mutex_unlock(&pinst->lock);
830 * @pinst: padata instance to stop
832 void padata_stop(struct padata_instance *pinst)
834 mutex_lock(&pinst->lock);
835 __padata_stop(pinst);
836 mutex_unlock(&pinst->lock);
842 static inline int pinst_has_cpu(struct padata_instance *pinst, int cpu)
844 return cpumask_test_cpu(cpu, pinst->cpumask.pcpu) ||
845 cpumask_test_cpu(cpu, pinst->cpumask.cbcpu);
853 struct padata_instance *pinst;
856 pinst = container_of(nfb, struct padata_instance, cpu_notifier);
861 if (!pinst_has_cpu(pinst, cpu))
863 mutex_lock(&pinst->lock);
864 err = __padata_add_cpu(pinst, cpu);
865 mutex_unlock(&pinst->lock);
872 if (!pinst_has_cpu(pinst, cpu))
874 mutex_lock(&pinst->lock);
875 err = __padata_remove_cpu(pinst, cpu);
876 mutex_unlock(&pinst->lock);
883 if (!pinst_has_cpu(pinst, cpu))
885 mutex_lock(&pinst->lock);
886 __padata_remove_cpu(pinst, cpu);
887 mutex_unlock(&pinst->lock);
891 if (!pinst_has_cpu(pinst, cpu))
893 mutex_lock(&pinst->lock);
894 __padata_add_cpu(pinst, cpu);
895 mutex_unlock(&pinst->lock);
902 static void __padata_free(struct padata_instance *pinst)
905 unregister_hotcpu_notifier(&pinst->cpu_notifier);
908 padata_stop(pinst);
909 padata_free_pd(pinst->pd);
910 free_cpumask_var(pinst->cpumask.pcpu);
911 free_cpumask_var(pinst->cpumask.cbcpu);
912 kfree(pinst);
922 struct padata_instance *pinst = kobj2pinst(kobj);
923 __padata_free(pinst);
933 static ssize_t show_cpumask(struct padata_instance *pinst,
939 mutex_lock(&pinst->lock);
941 cpumask = pinst->cpumask.cbcpu;
943 cpumask = pinst->cpumask.pcpu;
952 mutex_unlock(&pinst->lock);
956 static ssize_t store_cpumask(struct padata_instance *pinst,
974 ret = padata_set_cpumask(pinst, mask_type, new_cpumask);
1007 struct padata_instance *pinst;
1011 pinst = kobj2pinst(kobj);
1014 ret = pentry->show(pinst, attr, buf);
1022 struct padata_instance *pinst;
1026 pinst = kobj2pinst(kobj);
1029 ret = pentry->store(pinst, attr, buf, count);
1070 struct padata_instance *pinst;
1073 pinst = kzalloc(sizeof(struct padata_instance), GFP_KERNEL);
1074 if (!pinst)
1078 if (!alloc_cpumask_var(&pinst->cpumask.pcpu, GFP_KERNEL))
1080 if (!alloc_cpumask_var(&pinst->cpumask.cbcpu, GFP_KERNEL)) {
1081 free_cpumask_var(pinst->cpumask.pcpu);
1084 if (!padata_validate_cpumask(pinst, pcpumask) ||
1085 !padata_validate_cpumask(pinst, cbcpumask))
1088 pd = padata_alloc_pd(pinst, pcpumask, cbcpumask);
1092 rcu_assign_pointer(pinst->pd, pd);
1094 pinst->wq = wq;
1096 cpumask_copy(pinst->cpumask.pcpu, pcpumask);
1097 cpumask_copy(pinst->cpumask.cbcpu, cbcpumask);
1099 pinst->flags = 0;
1102 pinst->cpu_notifier.notifier_call = padata_cpu_callback;
1103 pinst->cpu_notifier.priority = 0;
1104 register_hotcpu_notifier(&pinst->cpu_notifier);
1109 BLOCKING_INIT_NOTIFIER_HEAD(&pinst->cpumask_change_notifier);
1110 kobject_init(&pinst->kobj, &padata_attr_type);
1111 mutex_init(&pinst->lock);
1113 return pinst;
1116 free_cpumask_var(pinst->cpumask.pcpu);
1117 free_cpumask_var(pinst->cpumask.cbcpu);
1119 kfree(pinst);
1131 void padata_free(struct padata_instance *pinst)
1133 kobject_put(&pinst->kobj);