 @@ -1,14 +1,14 @@
-/*	$NetBSD: ppp_tty.c,v 1.70 2022/05/04 07:48:35 andvar Exp $	*/
+/*	$NetBSD: ppp_tty.c,v 1.71 2022/10/26 23:42:56 riastradh Exp $	*/
 /*	Id: ppp_tty.c,v 1.3 1996/07/01 01:04:11 paulus Exp 	*/
 /*
  * ppp_tty.c - Point-to-Point Protocol (PPP) driver for asynchronous
  * 	       tty devices.
+ *
  * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
+ *
  * 1. Redistributions of source code must retain the above copyright
 @@ -83,27 +83,27 @@
  * caused system crashes and packet corruption.  Changed pppstart
  * so that it doesn't just give up with a "collision" if the whole
  * packet doesn't fit in the output ring buffer.
+ *
  * Added priority queueing for interactive IP packets, following
  * the model of if_sl.c, plus hooks for bpf.
  * Paul Mackerras (paulus@cs.anu.edu.au).
  */
 /* from if_sl.c,v 1.11 84/10/04 12:54:47 rick Exp */
 /* from NetBSD: if_ppp.c,v 1.15.2.2 1994/07/28 05:17:58 cgd Exp */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ppp_tty.c,v 1.70 2022/05/04 07:48:35 andvar Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ppp_tty.c,v 1.71 2022/10/26 23:42:56 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "ppp.h"
 #include "opt_ppp.h"
 #endif
 #define VJC
 #define PPP_COMPRESS
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/mbuf.h>
 #include <sys/dkstat.h>
 #include <sys/socket.h>
 @@ -225,50 +225,50 @@ pppopen(dev_t dev, struct tty *tp)
     sc->sc_asyncmap[0] = 0xffffffff;
     sc->sc_asyncmap[3] = 0x60000000;
     sc->sc_rasyncmap = 0;
     sc->sc_devp = (void *) tp;
     sc->sc_start = pppasyncstart;
     sc->sc_ctlp = pppasyncctlp;
     sc->sc_relinq = pppasyncrelinq;
     sc->sc_outm = NULL;
     pppgetm(sc);
     sc->sc_if.if_flags |= IFF_RUNNING;
     sc->sc_if.if_baudrate = tp->t_ospeed;
     tp->t_sc = (void *) sc;
-    mutex_spin_enter(&tty_lock);
+    ttylock(tp);
     ttyflush(tp, FREAD | FWRITE);
-    mutex_spin_exit(&tty_lock);
+    ttyunlock(tp);
     splx(s);
     return (0);
+}
 /*
  * Line specific close routine, called from device close routine
  * and from ttioctl.
  * Detach the tty from the ppp unit.
  * Mimics part of ttyclose().
  */
 static int
 pppclose(struct tty *tp, int flag)
+{
     struct ppp_softc *sc;
     int s;
     s = spltty();
-    mutex_spin_enter(&tty_lock);
+    ttylock(tp);
     ttyflush(tp, FREAD|FWRITE);
-    mutex_spin_exit(&tty_lock);	/* XXX */
+    ttyunlock(tp);	/* XXX */
     ttyldisc_release(tp->t_linesw);
     tp->t_linesw = ttyldisc_default();
     sc = (struct ppp_softc *) tp->t_sc;
     if (sc != NULL) {
 	tp->t_sc = NULL;
 	if (tp == (struct tty *) sc->sc_devp) {
 	    pppasyncrelinq(sc);
 	    pppdealloc(sc);
+	}
+    }
     splx(s);
     return 0;
+}
 @@ -306,57 +306,57 @@ pppasyncrelinq(struct ppp_softc *sc)
 static int
 pppread(struct tty *tp, struct uio *uio, int flag)
