1 /* 2 * padata.h - header for the padata parallelization interface 3 * 4 * Copyright (C) 2008, 2009 secunet Security Networks AG 5 * Copyright (C) 2008, 2009 Steffen Klassert <steffen.klassert@secunet.com> 6 * 7 * This program is free software; you can redistribute it and/or modify it 8 * under the terms and conditions of the GNU General Public License, 9 * version 2, as published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 14 * more details. 15 * 16 * You should have received a copy of the GNU General Public License along with 17 * this program; if not, write to the Free Software Foundation, Inc., 18 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. 19 */ 20 21 #ifndef PADATA_H 22 #define PADATA_H 23 24 #include <linux/workqueue.h> 25 #include <linux/spinlock.h> 26 #include <linux/list.h> 27 #include <linux/timer.h> 28 #include <linux/notifier.h> 29 #include <linux/kobject.h> 30 31 #define PADATA_CPU_SERIAL 0x01 32 #define PADATA_CPU_PARALLEL 0x02 33 34 /** 35 * struct padata_priv - Embedded to the users data structure. 36 * 37 * @list: List entry, to attach to the padata lists. 38 * @pd: Pointer to the internal control structure. 39 * @cb_cpu: Callback cpu for serializatioon. 40 * @cpu: Cpu for parallelization. 41 * @seq_nr: Sequence number of the parallelized data object. 42 * @info: Used to pass information from the parallel to the serial function. 43 * @parallel: Parallel execution function. 44 * @serial: Serial complete function. 45 */ 46 struct padata_priv { 47 struct list_head list; 48 struct parallel_data *pd; 49 int cb_cpu; 50 int cpu; 51 int info; 52 void (*parallel)(struct padata_priv *padata); 53 void (*serial)(struct padata_priv *padata); 54 }; 55 56 /** 57 * struct padata_list 58 * 59 * @list: List head. 60 * @lock: List lock. 61 */ 62 struct padata_list { 63 struct list_head list; 64 spinlock_t lock; 65 }; 66 67 /** 68 * struct padata_serial_queue - The percpu padata serial queue 69 * 70 * @serial: List to wait for serialization after reordering. 71 * @work: work struct for serialization. 72 * @pd: Backpointer to the internal control structure. 73 */ 74 struct padata_serial_queue { 75 struct padata_list serial; 76 struct work_struct work; 77 struct parallel_data *pd; 78 }; 79 80 /** 81 * struct padata_parallel_queue - The percpu padata parallel queue 82 * 83 * @parallel: List to wait for parallelization. 84 * @reorder: List to wait for reordering after parallel processing. 85 * @serial: List to wait for serialization after reordering. 86 * @pwork: work struct for parallelization. 87 * @swork: work struct for serialization. 88 * @pd: Backpointer to the internal control structure. 89 * @work: work struct for parallelization. 90 * @reorder_work: work struct for reordering. 91 * @num_obj: Number of objects that are processed by this cpu. 92 * @cpu_index: Index of the cpu. 93 */ 94 struct padata_parallel_queue { 95 struct padata_list parallel; 96 struct padata_list reorder; 97 struct parallel_data *pd; 98 struct work_struct work; 99 struct work_struct reorder_work; 100 atomic_t num_obj; 101 int cpu_index; 102 }; 103 104 /** 105 * struct padata_cpumask - The cpumasks for the parallel/serial workers 106 * 107 * @pcpu: cpumask for the parallel workers. 108 * @cbcpu: cpumask for the serial (callback) workers. 109 */ 110 struct padata_cpumask { 111 cpumask_var_t pcpu; 112 cpumask_var_t cbcpu; 113 }; 114 115 /** 116 * struct parallel_data - Internal control structure, covers everything 117 * that depends on the cpumask in use. 118 * 119 * @pinst: padata instance. 120 * @pqueue: percpu padata queues used for parallelization. 121 * @squeue: percpu padata queues used for serialuzation. 122 * @reorder_objects: Number of objects waiting in the reorder queues. 123 * @refcnt: Number of objects holding a reference on this parallel_data. 124 * @max_seq_nr: Maximal used sequence number. 125 * @cpumask: The cpumasks in use for parallel and serial workers. 126 * @lock: Reorder lock. 127 * @processed: Number of already processed objects. 128 * @timer: Reorder timer. 129 */ 130 struct parallel_data { 131 struct padata_instance *pinst; 132 struct padata_parallel_queue __percpu *pqueue; 133 struct padata_serial_queue __percpu *squeue; 134 atomic_t reorder_objects; 135 atomic_t refcnt; 136 atomic_t seq_nr; 137 struct padata_cpumask cpumask; 138 spinlock_t lock ____cacheline_aligned; 139 unsigned int processed; 140 struct timer_list timer; 141 }; 142 143 /** 144 * struct padata_instance - The overall control structure. 145 * 146 * @cpu_notifier: cpu hotplug notifier. 147 * @wq: The workqueue in use. 148 * @pd: The internal control structure. 149 * @cpumask: User supplied cpumasks for parallel and serial works. 150 * @cpumask_change_notifier: Notifiers chain for user-defined notify 151 * callbacks that will be called when either @pcpu or @cbcpu 152 * or both cpumasks change. 153 * @kobj: padata instance kernel object. 154 * @lock: padata instance lock. 155 * @flags: padata flags. 156 */ 157 struct padata_instance { 158 struct hlist_node node; 159 struct workqueue_struct *wq; 160 struct parallel_data *pd; 161 struct padata_cpumask cpumask; 162 struct blocking_notifier_head cpumask_change_notifier; 163 struct kobject kobj; 164 struct mutex lock; 165 u8 flags; 166 #define PADATA_INIT 1 167 #define PADATA_RESET 2 168 #define PADATA_INVALID 4 169 }; 170 171 extern struct padata_instance *padata_alloc_possible( 172 struct workqueue_struct *wq); 173 extern void padata_free(struct padata_instance *pinst); 174 extern int padata_do_parallel(struct padata_instance *pinst, 175 struct padata_priv *padata, int cb_cpu); 176 extern void padata_do_serial(struct padata_priv *padata); 177 extern int padata_set_cpumask(struct padata_instance *pinst, int cpumask_type, 178 cpumask_var_t cpumask); 179 extern int padata_start(struct padata_instance *pinst); 180 extern void padata_stop(struct padata_instance *pinst); 181 extern int padata_register_cpumask_notifier(struct padata_instance *pinst, 182 struct notifier_block *nblock); 183 extern int padata_unregister_cpumask_notifier(struct padata_instance *pinst, 184 struct notifier_block *nblock); 185 #endif 186