ELKS Logo

ELKS FAQ - Italiano

Baby Linux Logo

| Website History | Download | FAQ | History | Introduction | Mailing Lists | News | Releases | Home |


Questa è una lista delle risposte alle domandi piu' frequenti riguardanti ELKS , conosciuto anche come Linux-8086.

Nota che ELKS non è Linux , e la mailing list non è un luogo adatto per postare domande riguardanti Linux (malgrado il suo nome). Questo significa che dovrebbe essere meglio inviare domande a newsgroups specifici come comp.os.linux.misc o simili.


  1. Generali

    1. Cos'è ELKS ?

    2. Cos'ha ELKS in comune con il Linux standard ?

    3. Ci sono distribuzioni funzionanti di ELKS ?

    4. ELKS può girare su un 8088?

    5. E sui processori 80188 e 80186 ?

    6. E sui NEC V20 e V30 ?

  2. Compilazione ed Installazione

    1. Dove trovo i sorgenti di ELKS ?

    2. Come assemblo un kernel ELKS ?

    3. Ottengo un errore : /usr/include/linux/vm86.h does not exist.

    4. Come creo un 'init' per ELKS ?

    5. Come creo un disco con filesystem di root ?

    6. Come faccio se ho un XT con lettore floppy da 360K ?

    7. Come cambio il dispositivo di root delle boot images ?

    8. Come installarlo su un hard disk ?

    9. Ottengo errori compilando Dev86 su sistemi Linux recenti ?

    10. Ottengo errori compilando elkscmd ?

    11. Ottengo avvertimenti compilando elkscmd ?

  3. Usare ELKS

    1. Posso eseguire i binari fatti con bcc sotto Linux ?

    2. Posso avviare ELKS da DOSEMU ?

  1. Posso contribuire al progetto ELKS ?

  2. Cosa occorre per farlo ?

  3. Cos'è CVS ?

  4. Da dove lo scarico ?

  5. Come uso CVS senza un account ?

  1. Posso avviare ELKS da DOS , come LOADLIN.EXE fa per Linux ?

  2. Il mio palmare ha un disco RAM. ELKS può accedervi ? (Quando/se ELKS ottiene un filesystem MSDOS , si intende)

  3. Posso fondere le immagini di boot e di root?


Sezione 1 - Generali

Q1.1. Cos'è ELKS ?

