?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
added concrete implementations of putc(), getc(), getchar() and gets()
[tangerine.git] / workbench / c / install-i386-pc.c
blob4964d501067c0f6c054781dc7d7abefe9cc31e82
1 /*
2 Copyright © 1995-2007, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5 /******************************************************************************
6
7
8 NAME
9
10 Install-i386-pc
11
12 SYNOPSIS
13
14 DEVICE/A, UNIT/N/K/A, PARTITIONNUMBER=PN/K/N, GRUB/K/A, FORCELBA/S
15
16 LOCATION
17
18 SYS:C
19
20 FUNCTION
21
22 Installs the GRUB bootloader to the bootblock of the specified disk.
23
24 INPUTS
25
26 DEVICE -- Device name (eg. ata.device)
27 UNIT -- Unit number
28 PN -- Partition number (advice: the first AROS FFS partition)
29 GRUB -- Path to GRUB directory.
30 FORCELBA -- Force use of LBA mode.
31
32 RESULT
33
34 NOTES
35
36 EXAMPLE
37
38 install-i386-pc device ata.device unit 0 PN 1 grub dh0:boot/grub
39
40 BUGS
41
42 SEE ALSO
43
44 Partition, Format
45
46 INTERNALS
47
48 ******************************************************************************/
49
50 #include <stdio.h>
51 #include <string.h>
52 #include <proto/dos.h>
53 #include <proto/exec.h>
54 #include <proto/partition.h>
55 #include <aros/macros.h>
56 #include <devices/hardblocks.h>
57 #include <devices/newstyle.h>
58 #include <dos/dos.h>
59 #include <exec/errors.h>
60 #include <exec/memory.h>
61 #include <libraries/partition.h>
62
63 #define DEBUG 0
64 #include <aros/debug.h>
65
66 /* Defines for grub data */
67 /* Stage 1 pointers */
68 #define MBR_BPBEND 0x3e
69 #define GRUB_BOOT_DRIVE 0x40
70 #define GRUB_FORCE_LBA 0x41
71 #define GRUB_STAGE2_SECTOR 0x44
72 #define MBR_PARTSTART 0x1be
73 #define MBR_PARTEND 0x1fe
74 /* Stage 2 pointers */
75
76 /* BIOS drive flag */
77 #define BIOS_HDISK_FLAG 0x80
78
79 #define MBR_MAX_PARTITIONS 4
80 #define MBRT_EXTENDED 0x05
81 #define MBRT_EXTENDED2 0x0f
82
83 struct Volume {
84 struct MsgPort *mp;
85 struct IOExtTD *iotd;
86 ULONG readcmd;
87 ULONG writecmd;
88 ULONG startblock;
89 ULONG countblock;
90 ULONG unitnum;
91 UWORD SizeBlock;
92 UBYTE flags;
93 BYTE partnum;
94 ULONG *blockbuffer;
95 };
96
97 #define VF_IS_TRACKDISK (1<<0)
98 #define VF_IS_RDB (1<<1)
99
100 struct BlockNode {
101 ULONG sector;
102 UWORD count;
103 UWORD seg_adr;
104 };
105
106 char *template =
107 "DEVICE/A,"
108 "UNIT/N/K/A,"
109 "PARTITIONNUMBER=PN/K/N," /* Partition whose boot block we should install stage1 in */
110 "GRUB/K/A,"
111 "FORCELBA/S";
112 IPTR myargs[7] = {0,0,0,0,0,0};
113
114 struct FileSysStartupMsg *getDiskFSSM(STRPTR path) {
115 struct DosList *dl;
116 struct DeviceNode *dn;
117 char dname[32];
118 UBYTE i;
119
120 D(bug("[install-i386] getDiskFSSM('%s')\n", path));
121
122 for (i=0;(path[i]) && (path[i]!=':');i++)
123 dname[i] = path[i];
124 if (path[i] == ':')
125 {
126 dname[i] = 0;
127 dl = LockDosList(LDF_READ);
128 if (dl)
129 {
130 dn = (struct DeviceNode *)FindDosEntry(dl, dname, LDF_DEVICES);
131 UnLockDosList(LDF_READ);
132 if (dn)
133 {
134 if (IsFileSystem(dname))
135 {
136 return (struct FileSysStartupMsg *)BADDR(dn->dn_Startup);
137 }
138 else
139 printf("device '%s' doesn't contain a file system\n", dname);
140 }
141 else
142 PrintFault(ERROR_OBJECT_NOT_FOUND, dname);
143 }
144 }
145 else
146 printf("'%s' doesn't contain a device name\n",path);
147 return 0;
148 }
149
150 void fillGeometry(struct Volume *volume, struct DosEnvec *de) {
151 ULONG spc;
152
153 D(bug("[install-i386] fillGeometry(%x)\n", volume));
154
155 spc = de->de_Surfaces*de->de_BlocksPerTrack;
156 volume->SizeBlock = de->de_SizeBlock;
157 volume->startblock = de->de_LowCyl*spc;
158 volume->countblock =((de->de_HighCyl-de->de_LowCyl+1)*spc)-1+de->de_Reserved;
159 }
160
161 void nsdCheck(struct Volume *volume) {
162 struct NSDeviceQueryResult nsdq;
163 UWORD *cmdcheck;
164
165 D(bug("[install-i386] nsdCheck(%x)\n", volume));
166
167 if (
168 (
169 (volume->startblock+volume->countblock)* /* last block */
170 ((volume->SizeBlock<<2)/512) /* 1 portion (block) equals 512 (bytes) */
171 )>8388608)
172 {
173 nsdq.SizeAvailable=0;
174 nsdq.DevQueryFormat=0;
175 volume->iotd->iotd_Req.io_Command=NSCMD_DEVICEQUERY;
176 volume->iotd->iotd_Req.io_Data=&nsdq;
177 volume->iotd->iotd_Req.io_Length=sizeof(struct NSDeviceQueryResult);
178 if (DoIO((struct IORequest *)&volume->iotd->iotd_Req)==IOERR_NOCMD)
179 {
180 printf("Device doesn't understand NSD-Query\n");
181 }
182 else
183 {
184 if (
185 (volume->iotd->iotd_Req.io_Actual>sizeof(struct NSDeviceQueryResult)) ||
186 (volume->iotd->iotd_Req.io_Actual==0) ||
187 (volume->iotd->iotd_Req.io_Actual!=nsdq.SizeAvailable)
188 )
189 {
190 printf("WARNING wrong io_Actual using NSD\n");
191 }
192 else
193 {
194 if (nsdq.DeviceType != NSDEVTYPE_TRACKDISK)
195 printf("WARNING no trackdisk type\n");
196 for (cmdcheck=nsdq.SupportedCommands;*cmdcheck;cmdcheck++)
197 {
198 if (*cmdcheck == NSCMD_TD_READ64)
199 volume->readcmd = NSCMD_TD_READ64;
200 if (*cmdcheck == NSCMD_TD_WRITE64);
201 volume->writecmd = NSCMD_TD_WRITE64;
202 }
203 if (
204 (volume->readcmd!=NSCMD_TD_READ64) ||
205 (volume->writecmd!=NSCMD_TD_WRITE64)
206 )
207 printf("WARNING no READ64/WRITE64\n");
208 }
209 }
210 }
211 }
212
213
214 struct Volume *initVolume(STRPTR device, ULONG unit, ULONG flags, struct DosEnvec *de) {
215 struct Volume *volume;
216 LONG error=0;
217
218 D(bug("[install-i386] initVolume(%s:%d)\n", device, unit));
219
220 volume = AllocVec(sizeof(struct Volume), MEMF_PUBLIC | MEMF_CLEAR);
221 if (volume)
222 {
223 volume->mp = CreateMsgPort();
224 if (volume->mp)
225 {
226 volume->iotd = (struct IOExtTD *)CreateIORequest(volume->mp, sizeof(struct IOExtTD));
227 if (volume->iotd)
228 {
229 volume->blockbuffer = AllocVec(de->de_SizeBlock<<2, MEMF_PUBLIC | MEMF_CLEAR);
230 if (volume->blockbuffer)
231 {
232 if (
233 OpenDevice
234 (
235 device,
236 unit,
237 (struct IORequest *)volume->iotd,
238 flags
239 ) == 0
240 )
241 {
242 if (strcmp(device, "trackdisk.device")==0)
243 volume->flags |= VF_IS_TRACKDISK;
244 else
245 volume->flags |= VF_IS_RDB; /* just assume we have RDB */
246 volume->readcmd = CMD_READ;
247 volume->writecmd = CMD_WRITE;
248 volume->unitnum = unit;
249 fillGeometry(volume, de);
250 nsdCheck(volume);
251 return volume;
252 }
253 else
254 error = ERROR_NO_FREE_STORE;
255 FreeVec(volume->blockbuffer);
256 }
257 else
258 error = ERROR_NO_FREE_STORE;
259 DeleteIORequest((struct IORequest *)volume->iotd);
260 }
261 else
262 error = ERROR_NO_FREE_STORE;
263 DeleteMsgPort(volume->mp);
264 }
265 else
266 error = ERROR_NO_FREE_STORE;
267 FreeVec(volume);
268 }
269 else
270 error = ERROR_NO_FREE_STORE;
271 PrintFault(error, NULL);
272 return 0;
273 }
274
275 void uninitVolume(struct Volume *volume)
276 {
277
278 D(bug("[install-i386] uninitVolume(%x)\n", volume));
279
280 CloseDevice((struct IORequest *)volume->iotd);
281 FreeVec(volume->blockbuffer);
282 DeleteIORequest((struct IORequest *)volume->iotd);
283 DeleteMsgPort(volume->mp);
284 FreeVec(volume);
285 }
286
287 ULONG readwriteBlock
288 (
289 struct Volume *volume,
290 ULONG block, APTR buffer, ULONG length,
291 ULONG command
292 )
293 {
294 UQUAD offset;
295 ULONG retval=0;
296
297 D(bug("[install-i386] readwriteBlock(vol:%x, block:%d, %d bytes)\n", volume, block, length));
298
299 volume->iotd->iotd_Req.io_Command = command;
300 volume->iotd->iotd_Req.io_Length = length;
301 volume->iotd->iotd_Req.io_Data = buffer;
302 offset = (UQUAD)(volume->startblock+block)*(volume->SizeBlock<<2);
303 volume->iotd->iotd_Req.io_Offset = offset & 0xFFFFFFFF;
304 volume->iotd->iotd_Req.io_Actual = offset>>32;
305 retval = DoIO((struct IORequest *)&volume->iotd->iotd_Req);
306 if (volume->flags & VF_IS_TRACKDISK)
307 {
308 volume->iotd->iotd_Req.io_Command = TD_MOTOR;
309 volume->iotd->iotd_Req.io_Length = 0;
310 DoIO((struct IORequest *)&volume->iotd->iotd_Req);
311 }
312 return retval;
313 }
314
315 BOOL isvalidFileSystem(struct Volume *volume, STRPTR device, ULONG unit) {
316 BOOL retval = FALSE;
317 struct PartitionBase *PartitionBase;
318 struct PartitionHandle *ph;
319
320 D(bug("[install-i386] isvalidFileSystem(%x, %s, %d)\n", volume, device, unit));
321
322 if (readwriteBlock(volume, 0, volume->blockbuffer, 512, volume->readcmd))
323 {
324 printf("Read Error\n");
325 return FALSE;
326 }
327 if (
328 ((AROS_BE2LONG(volume->blockbuffer[0]) & 0xFFFFFF00)!=0x444F5300) ||
329 ((AROS_BE2LONG(volume->blockbuffer[0]) & 0xFF) == 0)
330 )
331 {
332 /* first block has no DOS\x so we don't have RDB for sure */
333 volume->flags &= ~VF_IS_RDB;
334 if (readwriteBlock(volume, 1, volume->blockbuffer, 512, volume->readcmd))
335 {
336 printf("Read Error\n");
337 return FALSE;
338 }
339 if (
340 ((AROS_BE2LONG(volume->blockbuffer[0]) & 0xFFFFFF00)!=0x444F5300) ||
341 ((AROS_BE2LONG(volume->blockbuffer[0]) & 0xFF) == 0)
342 )
343 return FALSE;
344 }
345 volume->partnum = -1;
346 PartitionBase = (struct PartitionBase *)OpenLibrary("partition.library", 1);
347 if (PartitionBase)
348 {
349 ph = OpenRootPartition(device, unit);
350 if (ph)
351 {
352 if (OpenPartitionTable(ph) == 0)
353 {
354 struct TagItem tags[3];
355 IPTR type;
356
357 tags[1].ti_Tag = TAG_DONE;
358 tags[0].ti_Tag = PTT_TYPE;
359 tags[0].ti_Data = (STACKIPTR)&type;
360 GetPartitionTableAttrs(ph, tags);
361 if (type == PHPTT_MBR)
362 {
363 struct PartitionHandle *pn;
364 struct DosEnvec de;
365 struct PartitionHandle *extph = NULL;
366 struct PartitionType ptype = {0};
367
368 tags[0].ti_Tag = PT_DOSENVEC;
369 tags[0].ti_Data = (STACKIPTR)&de;
370 tags[1].ti_Tag = PT_TYPE;
371 tags[1].ti_Data = (STACKIPTR)&ptype;
372 tags[2].ti_Tag = TAG_DONE;
373 pn = (struct PartitionHandle *)ph->table->list.lh_Head;
374 while (pn->ln.ln_Succ)
375 {
376 ULONG scp;
377
378 GetPartitionAttrs(pn, tags);
379 if (ptype.id[0] == MBRT_EXTENDED || ptype.id[0] == MBRT_EXTENDED2)
380 extph = pn;
381 else
382 {
383 scp = de.de_Surfaces*de.de_BlocksPerTrack;
384 if (
385 (volume->startblock>=(de.de_LowCyl*scp)) &&
386 (volume->startblock<=(((de.de_HighCyl+1)*scp)-1))
387 )
388 break;
389 }
390 pn = (struct PartitionHandle *)pn->ln.ln_Succ;
391 }
392 if (pn->ln.ln_Succ)
393 {
394 tags[0].ti_Tag = PT_POSITION;
395 tags[0].ti_Data = (STACKIPTR)&type;
396 tags[1].ti_Tag = TAG_DONE;
397 GetPartitionAttrs(pn, tags);
398 volume->partnum = (UBYTE)type;
399 retval = TRUE;
400 D(bug("[install-i386] Primary partition found: partnum=%ld\n", volume->partnum));
401 }
402 else if (extph != NULL)
403 {
404 if (OpenPartitionTable(extph) == 0)
405 {
406 tags[0].ti_Tag = PTT_TYPE;
407 tags[0].ti_Data = (STACKIPTR)&type;
408 tags[1].ti_Tag = TAG_DONE;
409 GetPartitionTableAttrs(extph, tags);
410 if (type == PHPTT_EBR)
411 {
412 tags[0].ti_Tag = PT_DOSENVEC;
413 tags[0].ti_Data = (STACKIPTR)&de;
414 tags[1].ti_Tag = TAG_DONE;
415 pn = (struct PartitionHandle *)extph->table->list.lh_Head;
416 while (pn->ln.ln_Succ)
417 {
418 ULONG offset, scp;
419
420 offset = extph->de.de_LowCyl
421 * extph->de.de_Surfaces
422 * extph->de.de_BlocksPerTrack;
423 GetPartitionAttrs(pn, tags);
424 scp = de.de_Surfaces*de.de_BlocksPerTrack;
425 if (
426 (volume->startblock>=offset+(de.de_LowCyl*scp)) &&
427 (volume->startblock<=offset+(((de.de_HighCyl+1)*scp)-1))
428 )
429 break;
430 pn = (struct PartitionHandle *)pn->ln.ln_Succ;
431 }
432 if (pn->ln.ln_Succ)
433 {
434 tags[0].ti_Tag = PT_POSITION;
435 tags[0].ti_Data = (STACKIPTR)&type;
436 GetPartitionAttrs(pn, tags);
437 volume->partnum = MBR_MAX_PARTITIONS + (UBYTE)type;
438 retval = TRUE;
439 D(bug("[install-i386] Logical partition found: partnum=%ld\n", volume->partnum));
440 }
441 }
442 ClosePartitionTable(extph);
443 }
444 }
445 }
446 else
447 {
448 if (type == PHPTT_RDB)
449 {
450 /* just use whole hard disk */
451 retval = TRUE;
452 }
453 else
454 printf("only MBR and RDB partition tables are supported\n");
455 }
456 ClosePartitionTable(ph);
457 }
458 else
459 {
460 /* just use whole hard disk */
461 retval = TRUE;
462 }
463 CloseRootPartition(ph);
464 }
465 else
466 printf("Error OpenRootPartition(%s,%ld)\n", device, unit);
467 CloseLibrary((struct Library *)PartitionBase);
468 }
469 else
470 printf("Couldn't open partition.library\n");
471 return retval;
472 }
473
474 struct Volume *getGrubStageVolume
475 (
476 STRPTR device,
477 ULONG unit,
478 ULONG flags,
479 struct DosEnvec *de
480 )
481 {
482 struct Volume *volume;
483
484 volume = initVolume(device, unit, flags, de);
485
486 D(bug("[install-i386] getGrubStageVolume(): volume=%x\n", volume));
487
488 if (volume)
489 {
490 if (isvalidFileSystem(volume, device, unit))
491 return volume;
492 else
493 {
494 printf("stage2 is on an unsupported file system\n");
495 PrintFault(ERROR_OBJECT_WRONG_TYPE, NULL);
496 }
497 uninitVolume(volume);
498 }
499 return 0;
500 }
501
502 BOOL isvalidPartition
503 (
504 STRPTR device,
505 ULONG unit,
506 LONG *pnum,
507 struct DosEnvec *de
508 )
509 {
510 struct PartitionBase *PartitionBase;
511 struct PartitionHandle *ph;
512 ULONG type;
513 BOOL retval=FALSE;
514
515 D(bug("[install-i386] isvalidPartition(%s:%d, part:%d)\n", device, unit, pnum));
516
517 PartitionBase = (struct PartitionBase *)OpenLibrary("partition.library", 1);
518 if (PartitionBase)
519 {
520 ph = OpenRootPartition(device, unit);
521 if (ph)
522 {
523 struct TagItem tags[2];
524
525 tags[1].ti_Tag = TAG_DONE;
526 /* is there a partition table? */
527 if (OpenPartitionTable(ph) == 0)
528 {
529 if (pnum)
530 {
531 /* install into partition bootblock */
532 tags[0].ti_Tag = PTT_TYPE;
533 tags[0].ti_Data = (STACKIPTR)&type;
534 GetPartitionTableAttrs(ph, tags);
535 if (type == PHPTT_MBR)
536 {
537 struct PartitionHandle *pn;
538
539 /* search for partition */
540 tags[0].ti_Tag = PT_POSITION;
541 tags[0].ti_Data = (STACKIPTR)&type;
542 pn = (struct PartitionHandle *)ph->table->list.lh_Head;
543 while (pn->ln.ln_Succ)
544 {
545 GetPartitionAttrs(pn, tags);
546 if (type == *pnum)
547 break;
548 pn = (struct PartitionHandle *)pn->ln.ln_Succ;
549 }
550 if (pn->ln.ln_Succ)
551 {
552 struct PartitionType ptype;
553
554 /* is it an AROS partition? */
555 tags[0].ti_Tag = PT_TYPE;
556 tags[0].ti_Data = (STACKIPTR)&ptype;
557 GetPartitionAttrs(pn, tags);
558 if (ptype.id[0] == 0x30)
559 {
560 tags[0].ti_Tag = PT_DOSENVEC;
561 tags[0].ti_Data = (STACKIPTR)de;
562 GetPartitionAttrs(pn, tags);
563 retval = TRUE;
564 }
565 else
566 printf("partition is not of type AROS (0x30)\n");
567 }
568 else
569 {
570 printf
571 (
572 "partition %ld not found on device %s unit %ld\n",
573 *pnum, device, unit
574 );
575 }
576 }
577 else
578 printf("you can only install in partitions which are MBR partitioned\n");
579 }
580 else
581 {
582 /* install into MBR */
583 tags[0].ti_Tag = PTT_TYPE;
584 tags[0].ti_Data = (STACKIPTR)&type;
585 GetPartitionTableAttrs(ph, tags);
586 if ((type == PHPTT_MBR) || (type == PHPTT_RDB))
587 {
588 tags[0].ti_Tag = PT_DOSENVEC;
589 tags[0].ti_Data = (STACKIPTR)de;
590 GetPartitionAttrs(ph, tags);
591 retval = TRUE;
592 }
593 else
594 printf("partition table type must be either MBR or RDB\n");
595 }
596 ClosePartitionTable(ph);
597 }
598 else
599 {
600 #warning "FIXME: GetPartitionAttr() should always work for root partition"
601 CopyMem(&ph->de, de, sizeof(struct DosEnvec));
602 retval = TRUE;
603 }
604 CloseRootPartition(ph);
605 }
606 else
607 printf("Error OpenRootPartition(%s,%ld)\n", device, unit);
608 CloseLibrary((struct Library *)PartitionBase);
609 }
610 else
611 printf("Couldn't open partition.library\n");
612 return retval;
613 }
614
615 struct Volume *getBBVolume(STRPTR device, ULONG unit, LONG *partnum) {
616 struct Volume *volume;
617 struct DosEnvec de;
618
619 D(bug("[install-i386] getBBVolume(%s:%d, %d)\n", device, unit, partnum));
620
621 if (isvalidPartition(device, unit, partnum, &de))
622 {
623 volume = initVolume(device, unit, 0, &de);
624 volume->partnum = partnum ? *partnum : -1;
625 readwriteBlock(volume, 0, volume->blockbuffer, 512, volume->readcmd);
626 if (AROS_BE2LONG(volume->blockbuffer[0]) != IDNAME_RIGIDDISK)
627 {
628 memset(volume->blockbuffer,0x00, 446); /* Clear the boot sector region! */
629 return volume;
630 }
631 else
632 printf("no space for bootblock (RDB is on block 0)\n");
633 }
634 return NULL;
635 }
636
637 ULONG collectBlockList
638 (
639 struct Volume *volume,
640 ULONG block,
641 struct BlockNode *blocklist
642 )
643 {
644 ULONG retval, first_block;
645 WORD blk_count,count;
646 UWORD i;
647
648 D(bug("[install-i386] collectBlockList(%x, %d, %x)\n", volume, block, blocklist));
649
650 #warning "TODO: logical/physical blocks"
651 /*
652 initialze stage2-blocklist
653 (it is NULL-terminated)
654 */
655 // for (blk_count=-1;blocklist[blk_count].sector!=0;blk_count--)
656 // blocklist[blk_count].sector = 0;
657
658 memset((char *)&blocklist[-20],0x00, 20*sizeof(struct BlockNode)); /* Clear the stage2 sector pointers region! */
659 D(bug("[install-i386] collectBlockList: Cleared sector list (20 entries) [start: %x, end %x]\n", &blocklist[-20], &blocklist[-1]));
660
661 /*
662 the first block of stage2 will be stored in stage1
663 so skip the first filekey in the first loop
664 */
665 #warning "Block read twice"
666 retval=readwriteBlock
667 (
668 volume, block, volume->blockbuffer, volume->SizeBlock<<2,
669 volume->readcmd
670 );
671 if (retval)
672 {
673 D(bug("[install-i386] collectBlockList: ERROR reading block (error: %ld\n", retval));
674 printf("ReadError %ld\n", retval);
675 return 0;
676 }
677
678 i = volume->SizeBlock - 52;
679 first_block = AROS_BE2LONG(volume->blockbuffer[volume->SizeBlock-51]);
680 blk_count=0;
681
682 D(bug("[install-i386] collectBlockList: First block @ %x, i:%d\n", first_block, i));
683
684
685 do
686 {
687 retval=readwriteBlock
688 (
689 volume, block, volume->blockbuffer, volume->SizeBlock<<2,
690 volume->readcmd
691 );
692 if (retval)
693 {
694 D(bug("[install-i386] collectBlockList: ERROR reading block (error: %ld)\n", retval));
695 printf("ReadError %ld\n", retval);
696 return 0;
697 }
698 D(bug("[install-i386] collectBlockList: read block %lx, i = %d\n", block, i));
699 while ((i>=6) && (volume->blockbuffer[i]))
700 {
701 D(bug("[install-i386] collectBlockList: i = %d\n", i));
702 /*
703 if current sector follows right after last sector
704 then we don't need a new element
705 */
706 if (
707 (blocklist[blk_count].sector) &&
708 ((blocklist[blk_count].sector+blocklist[blk_count].count)==
709 AROS_BE2LONG(volume->blockbuffer[i]))
710 )
711 {
712 blocklist[blk_count].count += 1;
713 D(bug("[install-i386] collectBlockList: sector %d follows previous - increasing count of block %d to %d\n", i, blk_count, blocklist[blk_count].count));
714 }
715 else
716 {
717 blk_count--; /* decrement first */
718 D(bug("[install-i386] collectBlockList: store new block (%d)\n", blk_count));
719 if (blocklist[blk_count-1].sector != 0)
720 {
721 D(bug("[install-i386] collectBlockList: ERROR: out of block space at sector %d, block %d\n", i, blk_count));
722 printf("There is no more space to save blocklist in stage2\n");
723 return 0;
724 }
725 D(bug("[install-i386] collectBlockList: storing sector pointer for %d in block %d\n", i, blk_count));
726 blocklist[blk_count].sector = AROS_BE2LONG(volume->blockbuffer[i]);
727 blocklist[blk_count].count = 1;
728 }
729 i--;
730 }
731 i = volume->SizeBlock - 51;
732 block = AROS_BE2LONG(volume->blockbuffer[volume->SizeBlock - 2]);
733 D(bug("[install-i386] collectBlockList: next block %d, i = %d\n", block, i));
734 } while (block);
735 /*
736 blocks in blocklist are relative to the first
737 sector of the HD (not partition)
738 */
739 D(bug("[install-i386] collectBlockList: successfully updated pointers for %d blocks\n", blk_count));
740
741 i = 0;
742 for (count=-1;count>=blk_count;count--)
743 {
744 blocklist[count].sector += volume->startblock;
745 blocklist[count].seg_adr = 0x820 + (i*32);
746 i += blocklist[count].count;
747 D(bug("[install-i386] collectBlockList: correcting block %d for partition start\n", count));
748 D(bug("[install-i386] collectBlockList: sector : %x seg_adr : %x\n", blocklist[count].sector, blocklist[count].seg_adr));
749 }
750 return first_block;
751 }
752
753 void copyRootPath(char *dst, char *rpdos, BOOL isRDB) {
754
755 D(bug("[install-i386] copyRootPath()\n"));
756
757 if (isRDB)
758 {
759 /* we have an RDB so use devicename */
760 *dst++ = '/';
761 while ((*rpdos) && (*rpdos!=':'))
762 *dst++ = *rpdos++;
763 }
764 else
765 {
766 while ((*rpdos) && (*rpdos!=':'))
767 rpdos++;
768 }
769 rpdos++; /* skip colon */
770 *dst++ = '/';
771 /* append path */
772 while (*rpdos)
773 *dst++ = *rpdos++;
774 if (dst[-1] == '/')
775 dst[-1] = 0;
776 else
777 *dst = 0;
778 }
779
780 UBYTE *memstr(UBYTE *mem, UBYTE *str, LONG len) {
781 UBYTE *next;
782 UBYTE *search;
783 LONG left;
784
785 while (len)
786 {
787 len--;
788 if (*mem++ == *str)
789 {
790 next = mem;
791 search = str+1;
792 left = len;
793 while ((*search) && (left) && (*next++ == *search++))
794 left--;
795 if (*search == 0)
796 return mem-1;
797 }
798 }
799 return 0;
800 }
801
802 BOOL writeStage2
803 (
804 BPTR fh,
805 UBYTE *buffer,
806 STRPTR grubpath,
807 struct Volume *volume
808 )
809 {
810 BOOL retval = FALSE;
811 char *menuname;
812
813 D(bug("[install-i386] writeStage2(%x)\n", volume));
814
815 if (Seek(fh, 0, OFFSET_BEGINNING) != -1)
816 {
817 /* write back first block */
818 if (Write(fh, buffer, 512)==512)
819 {
820 /* read second stage2 block */
821 if (Read(fh, buffer, 512) == 512)
822 {
823 /* set partition number where stage2 is on */
824 buffer[8] = 0xFF;
825 buffer[9] = 0xFF;
826 buffer[10] = volume->partnum;
827 buffer[11] = 0;
828 /* get ptr to version string */
829 menuname = buffer+18;
830 while (*menuname++); /* skip version string */
831 copyRootPath(menuname, grubpath, volume->flags & VF_IS_RDB);
832 strcat(menuname, "/menu.lst");
833 /* write second stage2 block back */
834 if (Seek(fh, -512, OFFSET_CURRENT) != -1)
835 {
836 if (Write(fh, buffer, 512) == 512)
837 {
838 retval = TRUE;
839 }
840 else
841 printf("%s: Write Error\n", menuname);
842 }
843 else
844 printf("%s: Seek Error\n", menuname);
845 }
846 else
847 printf("Read Error\n");
848 }
849 else
850 printf("Write Error\n");
851 }
852 else
853 PrintFault(IoErr(), NULL);
854 return retval;
855 }
856
857 ULONG changeStage2
858 (
859 STRPTR grubpath, /* path of grub dir */
860 struct Volume *volume, /* volume stage2 is on */
861 ULONG *buffer /* a buffer of at least 512 bytes */
862 )
863 {
864 ULONG block = 0;
865 struct FileInfoBlock fib;
866 BPTR fh;
867 char stage2path[256];
868
869 D(bug("[install-i386] changeStage2(%x)\n", volume));
870
871 AddPart(stage2path, grubpath, 256);
872 AddPart(stage2path, "stage2", 256);
873 fh = Open(stage2path, MODE_OLDFILE);
874 if (fh)
875 {
876 if (Examine(fh, &fib))
877 {
878 if (Read(fh, buffer, 512) == 512)
879 {
880 /*
881 get and store all blocks of stage2 in first block of stage2
882 first block of stage2 will be returned
883 */
884 block = collectBlockList
885 (volume, fib.fib_DiskKey, (struct BlockNode *)&buffer[128]);
886
887 if (block)
888 {
889 if (!writeStage2(fh, (UBYTE *)buffer, grubpath, volume))
890 block = 0;
891 }
892 }
893 else
894 printf("%s: Read Error\n", stage2path);
895 }
896 else
897 PrintFault(IoErr(), stage2path);
898 Close(fh);
899 }
900 else
901 PrintFault(IoErr(), stage2path);
902 return block;
903 }
904
905 BOOL writeStage1
906 (
907 STRPTR stage1path,
908 struct Volume *volume,
909 struct Volume *s2vol,
910 ULONG block, /* first block of stage2 file */
911 ULONG unit
912 )
913 {
914 BOOL retval = FALSE;
915 LONG error = 0;
916 BPTR fh;
917
918 D(bug("[install-i386] writeStage1(%x)\n", volume));
919
920 fh = Open(stage1path, MODE_OLDFILE);
921 if (fh)
922 {
923 if (Read(fh, volume->blockbuffer, 512) == 512)
924 {
925 /* install into MBR ? */
926 if ((volume->startblock == 0) && (!(volume->flags & VF_IS_TRACKDISK)))
927 {
928 D(bug("[install-i386] writeStage1: Install to HARDDISK\n"));
929 // read old MBR
930 error = readwriteBlock
931 (volume, 0, s2vol->blockbuffer, 512, volume->readcmd);
932
933 D(bug("[install-i386] writeStage1: MBR Buffer @ %x\n", volume->blockbuffer));
934 D(bug("[install-i386] writeStage1: Copying MBR BPB to %x\n", (char *)volume->blockbuffer + 0x04));
935 // copy BPB (BIOS Parameter Block)
936 CopyMem
937 (
938 (APTR)((char *)s2vol->blockbuffer + 0x04),
939 (APTR)((char *)volume->blockbuffer + 0x04),
940 (MBR_BPBEND - 4)
941 );
942 // copy partition table - [Overwrites Floppy boot code]
943 D(bug("[install-i386] writeStage1: Copying MBR Partitions to %x\n", (char *)volume->blockbuffer + MBR_PARTSTART));
944 CopyMem
945 (
946 (APTR)((char *)s2vol->blockbuffer + MBR_PARTSTART),
947 (APTR)((char *)volume->blockbuffer + MBR_PARTSTART),
948 (MBR_PARTEND - MBR_PARTSTART)
949 );
950 // store the drive num stage2 is stored on
951 ((char *)volume->blockbuffer)[GRUB_BOOT_DRIVE] = unit + BIOS_HDISK_FLAG;
952 // Store the stage 2 pointer ..
953 ULONG * stage2_sector_start = (ULONG *)((char *)volume->blockbuffer + GRUB_STAGE2_SECTOR);
954 D(bug("[install-i386] writeStage1: writing stage2 pointer @ %x\n", stage2_sector_start));
955 stage2_sector_start[0] = block;
956 D(bug("[install-i386] writeStage1: stage2 pointer = %x\n", stage2_sector_start[0]));
957 stage2_sector_start[0] += s2vol->startblock;
958 D(bug("[install-i386] writeStage1: + offset [%d] = %x\n", s2vol->startblock, stage2_sector_start[0]));
959
960 if (myargs[4]!=0)
961 {
962 D(bug("[install-i386] writeStage1: Forcing LBA\n"));
963 ((char *)volume->blockbuffer)[GRUB_FORCE_LBA] = 1;
964 }
965 else
966 {
967 D(bug("[install-i386] writeStage1: NOT Forcing LBA\n"));
968 ((char *)volume->blockbuffer)[GRUB_FORCE_LBA] = 0;
969 }
970 }
971 else
972 {
973 D(bug("[install-i386] writeStage1: Install to FLOPPY\n"));
974 }
975
976 if (error == 0)
977 {
978 error = readwriteBlock
979 (volume, 0, volume->blockbuffer, 512, volume->writecmd);
980 if (error)
981 printf("WriteError %ld\n", error);
982 else
983 retval = TRUE;
984 }
985 else
986 printf("WriteError %ld\n", error);
987 }
988 else
989 printf("%s: Read Error\n", stage1path);
990 Close(fh);
991 }
992 else
993 PrintFault(IoErr(), stage1path);
994 return retval;
995 }
996
997 /* Flushes the cache on the volume containing the specified path. */
998 VOID flushFS(CONST TEXT *path)
999 {
1000 char devname[256];
1001 UWORD i;
1002
1003 for (i = 0; path[i] != ':'; i++)
1004 devname[i] = path[i];
1005 devname[i++] = ':';
1006 devname[i] = '\0';
1007 if (Inhibit(devname, DOSTRUE))
1008 Inhibit(devname, DOSFALSE);
1009 }
1010
1011 BOOL installStageFiles
1012 (
1013 struct Volume *s2vol, /* stage2 volume */
1014 STRPTR stagepath, /* path to stage* files */
1015 ULONG unit, /* unit stage2 is on */
1016 struct Volume *s1vol /* device on which stage1 will be stored */
1017 )
1018 {
1019 BOOL retval = FALSE;
1020 char stagename[256];
1021 ULONG block;
1022
1023 D(bug("[install-i386] installStageFiles(%x)\n", s1vol));
1024
1025 /* Flush GRUB volume's cache */
1026 flushFS(stagepath);
1027
1028 block = changeStage2(stagepath, s2vol, s1vol->blockbuffer);
1029 if (block)
1030 {
1031 AddPart(stagename, stagepath, 256);
1032 AddPart(stagename, "stage1", 256);
1033 if (writeStage1(stagename, s1vol, s2vol, block, unit))
1034 retval = TRUE;
1035 }
1036 return retval;
1037 }
1038
1039 int main(int argc, char **argv) {
1040
1041 struct RDArgs *rdargs;
1042 struct Volume *grubvol;
1043 struct Volume *bbvol;
1044 struct FileSysStartupMsg *fssm;
1045
1046 D(bug("[install-i386] main()\n"));
1047
1048 rdargs = ReadArgs(template, myargs, NULL);
1049 if (rdargs)
1050 {
1051 D(bug("[install-i386] FORCELBA = %d\n",myargs[4]));
1052
1053 fssm = getDiskFSSM((STRPTR)myargs[3]);
1054 if (fssm != NULL)
1055 {
1056 if (
1057 (strcmp(AROS_BSTR_ADDR(fssm->fssm_Device),(char*)myargs[0])==0)
1058 )
1059 {
1060 grubvol = getGrubStageVolume
1061 (
1062 AROS_BSTR_ADDR(fssm->fssm_Device),
1063 fssm->fssm_Unit,
1064 fssm->fssm_Flags,
1065 (struct DosEnvec *)BADDR(fssm->fssm_Environ)
1066 );
1067 if (grubvol)
1068 {
1069 bbvol=getBBVolume
1070 (
1071 (STRPTR)myargs[0],
1072 *((LONG *)myargs[1]),
1073 (LONG *)myargs[2]
1074 );
1075 if (bbvol)
1076 {
1077 ULONG retval=0;
1078 /*
1079 getBBVolume() read block 0
1080 if the partition directly contains a filesystem
1081 (currently only DOS\x is supported) we have
1082 to move block 0 to block 1 to make space for stage1
1083 */
1084 if (
1085 (grubvol->startblock == bbvol->startblock) &&
1086 ((AROS_BE2LONG(bbvol->blockbuffer[0]) & 0xFFFFFF00)==0x444F5300)
1087 )
1088 {
1089 grubvol->flags &= ~VF_IS_RDB;
1090 retval = readwriteBlock
1091 (bbvol, 0, bbvol->blockbuffer, 512, bbvol->readcmd);
1092 }
1093 if (retval == 0)
1094 {
1095 installStageFiles
1096 (
1097 grubvol,
1098 (STRPTR)myargs[3], /* grub path (stage1/2) */
1099 fssm->fssm_Unit,
1100 bbvol
1101 );
1102 }
1103 else
1104 printf("Read Error: %ld\n", retval);
1105 uninitVolume(bbvol);
1106 }
1107 uninitVolume(grubvol);
1108 }
1109 }
1110 else
1111 {
1112 printf
1113 (
1114 "%s is not on device %s unit %ld\n",
1115 (STRPTR)myargs[3], (STRPTR)myargs[0], *((LONG *)myargs[1])
1116 );
1117 }
1118 }
1119 else
1120 if (fssm)
1121 printf("kernel path must begin with a device name\n");
1122 FreeArgs(rdargs);
1123 }
1124 else
1125 PrintFault(IoErr(), argv[0]);
1126 return 0;
1127 }
1128
A totally sweet operating system