projects / unix-history / blob
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
fixes from ghg
[unix-history] / usr / src / sys / vax / stand / format.c
/* format.c 6.2 83/09/18 */
/*
* Standalone program to do media checking
* and record bad block information on any
* disk with the appropriate driver and RM03-style headers.
*/
#include "../h/param.h"
#include "../h/fs.h"
#include "../h/inode.h"
#include "../h/dkbad.h"
#include "../h/vmmac.h"
#include "saio.h"
#include "savax.h"
#define MAXBADDESC 126 /* size of bad block table */
#define CHUNK 48 /* max # of sectors/io operation */
#define SECTSIZ 512 /* standard sector size */
#define HDRSIZ 4 /* number of bytes in sector header */
#define SSERR 0
#define BSERR 1
#define SSDEV ((ioctl(iob[fd-3], SAIOSSDEV, (char *)0) == 0))
struct sector {
u_short header1;
u_short header2;
char buf[SECTSIZ];
};
struct dkbad dkbad; /* bad sector table */
struct dkbad sstab; /* skip sector table */
#define NERRORS 6
static char *
errornames[NERRORS] = {
#define FE_BSE 0
"Bad sector",
#define FE_WCE 1
"Write check",
#define FE_ECC 2
"ECC",
#define FE_HARD 3
"Other hard",
#define FE_TOTAL 4
"Total",
#define FE_SSE 5
"Skip sector",
};
int errors[NERRORS]; /* histogram of errors */
int pattern;
char *malloc();
char *prompt();
extern int end;
main()
{
register int sector, sn;
int lastsector, tracksize;
int unit, fd, resid, i, trk, cyl, debug;
struct st st;
struct sector *bp, *cbp;
char *cp;
printf("Disk format/check utility\n\n");
again:
cp = prompt("Enable debugging (1=bse, 2=ecc, 3=bse+ecc)? ");
debug = atoi(cp);
if (debug < 0)
debug = 0;
for (i = 0; i < NERRORS; i++)
errors[i] = 0;
fd = getdevice();
ioctl(fd, SAIODEVDATA, &st);
printf("Device data: #cylinders=%d, #tracks=%d, #sectors=%d\n",
st.ncyl, st.ntrak, st.nsect);
if (getpattern())
goto again;
printf("Start formatting...make sure the drive is online\n");
ioctl(fd, SAIONOBAD, (char *)0);
ioctl(fd, SAIOECCLIM, (char *)0);
ioctl(fd, SAIODEBUG, (char *)debug);
if (SSDEV) {
ioctl(fd, SAIOSSI, (char *)0); /* set skip sector inhibit */
st.nsect++;
st.nspc += st.ntrak;
}
tracksize = sizeof (struct sector) * st.nsect;
bp = (struct sector *)malloc(tracksize);
bufinit(bp, tracksize);
/*
* Begin check, for each track,
*
* 1) Write header and test pattern.
* 2) Write check header and data.
*/
lastsector = st.nspc * st.ncyl;
for (sector = 0; sector < lastsector; sector += st.nsect) {
cyl = sector / st.nspc;
trk = (sector % st.nspc) / st.nsect;
for (i = 0; i < st.nsect; i++) {
bp[i].header1 =
(u_short) cyl | HDR1_FMT22 | HDR1_OKSCT;
bp[i].header2 = ((u_short)trk << 8) + i;
}
if (sector && (sector % (st.nspc * 10)) == 0)
printf("cylinder %d\n", cyl);
/*
* Try and write the headers and data patterns into
* each sector in the track. Continue until such
* we're done, or until there's less than a sector's
* worth of data to transfer.
*
* The lseek call is necessary because of
* the odd sector size (516 bytes)
*/
for (resid = tracksize, cbp = bp, sn = sector;;) {
int cc;
lseek(fd, sn * SECTSIZ, 0);
ioctl(fd, SAIOHDR, (char *)0);
cc = write(fd, cbp, resid);
if (cc == resid)
break;
/*
* Don't record errors during write,
* all errors will be found during
* writecheck performed below.
*/
sn = iob[fd - 3].i_errblk;
cbp += sn - sector;
resid -= (sn - sector) * sizeof (struct sector);
if (resid < sizeof (struct sector))
break;
}
/*
* Write check headers and test patterns.
* Retry remainder of track on error until
* we're done, or until there's less than a
* sector to verify.
*/
for (resid = tracksize, cbp = bp, sn = sector;;) {
int cc;
lseek(fd, sn * SECTSIZ, 0);
ioctl(fd, SAIOHCHECK, (char *)0);
cc = read(fd, cbp, resid);
if (cc == resid)
break;
sn = iob[fd-3].i_errblk;
printf("sector %d, write check error\n", sn);
recorderror(fd, sn, &st);
/* advance past bad sector */
sn++;
cbp += sn - sector;
resid -= (sn - sector) * sizeof (struct sector);
if (resid < sizeof (struct sector))
break;
}
}
/*
* Checking finished.
*/
if (errors[FE_TOTAL] || errors[FE_SSE]) {
printf("Errors:\n");
for (i = 0; i < NERRORS; i++)
printf("%s: %d\n", errornames[i], errors[i]);
printf("Total of %d hard errors found\n",
errors[FE_TOTAL] + errors[FE_SSE]);
/* change the headers of all the bad sectors */
writebb(fd, errors[FE_SSE], &sstab, &st, SSERR);
writebb(fd, errors[FE_TOTAL], &dkbad, &st, BSERR);
}
while (errors[FE_TOTAL] < MAXBADDESC) {
int i = errors[FE_TOTAL]++;
dkbad.bt_bad[i].bt_cyl = -1;
dkbad.bt_bad[i].bt_trksec = -1;
}
printf("\nWriting bad sector table at sector #%d\n",
st.ncyl * st.nspc - st.nsect);
/* place on disk */
for (i = 0; i < 10; i += 2) {
lseek(fd, SECTSIZ * (st.ncyl * st.nspc - st.nsect + i), 0);
write(fd, &dkbad, sizeof (dkbad));
}
printf("Done\n");
ioctl(fd,SAIONOSSI,(char *)0);
close(fd);
#ifndef JUSTEXIT
goto again;
#endif
}
/*
* Write out the bad blocks.
*/
writebb(fd, nsects, dbad, st, sw)
int nsects, fd;
struct dkbad *dbad;
register struct st *st;
{
struct sector bb_buf; /* buffer for one sector plus 4 byte header */
register int i;
int bn, j;
struct bt_bad *btp;
for (i = 0; i < nsects; i++) {
btp = &dbad->bt_bad[i];
if (sw == BSERR) {
bb_buf.header1 = HDR1_FMT22|btp->bt_cyl;
if (SSDEV)
bb_buf.header1 |= HDR1_SSF;
} else
bb_buf.header1 =
btp->bt_cyl | HDR1_FMT22 | HDR1_SSF | HDR1_OKSCT;
bb_buf.header2 = btp->bt_trksec;
bn = st->nspc * btp->bt_cyl +
st->nsect * (btp->bt_trksec >> 8) +
(btp->bt_trksec & 0xff);
lseek(fd, bn * SECTSIZ, 0);
ioctl(fd, SAIOHDR, (char *)0);
write(fd, &bb_buf, sizeof (bb_buf));
if (!SSDEV)
continue;
/*
* If skip sector, mark all remaining
* sectors on the track.
*/
for (j = (btp->bt_trksec & 0xff) + 1; j < st->nsect; j++) {
bb_buf.header1 = j | HDR1_FMT22 | HDR1_SSF;
ioctl(fd, SAIOHDR, (char *)0);
write(fd, &bb_buf, sizeof (bb_buf));
}
}
}
/*
* Record an error, and if there's room, put
* it in the appropriate bad sector table.
*/
recorderror(fd, bn, st)
int fd, bn;
register struct st *st;
{
int cn, tn, sn, strk;
if (errors[FE_TOTAL] >= MAXBADDESC) {
printf("Too many bad sectors\n");
return;
}
if (errors[FE_SSE] >= MAXBADDESC) {
printf("Too many skip sector errors\n");
return;
}
if (errno < EBSE || errno > EHER)
return;
errno -= EBSE;
errors[errno]++;
cn = bn / st->nspc;
sn = bn % st->nspc;
tn = sn / st->nsect;
sn %= st->nsect;
if (SSDEV) { /* if drive has skip sector capability */
int ss = errors[FE_SSE]++;
if (ss)
strk = sstab.bt_bad[ss - 1].bt_trksec >> 8;
else
strk = -1;
if (tn != strk) { /* only one skip sector/track */
sstab.bt_bad[ss].bt_cyl = cn;
sstab.bt_bad[ss].bt_trksec = (tn<<8) + sn;
return;
}
cn = -cn;
}
/* record the bad sector address and continue */
dkbad.bt_bad[errors[FE_TOTAL]].bt_cyl = cn;
dkbad.bt_bad[errors[FE_TOTAL]++].bt_trksec = (tn << 8) + sn;
}
/*
* Allocate memory on a page-aligned address.
* Round allocated chunk to a page multiple to
* ease next request.
*/
char *
malloc(size)
int size;
{
char *result;
static caddr_t last = 0;
if (last == 0)
last = (caddr_t)(((int)&end + 511) & ~0x1ff);
size = (size + 511) & ~0x1ff;
result = (char *)last;
last += size;
return (result);
}
/*
* Prompt and verify a device name from the user.
*/
getdevice()
{
register char *cp;
register struct devsw *dp;
int fd;
top:
cp = prompt("Device to format? ");
if ((fd = open(cp, 2)) < 0) {
printf("Known devices are: ");
for (dp = devsw; dp->dv_name; dp++)
printf("%s ",dp->dv_name);
printf("\n");
goto top;
}
printf("Formatting drive %d on %c%c%d ",
iob[fd - 3].i_unit % 8, cp[0], cp[1], iob[fd - 3].i_unit / 8);
cp = prompt("verify (yes/no)? ");
while (*cp != 'y' && *cp != 'n')
cp = prompt("Huh, yes or no? ");
if (*cp == 'y')
return (fd);
goto top;
}
static struct pattern {
long pa_value;
char *pa_name;
} pat[] = {
{ 0xf00ff00f, "RH750 worst case" },
{ 0xec6dec6d, "media worst case" },
{ 0xa5a5a5a5, "alternate 1's and 0's" },
{ 0, 0 },
};
getpattern()
{
register struct pattern *p;
int npatterns;
char *cp;
printf("Available test patterns are:\n");
for (p = pat; p->pa_value; p++)
printf("\t%d - (%x) %s\n", (p - pat) + 1,
p->pa_value & 0xffff, p->pa_name);
npatterns = p - pat;
cp = prompt("Pattern (one of the above, other to restart)? ");
pattern = atoi(cp) - 1;
return (pattern < 0 || pattern >= npatterns);
}
struct xsect {
u_short hd1;
u_short hd2;
long buf[128];
};
/*
* Initialize the buffer with the requested pattern.
*/
bufinit(bp, size)
register struct xsect *bp;
int size;
{
register struct pattern *pptr;
register long *pp, *last;
register struct xsect *lastbuf;
size /= sizeof (struct sector);
lastbuf = bp + size;
pptr = &pat[pattern];
while (bp < lastbuf) {
last = &bp->buf[128];
for (pp = bp->buf; pp < last; pp++)
*pp = pptr->pa_value;
bp++;
}
}
char *
prompt(msg)
char *msg;
{
static char buf[132];
printf("%s", msg);
gets(buf);
return (buf);
}
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.