From: Jorrit Herder Date: Tue, 31 May 2005 14:43:04 +0000 (+0000) Subject: Replaced flagalrm() timers with another technique to check for timeouts. X-Git-Tag: v3.1.0~795 X-Git-Url: http://zhaoyanbai.com/repos/doxygen.log?a=commitdiff_plain;h=0165662cd97edcde78566265eaaa60575c980d39;p=minix.git Replaced flagalrm() timers with another technique to check for timeouts. This allowed removing the p_flagarlm timer from the kernel's process table. Furthermore, I merged p_syncalrm and p_signalrm into p_alarm_timer to save even more space. Note that processes can no longer have both a signal and synchronous alarm timer outstanding as of now. --- diff --git a/drivers/at_wini/at_wini.c b/drivers/at_wini/at_wini.c index 86f366952..efb054ca9 100644 --- a/drivers/at_wini/at_wini.c +++ b/drivers/at_wini/at_wini.c @@ -8,7 +8,6 @@ * Changes: * Nov 18, 2004 moved AT disk driver to user-space (Jorrit N. Herder) * Aug 20, 2004 watchdogs replaced by sync alarms (Jorrit N. Herder) - * May 02, 2004 sys_flagalrm() replaces micro_elapsed() (Jorrit N. Herder) * Mar 23, 2000 added ATAPI CDROM support (Michael Temari) * May 14, 2000 d-d/i rewrite (Kees J. Bot) * Apr 13, 1992 device dependent/independent split (Kees J. Bot) @@ -883,17 +882,18 @@ int value; /* required status */ * ticks. Disabling the alarm is not needed, because a static flag is used * and a leftover timeout cannot do any harm. */ - static int timeout_flag; /* must be static, not cancelled */ + clock_t t0, t1; int s; - timeout_flag = 0; - sys_flagalrm(TIMEOUT_TICKS, &timeout_flag); + getuptime(&t0); do { if ((s=sys_inb(w_wn->base + REG_STATUS, &w_status)) != OK) server_panic(w_name(),"Couldn't read register",s); if ((w_status & mask) == value) { return 1; } - } while (! timeout_flag); + } while ((s=getuptime(&t1)) == OK && (t1-t0) < TIMEOUT_TICKS ); + if (OK != s) printf("AT_WINI: warning, get_uptime failed: %d\n",s); + w_need_reset(); /* controller gone deaf */ return(0); } diff --git a/drivers/floppy/floppy.c b/drivers/floppy/floppy.c index 1719ff0aa..ce9b3f05b 100644 --- a/drivers/floppy/floppy.c +++ b/drivers/floppy/floppy.c @@ -8,7 +8,6 @@ * Changes: * Dec 01, 2004 floppy driver moved to user-space (Jorrit N. Herder) * Sep 15, 2004 sync alarms/ local timer management (Jorrit N. Herder) - * May 02, 2004 sys_flagalrm() replaces micro_elapsed() (Jorrit N. Herder) * Aug 12, 2003 null seek no interrupt fix (Mike Haertel) * May 14, 2000 d-d/i rewrite (Kees J. Bot) * Apr 04, 1992 device dependent/independent split (Kees J. Bot) @@ -689,7 +688,7 @@ PRIVATE void start_motor() f_set_timer(&f_tmr_timeout, f_dp->start, f_timeout); f_busy = BSY_IO; do { - receive(HARDWARE, &mess); + receive(ANY, &mess); if (mess.m_type == SYN_ALARM) { f_expire_tmrs(NULL); } else { @@ -771,10 +770,7 @@ PRIVATE int seek() f_set_timer(&f_tmr_timeout, HZ/30, f_timeout); f_busy = BSY_IO; do { - /* printf("Wait for message from HARDWARE 0\n"); */ - receive(HARDWARE, &mess); - /* printf("Floppy: got message, type %d (HARD_INT %d)\n", - mess.m_type, (mess.m_type == HARD_INT)); */ + receive(ANY, &mess); if (mess.m_type == SYN_ALARM) { f_expire_tmrs(NULL); } else { @@ -872,15 +868,14 @@ PRIVATE int fdc_results() */ int s, result_nr, status; - static int timeout; /* must be static if not cancelled */ + clock_t t0,t1; /* Extract bytes from FDC until it says it has no more. The loop is * really an outer loop on result_nr and an inner loop on status. * A timeout flag alarm is set. */ result_nr = 0; - timeout = 0; - sys_flagalrm(TIMEOUT_TICKS, &timeout); + getuptime(&t0); do { /* Reading one byte is almost a mirror of fdc_out() - the DIRECTION * bit must be set instead of clear, but the CTL_BUSY bit destroys @@ -900,14 +895,10 @@ PRIVATE int fdc_results() if ((s=sys_irqenable(&irq_hook_id)) != OK) server_panic("FLOPPY", "Couldn't enable IRQs", s); - /* Disabling the alarm is not needed, because a static flag - * is used and a leftover timeout cannot do any harm. It is - * done for correctness. This can safely be removed, though. - */ - sys_flagalrm(0, &timeout); /* for correctness */ return(OK); /* only good exit */ } - } while (! timeout); + } while ( (s=getuptime(&t1))==OK && (t1-t0) < TIMEOUT_TICKS ); + if (OK!=s) printf("FLOPPY: warning, getuptime failed: %d\n", s); need_reset = TRUE; /* controller chip must be reset */ if ((s=sys_irqenable(&irq_hook_id)) != OK) @@ -952,19 +943,16 @@ int val; /* write this byte to floppy disk controller */ * can only write to it when it is listening, and it decides when to listen. * If the controller refuses to listen, the FDC chip is given a hard reset. */ - - static int timeout; /* must be static if not cancelled */ + clock_t t0, t1; int s, status; if (need_reset) return; /* if controller is not listening, return */ - /* It may take several tries to get the FDC to accept a command. - * A timeout flag alarm is set. - */ - timeout = 0; - sys_flagalrm(TIMEOUT_TICKS, &timeout); + /* It may take several tries to get the FDC to accept a command. */ + getuptime(&t0); do { - if (timeout) { /* controller is not listening */ + if ( (s=getuptime(&t1))==OK && (t1-t0) > TIMEOUT_TICKS ) { + if (OK!=s) printf("FLOPPY: warning, getuptime failed: %d\n", s); need_reset = TRUE; /* hit it over the head */ return; } @@ -973,11 +961,6 @@ int val; /* write this byte to floppy disk controller */ } while ((status & (MASTER | DIRECTION)) != (MASTER | 0)); - /* Disabling the alarm is not needed, because a static flag is used and a - * leftover timeout cannot do any harm. It is done for correctness. This - * can safely be removed, though. - */ - sys_flagalrm(0, &timeout); /* for correctness */ if ((s=sys_outb(FDC_DATA, val)) != OK) server_panic("FLOPPY","Sys_outb in fdc_out() failed", s); } @@ -1062,7 +1045,7 @@ PRIVATE void f_reset() * SYN_ALARM message on a timeout. */ do { - receive(HARDWARE, &mess); + receive(ANY, &mess); if (mess.m_type == SYN_ALARM) { f_expire_tmrs(NULL); } else { /* expect HARD_INT */ @@ -1108,10 +1091,7 @@ PRIVATE int f_intr_wait() * occurs, report an error. */ do { - /* printf("Wait for message from HARDWARE 2\n"); */ - receive(HARDWARE, &mess); - /* printf("Floppy: got message, type %d (HARD_INT %d) ", - mess.m_type, (mess.m_type == HARD_INT)); */ + receive(ANY, &mess); if (mess.m_type == SYN_ALARM) { f_expire_tmrs(NULL); } else { diff --git a/drivers/fxp/fxp.c b/drivers/fxp/fxp.c index e3748d56d..296c1f592 100644 --- a/drivers/fxp/fxp.c +++ b/drivers/fxp/fxp.c @@ -904,8 +904,7 @@ fxp_t *fp; { static char eakey[]= FXP_ENVVAR "#_EA"; static char eafmt[]= "x:x:x:x:x:x"; - static int timeout_flag; /* must be static */ - + clock_t t0,t1; int i, r; port_t port; u32_t bus_addr; @@ -959,13 +958,12 @@ fxp_t *fp; fxp_cu_ptr_cmd(fp, SC_CU_START, bus_addr, TRUE /* check idle */); - timeout_flag= 0; - sys_flagalrm(MICROS_TO_TICKS(1000), &timeout_flag); + getuptime(&t0); do { /* Wait for CU command to complete */ if (ias.ias_status & CBL_F_C) break; - } while (!timeout_flag); + } while (getuptime(&t1)==OK && (t1-t0) < MICROS_TO_TICKS(1000)); if (!(ias.ias_status & CBL_F_C)) panic("fxp_confaddr: CU command failed to complete", NO_NUM); @@ -1361,11 +1359,10 @@ suspend: static void fxp_do_conf(fp) fxp_t *fp; { - static int timeout_flag; /* must be static */ - int r; u32_t bus_addr; struct cbl_conf cc; + clock_t t0,t1; /* Configure device */ cc.cc_status= 0; @@ -1380,13 +1377,12 @@ fxp_t *fp; fxp_cu_ptr_cmd(fp, SC_CU_START, bus_addr, TRUE /* check idle */); - timeout_flag= 0; - sys_flagalrm(MICROS_TO_TICKS(100000), &timeout_flag); + getuptime(&t0); do { /* Wait for CU command to complete */ if (cc.cc_status & CBL_F_C) break; - } while (!timeout_flag); + } while (getuptime(&t1)==OK && (t1-t0) < MICROS_TO_TICKS(100000)); if (!(cc.cc_status & CBL_F_C)) panic("fxp_do_conf: CU command failed to complete", NO_NUM); @@ -1405,8 +1401,7 @@ int cmd; phys_bytes bus_addr; int check_idle; { - static int timeout_flag; /* must be static */ - + clock_t t0,t1; port_t port; u8_t scb_cmd; @@ -1425,14 +1420,13 @@ int check_idle; /* What is a reasonable time-out? There is nothing in the * documentation. 1 ms should be enough. */ - timeout_flag= 0; - sys_flagalrm(MICROS_TO_TICKS(1000), &timeout_flag); + getuptime(&t0); do { /* Wait for CU command to be accepted */ scb_cmd= fxp_inb(port, SCB_CMD); if ((scb_cmd & SC_CUC_MASK) == SC_CU_NOP) break; - } while (!timeout_flag); + } while (getuptime(&t1)==OK && (t1-t0) < MICROS_TO_TICKS(1000)); if ((scb_cmd & SC_CUC_MASK) != SC_CU_NOP) panic("fxp_cu_ptr_cmd: CU does not accept command", NO_NUM); @@ -1448,8 +1442,7 @@ int cmd; phys_bytes bus_addr; int check_idle; { - static int timeout_flag; /* must be static */ - + clock_t t0,t1; port_t port; u8_t scb_cmd; @@ -1465,14 +1458,13 @@ int check_idle; fxp_outl(port, SCB_POINTER, bus_addr); fxp_outb(port, SCB_CMD, cmd); - timeout_flag= 0; - sys_flagalrm(MICROS_TO_TICKS(1000), &timeout_flag); + getuptime(&t0); do { /* Wait for RU command to be accepted */ scb_cmd= fxp_inb(port, SCB_CMD); if ((scb_cmd & SC_RUC_MASK) == SC_RU_NOP) break; - } while (!timeout_flag); + } while (getuptime(&t1)==OK && (t1-t0) < MICROS_TO_TICKS(1000)); if ((scb_cmd & SC_RUC_MASK) != SC_RU_NOP) panic("fxp_ru_ptr_cmd: RU does not accept command", NO_NUM); @@ -1519,8 +1511,7 @@ fxp_t *fp; static void fxp_getstat(mp) message *mp; { - static int timeout_flag; /* Must be static */ - + clock_t t0,t1; int dl_port; port_t port; fxp_t *fp; @@ -1546,13 +1537,12 @@ message *mp; */ fxp_cu_ptr_cmd(fp, SC_CU_DUMP_SC, 0, FALSE /* do not check idle */); - timeout_flag= 0; - sys_flagalrm(MICROS_TO_TICKS(1000), &timeout_flag); + getuptime(&t0); do { /* Wait for CU command to complete */ if (*p != 0) break; - } while (!timeout_flag); + } while (getuptime(&t1)==OK && (t1-t0) < MICROS_TO_TICKS(1000)); if (*p == 0) panic("fxp_getstat: CU command failed to complete", NO_NUM); @@ -2331,8 +2321,7 @@ PRIVATE u16_t mii_read(fp, reg) fxp_t *fp; int reg; { - static int timeout_flag; /* must be static */ - + clock_t t0,t1; port_t port; u32_t v; @@ -2346,13 +2335,12 @@ int reg; fxp_outl(port, CSR_MDI_CTL, CM_READ | (1 << CM_PHYADDR_SHIFT) | (reg << CM_REG_SHIFT)); - timeout_flag= 0; - sys_flagalrm(MICROS_TO_TICKS(1000), &timeout_flag); + getuptime(&t0); do { v= fxp_inl(port, CSR_MDI_CTL); if (v & CM_READY) break; - } while (!timeout_flag); + } while (getuptime(&t1)==OK && (t1-t0) < MICROS_TO_TICKS(1000)); if (!(v & CM_READY)) panic("mii_read: MDI not ready after command", NO_NUM); diff --git a/drivers/rtl8139/rtl8139.c b/drivers/rtl8139/rtl8139.c index 75ad303d1..e938ec5db 100755 --- a/drivers/rtl8139/rtl8139.c +++ b/drivers/rtl8139/rtl8139.c @@ -836,33 +836,29 @@ re_t *rep; u32_t t; phys_bytes bus_buf; int i; - static int timeout; /* must be static if not cancelled */ + clock_t t0,t1; port= rep->re_base_port; #if 0 /* Reset the PHY */ rl_outb(port, RL_BMCR, MII_CTRL_RST); - timeout=0; - sys_flagalrm(HZ, &timeout); + getuptime(&t0); do { if (!(rl_inb(port, RL_BMCR) & MII_CTRL_RST)) break; - } while (! timeout); - sys_flagalrm(0, &timeout); /* for correctness */ + } while (getuptime(&t1)==OK && (t1-t0) < HZ); if (rl_inb(port, RL_BMCR) & MII_CTRL_RST) server_panic("rtl8139","reset PHY failed to complete", NO_NUM); #endif /* Reset the device */ rl_outb(port, RL_CR, RL_CR_RST); - timeout=0; - sys_flagalrm(HZ, &timeout); + getuptime(&t0); do { if (!(rl_inb(port, RL_CR) & RL_CR_RST)) break; - } while (! timeout); - sys_flagalrm(0, &timeout); /* for correctness */ + } while (getuptime(&t1)==OK && (t1-t0) < HZ); if (rl_inb(port, RL_CR) & RL_CR_RST) server_panic("rtl8139","reset failed to complete", NO_NUM); @@ -1789,7 +1785,7 @@ re_t *rep; port_t port; u8_t cr; int i; - static int timeout; /* must be static if not cancelled */ + clock_t t0,t1; rep->re_clear_rx= FALSE; port= rep->re_base_port; @@ -1798,13 +1794,11 @@ re_t *rep; cr= rl_inb(port, RL_CR); cr &= ~RL_CR_RE; rl_outb(port, RL_CR, cr); - timeout=0; - sys_flagalrm(HZ, &timeout); + getuptime(&t0); do { if (!(rl_inb(port, RL_CR) & RL_CR_RE)) break; - } while (! timeout); - sys_flagalrm(0, &timeout); /* for correctness */ + } while (getuptime(&t1)==OK && (t1-t0) < HZ); if (rl_inb(port, RL_CR) & RL_CR_RE) server_panic("rtl8139","cannot disable receiver", NO_NUM); @@ -2063,8 +2057,7 @@ re_t *rep; #if 0 u8_t cr; #endif - static int timeout; /* must be static if not cancelled */ - + clock_t t0,t1; int_event_check = FALSE; /* disable check by default */ RAND_UPDATE @@ -2160,13 +2153,11 @@ re_t *rep; cr= rl_inb(port, RL_CR); cr &= ~RL_CR_TE; rl_outb(port, RL_CR, cr); - timeout=0; - sys_flagalrm(HZ, &timeout); + getuptime(&t0); do { if (!(rl_inb(port, RL_CR) & RL_CR_TE)) break; - } while (! timeout); - sys_flagalrm(0, &timeout); /* for correctness */ + } while (getuptime(&t1)==OK && (t1-t0) < HZ); if (rl_inb(port, RL_CR) & RL_CR_TE) { server_panic("rtl8139","cannot disable transmitter", @@ -2575,7 +2566,7 @@ int a; u16_t w; { int b, i, cmd; - static int timeout; /* must be static if not cancelled */ + clock_t t0, t1; outb_reg3(dep, 1, 0x80 | 0x8); /* Set CS */ @@ -2602,13 +2593,11 @@ u16_t w; outb_reg3(dep, 1, 0x80); /* Drop CS */ /* micro_delay(1); */ /* Is this required? */ outb_reg3(dep, 1, 0x80 | 0x8); /* Set CS */ - timeout = 0; - sys_flagalrm(1, &timeout); + getuptime(&t0); do { if (inb_reg3(dep, 1) & 1) break; - } while (! timeout); - sys_flagalrm(0, &timeout); /* for correctness */ + } while (getuptime(&t1) == OK && (t1 == t0)); if (!(inb_reg3(dep, 1) & 1)) server_panic("set_ee_word","device remains busy", NO_NUM); } diff --git a/drivers/tty/console.c b/drivers/tty/console.c index 7cb74157d..d38a22deb 100644 --- a/drivers/tty/console.c +++ b/drivers/tty/console.c @@ -22,6 +22,9 @@ #include #include "tty.h" +#include "../../kernel/const.h" +#include "../../kernel/type.h" + /* Definitions used by the console driver. */ #define MONO_BASE 0xB0000L /* base of mono video memory */ #define COLOR_BASE 0xB8000L /* base of color video memory */ diff --git a/include/minix/config.h b/include/minix/config.h index 90d5b21c7..6d8ccb4f3 100755 --- a/include/minix/config.h +++ b/include/minix/config.h @@ -47,12 +47,11 @@ #define NR_BUF_HASH 512 /* size of buf hash table; MUST BE POWER OF 2*/ #endif -/* Defines for kernel configuration. */ +/* Defines for driver and kernel configuration. */ #define AUTO_BIOS 0 /* xt_wini.c - use Western's autoconfig BIOS */ #define LINEWRAP 1 /* console.c - wrap lines at column 80 */ #define ALLOW_GAP_MESSAGES 1 /* proc.c - allow messages in the gap between * the end of bss and lowest stack address */ -#define KMESS_BUF_SIZE 512 /* size in bytes for kernel messages */ /* Number of controller tasks (/dev/cN device classes). */ #define NR_CTRLRS 2 diff --git a/include/minix/type.h b/include/minix/type.h index ecde3aa74..1869c3011 100755 --- a/include/minix/type.h +++ b/include/minix/type.h @@ -119,14 +119,4 @@ struct machine { int vdu_vga; }; -/* The kernel outputs messages in a local buffer, which can be requested and - * printed by the TTY driver. The buffer structure is defined here. - */ -struct kmessages { - int km_next; /* next index to write */ - int km_size; /* current size in buffer */ - char km_buf[KMESS_BUF_SIZE]; /* buffer for messages */ -}; - - #endif /* _TYPE_H */ diff --git a/include/minix/utils.h b/include/minix/utils.h index 1cfe1e35d..7e7d9dacb 100644 --- a/include/minix/utils.h +++ b/include/minix/utils.h @@ -43,9 +43,9 @@ _PROTOTYPE(int fkey_ctl, (int fkey_code, int enable_disable) ); _PROTOTYPE(void server_report, (char *who, char *mess, int num) ); _PROTOTYPE(void server_panic, (char *who, char *mess, int num) ); -#define get_own_proc_nr(where) get_proc_nr((where), NULL) _PROTOTYPE(int get_proc_nr, (int *proc_nr, char *proc_name) ); +_PROTOTYPE(int getuptime, (clock_t *ticks)); _PROTOTYPE(int tick_delay, (clock_t ticks)); #endif /* _EXTRALIB_H */ diff --git a/kernel/const.h b/kernel/const.h index 65ebf77f4..ae89e4f14 100755 --- a/kernel/const.h +++ b/kernel/const.h @@ -4,8 +4,6 @@ #include /* port addresses and magic numbers */ #include /* BIOS addresses, sizes and magic numbers */ -#if (CHIP == INTEL) - /* To translate an address in kernel space to a physical address. This is * the same as umap_local(proc_ptr, D, vir, sizeof(*vir)), but less costly. */ @@ -27,6 +25,9 @@ /* How long should the process names be in the kernel? */ #define P_NAME_LEN 8 +/* How many bytes should the circular buffer for kernel diagnostics. */ +#define KMESS_BUF_SIZE 256 + /* How many bytes for (port,value)-pairs vector to copy in. */ #define VDEVIO_BUF_SIZE 128 @@ -48,6 +49,9 @@ #define SET_BIT(map,bit) ( MAP_CHUNK(map,bit) |= (1 << CHUNK_OFFSET(bit) ) #define UNSET_BIT(map,bit) ( MAP_CHUNK(map,bit) &= ~(1 << CHUNK_OFFSET(bit) ) + +#if (CHIP == INTEL) + /* Program stack words and masks. */ #define INIT_PSW 0x0200 /* initial psw */ #define INIT_TASK_PSW 0x1200 /* initial psw for tasks (with IOPL 1) */ @@ -67,7 +71,6 @@ */ #define NR_MEMS 8 /* number of chunks of memory */ - #endif /* (CHIP == INTEL) */ #if (CHIP == M68000) diff --git a/kernel/proc.h b/kernel/proc.h index 567e69091..570d8decc 100755 --- a/kernel/proc.h +++ b/kernel/proc.h @@ -45,19 +45,16 @@ struct proc { clock_t p_user_time; /* user time in ticks */ clock_t p_sys_time; /* sys time in ticks */ - timer_t p_signalrm; /* signal alarm timer */ - timer_t p_flagalrm; /* flag alarm timer */ - timer_t p_syncalrm; /* synchronous alarm timer */ - struct proc *p_nextready; /* pointer to next ready process */ struct notification *p_ntf_q; /* queue of pending notifications */ struct proc *p_caller_q; /* head of list of procs wishing to send */ struct proc *p_q_link; /* link to next proc wishing to send */ - message *p_messbuf; /* pointer to message buffer */ + message *p_messbuf; /* pointer to passed message buffer */ proc_nr_t p_getfrom; /* from whom does process want to receive? */ proc_nr_t p_sendto; /* to whom does process want to send? */ - sigset_t p_pending; /* bit map for pending signals */ + timer_t p_alarm_timer; /* timer shared by different alarm types */ + sigset_t p_pending; /* bit map for pending kernel signals */ unsigned p_pendcount; /* count of pending and unfinished signals */ char p_name[P_NAME_LEN]; /* name of the process, including \0 */ diff --git a/kernel/system.c b/kernel/system.c index d736f2c23..a60bf4e0f 100755 --- a/kernel/system.c +++ b/kernel/system.c @@ -114,9 +114,7 @@ PRIVATE void initialize(void) /* Initialize all alarm timers for all processes. */ for (rp=BEG_PROC_ADDR; rp < END_PROC_ADDR; rp++) { - tmr_inittimer(&(rp->p_signalrm)); - tmr_inittimer(&(rp->p_syncalrm)); - tmr_inittimer(&(rp->p_flagalrm)); + tmr_inittimer(&(rp->p_alarm_timer)); } /* Initialize the call vector to a safe default handler. Some system calls @@ -146,7 +144,6 @@ PRIVATE void initialize(void) map(SYS_TIMES, do_times); /* get uptime and process times */ map(SYS_SIGNALRM, do_signalrm); /* causes an alarm signal */ map(SYS_SYNCALRM, do_syncalrm); /* send a notification message */ - map(SYS_FLAGALRM, do_flagalrm); /* set a timeout flag to 1 */ /* Device I/O. */ map(SYS_IRQCTL, do_irqctl); /* interrupt control operations */ @@ -192,9 +189,7 @@ int proc_nr; /* slot of process to clean up */ rc = proc_addr(proc_nr); /* Turn off any alarm timers at the clock. */ - reset_timer(&rc->p_signalrm); - reset_timer(&rc->p_flagalrm); - reset_timer(&rc->p_syncalrm); + reset_timer(&rc->p_alarm_timer); /* Make sure the exiting process is no longer scheduled. */ if (rc->p_flags == 0) lock_unready(rc); diff --git a/kernel/system/clock.c b/kernel/system/clock.c index 7e31d0d3f..d096229ab 100644 --- a/kernel/system/clock.c +++ b/kernel/system/clock.c @@ -39,22 +39,19 @@ register message *m_ptr; /* pointer to request message */ /* The system call implemented in this file: - * m_type: SYS_SIGNALRM, SYS_SYNCALRM, SYS_FLAGALRM + * m_type: SYS_SIGNALRM, SYS_SYNCALRM * * The parameters for this system call are: * m2_i1: ALRM_PROC_NR (set alarm for this process) * m2_l1: ALRM_EXP_TIME (alarm's expiration time) * m2_i2: ALRM_ABS_TIME (expiration time is absolute?) * m2_l1: ALRM_SEC_LEFT (return seconds left of previous) - * m2_p1: ALRM_FLAG_PTR (virtual addr of alarm flag) * * Changes: - * Aug 25, 2004 fully rewritten to unite all alarms (Jorrit N. Herder) - * May 02, 2004 added new timeout flag alarm (Jorrit N. Herder) + * Aug 25, 2004 fully rewritten to clean up code (Jorrit N. Herder) */ FORWARD _PROTOTYPE( void cause_syncalrm, (timer_t *tp) ); -FORWARD _PROTOTYPE( void cause_flagalrm, (timer_t *tp) ); FORWARD _PROTOTYPE( void cause_signalrm, (timer_t *tp) ); /*===========================================================================* @@ -64,7 +61,7 @@ PUBLIC int do_setalarm(m_ptr) message *m_ptr; /* pointer to request message */ { /* A process requests an alarm, or wants to cancel its alarm. This function - * is shared used for all of SYS_SIGNALRM, SYS_SYNCALRM, and SYS_FLAGALRM. + * is shared used for both the SYS_SIGNALRM and SYS_SYNCALRM. */ int proc_nr; /* which process wants the alarm */ long exp_time; /* expiration time for this alarm */ @@ -80,26 +77,12 @@ message *m_ptr; /* pointer to request message */ use_abs_time = m_ptr->ALRM_ABS_TIME; /* flag for absolute time */ /* Get the timer structure and set the parameters for this alarm. */ + tp = &(proc_addr(proc_nr)->p_alarm_timer); + tmr_arg(tp)->ta_int = proc_nr; switch (m_ptr->m_type) { - case SYS_SYNCALRM: /* notify with SYN_ALARM message */ - tp = &(proc_addr(proc_nr)->p_syncalrm); - tmr_arg(tp)->ta_int = proc_nr; - tp->tmr_func = cause_syncalrm; - break; - case SYS_SIGNALRM: /* send process a SIGALRM signal */ - tp = &(proc_addr(proc_nr)->p_signalrm); - tmr_arg(tp)->ta_int = proc_nr; - tp->tmr_func = cause_signalrm; - break; - case SYS_FLAGALRM: /* set caller's timeout flag to 1 */ - tp = &(proc_addr(proc_nr)->p_flagalrm); - tmr_arg(tp)->ta_long = - numap_local(proc_nr,(vir_bytes) m_ptr->ALRM_FLAG_PTR,sizeof(int)); - if (! tmr_arg(tp)->ta_long) return(EFAULT); - tp->tmr_func = cause_flagalrm; - break; - default: /* invalid alarm type */ - return(EINVAL); + case SYS_SYNCALRM: tp->tmr_func = cause_syncalrm; break; + case SYS_SIGNALRM: tp->tmr_func = cause_signalrm; break; + default: return(EINVAL); /* invalid alarm type */ } /* Return the ticks left on the previous alarm. */ @@ -134,21 +117,6 @@ timer_t *tp; cause_sig(tmr_arg(tp)->ta_int, SIGALRM); } -/*===========================================================================* - * cause_flagalrm * - *===========================================================================*/ -PRIVATE void cause_flagalrm(tp) -timer_t *tp; -{ -/* Routine called if a timer goes off for a process that requested a timeout - * flag to be set when the alarm expires. The timer argument 'ta_long' gives - * the physical address of the timeout flag. No validity check was done when - * setting the alarm, so check for 0 here. - */ - int timeout = 1; - phys_bytes timeout_flag = (phys_bytes) tmr_arg(tp)->ta_long; - phys_copy(vir2phys(&timeout), tmr_arg(tp)->ta_long, sizeof(int)); -} /*===========================================================================* * cause_syncalrm * diff --git a/kernel/type.h b/kernel/type.h index 5fe929287..42832bc05 100755 --- a/kernel/type.h +++ b/kernel/type.h @@ -45,6 +45,14 @@ struct notification { struct notification* n_next; /* pointer to next notification */ }; +/* The kernel outputs diagnostic messages in a circular buffer. */ +struct kmessages { + int km_next; /* next index to write */ + int km_size; /* current size in buffer */ + char km_buf[KMESS_BUF_SIZE]; /* buffer for messages */ +}; + + #if (CHIP == INTEL) typedef unsigned reg_t; /* machine register */ diff --git a/lib/utils/Makefile b/lib/utils/Makefile index ff9dfeef4..c829e27cd 100644 --- a/lib/utils/Makefile +++ b/lib/utils/Makefile @@ -8,6 +8,7 @@ all: $(LIBUTILS) OBJECTS = \ $(LIBUTILS)(tick_delay.o) \ + $(LIBUTILS)(get_upt.o) \ $(LIBUTILS)(get_mon_prm.o) \ $(LIBUTILS)(env_parse.o) \ $(LIBUTILS)(env_panic.o) \ @@ -24,6 +25,9 @@ $(LIBUTILS): $(OBJECTS) aal cr $@ *.o rm *.o +$(LIBUTILS)(get_upt.o): get_upt.c + $(CC1) get_upt.c + $(LIBUTILS)(tick_delay.o): tick_delay.c $(CC1) tick_delay.c diff --git a/servers/fs/cmostime.c b/servers/fs/cmostime.c index 514c42d43..cce3cb587 100644 --- a/servers/fs/cmostime.c +++ b/servers/fs/cmostime.c @@ -1,6 +1,7 @@ #include "fs.h" #include #include +#include #include #include #include @@ -75,16 +76,16 @@ PRIVATE int get_cmostime(struct tm *t, int y2kflag) */ int osec, n; unsigned long i; - static int timeout_flag; + clock_t t0,t1; /* Start a timer to keep us from getting stuck on a dead clock. */ - timeout_flag = 0; - sys_flagalrm(5*HZ, &timeout_flag); + getuptime(&t0); do { osec = -1; n = 0; do { - if (timeout_flag) { + getuptime(&t1); + if (t1-t0 > 5*HZ) { printf("readclock: CMOS clock appears dead\n"); return(1); } @@ -117,7 +118,6 @@ PRIVATE int get_cmostime(struct tm *t, int y2kflag) || read_register(RTC_MDAY) != t->tm_mday || read_register(RTC_MONTH) != t->tm_mon || read_register(RTC_YEAR) != t->tm_year); - sys_flagalrm(0, &timeout_flag); /* not strictly necessarily; flag is static */ if ((read_register(RTC_REG_B) & RTC_B_DM_BCD) == 0) { /* Convert BCD to binary (default RTC mode). */