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: ; }