ELKS è un sottinsieme per sistemi embedded del kernel Linux (Embeddable Linux Kernel Subset ndr), un progetto per costruire un leggero sottinsieme del kernel di Linux (che dovrebbe offrire piu' o meno le funzionalità di UNIX V7 incluse nel kernel) che può girare su macchine con limitate risorse di processore e memoria. Maggiori informazioni sullo sviluppo , sui risultati e sullo stato attuale del progetto possono essere trovate alla home page di ELKS .

Gli obbiettivi iniziali erano gli Intel 8086 ed eventualmente i 286 in modalità protetta a 16 bit. Un kernel che può girare su questo genere di hardware è utile per i sistemi embedded, per lo sviluppo del terzo mondo dove le macchine superiori agli 8086 non sono facilmente reperibili , e per l'uso sui vari palmari.

Q1.2. Cos'ha ELKS in comune con il Linux standard ?

ELKS è nato per essere un sottinsime del vero Linux , e deve essere abbastanza piccolo per essere compreso da una persona , quindi rappresenta un inestimabile strumento di apprendimento. ELKS recentemente è entrato nello stato di sviluppo beta e la maggior parte delle sue funzionalità previste vi è inclusa.

Avendo detto questo , è già in grado di avviarsi , offrire consoles virtuali , montare filesystems minix , fornire I/O seriali e paralleli di base , connettersi ad un altro computer attraverso un collegamento SLIP null-modem. Infine ELKS supporta lo swapping per allargare virtualmente la RAM di sistema.

Q1.3. Ci sono distribuzioni funzionanti di ELKS ?

Non ancora. Devi usare una macchina Linux standard , scaricare i sorgenti , e cross-compilare per generare il codice 8086 necessario. Le immagini dei dischi di boot e di root sono distribuiti con la versione corrente di ELKS , ma tutto quello che fanno è rendere disponibile una piattaforma per testare il sistema , e si può fare molto poco con essi.

Se sei interessato a costruire una distribuzione attorno ad ELKS , sei il benvenuto.

Q1.4. ELKS può girare su un 8088 ?

L'8088 è identico all'8086 , eccetto che ha un bus per i dati esterni a b bit invece di 16 (e per questo è piu' lento). Comunque sì , ELKS può girare su di esso.

Q1.5. E sui processori 80188 e 80186 ?

Sono semplicemente delle versioni ad alta integrazione rispettivamente dell'8088 e dell'8086 , quindi sì , ELKS può girare su di essi.

Q1.6. E sui NEC V20 e V30 ?

Da un punto di vista software , questi sono semplicemente processori 8088 e 8086 rispettivamente , con la sola eccezione che l'istruzione AAD non può essere usata con altre basi diverse dai decimali sui V20 e V30 , mentre può essere usata con le altre basi sui processori 8088 e 8086. Questa differenza non dovrebbe impedire ad ELKS di girare su questi processori , e si crede che il kernel non è affetto da questa differenza , ma le segnalazioni degli utenti saranno apprezzate.


Sezione 2 - Compilazione ed Installazione

Q2.1. Dove trovo i sorgenti di ELKS ?

Il sito primario è http://elks.sf.net

Il sito primario per Dev86 è http://www.cix.co.uk/~mayday/ che è il miglior posto per trovare l'ultima versione.

Se ne conosci altri o metterne uno su , per favore contatta il maintainer.

Q2.2. Come assemblo un kernel ELKS ?

Le versioni recenti contengono un binario compilato del kernel che la maggior parte delle persone può usare per iniziare a testarlo. Devi compilarne uno tuo solo se vuoi modificare il kernel , o cambiare le opzioni di configurazione. Il file boot in images.zip può essere scritto su un floppy con dd o RAWRITE.EXE per creare un disco di boot con il kernel.

Se vuoi compilare il tuo kernel personale , scarica dev86/Dev86-0.0.13.4.tar.gz e kernel/elks-0.0.67/elks-0.0.67.tar.gz (o le utlime versioni) da linux.mit.edu, o uno degli altri siti. Decomprimi Dev86 in /usr/src (o un'altra directory conveniente), e elks in /usr/src/linux-86 , quindi fai...

        tar -xvzf Dev86-0.0.13.tar.gz -C /usr/src
        tar -xvzf elks-0.0.67.tar.gz -C /usr/src

L'ambiente di sviluppo verrà creato in /usr/src/linux-86, e il sorgente del kenrel in /usr/src/elks. Dopo devi compilare i programmi di sviluppo , che includono il compilatore bcc :

        cd /usr/src/linux-86
        make install

Ora , compila il kernel :

        cd /usr/src/elks
        # Build kernel
        make config
        make dep
        make

Make config funziona allo stesso modo del kernel Linux principale. La configurazione di default dovrebbe funzionare sulla maggior parte dei sistemi. Non cambiare alcuna delle opzioni se non sai cosa stai facendo.

(Se hai usato gcc per compilare i kernel di Linux , sarai sorpreso di com'è veloce questo ! :-) Il risultato è un'immagine per floppy disk chiamata "Image" , che puoi copiare su un floppy ed avviarla da esso.

        dd if=Image of=/dev/fd0

o

        make disk

Ora dovresti poter bootare con questo disco , ma non puoi ottenere altro senza un floppy disk di root da montare. Dovrai usare l'immagine di root fornita in images.zip , o fartene una tua. Devi usare bcc per compilare un programma di 'init' e creare un filesystem minix di root. Questo sarà spiegato successivamente sotto.

Q2.3. Ottengo un errore : /usr/include/linux/vm86.h does not exist.

Modifica /usr/include/sys/vm86.h e cambia...

        #include <linux/vm86.h>

...in...

        #include <asm/vm86.h>



Q2.4. Come creo un 'init' per ELKS?

Dopo che il kernel ELKS si è avviato , deve eseguire /bin/init. Si sta preparando una versione reale di 'init' per essere inclusa nel tiny-utils package, anche su linux.mit.edu. Un init molto basilare è incluso nella sezione sysutils del pacchetto elkscmd che è distribuito con ogni versione. Il codice del kernel è stato recentemente cambiato e carica /bin/init invece di /bin/sh

Per installare init e login compilali insieme con...

        bcc -0 -O -ansi -s init.c -o init
        bcc -0 -O -ansi -s login.c -o login

-0 seleziona la generazione di codice 8086,
-O abilta le ottimizzazioni,
-ansi abilitanables solo i prototipi di funzioni in stile ANSI e,
-s mette i simboli fuori dal binario.

...e copiali nella directory /bin del tuo root disk.Il programma login richiede un file /etc/passwd e uno /etc/group , e una /bin/sh (o altro dipendente da quando scritto in /etc/passwd).

A partire dal kernel 0.0.56 sash ora funziona ed è usata come /bin/sh da molte persone. Può essere trovata in elkscmd.tar.gz . Per ottenere i migliri risultati copia /etc/passwd e /etc/group da una distribuzione linux standard sul tuo disco di root affinchè ls -l funzioni , e /usr/lib/liberror.txt affinchè il sistema per riportare gli errori di sash funzioni.

Una versione di ash che funziona con ELKS è anche inclusa , ma è piu' grande , e non dovrebbe funzionare sulle macchine con meno di 640K di memoria.

Q2.5. Come creo un disco con filesystem di root ?

Per la maggior parte delle persone il file system di root incluso in images.zip dovrebbe essere l'ideale , e si può usare per creare un disco di root da linux quanto segue :

        dd if=root of=/dev/fd0 bs=8192

Da DOS, si può usare RAWRITE.EXE per lo stesso scopo.

Devi creare un floppy minix contenente i file nella posizione giusta. Questo file (la loop image ndr) deve contenere init, login, e sh in /bin/ e passwd e group in /etc , e almeno tre ttys per init in /dev/

Nota: /dev/tty è diverso da quello usato normalmente Linux (5,0)

        mkdir /usr/src/root86                   # crea una directory
        cd /usr/src/root86
        mkdir dev                               # crea delle sottodirectory in essa
        cd dev
        mknod tty1 c 4 0                        # crea i dispositivi richiesti
        mknod tty2 c 4 1
        mknod tty3 c 4 2
        mknod fd0 b 3 128
        cd ..
        mkdir bin
        cd bin
        cp <path-to-elkscmd-init> init          # copia dentro i file eseguibili essenziali
        cp <path-to-elkscmd-login> login
        cp <path-to-elkscmd-sash> sh
        cd ..
        mkdir etc
        cd etc
        cp <path-to-skeleton-passwd> passwd     # aggiunge i file richiesti da login
        cp <path-to-skeleton-group> group
        cd ..
        fdformat /dev/fd0H1440                  # se il floppy non è ancora formattato
        mkfs.minix -n14 /dev/fd0 1440
        mount -t minix /dev/fd0 /a              # richiede un mount point "/a"
        cp -pR /usr/src/root86/* /a
        umount /a

Alcune distribuzioni usano /dev/fd0u1440 al posti di /dev/fd0H1440. Devi rimuovere le passwords dal file passwd perchè non sono ancora supportate , e assicurati che la shell per ogni utente sia /bin/sh per compatibilità futura.

Alternativamente , se hai un kernel 2.0.x e mount-2.5k, puoi usare il filesystem di loopback per creare un'immagine del disco sul tuo hard disk , e poi riversarlo su floppy:

        dd if=/dev/zero of=root.image bs=18k count=80
        losetup /dev/loop0 root.image
        mkfs -t minix /dev/loop0 1440
        mount -t minix /dev/loop0 /a
                ...
        umount /a
        dd if=root.image of=/dev/fd0

A partire da ELKS 0.0.53 le dimensioni dei floppy diverse da 1.44M ora funzionano. Semplicemente segui le istruzioni sopra rendendo le dimensioni appropiate dove richiesto. Comunque , poiché i dischi da 360K sono scritti diversamente dai dispositivi da 1.2 Mega , le istruzioni sotto devono essere seguite se vuoi provare ad avviare una macchina con un lettore 360K.

Q2.6. Come faccio se ho un XT con lettore floppy da 360K ?

Preparare immagini di boot e root da eseguire su una macchina diversa richiede un po' d'attenzione , specialmente se la macchina di destinazione ha un lettore da 360K. I dispositivi 360K (5,25" DD) hanno 40-tracce a testina , e quelli da 1.2MB (5,25 DD) hanno 80-tracce per testina. Un lettore da 1.2M può leggere dischi da 360K ma non scriverli realmente , poiché dovrebbe scrivere tracce magnetiche che sono alte la metà di quanto si attende un lettore da 360K.

Una soluzione è montare il lettore 360K come secondo dispositivo nel tuo PC con Linux - quindi puoi formattare dischi da 360K con :

        fdformat /dev/fd1d360

...e creare i filesystems come di solito.

Altrimenti , devi creare un file immagine del floppy , trasferirlo nel PC che ha il 360K (ad esempio usando un cavo seriale), quindi usare "rawrite" da DOS per ricreare il disco dall'imagine.

Dischi di boot

Il file 'Image' può essere scritto su qualsiasi tipo di floppy e si avvierà con successo , e devi trasferirlo e quindi usare 'rawrite' per creare il disco di destinazione.

I dischi di root ora sono riconosciuti automaticamente , e non devi piu' ricompilare per usare dischetti diversi da 1.44Mb

Dischi di root

Puoi preparare un'immagine di root su un disco piu' grande - quando digiti mkfs sostituisci "360" alla dimensione del filesystem. Una volta copiati i file su questo disco , smontalo , quindi puoi creare un'immagine del dischetto da esso stesso :

        dd if=/dev/fd0 of=root.image bs=1k count=360

Quest'immagine può essere trasferita sul computer di destinazione e scritta usando rawrite come prima. Se usi un filesystem di loopback questo passo non è necessario.

RAM - limitazioni

0.0.44 expected there to be 640K RAM available. Comunque se non hai 640K i problemi con DEF_INITSEG e DEF_SETUPSEG sono stati risolti nelle ultime versione e non devi cambiare niente.

Q2.7. Come cambio il dispositivo di root delle boot images ?

Il disco di boot della versione 0.0.62 era compilato per usare il secondo drive floppy come root disck poiché la funzione wait_for_keypress() era danneggiata. Puoi girarci intorno se hai solo un drive floppy usando un editor hex per cambiare il "root device.no" nell'immagine.

Se ottieni un errore riguardo "root disk mount failing on device 03c0", carica la boot image in un editor hex e cerca c003h in prossimità dell'inzio dell'immagine e cambialo in 8003h (c003h è 03c0 nell'ordine dei byte inverso di Intel). Questo dovrebbe funzionare con qualsiasi versione , ma non è chiaro perchè l'indirizzo del byte da modificare cambia nelle varie versioni. jose@cnct.com segnala che nella boot image 0.0.62 , i due bytes sono a 0adf - oade .

Q2.8. Come installarlo su un hard disk ?

A partire dalla versione 0.0.65 è possiblie installare il root disk di ELKS in un hard disk e poi creare un floppy di boot che l'utilizza. Ci sono alcuni bugs ma è piu' usabile di un floppy di root.

Per prima cosa crea una partizione con fdisk. Qualsiasi versione di fdisk è in grado di farlo , ma l'attuale disco di root supporta solo bd?1-4 , che sono partizione primarie , e se hai già una partizione DOS primaria non puoi crearne una seconda con fdisk di DOS. La versione di fdisk inclusa nel disco di root di ELKS 0.0.67 è ancora giovane come codice , ma sembra funzionare bene sul mio sistema.

Avendo creato la partizione , avvia ELKS dai floppy di boot e di root , e crea un filesystem usando mkfs. E' consigliabile per usare fdisk di ELKS il corretto nome del dispositivo della partizione su cui vuoi creare il filesystem. Per creare il filesystem digita...

        mkfs /dev/bd?? <size>

...dove bd?? è la partizione corretta , e size è la dimensione della partizione in blocchi da un KB. <size> non può essere maggiore di 32M. Es. per creare un filesystem nella prima partizione del disco slave , che è una partizione da 20M :

        mkfs /dev/bdb1 20000

Ora monta la partizione in /mnt digitando...

        mount /dev/bd?? /mnt

...dove bd?? è la partizione corretta. La directory della nuova partizione potrebbe sembrare un po' corrotta e potrebbe non essere possibile usare ls da /mnt. Non sono sicuro del perchè mkfs genera dei filesystems leggermente corrotty , ma ci sto lavorando sopra.

Crea le directory essenziali sul nuovo filesystem come segue :

        cd /mnt
        mkdir bin dev etc home mnt root
        mkdir usr usr/lib
        mkdir var var/log var/run
        mkdir /mnt/home/user?....

Ora copia i file essenziali. Te ne servono molti piu' di questi per un sistema decente ma questi sono gli essenziali e alcuni un po' piu' utili :

        cd /bin
        cp -v cp init getty login ls mount pwd sh umount /mnt/bin/
        cd /etc
        cp -v group passwd /mnt/etc/
        cp /usr/lib/liberror.txt /mnt/usr/lib/
        touch /mnt/var/run/utmp

Infine crea i dispositivi essenziali :

        cd /mnt/dev
        for N in 0 1 2 3 ; do mknod tty$N c 4 $N ; done
        mknod fd0 b 3 128
        mknod fd1 b 3 192
        for N in '' 1 2 3 4 ; do mknod bda$N b 3 $[$N+0] ; done
        for N in '' 1 2 3 4 ; do mknod bdb$N b 3 $[$N+64] ; done
        cd /

Ora smonta la nuova partizione con:

        umount /dev/bd??

Ora devi ricompilare un nuovo kernel con il dispositivo di root corretto selezionato. Per fare questo modifica include/linuxmt/config.h nel codice sorgente di ELKS , e cambia il CONFIG_ROOTDEV da 0x380 al numero corretto di dispositivo della partizione. Le ultime due cifre sono il minor number della partizione in esadecimale. Il minor number può essere trovato dalla lista sopra. Il minor number di bdb3 è 67 , che è 43 in esadecimale , quindi il valore di ROOT_DEV è 0x343.

Quando hai finito questo, digita...

        make disk

...per compilare un nuovo floppy con il kernel, e riavvia la macchina ELKS con questo nuovo disco di avvio. Il nuovo root dovrebbe montarsi , ma potresti ottenere un avvertimento , e il sisitema appare come normalmente , ma piu' veloce che da un floppy. Come prima la directory di root potrebbe essere corrotta , ma dovrebbe essere possibile cambiare il percorso normalmente , e il sistema dovrebbe ad ogni modo lavorare normalmente.

Q2.9. Ottengo errori compilando Dev86 su sistemi Linux recenti ?

Ci sono due casi compilando Dev86 su sistemi recenti che sono riconosciuti come un problema sotto RedHat 6.0.

  1. Il primo è un conflitto con le recenti glibc e causa che un FILE * non può essere inizializzato puntando all'I/O standard. Si sta lavorando ad una correzione per questo problema.

  2. La versione di ar che accompagna alcuni sistemi Linux può non comportarsi bene con il formato .o dei files di bcc. Un nuovo programma ar è stato scritto per Dev86 e verrà incluso nella release successiva. Allo stesso tempo Greg Haerr ha fatto una nuova versione disponibile dal server ftp ftp://microwindows.censoft.com/pub/microwindows/ar .

Q2.10. Ottengo errori compilando elkscmd ?

Errori simili ai seguenti si possono incontrare compilando elkscmd se Dev86 non è compilato correttamente rispetto ad un kernel recente:

        undefined symbol: _setsid
        undefined symbol: _fchown

Questo è causato perchè Dev86 non stilla la lista delle chiamate di sistema dall'attuale sorgente del kernel. Un problema simile può accadere se Dev86 non trova le directory include del kernel, e crea link ad esse nella directory include standard di bcc :

        ps.c:2.26: error: cannot find include file linuxmt/sched.h

La soluzione di questi due problemi insieme è la seguente :

elkscmd ora dovrebbe compilare correttamente.

Q2.11. Ottengo avvertimenti compilando elkscmd ?

Avvertimenti simili ai seguenti possono capitare compilando elkscmd :

        ld86: warning: _utmpname redefined in file /usr/local/bcc/lib/bcc/i86/libc.a(utnt.o); using definition in utent.o

Questi sono causati perchè elkscmd contiene una versione patchata dei files dalla libreria C standard. Una volta queste versioni patchate sono state testate con successo e sono state integrate nelle librerie, e rimosse da Dev86.


Sezione 3 - Usare ELKS

Q3.1. Posso eseguire i binari fatti con bcc sotto Linux ?

Sì - caricando un modulo del kernel puoi eseguire i binari di ELKS direttamente. Questo rende lo sviluppo dei programmi che gireranno sotto ELKS molto meno gravoso , così puoi testarli sul tuo sistema Linux normale (sebbene potrebbero non funzionare sotto ELKS, se il tuo programma usa un'agevolazione del kernel che non &eg