xnu-7195.101.1.tar.gz

[apple/xnu.git] / bsd / dev / i386 / km.c

diff --git a/bsd/dev/i386/km.c b/bsd/dev/i386/km.c
index 2ce9ce21c55ab421b61456b9abe09d5185b99dc1..aee4edee858d14750a30fac202b996708af65572 100644 (file)
--- a/bsd/dev/i386/km.c
+++ b/bsd/dev/i386/km.c
@@ -1,17 +1,20 @@
 /*
  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
  *
 /*
  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
  *

- * @APPLE_LICENSE_HEADER_START@
- * 
- * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
- * 
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *

  * This file contains Original Code and/or Modifications of Original Code
  * as defined in and that are subject to the Apple Public Source License
  * Version 2.0 (the 'License'). You may not use this file except in
  * This file contains Original Code and/or Modifications of Original Code
  * as defined in and that are subject to the Apple Public Source License
  * Version 2.0 (the 'License'). You may not use this file except in

- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *

  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,


@@ -19,10 +22,10 @@
  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  * Please see the License for the specific language governing rights and
  * limitations under the License.
  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  * Please see the License for the specific language governing rights and
  * limitations under the License.

- * 
- * @APPLE_LICENSE_HEADER_END@
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
  */

-/*     Copyright (c) 1992 NeXT Computer, Inc.  All rights reserved. 
+/*      Copyright (c) 1992 NeXT Computer, Inc.  All rights reserved.

  *
  * km.m - kernel keyboard/monitor module, procedural interface.
  *
  *
  * km.m - kernel keyboard/monitor module, procedural interface.
  *


@@ -32,23 +35,32 @@
 #include <sys/param.h>
 #include <sys/tty.h>
 
 #include <sys/param.h>
 #include <sys/tty.h>
 

-#include <dev/i386/cons.h>
+#include <machine/cons.h>

 #include <sys/conf.h>
 #include <sys/systm.h>
 #include <sys/uio.h>
 #include <sys/conf.h>
 #include <sys/systm.h>
 #include <sys/uio.h>

-#include <sys/fcntl.h>         /* for kmopen */
-#include <sys/errno.h>         
-#include <sys/proc.h>          /* for kmopen */
+#include <sys/fcntl.h>          /* for kmopen */
+#include <sys/errno.h>
+#include <sys/proc.h>           /* for kmopen */

 #include <sys/msgbuf.h>
 #include <sys/time.h>
 #include <dev/kmreg_com.h>
 #include <pexpert/pexpert.h>
 #include <sys/msgbuf.h>
 #include <sys/time.h>
 #include <dev/kmreg_com.h>
 #include <pexpert/pexpert.h>

+#include <pexpert/i386/boot.h>
+
+extern int hz;
+
+extern void cnputcusr(char);
+extern void cnputsusr(char *, int);
+extern int  cngetc(void);
+
+void    kminit(void);
+void    cons_cinput(char ch);

 
 /*
  * 'Global' variables, shared only by this file and conf.c.
  */
 
 /*
  * 'Global' variables, shared only by this file and conf.c.
  */

-extern struct tty      cons;
-struct tty *km_tty[1] = { &cons };
+struct tty *km_tty[1] = { 0 };

 
 /*
  * this works early on, after initialize_screen() but before autoconf (and thus
 
 /*
  * this works early on, after initialize_screen() but before autoconf (and thus


@@ -62,42 +74,43 @@ int disableConsoleOutput;
 int initialized = 0;
 
 static int kmoutput(struct tty *tp);
 int initialized = 0;
 
 static int kmoutput(struct tty *tp);

-static void kmtimeout(struct tty *tp);

 static void kmstart(struct tty *tp);
 
 extern void KeyboardOpen(void);
 
 static void kmstart(struct tty *tp);
 
 extern void KeyboardOpen(void);
 

-int kminit()
+void
+kminit(void)

 {
 {

-        cons.t_dev = makedev(12, 0);
+       km_tty[0] = ttymalloc();
+       km_tty[0]->t_dev = makedev(12, 0);

        initialized = 1;
 }
        initialized = 1;
 }

+

 /*
  * cdevsw interface to km driver.
  */
 /*
  * cdevsw interface to km driver.
  */

