[ precedente ] [ Contenuti ] [ 1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ] [ 7 ] [ 8 ] [ 9 ] [ 10 ] [ 11 ] [ 12 ] [ 13 ] [ 14 ] [ 15 ] [ A ] [ successivo ]
Questa sezione fornisce delle coordinate di base per orientarsi nel mondo Debian, mirate all'utente inesperto. Se è un pò di tempo che utilizzate un sistema Unix-like, probabilmente saprete già tutto di quello che verrà spiegato qui. In tal caso, usatela come ripasso.
Dopo aver installato Debian sul vostro PC, dovete imparare alcune cose per renderlo utile. Partiamo a tambur battente con le lezioni.
Dopo il reboot vi si presenterà o la schermata grafica di accesso al sistema, oppure quella a carattere, a seconda della vostra selezione iniziale dei pacchetti. Per semplicità, se avete davanti la schermata grafica, premete Ctrl-Alt-F1 [3] per accedere alla schermata di accesso a carattere.
Supponiamo che il vostro hostname sia foo, il prompt del login sarà così:
foo login:
Digitate root , premete il tasto Enter e digitate la password scelta durante il processo di installazione. In Debian,come da tradizione del mondo Unix, la password è dipendente anche dal maiuscolo/minuscolo. Dopo di ciò, il sistema parte con il messaggio di benvenuto e vi presenta il prompt dei comandi di root in attesa di un vostro comando. [4]
foo login: root Password: Last login: Sun Oct 26 19:04:09 2003 on tty3 Linux foo 2.4.22-1-686 #6 Sat Oct 4 14:09:08 EST 2003 i686 GNU/Linux Most of the programs included with the Debian GNU/Linux system are freely redistributable; the exact distribution terms for each program are described in the individual file in /usr/share/doc/*/copyright Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent permitted by applicable law. root@foo:root#
A questo punto siete pronti per amministrare il sistema dal prompt dei comandi di root. L'account root è anche chiamato utente privilegiato o superuser. Tramite questo account potete fare qualsiasi cosa:
leggere, modificare e rimuovere qualsiasi file del sistema, indipendentemente dai loro permessi
impostare i permessi ed il proprietario di qualsiasi file del sistema
impostare la password di qualsiasi utente senza privilegi nel sistema
accedere a qualsiasi account senza bisogno di password
E' un'idea veramente pessima condividere l'accesso all'account di root
condividendone la password. Il modo giusto di condividere i privilegi
dell'amministratore è mediante l'uso di programmi come sudo(8)
.
Notate che è considerata una buona abitudine in ambito Unix accedere prima ad
un account senza privilegi, anche quando si pensa di eseguire delle attività di
amministrazione di sistema. Utilizzate i comandi sudo,
super, o su -c per guadagnare dei privilegi di root
limitati quando ne avete necessità. Vedere sudo
– lavorare con maggiore
sicurezza, Sezione 9.2.4. [5]
Credo che imparare ad usare un sistema operativo sia come imparare una nuova
lingua. Sebbene le guide siano utili, uno deve fare pratica con strumenti che
lo possano aiutare. In questo contesto, credo sia una buona idea installare
alcuni pacchetti aggiuntivi, tipo mc
, vim
,
lynx
, doc-linux-text
e debian-policy
.
[6]
# apt-get update ... # apt-get install mc vim lynx doc-linux-text debian-policy ...
Se avete questi pacchetti già installati, non accadrà nulla.
Durante l'installazione avrete creato un account utente senza privilegi, che utilizzerete per ricevere le mail inviate all'account di root. [7] Dato che non volete usare questo account speciale per le esercitazioni che andrete a fare, dovrete creare un nuovo account utente.
Supponiamo che vogliate come username penguin, digitate:
root@foo:root# adduser penguin ... rispondete a tutte le domande
eccolo creato. [8] Prima di andare avanti, impariamo alcune cose.
In un sistema Debian standard esistono 6 pseudo-terminali disponibili, cioè potete usare lo schermo a carattere VGA del PC come 6 terminali VT-100 intercambiabili. Potete passare da uno all'altro premendo simultaneamente i tasti Alt-sinistro ed uno dei tasti F1–F6. Ciascun (pseudo)terminale permette i login indipendenti agli account. L'ambiente multiutente è una grande ed avvincente caratteristica di Unix.
Se premete accidentalmente Alt-F7 su un sistema con X Window System e lo schermo mostra l'interfaccia grafica di login, potete riguadagnare l'accesso all'interfaccia a carattere premendo Ctrl-Alt-F1. Per abituarvi, provate a muovervi tra le varie console e a tornare indietro su quella di partenza.
Come qualsiasi moderno sistema operativo, in cui i file vengono tenuti in memoria, il sistema Debian una procedura di arresto appropriata, prima che l'interruttore possa essere spento con sicurezza, per mantenere l'integrità dei file. Date il seguente comando dal prompt di root per spegnere il sistema:
# shutdown -h now
Questo è per la normale modalità multiutente. In modalità singolo utente, sempre da prompt di root, è invece:
# poweroff -i -f
In alternativa, potete premere Ctrl-Alt-Delete (o Ctrl-Alt-Canc per la tastiera italiana) per spegnere. [9]
Attendete finchè non appare la scritta "System halted", poi spegnete il computer. Se le funzioni APM o ACPI sono state attivate dal BIOS e su Linux, il sistema si spegnerà da solo. Per i dettagli, vedere Grosse memorie e spegnimento automatico, Sezione 3.7.4.
Ora siete pronti per giocare con Debian senza rischi, finchè utilizzate l'account utente senza privilegi penguin. [10]
Accediamo come penguin. Se eravate al prompt di root, premete Ctrl-D [11] per chiudere l'attività della shell di root e tornare al prompt del login. Inserite lo username appena creato penguin e la password corrispondente. [12] Vi si presenterà il seguente prompt dei comandi.
penguin@foo:penguin$
Da ora in poi l'esempio utilizzerà dei prompt semplificati per maggiore chiarezza. Userò:
# : prompt della shell di root
$ : prompt della shell di un utente senza privilegi
Cominceremo ad imparare il sistema Debian nel modo più facile Midnight commander (MC), Sezione 4.2 e poi in quello più giusto Ambiente di lavoro Unix-like, Sezione 4.3.
Midnight commander (MC) può essere considerato come uno di quei coltellini svizzeri multiuso, per la console Linux ed altri terminali. Ciò offre al novizio un'esperienza con una console con menu, molto più semplice per imparare i comandi Unix standard.
Usate questo comando per esplorare il sistema Debian. E' il modo migliore per imparare. Esplorate alcune locazioni chiave usando solo i tasti cursore ed il tasto Enter:
/etc
e le sue sottodirectory.
/var/log
e le sue sottodirectory.
/usr/share/doc
e le sue sottodirectory.
/sbin
e /bin
Per far cambiare ad MC la directory di lavoro in uscita, dovete modificare
~/.bashrc
(o /etc/bash.bashrc
, chiamato da
.bashrc
), come spiegato nella sua pagina di manuale,
mc(1)
, sotto l'opzione -P. [13]
$ mc
MC si prende cura di tutte le operazioni sui file tramite il proprio menu, richiedendo il minimo sforzo da parte dell'utente. Basta premere F1 per accedere alla schermata di aiuto. Potete giocare con MC premendo i tasti cursore ed i tasti funzione. [14]
Come default vengono presentate due finestre affiancate che mostrano la lista
di file contenuti nelle directory correnti. Un'altra modalità utile è
impostare la finestra di destra ad "informazioni", per avere tute le
informazioni su file, tipo privilegi di accesso, ecc. A seguire si riportano i
tasti fondamentali. Se il demone gpm
sta girando, potete usare
anche il mouse. (Ricordatevi di premere il tasto maiscolo per avere il normale
comportamento sotto MC per taglia ed incolla).
F1: Menu aiuto
F3: File viewer interno
F4: Editor interno
F9: Attiva il menu a cascata
F10: Esce da Midnight commander
Tab: Muove tra le due finestre
Insert: Marca il file per operazioni con più file, tipo copia
Del: Cancella il file (Fate attenzione—impostate MC in modalità cancellazione sicura)
Tasti cursore: Si spiegano da sè
Qualsiasi comando cd
cambierà la directory mostrata sullo schermo
selezionato.
Control-Invio o Alt-Invio copiano il nome del file sulla riga di comando.
Usatelo insieme ai comandi cp
o mv
durante l'editing
da riga di comando.
Alt-Tab mostra le scelte per i suffissi di file.
Si possono stabilire le directory di partenza per ciascuna finestra, come argomenti per MC; per esempio, mc /etc /root.
Esc + tastonumero == Fn (cioè, Esc + `1' = F1, ecc.; Esc + `0' = F10)
Tasto Esc == tasto Alt (= Meta, M-); cioè, premete Esc + `c' per Alt-C.
L'editor interno ha un sistema di taglia ed incolla interessante. Premendo F3 si marca l'inizio della selezione, un secondo F3 ne segna la fine e la evidenzia. Muovete ora il cursore. Premendo F6 l'area selezionata viene mossa dove è il cursore. Con F5 l'area verrà copiata dove è il cursore. F2 salva il file, F10 esce. Gran parte dei tasti cursori ha un funzionamento intuitivo.
Questo editor può essere lanciato direttamente per un determinato file:
$ mc -e file_da_modificare $ mcedit file_da_modificare
Non è un editor multifinestra, si può ottenere lo stesso effetto utilizzando più console. Per copiare da una finestra all'altra, usate la combinazione Alt-Fn per passare da una console ad un'altra e"File->Insert file" o "File->Copy to file" per muovere parti di un file in un altro.
L'editor interno può essere sostituito da qualsiasi editor esterno preferiate.
Molti programmi usano variabili d'ambiente tipo EDITOR o
VISUAL per decidere quale editor usare. Se vi trovate male con
vim
, impostatele a mcedit aggiungendo queste righe a
~/.bashrc
:
... export EDITOR=mcedit export VISUAL=mcedit ...
Raccomando comunque di impostarle a vim, se possibile. Abituarsi
ai comandi di vim
sarebbe la cosa giusta da fare, dato che gli
editor-Vi sono una costante nel mondo Linux/Unix. [15]
Molto valido. E' uno strumento notevole per la ricerca di parole nei
documenti. Lo uso sempre per i file nella directory
/usr/share/doc
. Rappresenta uno dei modi più rapidi di girare tra
la massa di informazioni su Linux. Può essere lanciato direttamente con:
$ mc -v file_da_vedere
Premete Invio su un file, ed il programma appropriato si prenderà cura del suo contenuto. E' una caratteristica di MC molto utile.
eseguibile: Esegue il comando file man, html: Dirotta il contenuto al viewer corrispondente file tar.gz, deb: Sfoglia il contenuto come fosse una sottodirectory
Per permettere a queste utilità di svolgere il loro compito, i file da leggere
non devono essere segnati come eseguibili. Cambiatene lo stato tramite il
comando chmod
, oppure attraverso il menu file di MC.
MC può essere utilizzato per accedere a file tramite Internet, usando FTP. Attivate il menu premendo F9, poi attivate il file system virtuale FTP premendo `p'. Inserite una URL sotto forma di username:passwd@nomehost.nomedomain, che raggiungerà una directory remota che apparirà come una locale.
Provate http.us.debian.org/debian come URL e scorrete l'archivio dei file Debian. Vedere Gli archivi Debian, Sezione 2.1 per come sono organizzati.
Nonostante MC vi permetta di fare qualsiasi cosa, è bene che impariate come usare gli strumenti da riga di comando invocati dal prompt della shell e che familiarizziate con l'ambiente di lavoro Unix-like. [16]
Nell'ambiente Unix-like, esistono alcune combinazioni di tasti che hanno un significato particolare. [17]
Ctrl-U: Cancella la riga prima del cursore.
Ctrl-H: Cancella il carattere prima del cursore.
Ctrl-D: Termina l'input. (eshe dalla shell se la state usando)
Ctrl-C: Termina l'esecuzione di un programma.
Ctrl-Z: Ferma temporaneamente un programma. (mette il job in background vedere comando &, Sezione 4.3.10.1)
Ctrl-S: Interrompe l'output a schermo. [18]
Ctrl-Q: Riattiva l'output a schermo.
la shell di default, bash
, prevede l'editing della cronologia ed
il completamento mediante il tasto tab per facilitarne l'uso interattivo.
freccia su: Lancia la ricerca della cronologia dei comandi.
Ctrl-R: Lancia la ricerca incrementale della cronologia dei comandi.
TAB: Completa l'input del nome del file sulla riga di comando.
Ctrl-V TAB: Inserisce TAB senza espandere la riga di comando.
Altre combinazioni importanti da ricordare:
Ctrl-Alt-Del: Reboot/arresta il sistema, vedere Installate pochi altri pacchetti dopo l'installazione iniziale, Sezione 3.7.1.
Tasto-sinistro-e-sposta il mouse: Seleziona e copia negli appunti.
Tasto centrale del: Incolla il contenuto degli appunti dove è il cursore.
Tasto Meta (terminologia Emacs) viene tradizionalmente assegnato al tasto Alt sinsitro. Alcuni sistemi possono essere configurati per utilizzare come tasto Meta il tasto Windows.
Per usare il mouse sotto la console a caretteri Linux, dovete avere
gpm
lanciato come demone. [19] Vedere Configurare il
mouse, Sezione 3.3.
Impariamo i comandi base Unix. [20] Provate tutti i comandi dall'account utente senza privilegi penguin :
pwd
Mostra il nome della directory attuale/di lavoro.
whoami
Mostra il nome utente attuale.
file foo
Mostra il tipo per il dato file foo.
type -p nomecomando
Mostra la localizzazione del comando nomecomando.
which nomecomando fa la stessa cosa. [21]
type nomecomando
Mostra le informazioni sul comando nomecomando.
apropos parola-chiave
Trova i comandi correlati a parola-chiave.
man -k parola-chiave fa la stessa cosa.
whatis nomecomando
Mostra una linea di spegazione sul comando nomecomando.
man -a nomecomando
Mostra la spiegazione sul comando nomecomando. (Unix style)
info nomecomando
Mostra una spiegazione più lunga sul comando nomecomando. (stile GNU)
ls
Elenca il contenuto della directory. (file non puntati e directory) [22]
ls -a
Elenca il contenuto della directory. (tutti i file e directory)
ls -A
Elenca il contenuto della directory. (quasi tutti i file e directory, ovvero
salta "..
" e ".
")
ls -la
Elenca tutto il contenuto della directory con informazioni dettagliate. Vedere Il concetto di filesystem in Debian, Sezione 4.5.2.
ls -d
Elenca tutte le directory sotto la directory corrente.
lsof foo
Mostra lo stato del file foo.
mkdir foo
Crea una nuova directory foo sotto la directory corrente.
rmdir foo
Rimuove la directory foo nella directory corrente.
cd foo
Cambia directory nella directory foo
nella directory
corrente o in quella elencata nella variabile CDPATH. Vedere il
comando cd
in builtins(7)
.
cd /
Cambia directory in quella di root.
cd
Cambia directory nella home dell'utente attuale.
cd /foo
Cambia directory seguendo il percorso assoluto /foo
.
cd ..
Va nella directory superiore.
cd ~foo
Va nella home directory dell'utente foo.
cd -
Va nella directory precedente.
</etc/motd pager
Mostra il contenuto di /etc/motd
usando il paginatore di default.
Vedere comando < foo, Sezione
4.3.10.9. [23]
touch junkfile
Crea un file vuoto junkfile
.
cp foo bar
Copia un file esistente foo
in muovo file
bar
.
rm junkfile
Rimuove il file junkfile
.
mv foo bar
Rinomina un file esistente foo
in
bar
.
mv foo bar/baz
Muove un file esistente foo
in una nuova locazione con
un nuovo nome bar/baz
. La directory
bar
deve esistere.
chmod 600 foo
Rende un file esistente foo
non-leggibile e
non-scrivibile dagli altri utenti. (non-eseguibile per tutti)
chmod 644 foo
Rende un file esistente foo
leggibile ma non-scrivibile
dagli altri utenti. (non-eseguibile per tutti)
chmod 755 foo
Rende un file esistente foo
leggibile ma non-scrivibile
per gli altri utenti. (eseguibile per tutti)
top
Mostra le informazioni sui processi a tutto schermo. Digitate "q" per uscire.
ps aux | pager
Mostra le informazioni su tutti i processi in esecuzione usando un output in stile BSD. Vedere comando1 | comando2, Sezione 4.3.10.2.
ps -ef | pager
Mostra le informazioni su tutti i processi in esecuzione usando un output in stile Unix system-V.
ps aux | grep -e "[e]xim4*"
Mostra tutti i processi che usano exim
o exim4
.
Imparate le espressioni regolari dalla grep(1)
pagina di manuale
digitando man grep. [24]
ps axf | pager
Mostra le informazioni su tutti i processi in esecuzione usando un output in arte ASCII.
kill 1234
Uccide un processo idenficato dal numero: 1234. Vedere Uccidere un processo, Sezione 8.5.1.
grep -e "modello" *.html
Trova un "modello" in tutti i file che terminano per .html nella directory corrente e li mostra tutti.
gzip foo
Comprime foo
per creare foo.gz
usando la codifica Lempel-Ziv (LZ77).
gunzip foo.gz
Decomprime foo.gz
per creare
foo
.
bzip2 foo
Comprime foo
per creare foo.bz2
utilizzando l'algoritmo di compressione del testo Burrows-Wheeler e la codifica
Huffman. (Migliore compressione di gzip
)
bunzip2 foo.bz2
Decomprime foo.bz2
per creare
foo
.
tar -xvvf foo.tar
Estrae i file dall'archivio foo.tar
.
tar -xvvzf foo.tar.gz
Estrae i file dall'archivio gzippato foo.tar.gz
.
tar -xvvf --bzip2 foo.tar.bz2
Estrae i file dall'archivio foo.tar.bz2
. [25]
tar -cvvf foo.tar bar/
Archivia il contenuto della cartella bar/
in un
archivio foo.tar
.
tar -cvvzf foo.tar.gz bar/
Archivia il contenuto della cartella bar/
in un
archivio foo.tar.gz
compresso.
tar -cvvf --bzip2 foo.tar.bz2 bar/
Archivia il contenuto della cartella bar/
in
foo.tar.bz2
. [26]
zcat README.gz | pager
Mostra il contenuto del compresso README.gz
usando il paginatore
di default.
zcat README.gz > foo
Crea un file foo
con il contenuto non compresso di
README.gz
.
zcat README.gz >> foo
Appende il contenuto non compresso di README.gz
alla fine del file
foo
. (Se non esiste, prima lo crea.)
find . -name modello
trova i file con i nomi corrispondenti usando il modello della shell. (più lento)
locate -d . modello
find i file con i nomi corrispondenti usando il modello della shell. (più rapido, se si usa un database generato regolarmente)
Come esercizio, attraversate le directory e sbirciate nel sistema usando i comandi sopraelencati. Se avete dubbi sui comandi, assicuratevi di aver letto le pagine di manuale. Per esempio, un buon inizio sono questi comandi:
$ man man $ man bash $ man ls
Questo è anche il momento giusto per lanciare vim
e premere il
tasto F1. Dovreste leggere almeno le prime 35 righe. Poi fate un pò di
esercizio in linea muovendo il cursore su |tutor| e premendo
Ctrl-]. Vedere Gli Editor, Capitolo 11 per
impararne di più sugli editor.
Notate che molti comandi Unix-like, compresi quelli provenienti da GNU e BSD, mostreranno delle brevi informazioni di aiuto se invocati in uno dei modi seguenti (o senza argomenti, in alcuni casi):
$ nomecomando --help $ nomecomando -h
Come esercizio, provate anche gli esempi in Trucchi per Debian, Capitolo 8.
Avete avuto un assaggio su come usare il sistema Debian. Addentriamoci ora nei meccanismi di esecuzione dei comandi. [27]
Un comando semplice è una sequenza di
compiti della variabile (opzionale)
nome comando
argomenti (opzionale)
redirezioni (opzionale: > , >> , < , << , etc.)
operatore di controllo (opzionale: && , || ; <newline> , ; , & , ( , ) )
Per comandi più complessi, con quotazioni e sostituzioni, vedere Processamento delle righe di comando, Sezione 13.2.6.
Una tipica esecuzione di un comando usa una sequenza di shell coma la seguente: [28]
$ date Sun Oct 26 08:17:20 CET 2003 $ LC_ALL=fr_FR date dim oct 26 08:17:39 CET 2003
In questo caso il programma date
viene eseguito in primo piano.
La variabile di ambiente LC_ALL è:
non impostata (default del sistema, C) per il primo comando
impostata a fr_FR (locale Francese) per il secondo comando
Gran parte delle esecuzioni dei comandi non sono generalmente preceduti da una definizione della variabile di ambiente. In riferimento all'esempio precedente, potete eseguire, in alternativa:
$ LC_ALL=fr_FR $ date dim oct 26 08:17:39 CET 2003
Come potete vedere, il risultato del comando viene influenzato dalla variabile di ambiente, che produrrà un risultato in francese. Se volete che la variabile di ambiente venga inglobata dai sottoprocessi (quando chiamate uno script della shell, per esempio), dovete "esportarla", usando:
$ export LC_ALL
Quando date un comando nella shell, essa lo cerca nella lista di directory contenuta nella variabile PATH. Il valore di PATH viene anche chiamato percorso di ricerca della shell.
In una installazione Debian di base, la variabile PATH degli
account utenti può non comprendere /sbin/
. Quindi, se volete
lanciare un comando tipo ifconfig
da /sbin/
, dovete
modificare PATH in maniera da includerlo. La variabile
PATH viene di solito impostata dal file di inizializzazione
~/.bash_profile
, vedere Configurare Bash, Sezione 3.2.
Alcuni comandi richiedono degli argomenti. Gli argomenti che cominciano con - o con -- vengono chiamati opzioni e controllano il comportamento del comando.
$ date Mon Oct 27 23:02:09 CET 2003 $ date -R Mon, 27 Oct 2003 23:02:40 +0100
In questo caso l'argomento -R modifica il comportamento di
date
per dare come risultato una stringa con una data compatibile
RFC-2822.
Spesso capita che vogliate che un comando funzioni su un gruppo di file, senza digitarli tutti. Il modello di espansione dei nomi dei file che utlizza metacaratteri facilita questo compito.
*
Comprende un qualsiasi gruppo di 0 o più caratteri.
Non comprende un file che inizia per ".".
?
Comprende esattamente un unico carattere.
[...]
Comprende esattamente qualsiasi carattere contenuto fra le parentesi
[a-z]
Comprende esattamente qualsiasi carattere compreso fra a e z.
[^...]
Comprende esattamente qualsiasi carattere diverso da quelli contenuti tra parentesi (escluso "^").
Come esempio, provate da voi e ragionateci su:
$ mkdir junk; cd junk; touch 1.txt 2.txt 3.c 4.h .5.txt $ echo *.txt 1.txt 2.txt $ echo * 1.txt 2.txt 3.c 4.h $ echo *.[hc] 3.c 4.h $ echo .* . .. .5.txt $ echo .[^.]* .5.txt $ echo [^1-3]* 4.h $ cd ..; rm -rf junk
Ogni comando restituisce il suo stato in uscita come valore restituito.
valore restituito = 0 se il comando è stato eseguito con successo.
valore restituito = non-zero se il comando termina con errori.
Si può accedere al valore restituito attraverso la variabile di shell $? subito dopo l'esecuzione.
$ [ 1 = 1 ] ; echo $? 0 $ [ 1 = 2 ] ; echo $? 1
Notate che, quando il valore restituito viene usato nel contesto logico della shell, il successo viene trattato come il VERO in logica. Ciò è poco intuitivo, dato che successo ha valore zero.
Vedere Condizionali, Sezione 13.2.5.
Proviamo a ricordare i seguenti comandi idiomatici della shell. Vedere Parametri della shell, Sezione 13.2.3, Redirezione, Sezione 13.2.4, Condizionali, Sezione 13.2.5, e Processamento delle righe di comando, Sezione 13.2.6 dopo aver letto questi idiomi.
Il comando
viene eseguito nella subshell nello
sfondo. I lavori nello sfondo permettono all'utente di
lanciare più programmi in una singola shell.
La gestione dei processi nello sfondo coinvolge i fondamentali della shell:
jobs
, fg
, bg
, e kill
.
Leggete le sezioni della pagina di manuale bash(1)
sotto
"SIGNALS", "JOB CONTROL", e "SHELL BUILTIN
COMMANDS". [29]
Lo standard output di comando1
viene dato allo standard input di
comando2
. Entrambi i comandi possono essere eseguiti
contemporaneamente. Questa si chiama
pipeline.
comando1
e comando2
sono eseguiti in
sequenza.
comando1
viene eseguito. Se con successo, comando2
viene eseguito in sequenza. Verrà restituito un successo se
sia comando1
che comando2
sono stati
eseguiti con successo.
comando1
viene eseguito. Se non con successo, allora anche
comando2
viene eseguito in sequenza. Verrà
restituito un successo se comando1
oppure
comando2
sono stati eseguiti con successo.
Redireziona lo standard output di comando
ad un file
foo. (sovrascrive)
Redireziona lo standard output di comando
ad un file
foo. (appende)
Redireziona sia lo standard output che lo standard error di
comando
ad un file foo.
Redireziona lo standard input di comando
ad un file
foo. Provate:
$ </etc/motd pager ... (il saluto) $ pager </etc/motd ... (il saluto) $ pager /etc/motd ... (il saluto) $ cat /etc/motd | pager ... (il saluto)
Sebbene tutte e 4 le sintassi mostrino la stessa cosa, l'ultimo esempio lancia
un comando in più, cat
e spreca risorse senza motivo.
Potete impostare un alias per i comandi usati più di frequente. Per esempio:
$ alias la='ls -la'
Da adesso in poi, la
funzionerà come abbreviazione di ls
-la, che elenca tutti i file in formato esteso.
Potete identificare il percorso esatto o l'identità di un comando tramite il
comando type
. Per esempio:
$ type ls ls is hashed (/bin/ls) $ type la la is aliased to `ls -la' $ type echo echo is a shell builtin $ type file file is /usr/bin/file
In questo caso ls
è stato usato di recente, mentre
file
no, per cui ls
è "hashed", ovvero la
shell ha un registro interno per un accesso veloce alla locazione del comando
ls
.
Esistono alcuni strumenti standard per l'elaborazione del testo, che vengono spesso utilizzati nei sistemi Unix-like.
Nessuna espressione regolare viene usata:
head
restituisce la prima parte dei file.
tail
restituisce l'ultima parte dei file.
sort
ordina le righe di testo dei file.
uniq
rimuove le righe duplicate da un file ordinato.
tr
traduce o cancella i caratteri.
diff
confronta i file riga per riga.
Si usano le espressioni regolari di base (Basic regular expression, BRE):
grep
trova il testo corrispondente al modello dato.
ed
è un editor primitivo a riga.
sed
è un editor a flusso.
vi
è un editor a schermo.
emacs
è un editor a schermo.
Si usano le espressioni regolari estese (Extended regular expression, ERE):
egrep
trova il testo corrispondente al modello dato.
awk
fa della semplice elaborazione di testo. Vedere Awk, Sezione 13.3.
perl
fa qualsiasi concepibile elaborazione di testo. Vedere Perl, Sezione 13.4.
Vedere Sostituzione delle espressioni regolari, Sezione 8.6.13, Parti di script per il piping, Sezione 8.6.18, e Brevi follie in Perl script, Sezione 8.6.20 per alcuni script di esempio.
Le espressioni regolari vengono utilizzate da molti strumenti di elaborazione del testo. Sono analoghe ai metacaratteri della shell (vedere Metacaratteri della shell, Sezione 4.3.8), ma molto più complesse e potenti.
L'espressione regolare descrive il modello corrispondente da trovare ed è fatta da caratteri di testo e da metacaratteri. Il metacarattere è semplicemente un carattere con un significato speciale. esistono due stili maggiori, BRE ed ERE, aseconda degli strumenti utilizzati, come descritto in Elaborazione del testo Unix-like, Sezione 4.4.
In ERE, i metacaratteri comprendono "\ . [ ] ^ $ * + ? ( ) { } |". L'espressione regolare significa:
c
Corrispondenza con il non-metacarattere "c".
\c
Corrispondenza con il carattere letterale "c".
.
Corrispondenza con qualsiasi carattere che includa una nuova riga.
^
Corrispondenza con l'inizio di una stringa.
$
Corrispondenza con la fine di una stringa.
\<
Corrispondenza con l'inizio di una parola.
\>
Corrispondenza con la fine di una parola.
[abc...]
Questa lista di caratteri ha corrispondenza con uno qualsiasi dei caratteri "abc...".
[^abc...]
Questa lista di caratteri negat ha corrispondenza con qualsiasi carattere tranne quelli "abc...".
r*
Ha corrispondenza con nessuna o più espressioni regolari identificate da "r".
r+
Ha corrispondenza co una o più espressioni regolari identificate da "r".
r?
Ha corrispondenza con nessuna od una espressione regolare identificata da "r".
r1|r2
Ha corrispondenza con una delle espressioni regolari identificate da "r1" or "r2".
(r1|r2)
Ha corrispondenza con una delle espressioni regolari identificate da "r1" or "r2" e la tratta come una espressione regolare tra parentesi.
In BRE i metacaratteri "+ ? ( ) { } |"
perdono il loro significato speciale; al loro posto si usano le versioni con la
backslash "\+ \? \( \) \{ \} \|". Perciò il costrutto
(r1|r2) deve essere protetto come \(r1|r2\). Siccome
emacs
, sebbene sia di base BRE, tratta "+
?" come metacaratteri, non c'è necessità di
proteggerli. Vedere Espressioni sostitutive, Sezione
4.4.2 per come il costrutto viene utilizzato.
Per esempio, grep
può essere utilizzato per eseguita una ricerca
di testo mediante l'espressione regolare:
$ egrep 'GNU.*LICENSE|Yoyodyne' /usr/share/common-licenses/GPL GNU GENERAL PUBLIC LICENSE GNU GENERAL PUBLIC LICENSE Yoyodyne, Inc., hereby disclaims all copyright interest in the program
Per le espressioni sostitutive, i caratteri seguenti hanno significati speciali:
&
Rappresenta la corrispondenza dell'espressione regolare. (usate
\& in emacs
)
\n
Rappresenta l' n-esima corrispondenza dell'espressione regolare tra parentesi.
Nelle stringhe sostitutive in Perl si usa, $n al posto di \n e & non alcun significato speciale meaning.
Per esempio:
$ echo zzz1abc2efg3hij4 | \ sed -e 's/\(1[a-z]*\)[0-9]*\(.*\)$/=&=/' zzz=1abc2efg3hij4= $ echo zzz1abc2efg3hij4 | \ sed -e 's/\(1[a-z]*\)[0-9]*\(.*\)$/\2===\1/' zzzefg3hij4===1abc $ echo zzz1abc2efg3hij4 | \ perl -pe 's/(1[a-z]*)[0-9]*(.*)$/$2===$1/' zzzefg3hij4===1abc $ echo zzz1abc2efg3hij4 | \ perl -pe 's/(1[a-z]*)[0-9]*(.*)$/=&=/' zzz=&=
Ponete particolare attenzione allo stile delle espressioni regolari tra parentesi e a come le stringhe corrispondenti siano state usate nel processo di sostituzione del testo dai vari strumenti.
Queste espressioni regolari possono anche essere usate per i movimenti del cursore e la sostituzione del testo negli editor.
Per imparare questi comandi, leggete le loro pagine di manuale.
Nei sistemi operativi GNU/Linux e negli altri Unix-like, i
file sono organizzati in directory. [30] Tutti i file
e le directory sono organizzati in un unico grande albero, la
gerarchia dei file, la cui radice è /
.
Questi file e directory possono essere sparsi su vari device. Il comando
mount(8)
attacca il file system trovato su un device al grande
albero. Al contrario, il comando umount(8)
lo staccherà
nuovamente.
I principi basilari:
I nomi dei file dipendono dai caratteri maiuscoli o minuscoli. Ovvero,
MIOFILE
e MioFile
sono file
differenti.
La root directory è definita semplicemente come /
. Non confondete
questa "root" con l'utente root. Vedere Login come root al prompt dei comandi, Sezione 4.1.1.
Ciascuna directory ha un nome che può contenere sia lettere che simboli
tranne /
. [31] La root directory fa eccezione; il suo nome è
/
(pronunciato "slash" o "la root directory")
e non può essere rinominata.
Ciascun file o directory viene designato da un fully-qualified
filename, absolute filename, o path,
che fornisce la sequenza delle directory che devono esserre attraversate per
raggiungerlo. I tre termini sono sinonimi. Tutti gli absolute filenames
iniziano con la directory /
, e c'è una /
fra ciascuna
directory o file nel filename. La prima /
è il nome della
directory, mentre le altre sono dei semplici separatori per distinguere le
varie parti del.
Le parole possono confondere. Prendiamo il seguente esempio:
/usr/share/keytables/us.map.gz
Questo è un fully-qualified filename; alcuni lo chiamano path.
Comunque sia, ci si riferisce anche a us.map.gz
da solo come un
filename. [32]
La root directory ha un certo numero di branche, come /etc/
e
/usr/
. Queste sottodirectory a turno si dividono in altre
sottodirectory, come /etc/init.d/
e /usr/local/
. Il
loro insieme è definito l'albero delle directory.
Potete immaginare l'absolute filename come un percorso che parte dalla base
dell'albero (/
) fino alla fine di qualche ramo (un file).
Sentirete anche definire l'albero delle directory come se fosse un albero
genealogico: per cui le sottodirectory hanno dei
genitori, ed un path mostra la completa storia familiare di un
file.
Esiste anche un path relativo, cha ha inizio altrove rispetto alla root
directory. Ricordate che la directory ../
si riferisce alla
directory genitore.
Non esiste alcuna directory corrispondente ad un dispositivo fisico, tipo il vostro disco rigido. In ciò sta la differenza rispetto a CP/M, DOS, e Windows, dove tutti i paths iniziano con il nome di un dispositivo, come C:\. Vedere Il concetto di filesystem in Debian, Sezione 4.5.2.
Le pratiche migliori e più dettagliate per la gerarchia dei file vengono
descritte nelFilesystem Hierarchy
Standard
. per iniziare, dovreste ricordare i seguenti fatti:
/
Una semplice /
rappresenta la root directory.
/etc/
E' il luogo dei file di configurazione generale del sistema.
/var/log/
E' il luogo per i file di log del sistema.
/home/
E' la directory che contiene tutte le home directory di tutti gli utenti non privilegiati.
Seguendo la tradizione Unix, il sistema Debian fa sì che i filesystem sotto i quali i dati fisici sui dischi rigidi e sugli altri dispositivi di memorie di massa e l'interazione con i dispositivi hardware tipo le console su schermo e le console remotes vengano rappresentati in maniera unificata.
Ciascun file, directory, pipe, o dispositivo fisico in un sistema Debian ha una
struttura di dati chiamata inode che descrive gli attributi ad
esso associati, come l'utente a cui appartiene (proprietario), il gruppo a cui
appartiene, la data di ultimo accesso, ecc.. Vedere /usr/include/linux/fs.h
per la
definizione precisa di struct inode nel sistema Debian GNU/Linux.
Questa rappresentazione unificata di entità fisiche risulta molto potente, in quanto permette l'uso degli stessi comandi per lo stesso tipo di operazioni su dispositivi complatamente differenti
Tutti i vostri file potrebbero risiedere su un disco --- oppure potreste averne 20, alcuni connessi a computer diversi situati altrove sulla rete. Non potreste distinguerli guerdando semplicemente l'albero delle directory, e quasi tutti i comandi lavorerebbero alla stessa maniera, non importa su quale dispositivo(i) fisico(i) i file risiedono realmente.
I permessi di accesso a file e directory vengono definiti separatamente per ciascuna delle seguenti tre categorie di utenti:
l' utente che è proprietario del file (u),
gli altri utenti nel gruppo a cui il file appartiene (g) e
tutti gli altri utenti (o).
Dato un file, ciascun permesso corrispondente permette:
read (lettura) (r): di esaminare il contenuto del file,
write (scrittura) (w): di modificare e
execute (esecuzione) (x): di eseguire il file come un comando.
Data una directory, ciascun permesso corrispondente permette:
read (r): di elencare i contenuti della directory,
write (w): di aggiungere o rimuovere i file nella directory e
execute (x): di accedere ai file nella.
In questo caso il permesso in esecuzione sulla directory non solo permette di leggere i file nella directory, ma anche di vedere i lori attributi, come le dimensioni e la data dell'ultima modifica.
per mostrare le informazioni sui permessi (e molto altro) dei file e delle
directory si usa ls
. Vedere ls(1)
. Quando
ls
viene invocato con l'opzione -l mostrerà le
seguenti informazioni, nell'ordine:
tipo di file (primo carattere)
-: normale
d: directory
l: collegamento simbolico
c: character device node
b: block device node
p: named pipe
s: socket
i permessi di accesso al file (i nove caratteri successivi, consistenti di tre caratteri per ciascuno, utente, gruppo ed altri, in quest'ordine)
il numero di hard links al file
il nome dell' utente a cui appartiene
il nome del gruppo a cui il file appartiene
le dimensioni del file in caratteri (bytes)
data ed ora del file (mtime)
il nome del file.
Per cambiare il proprietario del file, si usa chown
dall'account
di root. Per cambiarne il gruppo, si utlizza chgrp
o dall'account
del proprietario, o da quello di root. Per cambiare i permessi di accesso al
file ed alla directory, si usa chmod
dall'account del
proprietario, o da quello di root. La sintassi di base per manipolare un dato
file foo
file è:
# chown nuovoproprietario foo # chgrp nuovogruppo foo # chmod [ugoa][+-=][rwx][,...] foo
Vedere chown(1)
, chgrp(1)
, e chmod(1)
per i dettagli.
Per esempio, per rendere proprietario di una directory l'utente foo e condivisa da un gruppo bar, eseguite i seguenti comandi dall'account di root:
# cd /una/locazione/ # chown -R foo:bar . # chmod -R ug+rwX,o=rX .
Esistono altri tre bit di permessi speciali:
set user ID (s o S invece della x di user),
set group ID (s o S invece della x di group), and
sticky bit (t o T invece della x di other).
In questo caso l'output di ls -l
per detti bit viene dato in
maiuscolo se la modalità nascosta per i bit di esecuzione non è impostata.
Impostare set user ID su un file eseguibile permette all'utente di eseguirlo con l'owner ID del file (per esempio root). Allo stesso modo, impostare set group ID su un eseguibile permette all'utente di eseguirlo con il group ID del file (per esempio root). Poichè queste impostazioni possono causare seri problemi di sicurezza, abilitarle richide estrema cautela.
Impostare set group ID su una directory abilita lo schema di creazione dei file stile BSD, dove tutti i file creati nella directory appartengono al gruppo della directory.
Impostare lo sticky bit in una directory previene la rimozione
di un file in detta directory da un utente che non sia il proprietario del
file. Per rendere sicuro il contenuto di un file in una directory scrivibile
da tutti, come ad esempio /tmp
o in diretory scrivibile dal
gruppo, non bisogna solamente disabilitare i permessi in
scrittura del file, ma anche impostare lo sticky
bit nella directory. Altrimenti il file potrebbe essere rimosso e
sostituito da un nuovo fiole con lo stesso nome, da qualsiasi utente con
accesso in scrittura alla directory.
Ecco alcuni esempi interessanti sui permessi.
$ ls -l /etc/passwd /etc/shadow /dev/ppp /usr/sbin/pppd crw-rw---- 1 root dip 108, 0 Jan 18 13:32 /dev/ppp -rw-r--r-- 1 root root 1051 Jan 26 08:29 /etc/passwd -rw-r----- 1 root shadow 746 Jan 26 08:29 /etc/shadow -rwsr-xr-- 1 root dip 234504 Nov 24 03:58 /usr/sbin/pppd $ ls -ld /tmp /var/tmp /usr/local /var/mail /usr/src drwxrwxrwt 4 root root 4096 Feb 9 16:35 /tmp drwxrwsr-x 10 root staff 4096 Jan 18 13:31 /usr/local drwxrwsr-x 3 root src 4096 Jan 19 08:36 /usr/src drwxrwsr-x 2 root mail 4096 Feb 2 22:19 /var/mail drwxrwxrwt 3 root root 4096 Jan 25 02:48 /var/tmp
Esiste un metodo numerico alternativo di descrivere i permessi per i comandi
chmod(1)
. Questo metodo usa numeri da 3 a 4 cifre in ottale (base
8). Ogni cifra corrisponde a:
1a cifra facoltativa: la somma di set user ID (=4), set group ID (=2), e sticky bit (=1)
2a cifra: la somma dei permessi lettura (=4), scrittura (=2), e esecuzione (=1) per l' utente
3a cifra: idem per il gruppo
4a cifra: idem per other
Suona complicato, ma è in effetti molto semplice. Se guardate alle prime (2-10) colonne dell'output del comando ls -l e le leggete come una rappresentazione binaria (base 2) dei permessi dei file ("-" essendo "0" e "rwx" essendo "1"), il valore numerico diventa una rappresentazione in ottale dei permessi. [33] Provate ad esempio:
$ touch foo bar $ chmod u=rw,go=r foo $ chmod 644 bar $ ls -l foo bar -rw-r--r-- 1 penguin penguin 0 Nov 3 23:30 foo -rw-r--r-- 1 penguin penguin 0 Nov 3 23:30 bar
La maschera di default dei permessi può essere impostata tramite il comando di
shell umask
. Vedere builtins(7)
.
Per un file GNU/Linux, ci sono tre tipi di timestamp:
mtime: orario di modifica (ls -l),
ctime: orario di cambio di stato (ls -lc), e
atime: orario dell'ultimo accesso (ls -lu).
Notate che ctime non è l'orario di creazione del file.
La sovrascrittura di un file cambierà tutti e tre, mtime, ctime, e atime.
Il cambio di permessi od utente modificherà ctime e atime.
La lettura di un file ne cambierà atime.
Notate che anche una semplice lettura del file in un sistema Debian causerà una
normale operazione di scrittura del file, per aggiornare le informazioni
relative a atime nell' inode. Montare un
filesystem con l'opzione noatime farà si che il sistemi salti
questa operazione, risultando un tempo di accesso del file più breve in
lettura. Vedere mount(8)
.
Usate il comando touch(1)
per cambiare i timestamp dei file
esistenti.
Due sono i metodi per associare un dato file foo con un diverso nome bar.
un collegamento è un nome duplicato di un file esistente (ln foo bar),
un collegamento simbolico, o "symlink", è un file speciale che punta ad un altro file (ln -s foo bar).
Vedere il seguente esempio per i cambiamenti nella conta dei collegamenti e le
sottili differenze nel risultato del comando rm
.
$ echo "Contenuto Originale" > foo $ ls -l foo -rw-r--r-- 1 osamu osamu 4 Feb 9 22:26 foo $ ln foo bar # hard link $ ln -s foo baz # symlink $ ls -l foo bar baz -rw-r--r-- 2 osamu osamu 4 Feb 9 22:26 bar lrwxrwxrwx 1 osamu osamu 3 Feb 9 22:28 baz -> foo -rw-r--r-- 2 osamu osamu 4 Feb 9 22:26 foo $ rm foo $ echo "Nuovo Contenuto" > foo $ cat bar Contenuto Originale $ cat baz Nuovo Contenuto
Il collegamento simbolico ha sempre i permessi nominali di accesso impostati su "rwxrwxrwx", come mostrato nell'esempio precedente, con i permessi effettivi dettati dai permessi del file a cui punta.
La directory .
è collegata alla directory nella quale appare, per
cui la conta dei collegamenti di qualsiasi nuova directory parte da 2. La
directory ..
e collegata alla directory genitore, per cui la conta
dei collegamenti della directory aumenta all'aggiungere nuove sottodirectory.
Una named pipe è un file che agisce come una pipe. Inserite qualcosa in un file da un lato ed esce dall'altro. Da qui il nome FIFO, o First-In-First-Out: la prima cosa che infilate nella pipe è anche la prima ad uscirne.
Se avviate un processo di scrittura verso una named pipe, il processo non terminerà finchè l'informazione che viene scritta non è letta dalla pipe. Se avviate un processo di lettura dalla pipe, il processo aspetterà prima di terminare che non ci sia altro da leggere. Le dimesioni della pipe sono sempre zero --- non memorizza dati, si limita ad unire due processi, come il carattere | della shell. Comunque, poichè questa pipe ha un nome, i due processi non devono necessariamente stare sulla riga di comando, nè essere lanciati dallo stesso utente.
Provate facendo quanto segue:
$ cd; mkfifo miapipe $ echo "hello" >miapipe & # gira nello sfondo [1] 5952 $ ls -l miapipe prw-r--r-- 1 penguin penguin 0 2003-11-06 23:18 miapipe $ cat miapipe hello [1]+ Done echo hello >miapipe $ ls miapipe prw-r--r-- 1 penguin penguin 0 2003-11-06 23:20 miapipe $ rm miapipe
Il socket è simile alla named pipe (FIFO) è permette ai processi di scambiarsi informazioni. per il socket questi processi non devono girare allo stesso tempo, nè devono essere figli dello stesso genitore. Questo è il traguardo di qualsiasi comunicazione interprocesso. Lo scambio di informazioni può avvenire attraverso una rete, fra host differenti.
Un device fa riferimento ad un dispositivo fisico o virtuale presente nel sistema, come il disco rigido, la scheda grafica, lo schermo o la tastiera. Esempio di dispositivo virtuale è la console, rappresentata da /dev/console.
Esistono due tipi di device:
character device
Vi può accedere un carattere alla volta, cioè la più piccola unità di dati che vi può essere scritta è un carattere (byte).
block device
Qui vi si può accedere in unità maggiori, chiamte blocchi, che contengono un numero di caratteri. Il disco rigido è un block device.
Potete leggere e scrivere sui device, anche se il file potrebbe contenere dati
binari, incomprensibili ai comuni mortali. Scrivere direttamente i dati su
questi file può essere utile per diagnosticare problemi nelle connessioni
hardware. Per esempio, inviare un file di testo al device della stampante
/dev/lp0
oppure inviare i comandi del modem alla porta seriale
appropriata /dev/ttyS0
. Attenzione che, se eseguite
imprudentemente, queste manovre possono portare a disastri notevoli.
/dev/null
ecc.
/dev/null
è un device speciale che elimina qualsiasi cosa gli si
vada a scrivere. Se c'è qualcosa che non volete, gettatela in
/dev/null
. E' fondamentalmente un pozzo senza fondo. Se andate a
leggere /dev/null
, ottenete immediatamente un carattere
end-of-file (EOF).
/dev/zero
is simile, solo che se andate a leggerlo, ottenete il
carattere \0 (diverso dal numero zero in ASCII). Vedere File fantoccio, Sezione 8.6.34.
I numeri dei nodi dei device lanciando ls
come:
$ ls -l /dev/hda /dev/ttyS0 /dev/zero brw-rw---- 1 root disk 3, 0 Mar 14 2002 /dev/hda crw-rw---- 1 root dialout 4, 64 Nov 15 09:51 /dev/ttyS0 crw-rw-rw- 1 root root 1, 5 Aug 31 03:03 /dev/zero
Qui,
/dev/hda
ha come numero primario 3 e come secondario 0. E'
accessibile in lettura/scrittura dall'utente che appartiene al gruppo
disk,
/dev/ttyS0
ha come numero primario 4 e come secondario 64. E'
accessibile in lettura/scrittura dall'utente che appartiene al gruppo
dialout group e
/dev/zero
ha come numero primario 1, secondario 5. E' accessibile
in lettura/scrittura da chiunque.
Nei vecchi sistemi il processo di installazione crea i nodi dei device tramite
il comando /sbin/MAKEDEV
command. Vedere MAKEDEV(8)
.
Nei sistemi più recenti il filesystem sotto /dev
viene popolato
automaticamente in maniera analoga al filesystem /proc
.
/proc
Il filesystem /proc
è uno pseudo-filesystem e contiene
informazioni sul sistema e sui processi in corso.
La gente in genere si spaventa quando nota un file in particolare -
/proc/kcore
- che è generalmente enorme. Esso è (più o meno) una
copia della memoria del vostro computer. Viene utilizzato per il debug del
kernel. In pratica non esiste da nessuna parte, per cui non preoccupatevi
delle sue dimensioni.
Vedere Mettere a punto il kernel tramite
il filesystem proc, Sezione 7.3 and proc(5)
.
Vedere X, Sezione 9.4.
X Window può essere lanciato automaticamente con xdm
-come demone
per il login grafico, o digitando quanto segue da console.
$ exec startx
Poichè l'ambiente di X è in grado di ospitare molti window manager, le loro interfacce variano molto. Ricordate che cliccando col pulsante destro del mouse sulla root window evidenzierà il menu delle scelte. Questo è sempre disponibile.
Per avviare la shell, lanciate Xterm dal menu:
"XShells" --> "XTerm".
Per scorrere graficamente le pagine web, lanciate Mozilla dal menu:
"Apps" --> "Net" --> "Mozilla Navigator".
Per visualizzare graficamente file in PDF, lanciate xpdf del menu:
"Apps" --> "Viewers" --> "Xpdf".
Se vi manca la voce nel menu, installate i pacchetti corrispondenti. Vedere Iniziare la gestione dei pacchetti Debian, Sezione 6.2.
Alcune combinazioni da ricordare quandi si è in X:
Ctrl-Alt-F1 fino a F6: Passa ad altri pseudo-terminali (da X-window, DOSEMU, ecc.)
Alt-F7: Torna ad X
Ctrl-Alt-meno: Modifica la risoluzione dello schermo in X (il meno si riferisce al tastierono numerico)
Ctrl-Alt-più: Modifica la risoluzione in X dalla parte opposta (il più si riferisce al tastierino numerico)
Ctrl-Alt-Backspace: Termina il server X
Alt-X, Alt-C, Alt-V: Le normali combinazioni Windows/Mac per Taglia, Copia, Incolla con Ctrl- in alcuni programmi tipo Netscape Composer vengono sostituite da Alt-.
In questo momento, vi raccomando la lettura delle guide fondamentali da
The Linux Documentation
Project: Guides
:
"The Linux System Administrators' Guide",
Copre tutti gli aspetti del mantenimento di un sistema in funzione, gestione degli account utente, backup, configurazione del sistema.
pacchetto: sysadmin-guide
"The Linux Network Administrator's Guide, Second Edition",
Riferimento per l'amministrazione di rete in ambiente Linux.
pacchetto: (not available)
file: (not applicable)
Linux: Rute User's Tutorial and Exposition
Un bel libro e versione on line che copre l'amministrazione dei sistemi GNU/Linux.
Di Paul Sheer
Pubblicato da Prentice Hall
Pacchetto: rutebook
(da non-free)
File: /usr/share/doc/rutebook/
Vedere Supporto per Debian, Capitolo 15 per ulteriori fonti di apprendimento.
[ precedente ] [ Contenuti ] [ 1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ] [ 7 ] [ 8 ] [ 9 ] [ 10 ] [ 11 ] [ 12 ] [ 13 ] [ 14 ] [ 15 ] [ A ] [ successivo ]
La guida Debian
CVS, gio gen 18 11:52:32 UTC 2007osamu#at#debian.org
mc0315#at#mclink.it