Linux設備驅動之時間，延遲及延緩操作（實踐）

一 jit.函數源碼

1. /*
2. * jit.c -- the just-in-time module
3. *
4. * Copyright (C) 2001,2003 Alessandro Rubini and Jonathan Corbet
5. * Copyright (C) 2001,2003 O'Reilly & Associates
6. *
7. * The source code in this file can be freely used, adapted,
8. * and redistributed in source or binary form, so long as an
9. * acknowledgment appears in derived source files. The citation
10. * should list that the code comes from the book "Linux Device
11. * Drivers" by Alessandro Rubini and Jonathan Corbet, published
12. * by O'Reilly & Associates. No warranty is attached;
13. * we cannot take responsibility for errors or fitness for use.
14. *
15. * $Id: jit.c,v 1.16 2004/09/26 07:02:43 gregkh Exp $
16. */
19. #include <linux/module.h>
20. #include <linux/moduleparam.h>
21. #include <linux/init.h>
23. #include <linux/time.h>
24. #include <linux/timer.h>
25. #include <linux/kernel.h>
26. #include <linux/proc_fs.h>
27. #include <linux/types.h>
28. #include <linux/spinlock.h>
29. #include <linux/interrupt.h>
31. #include <linux/param.h>
32. #include <linux/wait.h>
33. #include <linux/jiffies.h>
34. #include <linux/sched.h>
36. #include <asm/hardirq.h>
37. /*
38. * This module is a silly one: it only embeds short code fragments
39. * that show how time delays can be handled in the kernel.
40. */
42. int delay = HZ; /* the default delay, expressed in jiffies */
44. module_param(delay, int, 0);
46. MODULE_AUTHOR("Alessandro Rubini");
47. MODULE_LICENSE("Dual BSD/GPL");
49. /* use these as data pointers, to implement four files in one function */
50. enum jit_files {
51. JIT_BUSY,
52. JIT_SCHED,
53. JIT_QUEUE,
54. JIT_SCHEDTO
55. };
57. /*
58. * This function prints one line of data, after sleeping one second.
59. * It can sleep in different ways, according to the data pointer
60. */
61. int jit_fn(char *buf, char **start, off_t offset,
62. int len, int *eof, void *data)
63. {
64. unsigned long j0, j1; /* jiffies */
65. wait_queue_head_t wait;
67. init_waitqueue_head (&wait);
68. j0 = jiffies;
69. j1 = j0 + delay;
71. switch((long)data) {
72. case JIT_BUSY:
73. while (time_before(jiffies, j1))
74. cpu_relax();
75. break;
76. case JIT_SCHED:
77. while (time_before(jiffies, j1)) {
78. schedule();
79. }
80. break;
81. case JIT_QUEUE:
82. wait_event_interruptible_timeout(wait, 0, delay);
83. break;
84. case JIT_SCHEDTO:
85. set_current_state(TASK_INTERRUPTIBLE);
86. schedule_timeout (delay);
87. break;
88. }
89. j1 = jiffies; /* actual value after we delayed */
91. len = sprintf(buf, "%9li %9li\n", j0, j1);
92. *start = buf;
93. return len;
94. }
96. /*
97. * This file, on the other hand, returns the current time forever
98. */
99. int jit_currentime(char *buf, char **start, off_t offset,
100. int len, int *eof, void *data)
101. {
102. struct timeval tv1;
103. struct timespec tv2;
104. unsigned long j1;
105. u64 j2;
107. /* get them four */
108. j1 = jiffies;
109. j2 = get_jiffies_64();
110. do_gettimeofday(&tv1);
111. tv2 = current_kernel_time();
113. /* print */
114. len=0;
115. len += sprintf(buf,"0x%08lx 0x%016Lx %10i.%06i\n"
116. "%40i.%09i\n",
117. j1, j2,
118. (int) tv1.tv_sec, (int) tv1.tv_usec,
119. (int) tv2.tv_sec, (int) tv2.tv_nsec);
120. *start = buf;
121. return len;
122. }
124. /*
125. * The timer example follows
126. */
128. int tdelay = 10;
129. module_param(tdelay, int, 0);
131. /* This data structure used as "data" for the timer and tasklet functions */
132. struct jit_data {
133. struct timer_list timer;
134. struct tasklet_struct tlet;
135. int hi; /* tasklet or tasklet_hi */
136. wait_queue_head_t wait;
137. unsigned long prevjiffies;
138. unsigned char *buf;
139. int loops;
140. };
141. #define JIT_ASYNC_LOOPS 5
143. void jit_timer_fn(unsigned long arg)
144. {
145. struct jit_data *data = (struct jit_data *)arg;
146. unsigned long j = jiffies;
147. data->buf += sprintf(data->buf, "%9li %3li %i %6i %i %s\n",
148. j, j - data->prevjiffies, in_interrupt() ? 1 : 0,
149. current->pid, smp_processor_id(), current->comm);
151. if (--data->loops) {
152. data->timer.expires += tdelay;
153. data->prevjiffies = j;
154. add_timer(&data->timer);
155. } else {
156. wake_up_interruptible(&data->wait);
157. }
158. }
160. /* the /proc function: allocate everything to allow concurrency */
161. int jit_timer(char *buf, char **start, off_t offset,
162. int len, int *eof, void *unused_data)
163. {
164. struct jit_data *data;
165. char *buf2 = buf;
166. unsigned long j = jiffies;
168. data = kmalloc(sizeof(*data), GFP_KERNEL);
169. if (!data)
170. return -ENOMEM;
172. init_timer(&data->timer);
173. init_waitqueue_head (&data->wait);
175. /* write the first lines in the buffer */
176. buf2 += sprintf(buf2, " time delta inirq pid cpu command\n");
177. buf2 += sprintf(buf2, "%9li %3li %i %6i %i %s\n",
178. j, 0L, in_interrupt() ? 1 : 0,
179. current->pid, smp_processor_id(), current->comm);
181. /* fill the data for our timer function */
182. data->prevjiffies = j;
183. data->buf = buf2;
184. data->loops = JIT_ASYNC_LOOPS;
186. /* register the timer */
187. data->timer.data = (unsigned long)data;
188. data->timer.function = jit_timer_fn;
189. data->timer.expires = j + tdelay; /* parameter */
190. add_timer(&data->timer);
192. /* wait for the buffer to fill */
193. wait_event_interruptible(data->wait, !data->loops);
194. if (signal_pending(current))
195. return -ERESTARTSYS;
196. buf2 = data->buf;
197. kfree(data);
198. *eof = 1;
199. return buf2 - buf;
200. }
202. void jit_tasklet_fn(unsigned long arg)
203. {
204. struct jit_data *data = (struct jit_data *)arg;
205. unsigned long j = jiffies;
206. data->buf += sprintf(data->buf, "%9li %3li %i %6i %i %s\n",
207. j, j - data->prevjiffies, in_interrupt() ? 1 : 0,
208. current->pid, smp_processor_id(), current->comm);
210. if (--data->loops) {
211. data->prevjiffies = j;
212. if (data->hi)
213. tasklet_hi_schedule(&data->tlet);
214. else
215. tasklet_schedule(&data->tlet);
216. } else {
217. wake_up_interruptible(&data->wait);
218. }
219. }
221. /* the /proc function: allocate everything to allow concurrency */
222. int jit_tasklet(char *buf, char **start, off_t offset,
223. int len, int *eof, void *arg)
224. {
225. struct jit_data *data;
226. char *buf2 = buf;
227. unsigned long j = jiffies;
228. long hi = (long)arg;
230. data = kmalloc(sizeof(*data), GFP_KERNEL);
231. if (!data)
232. return -ENOMEM;
234. init_waitqueue_head (&data->wait);
236. /* write the first lines in the buffer */
237. buf2 += sprintf(buf2, " time delta inirq pid cpu command\n");
238. buf2 += sprintf(buf2, "%9li %3li %i %6i %i %s\n",
239. j, 0L, in_interrupt() ? 1 : 0,
240. current->pid, smp_processor_id(), current->comm);
242. /* fill the data for our tasklet function */
243. data->prevjiffies = j;
244. data->buf = buf2;
245. data->loops = JIT_ASYNC_LOOPS;
247. /* register the tasklet */
248. tasklet_init(&data->tlet, jit_tasklet_fn, (unsigned long)data);
249. data->hi = hi;
250. if (hi)
251. tasklet_hi_schedule(&data->tlet);
252. else
253. tasklet_schedule(&data->tlet);
255. /* wait for the buffer to fill */
256. wait_event_interruptible(data->wait, !data->loops);
258. if (signal_pending(current))
259. return -ERESTARTSYS;
260. buf2 = data->buf;
261. kfree(data);
262. *eof = 1;
263. return buf2 - buf;
264. }
268. int __init jit_init(void)
269. {
270. create_proc_read_entry("currentime", 0, NULL, jit_currentime, NULL);
271. create_proc_read_entry("jitbusy", 0, NULL, jit_fn, (void *)JIT_BUSY);
272. create_proc_read_entry("jitsched",0, NULL, jit_fn, (void *)JIT_SCHED);
273. create_proc_read_entry("jitqueue",0, NULL, jit_fn, (void *)JIT_QUEUE);
274. create_proc_read_entry("jitschedto", 0, NULL, jit_fn, (void *)JIT_SCHEDTO);
276. create_proc_read_entry("jitimer", 0, NULL, jit_timer, NULL);
277. create_proc_read_entry("jitasklet", 0, NULL, jit_tasklet, NULL);
278. create_proc_read_entry("jitasklethi", 0, NULL, jit_tasklet, (void *)1);
280. return 0; /* success */
281. }
283. void __exit jit_cleanup(void)
284. {
285. remove_proc_entry("currentime", NULL);
286. remove_proc_entry("jitbusy", NULL);
287. remove_proc_entry("jitsched", NULL);
288. remove_proc_entry("jitqueue", NULL);
289. remove_proc_entry("jitschedto", NULL);
291. remove_proc_entry("jitimer", NULL);
292. remove_proc_entry("jitasklet", NULL);
293. remove_proc_entry("jitasklethi", NULL);
294. }
296. module_init(jit_init);
297. module_exit(jit_cleanup);