Lines Matching refs:level
60 * The cyclic subsystem is a low-level kernel subsystem designed to provide
63 * can be specified to fire at high, lock or low interrupt level, and may be
304 * CY_HIGH_LEVEL and its execution at the desired level (either CY_HIGH_LEVEL,
311 * potential disconnect: if the CPU is at an interrupt level less than
312 * CY_HIGH_LEVEL but greater than the level of a cyclic for a period of
320 * expired cyclic and posts a soft interrupt at the desired level. In the
328 * level, cyclic_softint() must be able to quickly determine which cyclics
330 * level producer/consumer buffer shared with CY_HIGH_LEVEL. These buffers
381 * level: readers and writers are required to raise their interrupt level
382 * to that of the highest level writer.
387 * programmable interrupt level is undesirable: aside from the additional
388 * latency incurred by manipulating interrupt level in the hot cy_pend
389 * processing path, this would create the potential for soft level cy_pend
398 * because these routines execute at a higher interrupt level than
455 * 3. cyclic_expand_xcall() raises interrupt level to CY_HIGH_LEVEL
463 * level: a hard buffer (the buffer being produced into by cyclic_expire())
482 * soft interrupt will be generated for the remaining level.
518 * 2. cyclic_remove_xcall() raises interrupt level to CY_HIGH_LEVEL
569 * If a high-level cyclic handler reprograms its own cyclic, then
571 * expiration. However, for a lock-level or a low-level cyclic, the
586 * 2. cyclic_reprogram_xcall() raises interrupt level to CY_HIGH_LEVEL
598 * operations, the interrupt level is raised during reprogramming. Plus,
652 cyclic_coverage(char *why, int level, uint64_t arg0, uint64_t arg1)
679 if (level == CY_PASSIVE_LEVEL)
682 cyc_coverage[ndx].cyv_count[level]++;
688 #define CYC_TRACE(cpu, level, why, arg0, arg1) \
689 CYC_TRACE_IMPL(&cpu->cyp_trace[level], level, why, arg0, arg1)
694 #define CYC_TRACE_IMPL(buf, level, why, a0, a1) { \
703 cyclic_coverage(why, level, \
712 #define CYC_TRACE(cpu, level, why, arg0, arg1)
717 #define CYC_TRACE0(cpu, level, why) CYC_TRACE(cpu, level, why, 0, 0)
718 #define CYC_TRACE1(cpu, level, why, arg0) CYC_TRACE(cpu, level, why, arg0, 0)
855 cyc_level_t level = cyclic->cy_level;
861 if (level == CY_HIGH_LEVEL) {
878 * be atomic (the high interrupt level assures that it will appear
882 cyc_softbuf_t *softbuf = &cpu->cyp_softbuf[level];
985 * If a hi level cyclic reprograms itself,
1039 cyclic_remove_pend(cyc_cpu_t *cpu, cyc_level_t level, cyclic_t *cyclic)
1050 CYC_TRACE(cpu, level, "remove-rpend", cyclic, cpu->cyp_rpend);
1057 CYC_TRACE(cpu, level, "rpend-in", handler, arg);
1063 CYC_TRACE(cpu, level, "rpend-out", handler, arg);
1073 * cyclic_softint(cpu_t *cpu, cyc_level_t level)
1084 * CPU. The second argument is the level of the soft interrupt; it must
1088 * specified level. cyclic_softint() will not return until all pending
1089 * cyclics at the specified level have been dealt with; intervening
1090 * CY_HIGH_LEVEL interrupts which enqueue cyclics at the specified level
1114 * CY_LOCK_LEVEL or CY_LOW_LEVEL. The level passed to cyclic_softint()
1115 * must match the level at which it is executing. On optimal backends,
1121 cyclic_softint(cpu_t *c, cyc_level_t level)
1130 CYC_TRACE(cpu, level, "softint", cyclics, 0);
1132 ASSERT(level < CY_LOW_LEVEL + CY_SOFT_LEVELS);
1134 softbuf = &cpu->cyp_softbuf[level];
1144 CYC_TRACE(cpu, level, "softint-top", cyclics, pc);
1154 CYC_TRACE(cpu, level, "consuming", consndx, cyclic);
1178 CYC_TRACE(cpu, level, "handler-in", handler, arg);
1184 CYC_TRACE(cpu, level, "handler-out", handler, arg);
1202 cyclic_remove_pend(cpu, level, cyclic);
1209 CYC_TRACE(cpu, level, "resize-int", cyclics, 0);
1229 * (a) An intervening high level bumped up the
1249 CYC_TRACE(cpu, level, "cas-fail", opend, pend);
1269 * If the high level handler is no longer writing to the same
1278 CYC_TRACE(cpu, level, "buffer-grow", 0, 0);
1291 CYC_TRACE1(cpu, level, "resize-int-int", consndx);
1320 * If we are the last soft level to see the modification,
1322 * already at low level), post down to the next soft level.
1325 CYC_TRACE0(cpu, level, "resize-kick");
1329 if (level != CY_LOW_LEVEL) {
1332 CYC_TRACE0(cpu, level, "resize-post");
1333 be->cyb_softint(be->cyb_arg, level - 1);
1353 * This is a little dicey. First, we'll raise our interrupt level
1375 * softints (which are executing at a lower priority level), the
1899 cyc_level_t level = cyclic->cy_level;
1921 ASSERT(!(level == CY_HIGH_LEVEL && cpu->cyp_rpend != 0));
2724 * to the specified level (i.e. either high, lock or low level). The
3529 * of cyclic_suspend(), cyclic handlers at its level may continue to be
3552 * cannot be in high-level interrupt context. However, unlike most other
3605 * cannot be in high-level interrupt context. However, unlike most other