-int 
-kmopen(
-       dev_t dev, 
-       int flag,
-       int devtype, 
-       struct proc *pp)
+int
+kmopen(dev_t dev, int flag, __unused int devtype, proc_t pp)

 {
 {

-       int rtn;

        int unit;
        struct tty *tp;
        struct winsize *wp;
        int ret;
        int unit;
        struct tty *tp;
        struct winsize *wp;
        int ret;

-       
+

        unit = minor(dev);
        unit = minor(dev);

-       if(unit >= 1)
-               return (ENXIO);
+       if (unit >= 1) {
+               return ENXIO;
+       }
+
+       tp = km_tty[unit];
+
+       tty_lock(tp);

 
 

-       tp = (struct tty *)&cons;

        tp->t_oproc = kmstart;
        tp->t_param = NULL;
        tp->t_dev = dev;
        tp->t_oproc = kmstart;
        tp->t_param = NULL;
        tp->t_dev = dev;

-       
-       if ( !(tp->t_state & TS_ISOPEN) ) {
+
+       if (!(tp->t_state & TS_ISOPEN)) {

                tp->t_iflag = TTYDEF_IFLAG;
                tp->t_oflag = TTYDEF_OFLAG;
                tp->t_cflag = (CREAD | CS8 | CLOCAL);
                tp->t_iflag = TTYDEF_IFLAG;
                tp->t_oflag = TTYDEF_OFLAG;
                tp->t_cflag = (CREAD | CS8 | CLOCAL);


@@ -105,26 +118,36 @@ kmopen(
                tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
                termioschars(&tp->t_termios);
                ttsetwater(tp);
                tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
                termioschars(&tp->t_termios);
                ttsetwater(tp);

-       } else if ((tp->t_state & TS_XCLUDE) && pp->p_ucred->cr_uid != 0)
-               return EBUSY;
+       } else if ((tp->t_state & TS_XCLUDE) && proc_suser(pp)) {
+               ret = EBUSY;
+               goto out;
+       }

 
        tp->t_state |= TS_CARR_ON; /* lie and say carrier exists and is on. */
 
        tp->t_state |= TS_CARR_ON; /* lie and say carrier exists and is on. */

+

        ret = ((*linesw[tp->t_line].l_open)(dev, tp));
        {
                PE_Video video;
                wp = &tp->t_winsize;
        ret = ((*linesw[tp->t_line].l_open)(dev, tp));
        {
                PE_Video video;
                wp = &tp->t_winsize;

-               /* Magic numbers.  These are CHARWIDTH and CHARHEIGHT
+               /*
+                * Magic numbers.  These are CHARWIDTH and CHARHEIGHT

                 * from pexpert/i386/video_console.c
                 */
                wp->ws_xpixel = 8;
                wp->ws_ypixel = 16;
 
                 * from pexpert/i386/video_console.c
                 */
                wp->ws_xpixel = 8;
                wp->ws_ypixel = 16;
 

-               if (flag & O_POPUP)
+               tty_unlock(tp);         /* XXX race window */
+
+               if (flag & O_POPUP) {

                        PE_initialize_console(0, kPETextScreen);
                        PE_initialize_console(0, kPETextScreen);

+               }

 
                bzero(&video, sizeof(video));
                PE_current_console(&video);
 
                bzero(&video, sizeof(video));
                PE_current_console(&video);

-               if( video.v_width != 0 && video.v_height != 0 ) {
+
+               tty_lock(tp);
+
+               if (video.v_display == FB_TEXT_MODE && video.v_width != 0 && video.v_height != 0) {

                        wp->ws_col = video.v_width / wp->ws_xpixel;
                        wp->ws_row = video.v_height / wp->ws_ypixel;
                } else {
                        wp->ws_col = video.v_width / wp->ws_xpixel;
                        wp->ws_row = video.v_height / wp->ws_ypixel;
                } else {


@@ -132,233 +155,262 @@ kmopen(
                        wp->ws_row = 36;
                }
        }
                        wp->ws_row = 36;
                }
        }

+
+out:
+       tty_unlock(tp);
+

        return ret;
 }
 
        return ret;
 }
 

-int 
-kmclose(
-       dev_t dev, 
-       int flag,
-       int mode,
-       struct proc *p)
+int
+kmclose(dev_t dev, int flag, __unused int mode, __unused proc_t p)

 {
 {

-        
-       struct tty *tp;
+       int ret;
+       struct tty *tp = km_tty[minor(dev)];

 
 

-       tp = &cons;
-       (*linesw[tp->t_line].l_close)(tp,flag);
+       tty_lock(tp);
+       ret = (*linesw[tp->t_line].l_close)(tp, flag);

        ttyclose(tp);
        ttyclose(tp);

-       return (0);
+       tty_unlock(tp);
+
+       return ret;

 }
 
 }
 

-int 
-kmread(
-       dev_t dev, 
-       struct uio *uio,
-       int ioflag)
+int
+kmread(dev_t dev, struct uio *uio, int ioflag)

 {
 {

-       register struct tty *tp;
- 
-       tp = &cons;
-       return ((*linesw[tp->t_line].l_read)(tp, uio, ioflag));
+       int ret;
+       struct tty *tp = km_tty[minor(dev)];
+
+       tty_lock(tp);
+       ret = (*linesw[tp->t_line].l_read)(tp, uio, ioflag);
+       tty_unlock(tp);
+
+       return ret;

 }
 
 }
 

-int 
-kmwrite(
-       dev_t dev, 
-       struct uio *uio,
-       int ioflag)
+int
+kmwrite(dev_t dev, struct uio *uio, int ioflag)

 {
 {

-       register struct tty *tp;
- 
-       tp = &cons;
-       return ((*linesw[tp->t_line].l_write)(tp, uio, ioflag));
+       int ret;
+       struct tty *tp = km_tty[minor(dev)];
+
+       tty_lock(tp);
+       ret = (*linesw[tp->t_line].l_write)(tp, uio, ioflag);
+       tty_unlock(tp);
+
+       return ret;

 }
 
 }
 

-int 
-kmioctl(
-       dev_t dev, 
-       int cmd, 
-       caddr_t data, 
-       int flag,
-       struct proc *p)
+int
+kmioctl(dev_t dev, u_long cmd, caddr_t data, int flag, proc_t p)

 {
 {

-       int error;
-       struct tty *tp = &cons;
+       int error = 0;
+       struct tty *tp = km_tty[minor(dev)];

        struct winsize *wp;
        struct winsize *wp;

-       
-       switch (cmd) {
-               

 
 

+       tty_lock(tp);

 
 

-           case KMIOCSIZE:
+       switch (cmd) {
+       case KMIOCSIZE:

                wp = (struct winsize *)data;
                *wp = tp->t_winsize;
                wp = (struct winsize *)data;
                *wp = tp->t_winsize;

-               return 0;
-               
-           case TIOCSWINSZ:
+               break;
+
+       case TIOCSWINSZ:

                /* Prevent changing of console size --
                 * this ensures that login doesn't revert to the
                 * termcap-defined size
                 */
                /* Prevent changing of console size --
                 * this ensures that login doesn't revert to the
                 * termcap-defined size
                 */

-               return EINVAL;
+               error = EINVAL;
+               break;

 
 

-           /* Bodge in the CLOCAL flag as the km device is always local */
-           case TIOCSETA:
-           case TIOCSETAW:
-           case TIOCSETAF: {
-               register struct termios *t = (struct termios *)data;
+       /* Bodge in the CLOCAL flag as the km device is always local */
+       case TIOCSETA_32:
+       case TIOCSETAW_32:
+       case TIOCSETAF_32:
+       {
+               struct termios32 *t = (struct termios32 *)data;
+               t->c_cflag |= CLOCAL;
+               /* No Break */
+       }
+               goto fallthrough;
+       case TIOCSETA_64:
+       case TIOCSETAW_64:
+       case TIOCSETAF_64:
+       {
+               struct user_termios *t = (struct user_termios *)data;

                t->c_cflag |= CLOCAL;
                /* No Break */
                t->c_cflag |= CLOCAL;
                /* No Break */

-           }
-           default:            
+       }
+fallthrough:
+       default:

                error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
                error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);

-               if (error >= 0) {
-                       return error;
-               }
-               error = ttioctl (tp, cmd, data, flag, p);
-               if (error >= 0) {
-                       return error;
-               }
-               else {
-                       return ENOTTY;
+               if (ENOTTY != error) {
+                       break;

                }
                }

+               error = ttioctl_locked(tp, cmd, data, flag, p);
+               break;

        }
        }

-}

 
 

-int 
-kmputc(
-       int c)
-{
-
-       if( disableConsoleOutput)
-               return( 0);
-
-       if(!initialized)
-               return( 0);
-
-       if(c == '\n')
-               cnputc('\r');
+       tty_unlock(tp);

 
 

-       cnputc(c);
-
-       return 0;
+       return error;

 }
 
 }
 

-int 
-kmgetc(
-       dev_t dev)
+/*
+ * kmputc
+ *
+ * Output a character to the serial console driver via cnputcusr(),
+ * which is exported by that driver.
+ *
+ * Locks:       Assumes tp in the calling tty driver code is locked on
+ *              entry, remains locked on exit
+ *
+ * Notes:       Called from kmoutput(); giving the locking output
+ *              assumptions here, this routine should be static (and
+ *              inlined, given there is only one call site).
+ */
+int
+kmputc(__unused dev_t dev, char c)

 {
 {

-       int c;
-       
-       c= cngetc();
-
-       if (c == '\r') {
-               c = '\n';
+       if (!disableConsoleOutput && initialized) {
+               /* OCRNL */
+               if (c == '\n') {
+                       cnputcusr('\r');
+               }
+               cnputcusr(c);

        }
        }

-       cnputc(c);
-       return c;
-}

 
 

-int 
-kmgetc_silent(
-       dev_t dev)
-{
-       int c;
-       
-       c= cngetc();
-       if (c == '\r') {
-               c = '\n';
-       }
-       return c;
+       return 0;

 }
 
 }
 

+

 /*
  * Callouts from linesw.
  */
 /*
  * Callouts from linesw.
  */

- 
-#define KM_LOWAT_DELAY ((ns_time_t)1000)

 
 

-static void 
-kmstart(
-       struct tty *tp)
+#define KM_LOWAT_DELAY  ((ns_time_t)1000)
+
+/*
+ * t_oproc for this driver; called from within the line discipline
+ *
+ * Locks:      Assumes tp is locked on entry, remains locked on exit
+ */
+static void
+kmstart(struct tty *tp)

 {
 {

-       extern int hz;
-       if (tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP))
+       if (tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP)) {

                goto out;
                goto out;

-       if (tp->t_outq.c_cc == 0)
-               goto out;
-       tp->t_state |= TS_BUSY;
-       if (tp->t_outq.c_cc > tp->t_lowat) {
-               /*
-                * Start immediately.
-                */
-               kmoutput(tp);

        }
        }

-       else {
-               /*
-                * Wait a bit...
-                */
-#if 0
-               /* FIXME */
-               timeout(kmtimeout, tp, hz);
-#else
-               kmoutput(tp);
-#endif
+       if (tp->t_outq.c_cc == 0) {
+               goto out;

        }
        }

+       tp->t_state |= TS_BUSY;
+       kmoutput(tp);
+       return;
+

 out:
 out:

-       ttwwakeup(tp);
+       (*linesw[tp->t_line].l_start)(tp);
+       return;

 }
 
 }
 