+{
     struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc;
     struct mbuf *m, *m0;
     int error = 0;
     if (sc == NULL)
 	return 0;
     /*
      * Loop waiting for input, checking that nothing disastrous
      * happens in the meantime.
      */
-    mutex_spin_enter(&tty_lock);
+    ttylock(tp);
     for (;;) {
 	if (tp != (struct tty *) sc->sc_devp ||
 	    tp->t_linesw != &ppp_disc) {
-	    mutex_spin_exit(&tty_lock);
+	    ttyunlock(tp);
 	    return 0;
+	}
 	if (sc->sc_inq.ifq_head != NULL)
 	    break;
 	if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0
 	    && (tp->t_state & TS_ISOPEN)) {
-	    mutex_spin_exit(&tty_lock);
+	    ttyunlock(tp);
 	    return 0;		/* end of file */
+	}
 	if (tp->t_state & TS_ASYNC || flag & IO_NDELAY) {
-	    mutex_spin_exit(&tty_lock);
+	    ttyunlock(tp);
 	    return (EWOULDBLOCK);
+	}
 	error = ttysleep(tp, &tp->t_rawcv, true, 0);
 	if (error) {
-	    mutex_spin_exit(&tty_lock);
+	    ttyunlock(tp);
 	    return error;
+	}
+    }
     /* Pull place-holder byte out of canonical queue */
     getc(&tp->t_canq);
     /* Get the packet from the input queue */
     IF_DEQUEUE(&sc->sc_inq, m0);
-    mutex_spin_exit(&tty_lock);
+    ttyunlock(tp);
     for (m = m0; m && uio->uio_resid; m = m->m_next)
 	if ((error = uiomove(mtod(m, u_char *), m->m_len, uio)) != 0)
 	    break;
     m_freem(m0);
     return (error);
+}
 /*
  * Line specific (tty) write routine.
  */
 static int
 pppwrite(struct tty *tp, struct uio *uio, int flag)
 @@ -692,27 +692,27 @@ pppasyncstart(struct ppp_softc *sc)
+{
     struct tty *tp = (struct tty *) sc->sc_devp;
     struct mbuf *m;
     int len;
     u_char *start, *stop, *cp;
     int n, ndone, done, idle;
     struct mbuf *m2;
     if (sc->sc_flags & SC_SYNC){
 	pppsyncstart(sc);
 	return;
+    }
-    mutex_spin_enter(&tty_lock);
+    ttylock(tp);
     idle = 0;
     while (CCOUNT(&tp->t_outq) < PPP_HIWAT) {
 	/*
 	 * See if we have an existing packet partly sent.
 	 * If not, get a new packet and start sending it.
 	 */
 	m = sc->sc_outm;
 	if (m == NULL) {
 	    /*
 	     * Get another packet to be sent.
 	     */
 	    m = ppp_dequeue(sc);
 @@ -850,44 +850,44 @@ pppasyncstart(struct ppp_softc *sc)
     /* Call pppstart to start output again if necessary. */
     pppstart(tp);
     /*
      * This timeout is needed for operation on a pseudo-tty,
      * because the pty code doesn't call pppstart after it has
      * drained the t_outq.
      */
     if (!idle && (sc->sc_flags & SC_TIMEOUT) == 0) {
 	callout_reset(&sc->sc_timo_ch, 1, ppp_timeout, sc);
 	sc->sc_flags |= SC_TIMEOUT;
+    }
-    mutex_spin_exit(&tty_lock);
+    ttyunlock(tp);
+}
 /*
  * This gets called when a received packet is placed on
  * the inq, at splsoftnet.
  */
 static void
 pppasyncctlp(struct ppp_softc *sc)
+{
     struct tty *tp;
     /* Put a placeholder byte in canq for ttselect()/ttnread(). */
     mutex_spin_enter(&tty_lock);
     tp = (struct tty *) sc->sc_devp;
     ttylock(tp);
     putc(0, &tp->t_canq);
     ttwakeup(tp);
-    mutex_spin_exit(&tty_lock);
+    ttyunlock(tp);
+}
 /*
  * Start output on async tty interface.  If the transmit queue
  * has drained sufficiently, arrange for pppasyncstart to be
  * called later at splsoftnet.
  * Called at spltty or higher.
  */
 static int
 pppstart(struct tty *tp)
+{
     struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc;
 @@ -922,30 +922,30 @@ pppstart(struct tty *tp)
     return 0;
+}
 /*
  * Timeout routine - try to start some more output.
  */
 static void
 ppp_timeout(void *x)
+{
     struct ppp_softc *sc = (struct ppp_softc *) x;
     struct tty *tp = (struct tty *) sc->sc_devp;
-    mutex_spin_enter(&tty_lock);
+    ttylock(tp);
     sc->sc_flags &= ~SC_TIMEOUT;
     pppstart(tp);
-    mutex_spin_exit(&tty_lock);
+    ttyunlock(tp);
+}
 /*
  * Allocate enough mbuf to handle current MRU.
  */
 static void
 pppgetm(struct ppp_softc *sc)
+{
     struct mbuf *m, **mp;
     int len;
     mp = &sc->sc_m;
     for (len = sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN; len > 0; ){