Rename logbuffer dskrsv/dskreqs -> dskpool

src/fellow_log.c

@@ -421,9 +421,9 @@ assert_lbuf_dsk_resv(void)
 }
 
 // dsk request
-BUDDY_REQS(lbuf_dskrsv_s, LBUF_DSK_RSV_REQS);
-// this is the memory request for dskrsv
-BUDDY_REQS(lbuf_dskrsv_mem_s, 1);
+BUDDY_REQS(lbuf_dskpool_s, LBUF_DSK_RSV_REQS);
+// this is the memory request for dskpool
+BUDDY_REQS(lbuf_dskpool_mem_s, 1);
 // memory for flush_finish
 BUDDY_REQS(lbuf_ff_mem_s, 1);
 
@@ -466,8 +466,8 @@ struct fellow_logbuffer {
 	off_t				tail_off;
 	struct fellow_logbuffer_ff	*ff;
 	struct lbuf_ff_mem_s		ff_mem;
-	struct lbuf_dskrsv_mem_s	dskreqs_mem;
-	struct lbuf_dskrsv_s		(*dskreqs)[2];
+	struct lbuf_dskpool_mem_s	dskpool_mem;
+	struct lbuf_dskpool_s		(*dskpool)[2];
 	unsigned			active_reqs;
 };
 
@@ -1999,33 +1999,33 @@ logbuffer_fini_ff_mem(struct fellow_logbuffer *lbuf)
 }
 
 static inline void
-logbuffer_fini_dskreqs_mem(struct fellow_logbuffer *lbuf)
+logbuffer_fini_dskpool_mem(struct fellow_logbuffer *lbuf)
 {
-	if (lbuf->dskreqs_mem.reqs.magic == 0)
+	if (lbuf->dskpool_mem.reqs.magic == 0)
 		return;
 
-	buddy_alloc_wait_done(&lbuf->dskreqs_mem.reqs);
-	lbuf->dskreqs_mem.reqs.magic = 0;
+	buddy_alloc_wait_done(&lbuf->dskpool_mem.reqs);
+	lbuf->dskpool_mem.reqs.magic = 0;
 }
 
 static void
