?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
exec.library: Allocate/Deallocate functions must remain generic and not handler MemHe...
[AROS.git] / workbench / c / Install.c
blob32b495acdaf99fd32e7cf9cbad9d6ddf98474392
1 /*
2 Copyright © 1995-2001, The AROS Development Team. All rights reserved.
3 $Id$
4
5 Desc:
6 Lang: English
7 */
8 /******************************************************************************
9
10
11 NAME
12
13 Install
14
15 SYNOPSIS
16
17 DRIVE/A, NOBOOT/S, CHECK/S, FFS/S
18
19 LOCATION
20
21 C:
22
23 FUNCTION
24
25 Saves a bootblock to a floppy disk. If the NOBOOT is appointed it
26 will not be able to be boot on computer startup (Amiga only)
27
28 INPUTS
29
30 DRIVE -- Show information on file system devices
31 NOBOOT -- Should be set on PC Floppy drives
32 CHECK -- Verify the existing bootblock
33 FFS -- For FFS formatted Floppy disks
34
35 RESULT
36
37 NOTES
38
39 This is a pretty useless command for PC-Drives, since most systems
40 require grub to be present on disk for AROS to boot.
41
42 EXAMPLE
43
44 Install df0: NOBOOT FFS
45
46 BUGS
47
48 SEE ALSO
49
50 Install-i386-pc, Sys:System/Format
51
52 INTERNALS
53
54 HISTORY
55
56 ******************************************************************************/
57
58 #include <string.h>
59
60 #include <proto/dos.h>
61 #include <proto/exec.h>
62 #include <proto/alib.h>
63
64 #include <devices/newstyle.h>
65 #include <devices/trackdisk.h>
66 #include <dos/dos.h>
67 #include <dos/dosextens.h>
68 #include <dos/filehandler.h>
69 #include <exec/errors.h>
70 #include <exec/io.h>
71 #include <exec/memory.h>
72 #include <exec/types.h>
73 #include <exec/ports.h>
74 #include <aros/macros.h>
75
76 struct Volume {
77 STRPTR drivename;
78 struct MsgPort *mp;
79 struct IOExtTD *iotd;
80 struct FileSysStartupMsg *fssm;
81 ULONG readcommand;
82 ULONG writecommand;
83 ULONG startblock;
84 ULONG countblock;
85 UWORD SizeBlock;
86 UBYTE flags;
87 ULONG *blockbuffer;
88 };
89
90 #define VF_IS_TRACKDISK (1<<0)
91 #define VF_MOVE_BB (1<<1)
92
93 struct BlockNode {
94 ULONG sector;
95 UWORD count;
96 UWORD seg_adr;
97 };
98
99 ULONG stage2_firstblock[128];
100
101 int readwriteBlock
102 (
103 struct Volume *volume,
104 ULONG block, APTR buffer, ULONG length,
105 ULONG command
106 )
107 {
108 UQUAD offset;
109 ULONG retval;
110
111 volume->iotd->iotd_Req.io_Command = command;
112 volume->iotd->iotd_Req.io_Length = length;
113 volume->iotd->iotd_Req.io_Data = buffer;
114 offset = (UQUAD)(volume->startblock+block)*(volume->SizeBlock*4);
115 volume->iotd->iotd_Req.io_Offset = offset & 0xFFFFFFFF;
116 volume->iotd->iotd_Req.io_Actual = offset>>32;
117 retval = DoIO((struct IORequest *)&volume->iotd->iotd_Req);
118 if (volume->flags & VF_IS_TRACKDISK)
119 {
120 volume->iotd->iotd_Req.io_Command = TD_MOTOR;
121 volume->iotd->iotd_Req.io_Length = 0;
122 DoIO((struct IORequest *)&volume->iotd->iotd_Req);
123 }
124 return retval;
125 }
126
127 ULONG collectBlockList(struct Volume *volume, ULONG block, struct BlockNode *blocklist) {
128 ULONG retval, first_block;
129 WORD blk_count,count;
130 UWORD i;
131
132 /* TODO: logical/physical blocks */
133 /*
134 initialze stage2-blocklist
135 (it is NULL-terminated)
136 */
137 for (blk_count=-1;blocklist[blk_count].sector!=0;blk_count--)
138 blocklist[blk_count].sector = 0;
139 /*
140 the first block of stage2 will be stored in stage1
141 so skip the first filekey in the first loop
142 */
143 /* FIXME: Block read twice */
144 retval=readwriteBlock
145 (
146 volume, block, volume->blockbuffer, volume->SizeBlock*4,
147 volume->readcommand
148 );
149 i = volume->SizeBlock - 52;
150 first_block = AROS_BE2LONG(volume->blockbuffer[volume->SizeBlock-51]);
151 blk_count=0;
152 do {
153 retval=readwriteBlock
154 (
155 volume, block, volume->blockbuffer, volume->SizeBlock*4,
156 volume->readcommand
157 );
158 if (retval)
159 {
160 Printf("ReadError %lu\n", (long)retval);
161 return 0;
162 }
163 while ((i>=6) && (volume->blockbuffer[i]))
164 {
165 /*
166 if current sector follows right after last sector
167 then we don't need a new element
168 */
169 if (
170 (blocklist[blk_count].sector) &&
171 ((blocklist[blk_count].sector+blocklist[blk_count].count)==
172 AROS_BE2LONG(volume->blockbuffer[i]))
173 )
174 {
175 blocklist[blk_count].count += 1;
176 }
177 else
178 {
179 blk_count--; /* decrement first */
180 if (blocklist[blk_count-1].sector != 0)
181 {
182 Printf("There is no more space to save blocklist in stage2\n");
183 return 0;
184 }
185 blocklist[blk_count].sector = AROS_BE2LONG(volume->blockbuffer[i]);
186 blocklist[blk_count].count = 1;
187 }
188 i--;
189 }
190 i = volume->SizeBlock - 51;
191 block = AROS_BE2LONG(volume->blockbuffer[volume->SizeBlock - 2]);
192 } while (block);
193 /*
194 blocks in blocklist are relative to the first
195 sector of the HD (not partition)
196 */
197 i = 0;
198 for (count=-1;count>=blk_count;count--)
199 {
200 blocklist[count].sector += volume->startblock;
201 blocklist[count].seg_adr = 0x820 + (i*32);
202 i += blocklist[count].count;
203 }
204 return first_block;
205 }
206
207 /*************************************
208 Name : installStageFiles
209 Descr.: install stage1 and initialize stage2
210 Input : volume - the volume to install on
211 use_mbr - flag to use MBR
212 stage2_drive - the unit stage2 is located
213 **************************************/
214 void installStageFiles(struct Volume *volume, LONG use_mbr, UBYTE stage2_drive) {
215 char stagename[256];
216 struct FileInfoBlock fib;
217 BPTR fh, fh2;
218 ULONG block,retval;
219 ULONG error=0;
220 STRPTR errstr=NULL;
221
222
223 strcpy(stagename, (char *)volume->drivename);
224 strcat(stagename, "Boot/grub/stage2");
225 fh = Open(stagename,MODE_OLDFILE);
226 if (fh)
227 {
228 if (ExamineFH(fh, &fib))
229 {
230 if (Read(fh, stage2_firstblock, 512) == 512)
231 {
232 if ((volume->flags & VF_MOVE_BB) && !use_mbr)
233 {
234 readwriteBlock
235 (
236 volume, 1, volume->blockbuffer, 512,
237 volume->writecommand
238 );
239 }
240 if (
241 (
242 block=collectBlockList
243 (
244 volume, fib.fib_DiskKey,
245 (struct BlockNode *)&stage2_firstblock[128]
246 )
247 )
248 )
249 {
250 if (Seek(fh, 0, OFFSET_BEGINNING)!=-1)
251 {
252 if (Write(fh, stage2_firstblock, 512)==512)
253 {
254 strcpy(stagename, (char *)volume->drivename);
255 strcat(stagename, "Boot/grub/stage1");
256 fh2 = Open(stagename, MODE_OLDFILE);
257 if (fh2)
258 {
259 if (Read(fh2, volume->blockbuffer, 512) == 512)
260 {
261 volume->blockbuffer[17]=block;
262 retval = 0;
263 if (use_mbr)
264 {
265 volume->blockbuffer[17] += volume->startblock;
266 volume->startblock = 0;
267 retval = readwriteBlock
268 (
269 volume, 0,
270 stage2_firstblock, 512, volume->readcommand
271 );
272 /* copy BPB (BIOS Parameter Block)*/
273 CopyMem
274 (
275 (APTR)((char *)stage2_firstblock+0x3),
276 (APTR)((char *)volume->blockbuffer+0x3),
277 0x3B
278 );
279 /* copy partition table */
280 CopyMem
281 (
282 (APTR)((char *)stage2_firstblock+0x1BE),
283 (APTR)((char *)volume->blockbuffer+0x1BE),
284 0x40
285 );
286 /* store the drive num stage2 is stored on */
287 ((char *)volume->blockbuffer)[0x40] = stage2_drive+0x80;
288 }
289 if (retval==0)
290 {
291 retval = readwriteBlock
292 (
293 volume, 0,
294 volume->blockbuffer, 512, volume->writecommand
295 );
296 if (retval)
297 Printf("WriteError %lu\n", (long)retval);
298 }
299 else
300 Printf("WriteErrro %lu\n", (long)retval);
301 }
302 else
303 error = IoErr();
304 Close(fh2);
305 }
306 else
307 {
308 error = IoErr();
309 errstr = stagename;
310 }
311 }
312 else
313 error = IoErr();
314 }
315 else
316 error = IoErr();
317 }
318 }
319 else
320 {
321 error = IoErr();
322 errstr = stagename;
323 }
324 }
325 else
326 {
327 error = IoErr();
328 errstr = stagename;
329 }
330 Close(fh);
331 }
332 else
333 {
334 error = IoErr();
335 errstr = stagename;
336 }
337 if (error)
338 PrintFault(error, errstr);
339 }
340
341 void nsdCheck(struct Volume *volume) {
342 struct NSDeviceQueryResult nsdq;
343 UWORD *cmdcheck;
344 if (
345 (
346 (volume->startblock+volume->countblock)* /* last block */
347 (volume->SizeBlock*4/512) /* 1 portion (block) equals 512 (bytes) */
348 )>8388608)
349 {
350 nsdq.SizeAvailable=0;
351 nsdq.DevQueryFormat=0;
352 volume->iotd->iotd_Req.io_Command=NSCMD_DEVICEQUERY;
353 volume->iotd->iotd_Req.io_Data=&nsdq;
354 volume->iotd->iotd_Req.io_Length=sizeof(struct NSDeviceQueryResult);
355 if (DoIO((struct IORequest *)&volume->iotd->iotd_Req)==IOERR_NOCMD)
356 {
357 Printf("Device doesn't understand NSD-Query\n");
358 }
359 else
360 {
361 if (
362 (volume->iotd->iotd_Req.io_Actual>sizeof(struct NSDeviceQueryResult)) ||
363 (volume->iotd->iotd_Req.io_Actual==0) ||
364 (volume->iotd->iotd_Req.io_Actual!=nsdq.SizeAvailable)
365 )
366 {
367 Printf("WARNING wrong io_Actual using NSD\n");
368 }
369 else
370 {
371 if (nsdq.DeviceType != NSDEVTYPE_TRACKDISK)
372 Printf("WARNING no trackdisk type\n");
373 for (cmdcheck=nsdq.SupportedCommands;*cmdcheck;cmdcheck++)
374 {
375 if (*cmdcheck == NSCMD_TD_READ64)
376 volume->readcommand = NSCMD_TD_READ64;
377 if (*cmdcheck == NSCMD_TD_WRITE64);
378 volume->writecommand = NSCMD_TD_WRITE64;
379 }
380 if (
381 (volume->readcommand!=NSCMD_TD_READ64) ||
382 (volume->writecommand!=NSCMD_TD_WRITE64)
383 )
384 Printf("WARNING no READ64/WRITE64\n");
385 }
386 }
387 }
388 }
389
390 struct Volume *initVolume(STRPTR drivename, IPTR use_mbr) {
391 struct Volume *volume=0;
392 struct FileSysStartupMsg *fssm;
393 struct DosList *dl;
394 struct DosEnvec *de;
395 struct DeviceNode *dn;
396 char dname[32];
397 UBYTE i;
398 ULONG error=0,retval;
399 STRPTR errstr=NULL;
400
401 for (i=0;(drivename[i]) && (drivename[i]!=':');i++)
402 dname[i]=drivename[i];
403 dname[i]=0;
404 dl = LockDosList(LDF_READ | LDF_DEVICES);
405 if (dl)
406 {
407 dn = (struct DeviceNode *)FindDosEntry(dl, dname, LDF_DEVICES);
408 UnLockDosList(LDF_READ | LDF_DEVICES);
409 if (dn)
410 {
411 if (IsFileSystem(drivename))
412 {
413 fssm = (struct FileSysStartupMsg *)BADDR(dn->dn_Startup);
414 if (use_mbr)
415 {
416 if (strcmp(AROS_BSTR_ADDR(fssm->fssm_Device),"ide.device")!=0)
417 {
418 error = ERROR_OBJECT_WRONG_TYPE;
419 errstr = AROS_BSTR_ADDR(fssm->fssm_Device);
420 }
421 else
422 {
423 if (fssm->fssm_Unit!=0)
424 {
425 error = ERROR_OBJECT_WRONG_TYPE;
426 errstr = "MBR can only be stored on the first HD";
427 }
428 }
429 }
430 if (error == 0)
431 {
432 volume = AllocVec(sizeof(struct Volume), MEMF_PUBLIC | MEMF_CLEAR);
433 if (volume)
434 {
435 volume->fssm = fssm;
436 volume->drivename = drivename;
437 volume->mp = CreateMsgPort();
438 if (volume->mp)
439 {
440 volume->iotd = (struct IOExtTD *)CreateIORequest(volume->mp, sizeof(struct IOExtTD));
441 if (volume->iotd)
442 {
443 de = BADDR(volume->fssm->fssm_Environ);
444 volume->SizeBlock = de->de_SizeBlock;
445 volume->blockbuffer = AllocVec(volume->SizeBlock*4, MEMF_PUBLIC | MEMF_CLEAR);
446 if (volume->blockbuffer)
447 {
448 if (
449 OpenDevice
450 (
451 AROS_BSTR_ADDR(volume->fssm->fssm_Device),
452 volume->fssm->fssm_Unit,
453 (struct IORequest *)&volume->iotd->iotd_Req,
454 volume->fssm->fssm_Flags
455 )==0
456 )
457 {
458 if (strcmp(AROS_BSTR_ADDR(volume->fssm->fssm_Device), "trackdisk.device") == 0)
459 volume->flags |= VF_IS_TRACKDISK;
460 volume->startblock =
461 de->de_LowCyl*
462 de->de_Surfaces*
463 de->de_BlocksPerTrack;
464 volume->countblock =
465 (
466 (
467 de->de_HighCyl-de->de_LowCyl+1
468 )*de->de_Surfaces*de->de_BlocksPerTrack
469 )-1+de->de_Reserved;
470 volume->readcommand = CMD_READ;
471 volume->writecommand = CMD_WRITE;
472 nsdCheck(volume);
473 retval = readwriteBlock
474 (
475 volume, 0,
476 volume->blockbuffer, 512, volume->readcommand
477 );
478 if (retval == 0)
479 {
480 if ((AROS_BE2LONG(volume->blockbuffer[0]) & 0xFFFFFF00)!=0x444F5300)
481 {
482 retval = readwriteBlock
483 (
484 volume, 1,
485 volume->blockbuffer, 512, volume->readcommand
486 );
487 }
488 else
489 volume->flags |= VF_MOVE_BB;
490 if (
491 ((AROS_BE2LONG(volume->blockbuffer[0]) & 0xFFFFFF00)==0x444F5300) &&
492 ((AROS_BE2LONG(volume->blockbuffer[0]) & 0xFF)>0)
493 )
494 {
495 return volume;
496 }
497 else
498 error = ERROR_NOT_A_DOS_DISK;
499 }
500 else
501 {
502 error = ERROR_UNKNOWN;
503 errstr = "Read Error";
504 }
505 }
506 else
507 {
508 error = ERROR_UNKNOWN;
509 errstr = "OpenDevice() Error";
510 }
511 FreeVec(volume->blockbuffer);
512 }
513 else
514 error = ERROR_NO_FREE_STORE;
515 }
516 else
517 error = ERROR_NO_FREE_STORE;
518 DeleteMsgPort(volume->mp);
519 }
520 else
521 error = ERROR_NO_FREE_STORE;
522 FreeVec(volume);
523 volume = 0;
524 }
525 else
526 error = ERROR_NO_FREE_STORE;
527 }
528 }
529 else
530 error = IoErr();
531 }
532 else
533 {
534 error = ERROR_OBJECT_NOT_FOUND;
535 errstr = dname;
536 }
537 }
538 else
539 {
540 error = ERROR_UNKNOWN;
541 errstr = "LockDosList Error";
542 }
543 PrintFault(error, errstr);
544 return 0;
545 }
546
547 void uninitVolume(struct Volume *volume) {
548
549 FreeVec(volume->blockbuffer);
550 CloseDevice((struct IORequest *)&volume->iotd->iotd_Req);
551 DeleteIORequest((struct IORequest *)volume->iotd);
552 DeleteMsgPort(volume->mp);
553 FreeVec(volume);
554 }
555
556 void checkBootCode(struct Volume *volume) {
557 Printf("CHECK not implemented yet\n");
558 }
559
560 void removeBootCode(struct Volume *volume) {
561 ULONG retval;
562
563 retval = readwriteBlock
564 (
565 volume, 1,
566 volume->blockbuffer, 512, volume->readcommand
567 );
568 if (retval)
569 Printf("ReadError %lu\n", (long)retval);
570 else
571 {
572 if ((AROS_BE2LONG(volume->blockbuffer[0]) & 0xFFFFFF00)==0x444F5300)
573 {
574 retval = readwriteBlock
575 (
576 volume, 0,
577 volume->blockbuffer, 512, volume->writecommand
578 );
579 if (retval)
580 Printf("WriteError %lu\n", (long)retval);
581 }
582 }
583 }
584
585 int main(void) {
586 IPTR myargs[5]={0,0,0,0,0};
587 struct RDArgs *rdargs;
588 struct Volume *volume;
589
590 rdargs = ReadArgs("DRIVE/A,NOBOOT/S,CHECK/S,FFS/S,MBR/S",myargs,NULL);
591 if (rdargs)
592 {
593 volume = initVolume((STRPTR)myargs[0], myargs[4]);
594 if (volume)
595 {
596 if (myargs[1])
597 removeBootCode(volume);
598 else if (myargs[2])
599 checkBootCode(volume);
600 else
601 installStageFiles(volume, myargs[4], volume->fssm->fssm_Unit);
602 uninitVolume(volume);
603 }
604 FreeArgs(rdargs);
605 }
606 else
607 PrintFault(IoErr(), NULL);
608 return 0;
609 }
610
Mirror of AROS' svn.