+/*
+ * One-shot output retry timeout from kmoutput(); re-calls kmoutput() at
+ * intervals until the output queue for the tty is empty, at which point
+ * the timeout is not rescheduled by kmoutput()
+ *
+ * This function must take the tty_lock() around the kmoutput() call; it
+ * ignores the return value.
+ */

 static void
 static void

-kmtimeout( struct tty *tp)
+kmtimeout(void *arg)

 {
 {

-       boolean_t       funnel_state;
-
-       funnel_state = thread_funnel_set(kernel_flock, TRUE);
-       kmoutput(tp);
-       (void) thread_funnel_set(kernel_flock, funnel_state);
-
+       struct tty      *tp = (struct tty *)arg;

 
 

+       tty_lock(tp);
+       (void)kmoutput(tp);
+       tty_unlock(tp);

 }
 }

-static int 
-kmoutput(
-       struct tty *tp)
+
+/*
+ * kmoutput
+ *
+ * Locks:      Assumes tp is locked on entry, remains locked on exit
+ *
+ * Notes:      Called from kmstart() and kmtimeout(); kmtimeout() is a
+ *             timer initiated by this routine to deal with pending
+ *             output not yet flushed (output is flushed at a maximum
+ *             of sizeof(buf) charatcers at a time before dropping into
+ *             the timeout code).
+ */
+static int
+kmoutput(struct tty *tp)

 {
 {

-       /*
-        * FIXME - to be grokked...copied from m68k km.c.
-        */
-       char            buf[80];
-       char            *cp;
-       int             cc = -1;
-       extern int hz;
+       unsigned char   buf[80];        /* buffer; limits output per call */
+       unsigned char   *cp;
+       int             cc = -1;

 
 
 
 

+       /* While there is data available to be output... */

        while (tp->t_outq.c_cc > 0) {
                cc = ndqb(&tp->t_outq, 0);
        while (tp->t_outq.c_cc > 0) {
                cc = ndqb(&tp->t_outq, 0);

-               if (cc == 0)
+               if (cc == 0) {

                        break;
                        break;

-               cc = min(cc, sizeof buf);
+               }
+               /*
+                * attempt to output as many characters as are available,
+                * up to the available transfer buffer size.
+                */
+               cc = min(cc, sizeof(buf));
+               /* copy the output queue contents to the buffer */

                (void) q_to_b(&tp->t_outq, buf, cc);
                for (cp = buf; cp < &buf[cc]; cp++) {
                (void) q_to_b(&tp->t_outq, buf, cc);
                for (cp = buf; cp < &buf[cc]; cp++) {

-                   kmputc(*cp & 0x7f);
+                       /* output the buffer one charatcer at a time */
+                       *cp = *cp & 0x7f;
+               }
+
+               if (cc > 1) {
+                       cnputsusr((char *)buf, cc);
+               } else {
+                       kmputc(tp->t_dev, *buf);

                }
        }
                }
        }

-        if (tp->t_outq.c_cc > 0) {
+       /*
+        * XXX This is likely not necessary, as the tty output queue is not
+        * XXX writeable while we hold the tty_lock().
+        */
+       if (tp->t_outq.c_cc > 0) {

                timeout(kmtimeout, tp, hz);
        }
        tp->t_state &= ~TS_BUSY;
                timeout(kmtimeout, tp, hz);
        }
        tp->t_state &= ~TS_BUSY;

-       ttwwakeup(tp);
+       /* Start the output processing for the line discipline */
+       (*linesw[tp->t_line].l_start)(tp);

 
        return 0;
 }
 
        return 0;
 }

+
+
+/*
+ * cons_cinput
+ *
+ * Driver character input from the polled mode serial console driver calls
+ * this routine to input a character from the serial driver into the tty
+ * line discipline specific input processing receiv interrupt routine,
+ * l_rint().
+ *
+ * Locks:       Assumes that the tty_lock() is NOT held on the tp, so a
+ *              serial driver should NOT call this function as a result
+ *              of being called from a function which already holds the
+ *              lock; ECHOE will be handled at the line discipline, if
+ *              output echo processing is going to occur.
+ */
+void

 cons_cinput(char ch)
 {
 cons_cinput(char ch)
 {

-       struct tty *tp = &cons;
-       boolean_t       funnel_state;
-
-       
-       (*linesw[tp->t_line].l_rint) (ch, tp);
+       struct tty *tp = km_tty[0];     /* XXX */

 
 

+       tty_lock(tp);
+       (*linesw[tp->t_line].l_rint)(ch, tp);
+       tty_unlock(tp);

 }
 }

-