From df3858fdf4c7597a6e336e86129030d44e3d73de Mon Sep 17 00:00:00 2001 From: Keith Bostic Date: Sat, 5 Jun 1993 19:38:31 -0800 Subject: [PATCH] new version from Chris Torek SCCS-vsn: sbin/scsiformat/scsiformat.c 5.4 --- usr/src/sbin/scsiformat/scsiformat.c | 758 +++++++++++++++++---------- 1 file changed, 490 insertions(+), 268 deletions(-) diff --git a/usr/src/sbin/scsiformat/scsiformat.c b/usr/src/sbin/scsiformat/scsiformat.c index c887c38d0b..05c038bd48 100644 --- a/usr/src/sbin/scsiformat/scsiformat.c +++ b/usr/src/sbin/scsiformat/scsiformat.c @@ -8,76 +8,93 @@ * * %sccs.include.redist.c% * - * @(#)scsiformat.c 5.3 (Berkeley) %G% + * @(#)scsiformat.c 5.4 (Berkeley) %G% */ +#ifndef lint +char copyright[] = +"@(#) Copyright (c) 1993 The Regents of the University of California.\n\ + All rights reserved.\n"; +#endif /* not lint */ + +#ifndef lint +static char sccsid[] = "@(#)scsiformat.c 5.4 (Berkeley) %G%"; +#endif /* not lint */ + #include #include -#include -#include +#include +#include +#include +#include + +#define COMPAT_HPSCSI + #include -#include -#include +#include #include +#include #include - -struct scsi_inquiry inqbuf; -struct { - int blks; - int blksize; -} capbuf; -struct { - struct scsi_modesense_hdr h; - u_char p[126-12]; -} msbuf; -u_char mselbuf[24]; - -struct scsi_fmt_cdb cap = { - 10, - CMD_READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0, 0, 0 -}; -struct scsi_fmt_cdb format = { - 6, - CMD_FORMAT_UNIT, 0, 0, 0, 0, 0 -}; -struct scsi_fmt_cdb inq = { - 6, - CMD_INQUIRY, 0, 0, 0, sizeof(inqbuf), 0 -}; -struct scsi_fmt_cdb modeselect = { - 6, - CMD_MODE_SELECT, 0x11, 0, 0, sizeof(mselbuf), 0 -}; -struct scsi_fmt_cdb modesense = { - 6, - CMD_MODE_SENSE, 0, 0x3f, 0, sizeof(msbuf), 0 -}; +#include int fd; char *device; -void do_command __P((int, struct scsi_fmt_cdb *, u_char *, int)); +void scsi_str __P((char *, char *, int)); +void do_command __P((int, struct scsi_cdb *, void *, int)); void do_format __P((void)); void print_capacity __P((void)); void print_inquiry __P((void)); +void prflags __P((int, const char *)); u_char *print_mode_page __P((u_char *)); void print_mode_sense __P((void)); void usage __P((void)); +#define N2(c, d) (((c) << 8) | (d)) +#define N3(b, c, d) (((b) << 16) | N2(c, d)) +#define N4(a, b, c, d) (((a) << 24) | N3(b, c, d)) + +int sense_pctl; + int main(argc, argv) int argc; char *argv[]; { - int ch; + extern char *optarg; + int ch, readonly; - while ((ch = getopt(argc, argv, "")) != EOF) + readonly = 0; + sense_pctl = SCSI_MSENSE_PCTL_CUR; + while ((ch = getopt(argc, argv, "rp:")) != EOF) { switch(ch) { + case 'r': + readonly = 1; + break; + case 'p': /* mode sense page control */ + switch (*optarg) { + case 'c': + sense_pctl = SCSI_MSENSE_PCTL_CUR; + break; + case 'd': + sense_pctl = SCSI_MSENSE_PCTL_DFLT; + break; + case 's': + sense_pctl = SCSI_MSENSE_PCTL_SAVED; + break; + case 'v': + (void)printf( + "*** note: for variable parameters, 1-bit means ``can write here''\n"); + sense_pctl = SCSI_MSENSE_PCTL_VAR; + break; + } + /* FALLTHROUGH */ case '?': default: usage(); } + } argc -= optind; argv += optind; @@ -85,7 +102,8 @@ main(argc, argv) usage(); device = *argv; - if ((fd = open(device, O_RDWR, 0)) < 0) { + fd = open(device, readonly ? O_RDONLY : O_RDWR, 0); + if (fd < 0) { (void)fprintf(stderr, "scsiformat: %s: %s\n", device, strerror(errno)); exit(1); @@ -94,226 +112,402 @@ main(argc, argv) print_capacity(); print_mode_sense(); - do_format(); + if (!readonly) + do_format(); exit(0); } +/* + * Copy a counted string, trimming trailing blanks, and turning the + * result into a C-style string. + */ void -print_inquiry() +scsi_str(src, dst, len) + register char *src, *dst; + register int len; { - char idstr[32]; - int i; - do_command(fd, &inq, (u_char *)&inqbuf, sizeof(inqbuf)); - printf("%s: ", device); + while (src[len - 1] == ' ') { + if (--len == 0) { + *dst = 0; + return; + } + } + bcopy(src, dst, len); + dst[len] = 0; +} - if (inqbuf.version != 1) { - printf("type 0x%x, qual 0x%x, ver %d\n", inqbuf.type, - inqbuf.qual, inqbuf.version); +void +print_inquiry() +{ + register struct scsi_inq_ansi *si; + int ver; + struct scsi_inquiry inqbuf; + char vendor[10], product[17], rev[5]; + static struct scsi_cdb inq = { + CMD_INQUIRY, 0, 0, 0, sizeof(inqbuf), 0 + }; + + do_command(fd, &inq, &inqbuf, sizeof(inqbuf)); + (void)printf("%s: ", device); + + ver = (inqbuf.si_version >> VER_ANSI_SHIFT) & VER_ANSI_MASK; + if (ver != 1 && ver != 2) { + (void)printf("type 0x%x, qual 0x%x, ver 0x%x (ansi %d)\n", + inqbuf.si_type, inqbuf.si_qual, inqbuf.si_version, ver); return; } - switch (inqbuf.type) { - case 0: printf("(disk)"); break; - case 4: printf("(WORM)"); break; - case 5: printf("(CD-ROM)"); break; - case 7: printf("(MO-DISK)"); break; - default: printf("(??)"); break; + si = (struct scsi_inq_ansi *)&inqbuf; + switch (si->si_type & TYPE_TYPE_MASK) { + + case TYPE_DAD: + (void)printf("(disk)"); + break; + + case TYPE_WORM: + (void)printf("(WORM)"); + break; + + case TYPE_ROM: + (void)printf("(CD-ROM)"); + break; + + case TYPE_MO: + (void)printf("(MO-DISK)"); + break; + + case TYPE_JUKEBOX: + (void)printf("(jukebox)"); + break; + + default: + (void)printf("(??)"); + break; } - bcopy((caddr_t)&inqbuf.vendor_id, (caddr_t)idstr, 28); - for (i = 27; i > 23; --i) - if (idstr[i] != ' ') - break; - idstr[i+1] = 0; - for (i = 23; i > 7; --i) - if (idstr[i] != ' ') - break; - idstr[i+1] = 0; - for (i = 7; i >= 0; --i) - if (idstr[i] != ' ') - break; - idstr[i+1] = 0; - printf(" %s %s rev %s:", idstr, &idstr[8], &idstr[24]); + scsi_str(si->si_vendor, vendor, sizeof(si->si_vendor)); + scsi_str(si->si_product, product, sizeof(si->si_product)); + scsi_str(si->si_rev, rev, sizeof(si->si_rev)); + (void)printf(" %s %s rev %s:", vendor, product, rev); } void print_capacity() { - do_command(fd, &cap, (u_char *)&capbuf, sizeof(capbuf)); - printf(" %d blocks of %d bytes each\n", capbuf.blks, capbuf.blksize); + struct scsi_rc rc; /* for READ CAPACITY */ + static struct scsi_cdb cap = { CMD_READ_CAPACITY }; + + do_command(fd, &cap, &rc, sizeof(rc)); + (void)printf(" %d blocks of %d bytes each\n", + N4(rc.rc_lbah, rc.rc_lbahm, rc.rc_lbalm, rc.rc_lbal) + 1, + N4(rc.rc_blh, rc.rc_blhm, rc.rc_bllm, rc.rc_bll)); } void print_mode_sense() { - u_char *cp; - u_char *ep; - - do_command(fd, &modesense, (u_char *)&msbuf, sizeof(msbuf)); - - printf("\n%d bytes of mode sense data. ", msbuf.h.len); - printf("media type %d, %swrite protected\n", msbuf.h.media_type, - msbuf.h.wp? "" : "not "); - if (msbuf.h.block_desc_len) { - printf("density 0x%x, ", msbuf.h.density); - if (msbuf.h.number_blocks) - printf("%d blocks of length %d\n", - msbuf.h.number_blocks, msbuf.h.block_length); - else - printf("all blocks of length %d\n", - msbuf.h.block_length); - cp = msbuf.p; - } else - cp = &msbuf.h.block_desc_len + 1; - - ep = (u_char *)&msbuf + msbuf.h.len; + register u_char *cp, *ep; + register struct scsi_ms_bd *bd; + register int n, i, l, len, bdlen; +#ifdef TEN_BYTE_SENSE + struct { + struct scsi_ms10 ms; + u_char p[1023 - sizeof(struct scsi_ms10)]; + } msbuf; + static struct scsi_cdb modesense = { + CMD_MODE_SENSE10, SCSI_MSENSE_DBD, 0, 0, 0, 0, 0, + sizeof(msbuf) >> 8, sizeof (msbuf), 0 + }; + + CDB10(&modesense)->cdb_lbam = sense_pctl | SCSI_MS_PC_ALL; + do_command(fd, &modesense, &msbuf, sizeof(msbuf)); + len = N2(msbuf.ms.ms_lenh, msbuf.ms.ms_lenl); + bdlen = N2(msbuf.ms.ms_bdlh, msbuf.ms.ms_bdll); +#else + struct { + struct scsi_ms6 ms; + u_char p[255 - sizeof(struct scsi_ms6)]; + } msbuf; + static struct scsi_cdb modesense = { + CMD_MODE_SENSE6, 0, 0, 0, sizeof(msbuf), 0 + }; + + CDB6(&modesense)->cdb_lbam = sense_pctl | SCSI_MS_PC_ALL; + do_command(fd, &modesense, &msbuf, sizeof(msbuf)); + len = msbuf.ms.ms_len; + bdlen = msbuf.ms.ms_bdl; +#endif + (void)printf("\n%d bytes of mode sense data. ", len); + (void)printf("medium type 0x%x, %swrite protected\n", + msbuf.ms.ms_mt, msbuf.ms.ms_dsp & SCSI_MS_DSP_WP ? "" : "not "); + if ((n = bdlen) != 0) { + bd = (struct scsi_ms_bd *)msbuf.p; + for (n /= sizeof(*bd); --n >= 0; bd++) { + (void)printf("\tdensity code 0x%x, ", bd->bd_dc); + i = N3(bd->bd_nbh, bd->bd_nbm, bd->bd_nbl); + l = N3(bd->bd_blh, bd->bd_blm, bd->bd_bll); + if (i) + (void)printf("%d blocks of length %d\n", i, l); + else + (void)printf("all blocks of length %d\n", l); + } + } + /* + * Sense header lengths includes the sense header, while mode page + * lengths do not ... let's hear it for consistency! + */ + cp = msbuf.p + bdlen; + ep = msbuf.p + len - sizeof(msbuf.ms); while (cp < ep) cp = print_mode_page(cp); } +void +prflags(v, cp) + int v; + register const char *cp; +{ + register const char *np; + char f, sep; + + for (sep = '<'; (f = *cp++) != 0; cp = np) { + for (np = cp; *np >= ' ';) + np++; + if ((v & (1 << (f - 1))) == 0) + continue; + printf("%c%.*s", sep, np - cp, cp); + sep = ','; + } + if (sep != '<') + putchar('>'); +} + +static char * +cache_policy(x) + int x; +{ + static char rsvd[30]; + + switch (x) { + + case SCSI_CACHE_DEFAULT: + return ("default"); + + case SCSI_CACHE_KEEPPF: + return ("toss cmd data, save prefetch"); + + case SCSI_CACHE_KEEPCMD: + return ("toss prefetch data, save cmd"); + + default: + (void)sprintf(rsvd, "reserved %d", x); + return (rsvd); + } + /* NOTREACHED */ +} + u_char * print_mode_page(cp) u_char *cp; { - int n = cp[1]; - int i; - char c; - - printf("\npage type %d%s (%d bytes): ", cp[0] & 0x7f, - (cp[0] & 0x80)? " (saveable)" : "", n); - switch (cp[0] & 0x7f) { - case 1: - printf("Error Recovery parameters.\n"); - printf("\tflags = 0x%x ", i = cp[2]); - c = '<'; - if (i & 0x80) { - printf("%cAWRE", c); - c = ','; - } - if (i & 0x40) { - printf("%cARRE", c); - c = ','; - } - if (i & 0x20) { - printf("%cTB", c); - c = ','; - } - if (i & 0x10) { - printf("%cRC", c); - c = ','; - } - if (i & 0x08) { - printf("%cEEC", c); - c = ','; - } - if (i & 0x04) { - printf("%cPER", c); - c = ','; - } - if (i & 0x02) { - printf("%cDTE", c); - c = ','; - } - if (i & 0x01) { - printf("%cDCR", c); - c = ','; - } - if (c == ',') - printf(">"); - - printf("\n\t%d retries, %d correction span bits,\n", cp[3], - cp[4]); - printf("\t%d head offsets, %d data strobe offsets,\n\t", - cp[5], cp[6]); - if (cp[7] != 0xff) - printf("%d", cp[7]); + register struct scsi_ms_page_hdr *mp; + int len, code, i; + u_char *tp; + const char *s; + + mp = (struct scsi_ms_page_hdr *)cp; + code = mp->mp_psc & SCSI_MS_PC_MASK; + len = mp->mp_len; + (void)printf("\npage type %d%s (%d bytes): ", + code, mp->mp_psc & SCSI_MS_MP_SAVEABLE ? " (saveable)" : "", len); + switch (code) { + + case SCSI_MS_PC_RWERRREC: +#define rw ((struct scsi_page_rwerrrec *)(mp + 1)) + (void)printf("Read/Write Error Recovery parameters.\n"); + (void)printf("\tflags = 0x%x", rw->rw_flags); + prflags(rw->rw_flags, + "\10AWRE\7ARRE\6TB\5RC\4EER\3PER\2DTE\1DCR"); + (void)printf(",\n\t%d read retries, %d correction span bits,\n", + rw->rw_read_retry, rw->rw_corr_span); + (void)printf("\t%d head offsets, %d data strobe offsets%s\n", + rw->rw_hd_off, rw->rw_ds_off, len > 6 ? "," : "."); + if (len <= 6) + break; + (void)printf("\t%d write retries, ", rw->rw_write_retry); + i = N2(rw->rw_rtlh, rw->rw_rtll); + if (i != 0xffff) + (void)printf("%d", i); else - printf("no"); - printf(" recovery time limit.\n"); - cp += 8; - break; - - case 2: - printf("Disconnect/Reconnect control.\n"); - printf("\tbuffer full ratio %d, buffer empty ratio %d,\n", - cp[2], cp[3]); - printf("\ttime limits: %d bus inactivity, ", - *(u_short *)&cp[4]); - printf("%d disconnect, %d connect.\n", - *(u_short *)&cp[6],*(u_short *)&cp[8]); - cp += 12; + (void)printf("no"); + (void)printf(" recovery time limit.\n"); break; - - case 3: - { - struct scsi_format *sf = (struct scsi_format *)cp; - printf("Format parameters.\n"); - printf("\t%d tracks/zone, %d alt.sect./zone, ", - sf->tracks_per_zone, sf->alt_sect_zone); - printf("%d alt.tracks/zone,\n\t%d alt.tracks/vol., ", - sf->alt_tracks_zone, sf->alt_tracks_vol); - printf("%d sectors/track, %d bytes/sector, interleave %d\n", - sf->sect_track, sf->data_sect, sf->interleave); - printf("\ttrack skew %d, cylinder skew %d,\n", - sf->track_skew_factor, sf->cyl_skew_factor); - printf("\tdrive type 0x%x ", i = cp[20]); - c = '<'; - if (i & 0x80) { - printf("%cSSEC", c); - c = ','; - } - if (i & 0x40) { - printf("%cHSEC", c); - c = ','; - } - if (i & 0x20) { - printf("%cRMB", c); - c = ','; - } - if (i & 0x10) { - printf("%cSURF", c); - c = ','; - } - if (i & 0x08) { - printf("%cINS", c); - c = ','; - } - if (i & 0x04) { - printf("%c?", c); - c = ','; - } - if (i & 0x02) { - printf("%c?", c); - c = ','; - } - if (i & 0x01) { - printf("%c?", c); - c = ','; +#undef rw + + case SCSI_MS_PC_DR: +#define dr ((struct scsi_page_dr *)(mp + 1)) + (void)printf("Disconnect/Reconnect control.\n"); + (void)printf("\tbuffer full ratio %d, buffer empty ratio %d,\n", + dr->dr_full, dr->dr_empty); + (void)printf("\ttime limits: %d bus inactivity, ", + N2(dr->dr_inacth, dr->dr_inactl)); + (void)printf("%d disconnect, %d connect.\n", + N2(dr->dr_disconh, dr->dr_disconl), + N2(dr->dr_conh, dr->dr_conl)); + (void)printf("\tmaximum burst size %d,\n", + N2(dr->dr_bursth, dr->dr_burstl)); + switch (dr->dr_dtdc & SCSI_DR_DTDC_MASK) { + case SCSI_DR_DTDC_NONE: + s = "never"; + break; + case SCSI_DR_DTDC_NOTDATA: + s = "during data transfer"; + break; + case SCSI_DR_DTDC_RSVD: + s = "???"; + break; + case SCSI_DR_DTDC_NOTD2: + s = "during and after data transfer"; + break; } - if (c == ',') - printf(">"); - printf("\n"); - cp += 24; + (void)printf("\tsuppress disconnect %s.\n", s); + break; +#undef dr + + case SCSI_MS_PC_FMT: +#define fmt ((struct scsi_page_fmt *)(mp + 1)) + (void)printf("Format parameters.\n"); + (void)printf("\t%d tracks/zone, %d alt.sect./zone, ", + N2(fmt->fmt_tpzh, fmt->fmt_tpzl), + N2(fmt->fmt_aspzh, fmt->fmt_aspzl)); + (void)printf("%d alt.tracks/zone,\n\t%d alt.tracks/vol., ", + N2(fmt->fmt_atpzh, fmt->fmt_atpzl), + N2(fmt->fmt_atpvh, fmt->fmt_atpvl)); + (void)printf("%d sectors/track, %d bytes/phys.sector,\n", + N2(fmt->fmt_spth, fmt->fmt_sptl), + N2(fmt->fmt_dbppsh, fmt->fmt_dbppsl)); + (void)printf("\tinterleave %d, track skew %d, cyl.skew %d,\n", + N2(fmt->fmt_ilh, fmt->fmt_ill), + N2(fmt->fmt_tsfh, fmt->fmt_tsfl), + N2(fmt->fmt_csfh, fmt->fmt_csfl)); + (void)printf("\tdrive flags 0x%x", fmt->fmt_flags); + prflags(fmt->fmt_flags, "\10SSEC\7HSEC\6RMB\5SURF"); + (void)printf(".\n"); + break; +#undef fmt + + case SCSI_MS_PC_RDGEOM: +#define rd ((struct scsi_page_rdgeom *)(mp + 1)) + (void)printf("Disk Geometry parameters.\n"); + (void)printf("\t%d cylinders, %d heads,\n", + N3(rd->rd_ncylh, rd->rd_ncylm, rd->rd_ncyll), + rd->rd_nheads); + (void)printf("\tstart write precompensation at cyl %d,\n", + N3(rd->rd_wpcylh, rd->rd_wpcylm, rd->rd_wpcyll)); + (void)printf("\tstart reduced write current at cyl %d,\n", + N3(rd->rd_rwcylh, rd->rd_rwcylm, rd->rd_rwcyll)); + (void)printf("\tseek step rate %f us, landing zone cyl %d,\n", + N2(rd->rd_steph, rd->rd_stepl) * 0.1, + N3(rd->rd_lcylh, rd->rd_lcylm, rd->rd_lcyll)); + switch (rd->rd_rpl & SCSI_RD_RPL_MASK) { + case SCSI_RD_RPL_NONE: + s = "disabled or unsupported"; + break; + case SCSI_RD_RPL_SLAVE: + s = "slave"; + break; + case SCSI_RD_RPL_MASTER: + s = "master"; + break; + case SCSI_RD_RPL_MCONTROL: + s = "master control"; + break; } + (void)printf("\trotational synch %s, offset %d/256%s\n", + s, rd->rd_roff, len > 18 ? "," : "."); + if (len > 18) + (void)printf("\trotation %d rpm.\n", + N2(rd->rd_rpmh, rd->rd_rpml)); break; - - case 4: - printf("Disk Geometry parameters.\n"); - printf("\t%d cylinders, %d heads.\n", - (cp[2] << 16) | (cp[3] << 8) | cp[4], cp[5]); - cp += cp[1] + 2; +#undef rd + + case SCSI_MS_PC_VERRREC: +#define v ((struct scsi_page_verrrec *)(mp + 1)) + (void)printf("Verify Error Recovery parameters.\n"); + (void)printf("\tflags = 0x%x", v->v_flags); + prflags(v->v_flags, "\4EER\3PER\2DTE\1DCR"); + (void)printf(",\n\t%d verify retries, %d %s span bits,\n\t", + v->v_verify_retry, v->v_corr_span, "correction"); + (void)printf("%d recovery time limit.\n", + N2(v->v_rtlh, v->v_rtll)); + break; +#undef v + + case SCSI_MS_PC_CACHE: +#define cache ((struct scsi_page_cache *)(mp + 1)) + (void)printf("Caching Page.\n"); + (void)printf("\tflags = 0x%x", cache->cache_flags); + prflags(cache->cache_flags, "\3WCE\2MF\1RCD"); + (void)printf( + ",\n\tread retention = %s, write retention = %s,\n", + cache_policy(SCSI_CACHE_RDPOLICY(cache->cache_reten)), + cache_policy(SCSI_CACHE_WRPOLICY(cache->cache_reten))); + (void)printf("\tdisable prefetch transfer length = %d,\n", + N2(cache->cache_dptlh, cache->cache_dptll)); + (void)printf("\tmin prefetch = %d, max prefetch = %d, ", + N2(cache->cache_minpfh, cache->cache_minpfl), + N2(cache->cache_maxpfh, cache->cache_maxpfl)); + (void)printf("max prefetch ceiling = %d.\n", + N2(cache->cache_mpch, cache->cache_mpcl)); break; +#undef cache + + case SCSI_MS_PC_CTLMODE: +#define cm ((struct scsi_page_ctlmode *)(mp + 1)) + (void)printf("Control Mode Page.\n"); + (void)printf("\t%s report log-activity error conditions,\n", + cm->cm_rlec & SCSI_CM_RLEC ? "do" : "do not"); + (void)printf("\tqueue algorithm modifier = %d, flags = 0x%x", + SCSI_CM_QMOD(cm->cm_qctl), + cm->cm_qctl & (SCSI_CM_QERR|SCSI_CM_DQUE)); + prflags(cm->cm_qctl, "\2QERR\1DQUE"); + (void)printf(",\n\tECA/AEN flags = 0x%x", cm->cm_ecaaen); + prflags(cm->cm_ecaaen, "\10ECA\3RAENP\2UUAENP\1EAENP"); + (void)printf(", AEN holdoff period = %d ms.\n", + N2(cm->cm_aenholdh, cm->cm_aenholdl)); + break; +#undef cm + + /* + * Vendor Unique, but what the heck. + */ + case SCSI_MS_PC_CDCCACHECTL: +#define ccm ((struct scsi_page_CDCcachectlmode *)(mp + 1)) + (void)printf("CDC-specific Cache Control Mode Page.\n"); + (void)printf("\tflags = 0x%x", ccm->ccm_flags); + prflags(ccm->ccm_flags, "\7WIE\5ENABLE"); + (void)printf(", table size = %d, prefetch threshold = %d\n", + SCSI_CDC_CCM_TBLSZ(ccm->ccm_flags), + ccm->ccm_pfthresh); + (void)printf("\tmaximum %s = %d, maximum %s = %d,\n", + "threshold", ccm->ccm_maxthresh, + "prefetch multiplier", ccm->ccm_maxpfmult); + (void)printf("\tminimum %s = %d, minimum %s = %d.\n", + "threshold", ccm->ccm_minthresh, + "prefetch multiplier", ccm->ccm_minpfmult); + break; +#undef ccm default: - printf("Unknown page type."); - for (cp += 2, i = 0; i < n; ++i) { + (void)printf("Unknown page type."); + for (tp = cp + sizeof(*mp), i = 0; i < len; ++i) { if ((i & 7) == 0) - printf("\n\t%2d ", i); - printf(" %02x", *cp++); + (void)printf("\n\t%2d: ", i); + (void)printf(" %02x", *tp++); } - printf("\n"); + (void)printf(".\n"); break; } - return (cp); + return (cp + sizeof(*mp) + len); } void @@ -321,6 +515,7 @@ pr_sense(fd) int fd; { static struct scsi_fmt_sense s; + register struct scsi_sense *sn; if (ioctl(fd, SDIOCSENSE, &s) < 0) (void)fprintf(stderr, @@ -328,13 +523,14 @@ pr_sense(fd) (void)printf("scsi status 0x%x", s.status); if (s.status & STS_CHECKCOND) { - struct scsi_xsense *sp = (struct scsi_xsense *)s.sense; - - (void)printf(" sense class %d, code %d", sp->class, sp->code); - if (sp->class == 7) { - (void)printf(", key %d", sp->key); - if (sp->valid) - (void)printf(", blk %d", *(int *)&sp->info1); + sn = (struct scsi_sense *)s.sense; + + (void)printf(" sense class %d, code %d", + SENSE_ECLASS(sn), SENSE_ECODE(sn)); + if (SENSE_ISXSENSE(sn)) { + (void)printf(", key %d", XSENSE_KEY(sn)); + if (XSENSE_IVALID(sn)) + (void)printf(", blk %d", XSENSE_INFO(sn)); } } (void)printf("\n"); @@ -343,58 +539,84 @@ pr_sense(fd) void do_format() { - static int on = 1; - static int off = 0; - static u_char fmtbuf[128]; - struct scsi_modesel_hdr *ms = (struct scsi_modesel_hdr *)mselbuf; - - ms->block_desc_len = 8; - ms->block_length = 512; - mselbuf[12] = 32; - mselbuf[13] = 10; - mselbuf[14] = 1; - - if (ioctl(fd, SDIOCSFORMAT, &on) < 0) { - (void)fprintf(stderr, - "scsiformat: SDIOCSFORMAT (on): %s\n", strerror(errno)); - return; - } - if (ioctl(fd, SDIOCSCSICOMMAND, &modeselect) < 0) - (void)fprintf(stderr, - "scsiformat: modeselect cmd: %s\n", strerror(errno)); - else if (write(fd, mselbuf, sizeof(mselbuf)) < 0) { - (void)fprintf(stderr, - "scsiformat: modeselect write: %s\n", strerror(errno)); - pr_sense(fd); - } else if (ioctl(fd, SDIOCSCSICOMMAND, &format) < 0) - (void)fprintf(stderr, - "scsiformat: format cmd: %s\n", strerror(errno)); - else if (write(fd, fmtbuf, sizeof(fmtbuf)) < 0) { - (void)fprintf(stderr, - "scsiformat: format write: %s\n", strerror(errno)); - pr_sense(fd); - } - if (ioctl(fd, SDIOCSFORMAT, &off) < 0) - (void)fprintf(stderr, - "scsiformat: SDIOCSFORMAT (off): %s\n", strerror(errno)); + struct { + struct scsi_ms6 ms; /* mode select header */ + struct scsi_ms_bd bd; /* block descriptor */ + struct scsi_ms_page_hdr mp; /* ctl mode page hdr */ + struct scsi_page_ctlmode cm; /* ctl mode page */ + u_char pad[4]; /* ??? */ + } msel; + u_char fmtbuf[128]; + static struct scsi_cdb modeselect = { + CMD_MODE_SELECT6, + SCSI_MSEL_SCSI2_DATA | SCSI_MSEL_SAVEPAGES, 0, 0, + sizeof(msel), 0 + }; + static struct scsi_cdb format = { CMD_FORMAT_UNIT }; + + /* want mostly 0s; set them all zero here */ + bzero(&msel, sizeof(msel)); + + /* one block descriptor */ + msel.ms.ms_bdl = sizeof(struct scsi_ms_bd); + + /* block length = 512 bytes */ + msel.bd.bd_blm = 512 / 256; + msel.bd.bd_bll = 512 % 256; + + /* + * In the following, the mystery pad region is copied from + * the original driver. I have no idea what it is for. + * (Anyone got SCSI-2 documents?) + */ + + /* mode page parameters: report log-activity exception conditions */ + msel.mp.mp_psc = SCSI_MS_PC_CTLMODE; + msel.mp.mp_len = sizeof(msel.cm) + sizeof(msel.pad); + msel.cm.cm_rlec = SCSI_CM_RLEC; + + do_command(fd, &modeselect, &msel, sizeof(msel)); + + bzero(fmtbuf, sizeof(fmtbuf)); + do_command(fd, &format, fmtbuf, sizeof(fmtbuf)); } void do_command(fd, cdb, buf, len) int fd; - struct scsi_fmt_cdb *cdb; - u_char *buf; + struct scsi_cdb *cdb; + void *buf; int len; { - static int on = 1; - static int off = 0; + static int on = 1, off = 0; + int user, ret; + bzero(buf, len); if (ioctl(fd, SDIOCSFORMAT, &on) < 0) { (void)fprintf(stderr, "scsiformat: SDIOCSFORMAT (on): %s\n", strerror(errno)); + if (ioctl(fd, SDIOCGFORMAT, &user) == 0 && user != 0) + (void)fprintf(stderr, "scsiformat: pid %d has it\n", + user); return; } - if (ioctl(fd, SDIOCSCSICOMMAND, cdb) < 0) + ret = ioctl(fd, SDIOCSCSICOMMAND, cdb); +#ifdef COMPAT_HPSCSI + if (ret < 0) { + static const char scsicmdlen[8] = { 6, 10, 0, 0, 0, 12, 0, 0 }; +#define SCSICMDLEN(cmd) scsicmdlen[(cmd) >> 5] + struct scsi_fmt_cdb { + int len; + u_char cdb[28]; + } sc; +#define OSDIOCSCSICOMMAND _IOW('S', 0x3, struct scsi_fmt_cdb) + + sc.len = SCSICMDLEN(cdb->cdb_bytes[0]); + bcopy(cdb->cdb_bytes, sc.cdb, sc.len); + ret = ioctl(fd, OSDIOCSCSICOMMAND, &sc); + } +#endif + if (ret < 0) (void)fprintf(stderr, "scsiformat: SDIOCSCSICOMMAND: %s\n", strerror(errno)); else if (read(fd, buf, len) < 0) { @@ -411,6 +633,6 @@ do_command(fd, cdb, buf, len) void usage() { - (void)fprintf(stderr, "usage: scsiformat device\n"); + (void)fprintf(stderr, "usage: scsiformat [-r] [-p c|d|s|v] device\n"); exit(1); } -- 2.20.1