 @@ -1,14 +1,14 @@
-/*	$NetBSD: ld.c,v 1.111 2020/08/02 01:17:56 riastradh Exp $	*/
+/*	$NetBSD: ld.c,v 1.112 2021/05/30 11:24:02 riastradh Exp $	*/
 /*-
  * Copyright (c) 1998, 2000 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran and Charles M. Hannum.
+ *
  * 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
  *    notice, this list of conditions and the following disclaimer.
 @@ -24,27 +24,27 @@
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Disk driver for use by RAID controllers.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ld.c,v 1.111 2020/08/02 01:17:56 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ld.c,v 1.112 2021/05/30 11:24:02 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/device.h>
 #include <sys/queue.h>
 #include <sys/proc.h>
 #include <sys/buf.h>
 #include <sys/bufq.h>
 #include <sys/endian.h>
 #include <sys/disklabel.h>
 #include <sys/disk.h>
 #include <sys/dkio.h>
 @@ -53,26 +53,27 @@ __KERNEL_RCSID(0, "$NetBSD: ld.c,v 1.111
 #include <sys/fcntl.h>
 #include <sys/vnode.h>
 #include <sys/syslog.h>
 #include <sys/mutex.h>
 #include <sys/module.h>
 #include <sys/reboot.h>
 #include <dev/ldvar.h>
 #include "ioconf.h"
 static void	ldminphys(struct buf *bp);
 static bool	ld_suspend(device_t, const pmf_qual_t *);
 static bool	ld_resume(device_t, const pmf_qual_t *);
 static bool	ld_shutdown(device_t, int);
 static int	ld_diskstart(device_t, struct buf *bp);
 static void	ld_iosize(device_t, int *);
 static int	ld_dumpblocks(device_t, void *, daddr_t, int);
 static void	ld_fake_geometry(struct ld_softc *);
 static void	ld_set_geometry(struct ld_softc *);
 static void	ld_config_interrupts (device_t);
 static int	ld_lastclose(device_t);
 static int	ld_discard(device_t, off_t, off_t);
 static int	ld_flush(device_t, bool);
 static dev_type_open(ldopen);
 static dev_type_close(ldclose);
 @@ -156,27 +157,28 @@ ldattach(struct ld_softc *sc, const char
 	sc->sc_disksize512 = sc->sc_secperunit * sc->sc_secsize / DEV_BSIZE;
 	if (sc->sc_flags & LDF_NO_RND)
 		dksc->sc_flags |= DKF_NO_RND;
 	/* Attach dk and disk subsystems */
 	dk_attach(dksc);
 	disk_attach(&dksc->sc_dkdev);
 	ld_set_geometry(sc);
 	bufq_alloc(&dksc->sc_bufq, default_strategy, BUFQ_SORT_RAWBLOCK);
 	/* Register with PMF */
-	if (!pmf_device_register1(dksc->sc_dev, ld_suspend, NULL, ld_shutdown))
+	if (!pmf_device_register1(dksc->sc_dev, ld_suspend, ld_resume,
 		ld_shutdown))
 		aprint_error_dev(dksc->sc_dev,
 		    "couldn't establish power handler\n");
 	/* Discover wedges on this disk. */
 	config_interrupts(sc->sc_dv, ld_config_interrupts);
+}
 int
 ldadjqparam(struct ld_softc *sc, int xmax)
+{
 	mutex_enter(&sc->sc_mutex);
 	sc->sc_maxqueuecnt = xmax;
 @@ -266,27 +268,75 @@ ldenddetach(struct ld_softc *sc)
 	 * XXX perspective.
 	 */
 #if 0
 	ld_flush(dksc->sc_dev, false);
 #endif
 	cv_destroy(&sc->sc_drain);
 	mutex_destroy(&sc->sc_mutex);
+}
 /* ARGSUSED */
 static bool
 ld_suspend(device_t dev, const pmf_qual_t *qual)
+{
-	return ld_shutdown(dev, 0);
+	struct ld_softc *sc = device_private(dev);
 	int queuecnt;
 	bool ok = false;
 	/* Block new requests and wait for outstanding requests to drain.  */
 	mutex_enter(&sc->sc_mutex);
 	KASSERT((sc->sc_flags & LDF_SUSPEND) == 0);
 	sc->sc_flags |= LDF_SUSPEND;
 	while ((queuecnt = sc->sc_queuecnt) > 0) {
 		if (cv_timedwait(&sc->sc_drain, &sc->sc_mutex, 30 * hz))
 			break;
+	}
 	mutex_exit(&sc->sc_mutex);
 	/* Block suspend if we couldn't drain everything in 30sec.  */
 	if (queuecnt > 0) {
 		device_printf(dev, "timeout draining buffers\n");
 		goto out;
+	}
 	/* Flush cache before we lose power.  If we can't, block suspend.  */
 	if (ld_flush(dev, /*poll*/false) != 0) {
 		device_printf(dev, "failed to flush cache\n");
 		goto out;
+	}
 	/* Success!  */
 	ok = true;
 out:	if (!ok)
 		(void)ld_resume(dev, qual);
 	return ok;
+}
 static bool
 ld_resume(device_t dev, const pmf_qual_t *qual)
