xfsdump: rename worker threads

xfsdump's use of "slave," while largely understood in technical circles,
poses a barrier for inclusion to some potential members of the development
and user community, due to the historical context of masters and slaves,
particularly in the United States.

As these entities are already controlled by "managers" in the code,
simply rename them to "workers," which is a more natural fit in any
case.

Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Pavel Reichl <preichl@redhat.com>
Signed-off-by: Eric Sandeen <sandeen@sandeen.net>

8 files changed, 68 insertions, 68 deletions

diff --git a/common/drive.h b/common/drive.h
index ee53aeb3..973108a7 100644
--- a/common/drive.h
+++ b/common/drive.h
@@ -584,7 +584,7 @@ struct drive_ops {
 				 */
 	void (*do_quit)(drive_t *drivep);
 				/* tells the drive manager to de-allocate
-				 * resources, INCLUDING the slave process.
+				 * resources, INCLUDING the worker process.
 				 */
 };
 
diff --git a/common/drive_minrmt.c b/common/drive_minrmt.c
index 55aa8b0f..0cbf2352 100644
--- a/common/drive_minrmt.c
+++ b/common/drive_minrmt.c
@@ -186,7 +186,7 @@ struct drive_context {
 			 * to media without error. includes media file header
 			 * record. this is incremented when the actual I/O is
 			 * done. dc_reccnt is different, indicating what has
-			 * been seen by client. slave may have read ahead /
+			 * been seen by client. worker may have read ahead /
 			 * written behind.
 			 */
 	int dc_fd;
@@ -211,7 +211,7 @@ struct drive_context {
 			 * compression
 			 */
 	bool_t dc_singlethreadedpr;
-			/* single-threaded operation (no slave)
+			/* single-threaded operation (no worker)
 			 */
 	bool_t dc_errorpr;
 			/* TRUE if error encountered during reading or writing.
@@ -687,7 +687,7 @@ do_init(drive_t *drivep)
 	return BOOL_TRUE;
 }
 
-/* wait here for slave to complete initialization.
+/* wait here for worker to complete initialization.
  * set drive capabilities flags. NOTE: currently don't make use of this
  * feature: drive initialization done whenever block/record sizes unknown.
  */
@@ -2514,7 +2514,7 @@ do_quit(drive_t *drivep)
 	if (ringp) {
 		display_ring_metrics(drivep, MLOG_VERBOSE);
 
-		/* tell slave to die
+		/* tell worker to die
 		 */
 		mlog((MLOG_NITTY + 1) | MLOG_DRIVE,
 		      "ring op: destroy\n");
@@ -3873,10 +3873,10 @@ display_ring_metrics(drive_t *drivep, int mlog_flags)
 	      bufszbuf,
 	      bufszsfxp,
 	      contextp->dc_ringpinnedpr ? _("pinned ") : "",
-	      ringp->r_slave_msgcnt - ringp->r_slave_blkcnt,
-	      ringp->r_slave_msgcnt,
-	      percent64(ringp->r_slave_msgcnt - ringp->r_slave_blkcnt,
-			 ringp->r_slave_msgcnt),
+	      ringp->r_worker_msgcnt - ringp->r_worker_blkcnt,
+	      ringp->r_worker_msgcnt,
+	      percent64(ringp->r_worker_msgcnt - ringp->r_worker_blkcnt,
+			 ringp->r_worker_msgcnt),
 	      (double)(ringp->r_all_io_cnt)
 	      *
 	      (double)tape_recsz
diff --git a/common/drive_scsitape.c b/common/drive_scsitape.c
index 452a16a4..878a5d7c 100644
--- a/common/drive_scsitape.c
+++ b/common/drive_scsitape.c
@@ -188,7 +188,7 @@ struct drive_context {
 			 * to media without error. includes media file header
 			 * record. this is incremented when the actual I/O is
 			 * done. dc_reccnt is different, indicating what has
-			 * been seen by client. slave may have read ahead /
+			 * been seen by client. worker may have read ahead /
 			 * written behind.
 			 */
 	int dc_fd;
@@ -231,7 +231,7 @@ struct drive_context {
 			 * compression
 			 */
 	bool_t dc_singlethreadedpr;
-			/* single-threaded operation (no slave)
+			/* single-threaded operation (no worker)
 			 */
 	bool_t dc_errorpr;
 			/* TRUE if error encountered during reading or writing.
@@ -800,7 +800,7 @@ do_init(drive_t *drivep)
 	return BOOL_TRUE;
 }
 
-/* wait here for slave to complete initialization.
+/* wait here for worker to complete initialization.
  * set drive capabilities flags. NOTE: currently don't make use of this
  * feature: drive initialization done whenever block/record sizes unknown.
  */
@@ -2752,7 +2752,7 @@ do_quit(drive_t *drivep)
 	if (ringp) {
 		display_ring_metrics(drivep, MLOG_VERBOSE);
 
-		/* tell slave to die
+		/* tell worker to die
 		 */
 		mlog((MLOG_NITTY + 1) | MLOG_DRIVE,
 		      "ring op: destroy\n");
@@ -5156,10 +5156,10 @@ display_ring_metrics(drive_t *drivep, int mlog_flags)
 	      bufszbuf,
 	      bufszsfxp,
 	      contextp->dc_ringpinnedpr ? _("pinned ") : "",
-	      ringp->r_slave_msgcnt - ringp->r_slave_blkcnt,
-	      ringp->r_slave_msgcnt,
-	      percent64(ringp->r_slave_msgcnt - ringp->r_slave_blkcnt,
-			 ringp->r_slave_msgcnt),
+	      ringp->r_worker_msgcnt - ringp->r_worker_blkcnt,
+	      ringp->r_worker_msgcnt,
+	      percent64(ringp->r_worker_msgcnt - ringp->r_worker_blkcnt,
+			 ringp->r_worker_msgcnt),
 	      (double)(ringp->r_all_io_cnt)
 	      *
 	      (double)tape_recsz
diff --git a/common/main.c b/common/main.c
index cb2caf77..1db07d4b 100644
--- a/common/main.c
+++ b/common/main.c
@@ -625,10 +625,10 @@ main(int argc, char *argv[])
 
 	/* now do the second and third passes of drive initialization.
 	 * allocate per-stream write and read headers. if a drive
-	 * manager uses a slave process, it should be created now,
-	 * using cldmgr_create(). each drive manager may use the slave to
+	 * manager uses a worker process, it should be created now,
+	 * using cldmgr_create(). each drive manager may use the worker to
 	 * asynchronously read the media file header, typically a very
-	 * time-consuming chore. drive_init3 will synchronize with each slave.
+	 * time-consuming chore. drive_init3 will synchronize with each worker.
 	 */
 	if (!init_error) {
 #ifdef DUMP
@@ -1465,7 +1465,7 @@ childmain(void *arg1)
 	exitcode = content_stream_restore(stix);
 #endif /* RESTORE */
 
-	/* let the drive manager shut down its slave thread
+	/* let the drive manager shut down its worker thread
 	 */
 	drivep = drivepp[stix];
 	(*drivep->d_opsp->do_quit)(drivep);
diff --git a/common/ring.c b/common/ring.c
index 87152dd9..7c6b4995 100644
--- a/common/ring.c
+++ b/common/ring.c
@@ -33,7 +33,7 @@
 #include "cldmgr.h"
 #include "ring.h"
 
-static int ring_slave_entry(void *ringctxp);
+static int ring_worker_entry(void *ringctxp);
 
 ring_t *
 ring_create(size_t ringlen,
@@ -72,14 +72,14 @@ ring_create(size_t ringlen,
 	ringp->r_active_in_ix = 0;
 	ringp->r_active_out_ix = 0;
 	ringp->r_client_cnt = 0;
-	ringp->r_slave_cnt = 0;
+	ringp->r_worker_cnt = 0;
 
 	/* initialize the meters
 	 */
 	ringp->r_client_msgcnt = 0;
-	ringp->r_slave_msgcnt = 0;
+	ringp->r_worker_msgcnt = 0;
 	ringp->r_client_blkcnt = 0;
-	ringp->r_slave_blkcnt = 0;
+	ringp->r_worker_blkcnt = 0;
 	ringp->r_first_io_time = 0;
 	ringp->r_all_io_cnt = 0;
 
@@ -120,11 +120,11 @@ ring_create(size_t ringlen,
 		}
 	}
 
-	/* kick off the slave thread
+	/* kick off the worker thread
 	 */
-	ok = cldmgr_create(ring_slave_entry,
+	ok = cldmgr_create(ring_worker_entry,
 			    drive_index,
-			    _("slave"),
+			    _("worker"),
 			    ringp);
 	assert(ok);
 
@@ -233,7 +233,7 @@ ring_reset(ring_t *ringp, ring_msg_t *msgp)
 		assert(ringp->r_client_cnt == 1);
 	}
 
-	/* tell the slave to abort
+	/* tell the worker to abort
 	 */
 	msgp->rm_op = RING_OP_RESET;
 	ring_put(ringp, msgp);
@@ -263,7 +263,7 @@ ring_reset(ring_t *ringp, ring_msg_t *msgp)
 	ringp->r_active_in_ix = 0;
 	ringp->r_active_out_ix = 0;
 	ringp->r_client_cnt = 0;
-	ringp->r_slave_cnt = 0;
+	ringp->r_worker_cnt = 0;
 	for (mix = 0; mix < ringp->r_len; mix++) {
 		ring_msg_t *msgp = &ringp->r_msgp[mix];
 		msgp->rm_mix = mix;
@@ -290,7 +290,7 @@ ring_destroy(ring_t *ringp)
 	 */
 	msgp = ring_get(ringp);
 
-	/* tell the slave to exit
+	/* tell the worker to exit
 	 */
 	msgp->rm_op = RING_OP_DIE;
 	ring_put(ringp, msgp);
@@ -308,7 +308,7 @@ ring_destroy(ring_t *ringp)
 					ringp->r_len;
 	} while (msgp->rm_stat != RING_STAT_DIEACK);
 
-	/* the slave is dead.
+	/* the worker is dead.
 	 */
 	qsem_free(ringp->r_ready_qsemh);
 	qsem_free(ringp->r_active_qsemh);
@@ -317,19 +317,19 @@ ring_destroy(ring_t *ringp)
 
 
 static ring_msg_t *
-ring_slave_get(ring_t *ringp)
+ring_worker_get(ring_t *ringp)
 {
 	ring_msg_t *msgp;
 
-	/* assert slave currently holds no messages
+	/* assert worker currently holds no messages
 	 */
-	assert(ringp->r_slave_cnt == 0);
+	assert(ringp->r_worker_cnt == 0);
 
-	/* bump slave message count and note if slave needs to block
+	/* bump worker message count and note if worker needs to block
 	 */
-	ringp->r_slave_msgcnt++;
+	ringp->r_worker_msgcnt++;
 	if (qsemPwouldblock(ringp->r_active_qsemh)) {
-		ringp->r_slave_blkcnt++;
+		ringp->r_worker_blkcnt++;
 	}
 
 	/* block until msg available on active queue ("P")
@@ -358,23 +358,23 @@ ring_slave_get(ring_t *ringp)
 	 */
 	msgp->rm_loc = RING_LOC_SLAVE;
 
-	/* bump the count of messages held by the slave
+	/* bump the count of messages held by the worker
 	 */
-	ringp->r_slave_cnt++;
+	ringp->r_worker_cnt++;
 
-	/* return the msg to the slave
+	/* return the msg to the worker
 	 */
 	return msgp;
 }
 
 static void
-ring_slave_put(ring_t *ringp, ring_msg_t *msgp)
+ring_worker_put(ring_t *ringp, ring_msg_t *msgp)
 {
-	/* assert the slave holds exactly one message
+	/* assert the worker holds exactly one message
 	 */
-	assert(ringp->r_slave_cnt == 1);
+	assert(ringp->r_worker_cnt == 1);
 
-	/* assert the slave is returning the right message
+	/* assert the worker is returning the right message
 	 */
 	assert(msgp->rm_mix == ringp->r_ready_in_ix);
 
@@ -382,9 +382,9 @@ ring_slave_put(ring_t *ringp, ring_msg_t *msgp)
 	 */
 	assert(msgp->rm_loc == RING_LOC_SLAVE);
 
-	/* decrement the count of messages held by the slave
+	/* decrement the count of messages held by the worker
 	 */
-	ringp->r_slave_cnt--;
+	ringp->r_worker_cnt--;
 
 	/* update the message location
 	 */
@@ -402,7 +402,7 @@ ring_slave_put(ring_t *ringp, ring_msg_t *msgp)
 }
 
 static int
-ring_slave_entry(void *ringctxp)
+ring_worker_entry(void *ringctxp)
 {
 	sigset_t blocked_set;
 	ring_t *ringp = (ring_t *)ringctxp;
@@ -424,7 +424,7 @@ ring_slave_entry(void *ringctxp)
 		ring_msg_t *msgp;
 		int rval;
 
-		msgp = ring_slave_get(ringp);
+		msgp = ring_worker_get(ringp);
 		msgp->rm_rval = 0;
 
 		switch(msgp->rm_op) {
@@ -486,7 +486,7 @@ ring_slave_entry(void *ringctxp)
 			msgp->rm_stat = RING_STAT_IGNORE;
 			break;
 		}
-		ring_slave_put(ringp, msgp);
+		ring_worker_put(ringp, msgp);
 	}
 
 	return 0;
diff --git a/common/ring.h b/common/ring.h
index 6535af8d..b90efd4b 100644
--- a/common/ring.h
+++ b/common/ring.h
@@ -21,16 +21,16 @@
 /* ring - readahead/writeahead abstraction
  *
  * the ring is conceptually an ordered set of messages circulating between the
- * client thread and the I/O slave thread. a message can be in one of four
+ * client thread and the I/O worker thread. a message can be in one of four
  * places: on the ready queue, held by the client, on the active queue, or held
- * by the slave. The client and slave can each hold at most one message at a
+ * by the worker. The client and worker can each hold at most one message at a
  * time. all others must be on one of the two queues. the messages must
- * circulate in that order: ready, client, active, slave, ready, ...
+ * circulate in that order: ready, client, active, worker, ready, ...
  * initially all messages are on the ready queue, with status set to
  * INIT. The client uses ring_get to remove a message from the ready queue.
  * the client can then use the message to read or write. to read, the client
  * sets the op field to READ, and places the message on the active queue. the
- * slave will remove messages from the active queue, invoke the client-supplied
+ * worker will remove messages from the active queue, invoke the client-supplied
  * read function with the message's buffer, record the read function's return
  * value in the message, set the message status to OK (read function returned 0)
  * or ERROR (read returned non-zero), and place the message on the ready queue.
@@ -39,28 +39,28 @@
  * except the client fills the buffer and sets the op to WRITE prior to placing
  * the message on the active queue.
  *
- * if the client-supplied read or write function returns an error, the slave
- * will set the message status to ERROR. the slave will pass all subsequent
+ * if the client-supplied read or write function returns an error, the worker
+ * will set the message status to ERROR. the worker will pass all subsequent
  * messages appearing on the active queue directly to the ready queue with
- * no I/O done and the message status set to IGNORE. the slave will remain
+ * no I/O done and the message status set to IGNORE. the worker will remain
  * in this state until a reset is performed (see below).
  *
- * The client may at anytime place a NOP msg on the ring. the slave does
+ * The client may at anytime place a NOP msg on the ring. the worker does
  * nothing with this mmessage other than to place it back on the ready queue
  * with NOPACK status. This is useful for inhibiting read-ahead.
  *
  * To flush the ring, the client must repetatively place TRACE messages on the
- * active queue until it sees an IGNORE msg on the ready queue. the slave will
+ * active queue until it sees an IGNORE msg on the ready queue. the worker will
  * simply transfer TRACErs from active to ready with no other action taken
  * (other than to set the message status to IGNORE).
  *
  * the client may at any time reset the ring. the reset will return to the
- * client when the current I/O being executed by the slave completes, and
+ * client when the current I/O being executed by the worker completes, and
  * all messages have been wiped clean and placed on the ready queue with
  * status set to INIT. the ring_reset function accomplishes this internally by
  * placing a RESET message on the active QUEUE, and continuing to remove
  * messages from the ready queue (without placing them on the active queue)
- * until the RESET message is seen the slave responds to a reset message by
+ * until the RESET message is seen the worker responds to a reset message by
  * setting the status to RESETACK, queueing the message on the ready queue, and
  * waiting for a message from the active queue. ring_reset will then re-
  * initialize the ring and return. note that the client may be holding one
@@ -68,7 +68,7 @@
  * that message into the reset call. otherwise it must pass in NULL.
  *
  * the ring_destroy function may be invoked to shut down the ring and kill the
- * slave thread. it simply places a DIE message on the active queue, and waits
+ * worker thread. it simply places a DIE message on the active queue, and waits
  * for a DIEACK response. it then de-allocates all semaphores memory allocated
  * by ring_create.
  *
@@ -76,7 +76,7 @@
  * of the client. it is not perturbed during any ring operations.
  *
  * the ring maintains four performance metering values: the number of times
- * the slave and client attempted to get a message, and the number of times
+ * the worker and client attempted to get a message, and the number of times
  * those attempts resulting in blocking.
  */
 
@@ -128,9 +128,9 @@ typedef struct ring_msg ring_msg_t;
  */
 struct ring {
 	off64_t r_client_msgcnt;
-	off64_t r_slave_msgcnt;
+	off64_t r_worker_msgcnt;
 	off64_t r_client_blkcnt;
-	off64_t r_slave_blkcnt;
+	off64_t r_worker_blkcnt;
 	time32_t r_first_io_time;
 	off64_t r_all_io_cnt;
 /* ALL BELOW PRIVATE!!! */
@@ -143,7 +143,7 @@ struct ring {
 	size_t r_active_out_ix;
 	qsemh_t r_active_qsemh;
 	size_t r_client_cnt;
-	size_t r_slave_cnt;
+	size_t r_worker_cnt;
 	int (*r_readfunc)(void *contextp, char *bufp);
 	int (*r_writefunc)(void *contextp, char *bufp);
 	void *r_clientctxp;
diff --git a/common/stream.c b/common/stream.c
index 4f565173..3c2b1722 100644
--- a/common/stream.c
+++ b/common/stream.c
@@ -54,7 +54,7 @@ stream_init(void)
  * Note that the stream list structure (updated via the stream_* functions)
  * is indexed by pthread_t (tid). Multiple processes can be registered against
  * the same stream index, typically: the primary content process that does the
- * work; and the drive slave process, which just processes stuff off the ring
+ * work; and the drive worker process, which just processes stuff off the ring
  * buffer. In general having multiple tids registered per stream is not an issue
  * for termination status reporting, as the mlog_exit* logging functions only
  * ever get called out of the primary content process.
diff --git a/common/ts_mtio.h b/common/ts_mtio.h
index 9b31d25c..76f3f914 100644
--- a/common/ts_mtio.h
+++ b/common/ts_mtio.h
@@ -611,7 +611,7 @@ struct mt_capablity  {
 #define MTCANT_IMM	0x80000 /* drive doesn't work correctly when
 	immediate mode rewind, etc. is enabled.  Setting this bit
 	will disable immediate mode rewind on the drive, independent
-	of the setting of tpsc_immediate_rewind (in master.d/tpsc) */
+	of the setting of tpsc_immediate_rewind (in the tpsc sysgen file) */
 #define MTCAN_COMPRESS	0x100000 /* drive supports compression */
 #define MTCAN_BUFFM	0x200000 /* drive supports writing of
 				  * buffered filemarks */