Linux ha un file system---intendendo con cio' ``la struttura delle directory e dei file in esse contenuti''---molto simile a quello del DOS. I file hanno dei nomi che seguono certe regole, sono messi in directory, alcuni sono eseguibili, e tra questi ultimi molti hanno degli switch. Inoltre, ci sono i caratteri wildcards, la redirezione e il piping. Ci sono solo alcune piccole differenze:
Ecco.un_NOME_molto.LUNGO
. Notare che ho usato lettere maiuscole e
minuscole: infatti...
FILENAME.tar.gz
e filename.tar.gz
sono due file diversi.
ls
è un comando, LS
è un errore;
'*'
alla fine del loro nome quando si dà il comando
ls -F
. Per esempio:
$ ls -F
lettera.txt cindy.jpg cjpg* Direttorio/ script* old~
I files cjpg*
e script*
sono eseguibili---``programmi''.
Sotto DOS, i file di backup hanno il nome che finisce in .BAK, sotto Linux
finiscono con una tilde '~
'. Inoltre, un file il cui nome inizia
con un punto viene considerato un file nascosto. Per esempio, il file
.Io.sono.nascosto
non apparirà dopo il comando ls
.
/switch
, con i
programmi Linux si ottengono con -switch
or --switch
. Esempio:
dir /s
diventa ls -R
. Notare che molti programmi DOS, come
PKZIP o ARJ, hanno gli switch in stile Unix.
Ora potete saltare alla sezione Tradurre i comandi dal DOS a Linux, ma se fossi in voi continuerei a leggere.
Unix ha un tipo di file che il DOS non ha: il link simbolico. Questo è un
puntatore ad un file o directory, e può essere usato al posto del file o
directory a cui punta; è molto simile a XXXXX di Windows 95. Esempi di link
simbolici sono /usr/X11
, che punta a /usr/X11R6
;
/dev/modem
, che punta a /dev/cua0
o /dev/cua1
.
Per fare un link simbolico:
$ ln -s <file_o_dir> <nomelink>
Esempio:
$ ln -s /usr/doc/g77/DOC g77manual.txt
Ora potete riferirvi a g77manual.txt
al posto di
/usr/doc/g77/DOC
.
I file e le directory DOS hanno i seguenti attributi: A (archivio), H (hidden, nascosto), R (read-only, solo lettura), and S (system, file di sistema). Solo H e R hanno senso sotto Linux: i files nascosti iniziano con un punto, e per quanto riguarda l'attributo R, continuate a leggere.
Sotto Unix un file ha dei ``permessi'' e un proprietario, che appartiene ad un ``gruppo''. Guardate questo esempio:
$ ls -l /bin/ls
-rwxr-xr-x 1 root bin 27281 Aug 15 1995 /bin/ls*
Il primo campo contiene i permessi del file /bin/ls
,
che appartiene a root, gruppo bin. Tralasciando le altre informazioni (il
libro di Matt Welsh è lì per quello), ricordate che -rwxr-xr-x
significa (da sinistra a destra):
-
è il tipo di file (- = file normale, d = directory, l = link,
etc.); rwx
sono i permessi per il proprietario del file (read, write,
execute); r-x
sono i permessi per il gruppo cui il proprietario del
file appartiene (non spiegherò il concetto di gruppo, ne potete fare a meno
finché siete principianti ;-) r-x
sono i permessi per tutti gli altri
utenti (read, execute).
Ecco perché non potete cancellare il file /bin/ls
, a meno che non
siate root: non avete i permessi necessari. Per cambiare i permessi di un
file, il comando è:
$ chmod <whoXperm> <file>
dove who è u
(user, cioè proprietario), g
(group, gruppo), o
(other, altri), X è +
o -
, perm è r
(read, lettura), w
(write, scrittura), o x
(execute, esecuzione). Esempi:
$ chmod u+x file
setta il permesso di esecuzione per il proprietario. Scorciatoia:
chmod +x file
.
$ chmod go-wx file
toglie i permessi di scrittura ed esecuzione per tutti tranne il proprietario.
$ chmod ugo+rwx file
dà a tutti i permessi di lettura, scrittura ed esecuzione.
# chmod +s file
rende un file ``setuid'' o ``suid'': ciascuno lo può eseguire con i permessi di root.
Una maniera più breve di riferirsi ai permessi è con i numeri:
rwxr-xr-x
può essere espresso con 755 (ogni lettera corrisponde a un
bit: ---
è 0, --x
è 1, -w-
è 2, -wx
è 3...). Sembra
difficile, ma con un po' di pratica capirete il concetto.
root, essendo il cossiddetto superutente, può cambiare i permessi di ogni file. C'è molto di più sull'argomento---LMP.
Alla sinistra, i comandi DOS; a destra, i corrispondenti comandi Linux.
COPY: cp
DEL: rm
MOVE: mv
REN: mv
TYPE: more, less, cat
Operatori per la redirezione e il plumbing: < > >> |
Wildcards: * ?
nul: /dev/null
prn, lpt1: /dev/lp0 or /dev/lp1; lpr
- EXAMPLES -
DOS Linux
---------------------------------------------------------------------
C:\GUIDO>copy joe.txt joe.doc $ cp joe.txt joe.doc
C:\GUIDO>copy *.* total $ cat * > total
C:\GUIDO>copy fractals.doc prn $ lpr fractals.doc
C:\GUIDO>del temp $ rm temp
C:\GUIDO>del *.bak $ rm *~
C:\GUIDO>move paper.txt tmp\ $ mv paper.txt tmp/
C:\GUIDO>ren paper.txt paper.asc $ mv paper.txt paper.asc
C:\GUIDO>print letter.txt $ lpr letter.txt
C:\GUIDO>type letter.txt $ more letter.txt
C:\GUIDO>type letter.txt $ less letter.txt
C:\GUIDO>type letter.txt > nul $ cat letter.txt > /dev/null
n/a $ more *.txt *.asc
n/a $ cat section*.txt | less
Note:
more
, premere SPAZIO per leggere il file,
`q' o CTRL-C per uscire. less
è più intuitivo, si possono usare i tasti
freccia;
UNDELETE
, quindi pensarci bene prima di cancellare;
< > >>
del DOS, Linux ha 2>
per
redirigere i messaggi di errore (stderr); inoltre, 2>&1
redirige
stderr su stdout, mentre 1>&2
redirige stdout su stderr;
[]
. Uso: [abc]*
prende i file che cominciano con a, b, c; *[I-N,1,2,3]
prende i file
che finiscono con I, J, K, L, M, N, 1, 2, 3;
RENAME
alla DOS; cioè, mv
*.xxx *.yyy
non funziona;
cp -i
e mv -i
per essere avvisati se un file sta per
essere sovrascritto.
Per far partire un programma, si scrive il suo nome come col DOS. Se la
directory (Sezione
Directories) dove il
programma risiede è nel PATH (Sezione
Files di inizializzazione), il programma parte. Eccezione: sotto
Linux, un programma che sta nella directory corrente non parte se la
directory non è inclusa nel PATH. Scappatoia: se prog
è il programma,
scrivere ./prog
.
Questa è una tipica linea di comando:
$ command -s1 -s2 ... -sn par1 par2 ... parn < input > output
dove -s1
, ..., -sn
sono gli switch del programma,
par1
, ..., parn
sono gli argomenti del programma. Si possono dare
più comandi sulla stessa linea:
$ command1 ; command2 ; ... ; commandn
Tutto qui per quanto riguarda i programmi, ma è facile fare dei passi avanti. Uno dei vantaggi di Linux è il multitasking: può far girare più programmi (d'ora in poi, processi) allo stesso tempo. Si possono lanciare programmi in background e continuare a lavorare. Inoltre, Linux mette a disposizione più sessioni di lavoro contemporanee: è come avere tanti computer allo stesso tempo!
$ ALT-F1 ... ALT-F6
$ su - <loginname>
Esempio:
$ su - root
Questo è utile, tra l'altro,
per usare i floppy (Sezione
Floppies):
normalmente, solo root lo può fare.
$ exit
Se ci sono dei job sospesi (vedi più avanti) si viene avvisati.
$ progname [-switches] [parameters] [< input] [> output]
&
' alla fine della linea di comando:
$ progname [-switches] [parameters] [< input] [> output] &
[1] 123
la shell identifica i processi dando loro un numero (es. [1]
; vedi
sotto) e un PID (123 nel nostro esempio).
$ ps -a
Questo comando dà una lista dei processi attualmente in esecuzione.
$ kill <PID>
Potreste dover uccidere un processo se non sapete come uscire normalmente...
;-). A volte, un processo si può uccidere solo con uno dei comandi seguenti:
$ kill -15 <PID>
$ kill -9 <PID>
Oltre a questo, la shell consente di fermare o sospendere un processo,
mandare un processo in background, e portare un processo dal background in
primo piano. In questo contesto, i processi sono chiamati `job'.
$ jobs
qui i job sono identificati dal loro numero, non dal PID.
$ CTRL-C
$ CTRL-Z
$ bg <job>
$ fg <job>
$ kill <%job>
dove <job> può essere 1, 2, 3, ... Usando questi comandi si può
formattare un disco, zippare dei files, compilare un programma e
decompattare un archivio tutto allo stesso tempo, e ancora avere il prompt a
disposizione. Provate a farlo col DOS! E provate con Windows, giusto per
vedere la differenza in performance.
Per eseguire un programma su un computer remoto il cui indirizzo IP è
remote.bigone.edu
, si fa:
$ telnet remote.bigone.edu
Dopo il login, si fa partire il programma. Ovviamente, bisogna avere un account sul computer remoto.
Se avete X11, si possono far girare anche applicazioni X sul computer
remoto, e queste verranno visualizzate sul vostro schermo. Siano
remote.bigone.edu
il computer remoto e local.linux.box
il vostro
PC. Per far girare da local.linux.box
un programma X che sta su
remote.bigone.edu
, si fa:
xterm
o equivalente emulatore di
terminale, poi digitare:
$ xhost +remote.bigone.edu
$ telnet remote.bigone.edu
remote:$ DISPLAY=local.linux.box:0.0
remote:$ progname &
(invece di DISPLAY...
, potreste dover scrivere: setenv DISPLAY local.linux.box:0.0
. Dipende dalla shell remota.)Et voila! Ora progname
parte su remote.bigone.edu
e viene
visualizzato sulla vostra macchina. È però meglio non provarci tramite PPP.