Skip site navigation (1)Skip section navigation (2)
Date:      Tue, 2 Jan 2018 16:19:41 +0000 (UTC)
From:      Mark Johnston <markj@FreeBSD.org>
To:        src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-stable@freebsd.org, svn-src-stable-11@freebsd.org
Subject:   svn commit: r327493 - stable/11/sys/geom/mirror
Message-ID:  <201801021619.w02GJfBM038701@repo.freebsd.org>

next in thread | raw e-mail | index | archive | help
Author: markj
Date: Tue Jan  2 16:19:41 2018
New Revision: 327493
URL: https://svnweb.freebsd.org/changeset/base/327493

Log:
  MFC r326983:
  Avoid using bioq_* in gmirror.

Modified:
  stable/11/sys/geom/mirror/g_mirror.c
  stable/11/sys/geom/mirror/g_mirror.h
Directory Properties:
  stable/11/   (props changed)

Modified: stable/11/sys/geom/mirror/g_mirror.c
==============================================================================
--- stable/11/sys/geom/mirror/g_mirror.c	Tue Jan  2 16:15:24 2018	(r327492)
+++ stable/11/sys/geom/mirror/g_mirror.c	Tue Jan  2 16:19:41 2018	(r327493)
@@ -305,7 +305,7 @@ g_mirror_nrequests(struct g_mirror_softc *sc, struct g
 	u_int nreqs = 0;
 
 	mtx_lock(&sc->sc_queue_mtx);
-	TAILQ_FOREACH(bp, &sc->sc_queue.queue, bio_queue) {
+	TAILQ_FOREACH(bp, &sc->sc_queue, bio_queue) {
 		if (bp->bio_from == cp)
 			nreqs++;
 	}
@@ -918,7 +918,7 @@ g_mirror_done(struct bio *bp)
 	sc = bp->bio_from->geom->softc;
 	bp->bio_cflags = G_MIRROR_BIO_FLAG_REGULAR;
 	mtx_lock(&sc->sc_queue_mtx);
-	bioq_insert_tail(&sc->sc_queue, bp);
+	TAILQ_INSERT_TAIL(&sc->sc_queue, bp, bio_queue);
 	mtx_unlock(&sc->sc_queue_mtx);
 	wakeup(sc);
 }
@@ -963,7 +963,7 @@ g_mirror_regular_request(struct bio *bp)
 			pbp->bio_completed = pbp->bio_length;
 			if (pbp->bio_cmd == BIO_WRITE ||
 			    pbp->bio_cmd == BIO_DELETE) {
-				bioq_remove(&sc->sc_inflight, pbp);
+				TAILQ_REMOVE(&sc->sc_inflight, pbp, bio_queue);
 				/* Release delayed sync requests if possible. */
 				g_mirror_sync_release(sc);
 			}
@@ -1018,7 +1018,7 @@ g_mirror_regular_request(struct bio *bp)
 		else {
 			pbp->bio_error = 0;
 			mtx_lock(&sc->sc_queue_mtx);
-			bioq_insert_tail(&sc->sc_queue, pbp);
+			TAILQ_INSERT_TAIL(&sc->sc_queue, pbp, bio_queue);
 			mtx_unlock(&sc->sc_queue_mtx);
 			G_MIRROR_DEBUG(4, "%s: Waking up %p.", __func__, sc);
 			wakeup(sc);
@@ -1038,7 +1038,7 @@ g_mirror_regular_request(struct bio *bp)
 			pbp->bio_error = 0;
 			pbp->bio_completed = pbp->bio_length;
 		}
-		bioq_remove(&sc->sc_inflight, pbp);
+		TAILQ_REMOVE(&sc->sc_inflight, pbp, bio_queue);
 		/* Release delayed sync requests if possible. */
 		g_mirror_sync_release(sc);
 		g_io_deliver(pbp, pbp->bio_error);
@@ -1058,7 +1058,7 @@ g_mirror_sync_done(struct bio *bp)
 	sc = bp->bio_from->geom->softc;
 	bp->bio_cflags = G_MIRROR_BIO_FLAG_SYNC;
 	mtx_lock(&sc->sc_queue_mtx);
-	bioq_insert_tail(&sc->sc_queue, bp);
+	TAILQ_INSERT_TAIL(&sc->sc_queue, bp, bio_queue);
 	mtx_unlock(&sc->sc_queue_mtx);
 	wakeup(sc);
 }
