| Entrambe le parti precedenti la revisioneRevisione precedenteProssima revisione | Revisione precedenteProssima revisioneEntrambe le parti successive la revisione |
| it:slackware:liveslak [2021/12/31 18:35 (UTC)] – [Boot parameters explained] twenty-seven | it:slackware:liveslak [2022/01/04 19:03 (UTC)] – [Scripts e tools] twenty-seven |
|---|
| Eliminate tutti i dati dalla directory di persistenza o da container. | Eliminate tutti i dati dalla directory di persistenza o da container. |
| Utile in caso i vostri dati persistenti fossero corrotti. | Utile in caso i vostri dati persistenti fossero corrotti. |
| |
| ########################### RIPRENDERE DA QUI ################################33 | |
| |
| persistence=name => | persistence=name => |
| Use this if you are using a different | Impostate questo se state usando un file/directory diversi |
| directory/file than "persistence" for storing persistent data. | da "persistence" per contenere i dati persistenti. |
| |
| persistence=/dev/sdX:/path/to/mypersistence | persistence=/dev/sdX:/path/to/mypersistence |
| persistence=scandev:/path/to/mypersistence => | persistence=scandev:/path/to/mypersistence => |
| Use this if the persistence directory or container is not located on | Usate questo se la directory di persistenza o il container non e' sulla |
| the USB stick, but on a local hard disk partition. | penna USB, ma su una partizione locale del disco fisso. |
| Useful for network (PXE) boot where you still want to offer users persistence. | Utile per il boot da rete (PXE) in cui volete offire agli utenti la persistenza. |
| |
| toram => | toram => |
| Copy the OS from the media to to RAM before running it. | Copiate il sistema operativo dal media alla RAM prima di avviarlo. |
| You can remove the boot media after booting. | Una volta terminato il boot potete rimuovere il media. |
| |
| toram=all => | toram=all => |
| Prevent writes to disk since we are supposed to run from RAM; | Previene le scritture su disco dato che si suppone che funzioni in RAM; |
| equivalent to parameter "toram". | equivalente al parametro "toram". |
| |
| toram=core => Load Console OS modules into RAM. Console-only Slackware | toram=core => Carica i moduli della Console nella RAM. Slackware con sola Console |
| loads fast, contains 'setup2hd' and frees up your USB drive so you can | si carica piu' velocemente, contiene 'setup2hd' e libera la vostra USB cosicche' potete |
| overwrite it with a Persistent Live OS. | sovrascriverla con un Live OS persistente. |
| |
| toram=os => | toram=os => |
| Load OS modules into RAM, but write persistent data to USB. | Carica i moduli OS nella RAM, ma scrive dati persistenti sulla USB. |
| |
| === Troubleshooting === | === Troubleshooting === |
| |
| blacklist=mod1[,mod2[...]] => | blacklist=mod1[,mod2[...]] => |
| Add one or more kernel modules | Aggiunge uno o piu' moduli del kernel |
| to the kernel blacklist to prevent them from loading, in case | alla blacklist per prevenirne il caricamento, in caso |
| they cause issues during operation. | dovessero causare problemi durante le operazioni. |
| |
| debug => | debug => |
| During init, pause at strategic locations while | Durante l' init, fermati in "posti" strategici mentre assembli il filesystem |
| assembling the overlay filesystem and show mount information. | overlay e mostra le informazioni di mount. |
| |
| debug=<number> => | debug=<number> => |
| '2' enables verbose script execution; | '2' abilita la scrittura verbosa delle operazioni; |
| '4' dumps you into a debug shell right before the switch_root. | '4' fa il dump in una shell di debug proprio prima di dello switch_root. |
| |
| rescue => | rescue => |
| After initialization, you will be dropped in a | Dopo l' inizializzazione, sarai riportato a una shell di rescue |
| rescue shell to perform lowlevel maintenance. | per fare manutenzione a basso livello. |
| |
| |
| ==== Layout of the ISO ==== | ==== Layout della ISO ==== |
| |
| |
| The Live ISO contains three directories in the root of its filesystem: | La ISO Live contiene tre directory nella root del suo filesystem: |
| * EFI/ | * EFI/ |
| * boot/ | * boot/ |
| * liveslak/ | * liveslak/ |
| |
| The USB variant with persistence may have an additional directory in the root: | La variante USB con persistenza puo' avere una directory aggiuntiva nella root: |
| * persistence/ | * persistence/ |
| |
| * The EFI/ directory contains the Grub configuration used when you boot the Live OS on a computer with UEFI. | * La directory EFI/ contiene la configurazione del Grub usata quanto fai il boot del Live OS su un computer con UEFI. |
| * The boot/ directory contains the syslinux configuration used when the Live OS boots on a computer with a BIOS. This directory also contains the kernel and initrd files which are used to actually boot the OS. | * La directory boot/ contiene la configurazione del syslinux usata quando fai il boot del Live OS su un computer con BIOS. Questa directory contiene inoltre il kernel e i files dell' initrd che sono usati in realta' per avviare il sistema operativo. |
| * The liveslak/ directory contains all the squashfs modules which are used to assemble the filesystem of the Live OS, as well as files that are copied directly into the root of the Live filesystem. It contains four subdirectories: | * La directory liveslak/ contiene tutti i moduli squashfs che sono usati per assemblare il filesystem della Live OS, allo stesso modo dei files che sono copiati direttamente nella root del filesystem della Live. Contiene le seguenti sottodirectory: |
| * addons/ - modules which are stored in this directory will always be added to the Live filesystem unless you prevent that with a "noload=" boot parameter; | * addons/ - i moduli che sono contenuti in questa directory saranno sempre aggiunti al filesystem Live a meno che voi non li escludiate con un parametro "noload=" al boot; |
| * optional/ - modules in this directory will not be added to the filesystem of the Live OS unless you force this with a "load=" boot parameter; | * optional/ - i moduli che sono contenuti in questa directory non saranno aggiunti al filesystem Live a meno che voi non ne forziate il caricamento con il parametro "load=" al boot; |
| * system/ - this directory contains all the modules which were created by the "make_slackware_live.sh" script. All these modules are numbered and the Live init script will use that to re-assemble the Live filesystem in the exact same order as they were created initially. | * system/ - questa directory contiene tutti i moduli che sono stai creati dallo script "make_slackware_live.sh". Tutti questi moduli sono numerati e lo script di init della Live usera' quella numerazione per assemblare il filesystem Live nello stesso ordine di come essi sono stati creati inizialmente. |
| * rootcopy/ - this directory is empty by default. Anything you (the user of the ISO) add to this directory will be copied verbatim into the filesystem by the init script when the Live OS boots. You can use this feature for instance if you do not want to create a separate squashfs module file for your application configuration files. | * rootcopy/ - questa directory e' vuota di default. Qualunque cosa (l' utente della ISO) aggiungiate a questa directory sara' copiato testualmente nel filesystem dallo script di init quando la Live OS fa il boot. Potete usare questa feature per esempio se non volete creare un modulo squashfs separato per i file di configurazione della vostra applicazione. |
| | ===== Documentazione per lo Sviluppatore ===== |
| |
| |
| ===== Developer Documentation ===== | ==== Scripts e tools ==== |
| | |
| | |
| ==== Scripts and tools ==== | |
| |
| |
| === make_slackware_live.sh === | === make_slackware_live.sh === |
| |
| | Il primo script: |
| |
| The first script: | Lo script "make_slackware_live.sh" crea un file ISO che come output contiene la Live OS. |
| | Grazie al kernel Linux 4.x e al pacchetto squashfs-tools in Slackware, il processo di creazione di una Live ISO di Slackware **non** richiede (ri)compilazione del contenuto di Slackware o l' installazione di pacchetti di terze parti. |
| |
| The script "make_slackware_live.sh" creates an ISO file as its output which contains the Live OS. | Il funzionamento interno dello script puo' essere suddiviso in diversi passaggi distinti. Per la completa ISO di Slackware i passaggi del processo sono i seguenti: |
| Thanks to Linux kernel 4.x and the squashfs-tools package in Slackware, the process of creating a Slackware Live ISO requires **no** (re)compilation of Slackware content or installing 3rd party packages. | |
| |
| The script's inner workings can be subdivided into several distinct stages. For the full Slackware ISO the process stages are as follows: | |
| |
| | == Installare i pacchetti di Slackware == |
| |
| == Install the Slackware packages == | Primo stage: |
| |
| | * Lo script legge una sequenza di pacchetti per la variante della Live e installa tutti i pacchetti in questa sequenza nello sottodirectory di un albero di directory temporaneo. |
| | * Ogni set di pacchetti di Slackware (a, ap, d, ... , y) o lista di pacchetti (min, noxbase, x_base, xapbase, ...) viene installato in una directory 'root' separata. |
| | * Ognuna di queste directory e' "squashata" (usando squashfs) in un modulo squashfs separato. Tale modulo e' un singolo file di archivio contenente la struttura compressa delle directory dei pacchetti installati. |
| | * Questi files dei moduli sono successivamente montati in loop e poi messi insieme in una singola struttuta a directory a sola lettura usando un "overlay mount". L' overlayfs e' relativamente nuovo; Le distro Live precedenti usavano aufs e unionfs per ottenere simili funzionalita', ma essi non erano parte di nessun sorgente stock del kernel e quindi i kernels custom dovevano essere compilati per tali distro Live. |
| | * Questo "overlay assemblato" e' il filesystem che sara' avviato come filesystem della Live OS. |
| | * In 'cima' a questa serie di filesystems overlay in sola lettura, lo script "make_slackware_live.sh" aggiunge un filesystem scrivibile. Questo filesystem scrivibile e' usato per contenere tutte le customizzazioni alla nostra distro, che vogliamo vengano applicate quando la Slackware Live si avvia. Vedere la prossima sezione per maggiori dettagli. |
| | * Notate che quando fate il boot della Live OS successivamente, un altro overlay scrivibile sara' usato per recepire ogni operazione di scrittura eseguita dall' OS. Voi vedrete la Live Os come un vero sistema operativo che puo' scrivere e cancellare files. Questo filesystem scrivibile sara': |
| | * un filesystem basato sulla RAM quando la Live OS sara' eseguita senza persistenza. |
| | * una directory o un container file montato in loop sulla vostra penna USB, se state usando una USB con persistenza. |
| |
| Stage one: | |
| |
| * The script reads a package sequence for the Live variant and installs all packages in this sequence to subdirectories of a temporary directory tree. | == Configurare il filesystem della Live con utili defaults out-of-the-box == |
| * Every Slackware package set (a, ap, d, ... , y) or package list (min, noxbase, x_base, xapbase, ...) is installed into a separate 'root' directory. | |
| * Each of those root directories is "squashed" (using squashfs) into a separate squashfs module. Such a module is a single archive file containing the compressed directory structure of the installed packages. | |
| * These module files are subsequently loop-mounted and then combined together into a single read-only directory structure using an "overlay mount". The overlayfs is relatively new; earlier Live distros have been using aufs and unionfs to achieve similar functionality, but those were not part of any stock kernel source and therefore custom kernels had to be compiled for such a Live distro. | |
| * This "overlay assembly" is the filesystem that will be booted as the filesystem of the Live OS. | |
| * On 'top' of this series of overlayed read-only filesystems, a writable filesystem is added by the "make_slackware_live.sh" script. This writable filesystem is used to store all the customizations to our distro that we want to be applied when Slackware Live boots up. See the next section for more detail. | |
| * Note that when you boot the Live OS later on, another writable overlay will be used to capture any write operations performed by the OS. You will perceive the Live OS as a real OS that can write and remove files. That writable filesystem will be: | |
| * a RAM-based filesystem when the Live OS runs without persistence. | |
| * a directory or a loop-mounted container file on your USB stick, if you use a USB stick with persistence. | |
| |
| |
| == Configure the Live filesystem with useful out-of-the-box defaults == | Secondo stage: |
| |
| | * L'inizializzazione di alcuni filesystem e' fatta quando l' overlay e' stato assemblato: |
| | * gli utenti 'root' e 'live' vengono creati, |
| | * un ambiente iniziale per gli account viene configurato, |
| | * l' ambiente desktop e' pre-configuurato per il primo uso, |
| | * gli scripts della liveslak "makemod", "iso2usb" e "upslak.sh" sono copiati in "/usr/local/sbin/" nella ISO per vostra comodita', |
| | * lo script "setup2hd" e i files dell' installer della Slackware sono copiati rispettivamente in "/usr/local/sbin" e "/usr/share/liveslak". |
| | * Viene configurato slackpkg, |
| | * viene creato un database locale, |
| | * ecc... |
| | * Tutte queste modifiche sono scritte nel filesystem scrivibile che e' stato creato nella precedente sezione. Questo filesystem sara' anche contenuto della ISO come modulo squashfs e, quando il Live OS si avviera', sara' montato in sola lettura come tutti gli altri moduli. Il suo nome sara' "0099-slackware_zzzconf-current-x86_64.sxz" o, piu' genericamente, "0099slackware_zzzconf-${SLACKVERSION}-${ARCH}.sxz" |
| |
| Stage two: | == Configurare la fase di boot della Live OS == |
| |
| * Some filesystem initialization is done when the overlay has been assembled: | |
| * 'root' and 'live' user accounts are created, | |
| * an initial environment for the accounts is configured, | |
| * the desktop environment is pre-configured for first use, | |
| * the liveslak scripts "makemod", "iso2usb.sh" and "upslak.sh" are copied to "/usr/local/sbin/" in the ISO for your convenience, | |
| * the "setup2hd" script and the Slackware installer files are copied to "/usr/local/sbin" and "/usr/share/liveslak" respectively. | |
| * slackpkg is configured, | |
| * a locate database is created, | |
| * etc... | |
| * All these modifications are written to the writable filesystem that was created in the previous section. This filesystem will also be stored on the ISO as a squashfs module and when the Live OS boots, it will be mounted read-only just like all the other modules. Its name will be "0099-slackware_zzzconf-current-x86_64.sxz" or more generically "0099-slackware_zzzconf-${SLACKVERSION}-${ARCH}.sxz" | |
| |
| | Fase tre: |
| |
| == Configure the boot stage of the Live OS == | * viene generato un initrd, contenente uno script di "init" modificato (altre distro Live lo chiamano "linuxrc script") che ri-assembla il filesystem di overlay al boot e configura la Live OS a seconda dei parametri di boot (lingua, tastiera, fuso orario, runlevel, ...) |
| | * un kernel gnerico slackware e l' initrd di cui sopra vengono aggiunti a una configurazione syslinux (per computers con BIOS) e a grub2 (per computers con UEFI). |
| |
| |
| Stage three: | == Creazione dell' immagine ISO == |
| |
| * an initrd is generated, containing a modified "init" script (other Live distros call it a "linuxrc script") which re-assembles the overlay filesystem on boot and configures the Live OS according to the boot parameters (language, keyboard, timezone, runlevel, ...) | Faser quattro: |
| * a slackware generic kernel plus the above initrd are added to a syslinux (for BIOS computers) and a grub2 (for UEFI computers) configuration. | |
| |
| | * una ISO bootabile viene creata usando mkisofs. |
| | * il comando "isohybrid" viene lanciato sulla ISO cosicche' voi potrete copiare la ISO con "dd" o "cp" su una penna USB e di conseguenza creare un media USB bootabile. |
| |
| == Create the ISO image == | Fatto! Potete trovare il file ISO e il suo checksum MD5 nella directory /tmp. |
| |
| |
| Stage four: | === iso2usb.sh === |
| |
| * a bootable ISO file is created using mkisofs. | |
| * the "isohybrid" command is run on the ISO so that you can "dd" or "cp" the ISO to a USB stick and thus create a bootable USB media. | |
| |
| Done! You can find the ISO file and its MD5 checksum in the /tmp directory. | Il secondo script: |
| |
| | L' utilizzo a runtime dello script "iso2usb.sh" e' spiegato in dettaglio in un precedente paragrafo "Trsferire il contenuto della ISO su una penna USB". |
| |
| === iso2usb.sh === | Questa sezione spiega come lo script modifichi la ISO per le funzionalita' aggiuntive della USB. |
| |
| |
| The second script: | == Layout della chiavetta USB == |
| |
| The "iso2usb.sh" script's runtime usage is explained in detail in a previous paragraph "Transfering ISO content to USB stick". | Lo script "iso2usb.sh" cancella e ri-partiziona la penna USB a meno che non vengano usati i parametri "-r" o //refresh//. Vedi la sezione "[[#Trasferire il contenuto di una ISO su una penna USB|Trasferire il contenuto di una ISO su una penna USB]]" per una spiegazione di tutte le impostazioni da linea di comando. \\ Lo script creera' 3 partizioni: |
| |
| This section explains how the script modifies the ISO for the enhanced USB functionality. | * Prima partizione: una piccola (1 MB di dimensione) partizione FAT che non e' usata dalla Slackware Live Edition. Puo' essere usata da un bootloader alternativo se si necessita. Potete anche metterci il vostro keyfile LUKS per sbloccare un computer con Slackware Linux criptato con LUKS (vedete il file [[http://ftp.osuosl.org/pub/slackware/slackware64-current/README_CRYPT.TXT|README_CRYPT.TXT]] sul vostro DVD Slackware per maggiori informazioni sui LUKS keyfile). |
| | * Seconda partizione: una partizione VFAT di 100MB contenente il kernel, l' initrd e tutte le altre cose necessarie a syslinux e grub2 per avviare Slackware Live Edition. |
| | * Terza partizione: una partizione Linux che occupa tutto il resto dello spazio. Conterra' i moduli liveslak, lo spazio di archiviazione persistente e, opzionalmente, la vostra directory home criptata. Potete usare il resto dello spazio libero di questo filesystem Linux //ext4// per metterci tutto quello che volete. |
| |
| == Layout of the USB stick == | Notate che questo script e' l' unico metodo supportato per trasferire il contenuto della ISO liveslak su una penna USB e di rendere quella stessa USB un Live OS con persistenza. Diversi tool di terze parti (come mulibootusb, rufus, unetbootin), che dichiarano di essere in grado di mischiare diverse Live OS su una singola penna USB e renderle funzionanti in un setup multi-boot, attualmente non supportano liveslak. |
| |
| The "iso2usb.sh" script wipes and re-partitions the USB stick unless the "-r" or //refresh// parameter is used. See section "[[#transfering_iso_content_to_usb_stick|Transfering ISO content to USB stick]]" for an explanation of all commandline switches. \\ The script will create 3 partitions: | |
| |
| * First partition: a small (1 MB in size) FAT partition which is not used for Slackware Live Edition. It can be used by an alternative bootloader if needed. You can also store your LUKS keyfile on it to unlock a LUKS-encrypted Slackware Linux computer (see the [[http://ftp.osuosl.org/pub/slackware/slackware64-current/README_CRYPT.TXT|README_CRYPT.TXT]] file on your Slackware DVD for more information on LUKS keyfiles). | == Montare un filesystem in un container criptato == |
| * Second partition: a 100 MB VFAT partition containing the kernel, initrd and all the other stuff required by syslinux and grub2 to boot Slackware Live Edition. | |
| * Third partition: a Linux partition taking up all of the remaining space. It contains the actual liveslak modules, the persistent live storage and optionally your encrypted homedirectory. You can use the remainder of this Linux //ext4// filesystem's free space to store anything you like. | |
| |
| Note that this script is the only supported method of transfering the liveslak ISO content to a USB stick and make that USB stick into a persistent live OS. Several 3rd party tools (like multibootusb, rufus, unetbootin) that claim to be able to mix several Live OS'es on a single USB stick and make them all work in a multi-boot setup, are not currently supporting liveslak. | Lo script creera' un file di dimensione richiesta nella root della partizione Live usando il comando 'dd'. Il comando 'cryptsetup luksCreate' inizializzera' la cifratura, che fara' in modo che lo script vi chieda "se siete sicuri, digitate YES in maiuscolo", dopodiche' dovrete inserire una passphrase tre volte (due per l' inizializzazione, una per l' apertura del container). Se il container e' usato per una /home criptata, il nome del suo file sara' "slhome.img". Lo script copiera' il contenuto esistente della /home della ISO nel filesystem del container che sara' montato piu' tardi sulla /home della ISO (coprendo quindi la /home esistente). |
| | Il Live OS e' istruito per decriptare il container e montare il filesystem. Questo e' fatto editando il file "/luksdev" nell' initrd e aggiungendo una linea: "/slhome.img". |
| | Lo script iso2usb.sh supporta solamente la creazione e configurazione di una /home criptata, ma potete creare dei containers criptati aggiuntivi da voi e montarli in altri posti del filesystem della ISO. Affinche' tutto cio' funzioni, dovete editare il file "/luksdev" e aggiungere una linea "/vostro/container.img:/vostro/mountpoint", cioe'il path del container e la directory target per il mount su una singola linea, separati dai due punti. Lo scritp di init Live creera' un mount point, nel caso sia mancante. |
| |
| == Mounting a filesystem in an encrypted container == | |
| |
| The script will create a file of requested size in the root of the Live partition using the 'dd' command. The 'cryptsetup luksCreate' command will initialize the encryption, which causes the script to prompt you with "are you sure, type uppercase YES" after which an encryption passphrase must be entered three times (two for intializing, and one for opening the container). | == Utilizzare un file container per immagazzinare dati persistenti == |
| If the container is used for an encrypted /home, its filename will be "slhome.img". The script will copy the existing content of the ISO's /home into the container's filesystem which will later be mounted on top of the ISO's /home (thereby masking the existing /home). | |
| The Live OS is instructed to decrypt the container and mount the filesystem. This is done by editing the file "/luksdev" in the initrd and adding a line: "/slhome.img". | |
| The iso2usb.sh script only supports creating and configuring an encrypted /home, but you can create additional encrypted containers yourself and mount them on other locations in the ISO's filesystem. In order for this to work, you need to edit the "/luksdev" file and add a line "/your/container.img:/your/mountpoint" i.e. container path and the target mount directory on a single line, separated by a colon. The Live init script will create the mount point if it is missing. | |
| |
| == Using a container file for storing persistence data == | Esiste un secondo tipo di container cifrato, che puo' essere usato per immagazzinare i vostri dati persistenti. Lo script di init della Live controllera' se sia necessario abilitare la persistenza in questo ordine: |
| | - il filesystem USB e' scrivibile? Se si', |
| | - esiste una directory /persistence? Se si', usala; altrimenti, |
| | - esiste un file /persistence.img? Se si', montalo e, nel caso sia un container cifrato, chiedi la password durante il boot. |
| |
| A second type of encrypted container exists, which can be used for storing your persistence data. The Live init script will check if it needs to enable persistence in this order: | == Aggiungere il tempo di atteda all' USB == |
| - is the USB filesystem writable? If so, | |
| - does a directory /persistence exist? If so, use that; if not, | |
| - does a file /persistence.img exist? If so, mount the file and if it is an encrypted container, ask for a passphrase during boot. | |
| | |
| == Adding USB wait time == | |
| | |
| For slow USB media, the default 5 seconds wait time during boot are sometimes insufficient to allow the kernel to detect the partitions on your USB device. The script can optionally add more wait time. It does this by editing the file "wait-for-root" in the initrd and updating the value which is stored there (by default "5" is written there by the "make_slackware_live.sh" script). | |
| |
| | Per media USB lenti, il tempo di attesa di default di 5 secondi durante il boot talvolta e' insufficiente per permettere al kernel di rilevare le partizioni sul vostro dispositivo USB. Lo script puo' opzionalmente aggiungere piu' tempo di attesa. Cio' viene fatto editando il file "wait-for-root" nell' initrd e aggiornando il valore che e' vi e' contenuto (di default "5" e' scritto la' dallo script "make_slackware_live.sh"). |
| |
| === makemod === | === makemod === |
| |
| | Il terzo script: |
| |
| The third script: | Lo script "makemod" vi permette di creare un modulo Slackware Live facilmente, con un pacchetto Slackware o un albero di directory come parametro di input. |
| | |
| The "makemod" script allows you to create a Slackware Live module easily, with a Slackware package or a directory tree as its input parameter. | |
| |
| Usage: | Utilizzo: |
| # makemod <packagename|directory> modulename.sxz | # makemod <nome_pacchetto|directory> nome_modulo.sxz |
| |
| * The first parameter is either the full path to a Slackware package, or else a directory. | * Il primo parametro e' il percorso completo di un pacchetto Slackware, oppure una directory. |
| * If a packagename is supplied as first parameter, it will be installed into a temporary directory using Slackware's "installpkg". The content of the temporary directory will be squashed into a module by the "squashfs" program. | * Se il nome di un pacchetto viene passato come primo parametro, sara' installato in una directory temporanea utilizzando l' "installpkg" di Slackware. Il contenuto della directory temporanea sara' squashato in un modulo dal programma "squashfs". |
| * If a directoryname is supplied, its content will be squashed into a module by the "squashfs" program.. | * Se viene passato il nome di una directory, il suo contenuto sara' squashato in un modulo dal programma "squashfs". |
| * The second parameter is the full pathname of the output module which will be created. | * Il secondo parametro e' il nome del percorso completo del modulo di output che sara' creato. |
| |
| You can copy the module you just created (minding the filename conventions for a Slackware Live module, see paragraph "Slackware Live module format") to either the optional/ or to the addon/ directory of your Live OS. If you copy it to the optional/ or addon/ directory of the liveslak sources then "make_slackware_live.sh" will use the module when creating the ISO image. | Potete copiare il modulo che avete appena creato (tenendo a mente le convenzioni sui nomi dei file per i moduli della Slackware Live, vedete il paragrafo "Formato dei moduli della Slackware Live") nella directory optional/ oppure addon/ del vostro Live OS. Se lo copiate nella directory optional/ o addon/ dei sorgenti della liveslak, allora "make_slackware_live.sh" usera' il modulo quando creera' l' immagine ISO. |
| |
| | ############################# DA QUI ############################ |
| |
| === setup2hd === | === setup2hd === |
