linux驱动之定时任务timer，队列queue，小任务tasklet机制及用法

1
Timer.h (includelinux)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
struct timer_list{
	/*
	 * All fields that change during normal runtime grouped to the
	 * same cacheline
	 */
	struct list_head entry;
	unsigned long expires;
	struct tvec_base *base;

	void (*function)(unsigned long);
	unsigned long data;

	int slack;

#ifdef CONFIG_TIMER_STATS
	int start_pid;
	void *start_site;
	char start_comm[16];
#endif
#ifdef CONFIG_LOCKDEP
	struct lockdep_map lockdep_map;
#endif
};

1
2
  setup_timer(&kp->timer, kp_timer_sr, (unsigned int)kp) ;
  mod_timer(&kp->timer, jiffies+msecs_to_jiffies(100));

1
2
#define setup_timer(timer, fn, data)					
	__setup_timer((timer), (fn), (data), 0)

1
2
3
4
5
6
#define __setup_timer(_timer, _fn, _data, _flags)			
	do {								
		__init_timer((_timer), (_flags));			
		(_timer)->function = (_fn);				
		(_timer)->data = (_data);				
	} while (0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int mod_timer(struct timer_list *timer, unsigned long expires)
{
	expires = apply_slack(timer, expires);

	/*
	 * This is a common optimization triggered by the
	 * networking code - if the timer is re-modified
	 * to be the same thing then just return:
	 */
	if (timer_pending(timer) && timer->expires == expires)
		return 1;

	return __mod_timer(timer, expires, false, TIMER_NOT_PINNED);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/* Tasklets --- multithreaded analogue of BHs.

   Main feature differing them of generic softirqs: tasklet
   is running only on one CPU simultaneously.

   Main feature differing them of BHs: different tasklets
   may be run simultaneously on different CPUs.

   Properties:
   * If tasklet_schedule() is called, then tasklet is guaranteed
     to be executed on some cpu at least once after this.
   * If the tasklet is already scheduled, but its execution is still not
     started, it will be executed only once.
   * If this tasklet is already running on another CPU (or schedule is called
     from tasklet itself), it is rescheduled for later.
   * Tasklet is strictly serialized wrt itself, but not
     wrt another tasklets. If client needs some intertask synchronization,
     he makes it with spinlocks.
 */

struct tasklet_struct
{
	struct tasklet_struct *next;
	unsigned long state;
	atomic_t count;
	void (*func)(unsigned long);
	unsigned long data;
};

1
2
3
4
5
#define DECLARE_TASKLET(name, func, data) 
struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data }

#define DECLARE_TASKLET_DISABLED(name, func, data) 
struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(1), func, data }

1
2
3
4
5
6
static inline void tasklet_disable(struct tasklet_struct *t)
{
	tasklet_disable_nosync(t);
	tasklet_unlock_wait(t);
	smp_mb();
}

1
2
3
4
5
static inline void tasklet_enable(struct tasklet_struct *t)
{
	smp_mb__before_atomic_dec();
	atomic_dec(&t->count);
}

1
2
3
4
5
static inline void tasklet_schedule(struct tasklet_struct *t)
{
	if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
		__tasklet_schedule(t);
}

1
2
3
4
extern void tasklet_kill(struct tasklet_struct *t);
extern void tasklet_kill_immediate(struct tasklet_struct *t, unsigned int cpu);
extern void tasklet_init(struct tasklet_struct *t,
			 void (*func)(unsigned long), unsigned long data);

1
2
3
4
5
6
/*
 * This version avoids touching any other tasklets. Needed for kmemcheck
 * in order not to take any page faults while enqueueing this tasklet;
 * consider VERY carefully whether you really need this or
 * tasklet_hi_schedule()...
 */

1
2
#define create_workqueue(name)						
	alloc_workqueue((name), WQ_MEM_RECLAIM, 1)

1
2
#define create_singlethread_workqueue(name)				
	alloc_workqueue((name), WQ_UNBOUND | WQ_MEM_RECLAIM, 1)

1
static DECLARE_WORK(binder_deferred_work, binder_deferred_func);

1
2
#define DECLARE_WORK(n, f)						
	struct work_struct n = __WORK_INITIALIZER(n, f)

1
2
3
4
#define INIT_WORK(_work, _func)						
	do {								
		__INIT_WORK((_work), (_func), 0);			
	} while (0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * queue_work - queue work on a workqueue
 * @wq: workqueue to use
 * @work: work to queue
 *
 * Returns %false if @work was already on a queue, %true otherwise.
 *
 * We queue the work to the CPU on which it was submitted, but if the CPU dies
 * it can be processed by another CPU.
 */
static inline bool queue_work(struct workqueue_struct *wq,
			      struct work_struct *work)
{
	return queue_work_on(WORK_CPU_UNBOUND, wq, work);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * queue_delayed_work - queue work on a workqueue after delay
 * @wq: workqueue to use
 * @dwork: delayable work to queue
 * @delay: number of jiffies to wait before queueing
 *
 * Equivalent to queue_delayed_work_on() but tries to use the local CPU.
 */
static inline bool queue_delayed_work(struct workqueue_struct *wq,
				      struct delayed_work *dwork,
				      unsigned long delay)
{
	return queue_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay);
}

1
void destroy_workqueue(struct workqueue_struct *wq);

1
2
struct workqueue_struct *stk_acc_wq;<span style="white-space: pre;">	struct work_struct stk_acc_work; void stk_acc_poll_work_func(struct work_struct *work)</span>

1
2
stk->stk_acc_wq = create_singlethread_workqueue("stk_acc_wq");
	INIT_WORK(&stk->stk_acc_work, stk_acc_poll_work_func);

1
2
queue_work(stk->stk_acc_wq, &stk->stk_acc_work);

1
2
！：INIT_WORK(&(kp->work_update), update_work_func);
！！： schedule_work(&(kp->work_update));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * schedule_work - put work task in global workqueue
 * @work: job to be done
 *
 * Returns %false if @work was already on the kernel-global workqueue and
 * %true otherwise.
 *
 * This puts a job in the kernel-global workqueue if it was not already
 * queued and leaves it in the same position on the kernel-global
 * workqueue otherwise.
 */
static inline bool schedule_work(struct work_struct *work)
{
	return queue_work(system_wq, work);
}