@@ -1115,30 +1115,33 @@ g_mirror_kernel_dump(struct bio *bp)
 static void
 g_mirror_flush(struct g_mirror_softc *sc, struct bio *bp)
 {
-	struct bio_queue_head queue;
+	struct bio_queue queue;
 	struct g_mirror_disk *disk;
 	struct g_consumer *cp;
 	struct bio *cbp;
 
-	bioq_init(&queue);
+	TAILQ_INIT(&queue);
 	LIST_FOREACH(disk, &sc->sc_disks, d_next) {
 		if (disk->d_state != G_MIRROR_DISK_STATE_ACTIVE)
 			continue;
 		cbp = g_clone_bio(bp);
 		if (cbp == NULL) {
-			while ((cbp = bioq_takefirst(&queue)) != NULL)
+			while ((cbp = TAILQ_FIRST(&queue)) != NULL) {
+				TAILQ_REMOVE(&queue, cbp, bio_queue);
 				g_destroy_bio(cbp);
+			}
 			if (bp->bio_error == 0)
 				bp->bio_error = ENOMEM;
 			g_io_deliver(bp, bp->bio_error);
 			return;
 		}
-		bioq_insert_tail(&queue, cbp);
+		TAILQ_INSERT_TAIL(&queue, cbp, bio_queue);
 		cbp->bio_done = g_mirror_flush_done;
 		cbp->bio_caller1 = disk;
 		cbp->bio_to = disk->d_consumer->provider;
 	}
-	while ((cbp = bioq_takefirst(&queue)) != NULL) {
+	while ((cbp = TAILQ_FIRST(&queue)) != NULL) {
+		TAILQ_REMOVE(&queue, cbp, bio_queue);
 		G_MIRROR_LOGREQ(3, cbp, "Sending request.");
 		disk = cbp->bio_caller1;
 		cbp->bio_caller1 = NULL;
@@ -1192,7 +1195,7 @@ g_mirror_start(struct bio *bp)
 		g_io_deliver(bp, bp->bio_to->error);
 		return;
 	}
-	bioq_insert_tail(&sc->sc_queue, bp);
+	TAILQ_INSERT_TAIL(&sc->sc_queue, bp, bio_queue);
 	mtx_unlock(&sc->sc_queue_mtx);
 	G_MIRROR_DEBUG(4, "%s: Waking up %p.", __func__, sc);
 	wakeup(sc);
@@ -1244,7 +1247,7 @@ g_mirror_regular_collision(struct g_mirror_softc *sc, 
 		return (false);
 	sstart = sbp->bio_offset;
 	send = sbp->bio_offset + sbp->bio_length;
-	TAILQ_FOREACH(bp, &sc->sc_inflight.queue, bio_queue) {
+	TAILQ_FOREACH(bp, &sc->sc_inflight, bio_queue) {
 		rstart = bp->bio_offset;
 		rend = bp->bio_offset + bp->bio_length;
 		if (rend > sstart && rstart < send)
@@ -1261,7 +1264,7 @@ g_mirror_regular_delay(struct g_mirror_softc *sc, stru
 {
 
 	G_MIRROR_LOGREQ(2, bp, "Delaying request.");
-	bioq_insert_head(&sc->sc_regular_delayed, bp);
+	TAILQ_INSERT_HEAD(&sc->sc_regular_delayed, bp, bio_queue);
 }
 
 /*
@@ -1272,7 +1275,7 @@ g_mirror_sync_delay(struct g_mirror_softc *sc, struct 
 {
 
 	G_MIRROR_LOGREQ(2, bp, "Delaying synchronization request.");
-	bioq_insert_tail(&sc->sc_sync_delayed, bp);
+	TAILQ_INSERT_TAIL(&sc->sc_sync_delayed, bp, bio_queue);
 }
 
 /*
@@ -1284,13 +1287,13 @@ g_mirror_regular_release(struct g_mirror_softc *sc)
 {
 	struct bio *bp, *bp2;
 
-	TAILQ_FOREACH_SAFE(bp, &sc->sc_regular_delayed.queue, bio_queue, bp2) {
+	TAILQ_FOREACH_SAFE(bp, &sc->sc_regular_delayed, bio_queue, bp2) {
 		if (g_mirror_sync_collision(sc, bp))
 			continue;
-		bioq_remove(&sc->sc_regular_delayed, bp);
+		TAILQ_REMOVE(&sc->sc_regular_delayed, bp, bio_queue);
 		G_MIRROR_LOGREQ(2, bp, "Releasing delayed request (%p).", bp);
 		mtx_lock(&sc->sc_queue_mtx);
-		bioq_insert_head(&sc->sc_queue, bp);
+		TAILQ_INSERT_HEAD(&sc->sc_queue, bp, bio_queue);
 		mtx_unlock(&sc->sc_queue_mtx);
 	}
 }
@@ -1304,10 +1307,10 @@ g_mirror_sync_release(struct g_mirror_softc *sc)
 {
 	struct bio *bp, *bp2;
 
-	TAILQ_FOREACH_SAFE(bp, &sc->sc_sync_delayed.queue, bio_queue, bp2) {
+	TAILQ_FOREACH_SAFE(bp, &sc->sc_sync_delayed, bio_queue, bp2) {
 		if (g_mirror_regular_collision(sc, bp))
 			continue;
-		bioq_remove(&sc->sc_sync_delayed, bp);
+		TAILQ_REMOVE(&sc->sc_sync_delayed, bp, bio_queue);
 		G_MIRROR_LOGREQ(2, bp,
 		    "Releasing delayed synchronization request.");
 		g_io_request(bp, bp->bio_from);
@@ -1613,7 +1616,7 @@ g_mirror_request_load(struct g_mirror_softc *sc, struc
 static void
 g_mirror_request_split(struct g_mirror_softc *sc, struct bio *bp)
 {
-	struct bio_queue_head queue;
+	struct bio_queue queue;
 	struct g_mirror_disk *disk;
 	struct g_consumer *cp;
 	struct bio *cbp;
@@ -1637,20 +1640,22 @@ g_mirror_request_split(struct g_mirror_softc *sc, stru
 	left = bp->bio_length;
 	offset = bp->bio_offset;
 	data = bp->bio_data;
-	bioq_init(&queue);
+	TAILQ_INIT(&queue);
 	LIST_FOREACH(disk, &sc->sc_disks, d_next) {
 		if (disk->d_state != G_MIRROR_DISK_STATE_ACTIVE)
 			continue;
 		cbp = g_clone_bio(bp);
 		if (cbp == NULL) {
-			while ((cbp = bioq_takefirst(&queue)) != NULL)
+			while ((cbp = TAILQ_FIRST(&queue)) != NULL) {
+				TAILQ_REMOVE(&queue, cbp, bio_queue);
 				g_destroy_bio(cbp);
+			}
 			if (bp->bio_error == 0)
 				bp->bio_error = ENOMEM;
 			g_io_deliver(bp, bp->bio_error);
 			return;
 		}
-		bioq_insert_tail(&queue, cbp);
+		TAILQ_INSERT_TAIL(&queue, cbp, bio_queue);
 		cbp->bio_done = g_mirror_done;
 		cbp->bio_caller1 = disk;
 		cbp->bio_to = disk->d_consumer->provider;
@@ -1663,7 +1668,8 @@ g_mirror_request_split(struct g_mirror_softc *sc, stru
 		offset += cbp->bio_length;
 		data += cbp->bio_length;
 	}
-	while ((cbp = bioq_takefirst(&queue)) != NULL) {
+	while ((cbp = TAILQ_FIRST(&queue)) != NULL) {
+		TAILQ_REMOVE(&queue, cbp, bio_queue);
 		G_MIRROR_LOGREQ(3, cbp, "Sending request.");
 		disk = cbp->bio_caller1;
 		cbp->bio_caller1 = NULL;
@@ -1702,9 +1708,9 @@ g_mirror_register_request(struct bio *bp)
 	case BIO_WRITE:
 	case BIO_DELETE:
 	    {
+		struct bio_queue queue;
 		struct g_mirror_disk *disk;
 		struct g_mirror_disk_sync *sync;
-		struct bio_queue_head queue;
 		struct g_consumer *cp;
 		struct bio *cbp;
 
@@ -1734,7 +1740,7 @@ g_mirror_register_request(struct bio *bp)
 		 * Allocate all bios before sending any request, so we can
 		 * return ENOMEM in nice and clean way.
 		 */
-		bioq_init(&queue);
+		TAILQ_INIT(&queue);
 		LIST_FOREACH(disk, &sc->sc_disks, d_next) {
 			sync = &disk->d_sync;
 			switch (disk->d_state) {
@@ -1752,14 +1758,16 @@ g_mirror_register_request(struct bio *bp)
 				continue;
 			cbp = g_clone_bio(bp);
 			if (cbp == NULL) {
-				while ((cbp = bioq_takefirst(&queue)) != NULL)
+				while ((cbp = TAILQ_FIRST(&queue)) != NULL) {
+					TAILQ_REMOVE(&queue, cbp, bio_queue);
 					g_destroy_bio(cbp);
+				}
 				if (bp->bio_error == 0)
 					bp->bio_error = ENOMEM;
 				g_io_deliver(bp, bp->bio_error);
 				return;
 			}
-			bioq_insert_tail(&queue, cbp);
+			TAILQ_INSERT_TAIL(&queue, cbp, bio_queue);
 			cbp->bio_done = g_mirror_done;
 			cp = disk->d_consumer;
 			cbp->bio_caller1 = cp;
@@ -1768,12 +1776,13 @@ g_mirror_register_request(struct bio *bp)
 			    ("Consumer %s not opened (r%dw%de%d).",
 			    cp->provider->name, cp->acr, cp->acw, cp->ace));
 		}
-		if (bioq_first(&queue) == NULL) {
+		if (TAILQ_EMPTY(&queue)) {
 			g_io_deliver(bp, EOPNOTSUPP);
 			return;
 		}
-		while ((cbp = bioq_takefirst(&queue)) != NULL) {
+		while ((cbp = TAILQ_FIRST(&queue)) != NULL) {
 			G_MIRROR_LOGREQ(3, cbp, "Sending request.");
+			TAILQ_REMOVE(&queue, cbp, bio_queue);
 			cp = cbp->bio_caller1;
 			cbp->bio_caller1 = NULL;
 			cp->index++;
@@ -1784,7 +1793,7 @@ g_mirror_register_request(struct bio *bp)
 		 * Put request onto inflight queue, so we can check if new
 		 * synchronization requests don't collide with it.
 		 */
-		bioq_insert_tail(&sc->sc_inflight, bp);
+		TAILQ_INSERT_TAIL(&sc->sc_inflight, bp, bio_queue);
 		return;
 	    }
 	default:
@@ -1927,8 +1936,10 @@ g_mirror_worker(void *arg)
 		 */
 		/* Get first request from the queue. */
 		mtx_lock(&sc->sc_queue_mtx);
-		bp = bioq_takefirst(&sc->sc_queue);
-		if (bp == NULL) {
+		bp = TAILQ_FIRST(&sc->sc_queue);
+		if (bp != NULL)
+			TAILQ_REMOVE(&sc->sc_queue, bp, bio_queue);
+		else {
 			if ((sc->sc_flags &
 			    G_MIRROR_DEVICE_FLAG_DESTROY) != 0) {
 				mtx_unlock(&sc->sc_queue_mtx);
@@ -1938,7 +1949,7 @@ g_mirror_worker(void *arg)
 					kproc_exit(0);
 				}
 				mtx_lock(&sc->sc_queue_mtx);
-				if (bioq_first(&sc->sc_queue) != NULL) {
+				if (!TAILQ_EMPTY(&sc->sc_queue)) {
 					mtx_unlock(&sc->sc_queue_mtx);
 					continue;
 				}
@@ -2188,7 +2199,8 @@ g_mirror_destroy_provider(struct g_mirror_softc *sc)
 	g_topology_lock();
 	g_error_provider(sc->sc_provider, ENXIO);
 	mtx_lock(&sc->sc_queue_mtx);
-	while ((bp = bioq_takefirst(&sc->sc_queue)) != NULL) {
+	while ((bp = TAILQ_FIRST(&sc->sc_queue)) != NULL) {
+		TAILQ_REMOVE(&sc->sc_queue, bp, bio_queue);
 		/*
 		 * Abort any pending I/O that wasn't generated by us.
 		 * Synchronization requests and requests destined for individual
@@ -3007,11 +3019,11 @@ g_mirror_create(struct g_class *mp, const struct g_mir
 	sc->sc_writes = 0;
 	sc->sc_refcnt = 1;
 	sx_init(&sc->sc_lock, "gmirror:lock");
-	bioq_init(&sc->sc_queue);
+	TAILQ_INIT(&sc->sc_queue);
 	mtx_init(&sc->sc_queue_mtx, "gmirror:queue", NULL, MTX_DEF);
-	bioq_init(&sc->sc_regular_delayed);
-	bioq_init(&sc->sc_inflight);
-	bioq_init(&sc->sc_sync_delayed);
+	TAILQ_INIT(&sc->sc_regular_delayed);
+	TAILQ_INIT(&sc->sc_inflight);
+	TAILQ_INIT(&sc->sc_sync_delayed);
 	LIST_INIT(&sc->sc_disks);
 	TAILQ_INIT(&sc->sc_events);
 	mtx_init(&sc->sc_events_mtx, "gmirror:events", NULL, MTX_DEF);

Modified: stable/11/sys/geom/mirror/g_mirror.h
==============================================================================
--- stable/11/sys/geom/mirror/g_mirror.h	Tue Jan  2 16:15:24 2018	(r327492)
+++ stable/11/sys/geom/mirror/g_mirror.h	Tue Jan  2 16:19:41 2018	(r327493)
@@ -191,17 +191,14 @@ struct g_mirror_softc {
 	uint32_t	sc_id;		/* Mirror unique ID. */
 
 	struct sx	 sc_lock;
-	struct bio_queue_head sc_queue;
+	struct bio_queue sc_queue;
 	struct mtx	 sc_queue_mtx;
 	struct proc	*sc_worker;
-	struct bio_queue_head sc_regular_delayed; /* Delayed I/O requests due
-						     collision with sync
-						     requests. */
-	struct bio_queue_head sc_inflight; /* In-flight regular write
-					      requests. */
-	struct bio_queue_head sc_sync_delayed; /* Delayed sync requests due
-						  collision with regular
-						  requests. */
+	struct bio_queue sc_inflight; /* In-flight regular write requests. */
+	struct bio_queue sc_regular_delayed; /* Delayed I/O requests due to
+						collision with sync requests. */
+	struct bio_queue sc_sync_delayed; /* Delayed sync requests due to
+					     collision with regular requests. */
 
 	LIST_HEAD(, g_mirror_disk) sc_disks;
 	u_int		sc_ndisks;	/* Number of disks. */



Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201801021619.w02GJfBM038701>