From owner-svn-src-all@freebsd.org Sat Jun 20 20:14:51 2020 Return-Path: Delivered-To: svn-src-all@mailman.nyi.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2610:1c1:1:606c::19:1]) by mailman.nyi.freebsd.org (Postfix) with ESMTP id 3616E33398C; Sat, 20 Jun 2020 20:14:51 +0000 (UTC) (envelope-from cem@FreeBSD.org) Received: from mxrelay.nyi.freebsd.org (mxrelay.nyi.freebsd.org [IPv6:2610:1c1:1:606c::19:3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256 client-signature RSA-PSS (4096 bits) client-digest SHA256) (Client CN "mxrelay.nyi.freebsd.org", Issuer "Let's Encrypt Authority X3" (verified OK)) by mx1.freebsd.org (Postfix) with ESMTPS id 49q6NC16BSz3WDx; Sat, 20 Jun 2020 20:14:51 +0000 (UTC) (envelope-from cem@FreeBSD.org) Received: from repo.freebsd.org (repo.freebsd.org [IPv6:2610:1c1:1:6068::e6a:0]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (Client did not present a certificate) by mxrelay.nyi.freebsd.org (Postfix) with ESMTPS id 2126F11EC9; Sat, 20 Jun 2020 20:14:51 +0000 (UTC) (envelope-from cem@FreeBSD.org) Received: from repo.freebsd.org ([127.0.1.37]) by repo.freebsd.org (8.15.2/8.15.2) with ESMTP id 05KKEpJ2022508; Sat, 20 Jun 2020 20:14:51 GMT (envelope-from cem@FreeBSD.org) Received: (from cem@localhost) by repo.freebsd.org (8.15.2/8.15.2/Submit) id 05KKEpoE022507; Sat, 20 Jun 2020 20:14:51 GMT (envelope-from cem@FreeBSD.org) Message-Id: <202006202014.05KKEpoE022507@repo.freebsd.org> X-Authentication-Warning: repo.freebsd.org: cem set sender to cem@FreeBSD.org using -f From: Conrad Meyer Date: Sat, 20 Jun 2020 20:14:51 +0000 (UTC) To: src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-head@freebsd.org Subject: svn commit: r362447 - head/sbin/dump X-SVN-Group: head X-SVN-Commit-Author: cem X-SVN-Commit-Paths: head/sbin/dump X-SVN-Commit-Revision: 362447 X-SVN-Commit-Repository: base MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: svn-src-all@freebsd.org X-Mailman-Version: 2.1.33 Precedence: list List-Id: "SVN commit messages for the entire src tree \(except for " user" and " projects" \)" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sat, 20 Jun 2020 20:14:51 -0000 Author: cem Date: Sat Jun 20 20:14:50 2020 New Revision: 362447 URL: https://svnweb.freebsd.org/changeset/base/362447 Log: dump(8): Reapply slightly modified r362422 Go ahead and replace the distasteful slave language for worker processes with the straightforward description, "worker(s)." Modified: head/sbin/dump/tape.c Modified: head/sbin/dump/tape.c ============================================================================== --- head/sbin/dump/tape.c Sat Jun 20 20:10:42 2020 (r362446) +++ head/sbin/dump/tape.c Sat Jun 20 20:14:50 2020 (r362447) @@ -75,19 +75,19 @@ static char *nexttape; static FILE *popenfp = NULL; static int atomic(ssize_t (*)(), int, char *, int); -static void doslave(int, int); -static void enslave(void); +static void worker(int, int); +static void enworker(void); static void flushtape(void); static void killall(void); static void rollforward(void); /* * Concurrent dump mods (Caltech) - disk block reading and tape writing - * are exported to several slave processes. While one slave writes the + * are exported to several worker processes. While one worker writes the * tape, the others read disk blocks; they pass control of the tape in * a ring via signals. The parent process traverses the file system and - * sends writeheader()'s and lists of daddr's to the slaves via pipes. - * The following structure defines the instruction packets sent to slaves. + * sends writeheader()'s and lists of daddr's to the workers via pipes. + * The following structure defines the instruction packets sent to workers. */ struct req { ufs2_daddr_t dblk; @@ -95,20 +95,20 @@ struct req { }; static int reqsiz; -#define SLAVES 3 /* 1 slave writing, 1 reading, 1 for slack */ -static struct slave { +#define WORKERS 3 /* 1 worker writing, 1 reading, 1 for slack */ +static struct worker { int64_t tapea; /* header number at start of this chunk */ int64_t firstrec; /* record number of this block */ int count; /* count to next header (used for TS_TAPE */ /* after EOT) */ int inode; /* inode that we are currently dealing with */ - int fd; /* FD for this slave */ - int pid; /* PID for this slave */ - int sent; /* 1 == we've sent this slave requests */ + int fd; /* FD for this worker */ + int pid; /* PID for this worker */ + int sent; /* 1 == we've sent this worker requests */ char (*tblock)[TP_BSIZE]; /* buffer for data blocks */ struct req *req; /* buffer for requests */ -} slaves[SLAVES+1]; -static struct slave *slp; +} workers[WORKERS+1]; +static struct worker *mlp; static char (*nextblock)[TP_BSIZE]; @@ -116,9 +116,9 @@ static int master; /* pid of master, for sending error static int tenths; /* length of tape used per block written */ static volatile sig_atomic_t caught; /* have we caught the signal to proceed? */ static volatile sig_atomic_t ready; /* reached the lock point without having */ - /* received the SIGUSR2 signal from the prev slave? */ + /* received the SIGUSR2 signal from the prev worker? */ static jmp_buf jmpbuf; /* where to jump to if we are ready when the */ - /* SIGUSR2 arrives from the previous slave */ + /* SIGUSR2 arrives from the previous worker */ int alloctape(void) @@ -143,20 +143,20 @@ alloctape(void) * packets, so flushtape() can write them together with one write(). * Align tape buffer on page boundary to speed up tape write(). */ - for (i = 0; i <= SLAVES; i++) { + for (i = 0; i <= WORKERS; i++) { buf = (char *) malloc((unsigned)(reqsiz + writesize + pgoff + TP_BSIZE)); if (buf == NULL) return(0); - slaves[i].tblock = (char (*)[TP_BSIZE]) + workers[i].tblock = (char (*)[TP_BSIZE]) (((long)&buf[ntrec + 1] + pgoff) &~ pgoff); - slaves[i].req = (struct req *)slaves[i].tblock - ntrec - 1; + workers[i].req = (struct req *)workers[i].tblock - ntrec - 1; } - slp = &slaves[0]; - slp->count = 1; - slp->tapea = 0; - slp->firstrec = 0; - nextblock = slp->tblock; + mlp = &workers[0]; + mlp->count = 1; + mlp->tapea = 0; + mlp->firstrec = 0; + nextblock = mlp->tblock; return(1); } @@ -164,8 +164,8 @@ void writerec(char *dp, int isspcl) { - slp->req[trecno].dblk = (ufs2_daddr_t)0; - slp->req[trecno].count = 1; + mlp->req[trecno].dblk = (ufs2_daddr_t)0; + mlp->req[trecno].count = 1; /* Can't do a structure assignment due to alignment problems */ bcopy(dp, *(nextblock)++, sizeof (union u_spcl)); if (isspcl) @@ -185,8 +185,8 @@ dumpblock(ufs2_daddr_t blkno, int size) dblkno = fsbtodb(sblock, blkno); tpblks = size >> tp_bshift; while ((avail = MIN(tpblks, ntrec - trecno)) > 0) { - slp->req[trecno].dblk = dblkno; - slp->req[trecno].count = avail; + mlp->req[trecno].dblk = dblkno; + mlp->req[trecno].count = avail; trecno += avail; spcl.c_tapea += avail; if (trecno >= ntrec) @@ -232,27 +232,27 @@ flushtape(void) int i, blks, got; int64_t lastfirstrec; - int siz = (char *)nextblock - (char *)slp->req; + int siz = (char *)nextblock - (char *)mlp->req; - slp->req[trecno].count = 0; /* Sentinel */ + mlp->req[trecno].count = 0; /* Sentinel */ - if (atomic(write, slp->fd, (char *)slp->req, siz) != siz) + if (atomic(write, mlp->fd, (char *)mlp->req, siz) != siz) quit("error writing command pipe: %s\n", strerror(errno)); - slp->sent = 1; /* we sent a request, read the response later */ + mlp->sent = 1; /* we sent a request, read the response later */ - lastfirstrec = slp->firstrec; + lastfirstrec = mlp->firstrec; - if (++slp >= &slaves[SLAVES]) - slp = &slaves[0]; + if (++mlp >= &workers[WORKERS]) + mlp = &workers[0]; - /* Read results back from next slave */ - if (slp->sent) { - if (atomic(read, slp->fd, (char *)&got, sizeof got) + /* Read results back from next worker */ + if (mlp->sent) { + if (atomic(read, mlp->fd, (char *)&got, sizeof got) != sizeof got) { perror(" DUMP: error reading command pipe in master"); dumpabort(0); } - slp->sent = 0; + mlp->sent = 0; /* Check for end of tape */ if (got < writesize) { @@ -262,15 +262,15 @@ flushtape(void) * Drain the results, don't care what the values were. * If we read them here then trewind won't... */ - for (i = 0; i < SLAVES; i++) { - if (slaves[i].sent) { - if (atomic(read, slaves[i].fd, + for (i = 0; i < WORKERS; i++) { + if (workers[i].sent) { + if (atomic(read, workers[i].fd, (char *)&got, sizeof got) != sizeof got) { perror(" DUMP: error reading command pipe in master"); dumpabort(0); } - slaves[i].sent = 0; + workers[i].sent = 0; } } @@ -288,11 +288,11 @@ flushtape(void) if (spcl.c_addr[i] != 0) blks++; } - slp->count = lastspclrec + blks + 1 - spcl.c_tapea; - slp->tapea = spcl.c_tapea; - slp->firstrec = lastfirstrec + ntrec; - slp->inode = curino; - nextblock = slp->tblock; + mlp->count = lastspclrec + blks + 1 - spcl.c_tapea; + mlp->tapea = spcl.c_tapea; + mlp->firstrec = lastfirstrec + ntrec; + mlp->inode = curino; + nextblock = mlp->tblock; trecno = 0; asize += tenths; blockswritten += ntrec; @@ -312,7 +312,7 @@ trewind(void) int f; int got; - for (f = 0; f < SLAVES; f++) { + for (f = 0; f < WORKERS; f++) { /* * Drain the results, but unlike EOT we DO (or should) care * what the return values were, since if we detect EOT after @@ -321,22 +321,22 @@ trewind(void) * * fixme: punt for now. */ - if (slaves[f].sent) { - if (atomic(read, slaves[f].fd, (char *)&got, sizeof got) + if (workers[f].sent) { + if (atomic(read, workers[f].fd, (char *)&got, sizeof got) != sizeof got) { perror(" DUMP: error reading command pipe in master"); dumpabort(0); } - slaves[f].sent = 0; + workers[f].sent = 0; if (got != writesize) { msg("EOT detected in last 2 tape records!\n"); msg("Use a longer tape, decrease the size estimate\n"); quit("or use no size estimate at all.\n"); } } - (void) close(slaves[f].fd); + (void) close(workers[f].fd); } - while (wait((int *)NULL) >= 0) /* wait for any signals from slaves */ + while (wait((int *)NULL) >= 0) /* wait for any signals from workers */ /* void */; if (pipeout) @@ -396,29 +396,29 @@ void rollforward(void) { struct req *p, *q, *prev; - struct slave *tslp; + struct worker *tmlp; int i, size, got; int64_t savedtapea; union u_spcl *ntb, *otb; - tslp = &slaves[SLAVES]; - ntb = (union u_spcl *)tslp->tblock[1]; + tmlp = &workers[WORKERS]; + ntb = (union u_spcl *)tmlp->tblock[1]; /* - * Each of the N slaves should have requests that need to - * be replayed on the next tape. Use the extra slave buffers - * (slaves[SLAVES]) to construct request lists to be sent to - * each slave in turn. + * Each of the N workers should have requests that need to + * be replayed on the next tape. Use the extra worker buffers + * (workers[WORKERS]) to construct request lists to be sent to + * each worker in turn. */ - for (i = 0; i < SLAVES; i++) { - q = &tslp->req[1]; - otb = (union u_spcl *)slp->tblock; + for (i = 0; i < WORKERS; i++) { + q = &tmlp->req[1]; + otb = (union u_spcl *)mlp->tblock; /* - * For each request in the current slave, copy it to tslp. + * For each request in the current worker, copy it to tmlp. */ prev = NULL; - for (p = slp->req; p->count > 0; p += p->count) { + for (p = mlp->req; p->count > 0; p += p->count) { *q = *p; if (p->dblk == 0) *ntb++ = *otb++; /* copy the datablock also */ @@ -433,26 +433,26 @@ rollforward(void) ntb--; q -= 1; q->count = 0; - q = &tslp->req[0]; + q = &tmlp->req[0]; if (i == 0) { q->dblk = 0; q->count = 1; trecno = 0; - nextblock = tslp->tblock; + nextblock = tmlp->tblock; savedtapea = spcl.c_tapea; - spcl.c_tapea = slp->tapea; + spcl.c_tapea = mlp->tapea; startnewtape(0); spcl.c_tapea = savedtapea; lastspclrec = savedtapea - 1; } size = (char *)ntb - (char *)q; - if (atomic(write, slp->fd, (char *)q, size) != size) { + if (atomic(write, mlp->fd, (char *)q, size) != size) { perror(" DUMP: error writing command pipe"); dumpabort(0); } - slp->sent = 1; - if (++slp >= &slaves[SLAVES]) - slp = &slaves[0]; + mlp->sent = 1; + if (++mlp >= &workers[WORKERS]) + mlp = &workers[0]; q->count = 1; @@ -464,34 +464,34 @@ rollforward(void) */ q->dblk = prev->dblk + prev->count * (TP_BSIZE / DEV_BSIZE); - ntb = (union u_spcl *)tslp->tblock; + ntb = (union u_spcl *)tmlp->tblock; } else { /* * It wasn't a disk block. Copy the data to its * new location in the buffer. */ q->dblk = 0; - *((union u_spcl *)tslp->tblock) = *ntb; - ntb = (union u_spcl *)tslp->tblock[1]; + *((union u_spcl *)tmlp->tblock) = *ntb; + ntb = (union u_spcl *)tmlp->tblock[1]; } } - slp->req[0] = *q; - nextblock = slp->tblock; + mlp->req[0] = *q; + nextblock = mlp->tblock; if (q->dblk == 0) nextblock++; trecno = 1; /* - * Clear the first slaves' response. One hopes that it + * Clear the first workers' response. One hopes that it * worked ok, otherwise the tape is much too short! */ - if (slp->sent) { - if (atomic(read, slp->fd, (char *)&got, sizeof got) + if (mlp->sent) { + if (atomic(read, mlp->fd, (char *)&got, sizeof got) != sizeof got) { perror(" DUMP: error reading command pipe in master"); dumpabort(0); } - slp->sent = 0; + mlp->sent = 0; if (got != writesize) { quit("EOT detected at start of the tape!\n"); @@ -634,7 +634,7 @@ restore_check_point: } } - enslave(); /* Share open tape file descriptor with slaves */ + enworker(); /* Share open tape file descriptor with workers */ if (popenout) close(tapefd); /* Give up our copy of it. */ signal(SIGINFO, infosch); @@ -643,18 +643,18 @@ restore_check_point: blocksthisvol = 0; if (top) newtape++; /* new tape signal */ - spcl.c_count = slp->count; + spcl.c_count = mlp->count; /* * measure firstrec in TP_BSIZE units since restore doesn't * know the correct ntrec value... */ - spcl.c_firstrec = slp->firstrec; + spcl.c_firstrec = mlp->firstrec; spcl.c_volume++; spcl.c_type = TS_TAPE; - writeheader((ino_t)slp->inode); + writeheader((ino_t)mlp->inode); if (tapeno > 1) msg("Volume %d begins with blocks from inode %d\n", - tapeno, slp->inode); + tapeno, mlp->inode); } } @@ -687,7 +687,7 @@ Exit(status) } /* - * proceed - handler for SIGUSR2, used to synchronize IO between the slaves. + * proceed - handler for SIGUSR2, used to synchronize IO between the workers. */ void proceed(int signo __unused) @@ -699,45 +699,45 @@ proceed(int signo __unused) } void -enslave(void) +enworker(void) { int cmd[2]; int i, j; master = getpid(); - signal(SIGTERM, dumpabort); /* Slave sends SIGTERM on dumpabort() */ + signal(SIGTERM, dumpabort); /* Worker sends SIGTERM on dumpabort() */ signal(SIGPIPE, sigpipe); - signal(SIGUSR1, tperror); /* Slave sends SIGUSR1 on tape errors */ - signal(SIGUSR2, proceed); /* Slave sends SIGUSR2 to next slave */ + signal(SIGUSR1, tperror); /* Worker sends SIGUSR1 on tape errors */ + signal(SIGUSR2, proceed); /* Worker sends SIGUSR2 to next worker */ - for (i = 0; i < SLAVES; i++) { - if (i == slp - &slaves[0]) { + for (i = 0; i < WORKERS; i++) { + if (i == mlp - &workers[0]) { caught = 1; } else { caught = 0; } if (socketpair(AF_UNIX, SOCK_STREAM, 0, cmd) < 0 || - (slaves[i].pid = fork()) < 0) - quit("too many slaves, %d (recompile smaller): %s\n", + (workers[i].pid = fork()) < 0) + quit("too many workers, %d (recompile smaller): %s\n", i, strerror(errno)); - slaves[i].fd = cmd[1]; - slaves[i].sent = 0; - if (slaves[i].pid == 0) { /* Slave starts up here */ + workers[i].fd = cmd[1]; + workers[i].sent = 0; + if (workers[i].pid == 0) { /* Worker starts up here */ for (j = 0; j <= i; j++) - (void) close(slaves[j].fd); + (void) close(workers[j].fd); signal(SIGINT, SIG_IGN); /* Master handles this */ - doslave(cmd[0], i); + worker(cmd[0], i); Exit(X_FINOK); } } - for (i = 0; i < SLAVES; i++) - (void) atomic(write, slaves[i].fd, - (char *) &slaves[(i + 1) % SLAVES].pid, - sizeof slaves[0].pid); + for (i = 0; i < WORKERS; i++) + (void) atomic(write, workers[i].fd, + (char *) &workers[(i + 1) % WORKERS].pid, + sizeof workers[0].pid); master = 0; } @@ -747,10 +747,10 @@ killall(void) { int i; - for (i = 0; i < SLAVES; i++) - if (slaves[i].pid > 0) { - (void) kill(slaves[i].pid, SIGKILL); - slaves[i].sent = 0; + for (i = 0; i < WORKERS; i++) + if (workers[i].pid > 0) { + (void) kill(workers[i].pid, SIGKILL); + workers[i].sent = 0; } } @@ -762,42 +762,42 @@ killall(void) * get the lock back for the next cycle by swapping descriptors. */ static void -doslave(int cmd, int slave_number) +worker(int cmd, int worker_number) { int nread; - int nextslave, size, wrote, eot_count; + int nextworker, size, wrote, eot_count; /* * Need our own seek pointer. */ (void) close(diskfd); if ((diskfd = open(disk, O_RDONLY)) < 0) - quit("slave couldn't reopen disk: %s\n", strerror(errno)); + quit("worker couldn't reopen disk: %s\n", strerror(errno)); /* - * Need the pid of the next slave in the loop... + * Need the pid of the next worker in the loop... */ - if ((nread = atomic(read, cmd, (char *)&nextslave, sizeof nextslave)) - != sizeof nextslave) { - quit("master/slave protocol botched - didn't get pid of next slave.\n"); + if ((nread = atomic(read, cmd, (char *)&nextworker, sizeof nextworker)) + != sizeof nextworker) { + quit("master/worker protocol botched - didn't get pid of next worker.\n"); } /* * Get list of blocks to dump, read the blocks into tape buffer */ - while ((nread = atomic(read, cmd, (char *)slp->req, reqsiz)) == reqsiz) { - struct req *p = slp->req; + while ((nread = atomic(read, cmd, (char *)mlp->req, reqsiz)) == reqsiz) { + struct req *p = mlp->req; for (trecno = 0; trecno < ntrec; trecno += p->count, p += p->count) { if (p->dblk) { - blkread(p->dblk, slp->tblock[trecno], + blkread(p->dblk, mlp->tblock[trecno], p->count * TP_BSIZE); } else { if (p->count != 1 || atomic(read, cmd, - (char *)slp->tblock[trecno], + (char *)mlp->tblock[trecno], TP_BSIZE) != TP_BSIZE) - quit("master/slave protocol botched.\n"); + quit("master/worker protocol botched.\n"); } } if (setjmp(jmpbuf) == 0) { @@ -816,14 +816,14 @@ doslave(int cmd, int slave_number) while (eot_count < 10 && size < writesize) { #ifdef RDUMP if (host) - wrote = rmtwrite(slp->tblock[0]+size, + wrote = rmtwrite(mlp->tblock[0]+size, writesize-size); else #endif - wrote = write(tapefd, slp->tblock[0]+size, + wrote = write(tapefd, mlp->tblock[0]+size, writesize-size); #ifdef WRITEDEBUG - printf("slave %d wrote %d\n", slave_number, wrote); + printf("worker %d wrote %d\n", worker_number, wrote); #endif if (wrote < 0) break; @@ -834,8 +834,8 @@ doslave(int cmd, int slave_number) #ifdef WRITEDEBUG if (size != writesize) - printf("slave %d only wrote %d out of %d bytes and gave up.\n", - slave_number, size, writesize); + printf("worker %d only wrote %d out of %d bytes and gave up.\n", + worker_number, size, writesize); #endif /* @@ -862,10 +862,10 @@ doslave(int cmd, int slave_number) } /* - * If partial write, don't want next slave to go. + * If partial write, don't want next worker to go. * Also jolts him awake. */ - (void) kill(nextslave, SIGUSR2); + (void) kill(nextworker, SIGUSR2); } if (nread != 0) quit("error reading command pipe: %s\n", strerror(errno));