RTAI API: base/sched/sched.c File Reference

do { \ RT_TASK *task = rt_smp_linux_task[cpuid].rnext; \ while (ready_task->priority >= task->priority) { \ if ((task = task->rnext)->priority < 0) break; \ } \ task->rprev = (ready_task->rprev = task->rprev)->rnext = ready_task; \ ready_task->rnext = task; \ } while (0)

do { \ RTIME now; \ now = rdtsc(); \ if (!rt_current->lnxtsk) { \ rt_current->exectime[0] += (now - switch_time[cpuid]); \ } \ switch_time[cpuid] = now; \ } while (0)

do { \ wake_up_hts[cpuid].task[wake_up_hts[cpuid].in++ & (MAX_WAKEUP_SRQ - 1)] = lnxtsk; \ hal_pend_uncond(wake_up_srq[cpuid].srq, cpuid); \ } while (0)

do { \ if (CONFIG_RTAI_ALLOW_RR && new_task->policy > 0) { \ preempt = 1; \ if (new_task->yield_time < rt_times.intr_time) { \ rt_times.intr_time = new_task->yield_time; \ } \ } else { \ preempt = 0; \ } \ } while (0)

if (CONFIG_RTAI_ALLOW_RR && rt_current->policy > 0) { \ if (rt_current->yield_time <= rt_times.tick_time) { \ rt_current->rr_remaining = rt_current->rr_quantum; \ if (rt_current->state == RT_SCHED_READY) { \ RT_TASK *task; \ task = rt_current->rnext; \ while (rt_current->priority == task->priority) { \ task = task->rnext; \ } \ if (task != rt_current->rnext) { \ (rt_current->rprev)->rnext = rt_current->rnext; \ (rt_current->rnext)->rprev = rt_current->rprev; \ task->rprev = (rt_current->rprev = task->rprev)->rnext = rt_current; \ rt_current->rnext = task; \ } \ } \ } else { \ rt_current->rr_remaining = rt_current->yield_time - rt_times.tick_time; \ } \ }

do { \ prio = (new_task = rt_linux_task.rnext)->priority; \ if (CONFIG_RTAI_ALLOW_RR && new_task->policy > 0) { \ new_task->yield_time = rt_times.tick_time + new_task->rr_remaining; \ } \ } while (0)

do { \ RTIME now; \ now = rdtsc(); \ if (rt_current->is_hard) { \ rt_current->exectime[0] += (now - switch_time[cpuid]); \ } \ switch_time[cpuid] = now; \ } while (0)

do { \ struct klist_t *p = &klist[cpuid]; \ while (p->out != p->in) { \ wake_up_process(p->task[p->out++ & (MAX_WAKEUP_SRQ - 1)]); \ } \ } while (0)

{ .notifier_call = &lxrt_notify_reboot, .next = NULL, .priority = 0 }


Data Structures
struct	sig_wakeup_t
Defines
#define	__KERNEL_SYSCALLS__
#define	fpu_task (rt_smp_fpu_task[cpuid])
#define	rt_half_tick (rt_smp_half_tick[cpuid])
#define	oneshot_running (rt_smp_oneshot_running[cpuid])
#define	oneshot_timer_cpuid (rt_smp_oneshot_timer[rtai_cpuid()])
#define	shot_fired (rt_smp_shot_fired[cpuid])
#define	rt_times (rt_smp_times[cpuid])
#define	linux_cr0 (rt_smp_linux_cr0[cpuid])
#define	MAX_FRESTK_SRQ (2 << 6)
#define	KTHREAD_M_PRIO MAX_LINUX_RTPRIO
#define	KTHREAD_F_PRIO MAX_LINUX_RTPRIO
#define	rt_request_sched_ipi() 0
#define	rt_free_sched_ipi()
#define	sched_get_global_lock(cpuid)
#define	sched_release_global_lock(cpuid)
#define	RR_YIELD()
#define	TASK_TO_SCHEDULE()
#define	RR_INTR_TIME()
#define	LOCK_LINUX_NOTSKPRI(cpuid) do { rt_switch_to_real_time(cpuid); } while (0)
#define	UNLOCK_LINUX_NOTSKPRI(cpuid) do { rt_switch_to_linux(cpuid); } while (0)
#define	LOCK_LINUX(cpuid) do { rt_switch_to_real_time(cpuid); } while (0)
#define	UNLOCK_LINUX(cpuid) do { rt_switch_to_linux(cpuid); } while (0)
#define	LOCK_LINUX_IN_IRQ(cpuid)
#define	UNLOCK_LINUX_IN_IRQ(cpuid)
#define	KEXECTIME()
#define	UEXECTIME()
#define	enq_soft_ready_task(ready_task)
#define	pend_wake_up_hts(lnxtsk, cpuid)
#define	lxrt_context_switch(prev, next, cpuid) do { _lxrt_context_switch(prev, next, cpuid); barrier(); } while (0)
#define	TIMER_TYPE 0
#define	cpuid 0
#define	rt_times (rt_smp_times[cpuid])
#define	SYSW_DIAG_MSG(x)
#define	RESERVOIR 4
#define	WAKE_UP_TASKs(klist)
Functions
	MODULE_LICENSE ("GPL")
