自学教程：C++ tick_setup_periodic函数代码示例

/** * tick_broadcast_control - Enable/disable or force broadcast mode * @mode:	The selected broadcast mode * * Called when the system enters a state where affected tick devices * might stop. Note: TICK_BROADCAST_FORCE cannot be undone. * * Called with interrupts disabled, so clockevents_lock is not * required here because the local clock event device cannot go away * under us. */void tick_broadcast_control(enum tick_broadcast_mode mode){	struct clock_event_device *bc, *dev;	struct tick_device *td;	int cpu, bc_stopped;	td = this_cpu_ptr(&tick_cpu_device);	dev = td->evtdev;	/*	 * Is the device not affected by the powerstate ?	 */	if (!dev || !(dev->features & CLOCK_EVT_FEAT_C3STOP))		return;	if (!tick_device_is_functional(dev))		return;	raw_spin_lock(&tick_broadcast_lock);	cpu = smp_processor_id();	bc = tick_broadcast_device.evtdev;	bc_stopped = cpumask_empty(tick_broadcast_mask);	switch (mode) {	case TICK_BROADCAST_FORCE:		tick_broadcast_forced = 1;	case TICK_BROADCAST_ON:		cpumask_set_cpu(cpu, tick_broadcast_on);		if (!cpumask_test_and_set_cpu(cpu, tick_broadcast_mask)) {			if (tick_broadcast_device.mode ==			    TICKDEV_MODE_PERIODIC)				clockevents_shutdown(dev);		}		break;	case TICK_BROADCAST_OFF:		if (tick_broadcast_forced)			break;		cpumask_clear_cpu(cpu, tick_broadcast_on);		if (!tick_device_is_functional(dev))			break;		if (cpumask_test_and_clear_cpu(cpu, tick_broadcast_mask)) {			if (tick_broadcast_device.mode ==			    TICKDEV_MODE_PERIODIC)				tick_setup_periodic(dev, 0);		}		break;	}	if (cpumask_empty(tick_broadcast_mask)) {		if (!bc_stopped)			clockevents_shutdown(bc);	} else if (bc_stopped) {		if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC)			tick_broadcast_start_periodic(bc);		else			tick_broadcast_setup_oneshot(bc);	}	raw_spin_unlock(&tick_broadcast_lock);}

/* * Setup the tick device */static void tick_setup_device(struct tick_device *td,			      struct clock_event_device *newdev, int cpu,			      const struct cpumask *cpumask){	ktime_t next_event;	void (*handler)(struct clock_event_device *) = NULL;	/*	 * First device setup ?	 */	if (!td->evtdev) {		/*		 * If no cpu took the do_timer update, assign it to		 * this cpu:		 */		if (tick_do_timer_cpu == TICK_DO_TIMER_BOOT) {			if (!tick_nohz_full_cpu(cpu))				tick_do_timer_cpu = cpu;			else				tick_do_timer_cpu = TICK_DO_TIMER_NONE;			tick_next_period = ktime_get();			tick_period = ktime_set(0, NSEC_PER_SEC / HZ);		}		/*		 * Startup in periodic mode first.		 */		td->mode = TICKDEV_MODE_PERIODIC;	} else {		handler = td->evtdev->event_handler;		next_event = td->evtdev->next_event;		td->evtdev->event_handler = clockevents_handle_noop;	}	td->evtdev = newdev;	/*	 * When the device is not per cpu, pin the interrupt to the	 * current cpu:	 */	if (!cpumask_equal(newdev->cpumask, cpumask))		irq_set_affinity(newdev->irq, cpumask);	/*	 * When global broadcasting is active, check if the current	 * device is registered as a placeholder for broadcast mode.	 * This allows us to handle this x86 misfeature in a generic	 * way. This function also returns !=0 when we keep the	 * current active broadcast state for this CPU.	 */	if (tick_device_uses_broadcast(newdev, cpu))		return;	if (td->mode == TICKDEV_MODE_PERIODIC)		tick_setup_periodic(newdev, 0);	else		tick_setup_oneshot(newdev, handler, next_event);}

/** * tick_resume_local - Resume the local tick device * * Called from the local CPU for unfreeze or XEN resume magic. * * No locks required. Nothing can change the per cpu device. */void tick_resume_local(void){	struct tick_device *td = this_cpu_ptr(&tick_cpu_device);	bool broadcast = tick_resume_check_broadcast();	clockevents_tick_resume(td->evtdev);	if (!broadcast) {		if (td->mode == TICKDEV_MODE_PERIODIC)			tick_setup_periodic(td->evtdev, 0);		else			tick_resume_oneshot();	}}

void tick_resume(void){	struct tick_device *td = &__get_cpu_var(tick_cpu_device);	int broadcast = tick_resume_broadcast();	clockevents_set_mode(td->evtdev, CLOCK_EVT_MODE_RESUME);	if (!broadcast) {		if (td->mode == TICKDEV_MODE_PERIODIC)			tick_setup_periodic(td->evtdev, 0);		else			tick_resume_oneshot();	}}

