Rename serialize_sleep() to zsleep()

diff --git a/sys/dev/drm/drm_irq.c b/sys/dev/drm/drm_irq.c
index 5346158..47e3945 100644 (file)
--- 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 c1af330..9fbdda2 100644 (file)
--- 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 2775a53..db65b14 100644 (file)
--- 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 7aa5d32..4431ac1 100644 (file)
--- 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 977e36d..725f4e1 100644 (file)
--- 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);