Visualizzazione dei risultati da 1 a 4 su 4
  1. #1
    Utente di HTML.it L'avatar di Andre00
    Registrato dal
    Mar 2003
    Messaggi
    371

    Creare Live cd da ZERO...manualetto

    A qualcuno potrebbe servire....Creare un live cd.
    PARTE 1

    Creare un floppy avviabile
    con slackware dare
    makebootdisk
    (vi verrà chiesto quale kernel copiare nel floppy ed automaticamente il floppy verrà formattato con fs
    vfat o msdos da 1.68Mb e verranno trasferiti alcuni file quali
    syslinux.cfg
    ldlinux.sys //file che rende di fatto il floppy vero e proprio avviabile (credo)
    kernel
    maessage.txt //file contente istruzioni principali o informazioni di benvenuto
    f1.txt //file che viene visualizzato premendo f1
    f2.txt //file che viene visualizzato premendo f2

    Se non abbiamo makebootdisk dobbiamo procedere come segue
    formattare un floppy disk con filesystem msdos o vfat

    mkfs -t msdos /dev/fd0u1440
    o usare
    fdformat

    Noi possiamo anche formattarlo da 1.44 Mb
    Poi diamo
    syslinux /dev/fd0 ##Rende un floppy avviabile, (copia quel file ldlinux.sys sul floppy appunto)
    copiare un kernel funzionante (che stia in un floppy meno di 1.44 Mb quindi) nel floppy
    con ad esempio
    mount /dev/fd0 /mnt/floppy
    cd /mnt/floppy

    cp /boot/vmlinuz /mnt/floppy


    cd /mnt/floppy

    Creiamo il file syslinux.cfg nel floppy

    #syslinux.cfg dovrà contenere qualcosa come testo di configurazione.
    #Esempio un file syslinux.cfg
    #(se non sbaglio contiene una sorta di lilo.conf che avvia il sistema.)
    cat > syslinux.cfg

    display message.txt
    default vmlinuz ramdisk_size=100000 root=/dev/hdc
    prompt 1
    F1 help.txt
    F2 help2.txt

    label eml
    kernel vmlinuz
    append ramdisk_size=200000 root=/dev/hdc

    (praticamente si dice che si legge vmlinuz come immagine del kernel, viene letto il filesystem root da /dev/hdc (che sarà il nostro cdrom) e cosa importante viene settata una ram di blocchi 100000.
    Dare control-Z
    creiamo il file di benvenuto
    cat > message.txt
    Benvenuti in minilinux
    Premere F1 per l'help
    Dare control-Z


    creiamo il file di help che verrà visualizzato premendo f1 help.txt

    cat > help.txt
    Messaggio di help 1
    Inserite cosa volete
    Dare control-Z

    creiamo il file di help che verrà visualizzato premendo f2 help2.txt

    cat > help2.txt
    Messaggio di help 2
    Inserite cosa volete
    Dare control-Z

    smontiamo il floppy con
    cd /
    umount /mnt/floppy
    e copiamo il nostro floppy in un file immagine chiamato floppy.img (file immagine di un floppy avviabile)

    dd if=/dev/fd0 of=/floppy.img bs=1440k count=1 oppure
    cp /dev/fd0 /floppy.img // copia il floppy e ne fa un immagine in /
    L'incubo peggiore è non poter più sognare...

  2. #2
    Utente di HTML.it L'avatar di Andre00
    Registrato dal
    Mar 2003
    Messaggi
    371
    PARTE 2

    a questo punto creiamo una cartella...chiamata mnt2
    mkdir /mnt2
    in questa cartella andremo a copiare tutto ciò che vogliamo compaia nel nostro linux
    ossia copiamo ad esempio in questo modo

    cp -r /boot /mnt2

    cp -dpr /bin /mnt2

    cp -dpr /sbin /mnt2

    cp -dpR /dev /mnt2

    cp -dpR /var /mnt2

    cp -dpr /etc /mnt2

    mkdir /mnt2/proc

    mkdir /mnt2/tmp
    mkdir /mnt2/sys

    cp -dpR /lib /mnt2

    mkdir /mnt2/home
    mkdir /mnt2/home/ftp
    mkdir /mnt2/mnt
    mkdir /mnt2/mnt/floppy
    mkdir /mnt2/mnt/cdrom
    mkdir /mnt2/mnt/dvd
    mkdir /mnt2/mnt/digicam
    mkdir /mnt2/mnt/ram
    mkdir /mnt2/mnt/ram2
    mkdir /mnt2/mnt/c
    mkdir /mnt2/mnt/d
    mkdir /mnt2/mnt/e
    mkdir /mnt2/mnt/f
    mkdir /mnt2/mnt/g
    mkdir /mnt2/mnt/proc
    cp -dR /usr/ /mnt2


    Ora in /mnt2 avremo il nostro minilinux.
    Copiamo anche l'immagine del floppy floppy.img in /boot con
    cp /floppy.img /boot

    Andiamo in /mnt2/etc/rc.d/
    e modifichiamo rc.S in questo modo

    #!/bin/sh
    PS1='\u:\w>\$'
    export PS1
    DIS="/dev/ram0"
    clear
    trap "" 1 2 3 15
    echo "Benvenuti in Mini Linux"
    echo "Scegliere il dispositivo sul quale caricare MiniLinux"
    echo "es. /dev/hda6 oppure /dev/hdb5, /dev/hda1 ecc.."
    echo "Il default e' /dev/ram0"
    echo "Fare molta attenzione: tutti i dati verrano cancellati irrimediabilmente"
    echo "Il dispositivo verra' formattato.Enter per confermare il default"
    read DISPO
    if [ "$DISPO" != "" ]; then
    DIS=$DISPO
    echo "Al termine del caricamento modificare il file /etc/lilo.conf aggiungendo:"

    echo "image = /boot/vmlinuz"
    echo "root = $DIS"
    echo "label = Minilinux"
    echo "Salvare il file e digitare:"
    echo "lilo"
    fi
    echo "Sto per formattare $DIS"
    echo "Enter per confermare - Altro per riavviare"
    read OPZ
    if [ "$OPZ" = "" ]; then
    mkfs.ext2 $DIS
    mount $DIS /mnt
    else
    echo "Riavvio sistema"
    mount -t proc /proc /proc
    reboot
    fi

    echo "Creazione filesystem root e caricamento in $DIS"
    echo "Al termine del caricamento in caso di problemi con alcuni comandi digitare:"
    echo "chroot /mnt"
    echo "mount -t proc /proc /proc"
    echo "mkswap /dev/hdb6 ******** dove /dev/hdb6 sara' la partizione di swap"
    echo "swapon /dev/hdb6"
    echo "Enter per continuare"
    read ENTRATA
    clear
    echo "Attendere....."
    /sbin/swapon -a
    cp -r /boot /mnt
    echo "/boot copiata"
    cp -dpr /bin /mnt
    echo "/bin copiata"
    cp -dpr /sbin /mnt
    echo "/sbin copiata"
    cp -dpR /dev /mnt
    echo "Dispositivi copiati"
    cp -dpR /var /mnt
    echo "/var copiata"
    cp -dpr /etc /mnt
    echo "/etc copiata"
    if [ "$DIS" != "/dev/ram0" ]; then
    rm /mnt/etc/rc.d/rc.S
    cp /mnt/etc/rc.d/rc.SD /mnt/etc/rc.d/rc.S
    fi
    cp -dpR /lib /mnt
    echo "Librerie copiate"

    # cp -r /boot /mnt

    mkdir /mnt/proc
    mkdir /mnt/proc/mounts
    mount -t proc /proc /mnt/proc
    echo "Processi ricostruiti"
    mkdir /mnt/tmp
    echo "Creazione directory file temporanei /tmp terminata"
    cp -r /root /mnt
    mkdir /mnt/home
    mkdir /mnt/home/ftp
    mkdir /mnt/mnt
    mkdir /mnt/mnt/floppy
    mkdir /mnt/mnt/cdrom
    mkdir /mnt/mnt/dvd
    mkdir /mnt/mnt/digicam
    mkdir /mnt/mnt/ram
    mkdir /mnt/mnt/ram2
    mkdir /mnt/mnt/c
    mkdir /mnt/mnt/d
    mkdir /mnt/mnt/e
    mkdir /mnt/mnt/f
    mkdir /mnt/mnt/g
    mkdir /mnt/mnt/proc
    cp /usr/bin/fdformat /mnt/bin
    echo "Creazione directory di mount /mnt terminata"
    echo "A causa delle notevoli dimensioni e' possibile scegliere se copiare"
    echo "la directory /usr in memoria.In questa directory sono contenuti molti"
    echo "comandi importanti e numerosi file di configurazione."
    echo "Se possibile si consiglia di caricarla in memoria"
    echo "Copiare questa directory (s/n)?"
    read ANDREA
    if [ "$ANDREA" = "s" ]; then
    echo "Sto copiando /usr"
    rm /mnt/bin/fdformat
    cp -dR /usr/ /mnt
    echo "/usr copiata"
    fi

    echo "Caricamento e creazione del filesystem root terminata"

    clear
    echo "Benvenuti in Mini Linux "
    echo "******************* IMPORTANTE *******************"
    echo "Digitare subito"
    echo "chroot /mnt"
    echo "all'avvio di ogni console"
    echo "************************************************* *"
    echo "Per configurare periferiche usb, tastiera"
    echo "caricare i moduli ntfs, apm, ide-scsi e scsi_debug"
    echo "digitare minilinux"
    echo "************************************************* *"
    echo "Digitare"
    echo "chroot /mnt"
    echo "adesso"
    echo "************************************************* *"
    #chroot /mnt
    #mount -t proc /proc /proc

    E andiamo anche a modificare il file /mnt2/etc/inittab in questo modo

    #/etc/inittab
    # Boot-time system configuration/initialization script.
    # This is run first except when booting in single-user mode.
    ::sysinit:/etc/rc.d/rc.S

    # Login /bin/sh invocations on selected ttys.
    #
    # Start a shell on the console
    ::respawn:-/bin/sh
    # Start an "askfirst" shell on tty2 and tty3
    tty2::askfirst:-/bin/sh
    tty3::askfirst:-/bin/sh
    tty4::askfirst:-/bin/sh
    tty5::askfirst:-/bin/sh
    tty6::askfirst:-/bin/sh
    #c5:2345:respawn:/sbin/agetty 38400 tty5
    #c6:2345:respawn:/sbin/agetty 38400 tty6
    # /sbin/getty invocations for selected ttys.
    #
    #tty1::respawn:/sbin/getty 38400 tty1
    #tty2::respawn:/sbin/getty 38400 tty2

    # Example of how to put a getty on a serial line (for a terminal)
    #
    #ttyS0::respawn:/sbin/getty -L ttyS0 9600 vt100
    #ttyS1::respawn:/sbin/getty -L ttyS1 9600 vt100
    #
    # Example how to put a getty on a modem line.
    #ttyS2::respawn:/sbin/getty -x0 -s 57600 ttyS2

    # Reboot when ctrl-alt-del keys are pressed.
    ::ctrlaltdel:/sbin/reboot
    #::ctrlaltdel:/sbin/brc

    # Stuff to do before halting or rebooting.
    ::shutdown:/sbin/swapoff -a >/dev/null 2>&

    Questo perchè quando il cdrom si avvierà partirà succederà pressapoco questo:

    Parte il cd avviabile richiamato dal bios.
    Il cd avviabile parte grazie all'immagine del floppy avviabile che abbiamo creato (floppy.img) contenuta nel cd per l'appunto
    Nel floppy c'è il kernel vmlinuz.
    Viene caricato il kernel.
    In seguito viene caricato dall'immagine avviabile del floppy lo script syslinux.cfg che setta il filesystem root su /dev/hdc e setta una ramdisk di dimensione 100000 in blocchi (il file che fa questo è syslinux.cfg)

    Poi il tutto passa al processo init...letto da /dev/hdc
    init andrà a leggersi un sacco di cose fra le quali /etc/inittab e /etc/rc.d/rc.S (in slackware)
    rc.S secondo come lo abbiamo creato noi copia il linux da /dev/hdc al disposisitivo /dev/ram0 (che viene creato e formattato nelle prime righe dell' rc.S stesso)
    Precisazione il file syslinux.cfg setta la grandezza della ramdisk con ramdisk_size=100000
    Nello script /mnt2/etc/rc.d/rc.S (in slackware) viene formattato /dev/ram0 (che dobbiamo aver copiato all'inizio (con cp -dpR /dev /mnt2)
    Se in /dev/ non c'era ram0 dobbiamo crearlo noi...come non lo so ma sicuramente con mknod.)

    Ora Terminato lo script rc.S abbiamo in /dev/ram0 (montato su /mnt quindi difatto in /mnt) il nostro linux.
    In sostanza abbiamo il nostro linux in memoria.A questo punto...non ci resta che dare appena compare il prompt un bel
    chroot /mnt (oppure inserirlo anch'esso in rc.S ma consiglio di darlo da prompt poichè c'è qualche problema con la shell)
    ossia diciamo al nostro linux che finora è stato caricato interamente da cdrom (ossia da dove era caricato il filesystem root dall'inizio cioè nel mio caso da /dev/hdc secondo quanto impostato in syslinux.cfg) di cambiare il filesystem di root da /dev/hdc in sola lettura a /mnt in scrittura e lettura.
    Bene a questo punto il gioco è fatto e linux è pronto per essere usato..
    Non resta che caricare un po' di moduli ad esempio con
    insmod ntfs
    insmod apm
    (se li avete naturalmente copiati dall'harddisk al cdrom inizialmente) e se il kernel inserito nell'immagine del floppy era predisposto a caricare questi moduli ad esempio.
    IO mi sono creato uno script avviabile che ho chiamato minilinux è che è così fatto:
    L'incubo peggiore è non poter più sognare...

  3. #3
    Utente di HTML.it L'avatar di Andre00
    Registrato dal
    Mar 2003
    Messaggi
    371
    Parte 3

    #!/bin/sh

    # This is a function to unload the USB mouse/keyboard modules:
    usb_kbd_down() {
    modprobe -r keybdev mousedev usbmouse hid usbkbd input uhci usb-uhci usb-ohci uhci-hcd ohci-hcd ehci-hcd 2> /dev/null
    umount usbfs 2> /dev/null
    modprobe -r usbcore 2> /dev/null
    }

    # This is a function to attempt to enable a USB keyboard.
    # If this causes problems for you, use "nousb" as a kernel
    # command line option at boot time.
    usb_kbd_up() {
    # If nousb was given at boot, skip.
    if ! cat /proc/cmdline | grep nousb 1> /dev/null 2> /dev/null ; then
    # If there aren't even any modules for this kernel, skip.
    if [ -d /lib/modules/`uname -r` ]; then
    # If usbcore is already loaded, skip.
    if ! grep usbcore /proc/modules 1> /dev/null 2> /dev/null ; then
    modprobe -q usbcore >/dev/null 2>&1
    # Try to mount usbfs:
    if [ -d /proc/bus/usb -a ! -f /proc/bus/usb/devices ]; then
    mount -t usbfs usbfs /proc/bus/usb
    fi
    # Try to load all the hub modules:
    modprobe -q ehci-hcd >/dev/null 2>&1
    modprobe -q ohci-hcd >/dev/null 2>&1
    modprobe -q uhci-hcd >/dev/null 2>&1
    modprobe -q usb-ohci >/dev/null 2>&1
    # NOTE: this prefers "usb-uhci"; you may prefer "uhci".
    modprobe -q usb-uhci >/dev/null 2>&1 || modprobe -q uhci >/dev/null 2>&1
    # modprobe -q uhci >/dev/null 2>&1 || modprobe -q usb-uhci >/dev/null 2>&1
    # Load input core:
    modprobe -q input >/dev/null 2>&1
    # Load USB keyboard:
    modprobe -q usbkbd >/dev/null 2>&1
    # Load Human Interface Device (HID) USB module:
    modprobe -q hid >/dev/null 2>&1
    # Load mouse (just in case (TM)) and keyboard USB input modules:
    modprobe -q mousedev >/dev/null 2>&1
    modprobe -q keybdev >/dev/null 2>&1
    # Give these some time to register:
    sleep 2
    # Next, take a look to see if there are devices detected.
    # If not, unload the modules.
    if [ ! -r /proc/bus/usb/devices ]; then
    usb_kbd_down
    break
    elif cat /proc/bus/usb/devices | grep -i Driver=usb_mouse 1> /dev/null 2> /dev/null ; then
    # Looks like a mouse.
    break
    elif cat /proc/bus/usb/devices | grep -i Driver=hid 1> /dev/null 2> /dev/null ; then
    # Probably a keyboard (but could be a game pad
    break
    elif [ -d /proc/bus/usb/devices/001 ]; then # we're REALLY not picky here...
    break
    else
    # Nothing? Fine, we'll give up.
    echo "No USB devices found. Unloading USB subsystem..."
    usb_kbd_down
    fi
    fi
    fi
    fi
    }

    # remove /etc/mtab* so mount creates the /etc/mtab file
    /bin/rm -f /etc/mtab* /etc/nologin

    /bin/mount -av -t nonfs

    #/sbin/swapon -a 2> /dev/null

    if [ -x /sbin/ldconfig ]; then
    /sbin/ldconfig -v
    fi

    ## Detect serial console from kernel command line:
    if cat /proc/cmdline | grep console=ttyS 1> /dev/null 2> /dev/null ; then
    SERIAL_CONSOLE="true"
    fi

    # USB keyboard?
    usb_kbd_up

    # Replace some startup binaries with better versions:
    ( cd /bin
    rm -f grep gzip tar gunzip zcat df
    ln -sf df.bin df
    ln -sf grep.bin grep
    ln -sf gzip.bin gzip
    ln -sf tar-1.13 tar
    ln -sf gzip gunzip
    ln -sf gzip zcat
    )

    # Make detected partitions:
    /dev/makedevs.sh

    if [ -x /etc/rc.d/rc.inet1 ]; then
    /bin/sh /etc/rc.d/rc.inet1
    fi

    /sbin/syslogd 2> /dev/null
    sleep 1
    /sbin/klogd -c 3 1> /dev/null

    /bin/setterm -blank 0

    echo
    echo "<OPZIONI PER CARICAMENTO MAPPA CARATTERI DELLA TASTIERA>"
    echo
    echo "Se non stai usando una tastiera Inglese, hai la possibilità di cambiarla"
    echo "con quella del tuo paese. Per selezionare una mappa diversa di caratteri"
    echo "per la tua tastiera digita 1 adesso.Scegli it.map se la tastiera e' italiana."
    echo "Altrimenti premi solo enter per confermare la tastiera inglese"
    echo -n "Digita 1 per selezionare la mappa di caratteri per la tua tastiera: "
    read ONE
    if [ "$ONE" = "1" ]; then
    /usr/lib/setup/SeTkeymap
    fi
    clear


    # If possible, figure out what kernel we just booted with:
    #unset SLACK_KERNEL
    #for ARG in `cat /proc/cmdline` ; do
    # if [ "`echo $ARG | cut -f 1 -d =`" = "SLACK_KERNEL" ]; then
    # IMAGE="`echo $ARG | cut -f 2 -d =`"
    # SLACK_KERNEL=$IMAGE
    # fi
    #done
    #export SLACK_KERNEL

    alias ll='ls -al --color=auto'
    insmod apm
    insmod ntfs
    insmod ide-scsi
    insmod scsi_debug
    clear
    echo "Mini Linux login: enter per proseguire"
    echo "Per espellere il cd digitare:"
    echo "cdrecord -dev=ATAPI:0,0,0 -eject"
    echo "I tre numeri 0,0,0 (bus,target,lun) potrebbero necessitare"
    echo "di modifiche a seconda della configurazione del bus, masterizzatore ecc..."
    echo "Esempio masterizzatore sul secondo bus:"
    echo "senza emulazione scsi:cdrecord -dev=ATAPI:1,0,0 -eject"
    echo "Esempio secondo masterizzatore sul primo bus"
    echo "con emulazione scsi: cdrecord -dev=0,1,0 -eject"

    minilinux che io ho inserito nel cd nella directory /bin...praticamente configura le periferiche usb, carica i moduli che a me interessano ed infine da qualche informazione utile e permette di settare la tastiera.

    Bene ma noi dobbiamo ancora creare il cdrom...allora dicevamo che in /mnt2 c'è il nostro linux...
    copiamo in /mnt2/boot l'immagine avviabile del floppy floppy.img
    cp /floppy.img /mnt2/boot/ se non lo avevamo già fatto prima..

    Poi entriamo in /mnt2 e diamo il comandone del secolo che creerà l'immagine iso del cd da scrivere utilizzando come avvio l'immagine di un floppy avviabile ( il nostro floppy.img)

    cd /mnt2
    mkisofs -v -R -J -V "Live CD" -b boot/floppy.img -c boot/catalogo.b -o livecd.iso /mnt2

    Questo comando creera' il file catalogo.b utile a rendere il cd avviabile e lo inserirà nel file livecd.iso che conterra' tutta la directoty /mnt2 utilizzando come avvio l'immagine del floppy avviabile (floppy.img che badate bene deve trovarsi all'interno della directory contente il nostro linux.Io per comodità l'ho copiata in /boot (vedi sopra))
    Di fatto questo comandone del secolo crea un file chiamato livecd.iso che sarà quello da scrivere nel cd...

    Bene ora abbiamo livecd.iso...scriviamo adesso sul cd con
    Controllate i parametri che potrebbero differire a seconda dei casi (i tre numerini 0,0,0 che rappresentano scsibus, masterizzatore (0 o 1) e lun (che non so cos'è ma che di solito è sempre 0).Se non avete caricato il modulo scsi dovrete dare ATAPI:0,0,0 al posto di 0,0,0 da solo)..(può essere utile dare

    cdrecord -scanbus per capire come è configurato il nostro bus..

    .quindi...

    da /mnt2

    cdrecord -v dev=0,0,0 -data livecd.iso

    man cdrecord per le mille opzioni da usare con cdrecord
    L'incubo peggiore è non poter più sognare...

  4. #4
    Utente di HTML.it L'avatar di Andre00
    Registrato dal
    Mar 2003
    Messaggi
    371
    Parte 4

    Se usiamo isolinux.... approfondimenti..

    Utilizzando isolinux (che fa di fatto le stesse cose che fa syslinux) possiamo evitarci di creare l'immagine del floppy avviabile poiche l'immagine è già isolinux.bin.
    Tuttavia per utilizzare questo secondo metodo vedere le istruzioni di isolinux (file che si trova in questa cartella)

    Comune ad entrambi i metodi e tuttavia l'uso di initrd.gz
    Io nell'esmempio del primo metodo non ne faccio uso ma si potrebbe anche fare così-

    Desrizione processo di avvio:
    Parte il kernel (che può trovarsi o sul cd live in una directory che noi andremo a specificare dal prompt, oppure sarà incluso nelle immagini avviabili create da syslinux e poi inglobate nel file floppy.img oppure create da isolinux (isolinux.bin)

    Il kernel automaticamente contiene in sè un codice che va ha cercare se esiste un'immagine sul cd compressa con gzip di un filesystem linux da caricare in memoria prima di caricare il vero linux.
    Questa sarà specificata negli script syslinux.cfg o isolinux.cfg oppure lo diremo noi dal prompt con initrd=nomeimmaginecompressa.gz
    Dunque il kernel cerca questa prima immagine che deve contenere un linux in miniatura che serve per caricare in memoria dei moduli che permettano a questo prelinux di caricare il linux vero e proprio che si troverà da qualche parte.
    Io creo un filesystem linux in miniatura (che non può occupare mi sembra più di 10 mb u giu di lì)
    Come faccio?
    O me lo creo io creandomi proprio le directory bin, sbin, lib eccc con i file essenziali e poi creo un immagine compressa (esempio prima con mkisofs creo un immagine iso del prelinux che poi comprimo con gzip -0 prelinux.iso) oppure sotto slackware esiste il comando mkinitrd che crea in automatico questo mini prelinux avviato in automatico dal kernel

    il comando mkinitrd
    es
    mkinitrd -c -k 2.4.29 -m ext2:resiserfs:apm -f ext3 root=/dev/hda5
    crea sotto la directory boot del nostro sistema slackware una directory initrd-tree (che contiene tutto in prelinux in miniatura e un file initrd.gz contente script preziosi quali ad esempio linuxrc linuxrc.cfg ecc..)

    il file linuxrc che va a leggersi linuxrc.cfg è il cuore di tutto l'initrd.gz in quanto è lo script che il kernel va a cercare per primo se e solo se viene trovata l'immagine initrd.gz specificata da noi al prompt.
    linuxrc tanto per capirci e il file che la knoppix usa per configurare tutto il sistema già all'avvio.
    Tuttavia bisogna distinguere due cose.Nell'esempio quando io ho creato la mia initrd.gz a manina (in questa directory c'è un file che spiega come realizzare l'initrd.gz da zero a manina initrd.html) in initrd.gz c'è anche già la directory initrd-tree che il comando mkinitrd invece separa dal file compresso .gz.

    Adesso spieghiamo cosa fa quel comando mkinitrd
    -c cancello la vecchia initrd-tree se già presente o creata in passato (sotto /boot)
    -k 2.4.29 specifico che versione del kernel
    -m mod1:mod2:mod3 specifico quali moduli inserire nell'immagine initrd.gz (che sarà il mio prelinux.Se ad esempio ho sull'hardisk un linux con reiserfs su hda6 per avviarlo dovrò all'avvio aver già caricato in memoria il modulo reiserfs per poter caricare quel linux su hda6.A questo serve poi initrd.gz)
    -f ext3 dice ext3 dice a initrd.gz che il filesystem di root del linux che andrà a caricare sarà ext3
    root =/dev/hda5 dice a initrd.gz che terminato il suo caricamento in memoria dovrà cercare su hda5 il processo init che darà l'avvio al linux che si troverà in quella partizione.
    (attenzione se al prompt abbiamo dato root=/dev/hda7 o root=/dev/ram0 verrà cercata initrd.gz o su hda7 o su ram0.Attenzione:se questa non viene trovata verrà cercato init (e quindi il linux da caricare su hda7 o su ram0) ma se viene trovata initrd.gz su hda7 o su ram0 nell'esempio, ora il controllo passerà a initrd.gz la quale terminato il proprio caricamento andrà a cercare il linux dul device specificato con mkinitrd.
    Se non specifichiamo root=/dev/xxx in mkinitrd allora mkinitrd suppone di usare come device in cui cercare il filesystem di root quello specificato al prompt o di default nell'impostazione di avvio (isolinux.cfg o syslinux.cfg)

    vedere anche man mkinitrd

    Dunque il kernel è partito ha caricato initrd.gz e ora passa il controllo a linuxrc che configura il tutto.
    Naturalmente dal prompt di comando o da isolinux.cfg dovremo ricordarci di specificare che initrd.gz (in realtà il ramdisk) va montato in rw in questo modo:
    Alla comparsa del prompt digitiamo (o Aggiungiamo in syslinux.cfg o isolinux.cfg):
    esempio
    /boot/vmlinuz initrd=/boot/initrd.gz load_ramdisk=1 ramdisk_size=100000 rw root=/dev/ram

    Vedere nel file syslinux-3.07.tar.gz presente in questa directory la documentazione.

    Ora quindi linuxrc avrà fatto il suo dovere.Termninato questo script initrd.gz andrà a cercare se l'opzione root=/dev/xxx è stata specificata con mkinitrd altrimenti andrà a cercare init seguendo le istruzioni del prompt o isolinux.cfg o syslinux.cfg.
    Supponiamo che noi abbiamo dato al prompt
    root=/dev/ram

    initrd.gz è stata trovata
    e mkinitrd con root=/dev/hda8

    allora initrd è stata caricata in ram e adesso initrd cerca linux (o il processo init su hda8)
    Se non fosse stata trovata initrd.gz nell'esempio veniva cercato linux in ram e avremmo ottenuto kernel panic...ma bando alle ciance..
    Ora il processo init è il primo processo che da l'avvio al linux verò e proprio.
    QUesto processo va a leggersi il file /etc/inittab e in seguito lo script rc.S (che sotto slackware si trova sotto /etc/rc.d/)
    rc.S è dinuovo il secondo cuore del sistema nel caso non fosse stata trovata initrd.gz dal kernel e quindi neanche lo script linuxrc tutto ciò che vogliamo faccia il nostro linux all'avvio lo possiamo inserire in questo script..

    Vedere metodo 1 che non utilizza initrd.gz e fa tutto con rc.S.

    Vantaggi e svantaggi di usare initrd o no.

    Usarla rende tutto molto più veloce il processo di avvio e il primo filesystem (quello del prelinux) può essere montato subito in lettura e scrittura;anzi deve montato così).Usare rc.S invece è molto ma molto più laborioso e lungo perchè si deve formattare la memoria e copiare tutto in memoria senza poter montare tutto subito..tuttavia la sequenza è molto più lineare e chiara e alla fine fornisce gli stessi optional.



    Spero vi sia utile!!!

    CIAO CIAO!!!!

    Se ci sono cose sbagliate.... che ci volete fare sono i miei appunti di informatica libera..

    CIAO!
    L'incubo peggiore è non poter più sognare...

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2020 vBulletin Solutions, Inc. All rights reserved.