![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to defer.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / f / etc / conf / streams / src|
Return to defer.c CVS log | Up to [MW Coherent from dump] / coherent / f / etc / conf / streams / src |
1.1 root 1: #define _DDI_DKI 1
2: #define _DDI_DKI_IMPL 1
3: #define _SYSV4 1
4:
5: /*
6: *-IMPORTS:
7: * <common/ccompat.h>
8: * __USE_PROTO__
9: * __ARGS ()
10: * <sys/debug.h>
11: * ASSERT ()
12: * <kernel/ddi_cpu.h>
13: * dcdata_t
14: * ddi_cpu_data ()
15: * <kernel/ddi_glob.h>
16: * dgdata_t
17: * ddi_global_data ()
18: * <kernel/ddi_lock.h>
19: * defer_priority
20: * defer_hierarchy
21: * <sys/ksynch.h>
22: * LOCK ()
23: * UNLOCK ()
24: * <sys/cmn_err.h>
25: * CE_WARN
26: * cmn_err ()
27: * <sys/stdlib.h>
28: * NULL
29: */
30:
31: #include <common/ccompat.h>
32: #include <kernel/ddi_cpu.h>
33: #include <kernel/ddi_glob.h>
34: #include <kernel/ddi_lock.h>
35: #include <sys/debug.h>
36: #include <sys/ksynch.h>
37: #include <sys/cmn_err.h>
38: #include <stddef.h>
39:
40: #include <kernel/defer.h>
41:
42:
43: /*
44: * This internal function queues a deferred function on a deferred-function
45: * queue.
46: */
47:
48: #if __USE_PROTO__
49: __LOCAL__ int (DEFER) (defer_t * deferp, __deffuncp_t funcp)
50: #else
51: __LOCAL__ int
52: DEFER __ARGS ((deferp, funcp))
53: defer_t * deferp;
54: __deffuncp_t funcp;
55: #endif
56: {
57: pl_t prev_pl;
58: int idx;
59:
60: ASSERT (funcp != NULL);
61: ASSERT (deferp != NULL);
62: ASSERT (deferp->df_tab != NULL);
63: ASSERT (ATOMIC_FETCH_UCHAR (deferp->df_max) > 0);
64:
65: prev_pl = LOCK (deferp->df_wlock, defer_priority);
66:
67: /*
68: * Write the function pointer into the next free slot in the table,
69: * and then move the write pointer to the next entry in the circular
70: * buffer.
71: */
72:
73: idx = ATOMIC_FETCH_UCHAR (deferp->df_write);
74:
75: deferp->df_tab [idx ++] = funcp;
76:
77: if (idx == ATOMIC_FETCH_UCHAR (deferp->df_max))
78: idx = 0;
79:
80: /*
81: * If the write pointer bumps into the read pointer, then the defer
82: * table is full and we should complain. A possible alternative
83: * strategy would be to wait for the other processor, but that is only
84: * a good idea if we have the machinery to interrupt it available,
85: * which we currently do not.
86: */
87:
88: if (idx != ATOMIC_FETCH_UCHAR (deferp->df_read)) {
89: /*
90: * Store the updated write pointer and prepare to return
91: * success.
92: */
93:
94: ATOMIC_STORE_UCHAR (deferp->df_write, idx);
95: idx = 0;
96: } else {
97:
98: cmn_err (CE_WARN, "table overflow in DEFER ()");
99: idx = 1; /* flag failure to the caller */
100: }
101:
102: UNLOCK (deferp->df_wlock, prev_pl);
103:
104: return idx;
105: }
106:
107:
108: /*
109: *-STATUS:
110: * For the Implementors only.
111: *
112: *-NAME:
113: * defer_int_cpu Defer a routine on a specified CPU.
114: *
115: *-SYNOPSIS:
116: * #include <kernel/defer.h>
117: *
118: * int defer_int_cpu (void (* funcp) (void), processorid_t cpuid);
119: *
120: *-ARGUMENTS:
121: * funcp Pointer to the function to be executed upon the given
122: * processor's return from kernel execution to user-level
123: * execution.
124: *
125: * cpuid Processor on which "funcp" is to be executed.
126: *
127: *-DESCRIPTION:
128: * defer_int_cpu () requests that a function be executed on the given CPU
129: * at a priority higher than any user-level code. If the given CPU is
130: * currently executing kernel code, the function will be run before user-
131: * level execution is resumed. The routine is run at a priority lower
132: * than any interrupt-level code; if the implementation permits, the
133: * routine will be run at a priority higher than base kernel code, but
134: * this is not guaranteed.
135: *
136: * The implementation will make a best effort to ensure that the deferred
137: * function is executed promptly. However, some hardware configurations
138: * may not permit one CPU to interrupt another under software control, so
139: * if the specified CPU is currently running at user level it may not
140: * execute the deferred function for some time.
141: *
142: *-RETURN VALUE:
143: * 0 is returned on success. If the specified CPU is invalid, or the
144: * deferred-function table for the specified CPU is full, then a non-zero
145: * error value is returned.
146: *
147: *-LEVEL:
148: * Base or interrupt.
149: *
150: *-NOTES:
151: * Does not sleep.
152: *
153: * It is currently unspecified whether the function pointed to by "funcp"
154: * is permitted to contend for locks held by the caller.
155: */
156:
157: #if __USE_PROTO__
158: int (defer_int_cpu) (__deffuncp_t funcp, processorid_t cpuid)
159: #else
160: int
161: defer_int_cpu __ARGS ((funcp, cpuid))
162: __deffuncp_t funcp;
163: processorid_t cpuid;
164: #endif
165: {
166: dcdata_t * dcdatap;
167: int retval;
168:
169: ASSERT (funcp != NULL);
170:
171: if ((dcdatap = ddi_cpu_ref (cpuid)) == NULL)
172: return -1;
173:
174: retval = DEFER (& dcdatap->dc_defint, funcp);
175:
176: ddi_cpu_unref (dcdatap);
177: return retval;
178: }
179:
180:
181: /*
182: *-STATUS:
183: * For the Implementors only.
184: *
185: *-NAME:
186: * defer_int_any Defer a routine on an unspecified CPU.
187: *
188: *-SYNOPSIS:
189: * #include <kernel/defer.h>
190: *
191: * int defer_int_any (void (* funcp) (void));
192: *
193: *-ARGUMENTS:
194: * funcp Pointer to the function to be executed upon some
195: * processor's return from kernel execution to user-level
196: * execution.
197: *
198: *-DESCRIPTION:
199: * defer_int_any () requests that a function be executed at some future
200: * time convenient to the implementation. The routine will be run at a
201: * priority higher than any user-level code, and lower than any
202: * interrupt-level code; if the implementation permits, the function will
203: * be run at a priority higher than base kernel code, but this is not
204: * guaranteed.
205: *
206: * The function will be executed on the first CPU available. However, a
207: * typical implementation would not interrupt user-level execution on
208: * any other CPUs merely to run deferred functions.
209: *
210: *-RETURN VALUE:
211: * 0 is returned on success. If the global deferred-function table is
212: * full, then a non-zero error value is returned.
213: *
214: *-LEVEL:
215: * Base or interrupt.
216: *
217: *-NOTES:
218: * Does not sleep.
219: *
220: * It is currently unspecified whether the function pointed to by "funcp"
221: * is permitted to contend for locks held by the caller.
222: */
223:
224: #if __USE_PROTO__
225: int (defer_int_any) (__deffuncp_t funcp)
226: #else
227: int
228: defer_int_any __ARGS ((funcp))
229: __deffuncp_t funcp;
230: #endif
231: {
232: return DEFER (& ddi_global_data ()->dg_defint, funcp);
233: }
234:
235:
236: /*
237: *-STATUS:
238: * For the Implementors only.
239: *
240: *-NAME:
241: * defer_int_here Defer a routine on the current CPU.
242: *
243: *-SYNOPSIS:
244: * #include <kernel/defer.h>
245: *
246: * int defer_int_here (void (* funcp) (void));
247: *
248: *-ARGUMENTS:
249: * funcp Pointer to the function to be executed upon this
250: * processor's return from kernel execution to user-level
251: * execution.
252: *
253: *-DESCRIPTION:
254: * defer_int_here () requests that a function be executed at some future
255: * time convenient to the implementation on the current CPU. The routine
256: * will be run at a priority higher than any user-level code, and lower
257: * than any interrupt-level code; if the implementation permits, the
258: * function will run at a level higher than base kernel code, but this is
259: * not guaranteed.
260: *
261: *-RETURN VALUE:
262: * 0 is returned on success. If the current CPUs deferred-function table
263: * is full, then a non-zero error value is returned.
264: *
265: *-LEVEL:
266: * Base or interrupt.
267: *
268: *-NOTES:
269: * Does not sleep.
270: *
271: * It is currently unspecified whether the function pointed to by "funcp"
272: * is permitted to contend for locks held by the caller.
273: */
274:
275: #if __USE_PROTO__
276: int (defer_int_here) (__deffuncp_t funcp)
277: #else
278: int
279: defer_int_here __ARGS ((funcp))
280: __deffuncp_t funcp;
281: #endif
282: {
283: return DEFER (& ddi_cpu_data ()->dc_defint, funcp);
284: }
285:
286:
287: /*
288: *-STATUS:
289: * For the Implementors only.
290: *
291: *-NAME:
292: * defer_proc_cpu Defer a routine on a specified CPU.
293: *
294: *-SYNOPSIS:
295: * #include <kernel/defer.h>
296: *
297: * int defer_proc_cpu (void (* funcp) (void), processorid_t cpuid);
298: *
299: *-ARGUMENTS:
300: * funcp Pointer to the function to be executed upon the given
301: * processor's return from kernel execution to user-level
302: * execution.
303: *
304: * cpuid Processor on which "funcp" is to be executed.
305: *
306: *-DESCRIPTION:
307: * defer_proc_cpu () requests that a function be executed on the given CPU
308: * at a priority higher than any user-level code. If the given CPU is
309: * currently executing kernel code, the function will be run before user-
310: * level execution is resumed.
311: *
312: * The implementation will make a best effort to ensure that the deferred
313: * function is executed promptly. However, some hardware configurations
314: * may not permit one CPU to interrupt another under software control, so
315: * if the specified CPU is currently running at user level it may not
316: * execute the deferred function for some time.
317: *
318: *-RETURN VALUE:
319: * 0 is returned on success. If the specified CPU is invalid, or the
320: * deferred-function table for the specified CPU is full, then a non-zero
321: * error value is returned.
322: *
323: *-LEVEL:
324: * Base or interrupt.
325: *
326: *-NOTES:
327: * Does not sleep.
328: *
329: * It is currently unspecified whether the function pointed to by "funcp"
330: * is permitted to contend for locks held by the caller.
331: */
332:
333: #if __USE_PROTO__
334: int (defer_proc_cpu) (__deffuncp_t funcp, processorid_t cpuid)
335: #else
336: int
337: defer_proc_cpu __ARGS ((funcp, cpuid))
338: __deffuncp_t funcp;
339: processorid_t cpuid;
340: #endif
341: {
342: dcdata_t * dcdatap;
343: int retval;
344:
345: ASSERT (funcp != NULL);
346:
347: if ((dcdatap = ddi_cpu_ref (cpuid)) == NULL)
348: return -1;
349:
350: retval = DEFER (& dcdatap->dc_defproc, funcp);
351:
352: ddi_cpu_unref (dcdatap);
353: return retval;
354: }
355:
356:
357: /*
358: *-STATUS:
359: * For the Implementors only.
360: *
361: *-NAME:
362: * defer_proc_any Defer a routine on an unspecified CPU.
363: *
364: *-SYNOPSIS:
365: * #include <kernel/defer.h>
366: *
367: * int defer_proc_any (void (* funcp) (void));
368: *
369: *-ARGUMENTS:
370: * funcp Pointer to the function to be executed upon some
371: * processor's return from kernel execution to user-level
372: * execution.
373: *
374: *-DESCRIPTION:
375: * defer_proc_any () requests that a function be executed at some future
376: * time convenient to the implementation. The routine will be run at a
377: * priority higher than any user-level code, and lower than any
378: * interrupt-level code or kernel code.
379: *
380: * The function will be executed on the first CPU available. However, a
381: * typical implementation would not interrupt user-level execution on
382: * any other CPUs merely to run deferred functions.
383: *
384: *-RETURN VALUE:
385: * 0 is returned on success. If the global deferred-function table is
386: * full, then a non-zero error value is returned.
387: *
388: *-LEVEL:
389: * Base or interrupt.
390: *
391: *-NOTES:
392: * Does not sleep.
393: *
394: * It is currently unspecified whether the function pointed to by "funcp"
395: * is permitted to contend for locks held by the caller.
396: */
397:
398: #if __USE_PROTO__
399: int (defer_proc_any) (__deffuncp_t funcp)
400: #else
401: int
402: defer_proc_any __ARGS ((funcp))
403: __deffuncp_t funcp;
404: #endif
405: {
406: return DEFER (& ddi_global_data ()->dg_defproc, funcp);
407: }
408:
409:
410: /*
411: *-STATUS:
412: * For the Implementors only.
413: *
414: *-NAME:
415: * defer_proc_here Defer a routine on the current CPU.
416: *
417: *-SYNOPSIS:
418: * #include <kernel/defer.h>
419: *
420: * int defer_proc_here (void (* funcp) (void));
421: *
422: *-ARGUMENTS:
423: * funcp Pointer to the function to be executed upon this
424: * processor's return from kernel execution to user-level
425: * execution.
426: *
427: *-DESCRIPTION:
428: * defer_proc_here () requests that a function be executed at some futur
429: * time convenient to the implementation on the current CPU. The routine
430: * will be run at a priority higher than any user-level code, and lower
431: * than any interrupt-level code or kernel code.
432: *
433: *-RETURN VALUE:
434: * 0 is returned on success. If the current CPUs deferred-function table
435: * is full, then a non-zero error value is returned.
436: *
437: *-LEVEL:
438: * Base or interrupt.
439: *
440: *-NOTES:
441: * Does not sleep.
442: *
443: * It is currently unspecified whether the function pointed to by "funcp"
444: * is permitted to contend for locks held by the caller.
445: */
446:
447: #if __USE_PROTO__
448: int (defer_proc_here) (__deffuncp_t funcp)
449: #else
450: int
451: defer_proc_here __ARGS ((funcp))
452: __deffuncp_t funcp;
453: #endif
454: {
455: return DEFER (& ddi_cpu_data ()->dc_defproc, funcp);
456: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.