Il modo più semplice è quello di prendere uno dei kernel precompilati distribuiti con la Slackware dal più vicino mirror site. I kernel della Slackware sono generici e includono il numero maggiore di driver per tutti i device possibili, e quindi se avete un controller SCSI o IDE, è probabile che il driver adatto sia incluso nel kernel della Slackware.
Andate nella directory a1 e selezionate il kernel IDE o SCSI
a seconda del controller che avete. Controllate il file
xxxxkern.cfg per il kernel scelto e controllate quali driver sono
stati inclusi nel kernel. Se il device che volete è in quella lista,
allora il kernel corrispondente dovrebbe essere in grado di far
partire il vostro computer. Scaricate il file xxxxkern.tgz e
copiatelo nel vostro disco di boot che è descritto sopra
nella sezione su come costruire un disco di boot.
Dovete poi controllare il root device nel kernel, usando il comando rdev:
rdev zImage
/dev/sda2,
ma la mia partizione scsi root è /dev/sda8. Per usare un disco
root, dovete usare questo comando:
rdev zImage /dev/fd0
Copiate il kernel sul vostro disco di boot usando il comando dd per un disco di boot senza file system, o il comando cp per un disco boot/root. Fate riferimento alla sezione intitolata ``Boot'' per maggiori dettagli.
Questa non è propriamente un argomento riguardante i dischi di boot, ma è fatta così spesso... La risposta è, usate il comando DOS:
FDISK /MBR
Potete usare anche il comando dd per copiare il backup salvato dal LILO del boot sector vecchio sul boot sector nuovo - fate riferimento alla documentazione del LILO se intendete usare questo metodo.
Se non avete un boot disk, allora la cosa più semplice da fare è procurarsi un kernel adatto dalla Slackware come descritto prima nella sezione ``Come creo un disco di boot con il driver XXX?''. Potete quindi far partire il computer usando questo kernel, e poi riparare qualunque danno sia successo.
Il kernel che avete preso potrebbe non avere il root device settato con il tipo di disco e la partizione che voi volete. Per esempio, i kernel generici della Slackware per gli scsi hanno il root device settato a /dev/sda2, quando, invece, la mia partizione Linux si trova in /dev/sda8. In questo caso il root device del kernel deve essere cambiato.
Potete cambiare il root device e i settaggi del ramdisk nel kernel anche se tutto ciò che avete è un kernel, e qualche altro sistema operativo come il DOS.
Rdev cambia i parametri del kernel cambiando i valori in appositi punti del file immagine del kernel, in modo che potete fare lo stesso usando un semplice hex editor disponibile su qualunque sistema voi state usando - per esempio le Norton Utilities Disk Editor sotto DOS. Poi dovete controllare e se necessario, cambiare i valori nel kernel in questi punti:
0x01F8 Low byte della grandezza del RAMDISK
0x01F9 High byte della grandezza del RAMDISK
0x01FC Root minor device number - vedi sotto
0X01FD Root major device number - vedi sotto
I numeri maggiori e minori dei device devono essere impostati sul device su cui voi volete che il root filesystem sia ``mountato''. Alcuni valori utili potrebbero essere:
device maggiore minore
/dev/fd0 2 0 primo floppy drive
/dev/hda1 3 1 partizione 1 sul primo drive IDE
/dev/sda1 8 1 partizione 1 sul primo drive scsi
/dev/sda8 8 8 partizione 8 sul primo drive scsi
rawrite.exe. Questo programma è incluso
in molte distribuzioni, inclusa la distribuzione SLS e la Slackware.
È un programma DOS che scrive un file su un disco vergine (``raw''),
partendo dal boot sector, invece di scriverlo sul file system.
Se usate le Norton Utilities, allora dovete scrivere il file
su un disco fisico partendo dall'inizio del disco.
Non è mai desiderabile avere un solo set di disci di recupero; 2 o 3 copie dovrebbero essere mantenute nel caso che una non fosse leggibile.
La via più semplice per creare delle copie di qualunque dischetto, inclusi i dischi di boot/root, è di usare il comando dd per copiare il contenuto del dischetto originale su un file sul vostro hard disk, e poi usare lo stesso comando per copiare il file su un nuovo dischetto. Notate che non avete, e non dovreste avere, bisogno di eseguire il mount dei dischi, perché dd scrive in maniere cruda sul device.
Per copiare l'originale, usate il comando:
dd if=device of=nomefile
dove device e` il nome del device del dischetto
e nomefile e` il nome di un file su cui volete copiarlo
/dev/fd0 su un file temporaneo
/tmp/diskette.copy, userei il comando:
dd if=/dev/fd0 of=/tmp/diskette.copy
Omettendo il parametro ``count'', come abbiamo fatto noi ora, significa che il dischetto intero di 2880 blocchi sarà copiato.
Per copiare il file risultante su un nuovo dischetto, inserite il nuovo dischetto e usate il comando inverso:
dd if=nomefile of=device
dd if=/dev/fd0 of=/dev/fd1
Quando un device non può essere riconosciuto automaticamente dal kernel, è necessario passargli un stringa di comando, come:
aha152x=0x340,11,3,1
Per esempio, una riga di comando d'esempio che usa il parametro lock, dovrebbe essere:
zImage aha152x=0x340,11,3,1 root=/dev/sda1 lock
/dev/sda1 e salva l'intero
comando per riutilizzarlo in futuro.
Un esempio dell'uso di APPEND è:
APPEND = "aha152x=0x340,11,3,1"
Notate che il parametro NON viene incluso nelle virgolette.
Notate inoltre che per la stringa che passate al kernel usando
il parametro APPEND, bisogna che il kernel stesso abbia il supporto
per quel comando. In caso contrario dovrete ricompilare il
kernel con il supporto per il device richiesto.
Per i dettagli su come ricompilare il kernel, cd su /usr/src/linux
e leggete il file README, e leggete le LINUX FAQ e l'Installation
HOWTO. Alternativamente potete ottenere un kernel generico
che faccia al caso vostro.
I lettori sono fortemente invitati a leggere la documentazione del LILO prima della sua installazione. Un uso incauto del parametro ``BOOT'' può danneggiare le partizioni.
Un filesystem su un disco RAM è un filesystem residento su un disco in memoria che ha una capacità maggiore del disco di root dal quale è stato caricato. Questo può essere molto utile quando si usa Ftape, che richiede un controllo esclusivo del controller del floppy disk.
Due cose sono richieste: creare un filesystem più capiente sul disco di root e poi applicare una ``patch'' al kernel in modo che sia in grado di caricare blocchi oltre la fine del dischetto.
Due sono i metodi possibili:
mke2fs /dev/fd0 3000
dd if=/dev/hdb of=/dev/fd0 bs=1024 count=1440
dd if=/dev/hdb of=tailpart bs=1024 skip=1440
cmp -l tailparm /dev/zero
La seconda cosa richiesta per avere un filesystem di maggior capienza
è di far fermare il kernel alla fine fisica del disco quando
tenta di caricare il dischetto di root nel disco RAM. Per fare
questo bisogna apportare una piccola modifica al kernel nel
driver per il disco RAM, che dovrebbe essere situato in
/usr/src/linux/drivers/block/ramdisk.c. Il seguente ``patch''
è stato fatto da Bruce Elliot. È da applicare al kernel 1.2.0,
ma dovrebbe essere facile applicarlo anche ai kernel più
recenti.
=================================================================
X--- ramdisk.c~ Mon Jan 23 13:04:09 1995
X+++ ramdisk.c Mon May 29 00:54:52 1995
X@@ -113,6 +113,7 @@
X (struct ext2_super_block *)&sb;
X int block, tries;
X int i = 1;
X+ int fblocks;
X int nblocks;
X char *cp;
X
X@@ -168,12 +169,16 @@
X nblocks, rd_length >> BLOCK_SIZE_BITS);
X return;
X }
X- printk("RAMDISK: Loading %d blocks into RAM disk", nblocks);
X+ fblocks = blk_size[MAJOR(ROOT_DEV)][MINOR(ROOT_DEV)];
X+ if (fblocks > nblocks)
X+ fblocks = nblocks;
X+ printk(``RAMDISK: Loading %d blocks into %d block filesystem "
X+ "in RAM disk", fblocks, nblocks);
X
X /* We found an image file system. Load it into core! */
X cp = rd_start;
X- while (nblocks) {
X- if (nblocks > 2)
X+ while (fblocks) {
X+ if (fblocks > 2)
X bh = breada(ROOT_DEV, block, BLOCK_SIZE, 0, PAGE_SIZE);
X else
X bh = bread(ROOT_DEV, block, BLOCK_SIZE);
X@@ -184,7 +189,7 @@
X }
X (void) memcpy(cp, bh->b_data, BLOCK_SIZE);
X brelse(bh);
X- if (!(nblocks-- & 15)) printk(``.'');
X+ if (!(fblocks-- & 15)) printk(``.'');
X cp += BLOCK_SIZE;
X block++;
X i++;
=================================================================
Alcuni avvertimenti: io sono stato in grado di creare in questo modo un filesystem su un disco RAM di 3500 blocchi, ma provando con 3600 o più il kernel collassava con un errore come ``fixup table corrupt''. Non sono riuscito a evitare questa cosa, ma in ogni caso 3500 blocchi mi sembrano più che sufficienti.
A: cannot execute B.
Perché?Ci sono diversi casi di programmi che sono chiamati da altri programmi. Questi casi non avvengono sempre, ma possono spiegare perché un eseguibile apparentemente non può essere trovato su un sistema anche se potete vedere che è effettivamente presente. Potete vedere se un programma chiama un altro programma usando il comando ``strings'' e filtrando l'output attreverso il programma grep.
Esempi conosciuti sono:
/etc/reboot, quindi
reboot deve essere posto nella directory /etc.inittab)
per puntare alla directory corrette. Se siete in dubbio, mettete i
programmi nelle stesse directory in cui sono sul vostro
disco fisso, e usate lo stesso inittab e i file contenuti in
/etc/rc.d, così come appaiono sul vostro disco fisso.