int	lxrt_notify_reboot (struct notifier_block nb, unsigned long event, void ptr)
int	get_min_tasks_cpuid (void)
void	put_current_on_cpu (int cpuid)
int	set_rtext (RT_TASK task, int priority, int uses_fpu, void(signal)(void), unsigned int cpuid, struct task_struct *relink)
void	start_stop_kthread (RT_TASK , void()(long), long, int, int, void(*)(void), int)
int	rt_kthread_init_cpuid (RT_TASK task, void(rt_thread)(long), long data, int stack_size, int priority, int uses_fpu, void(*signal)(void), unsigned int cpuid)
int	rt_kthread_init (RT_TASK task, void(rt_thread)(long), long data, int stack_size, int priority, int uses_fpu, void(*signal)(void))
int	rt_task_init_cpuid (RT_TASK task, void(rt_thread)(long), long data, int stack_size, int priority, int uses_fpu, void(*signal)(void), unsigned int cpuid)
int	rt_task_init (RT_TASK task, void(rt_thread)(long), long data, int stack_size, int priority, int uses_fpu, void(*signal)(void))
void	rt_set_runnable_on_cpuid (RT_TASK *task, unsigned int cpuid)
void	rt_set_runnable_on_cpus (RT_TASK *task, unsigned long run_on_cpus)
int	rt_check_current_stack (void)
void	rt_do_force_soft (RT_TASK *rt_task)
void	make_current_soft (RT_TASK *rt_current, int cpuid)
RT_TASK *	switch_rtai_tasks (RT_TASK rt_current, RT_TASK new_task, int cpuid)
void	rt_schedule (void)
void	rt_spv_RMS (int cpuid)
void	rt_sched_lock (void)
void	rt_sched_unlock (void)
void	rtai_handle_isched_lock (int cpuid)
void *	rt_get_lxrt_fun_entry (int index)
void	sched_sem_signal (SEM *sem)
int	clr_rtext (RT_TASK *task)
int	rt_task_delete (RT_TASK *task)
int	rt_get_timer_cpu (void)
void	rt_timer_handler (void)
irqreturn_t	recover_jiffies (int irq, void dev_id, struct pt_regs regs)
int	rt_is_hard_timer_running (void)
void	rt_set_periodic_mode (void)
void	rt_set_oneshot_mode (void)
RTIME	start_rt_timer (int period)
void	start_rt_apic_timers (struct apic_timer_setup_data *setup_mode, unsigned int rcvr_jiffies_cpuid)
void	stop_rt_timer (void)
int	rt_sched_type (void)
int	rt_hard_timer_tick_count (void)
int	rt_hard_timer_tick_count_cpuid (int cpuid)
RT_TRAP_HANDLER	rt_set_task_trap_handler (RT_TASK *task, unsigned int vec, RT_TRAP_HANDLER handler)
	MODULE_PARM (OneShot,"i")
	MODULE_PARM (Latency,"i")
	MODULE_PARM (SetupTimeTIMER,"i")
void	krtai_objects_release (void)
void	frstk_srq_handler (void)
void	nihil (void)
void	reset_rt_fun_entries (struct rt_native_fun_entry *entry)
int	set_rt_fun_entries (struct rt_native_fun_entry *entry)
void	lxrt_killall (void)
RTIME	count2nano (RTIME counts)
RTIME	nano2count (RTIME ns)
RTIME	count2nano_cpuid (RTIME counts, unsigned int cpuid)
RTIME	nano2count_cpuid (RTIME ns, unsigned int cpuid)
RTIME	rt_get_time (void)
RTIME	rt_get_time_cpuid (unsigned int cpuid)
RTIME	rt_get_time_ns (void)
RTIME	rt_get_time_ns_cpuid (unsigned int cpuid)
RTIME	rt_get_cpu_time_ns (void)
RT_TASK *	rt_get_base_linux_task (RT_TASK **base_linux_tasks)
RT_TASK *	rt_alloc_dynamic_task (void)
RT_TASK **	rt_register_watchdog (RT_TASK *wd, int cpuid)
void	rt_deregister_watchdog (RT_TASK *wd, int cpuid)
void	_rt_schedule_soft_tail (RT_TASK *rt_task, int cpuid)
void	rt_schedule_soft (RT_TASK *rt_task)
void	rt_schedule_soft_tail (RT_TASK *rt_task, int cpuid)
void	fast_schedule (RT_TASK new_task, struct task_struct lnxtsk, int cpuid)
	MODULE_PARM (Reservoir,"i")
	MODULE_PARM (SpareKthreads,"i")
