dev/cyclic/cyclic.c

45  *  absolute time.  As a result, these parts cannot typically be reprogrammed
53  *  present a time-based interrupt source which can be reprogrammed arbitrarily
68  *  Alternatively, a cyclic may be specified to be "omnipresent", denoting
135  *  the array will be doubled.  The array will never shrink.  Cyclics are
154  *  (guaranteed to be the earliest in the heap) is then communicated to the
186  *  The heap array could be:
225  *  then all siblings are guaranteed to be on the same cache line.  Thus, the
246  *  Heaps must always be full, balanced trees.  Heap management must therefore
258  *  of decrementing the number of elements, swapping the to-be-deleted element
303  *  with concurrent resizes.  Resizes should be rare; they may induce jitter
307  *  Three key cyc_cpu data structures need to be resized:  the cyclics array,
318  *  Cyclic removals should be rare.  To simplify the implementation (and to
499  *    cyclic_fire() may be called spuriously without ill effect.  Optimal
516 	cyc_backend_t *be = cpu->cyp_backend;
519 	void *arg = be->cyb_arg;
541 		 * If this cyclic will be set to next expire in the distant
550 		 * In either case, we set the new expiration time to be the
554 		 * We arbitrarily define "distant" to be one second (one second
575 	be->cyb_reprogram(arg, exp);
600 	 * Set up the free list, and set all of the new cyclics to be CYF_FREE.
628 	cyc_backend_t *be = cpu->cyp_backend;
653 	be->cyb_xcall(be->cyb_arg, cpu->cyp_cpu,
670 	cyc_backend_t *be = cpu->cyp_backend;
672 	cyb_arg_t bar = be->cyb_arg;
686 		be->cyb_enable(bar);
717 		be->cyb_reprogram(bar, exp);
728 	cyc_backend_t *be = cpu->cyp_backend;
729 	cyb_arg_t bar = be->cyb_arg;
746 	 * By now, we know that we're going to be able to successfully
755 	be->cyb_xcall(bar, cpu->cyp_cpu, (cyc_func_t)cyclic_add_xcall, &arg);
764 	cyc_backend_t *be = cpu->cyp_backend;
765 	cyb_arg_t bar = be->cyb_arg;
779 	 * will be used when the cyclic is added to the new CPU.
809 		be->cyb_disable(bar);
850 	be->cyb_reprogram(bar, cyclic->cy_expire);
858 	cyc_backend_t *be = cpu->cyp_backend;
869 	be->cyb_xcall(be->cyb_arg, cpu->cyp_cpu,
905 	 * On platforms where stray interrupts may be taken during startup,
918 	cyc_backend_t *be = cpu->cyp_backend;
919 	cyb_arg_t bar = be->cyb_arg;
929 	if (be->cyb_unconfigure != NULL)
930 		be->cyb_unconfigure(bar);
931 	free(be, M_CYCLIC);
1023 	 * cyc_id_t is an omnipresent cyclic.  Note that cyi_omni_list may be
1072  *    The cyt_interval field _must_ be filled in by the caller; one-shots are
1076  *    cyt_when + cyt_interval <= INT64_MAX.  Neither field may be negative.
1080  *    be true even if interrupts have been disabled for periods greater than
1082  *    the cyclic handler may be called a finite number of times with an
1093  *    cyclic_add() returns a cyclic_id_t, which is guaranteed to be a value
1098  *    cpu_lock must be held by the caller, and the caller must not be in
1100  *    memory allocation, so the usual rules (e.g. p_lock cannot be held)
1101  *    apply.  A cyclic may be added even in the presence of CPUs that have
1103  *    configured CPUs will be eligible to run the new cyclic.
1107  *    Cyclic handlers will be executed in the interrupt context corresponding
1148  *      void *cyo_arg          <-- Argument to be passed to on/offline handlers
1156  *      cpu_t *                <-- Pointer to CPU about to be onlined
1157  *      cyc_handler_t *        <-- Pointer to cyc_handler_t; must be filled in
1159  *      cyc_time_t *           <-- Pointer to cyc_time_t; must be filled in by
1171  *      (b)  be explicitly in or out of phase with one another
1182  *    call back into the cyclic subsystem, and should be generally careful
1191  *      cpu_t *                <-- Pointer to CPU about to be offlined
1202  *    The offline handler is optional; it may be NULL.
1206  *    cyclic_add_omni() returns a cyclic_id_t, which is guaranteed to be a
1260  *    This leads to an important constraint on the caller:  no lock may be
1261  *    held across cyclic_remove() that also may be acquired by a cyclic
1270  *    cpu_lock must be held by the caller, and the caller must not be in
1306 cyclic_init(cyc_backend_t *be)
1312 	 * be done before the CPU can be configured.
1314 	bcopy(be, &cyclic_backend, sizeof (cyc_backend_t));