![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fdformat.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / etc|
Return to fdformat.c CVS log | Up to [MW Coherent from dump] / coherent / d / etc |
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.