Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 97e37d7b authored by Tejun Heo's avatar Tejun Heo
Browse files

workqueue: merge feature parameters into flags 



Currently, __create_workqueue_key() takes @singlethread and
@freezeable paramters and store them separately in workqueue_struct.
Merge them into a single flags parameter and field and use
WQ_FREEZEABLE and WQ_SINGLE_THREAD.

Signed-off-by: default avatarTejun Heo <tj@kernel.org>
parent 4690c4ab

include/linux/workqueue.h

+15 −10
Original line number Diff line number Diff line
@@ -184,13 +184,17 @@ static inline unsigned int work_static(struct work_struct *work) { return 0; } 
#define work_clear_pending(work) \

	clear_bit(WORK_STRUCT_PENDING, work_data_bits(work))



enum {

	WQ_FREEZEABLE		= 1 << 0, /* freeze during suspend */

	WQ_SINGLE_THREAD	= 1 << 1, /* no per-cpu worker */

};



extern struct workqueue_struct *

__create_workqueue_key(const char *name, int singlethread, int freezeable,

__create_workqueue_key(const char *name, unsigned int flags,

		       struct lock_class_key *key, const char *lock_name);



#ifdef CONFIG_LOCKDEP

#define __create_workqueue(name, singlethread, freezeable)	\

#define __create_workqueue(name, flags)				\

({								\

	static struct lock_class_key __key;			\

	const char *__lock_name;				\
@@ -200,19 +204,20 @@ __create_workqueue_key(const char *name, int singlethread, int freezeable, 
	else							\

		__lock_name = #name;				\

								\

	__create_workqueue_key((name), (singlethread),		\

			       (freezeable), &__key,		\

	__create_workqueue_key((name), (flags), &__key,		\

			       __lock_name);			\

})

#else

#define __create_workqueue(name, singlethread, freezeable)	\

	__create_workqueue_key((name), (singlethread), (freezeable), \

			       NULL, NULL)

#define __create_workqueue(name, flags)				\

	__create_workqueue_key((name), (flags), NULL, NULL)

#endif



#define create_workqueue(name) __create_workqueue((name), 0, 0)

#define create_freezeable_workqueue(name) __create_workqueue((name), 1, 1)

#define create_singlethread_workqueue(name) __create_workqueue((name), 1, 0)

#define create_workqueue(name)					\

	__create_workqueue((name), 0)

#define create_freezeable_workqueue(name)			\

	__create_workqueue((name), WQ_FREEZEABLE | WQ_SINGLE_THREAD)

#define create_singlethread_workqueue(name)			\

	__create_workqueue((name), WQ_SINGLE_THREAD)



extern void destroy_workqueue(struct workqueue_struct *wq);

kernel/workqueue.c

+7 −10
Original line number Diff line number Diff line
@@ -67,11 +67,10 @@ struct cpu_workqueue_struct { 
 * per-CPU workqueues:

 */

struct workqueue_struct {

	unsigned int		flags;		/* I: WQ_* flags */

	struct cpu_workqueue_struct *cpu_wq;	/* I: cwq's */

	struct list_head	list;		/* W: list of all workqueues */

	const char		*name;		/* I: workqueue name */

	int singlethread;

	int freezeable;		/* Freeze threads during suspend */

#ifdef CONFIG_LOCKDEP

	struct lockdep_map	lockdep_map;

#endif
@@ -203,9 +202,9 @@ static const struct cpumask *cpu_singlethread_map __read_mostly; 
static cpumask_var_t cpu_populated_map __read_mostly;



/* If it's single threaded, it isn't in the list of workqueues. */

static inline int is_wq_single_threaded(struct workqueue_struct *wq)

static inline bool is_wq_single_threaded(struct workqueue_struct *wq)

{

	return wq->singlethread;

	return wq->flags & WQ_SINGLE_THREAD;

}



static const struct cpumask *wq_cpu_map(struct workqueue_struct *wq)
@@ -463,7 +462,7 @@ static int worker_thread(void *__cwq) 
	struct cpu_workqueue_struct *cwq = __cwq;

	DEFINE_WAIT(wait);



	if (cwq->wq->freezeable)

	if (cwq->wq->flags & WQ_FREEZEABLE)

		set_freezable();



	for (;;) {
@@ -1013,8 +1012,7 @@ static void start_workqueue_thread(struct cpu_workqueue_struct *cwq, int cpu) 
}



struct workqueue_struct *__create_workqueue_key(const char *name,

						int singlethread,

						int freezeable,

						unsigned int flags,

						struct lock_class_key *key,

						const char *lock_name)

{
@@ -1030,13 +1028,12 @@ struct workqueue_struct *__create_workqueue_key(const char *name, 
	if (!wq->cpu_wq)

		goto err;



	wq->flags = flags;

	wq->name = name;

	lockdep_init_map(&wq->lockdep_map, lock_name, key, 0);

	wq->singlethread = singlethread;

	wq->freezeable = freezeable;

	INIT_LIST_HEAD(&wq->list);



	if (singlethread) {

	if (flags & WQ_SINGLE_THREAD) {

		cwq = init_cpu_workqueue(wq, singlethread_cpu);

		err = create_workqueue_thread(cwq, singlethread_cpu);

		start_workqueue_thread(cwq, -1);