static void run_timer_list(void)
{
register struct timer_list *timer;
clr_irq();
while ((timer = tl_list.tl_next) && timer->tl_expires <= jiffies) {
detach_timer(timer);
set_irq();
timer->tl_function(timer->tl_data);
clr_irq();
}
set_irq();
}
static struct unix_proto_data *unix_data_alloc(void)
{
struct unix_proto_data *upd;
clr_irq();
for (upd = unix_datas; upd <= last_unix_data; ++upd) {
if (!upd->refcnt) {
/* unix domain socket not yet in itialised - bgm */
upd->refcnt = -1;
set_irq();
upd->socket = NULL;
upd->sockaddr_len = 0;
upd->sockaddr_un.sun_family = 0;
#if 0
upd->buf = NULL;
#endif
upd->bp_head = upd->bp_tail = 0;
upd->inode = NULL;
upd->peerupd = NULL;
upd->sem = 0;
return upd;
}
}
set_irq();
return NULL;
}
void mark_buffer_uptodate(struct buffer_head *bh, int on)
{
flag_t flags;
save_flags(flags);
clr_irq();
bh->b_uptodate = on;
restore_flags(flags);
}
void wake_up_process(register struct task_struct *p)
{
flag_t flags;
save_flags(flags);
clr_irq();
p->state = TASK_RUNNING;
if (!p->next_run){
add_to_runqueue(p);
}
restore_flags(flags);
}
int del_timer(struct timer_list *timer)
{
int ret;
flag_t flags;
save_flags(flags);
clr_irq();
ret = detach_timer(timer);
restore_flags(flags);
return ret;
}
t_stat multibus_svc(UNIT *uptr)
{
switch (mbirq) {
case INT_1:
set_cpuint(INT_R);
clr_irq(SBC208_INT); /***** bad, bad, bad! */
// sim_printf("multibus_svc: mbirq=%04X int_req=%04X\n", mbirq, int_req);
break;
default:
// sim_printf("multibus_svc: default mbirq=%04X\n", mbirq);
break;
}
sim_activate (&multibus_unit, multibus_unit.wait); /* continue poll */
return SCPE_OK;
}
void add_timer(register struct timer_list *timer)
{
flag_t flags;
register struct timer_list *next = &tl_list;
struct timer_list *prev;
save_flags(flags);
clr_irq();
do {
prev = next;
} while ((next = next->tl_next) && (next->tl_expires < timer->tl_expires));
(timer->tl_prev = prev)->tl_next = timer;
if ((timer->tl_next = next))
next->tl_prev = timer;
restore_flags(flags);
}
void schedule(void)
{
register __ptask prev;
register __ptask next;
struct timer_list timer;
jiff_t timeout = 0UL;
prev = current;
if (prev->t_kstackm != KSTACK_MAGIC)
panic("Process %d exceeded kernel stack limit! magic %x\n",
prev->pid, prev->t_kstackm);
if (intr_count > 0) {
/* Taking a timer IRQ during another IRQ or while in kernel space is
* quite legal. We just dont switch then */
printk("Aiee: scheduling in interrupt %d - %d\n",
intr_count, prev->pid);
goto no_sched;
}
/* We have to let a task exit! */
if (prev->state == TASK_EXITING)
goto no_sched;
clr_irq();
if (prev->state == TASK_INTERRUPTIBLE) {
if (prev->signal || (prev->timeout && (prev->timeout <= jiffies))) {
prev->timeout = 0UL;
prev->state = TASK_RUNNING;
}
else {
timeout = prev->timeout;
}
}
/* Choose a task to run next */
next = prev->next_run;
if (prev->state != TASK_RUNNING)
del_from_runqueue(prev);
if (next == &init_task)
next = next->next_run;
set_irq();
if (next != prev) {
if (timeout) {
init_timer(&timer);
timer.tl_expires = timeout;
timer.tl_data = (int) prev;
timer.tl_function = process_timeout;
add_timer(&timer);
}
#ifdef CONFIG_SWAP
if (do_swapper_run(next) == -1){
printk("Can't become runnable %d\n", next->pid);
panic("");
}
#endif
previous = prev;
current = next;
tswitch(); /* Won't return for a new task */
if (timeout) {
del_timer(&timer);
}
}
no_sched:
;
}
