From: Matthew Dillon <dillon@apollo.backplane.com>
Date: Mon, 24 Aug 2009 15:31:17 +0000 (-0700)
Subject: Rename serialize_sleep() to zsleep()
X-Git-Tag: v2.4.0~134
X-Git-Url: https://gitweb.dragonflybsd.org/dragonfly.git/commitdiff_plain/ed3f6624e9093425dd733be90efc696df86c9e0e

Rename serialize_sleep() to zsleep()
---

diff --git a/sys/dev/drm/drm_irq.c b/sys/dev/drm/drm_irq.c
index 534615836d..47e3945e68 100644
--- a/sys/dev/drm/drm_irq.c
+++ b/sys/dev/drm/drm_irq.c
@@ -442,7 +442,7 @@ int drm_wait_vblank(struct drm_device *dev, void *data, struct drm_file *file_pr
 			if (!(((drm_vblank_count(dev, crtc) -
 			    vblwait->request.sequence) <= (1 << 23)) ||
 			    !dev->irq_enabled))
-				ret = serialize_sleep(&dev->vblank[crtc].queue,
+				ret = zsleep(&dev->vblank[crtc].queue,
 				    &dev->irq_lock, PCATCH, "vblwtq",
 				    DRM_HZ);
 			lwkt_serialize_exit(&dev->irq_lock);
diff --git a/sys/dev/netif/iwl/iwl2100.c b/sys/dev/netif/iwl/iwl2100.c
index c1af330b4b..9fbdda2b90 100644
--- a/sys/dev/netif/iwl/iwl2100.c
+++ b/sys/dev/netif/iwl/iwl2100.c
@@ -2387,7 +2387,7 @@ iwl2100_wait_cmd(struct iwl2100_softc *sc)
 		panic("sleep in interrupt thread\n");
 
 	sc->sc_flags |= IWL2100_F_WAITCMD;
-	error = serialize_sleep(sc, ifp->if_serializer, 0, "iwlcmd", 2 * hz);
+	error = zsleep(sc, ifp->if_serializer, 0, "iwlcmd", 2 * hz);
 	if (!error) {
 		sc->sc_flags &= ~IWL2100_F_WAITCMD;
 		if (sc->sc_flags & IWL2100_F_ERROR) {
diff --git a/sys/kern/kern_synch.c b/sys/kern/kern_synch.c
index 2775a5314a..db65b14698 100644
--- a/sys/kern/kern_synch.c
+++ b/sys/kern/kern_synch.c
@@ -732,13 +732,13 @@ mtxsleep(void *ident, struct mtx *mtx, int flags,
 
 /*
  * Interlocked serializer sleep.  An exclusively held serializer must
- * be passed to serialize_sleep().  The function will atomically release
+ * be passed to zsleep().  The function will atomically release
  * the serializer and tsleep on the ident, then reacquire the serializer
  * and return.
  */
 int
-serialize_sleep(void *ident, struct lwkt_serialize *slz, int flags,
-		const char *wmesg, int timo)
+zsleep(void *ident, struct lwkt_serialize *slz, int flags,
+       const char *wmesg, int timo)
 {
 	globaldata_t gd = mycpu;
 	int ret;
diff --git a/sys/kern/lwkt_msgport.c b/sys/kern/lwkt_msgport.c
index 7aa5d32c28..4431ac172a 100644
--- a/sys/kern/lwkt_msgport.c
+++ b/sys/kern/lwkt_msgport.c
@@ -976,8 +976,7 @@ lwkt_serialize_waitmsg(lwkt_msg_t msg, int flags)
 	     * We must still wait for message completion regardless.
 	     */
 	    if ((flags & PCATCH) && sentabort == 0) {
-		error = serialize_sleep(won, port->mpu_serialize, PCATCH,
-					"waitmsg", 0);
+		error = zsleep(won, port->mpu_serialize, PCATCH, "waitmsg", 0);
 		if (error) {
 		    sentabort = error;
 		    lwkt_serialize_exit(port->mpu_serialize);
@@ -985,8 +984,7 @@ lwkt_serialize_waitmsg(lwkt_msg_t msg, int flags)
 		    lwkt_serialize_enter(port->mpu_serialize);
 		}
 	    } else {
-		error = serialize_sleep(won, port->mpu_serialize, 0,
-					"waitmsg", 0);
+		error = zsleep(won, port->mpu_serialize, 0, "waitmsg", 0);
 	    }
 	    /* see note at the top on the MSGPORTF_WAITING flag */
 	}
@@ -1019,8 +1017,7 @@ lwkt_serialize_waitport(lwkt_port_t port, int flags)
 
     while ((msg = _lwkt_pollmsg(port)) == NULL) {
 	port->mp_flags |= MSGPORTF_WAITING;
-	error = serialize_sleep(port, port->mpu_serialize, flags,
-				"waitport", 0);
+	error = zsleep(port, port->mpu_serialize, flags, "waitport", 0);
 	/* see note at the top on the MSGPORTF_WAITING flag */
 	if (error)
 	    return(NULL);
diff --git a/sys/sys/systm.h b/sys/sys/systm.h
index 977e36dfd9..725f4e1751 100644
--- a/sys/sys/systm.h
+++ b/sys/sys/systm.h
@@ -335,8 +335,7 @@ extern watchdog_tickle_fn	wdog_tickler;
 int	tsleep (void *, int, const char *, int);
 int	msleep (void *, struct spinlock *, int, const char *, int);
 int	mtxsleep (void *, struct mtx *, int, const char *, int);
-int	serialize_sleep(void *, struct lwkt_serialize *, int,
-			const char *, int);
+int	zsleep(void *, struct lwkt_serialize *, int, const char *, int);
 void	tsleep_interlock (void *, int);
 void	tsleep_remove (struct thread *);
 int	lwkt_sleep (const char *, int);