-logbuffer_fini_dskreqs(struct fellow_logbuffer *lbuf)
+logbuffer_fini_dskpool(struct fellow_logbuffer *lbuf)
 {
 	struct buddy_ptr_extent alloc;
 	size_t sz;
 
-	if (lbuf->dskreqs != NULL) {
-		buddy_alloc_wait_done(&(*lbuf->dskreqs)[0].reqs);
-		buddy_alloc_wait_done(&(*lbuf->dskreqs)[1].reqs);
-		sz = buddy_rndup(lbuf->membuddy, sizeof *lbuf->dskreqs);
-		alloc = BUDDY_PTR_EXTENT(lbuf->dskreqs, sz);
+	if (lbuf->dskpool != NULL) {
+		buddy_alloc_wait_done(&(*lbuf->dskpool)[0].reqs);
+		buddy_alloc_wait_done(&(*lbuf->dskpool)[1].reqs);
+		sz = buddy_rndup(lbuf->membuddy, sizeof *lbuf->dskpool);
+		alloc = BUDDY_PTR_EXTENT(lbuf->dskpool, sz);
 		buddy_return1_ptr_extent(lbuf->membuddy, &alloc);
-		lbuf->dskreqs = NULL;
+		lbuf->dskpool = NULL;
 	}
-	else if (lbuf->dskreqs_mem.reqs.magic == BUDDY_REQS_MAGIC)
-		logbuffer_fini_dskreqs_mem(lbuf);
-	AZ(lbuf->dskreqs);
-	AZ(lbuf->dskreqs_mem.reqs.magic);
+	else if (lbuf->dskpool_mem.reqs.magic == BUDDY_REQS_MAGIC)
+		logbuffer_fini_dskpool_mem(lbuf);
+	AZ(lbuf->dskpool);
+	AZ(lbuf->dskpool_mem.reqs.magic);
 }
 
 static void
@@ -2039,7 +2039,7 @@ logbuffer_fini(struct fellow_logbuffer *lbuf)
 	assert(lbuf->state == LBUF_FINI);
 	AZ(lbuf->regions_to_free);
 
-	logbuffer_fini_dskreqs(lbuf);
+	logbuffer_fini_dskpool(lbuf);
 	logbuffer_fini_ff_mem(lbuf);
 
 	if (lbuf->fdil.ioctx != NULL) {
@@ -2129,7 +2129,7 @@ logbuffer_recycle(struct fellow_fd *ffd, struct fellow_logbuffer *lbuf,
 	CHECK_OBJ_NOTNULL(ffd, FELLOW_FD_MAGIC);
 	AN(lbuf);
 
-	logbuffer_fini_dskreqs(lbuf);
+	logbuffer_fini_dskpool(lbuf);
 
 	logbuffer_assert_empty(lbuf);
 	logbuffer_wait_flush_fini(lbuf);
@@ -2188,7 +2188,7 @@ logbuffer_init(struct fellow_fd *ffd, struct fellow_logbuffer *lbuf,
 static inline void
 logbuffer_take(struct fellow_logbuffer *to, struct fellow_logbuffer *from)
 {
-	logbuffer_fini_dskreqs_mem(from);
+	logbuffer_fini_dskpool_mem(from);
 	logbuffer_fini_ff_mem(from);
 	logbuffer_wait_flush_fini(from);
 	TAKE(*to, *from);
@@ -2315,18 +2315,18 @@ logbuffer_fill_dskreq(const struct fellow_logbuffer *lbuf,
 }
 
 static struct buddy_reqs *
-logbuffer_get_dskreqs(struct fellow_logbuffer *lbuf)
+logbuffer_get_dskpool(struct fellow_logbuffer *lbuf)
 {
 	struct buddy_reqs *reqs;
 	int i;
 
-	AN(lbuf->dskreqs);
+	AN(lbuf->dskpool);
 	/* i < 3: If both reqs are empty, at iteration 3 we
 	 * must hit the first filled alloc
 	 */
 	for (i = 0; i < 3; i++) {
 		AZ(lbuf->active_reqs & ~1);
-		reqs = &(*lbuf->dskreqs)[lbuf->active_reqs].reqs;
+		reqs = &(*lbuf->dskpool)[lbuf->active_reqs].reqs;
 		CHECK_OBJ_NOTNULL(reqs, BUDDY_REQS_MAGIC);
 		if (buddy_reqs_next_ready(reqs))
 			return (reqs);
@@ -2342,13 +2342,13 @@ logbuffer_get_dskreqs(struct fellow_logbuffer *lbuf)
 }
 
 static void
-logbuffer_prep_dskreqs(struct fellow_logbuffer *lbuf, unsigned urgent)
+logbuffer_prep_dskpool(struct fellow_logbuffer *lbuf, unsigned urgent)
 {
-	struct lbuf_dskrsv_s (*dskreqs)[2];
+	struct lbuf_dskpool_s (*dskpool)[2];
 	struct buddy_ptr_extent alloc;
 	unsigned i;
 
-	if (lbuf->dskreqs != NULL)
+	if (lbuf->dskpool != NULL)
 		return;
 
 	assert(logbuffer_can(lbuf, LBUF_CAN_FLUSH));
@@ -2362,35 +2362,35 @@ logbuffer_prep_dskreqs(struct fellow_logbuffer *lbuf, unsigned urgent)
 	 *
 	 * XXX is 25% a good measure?
 	 */
-	if (lbuf->dskreqs_mem.reqs.magic == 0 &&
+	if (lbuf->dskpool_mem.reqs.magic == 0 &&
 	    (lbuf->logreg == NULL ||
 	     lbuf->logreg->free_n * 4 < lbuf->logreg->space ||
 	     lbuf->logreg->free_n < lbuf->n * 4)) {
-		BUDDY_REQS_INIT(&lbuf->dskreqs_mem, lbuf->membuddy);
-		BUDDY_REQS_PRI(&lbuf->dskreqs_mem.reqs, FEP_MEM_LOG);
-		AN(buddy_req_extent(&lbuf->dskreqs_mem.reqs,
-			sizeof *lbuf->dskreqs, 0));
-		(void) buddy_alloc_async(&lbuf->dskreqs_mem.reqs);
+		BUDDY_REQS_INIT(&lbuf->dskpool_mem, lbuf->membuddy);
+		BUDDY_REQS_PRI(&lbuf->dskpool_mem.reqs, FEP_MEM_LOG);
+		AN(buddy_req_extent(&lbuf->dskpool_mem.reqs,
+			sizeof *lbuf->dskpool, 0));
+		(void) buddy_alloc_async(&lbuf->dskpool_mem.reqs);
 	}
 
-	if (lbuf->dskreqs_mem.reqs.magic == BUDDY_REQS_MAGIC &&
+	if (lbuf->dskpool_mem.reqs.magic == BUDDY_REQS_MAGIC &&
 	    urgent > 0)
-		(void) buddy_alloc_async_wait(&lbuf->dskreqs_mem.reqs);
+		(void) buddy_alloc_async_wait(&lbuf->dskpool_mem.reqs);
 
-	if (lbuf->dskreqs_mem.reqs.magic == BUDDY_REQS_MAGIC &&
-	    buddy_alloc_async_ready(&lbuf->dskreqs_mem.reqs)) {
-		alloc = buddy_get_ptr_extent(&lbuf->dskreqs_mem.reqs, 0);
-		buddy_alloc_wait_done(&lbuf->dskreqs_mem.reqs);
-		lbuf->dskreqs_mem.reqs.magic = 0;
+	if (lbuf->dskpool_mem.reqs.magic == BUDDY_REQS_MAGIC &&
+	    buddy_alloc_async_ready(&lbuf->dskpool_mem.reqs)) {
+		alloc = buddy_get_ptr_extent(&lbuf->dskpool_mem.reqs, 0);
+		buddy_alloc_wait_done(&lbuf->dskpool_mem.reqs);
+		lbuf->dskpool_mem.reqs.magic = 0;
 		AN(alloc.ptr);
-		assert(alloc.size >= sizeof *lbuf->dskreqs);
+		assert(alloc.size >= sizeof *lbuf->dskpool);
 
-		dskreqs = alloc.ptr;
+		dskpool = alloc.ptr;
 		for (i = 0; i < 2; i++) {
-			BUDDY_REQS_INIT(&(*dskreqs)[i], lbuf->dskbuddy);
-			logbuffer_fill_dskreq(lbuf, &(*dskreqs)[i].reqs);
+			BUDDY_REQS_INIT(&(*dskpool)[i], lbuf->dskbuddy);
+			logbuffer_fill_dskreq(lbuf, &(*dskpool)[i].reqs);
 		}
-		lbuf->dskreqs = dskreqs;
+		lbuf->dskpool = dskpool;
 	}
 }
 
@@ -2423,16 +2423,16 @@ logbuffer_alloc_some(struct fellow_logbuffer *lbuf,
 		n--;
 	}
 
-	logbuffer_prep_dskreqs(lbuf, n);
+	logbuffer_prep_dskpool(lbuf, n);
 
 	if (n == 0)
 		return;
 
-	AN(lbuf->dskreqs);
+	AN(lbuf->dskpool);
 
 	while (n > 0) {
 		log_blocks_alloc_from_reqs(
-		    logbuffer_get_dskreqs(lbuf),
+		    logbuffer_get_dskpool(lbuf),
 		    &arr, &n);
 	}
 
@@ -3187,11 +3187,11 @@ logbuffer_availblks(const struct fellow_logbuffer *lbuf)
 
 	if (lbuf->logreg != NULL)
 		avail += lbuf->logreg->free_n;
-	if (lbuf->dskreqs != NULL) {
+	if (lbuf->dskpool != NULL) {
 		avail += buddy_reqs_next_ready(
-		    &(*lbuf->dskreqs)[0].reqs);
+		    &(*lbuf->dskpool)[0].reqs);
 		avail += buddy_reqs_next_ready(
-		    &(*lbuf->dskreqs)[1].reqs);
+		    &(*lbuf->dskpool)[1].reqs);
 	}
 	return (avail);
 }
@@ -3292,7 +3292,7 @@ logbuffer_addblks(struct fellow_fd *ffd,
 		AZ(lbuf->active.block);
 	}
 	if(logbuffer_can(lbuf, LBUF_CAN_FLUSH))
-		logbuffer_prep_dskreqs(lbuf, 0);
+		logbuffer_prep_dskpool(lbuf, 0);
 }
 
 enum getblk_e {