task_struct *	__get_kthread (int cpuid)
void	detach_kthread (void)
void	lxrt_sigfillset (void)
void	kthread_fun (int cpuid)
void	kthread_m (int cpuid)
void	steal_from_linux (RT_TASK *rt_task)
void	give_back_to_linux (RT_TASK *rt_task, int keeprio)
task_struct *	get_kthread (int get, int cpuid, void *lnxtsk)
void	wake_up_srq_handler (unsigned srq)
int	lxrt_handle_trap (int vec, int signo, struct pt_regs regs, void dummy_data)
void	rt_signal_wake_up (RT_TASK *task)
int	lxrt_intercept_schedule_tail (unsigned event, void *nothing)
int	lxrt_intercept_sig_wakeup (long event, void *data)
int	lxrt_intercept_exit (unsigned long event, struct task_struct *lnx_task)
long long	rtai_lxrt_invoke (unsigned long, void , void )
int	lxrt_intercept_syscall_prologue (unsigned long event, struct pt_regs *regs)
int	lxrt_intercept_syscall_epilogue (unsigned long event, void *nothing)
void	usp_request_rtc (int, void *)
void	rt_release_rtc (void)
int	lxrt_init (void)
void	lxrt_exit (void)
void	timer_fun (unsigned long none)
int	rt_registry_alloc (void)
void	rt_registry_free (void)
int	__rtai_lxrt_init (void)
void	__rtai_lxrt_exit (void)
	module_init (__rtai_lxrt_init)
	module_exit (__rtai_lxrt_exit)
	EXPORT_SYMBOL (rt_fun_lxrt)
	EXPORT_SYMBOL (clr_rtext)
	EXPORT_SYMBOL (set_rtext)
	EXPORT_SYMBOL (get_min_tasks_cpuid)
	EXPORT_SYMBOL (rt_schedule_soft)
	EXPORT_SYMBOL (rt_do_force_soft)
	EXPORT_SYMBOL (rt_sched_timed)
	EXPORT_SYMBOL (rtai_handle_isched_lock)
Variables
RT_TASK	rt_smp_linux_task [NR_RT_CPUS]
RT_TASK *	rt_smp_current [NR_RT_CPUS]
RTIME	rt_smp_time_h [NR_RT_CPUS]
int	rt_smp_oneshot_timer [NR_RT_CPUS]
volatile int	rt_sched_timed
klist_t	wake_up_hts [NR_RT_CPUS]
klist_t	wake_up_srq [NR_RT_CPUS]
struct {
volatile int locked
volatile int rqsted
}	rt_scheduling []
int	rt_smp_linux_cr0 [NR_RT_CPUS]
RT_TASK *	rt_smp_fpu_task [NR_RT_CPUS]
int	rt_smp_half_tick [NR_RT_CPUS]
int	rt_smp_oneshot_running [NR_RT_CPUS]
volatile int	rt_smp_shot_fired [NR_RT_CPUS]
rt_times *	linux_times
RT_TASK *	lxrt_wdog_task [NR_RT_CPUS]
notifier_block	lxrt_notifier_reboot
klist_t	klistb [NR_RT_CPUS]
klist_t	klistm [NR_RT_CPUS]
task_struct *	kthreadm [NR_RT_CPUS]
semaphore	resem [NR_RT_CPUS]
int	endkthread
struct {
int srq
volatile unsigned long in
volatile unsigned long out
void * mp [MAX_FRESTK_SRQ]
}	frstk_srq
int	tasks_per_cpu [NR_RT_CPUS] = { 0, }
RTIME	switch_time [NR_RT_CPUS]
int	OneShot = CONFIG_RTAI_ONE_SHOT
int	Latency = TIMER_LATENCY
int	SetupTimeTIMER = TIMER_SETUP_TIME
rt_fun_entry	rt_fun_lxrt [MAX_LXRT_FUN]
RT_TRAP_HANDLER	lxrt_old_trap_handler
RT_TASK	thread_task [NR_RT_CPUS]
int	rsvr_cnt [NR_RT_CPUS]
int	Reservoir = RESERVOIR
int	SpareKthreads = 100
int	taskidx [NR_RT_CPUS]
task_struct **	taskav [NR_RT_CPUS]
unsigned long	traptrans
unsigned long	systrans
int(*	sys_call_table [])(struct pt_regs)
rt_native_fun_entry	rt_sched_entries []
void *	rtai_lxrt_dispatcher
	DECLARE_FUSION_WAKE_UP_STUFF
	DECLR_8254_TSC_EMULATION

base/sched/sched.c File Reference

Data Structures

Defines

Functions

Variables

Define Documentation

Function Documentation

Variable Documentation