1 /* SPDX-License-Identifier: GPL-2.0-only */ 2 /* 3 * padata.h - header for the padata parallelization interface 4 * 5 * Copyright (C) 2008, 2009 secunet Security Networks AG 6 * Copyright (C) 2008, 2009 Steffen Klassert <[email protected]> 7 */ 8 9 #ifndef PADATA_H 10 #define PADATA_H 11 12 #include <linux/compiler_types.h> 13 #include <linux/workqueue.h> 14 #include <linux/spinlock.h> 15 #include <linux/list.h> 16 #include <linux/kobject.h> 17 18 #define PADATA_CPU_SERIAL 0x01 19 #define PADATA_CPU_PARALLEL 0x02 20 21 /** 22 * struct padata_priv - Embedded to the users data structure. 23 * 24 * @list: List entry, to attach to the padata lists. 25 * @pd: Pointer to the internal control structure. 26 * @cb_cpu: Callback cpu for serializatioon. 27 * @cpu: Cpu for parallelization. 28 * @seq_nr: Sequence number of the parallelized data object. 29 * @info: Used to pass information from the parallel to the serial function. 30 * @parallel: Parallel execution function. 31 * @serial: Serial complete function. 32 */ 33 struct padata_priv { 34 struct list_head list; 35 struct parallel_data *pd; 36 int cb_cpu; 37 int cpu; 38 unsigned int seq_nr; 39 int info; 40 void (*parallel)(struct padata_priv *padata); 41 void (*serial)(struct padata_priv *padata); 42 }; 43 44 /** 45 * struct padata_list 46 * 47 * @list: List head. 48 * @lock: List lock. 49 */ 50 struct padata_list { 51 struct list_head list; 52 spinlock_t lock; 53 }; 54 55 /** 56 * struct padata_serial_queue - The percpu padata serial queue 57 * 58 * @serial: List to wait for serialization after reordering. 59 * @work: work struct for serialization. 60 * @pd: Backpointer to the internal control structure. 61 */ 62 struct padata_serial_queue { 63 struct padata_list serial; 64 struct work_struct work; 65 struct parallel_data *pd; 66 }; 67 68 /** 69 * struct padata_parallel_queue - The percpu padata parallel queue 70 * 71 * @parallel: List to wait for parallelization. 72 * @reorder: List to wait for reordering after parallel processing. 73 * @serial: List to wait for serialization after reordering. 74 * @pwork: work struct for parallelization. 75 * @swork: work struct for serialization. 76 * @work: work struct for parallelization. 77 * @num_obj: Number of objects that are processed by this cpu. 78 */ 79 struct padata_parallel_queue { 80 struct padata_list parallel; 81 struct padata_list reorder; 82 struct work_struct work; 83 atomic_t num_obj; 84 }; 85 86 /** 87 * struct padata_cpumask - The cpumasks for the parallel/serial workers 88 * 89 * @pcpu: cpumask for the parallel workers. 90 * @cbcpu: cpumask for the serial (callback) workers. 91 */ 92 struct padata_cpumask { 93 cpumask_var_t pcpu; 94 cpumask_var_t cbcpu; 95 }; 96 97 /** 98 * struct parallel_data - Internal control structure, covers everything 99 * that depends on the cpumask in use. 100 * 101 * @sh: padata_shell object. 102 * @pqueue: percpu padata queues used for parallelization. 103 * @squeue: percpu padata queues used for serialuzation. 104 * @refcnt: Number of objects holding a reference on this parallel_data. 105 * @max_seq_nr: Maximal used sequence number. 106 * @processed: Number of already processed objects. 107 * @cpu: Next CPU to be processed. 108 * @cpumask: The cpumasks in use for parallel and serial workers. 109 * @reorder_work: work struct for reordering. 110 * @lock: Reorder lock. 111 */ 112 struct parallel_data { 113 struct padata_shell *ps; 114 struct padata_parallel_queue __percpu *pqueue; 115 struct padata_serial_queue __percpu *squeue; 116 atomic_t refcnt; 117 atomic_t seq_nr; 118 unsigned int processed; 119 int cpu; 120 struct padata_cpumask cpumask; 121 struct work_struct reorder_work; 122 spinlock_t lock ____cacheline_aligned; 123 }; 124 125 /** 126 * struct padata_shell - Wrapper around struct parallel_data, its 127 * purpose is to allow the underlying control structure to be replaced 128 * on the fly using RCU. 129 * 130 * @pinst: padat instance. 131 * @pd: Actual parallel_data structure which may be substituted on the fly. 132 * @opd: Pointer to old pd to be freed by padata_replace. 133 * @list: List entry in padata_instance list. 134 */ 135 struct padata_shell { 136 struct padata_instance *pinst; 137 struct parallel_data __rcu *pd; 138 struct parallel_data *opd; 139 struct list_head list; 140 }; 141 142 /** 143 * struct padata_instance - The overall control structure. 144 * 145 * @cpu_notifier: cpu hotplug notifier. 146 * @parallel_wq: The workqueue used for parallel work. 147 * @serial_wq: The workqueue used for serial work. 148 * @pslist: List of padata_shell objects attached to this instance. 149 * @cpumask: User supplied cpumasks for parallel and serial works. 150 * @rcpumask: Actual cpumasks based on user cpumask and cpu_online_mask. 151 * @kobj: padata instance kernel object. 152 * @lock: padata instance lock. 153 * @flags: padata flags. 154 */ 155 struct padata_instance { 156 struct hlist_node node; 157 struct workqueue_struct *parallel_wq; 158 struct workqueue_struct *serial_wq; 159 struct list_head pslist; 160 struct padata_cpumask cpumask; 161 struct padata_cpumask rcpumask; 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(const char *name); 171 extern void padata_free(struct padata_instance *pinst); 172 extern struct padata_shell *padata_alloc_shell(struct padata_instance *pinst); 173 extern void padata_free_shell(struct padata_shell *ps); 174 extern int padata_do_parallel(struct padata_shell *ps, 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 #endif 182