static void tick_resume(void){	struct tick_device *td = &__get_cpu_var(tick_cpu_device);	unsigned long flags;	int broadcast = tick_resume_broadcast();	raw_spin_lock_irqsave(&tick_device_lock, flags);	clockevents_set_mode(td->evtdev, CLOCK_EVT_MODE_RESUME);	if (!broadcast) {		if (td->mode == TICKDEV_MODE_PERIODIC)			tick_setup_periodic(td->evtdev, 0);		else			tick_resume_oneshot();	}	raw_spin_unlock_irqrestore(&tick_device_lock, flags);}

/** * tick_broadcast_control - Enable/disable or force broadcast mode * @mode:	The selected broadcast mode * * Called when the system enters a state where affected tick devices * might stop. Note: TICK_BROADCAST_FORCE cannot be undone. */void tick_broadcast_control(enum tick_broadcast_mode mode){	struct clock_event_device *bc, *dev;	struct tick_device *td;	int cpu, bc_stopped;	unsigned long flags;	/* Protects also the local clockevent device. */	raw_spin_lock_irqsave(&tick_broadcast_lock, flags);	td = this_cpu_ptr(&tick_cpu_device);	dev = td->evtdev;	/*	 * Is the device not affected by the powerstate ?	 */	if (!dev || !(dev->features & CLOCK_EVT_FEAT_C3STOP))		goto out;	if (!tick_device_is_functional(dev))		goto out;	cpu = smp_processor_id();	bc = tick_broadcast_device.evtdev;	bc_stopped = cpumask_empty(tick_broadcast_mask);	switch (mode) {	case TICK_BROADCAST_FORCE:		tick_broadcast_forced = 1;	case TICK_BROADCAST_ON:		cpumask_set_cpu(cpu, tick_broadcast_on);		if (!cpumask_test_and_set_cpu(cpu, tick_broadcast_mask)) {			/*			 * Only shutdown the cpu local device, if:			 *			 * - the broadcast device exists			 * - the broadcast device is not a hrtimer based one			 * - the broadcast device is in periodic mode to			 *   avoid a hickup during switch to oneshot mode			 */			if (bc && !(bc->features & CLOCK_EVT_FEAT_HRTIMER) &&			    tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC)				clockevents_shutdown(dev);		}		break;	case TICK_BROADCAST_OFF:		if (tick_broadcast_forced)			break;		cpumask_clear_cpu(cpu, tick_broadcast_on);		if (cpumask_test_and_clear_cpu(cpu, tick_broadcast_mask)) {			if (tick_broadcast_device.mode ==			    TICKDEV_MODE_PERIODIC)				tick_setup_periodic(dev, 0);		}		break;	}	if (bc) {		if (cpumask_empty(tick_broadcast_mask)) {			if (!bc_stopped)				clockevents_shutdown(bc);		} else if (bc_stopped) {			if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC)				tick_broadcast_start_periodic(bc);			else				tick_broadcast_setup_oneshot(bc);		}	}out:	raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);}

/* * Setup the tick device */static void tick_setup_device(struct tick_device *td,			      struct clock_event_device *newdev, int cpu,			      const struct cpumask *cpumask){	void (*handler)(struct clock_event_device *) = NULL;	ktime_t next_event = 0;	/*	 * First device setup ?	 */	if (!td->evtdev) {		/*		 * If no cpu took the do_timer update, assign it to		 * this cpu:		 */		if (tick_do_timer_cpu == TICK_DO_TIMER_BOOT) {			tick_do_timer_cpu = cpu;			tick_next_period = ktime_get();			tick_period = NSEC_PER_SEC / HZ;#ifdef CONFIG_NO_HZ_FULL			/*			 * The boot CPU may be nohz_full, in which case set			 * tick_do_timer_boot_cpu so the first housekeeping			 * secondary that comes up will take do_timer from			 * us.			 */			if (tick_nohz_full_cpu(cpu))				tick_do_timer_boot_cpu = cpu;		} else if (tick_do_timer_boot_cpu != -1 &&						!tick_nohz_full_cpu(cpu)) {			tick_take_do_timer_from_boot();			tick_do_timer_boot_cpu = -1;			WARN_ON(tick_do_timer_cpu != cpu);#endif		}		/*		 * Startup in periodic mode first.		 */		td->mode = TICKDEV_MODE_PERIODIC;	} else {		handler = td->evtdev->event_handler;		next_event = td->evtdev->next_event;		td->evtdev->event_handler = clockevents_handle_noop;	}	td->evtdev = newdev;	/*	 * When the device is not per cpu, pin the interrupt to the	 * current cpu:	 */	if (!cpumask_equal(newdev->cpumask, cpumask))		irq_set_affinity(newdev->irq, cpumask);	/*	 * When global broadcasting is active, check if the current	 * device is registered as a placeholder for broadcast mode.	 * This allows us to handle this x86 misfeature in a generic	 * way. This function also returns !=0 when we keep the	 * current active broadcast state for this CPU.	 */	if (tick_device_uses_broadcast(newdev, cpu))		return;	if (td->mode == TICKDEV_MODE_PERIODIC)		tick_setup_periodic(newdev, 0);	else		tick_setup_oneshot(newdev, handler, next_event);}