+{
 	struct ld_softc *sc = device_private(dev);
 	/* Allow new requests to come in.  */
 	mutex_enter(&sc->sc_mutex);
 	KASSERT(sc->sc_flags & LDF_SUSPEND);
 	sc->sc_flags &= ~LDF_SUSPEND;
 	mutex_exit(&sc->sc_mutex);
 	/* Restart any pending queued requests.  */
 	dk_start(&sc->sc_dksc, NULL);
 	return true;
+}
 /* ARGSUSED */
 static bool
 ld_shutdown(device_t dev, int flags)
+{
 	if ((flags & RB_NOSYNC) == 0 && ld_flush(dev, true) != 0)
 		return false;
 	return true;
+}
 /* ARGSUSED */
 @@ -428,37 +478,44 @@ ldstrategy(struct buf *bp)
 	unit = DISKUNIT(bp->b_dev);
 	sc = device_lookup_private(&ld_cd, unit);
 	dksc = &sc->sc_dksc;
 	dk_strategy(dksc, bp);
+}
 static int
 ld_diskstart(device_t dev, struct buf *bp)
+{
 	struct ld_softc *sc = device_private(dev);
 	int error;
-	if (sc->sc_queuecnt >= sc->sc_maxqueuecnt)
+	if (sc->sc_queuecnt >= sc->sc_maxqueuecnt ||
 	    sc->sc_flags & LDF_SUSPEND) {
 		if (sc->sc_flags & LDF_SUSPEND)
 			aprint_debug_dev(dev, "i/o blocked while suspended\n");
 		return EAGAIN;
+	}
 	if ((sc->sc_flags & LDF_MPSAFE) == 0)
 		KERNEL_LOCK(1, curlwp);
 	mutex_enter(&sc->sc_mutex);
-	if (sc->sc_queuecnt >= sc->sc_maxqueuecnt)
+	if (sc->sc_queuecnt >= sc->sc_maxqueuecnt ||
 	    sc->sc_flags & LDF_SUSPEND) {
 		if (sc->sc_flags & LDF_SUSPEND)
 			aprint_debug_dev(dev, "i/o blocked while suspended\n");
 		error = EAGAIN;
-	else {
+	} else {
 		error = (*sc->sc_start)(sc, bp);
 		if (error == 0)
 			sc->sc_queuecnt++;
+	}
 	mutex_exit(&sc->sc_mutex);
 	if ((sc->sc_flags & LDF_MPSAFE) == 0)
 		KERNEL_UNLOCK_ONE(curlwp);
 	return error;
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ldvar.h,v 1.34 2020/08/02 01:17:56 riastradh Exp $	*/
+/*	$NetBSD: ldvar.h,v 1.35 2021/05/30 11:24:02 riastradh Exp $	*/
 /*-
  * Copyright (c) 2000 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * 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
  *    notice, this list of conditions and the following disclaimer.
 @@ -60,22 +60,23 @@ struct ld_softc {
 	char		*sc_typename;	/* inquiry data */
 	int		(*sc_dump)(struct ld_softc *, void *, int, int);
 	int		(*sc_ioctl)(struct ld_softc *, u_long, void *, int32_t, bool);
 	int		(*sc_start)(struct ld_softc *, struct buf *);
 	int		(*sc_discard)(struct ld_softc *, struct buf *);
 };
 /* sc_flags */
 #define	LDF_ENABLED	0x001		/* device enabled */
 #define	LDF_UNUSED0	0x020		/* was LDF_DRAIN */
 #define	LDF_NO_RND	0x040		/* do not attach rnd source */
 #define	LDF_MPSAFE	0x080		/* backend is MPSAFE */
 #define	LDF_SUSPEND	0x100		/* disk is suspended until resume */
 int	ldadjqparam(struct ld_softc *, int);
 void	ldattach(struct ld_softc *, const char *);
 int	ldbegindetach(struct ld_softc *, int);
 void	ldenddetach(struct ld_softc *);
 void	lddone(struct ld_softc *, struct buf *);
 void	lddiscardend(struct ld_softc *, struct buf *);
 #endif	/* !_DEV_LDVAR_H_ */