Return to fdformat.c CVS log

Up to [MW Coherent from dump] / coherent / d / etc

Annotation of coherent/d/etc/fdformat.c, revision 1.1

1.1     ! root        1: char helpmessage[] = "\
        !             2: /etc/fdformat -- format a floppy disk\n\
        !             3: Usage: /etc/fdformat [-a] [-i n] [-o n] [-v] [-w file] special\n\
        !             4: Options:\n\
        !             5:        -a      write information line during format\n\
        !             6:        -i n    use interleave factor n (default: 6)\n\
        !             7:        -o n    use offset factor n for numbering sectors (default: 0)\n\
        !             8:        -v      verify by reading each track (may be specified repeatedly)\n\
        !             9:        -w file write file to the diskette\n\
        !            10: ";
        !            11: 
        !            12: #include       <stdio.h>
        !            13: #include       <sys/fdioctl.h>
        !            14: #include       <sys/stat.h>
        !            15: #include       <errno.h>
        !            16: 
        !            17: extern char *malloc();
        !            18: 
        !            19: int    aflag = 0;
        !            20: int    dvfd = 0;
        !            21: char   *dvname = NULL;
        !            22: char   *dvbuff = NULL;
        !            23: int    wrfd = 0;
        !            24: char   *wrname = NULL;
        !            25: char   *wrbuff = NULL;
        !            26: int    interleave = 6;
        !            27: int    offset = 0;
        !            28: int    verify = 0;
        !            29: 
        !            30: struct fform fform[16];
        !            31: 
        !            32: struct fdata {
        !            33:        int fd_cyladdress;      /* Use cylinder addressing */
        !            34:        int fd_heads;           /* Number of heads */
        !            35:        int fd_tracks;          /* Number of tracks per surface */
        !            36:        int fd_sectors;         /* Number of sectors per track */
        !            37:        int fd_size;            /* Sector size parameter */
        !            38:        int fd_tsz;             /* Track size in bytes */
        !            39: } fdata[] = {
        !            40:        { 0, 1, 40, 8, 2 , 8*512 },     /* minor device 0 - /dev/f8s0 */
        !            41:        { 0, 2, 40, 8, 2 , 8*512 },     /* minor device 1 - /dev/f8d0 */
        !            42:        { 0, 2, 80, 8, 2 , 8*512 },     /* minor device 2 - /dev/f8q0 */
        !            43:        { 0, 1, 40, 9, 2,  9*512 },     /* minor device 3 - /dev/f9s0 */
        !            44:        { 0, 2, 40, 9, 2,  9*512 },     /* minor device 4 - /dev/f9d0 */
        !            45:        { 0, 2, 80, 9, 2,  9*512 },     /* minor device 5 - /dev/fqd0 */
        !            46:        { 0, 2, 80,15, 2, 15*512 },     /* minor device 6 - /dev/fhd0 */
        !            47:        { 0, 2, 80,18, 2, 18*512 },     /* minor device 7 - /dev/fvd0 */
        !            48: 
        !            49:        { 0, 0,  0, 0, 0,  0*  0 },     /* minor device 8 - unused */
        !            50:        { 1, 2, 40, 8, 2,  8*512 },     /* minor device 9 - /dev/f8a0 */
        !            51:        { 0, 0,  0, 0, 0,  0*  0 },     /* minor device 10 - unused */
        !            52:        { 0, 0,  0, 0, 0,  0*  0 },     /* minor device 11 - unused */
        !            53:        { 1, 2, 40, 9, 2,  9*512 },     /* minor device 12 - /dev/f9a0 */
        !            54:        { 1, 2, 80, 9, 2,  9*512 },     /* minor device 13 - /dev/fqa0 */
        !            55:        { 1, 2, 80,15, 2, 15*512 },     /* minor device 14 - /dev/fha0 */
        !            56:        { 1, 2, 80,18, 2, 18*512 }      /* minor device 15 - /dev/fva0 */
        !            57: };
        !            58: 
        !            59: struct fdata fkind;
        !            60: #define NKINDS (sizeof(fdata)/sizeof(fdata[0]))
        !            61: struct stat sbuf;
        !            62: 
        !            63: main(argc, argv)
        !            64: char *argv[];
        !            65: {
        !            66:        register int i;
        !            67:        register char *p;
        !            68:        int head, retry;
        !            69: 
        !            70:        for (i=1; i<argc && argv[i][0]=='-'; ++i) {
        !            71:                for (p=&argv[i][1]; *p!='\0'; p+=1) {
        !            72:                        switch (*p) {
        !            73: 
        !            74:                        case    'a':
        !            75:                                ++aflag;
        !            76:                                break;
        !            77: 
        !            78:                        case    'i':
        !            79:                                if (++i>argc
        !            80:                                 || (interleave = atoi(argv[i]))<0)
        !            81:                                        usage();
        !            82:                                break;
        !            83: 
        !            84:                        case    'o':
        !            85:                                if (++i>argc
        !            86:                                 || (offset = atoi(argv[i]))<0)
        !            87:                                        usage();
        !            88:                                break;
        !            89: 
        !            90:                        case    'v':
        !            91:                                verify += 1;
        !            92:                                break;
        !            93: 
        !            94:                        case    'w':
        !            95:                                if (++i>argc)
        !            96:                                        usage();
        !            97: 
        !            98:                                wrname = argv[i];
        !            99: 
        !           100:                                if ((wrfd = open(wrname, 0)) < 0) {
        !           101:                                        dvname = wrname;
        !           102:                                        xxerror("open", 1);
        !           103:                                }
        !           104: 
        !           105:                                break;
        !           106: 
        !           107:                        default:
        !           108:                                usage();
        !           109:                        }
        !           110:                }
        !           111:        }
        !           112: 
        !           113:        dvname = argv[i++];
        !           114: 
        !           115:        if (i != argc)
        !           116:                usage();
        !           117: 
        !           118:        if ((dvfd = open(dvname, 2)) < 0)
        !           119:                xxerror("open", 1);
        !           120: 
        !           121:        if (fstat(dvfd, &sbuf) < 0)
        !           122:                xxerror("fstat", 1);
        !           123: 
        !           124:        sbuf.st_rdev &= 0xF;
        !           125: 
        !           126:        if (sbuf.st_rdev >= NKINDS) {
        !           127:                errno = ENXIO;
        !           128:                xxerror("kind check", 1);
        !           129:        }
        !           130: 
        !           131:        fkind = fdata[sbuf.st_rdev];
        !           132: 
        !           133:        if (offset >= fkind.fd_sectors || interleave >= fkind.fd_sectors)
        !           134:                usage();
        !           135: 
        !           136:        if (verify && (dvbuff = malloc(fkind.fd_tsz)) == NULL)
        !           137:                xxerror("cannot allocate verify buffer", 1);
        !           138: 
        !           139:        if (wrfd && (wrbuff = malloc(fkind.fd_tsz)) == NULL)
        !           140:                xxerror("cannot allocate copy buffer", 1);
        !           141: 
        !           142:        for (i = 0; i < fkind.fd_tracks; i += 1)
        !           143:        for (head = 0; head < fkind.fd_heads; head += 1) {
        !           144:                retry = 0;
        !           145:                makeform(i, head, offset, interleave);
        !           146:                if (aflag) {
        !           147:                        printf("cyl=%2d hd=%d\r", i, head);
        !           148:                        fflush(stdout);
        !           149:                }
        !           150:                do
        !           151:                        if (ioctl(dvfd, FDFORMAT, (char *)fform) < 0)
        !           152:                                xxerror("ioctl", 1);
        !           153:                while ((verify || wrfd)
        !           154:                 && doextra(i, head) < 0
        !           155:                 && ++retry < verify);
        !           156: 
        !           157:                if (verify && (retry == verify)) {
        !           158:                        errno = 0;
        !           159:                        xxerror("verify failed", 1);
        !           160:                }
        !           161:        }
        !           162:        if (aflag) {
        !           163:                printf("           \r");
        !           164:                fflush(stdout);
        !           165:        }
        !           166:        exit(0);
        !           167: }
        !           168: 
        !           169: /*
        !           170:  * Construct a track format buffer for the floopy.
        !           171:  */
        !           172: makeform(c, h, o, i)
        !           173: {
        !           174:        register int psect, lsect;
        !           175:        register int nspt;
        !           176: 
        !           177:        nspt = fkind.fd_sectors;
        !           178: 
        !           179:        for (psect=0; psect<nspt; psect+=1)
        !           180:                fform[psect].ff_sect = 0;
        !           181: 
        !           182:        psect = 0;
        !           183:        lsect = c * o;
        !           184: 
        !           185:        while (psect<nspt) {
        !           186:                while (lsect>=nspt || fform[lsect].ff_sect!=0)
        !           187:                        if (lsect>=nspt)
        !           188:                                lsect-=nspt;
        !           189:                        else
        !           190:                                lsect+=1;
        !           191: 
        !           192:                fform[lsect].ff_cylin = c;
        !           193:                fform[lsect].ff_head = h;
        !           194:                fform[lsect].ff_sect = psect+1;
        !           195:                fform[lsect].ff_size = fkind.fd_size;
        !           196:                psect += 1;
        !           197:                lsect += i;
        !           198:        }
        !           199:        /* printform(); */
        !           200: }
        !           201: 
        !           202: /*
        !           203: printform()
        !           204: {
        !           205:        register int i;
        !           206:        register struct fform *f;
        !           207:        for (i = 0; i < fkind.fd_sectors; i += 1) {
        !           208:                f = &fform[i];
        !           209:                printf("%x %x %x %x\n",
        !           210:                        f->ff_cylin, f->ff_head, f->ff_sect, f->ff_size);
        !           211:        }
        !           212: }
        !           213: */
        !           214: 
        !           215: doextra(track, head)
        !           216: int track, head;
        !           217: {
        !           218:        long pos;
        !           219:        register int size;
        !           220:        register unsigned char *p, *q;
        !           221: 
        !           222:        if (fkind.fd_cyladdress)
        !           223:                pos = 2 * track + head;
        !           224:        else
        !           225:                pos = head * fkind.fd_tracks + track;
        !           226: 
        !           227:        pos *= fkind.fd_tsz;
        !           228:        size = fkind.fd_tsz;
        !           229: 
        !           230:        if (wrfd) {
        !           231:                lseek(wrfd, pos, 0);
        !           232: 
        !           233:                if (read(wrfd, wrbuff, size) != size)
        !           234:                        return (xxerror("read file", 0));
        !           235: 
        !           236:                lseek(dvfd, pos, 0);
        !           237: 
        !           238:                if (write(dvfd, wrbuff, size) != size)
        !           239:                        return (xxerror("write floppy", 0));
        !           240:        }
        !           241: 
        !           242:        if (verify) {
        !           243:                lseek(dvfd, pos, 0);
        !           244: 
        !           245:                if (read(dvfd, dvbuff, size) != size)
        !           246:                        return (xxerror("read floppy", 0));
        !           247:        }
        !           248: 
        !           249:        if (verify && wrfd) {
        !           250:                p = dvbuff;
        !           251:                q = wrbuff;
        !           252: 
        !           253:                while (--size >= 0)
        !           254:                        if (*p++ != *q++)
        !           255:                                return (xxerror("verify compare", 0));
        !           256:        } else if (verify) {
        !           257:                p = dvbuff;
        !           258: 
        !           259:                while (--size >= 0)
        !           260:                        if (*p++ != 0xF6)
        !           261:                                return (xxerror("verify compare", 0));
        !           262:        }
        !           263: 
        !           264:        return (0);
        !           265: }
        !           266: 
        !           267: usage()
        !           268: {
        !           269:        printf(helpmessage);
        !           270:        exit(1);
        !           271: }
        !           272: 
        !           273: xxerror(s, f) char *s; int f;
        !           274: {
        !           275:        extern int errno;
        !           276:        int uerror;
        !           277: 
        !           278:        uerror = errno;
        !           279:        fprintf(stderr, "fdformat: %s: ", dvname);
        !           280: 
        !           281:        if ((errno = uerror) > 0 && errno < sys_nerr)
        !           282:                perror(s);
        !           283: 
        !           284:        else if (errno != 0)
        !           285:                fprintf(stderr, "%s: errno==%d\n", s, errno);
        !           286: 
        !           287:        else
        !           288:                fprintf(stderr, "%s\n", s);
        !           289: 
        !           290:        if (f)
        !           291:                exit(1);
        !           292: 
        !           293:        return (-1);
        !           294: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.