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/notifier.h>
28 #include <linux/kobject.h>
29 
30 #define PADATA_CPU_SERIAL   0x01
31 #define PADATA_CPU_PARALLEL 0x02
32 
33 /**
34  * struct padata_priv -  Embedded to the users data structure.
35  *
36  * @list: List entry, to attach to the padata lists.
37  * @pd: Pointer to the internal control structure.
38  * @cb_cpu: Callback cpu for serializatioon.
39  * @cpu: Cpu for parallelization.
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			cpu;
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  * @work: work struct for parallelization.
88  * @num_obj: Number of objects that are processed by this cpu.
89  * @cpu_index: Index of the cpu.
90  */
91 struct padata_parallel_queue {
92        struct padata_list    parallel;
93        struct padata_list    reorder;
94        struct work_struct    work;
95        atomic_t              num_obj;
96        int                   cpu_index;
97 };
98 
99 /**
100  * struct padata_cpumask - The cpumasks for the parallel/serial workers
101  *
102  * @pcpu: cpumask for the parallel workers.
103  * @cbcpu: cpumask for the serial (callback) workers.
104  */
105 struct padata_cpumask {
106 	cpumask_var_t	pcpu;
107 	cpumask_var_t	cbcpu;
108 };
109 
110 /**
111  * struct parallel_data - Internal control structure, covers everything
112  * that depends on the cpumask in use.
113  *
114  * @pinst: padata instance.
115  * @pqueue: percpu padata queues used for parallelization.
116  * @squeue: percpu padata queues used for serialuzation.
117  * @reorder_objects: Number of objects waiting in the reorder queues.
118  * @refcnt: Number of objects holding a reference on this parallel_data.
119  * @max_seq_nr:  Maximal used sequence number.
120  * @cpu: Next CPU to be processed.
121  * @cpumask: The cpumasks in use for parallel and serial workers.
122  * @reorder_work: work struct for reordering.
123  * @lock: Reorder lock.
124  */
125 struct parallel_data {
126 	struct padata_instance		*pinst;
127 	struct padata_parallel_queue	__percpu *pqueue;
128 	struct padata_serial_queue	__percpu *squeue;
129 	atomic_t			reorder_objects;
130 	atomic_t			refcnt;
131 	atomic_t			seq_nr;
132 	int				cpu;
133 	struct padata_cpumask		cpumask;
134 	struct work_struct		reorder_work;
135 	spinlock_t                      lock ____cacheline_aligned;
136 };
137 
138 /**
139  * struct padata_instance - The overall control structure.
140  *
141  * @cpu_online_node: Linkage for CPU online callback.
142  * @cpu_dead_node: Linkage for CPU offline callback.
143  * @wq: The workqueue in use.
144  * @pd: The internal control structure.
145  * @cpumask: User supplied cpumasks for parallel and serial works.
146  * @cpumask_change_notifier: Notifiers chain for user-defined notify
147  *            callbacks that will be called when either @pcpu or @cbcpu
148  *            or both cpumasks change.
149  * @kobj: padata instance kernel object.
150  * @lock: padata instance lock.
151  * @flags: padata flags.
152  */
153 struct padata_instance {
154 	struct hlist_node		cpu_online_node;
155 	struct hlist_node		cpu_dead_node;
156 	struct workqueue_struct		*wq;
157 	struct parallel_data		*pd;
158 	struct padata_cpumask		cpumask;
159 	struct blocking_notifier_head	 cpumask_change_notifier;
160 	struct kobject                   kobj;
161 	struct mutex			 lock;
162 	u8				 flags;
163 #define	PADATA_INIT	1
164 #define	PADATA_RESET	2
165 #define	PADATA_INVALID	4
166 };
167 
168 extern struct padata_instance *padata_alloc_possible(
169 					struct workqueue_struct *wq);
170 extern void padata_free(struct padata_instance *pinst);
171 extern int padata_do_parallel(struct padata_instance *pinst,
172 			      struct padata_priv *padata, int cb_cpu);
173 extern void padata_do_serial(struct padata_priv *padata);
174 extern int padata_set_cpumask(struct padata_instance *pinst, int cpumask_type,
175 			      cpumask_var_t cpumask);
176 extern int padata_start(struct padata_instance *pinst);
177 extern void padata_stop(struct padata_instance *pinst);
178 extern int padata_register_cpumask_notifier(struct padata_instance *pinst,
179 					    struct notifier_block *nblock);
180 extern int padata_unregister_cpumask_notifier(struct padata_instance *pinst,
181 					      struct notifier_block *nblock);
182 #endif
183