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  * @seq_nr: Sequence number of the parallelized data object.
41  * @info: Used to pass information from the parallel to the serial function.
42  * @parallel: Parallel execution function.
43  * @serial: Serial complete function.
44  */
45 struct padata_priv {
46 	struct list_head	list;
47 	struct parallel_data	*pd;
48 	int			cb_cpu;
49 	int			seq_nr;
50 	int			info;
51 	void                    (*parallel)(struct padata_priv *padata);
52 	void                    (*serial)(struct padata_priv *padata);
53 };
54 
55 /**
56  * struct padata_list
57  *
58  * @list: List head.
59  * @lock: List lock.
60  */
61 struct padata_list {
62 	struct list_head        list;
63 	spinlock_t              lock;
64 };
65 
66 /**
67 * struct padata_serial_queue - The percpu padata serial queue
68 *
69 * @serial: List to wait for serialization after reordering.
70 * @work: work struct for serialization.
71 * @pd: Backpointer to the internal control structure.
72 */
73 struct padata_serial_queue {
74        struct padata_list    serial;
75        struct work_struct    work;
76        struct parallel_data *pd;
77 };
78 
79 /**
80  * struct padata_parallel_queue - The percpu padata parallel queue
81  *
82  * @parallel: List to wait for parallelization.
83  * @reorder: List to wait for reordering after parallel processing.
84  * @serial: List to wait for serialization after reordering.
85  * @pwork: work struct for parallelization.
86  * @swork: work struct for serialization.
87  * @pd: Backpointer to the internal control structure.
88  * @work: work struct for parallelization.
89  * @num_obj: Number of objects that are processed by this cpu.
90  * @cpu_index: Index of the cpu.
91  */
92 struct padata_parallel_queue {
93        struct padata_list    parallel;
94        struct padata_list    reorder;
95        struct parallel_data *pd;
96        struct work_struct    work;
97        atomic_t              num_obj;
98        int                   cpu_index;
99 };
100 
101 /**
102  * struct padata_cpumask - The cpumasks for the parallel/serial workers
103  *
104  * @pcpu: cpumask for the parallel workers.
105  * @cbcpu: cpumask for the serial (callback) workers.
106  */
107 struct padata_cpumask {
108 	cpumask_var_t	pcpu;
109 	cpumask_var_t	cbcpu;
110 };
111 
112 /**
113  * struct parallel_data - Internal control structure, covers everything
114  * that depends on the cpumask in use.
115  *
116  * @pinst: padata instance.
117  * @pqueue: percpu padata queues used for parallelization.
118  * @squeue: percpu padata queues used for serialuzation.
119  * @seq_nr: The sequence number that will be attached to the next object.
120  * @reorder_objects: Number of objects waiting in the reorder queues.
121  * @refcnt: Number of objects holding a reference on this parallel_data.
122  * @max_seq_nr:  Maximal used sequence number.
123  * @cpumask: The cpumasks in use for parallel and serial workers.
124  * @lock: Reorder lock.
125  * @processed: Number of already processed objects.
126  * @timer: Reorder timer.
127  */
128 struct parallel_data {
129 	struct padata_instance		*pinst;
130 	struct padata_parallel_queue	__percpu *pqueue;
131 	struct padata_serial_queue	__percpu *squeue;
132 	atomic_t			seq_nr;
133 	atomic_t			reorder_objects;
134 	atomic_t			refcnt;
135 	unsigned int			max_seq_nr;
136 	struct padata_cpumask		cpumask;
137 	spinlock_t                      lock ____cacheline_aligned;
138 	unsigned int			processed;
139 	struct timer_list		timer;
140 };
141 
142 /**
143  * struct padata_instance - The overall control structure.
144  *
145  * @cpu_notifier: cpu hotplug notifier.
146  * @wq: The workqueue in use.
147  * @pd: The internal control structure.
148  * @cpumask: User supplied cpumasks for parallel and serial works.
149  * @cpumask_change_notifier: Notifiers chain for user-defined notify
150  *            callbacks that will be called when either @pcpu or @cbcpu
151  *            or both cpumasks change.
152  * @kobj: padata instance kernel object.
153  * @lock: padata instance lock.
154  * @flags: padata flags.
155  */
156 struct padata_instance {
157 	struct notifier_block		 cpu_notifier;
158 	struct workqueue_struct		*wq;
159 	struct parallel_data		*pd;
160 	struct padata_cpumask		cpumask;
161 	struct blocking_notifier_head	 cpumask_change_notifier;
162 	struct kobject                   kobj;
163 	struct mutex			 lock;
164 	u8				 flags;
165 #define	PADATA_INIT	1
166 #define	PADATA_RESET	2
167 #define	PADATA_INVALID	4
168 };
169 
170 extern struct padata_instance *padata_alloc_possible(
171 					struct workqueue_struct *wq);
172 extern struct padata_instance *padata_alloc(struct workqueue_struct *wq,
173 					    const struct cpumask *pcpumask,
174 					    const struct cpumask *cbcpumask);
175 extern void padata_free(struct padata_instance *pinst);
176 extern int padata_do_parallel(struct padata_instance *pinst,
177 			      struct padata_priv *padata, int cb_cpu);
178 extern void padata_do_serial(struct padata_priv *padata);
179 extern int padata_set_cpumask(struct padata_instance *pinst, int cpumask_type,
180 			      cpumask_var_t cpumask);
181 extern int padata_set_cpumasks(struct padata_instance *pinst,
182 			       cpumask_var_t pcpumask,
183 			       cpumask_var_t cbcpumask);
184 extern int padata_add_cpu(struct padata_instance *pinst, int cpu, int mask);
185 extern int padata_remove_cpu(struct padata_instance *pinst, int cpu, int mask);
186 extern int padata_start(struct padata_instance *pinst);
187 extern void padata_stop(struct padata_instance *pinst);
188 extern int padata_register_cpumask_notifier(struct padata_instance *pinst,
189 					    struct notifier_block *nblock);
190 extern int padata_unregister_cpumask_notifier(struct padata_instance *pinst,
191 					      struct notifier_block *nblock);
192 #endif
193