convert directly between HP-UX termio and POSIX termios

SCCS-vsn: sys/hp/hpux/hpux_tty.c 7.4

diff --git a/usr/src/sys/hp/hpux/hpux_tty.c b/usr/src/sys/hp/hpux/hpux_tty.c
index facdefb..1d442a4 100644 (file)
--- a/usr/src/sys/hp/hpux/hpux_tty.c
+++ b/usr/src/sys/hp/hpux/hpux_tty.c
@@ -11,7 +11,7 @@
  *
  * from: Utah $Hdr: hpux_tty.c 1.7 89/04/11$
  *
  *
  * from: Utah $Hdr: hpux_tty.c 1.7 89/04/11$
  *

- *     @(#)hpux_tty.c  7.3 (Berkeley) %G%
+ *     @(#)hpux_tty.c  7.4 (Berkeley) %G%

  */
 
 /*
  */
 
 /*


@@ -34,244 +34,239 @@
 #include "hpux.h"
 #include "hpux_termio.h"
 
 #include "hpux.h"
 #include "hpux_termio.h"
 

-char hpuxtobsdbaud[32] = {
-       B0,     B50,    B75,    B110,   B134,   B150,   B200,   B300,
-       B600,   B0,     B1200,  B1800,  B2400,  B0,     B4800,  B0,
-       B9600,  EXTA,   EXTB,   B0,     B0,     B0,     B0,     B0,
-       B0,     B0,     B0,     B0,     B0,     B0,     B0,     B0
-};
-
-char bsdtohpuxbaud[16] = {
-       TIO_B0,         TIO_B50,        TIO_B75,        TIO_B110,
-       TIO_B134,       TIO_B150,       TIO_B200,       TIO_B300,
-       TIO_B600,       TIO_B1200,      TIO_B1800,      TIO_B2400,
-       TIO_B4800,      TIO_B9600,      TIO_B19200,     TIO_B38400
-};
-

 /*
 /*

- * Map BSD style sgtty info to and from SYS5 style termio stuff.
- * Map BSD style sgtty info to and from V7 style sgtty stuff.
+ * Map BSD/POSIX style termios info to and from SYS5 style termio stuff.

  */
 hpuxtermio(fp, com, data)
        struct file *fp;
        caddr_t data;
 {
  */
 hpuxtermio(fp, com, data)
        struct file *fp;
        caddr_t data;
 {

-       struct sgttyb sg;
-       struct bsdtchars {      /* avoid problem with ttychars.h */
-               char bsdt_intrc;
-               char bsdt_quitc;
-               char bsdt_startc;
-               char bsdt_stopc;
-               char bsdt_eofc;
-               char bsdt_brkc;
-       } tc;
-       struct bsdltchars {     /* avoid problem with ttychars.h */
-               char bsdt_suspc;
-               char bsdt_dsuspc;
-               char bsdt_rprntc;
-               char bsdt_flushc;
-               char bsdt_werasc;
-               char bsdt_lnextc;
-       } ltc;
-       int lmode, error, (*ioctlrout)();
-       register u_short flag;
+       struct termios tios;
+       int line, error, (*ioctlrout)();

        register struct hpuxtermio *tiop;
 
        ioctlrout = fp->f_ops->fo_ioctl;
        tiop = (struct hpuxtermio *)data;
        switch (com) {
        case HPUXTCGETA:
        register struct hpuxtermio *tiop;
 
        ioctlrout = fp->f_ops->fo_ioctl;
        tiop = (struct hpuxtermio *)data;
        switch (com) {
        case HPUXTCGETA:

-               /* get everything we might need */
+               /*
+                * Get BSD terminal state
+                */

                bzero(data, sizeof(struct hpuxtermio));
                bzero(data, sizeof(struct hpuxtermio));

-               if (error = ioctlrout(fp, TIOCGETP, (caddr_t)&sg))
+               if (error = (*ioctlrout)(fp, TIOCGETA, (caddr_t)&tios))

                        break;
                        break;

-               (void) ioctlrout(fp, TIOCGETC, (caddr_t)&tc);
-               (void) ioctlrout(fp, TIOCLGET, (caddr_t)&lmode);
-
-               /* set baud rate */
-               tiop->c_cflag = (u_short)bsdtohpuxbaud[sg.sg_ispeed&0xF];
-
-               /* set editing chars except for EOF/EOL (set below) */
-               tiop->c_cc[HPUXVINTR] = tc.bsdt_intrc;
-               tiop->c_cc[HPUXVQUIT] = tc.bsdt_quitc;
-               tiop->c_cc[HPUXVERASE] = sg.sg_erase;
-               tiop->c_cc[HPUXVKILL] = sg.sg_kill;
-
-               /* set flags */
-               flag = sg.sg_flags;
-               if ((flag & TBDELAY) == XTABS)
+               /*
+                * Set iflag.
+                * Same through ICRNL, no BSD equivs for IUCLC, IENQAK
+                */
+               tiop->c_iflag = tios.c_iflag & 0x1ff;
+               if (tios.c_iflag & IXON)
+                       tiop->c_iflag |= TIO_IXON;
+               if (tios.c_iflag & IXOFF)
+                       tiop->c_iflag |= TIO_IXOFF;
+               if (tios.c_iflag & IXANY)
+                       tiop->c_iflag |= TIO_IXANY;
+               /*
+                * Set oflag.
+                * No BSD equivs for OLCUC/OCRNL/ONOCR/ONLRET/OFILL/OFDEL
+                * or any of the delays.
+                */
+               if (tios.c_oflag & OPOST)
+                       tiop->c_oflag |= TIO_OPOST;
+               if (tios.c_oflag & ONLCR)
+                       tiop->c_oflag |= TIO_ONLCR;
+               if (tios.c_oflag & OXTABS)

                        tiop->c_oflag |= TIO_TAB3;
                        tiop->c_oflag |= TIO_TAB3;

-               else if (flag & TBDELAY)
-                       tiop->c_oflag |= TIO_TAB1;
-               if (flag & LCASE) {
-                       tiop->c_iflag |= TIO_IUCLC;
-                       tiop->c_oflag |= TIO_OLCUC;
-                       tiop->c_lflag |= TIO_XCASE;
+               /*
+                * Set cflag.
+                * Baud from ospeed, rest from cflag.
+                */
+               tiop->c_cflag = bsdtohpuxbaud(tios.c_ospeed);
+               switch (tios.c_cflag & CSIZE) {
+               case CS5:
+                       tiop->c_cflag |= TIO_CS5; break;
+               case CS6:
+                       tiop->c_cflag |= TIO_CS6; break;
+               case CS7:
+                       tiop->c_cflag |= TIO_CS7; break;
+               case CS8:
+                       tiop->c_cflag |= TIO_CS8; break;

                }
                }

-               if (flag & ECHO)
+               if (tios.c_cflag & CSTOPB)
+                       tiop->c_cflag |= TIO_CSTOPB;
+               if (tios.c_cflag & CREAD)
+                       tiop->c_cflag |= TIO_CREAD;
+               if (tios.c_cflag & PARENB)
+                       tiop->c_cflag |= TIO_PARENB;
+               if (tios.c_cflag & PARODD)
+                       tiop->c_cflag |= TIO_PARODD;
+               if (tios.c_cflag & HUPCL)
+                       tiop->c_cflag |= TIO_HUPCL;
+               if (tios.c_cflag & CLOCAL)
+                       tiop->c_cflag |= TIO_CLOCAL;
+               /*
+                * Set lflag.
+                * No BSD equiv for XCASE.
+                */
+               if (tios.c_lflag & ECHOE)
+                       tiop->c_lflag |= TIO_ECHOE;
+               if (tios.c_lflag & ECHOK)
+                       tiop->c_lflag |= TIO_ECHOK;
+               if (tios.c_lflag & ECHO)

                        tiop->c_lflag |= TIO_ECHO;
                        tiop->c_lflag |= TIO_ECHO;

-               if (flag & CRMOD) {
-                       tiop->c_iflag |= TIO_ICRNL;
-                       tiop->c_oflag |= TIO_ONLCR;
-                       if (flag & CR1)
-                               tiop->c_oflag |= TIO_CR1;
-                       if (flag & CR2)
-                               tiop->c_oflag |= TIO_CR2|TIO_ONOCR;
-               } else {
-                       tiop->c_oflag |= TIO_ONLRET;
-                       if (flag & NL1)
-                               tiop->c_oflag |= TIO_CR1;
-                       if (flag & NL2)
-                               tiop->c_oflag |= TIO_CR2;
-               }
-               if (flag & RAW) {
-                       tiop->c_cflag |= TIO_CS8;
-                       tiop->c_iflag &= ~(TIO_ICRNL|TIO_IUCLC);
-                       tiop->c_cc[HPUXVMIN] = 6;
-                       tiop->c_cc[HPUXVTIME] = 1;
-               } else {
-                       tiop->c_iflag |= TIO_BRKINT;
-                       if (tc.bsdt_startc == CSTART && tc.bsdt_stopc == CSTOP)
-                               tiop->c_iflag |= TIO_IXON;
-                       if (flag & TANDEM)
-                               tiop->c_iflag |= TIO_IXOFF;
-                       else if ((lmode & LDECCTQ) == 0)
-                               tiop->c_iflag |= TIO_IXANY;
-                       if ((lmode & LLITOUT) == 0) {
-                               tiop->c_iflag |= TIO_IGNPAR;
-                               tiop->c_oflag |= TIO_OPOST;
-                       }
-                       if (lmode & LPASS8)
-                               tiop->c_cflag |= TIO_CS8;
-                       else
-                               tiop->c_iflag |= TIO_ISTRIP;
-                       tiop->c_cflag |= TIO_CS7|TIO_PARENB;
+               if (tios.c_lflag & ECHONL)
+                       tiop->c_lflag |= TIO_ECHONL;
+               if (tios.c_lflag & ISIG)

                        tiop->c_lflag |= TIO_ISIG;
                        tiop->c_lflag |= TIO_ISIG;

-                       if (flag & CBREAK) {
-                               tiop->c_cc[HPUXVMIN] = 6;
-                               tiop->c_cc[HPUXVTIME] = 1;
-                       } else {
-                               tiop->c_lflag |= TIO_ICANON|TIO_ECHOK;
-                               if (lmode & LCRTERA)
-                                       tiop->c_lflag |= TIO_ECHOE;
-                               tiop->c_cc[HPUXVEOF] = tc.bsdt_eofc;
-                               tiop->c_cc[HPUXVEOL] = tc.bsdt_brkc;
-                       }
-               }
-               tiop->c_cflag |= TIO_PARENB;
-               if (flag & ODDP) {
-                       if (flag & EVENP)
-                               tiop->c_cflag &= ~TIO_PARENB;
-                       tiop->c_cflag |= TIO_PARODD;
+               if (tios.c_lflag & ICANON)
+                       tiop->c_lflag |= TIO_ICANON;
+               if (tios.c_lflag & NOFLSH)
+                       tiop->c_lflag |= TIO_NOFLSH;
+               /*
+                * Line discipline
+                */
+               line = 0;
+               (void) (*ioctlrout)(fp, TIOCGETD, (caddr_t)&line);
+               tiop->c_line = line;
+               /*
+                * Set editing chars
+                */
+               tiop->c_cc[HPUXVINTR] = tios.c_cc[VINTR];
+               tiop->c_cc[HPUXVQUIT] = tios.c_cc[VQUIT];
+               tiop->c_cc[HPUXVERASE] = tios.c_cc[VERASE];
+               tiop->c_cc[HPUXVKILL] = tios.c_cc[VKILL];
+               if (tiop->c_lflag & TIO_ICANON) {
+                       tiop->c_cc[HPUXVEOF] = tios.c_cc[VEOF];
+                       tiop->c_cc[HPUXVEOL] = tios.c_cc[VEOL];
+               } else {
+                       tiop->c_cc[HPUXVMIN] = tios.c_cc[VMIN];
+                       tiop->c_cc[HPUXVTIME] = tios.c_cc[VTIME];

                }
                }

-               if (tiop->c_cflag & TIO_PARENB)
-                       tiop->c_iflag |= TIO_INPCK;
-               if (flag & VTDELAY)
-                       tiop->c_oflag |= TIO_FFDLY;
-               if (flag & BSDELAY)
-                       tiop->c_oflag |= TIO_BSDLY;

                break;
 
        case HPUXTCSETA:
        case HPUXTCSETAW:
        case HPUXTCSETAF:
                break;
 
        case HPUXTCSETA:
        case HPUXTCSETAW:
        case HPUXTCSETAF:

-               /* get old lmode and determine if we are a tty */
-               if (error = ioctlrout(fp, TIOCLGET, (caddr_t)&lmode))
+               /*
+                * Get old characteristics and determine if we are a tty.
+                */
+               if (error = (*ioctlrout)(fp, TIOCGETA, (caddr_t)&tios))

                        break;
                        break;

-               (void) ioctlrout(fp, TIOCGLTC, (caddr_t)&ltc);
-
-               /* set baud rate */
-               sg.sg_ispeed = hpuxtobsdbaud[tiop->c_cflag&TIO_CBAUD];
-               sg.sg_ospeed = sg.sg_ispeed;
-
-               /* set special chars to defaults for cooked mode */
-               sg.sg_erase = tiop->c_cc[HPUXVERASE];
-               sg.sg_kill = tiop->c_cc[HPUXVKILL];
-               tc.bsdt_intrc = tiop->c_cc[HPUXVINTR];
-               tc.bsdt_quitc = tiop->c_cc[HPUXVQUIT];
-               tc.bsdt_startc = CSTART;
-               tc.bsdt_stopc = CSTOP;
-               tc.bsdt_eofc = tiop->c_cc[HPUXVEOF];
-               tc.bsdt_brkc = tiop->c_cc[HPUXVEOL];
-               ltc.bsdt_suspc = CSUSP;
-               ltc.bsdt_dsuspc = CDSUSP;
-               ltc.bsdt_flushc = CDISCARD;
-               ltc.bsdt_lnextc = CLNEXT;
-
-               /* set flags */
-               flag = 0;
-               if (tiop->c_oflag & TIO_BSDLY)
-                       flag |= BSDELAY;
-               if (tiop->c_oflag & TIO_FFDLY)
-                       flag |= VTDELAY;
-               if (tiop->c_oflag & TIO_TAB1) {
-                       if (tiop->c_oflag & TIO_TAB2)
-                               flag |= XTABS;
-                       else
-                               flag |= TAB1;
-               } else if (tiop->c_oflag & TIO_TAB2)
-                       flag |= TAB2;
-               if (tiop->c_oflag & TIO_CR1) {
-                       flag |= CR1;
-                       if (tiop->c_oflag & TIO_ONLRET)
-                               flag |= NL1;
-               }
-               if (tiop->c_oflag & TIO_CR2) {
-                       flag |= CR2;
-                       if (tiop->c_oflag & TIO_ONLRET)
-                               flag |= NL2;
-               }
-               if ((tiop->c_oflag & (TIO_NLDLY|TIO_ONLRET)) == TIO_NLDLY)
-                       flag |= NL2;
-               if ((tiop->c_cflag & TIO_PARENB) == 0)
-                       flag |= ODDP|EVENP;
-               else if (tiop->c_cflag & TIO_PARODD)
-                       flag |= ODDP;
-               else
-                       flag |= EVENP;
-               if ((tiop->c_iflag & TIO_ICRNL) || (tiop->c_oflag & TIO_ONLCR))
-                       flag |= CRMOD;
-               if (tiop->c_lflag & TIO_ECHO)
-                       flag |= ECHO;
-               if (tiop->c_iflag & TIO_IUCLC)
-                       flag |= LCASE;
+               /*
+                * Set iflag.
+                * Same through ICRNL, no HP-UX equiv for IMAXBEL
+                */
+               tios.c_iflag &= ~(IXON|IXOFF|IXANY|0x1ff);
+               tios.c_iflag |= tiop->c_iflag & 0x1ff;
+               if (tiop->c_iflag & TIO_IXON)
+                       tios.c_iflag |= IXON;

                if (tiop->c_iflag & TIO_IXOFF)
                if (tiop->c_iflag & TIO_IXOFF)

-                       flag |= TANDEM;
-               if ((tiop->c_lflag & TIO_ICANON) == 0) {
-                       if (tiop->c_lflag & TIO_ISIG)
-                               flag |= CBREAK;
-                       else
-                               flag |= RAW;
-               }
-               if (flag & CBREAK) {
-                       ltc.bsdt_suspc = ltc.bsdt_dsuspc = -1;
-                       ltc.bsdt_flushc = ltc.bsdt_lnextc = -1;
-                       if ((tiop->c_iflag & TIO_IXON) == 0)
-                               tc.bsdt_startc = tc.bsdt_stopc = -1;
+                       tios.c_iflag |= IXOFF;
+               if (tiop->c_iflag & TIO_IXANY)
+                       tios.c_iflag |= IXANY;
+               /*
+                * Set oflag.
+                * No HP-UX equiv for ONOEOT
+                */
+               tios.c_oflag &= ~(OPOST|ONLCR|OXTABS);
+               if (tiop->c_oflag & TIO_OPOST)
+                       tios.c_oflag |= OPOST;
+               if (tiop->c_oflag & TIO_ONLCR)
+                       tios.c_oflag |= ONLCR;
+               if (tiop->c_oflag & TIO_TAB3)
+                       tios.c_oflag |= OXTABS;
+               /*
+                * Set cflag.
+                * No HP-UX equiv for CCTS_OFLOW/CCTS_IFLOW/MDMBUF
+                */
+               tios.c_cflag &=
+                       ~(CSIZE|CSTOPB|CREAD|PARENB|PARODD|HUPCL|CLOCAL);
+               switch (tiop->c_cflag & TIO_CSIZE) {
+               case TIO_CS5:
+                       tios.c_cflag |= CS5; break;
+               case TIO_CS6:
+                       tios.c_cflag |= CS6; break;
+               case TIO_CS7:
+                       tios.c_cflag |= CS7; break;
+               case TIO_CS8:
+                       tios.c_cflag |= CS8; break;

                }
                }

-               sg.sg_flags = flag;
-               lmode &= ~(LCRTERA|LLITOUT|LDECCTQ|LPASS8);
+               if (tiop->c_cflag & TIO_CSTOPB)
+                       tios.c_cflag |= CSTOPB;
+               if (tiop->c_cflag & TIO_CREAD)
+                       tios.c_cflag |= CREAD;
+               if (tiop->c_cflag & TIO_PARENB)
+                       tios.c_cflag |= PARENB;
+               if (tiop->c_cflag & TIO_PARODD)
+                       tios.c_cflag |= PARODD;
+               if (tiop->c_cflag & TIO_HUPCL)
+                       tios.c_cflag |= HUPCL;
+               if (tiop->c_cflag & TIO_CLOCAL)
+                       tios.c_cflag |= CLOCAL;
+               /*
+                * Set lflag.
+                * No HP-UX equiv for ECHOKE/ECHOPRT/ECHOCTL
+                * IEXTEN treated as part of ICANON
+                */
+               tios.c_lflag &= ~(ECHOE|ECHOK|ECHO|ISIG|ICANON|IEXTEN|NOFLSH);

                if (tiop->c_lflag & TIO_ECHOE)
                if (tiop->c_lflag & TIO_ECHOE)

-                       lmode |= LCRTERA;
-               if ((tiop->c_oflag & TIO_OPOST) == 0)
-                       lmode |= LLITOUT;
-               if ((tiop->c_iflag & TIO_IXANY) == 0)
-                       lmode |= LDECCTQ;
-               if ((tiop->c_cflag & TIO_CS8) &&
-                   (tiop->c_iflag & TIO_ISTRIP) == 0)
-                       lmode |= LPASS8;
-
-               /* set the new stuff */
+                       tios.c_lflag |= ECHOE;
+               if (tiop->c_lflag & TIO_ECHOK)
+                       tios.c_lflag |= ECHOK;
+               if (tiop->c_lflag & TIO_ECHO)
+                       tios.c_lflag |= ECHO;
+               if (tiop->c_lflag & TIO_ECHONL)
+                       tios.c_lflag |= ECHONL;
+               if (tiop->c_lflag & TIO_ISIG)
+                       tios.c_lflag |= ISIG;
+               if (tiop->c_lflag & TIO_ICANON)
+                       tios.c_lflag |= (ICANON|IEXTEN);
+               if (tiop->c_lflag & TIO_NOFLSH)
+                       tios.c_lflag |= NOFLSH;
+               /*
+                * Set editing chars.
+                * No HP-UX equivs of VEOL2/VWERASE/VREPRINT/VSUSP/VDSUSP
+                * VSTOP/VLNEXT/VDISCARD/VMIN/VTIME/VSTATUS/VERASE2
+                */
+               tios.c_cc[VINTR] = tiop->c_cc[HPUXVINTR];
+               tios.c_cc[VQUIT] = tiop->c_cc[HPUXVQUIT];
+               tios.c_cc[VERASE] = tiop->c_cc[HPUXVERASE];
+               tios.c_cc[VKILL] = tiop->c_cc[HPUXVKILL];
+               if (tios.c_lflag & ICANON) {
+                       tios.c_cc[VEOF] = tiop->c_cc[HPUXVEOF];
+                       tios.c_cc[VEOL] = tiop->c_cc[HPUXVEOL];
+               } else {
+                       tios.c_cc[VMIN] = tiop->c_cc[HPUXVMIN];
+                       tios.c_cc[VTIME] = tiop->c_cc[HPUXVTIME];
+               }
+               /*
+                * Set the new stuff
+                */

                if (com == HPUXTCSETA)
                if (com == HPUXTCSETA)

-                       com = TIOCSETN;
+                       com = TIOCSETA;
+               else if (com == HPUXTCSETAW)
+                       com = TIOCSETAW;

                else
                else

-                       com = TIOCSETP;
-               (void) ioctlrout(fp, com, (caddr_t)&sg);
-               (void) ioctlrout(fp, TIOCSETC, (caddr_t)&tc);
-               (void) ioctlrout(fp, TIOCSLTC, (caddr_t)&ltc);
-               (void) ioctlrout(fp, TIOCLSET, (caddr_t)&lmode);
-               if (tiop->c_cflag & TIO_HUPCL)
-                       (void) ioctlrout(fp, TIOCHPCL, (caddr_t)0);
+                       com = TIOCSETAF;
+               error = (*ioctlrout)(fp, com, (caddr_t)&tios);
+               if (error == 0) {
+                       /*
+                        * Set line discipline
+                        */
+                       line = tiop->c_line;
+                       (void) (*ioctlrout)(fp, TIOCSETD, (caddr_t)&line);
+                       /*
+                        * Set non-blocking IO if VMIN == VTIME == 0.
+                        * Should handle the other cases as well.  It also
+                        * isn't correct to just turn it off as it could be
+                        * on as the result of a fcntl operation.
+                        * XXX - wouldn't need to do this at all if VMIN/VTIME
+                        * were implemented.
+                        */
+                       line = (tiop->c_cc[HPUXVMIN] == 0 &&
+                               tiop->c_cc[HPUXVTIME] == 0);
+                       (void) fset(fp, FNDELAY, line);
+               }

                break;
 
        default:
                break;
 
        default:


@@ -281,6 +276,43 @@ hpuxtermio(fp, com, data)
        return(error);
 }
 
        return(error);
 }
 

+bsdtohpuxbaud(bsdspeed)
+       long bsdspeed;
+{
+       switch (bsdspeed) {
+       case B0:     return(TIO_B0);
+       case B50:    return(TIO_B50);
+       case B75:    return(TIO_B75);
+       case B110:   return(TIO_B110);
+       case B134:   return(TIO_B134);
+       case B150:   return(TIO_B150);
+       case B200:   return(TIO_B200);
+       case B300:   return(TIO_B300);
+       case B600:   return(TIO_B600);
+       case B1200:  return(TIO_B1200);
+       case B1800:  return(TIO_B1800);
+       case B2400:  return(TIO_B2400);
+       case B4800:  return(TIO_B4800);
+       case B9600:  return(TIO_B9600);
+       case B19200: return(TIO_B19200);
+       case B38400: return(TIO_B38400);
+       default:     return(TIO_B0);
+       }
+}
+
+hpuxtobsdbaud(hpuxspeed)
+       int hpuxspeed;
+{
+       static char hpuxtobsdbaudtab[32] = {
+               B0,     B50,    B75,    B110,   B134,   B150,   B200,   B300,
+               B600,   B0,     B1200,  B1800,  B2400,  B0,     B4800,  B0,
+               B9600,  B19200, B38400, B0,     B0,     B0,     B0,     B0,
+               B0,     B0,     B0,     B0,     B0,     B0,     EXTA,   EXTB
+       };
+
+       return(hpuxtobsdbaudtab[hpuxspeed & TIO_CBAUD]);
+}
+

 /* #ifdef COMPAT */
 ohpuxgtty(p, uap, retval)
        struct proc *p;
 /* #ifdef COMPAT */
 ohpuxgtty(p, uap, retval)
        struct proc *p;