mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-11-27 05:30:56 +07:00
eb13ba8738
Dave Young reported warnings from lockdep that the workqueue API can sometimes try to register lockdep classes with the same key but different names. This is not permitted in lockdep. Unfortunately, I was unaware of that restriction when I wrote the code to debug workqueue problems with lockdep and used the workqueue name as the lockdep class name. This can obviously lead to the problem if the workqueue name is dynamic. This patch solves the problem by always using a constant name for the workqueue's lockdep class, namely either the constant name that was passed in or a string consisting of the variable name. Signed-off-by: Johannes Berg <johannes@sipsolutions.net> Signed-off-by: Ingo Molnar <mingo@elte.hu> Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
238 lines
6.5 KiB
C
238 lines
6.5 KiB
C
/*
|
|
* workqueue.h --- work queue handling for Linux.
|
|
*/
|
|
|
|
#ifndef _LINUX_WORKQUEUE_H
|
|
#define _LINUX_WORKQUEUE_H
|
|
|
|
#include <linux/timer.h>
|
|
#include <linux/linkage.h>
|
|
#include <linux/bitops.h>
|
|
#include <linux/lockdep.h>
|
|
#include <asm/atomic.h>
|
|
|
|
struct workqueue_struct;
|
|
|
|
struct work_struct;
|
|
typedef void (*work_func_t)(struct work_struct *work);
|
|
|
|
/*
|
|
* The first word is the work queue pointer and the flags rolled into
|
|
* one
|
|
*/
|
|
#define work_data_bits(work) ((unsigned long *)(&(work)->data))
|
|
|
|
struct work_struct {
|
|
atomic_long_t data;
|
|
#define WORK_STRUCT_PENDING 0 /* T if work item pending execution */
|
|
#define WORK_STRUCT_FLAG_MASK (3UL)
|
|
#define WORK_STRUCT_WQ_DATA_MASK (~WORK_STRUCT_FLAG_MASK)
|
|
struct list_head entry;
|
|
work_func_t func;
|
|
#ifdef CONFIG_LOCKDEP
|
|
struct lockdep_map lockdep_map;
|
|
#endif
|
|
};
|
|
|
|
#define WORK_DATA_INIT() ATOMIC_LONG_INIT(0)
|
|
|
|
struct delayed_work {
|
|
struct work_struct work;
|
|
struct timer_list timer;
|
|
};
|
|
|
|
struct execute_work {
|
|
struct work_struct work;
|
|
};
|
|
|
|
#ifdef CONFIG_LOCKDEP
|
|
/*
|
|
* NB: because we have to copy the lockdep_map, setting _key
|
|
* here is required, otherwise it could get initialised to the
|
|
* copy of the lockdep_map!
|
|
*/
|
|
#define __WORK_INIT_LOCKDEP_MAP(n, k) \
|
|
.lockdep_map = STATIC_LOCKDEP_MAP_INIT(n, k),
|
|
#else
|
|
#define __WORK_INIT_LOCKDEP_MAP(n, k)
|
|
#endif
|
|
|
|
#define __WORK_INITIALIZER(n, f) { \
|
|
.data = WORK_DATA_INIT(), \
|
|
.entry = { &(n).entry, &(n).entry }, \
|
|
.func = (f), \
|
|
__WORK_INIT_LOCKDEP_MAP(#n, &(n)) \
|
|
}
|
|
|
|
#define __DELAYED_WORK_INITIALIZER(n, f) { \
|
|
.work = __WORK_INITIALIZER((n).work, (f)), \
|
|
.timer = TIMER_INITIALIZER(NULL, 0, 0), \
|
|
}
|
|
|
|
#define DECLARE_WORK(n, f) \
|
|
struct work_struct n = __WORK_INITIALIZER(n, f)
|
|
|
|
#define DECLARE_DELAYED_WORK(n, f) \
|
|
struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f)
|
|
|
|
/*
|
|
* initialize a work item's function pointer
|
|
*/
|
|
#define PREPARE_WORK(_work, _func) \
|
|
do { \
|
|
(_work)->func = (_func); \
|
|
} while (0)
|
|
|
|
#define PREPARE_DELAYED_WORK(_work, _func) \
|
|
PREPARE_WORK(&(_work)->work, (_func))
|
|
|
|
/*
|
|
* initialize all of a work item in one go
|
|
*
|
|
* NOTE! No point in using "atomic_long_set()": useing a direct
|
|
* assignment of the work data initializer allows the compiler
|
|
* to generate better code.
|
|
*/
|
|
#ifdef CONFIG_LOCKDEP
|
|
#define INIT_WORK(_work, _func) \
|
|
do { \
|
|
static struct lock_class_key __key; \
|
|
\
|
|
(_work)->data = (atomic_long_t) WORK_DATA_INIT(); \
|
|
lockdep_init_map(&(_work)->lockdep_map, #_work, &__key, 0);\
|
|
INIT_LIST_HEAD(&(_work)->entry); \
|
|
PREPARE_WORK((_work), (_func)); \
|
|
} while (0)
|
|
#else
|
|
#define INIT_WORK(_work, _func) \
|
|
do { \
|
|
(_work)->data = (atomic_long_t) WORK_DATA_INIT(); \
|
|
INIT_LIST_HEAD(&(_work)->entry); \
|
|
PREPARE_WORK((_work), (_func)); \
|
|
} while (0)
|
|
#endif
|
|
|
|
#define INIT_DELAYED_WORK(_work, _func) \
|
|
do { \
|
|
INIT_WORK(&(_work)->work, (_func)); \
|
|
init_timer(&(_work)->timer); \
|
|
} while (0)
|
|
|
|
#define INIT_DELAYED_WORK_DEFERRABLE(_work, _func) \
|
|
do { \
|
|
INIT_WORK(&(_work)->work, (_func)); \
|
|
init_timer_deferrable(&(_work)->timer); \
|
|
} while (0)
|
|
|
|
/**
|
|
* work_pending - Find out whether a work item is currently pending
|
|
* @work: The work item in question
|
|
*/
|
|
#define work_pending(work) \
|
|
test_bit(WORK_STRUCT_PENDING, work_data_bits(work))
|
|
|
|
/**
|
|
* delayed_work_pending - Find out whether a delayable work item is currently
|
|
* pending
|
|
* @work: The work item in question
|
|
*/
|
|
#define delayed_work_pending(w) \
|
|
work_pending(&(w)->work)
|
|
|
|
/**
|
|
* work_clear_pending - for internal use only, mark a work item as not pending
|
|
* @work: The work item in question
|
|
*/
|
|
#define work_clear_pending(work) \
|
|
clear_bit(WORK_STRUCT_PENDING, work_data_bits(work))
|
|
|
|
|
|
extern struct workqueue_struct *
|
|
__create_workqueue_key(const char *name, int singlethread,
|
|
int freezeable, struct lock_class_key *key,
|
|
const char *lock_name);
|
|
|
|
#ifdef CONFIG_LOCKDEP
|
|
#define __create_workqueue(name, singlethread, freezeable) \
|
|
({ \
|
|
static struct lock_class_key __key; \
|
|
const char *__lock_name; \
|
|
\
|
|
if (__builtin_constant_p(name)) \
|
|
__lock_name = (name); \
|
|
else \
|
|
__lock_name = #name; \
|
|
\
|
|
__create_workqueue_key((name), (singlethread), \
|
|
(freezeable), &__key, \
|
|
__lock_name); \
|
|
})
|
|
#else
|
|
#define __create_workqueue(name, singlethread, freezeable) \
|
|
__create_workqueue_key((name), (singlethread), (freezeable), 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)
|
|
|
|
extern void destroy_workqueue(struct workqueue_struct *wq);
|
|
|
|
extern int FASTCALL(queue_work(struct workqueue_struct *wq, struct work_struct *work));
|
|
extern int FASTCALL(queue_delayed_work(struct workqueue_struct *wq,
|
|
struct delayed_work *work, unsigned long delay));
|
|
extern int queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
|
|
struct delayed_work *work, unsigned long delay);
|
|
|
|
extern void FASTCALL(flush_workqueue(struct workqueue_struct *wq));
|
|
extern void flush_scheduled_work(void);
|
|
|
|
extern int FASTCALL(schedule_work(struct work_struct *work));
|
|
extern int FASTCALL(schedule_delayed_work(struct delayed_work *work,
|
|
unsigned long delay));
|
|
extern int schedule_delayed_work_on(int cpu, struct delayed_work *work,
|
|
unsigned long delay);
|
|
extern int schedule_on_each_cpu(work_func_t func);
|
|
extern int current_is_keventd(void);
|
|
extern int keventd_up(void);
|
|
|
|
extern void init_workqueues(void);
|
|
int execute_in_process_context(work_func_t fn, struct execute_work *);
|
|
|
|
extern int cancel_work_sync(struct work_struct *work);
|
|
|
|
/*
|
|
* Kill off a pending schedule_delayed_work(). Note that the work callback
|
|
* function may still be running on return from cancel_delayed_work(), unless
|
|
* it returns 1 and the work doesn't re-arm itself. Run flush_workqueue() or
|
|
* cancel_work_sync() to wait on it.
|
|
*/
|
|
static inline int cancel_delayed_work(struct delayed_work *work)
|
|
{
|
|
int ret;
|
|
|
|
ret = del_timer_sync(&work->timer);
|
|
if (ret)
|
|
work_clear_pending(&work->work);
|
|
return ret;
|
|
}
|
|
|
|
extern int cancel_delayed_work_sync(struct delayed_work *work);
|
|
|
|
/* Obsolete. use cancel_delayed_work_sync() */
|
|
static inline
|
|
void cancel_rearming_delayed_workqueue(struct workqueue_struct *wq,
|
|
struct delayed_work *work)
|
|
{
|
|
cancel_delayed_work_sync(work);
|
|
}
|
|
|
|
/* Obsolete. use cancel_delayed_work_sync() */
|
|
static inline
|
|
void cancel_rearming_delayed_work(struct delayed_work *work)
|
|
{
|
|
cancel_delayed_work_sync(work);
|
|
}
|
|
|
|
#endif
|