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