Copyright © 1996, 1997, 1998 University Technology Services, The Ohio State University.
Traduzione a cura di Marco Trentini <mark@remotelab.org>.
Questo documento introduce il vasto mondo dei sistemi operativi Unix e lo fa in stile manualistico. Unix non è un sistema operativo unico, come molti potrebbero pensare, bensì è una grande famiglia di sistemi operativi (come ad esempio FreeBSD, NetBSD, OpenBSD, BSD, AIX, System V, SunOS, varie distribuzioni di Linux, ecc.), aventi comandi e caratteristiche simili e disponibili per molte architetture hardware (come ad esempio x86, alpha, ecc.).
Copyright e URL rivisti nel Settembre 1998.
© 1996-1998 University Technology Services, The Ohio State University, Baker Systems Engineering Building, 1971 Neil Avenue, Columbus, OH 43210.
Tutti i diritti riservati. La ridistribuzione e l'uso, con o senza modifiche, sono permesse purchè siano rispettate le seguenti condizioni:
La ridistribuzione deve contenere la precedente nota di copyright, questa lista di condizioni, e il seguente disclaimer.
Né il nome dell'Università né i nomi dei suoi contributori possono essere usati per appoggiare o promuovere prodotti o servizi derivanti da questo documento senza un precedente specifico permesso scritto.
QUESTA PUBBLICAZIONE VIENE FORNITA “COSÌ COM'È” SENZA NESSUN TIPO DI GARANZIA. QUESTA PUBBLICAZIONE PUÒ CONTENERE IMPRECISIONI TECNICHE O ERRORI TIPOGRAFICI.
Unix è un marchio registrato della The Open Group, AT&T è un marchio registrato della American Telephone and Telegraph, Inc.
Questo documento è rivolto in prevalenza a quelle persone che si avvicinano per la prima volta a Unix, ma non solo.
Prima di iniziare ad esporre la traduzione di questo documento volevo dire alcune cose. Alcune parole del testo originale in lingua inglese non sono state tradotte in italiano, vuoi perchè la rispettiva traduzione in italiano non è efficiente in termini di comprensibilità, vuoi perchè è di uso comune far riferimento a queste direttamente in lingua inglese (vedi login, quoting, built-in, here document, shell, background, pipe, script, ecc.). Inoltre mi è sembrato opportuno e logico modificare l'ultima sezione di questo documento, bibliografia di Unix (testi in lingua inglese), in una breve bibliografia italiana di Unix. Infine ho aggiunto un glossario dove poter trovare un elenco dei termini inglesi più caldi incontrati in questo documento e il loro significato corrispondente.
Non mi resta che augurarvi una buona lettura.
Per fornire un testo consistente e facile da leggere, sono state seguite numerose convenzioni in tutto il libro.
Un font italico è per i nomi dei file, per gli URL, per il testo enfatizzato, e per il primo utilizzo dei termini tecnici.
MonospazioUn font monospazio è usato per i messaggi di
errore, i comandi, le variabili di ambiente, i nomi di host, i nomi degli utenti, i nomi
dei gruppi, i nomi dei device, le variabili, e i frammenti di codice.
Un font in grassetto è per le applicazioni, i comandi, e i tasti.
I tasti sono visualizzati in grassetto per differenziarli dal testo normale. Le combinazioni di tasti che devono essere digitate contemporaneamente sono visualizzate con un `+' tra i tasti, come:
Ctrl+Alt+Del
I tasti che devono essere digitati in sequenza saranno separati da virgole, come per esempio:
Ctrl+X, Ctrl+S
Vuol dire che l'utente deve digitare i tasti Ctrl e X contemporaneamente e poi i tasti Ctrl e S.
1965 Bell Laboratory con la collaborazione del MIT e della General Eletric lavorano per la realizzazione di un nuovo sistema operativo, Multics, il quale vuole fornire, come principali caratteristiche, capacità multi-utente (multi-user), multi-processo (multi-processor) e un file system multi-livello (gerarchico) (multi-level file system).
1969 AT&T era infelice del progresso di Multics e abbandona il progetto. Ken Thompson, Dennis Ritchie, Rudd Canaday e Doug McIlroy, alcuni programmatori dei Bell Lab che avevano lavorato nel progetto Multics, progettano e implementano su un PDP-7 la prima versione del file system Unix insieme ad alcune utility. Il nome Unix è stato assegnato da parte di Brian Kernighan come gioco di parole su Multics.
1 Gennaio 1970 Inizio di Unix.
1971 Il sistema ora gira su un PDP-11 con 16 Kbyte di memoria, di cui 8 Kbyte per i programmi utente, e con un disco di 512 Kbyte.
Il suo primo reale impiego è come strumento di manipolazione del testo in esclusiva per il dipartimento dei Bell Lab. Quel tipo di utilizzo giustifica ulteriormente la ricerca e lo sviluppo attraverso la programmazione di gruppo. Unix attira i programmatori perchè è stato progettato con queste caratteristiche:
ambiente di programmazione;
semplice interfaccia utente;
semplici utility che possono essere combinate per realizzare potenti funzioni;
file system gerarchico (ad albero);
semplice interfacciamento con i dispositivi, in armonia con il formato dei file;
sistema multi-utente e multi-processo;
architettura indipendente e trasparente all'utente.
1973 Unix è riscritto prevalentemente in C, un nuovo linguaggio di programmazione sviluppato da Dennis Ritchie. La codifica in questo linguaggio di alto livello diminuisce fortemente lo sforzo necessario per portare Unix su nuove macchine.
1974 Thompson e Ritchie descrivono in una relazione pubblicata in un comunicato dell'ACM il nuovo sistema operativo Unix. Unix genera entusiasmo nella comunità accademica che lo vede come un potente strumento di insegnamento per lo studio della programmazione di sistemi. Poichè il decreto del 1956 impedisce ad AT&T di commercializzare il prodotto, viene concessa una licenza all'Università per scopi educativi e una per esistenza commerciale.
1977 Ci sono circa 500 siti Unix nel mondo.
1980 BSD 4.1 (software sviluppato da Berkeley).
1983 SunOS, BSD 4.2, Sys V.
1984 Ci sono circa 100.000 siti Unix che girano su differenti piattaforme hardware, con differenti capacità.
1988 AT&T e Sun Microsystem sviluppano System V Release 4 (SVR4). Questo sarà in futuro implementato in UnixWare e Solaris 2.
1993 Novell compra Unix da AT&T.
1994 Novell porta il nome UNIX a X/OPEN.
1995 Santa Cruz Operation compra UnixWare da Novell. Santa Cruz Operation e Hewlett-Packard annunciano lo sviluppo di una versione di Unix a 64 bit.
1996 International Data Corporation prevede che nel 1997 ci saranno 3 milioni di sistemi Unix nel mondo.
Unix è un sistema operativo a strati. Lo strato più interno è l'hardware il quale fornisce servizi al OS. Il sistema operativo (OS), riferito in Unix come al kernel, interagisce direttamente con l'hardware e fornisce i servizi ai programmi utente. I programmi utente non necessitano di conoscere informazioni sull'hardware. Devono solo sapere come interagire con il kernel ed è quest'ultimo a fornire i servizi richiesti. Uno dei più grandi fattori che ha contribuito alla richiesta di Unix da parte dei programmatori è stato che molti programmi utente corretti sono indipendenti dall'hardware sottostante, e ciò li rende facilmente trasportabili su nuovi sistemi.
I programmi utente interagiscono con il kernel attraverso un set di system call (chiamate di sistema) standard. Queste system call chiedono dei servizi, servizi che saranno forniti dal kernel. Così i servizi possono includere un accesso a un file: aprire, chiudere, leggere, scrivere un file, creare un link o eseguire un file; creare o aggiornare degli account (informazioni relative ad un utente come nome, password, ecc.); cambiare il proprietario di un file o di una directory; spostarsi in una nuova directory; creare, sospendere o terminare un processo; abilitare l'accesso a un dispositivo hardware e impostare dei limiti sulle risorse di sistema.
Unix è un sistema operativo multi-user (multi-utente) e multi-tasking (multi-processo). Si possono avere molti utenti “loggati” simultaneamente nel sistema (multi-user), ognuno dei quali esegue alcuni programmi (multi-tasking). È compito del kernel mantenere ogni processo e ogni utente separato e regolare l'accesso all'hardware di sistema, inclusa la cpu, la memoria, il disco e altri dispositivi di I/O.
FIGURA 2.1 Struttura di un sistema Unix _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ | | | Programmi | | _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ | | | | | | | Kernel | | | | _ _ _ _ _ _ _ _ _ _ _ _ _ _ | | | | | Hardware | | | | | |_ _ _ _ _ _ _ _ _ _ _ _ _ _| | | | | | | | | System Call | | | |_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _| | | | |_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|
L'aspetto del file system di Unix è paragonabile alla struttura rovesciata di un albero. Si parte dall'alto con la directory root, denotata con /, per poi scendere attraverso sotto-directory sottostanti la root.
FIGURA 2.2 Struttura del file system di Unix
/(root) 1 livello
| | | | |
bin dev etc tmp usr 2 livello
| | | | | | | | |
sh date csh ttya cua0 passwd group bin lib 3 livello
|
gcc 4 livello
.... n livello
Ogni nodo è o un file o una directory di file, dove quest'ultima può contenere altri file e directory. Un file o una directory vengono specificati attraverso il loro path name (percorso del nome del file o della directory), il quale può essere un path name assoluto oppure un path name relativo ad un'altra locazione. Un path name assoluto inizia con la directory root, /, seguono poi i “rami” del file system, ognuno separato da /, fino a raggiungere il file desiderato, come per esempio:
/home/condron/source/xntp
Un path name relativo specifica un percorso relativo ad un altro path name, che usualmente è la directory di lavoro corrente in cui ci si trova. Sono ora introdotte due directory speciali:
. la directory corrente
.. la directory padre della directory corrente
Quindi se si è in /home/frank e si desidera specificare un path nel modo relativo si può usare:
../condron/source/xntp
Questo indica che si deve prima salire di un livello di directory, quindi passare attraverso la directory condron, seguire la directory source e quindi xntp.
Ogni directory e ogni file sono inclusi nella loro directory padre. Nel caso della directory root, la directory padre è se stessa. Una directory è un file contenente una tabella che elenca i file contenuti nella directory stessa, dove ai nomi dei file in lista vengono assegnati i corrispondenti numeri di inode. Un inode è un file speciale, progettato per essere letto dal kernel al fine di conoscere alcune informazioni su ciascun file. Un inode specifica i permessi del file, il proprietario del file, la data di creazione, quella dell'ultimo accesso e quella dell'ultima modifica del file e la posizione fisica dei blocchi di dati sul disco che contengono il file.
Il sistema non richiede qualche struttura particolare per i dati contenuti nel file. Il file può essere ASCII o binario o una combinazione di questi e può rappresentare dati testuali, uno script di shell, un codice oggetto compilato per un programma, una tabella di directory, robaccia o qualunque cosa si voglia.
Non c'è un'intestazione, una traccia, un'etichetta o il carattere EOF come parte del file.
Un programma o un comando interagisce con il kernel per fornire l'ambiente e realizzare le funzioni richieste dall'utente. Un programma può essere: un file di shell eseguibile, conosciuto come uno script di shell, un comando interno (built-in) alla shell o un file sorgente compilato in codice oggetto.
La shell è un interprete a linea di comando. L'utente interagisce con il kernel attraverso la shell. Si può scrivere uno script ASCII (testo) in modo tale da essere interpretato da una shell.
I programmi di sistema sono generalmente in forma binaria, compilati partendo da un codice sorgente in C. Questi si trovano in posti come /bin, /usr/bin, /usr/local/bin, /usr/ucb, ecc. Questi comandi forniscono quelle funzionalità che normalmente si pensano essere di Unix. Alcuni di questi sono sh(1), csh(1), date(1), who(1), more(1), ls(1) e molti altri.
Una volta che l'utente si è collegato a un sistema Unix, gli viene chiesto di inserire un login username (nome utente) e una password (codice segreto). Il login username è il nome univoco dell'utente sul sistema. La password è un codice modificabile conosciuto solo dall'utente. Alla richiesta di login, l'utente deve inserire lo username e alla richiesta della password, deve essere inserita la password effettiva.
Nota: Unix è un sistema case sensitive (fa distinzione tra caratteri minuscoli e maiuscoli). Quindi sia il login username che la password devono essere inseriti esattamente come sono stati creati; il login username è normalmente in minuscolo.
Molti sistemi sono configurati in modo tale da richiedere all'utente il tipo di terminale da usare, il quale dovrebbe essere settato al tipo di terminale usato nella fase di login. Molti computer lavorano se si sceglie il tipo vt100. Gli utenti connessi tramite una workstation Sun molto probabilmente useranno il tipo sun; quelli che usano un Terminale-X molto probabilmente useranno xterms oppure xterm.
Il tipo di terminale indica al sistema Unix come interagire quando una sessione viene aperta.
Può essere necessario risettare il tipo di terminale, digitando il comando:
| setenv TERM <tipo di terminale> | -se si usa la shell C (vedere Capitolo 5) |
(Inoltre su alcuni sistemi Unix, ad esempio MAGNUS, è necessario dare il comando unsetenv TERMCAP.)
oppure
| TERM=<tipo di terminale>; export TERM | -se si usa la shell Bourne (vedere Capitolo 5) |
dove <tipo di terminale> è il tipo di terminale, come vt100, che si desidera settare.
Quando viene assegnato il proprio account, si riceve una password iniziale. Questa password è importate sia per la sicurezza del sistema sia per una sicurezza personale, perciò la password per il proprio account può essere cambiata a propria scelta. Il comando per cambiare una password è passwd(1). Verrà chiesto di inserire sia la propria vecchia password, sia la nuova password desiderata, quest'ultima due volte. Se si sbaglia la propria vecchia password o non si inserisce quella nuova nello stesso modo per due volte, il sistema indicherà che la password non ha subito cambiamenti.
Alcuni amministratori di sistema hanno programmi che verificano l'accuratezza di una password (che deve essere sufficientemente criptica per assicurare una certa sicurezza al sistema). Un cambiamento di password può essere rifiutato da questi programmi.
Quando si sceglie una password, è importante che questa non sia in qualche modo indovinabile né per qualche sconosciuto che tenta di scoprirla né per un conoscente. I suggerimenti per scegliere e mantenere una password sono i seguenti:
non usare una parola (o parole) di un linguaggio;
non usare il proprio nome;
non usare informazioni che possono essere trovate nel proprio portafoglio;
non usare informazioni comunemente conosciute circa se stessi (come il soprannome, patente di guida, ecc.);
non usare caratteri di controllo. Alcuni sistemi non li accettano;
non scrivere la password in qualche posto;
non dare la propria password a *nessuno*;
usare un mix di tipi di caratteri (alfabetici, numerici, speciali);
usare un mix di caratteri maiuscoli e caratteri minuscoli;
usare un minimo di 6 caratteri;
scegliere una password in modo da poterla ricordare;
cambiare di frequente la propria password;
assicurarsi che nessuna persona vicino a voi vi guardi quando si inserisce la propria password.
Ctrl+D - indica la fine di un flusso di dati; può far uscire dal sistema un utente. L'ultimo caso è disabilitato su molti sistemi
Ctrl+C - interruzione
logout(1) - rilascia il sistema
exit(1) - rilascia la shell
Il sistema identifica un utente attraverso il numero di utente e il numero di gruppo (rispettivamente userid e groupid) assegnati dall'amministratore di sistema. Generalmente non è necessario conoscere il proprio userid e groupid, poichè il sistema traduce in modo automatico lo userid in username (e viceversa) ed il groupid in groupname (e viceversa). Probabilmente si conosce già lo username: è il nome utilizzato per il login. Il groupname non è ovvio, e in realtà si può appartenere a più di un gruppo. Il proprio gruppo primario è quello associato con il proprio username nel file database delle password, configurato dall'amministratore di sistema. Similmente, c'è un file database per i gruppi, dove l'amministratore di sistema può assegnare gruppi aggiuntivi ad un utente.
Nei seguenti esempi il simbolo % è il proprio prompt di shell e non va digitato.
Si può determinare il proprio userid e la lista dei gruppi di appartenenza con i comandi id(1) e groups(1). Su alcuni sistemi id(1) mostra le informazioni sull'utente e le informazioni sul gruppo primario, esempio:
% id uid=1101(frank) gid=10(staff)
su altri sistemi mostra anche le informazioni sui gruppi aggiuntivi di appartenenza:
% id uid=1101(frank) gid=10(staff) groups=10(staff),5(operator),14(sysadmin),110(uts)
Il comando groups(1) mostra le informazioni di tutti i gruppi di appartenenza, esempio:
% groups staff sysadmin uts operator
Un comando è un programma che chiama il sistema Unix per qualche compito. Un comando ha la forma:
comando [opzioni] [argomenti]
dove un argomento indica su cosa il comando deve realizzare la sua azione, generalmente un file o una serie di file. Un'opzione modifica il comando, cambiandone il modo di esecuzione.
I comandi sono case sensitive (sensibili alle lettere maiuscole e minuscole). comando e Comando non sono la stessa cosa.
Le opzioni sono generalmente precedute da un trattino (-) e per molti comandi, più opzioni possono essere messe insieme nella forma:
comando -[opzione][opzione][opzione]
esempio:
ls -alR
che mostrerà un listato lungo di tutti i file che si trovano nella directory corrente e ricorsivamente anche quelli che si trovano in tutte le sotto-directory.
In molti comandi si possono separare le opzioni, facendole precedere ognuna da un trattino, esempio:
comando -opzione1 -opzione2 -opzione3
come in:
ls -a -l -R
Alcuni comandi hanno opzioni che richiedono parametri. Le opzioni che richiedono parametri sono di solito specificate separatamente, esempio:
lpr -Pprinter3 -#2 file
che trasmetterà 2 copie del file specificato a printer3.
Ci sono delle convenzioni standard per i comandi. Comunque, non tutti i comandi Unix seguono questo standard. Alcuni non richiedono il trattino prima dell'opzione e alcuni non permettono di mettere insieme più opzioni, per esempio alcuni possono richiedere che ogni opzione sia preceduta da un trattino e separata con uno spazio bianco da un'altra opzione o argomento.
Le opzioni e la sintassi di un comando sono mostrate nelle pagine man del comando.
I tasti di controllo sono usati per realizzare speciali funzioni su linea di comando o all'interno di un editor. Queste funzioni possono essere generate premendo contemporaneamente il tasto control e alcuni altri tasti. Questa combinazione è generalmente indicata con Ctrl+Tasto (oppure ^+Tasto). Control+S può essere scritto come Ctrl+S (oppure ^+S). Con i tasti di controllo le lettere maiuscole e minuscole sono la stessa cosa, così Ctrl+S è lo stesso di Ctrl+s. Questo particolare esempio (Ctrl+S) è un segnale di stop e dice al terminale di non accettare più input. Il terminale rimarrà sospeso finchè un segnale di start Ctrl+Q non sarà generato.
Ctrl+U è normalmente il segnale di “cancellazione di linea” per il proprio terminale. Quando lo si digita, l'intera linea di input viene cancellata.
Nell'editor vi(1) si possono inserire i tasti di controllo all'interno del file di testo facendo seguire a Ctrl+V il carattere di controllo desiderato; così per inserire in un documento Ctrl+H si digita Ctrl+V, Ctrl+H.
stty(1) mostra o configura le opzioni di controllo del terminale. L'abbreviazione “tty” risale fino ai giorni dei “teletypewrite”, che erano associati alla trasmissione di messaggi telegrafici ed erano primitivi modelli di terminali di computer.
Per i nuovi utenti, l'uso principale del comando stty(1) riguarda l'assegnazione della funzione di “cancellazione di linea” ad un tasto specifico per i loro terminali. Per i programmatori di sistema o per chi scrive script di shell, il comando stty(1) fornisce uno strumento prezioso per la configurazione di molti aspetti legati al controllo di I/O di un dispositivo specifico, inclusi i seguenti:
carattere di erase (eliminazione carattere) e di line-kill (eliminazione linea);
velocità di trasmissione dati;
controllo di parità sulla trasmissione dati;
controllo del flusso hardware;
carattere di nuova linea (<NL>), di return (<CR>) e di alimentazione linea (<LF>);
interpretazione del carattere tab;
modifica di un input grezzo;
trasformazione di lettere minuscole in lettere maiuscole.
Il comando stty(1) è molto dipendente dal sistema, quindi consultare le relative pagine man sul proprio sistema per i dettagli.
Sintassi
stty [opzioni]
Opzioni generali
(none) |
mostra i settaggi del terminale |
all (-a) |
mostra tutte le opzioni |
echoe |
richiama ERASE come BS-spazio-BS |
dec |
imposta la modalità specifica dei sistemi operativi conformi al Digital Equipment Corporation (che distinguono ERASE da BACKSPACE) (non disponibile su tutti i sistemi) |
kill |
imposta il carattere per LINE-KILL |
erase |
imposta il carattere per ERASE |
intr |
imposta il carattere per INTERRUPT |
Esempi:
Con il comando stty(1) si possono
visualizzare e cambiare i settaggi del proprio terminale di controllo. Per visualizzare
tutti (-a) i settaggi correnti:
% stty -a speed 38400 baud, 24 rows, 80 columns parenb -parodd cs7 -cstopb -hupcl cread -clocal -crtscts -ignbrk brkint ignpar -parmrk -inpck istrip -inlcr -igncr icrnl -iuclc ixon -ixany -ixoff imaxbel isig iexten icanon -xcase echo echoe echok -echonl -noflsh -tostop echoctl -echoprt echoke opost -olcuc onlcr -ocrnl -onocr -onlret -ofill -ofdel erase kill werase rprnt flush lnext susp intr quit stop eof ^H ^U ^W ^R ^O ^V ^Z/^Y ^C ^\ ^S/^Q ^D
Per cambiare i settaggi usando stty(1), ad esempio per cambiare il carattere di erase da Ctrl+? (il tasto elimina) a Ctrl+H:
% stty erase ^H
Questo setterà l'opzione del terminale solamente per la sessione corrente. Per far in modo che questo comando sia eseguito automaticamente ad ogni login, è possibile inserire tale comando nel file .login o .profile di cui si parlerà più avanti.
Il manuale di Unix, usualmente chiamato man page (pagine man), è disponibile per spiegare l'uso del sistema Unix e dei suoi comandi. Per servirsi di una pagina man digitare il comando man(1) al prompt di sistema seguito dal comando di cui si necessitano informazioni.
Sintassi
man [opzioni] nome_comando
Opzioni generali
-k parola_chiave |
mostra alcune linee riassuntive dei comandi contenenti la parola chiave richiesta |
-M path |
percorso per le pagine man |
-a |
mostra tutte le pagine man trovate (SVR4) |
Esempi:
Si può usare man(1) per ottenere
una linea riassuntiva di alcuni comandi che contengono la parola che si vuole ricercare
con l'opzione -k, ad esempio per cercare la parola password, si digita:
% man -k password passwd (5) - password file passwd (1) - cambia la password
Il numero in parentesi indica la sezione delle pagine man dove sono stati trovati i riferimenti. Si può accedere a quella pagina man (di default si fa riferimento al numero di sezione più basso, ma si può usare un'opzione su linea di comando per specificarne uno differente) con:
% man passwd PASSWD(1) USER COMMANDS PASSWD(1) NOME passwd - cambia password SINTASSI passwd [ -e login_shell ] [ username ] DESCRIZIONE passwd cambia (o setta) la password di un utente. passwd chiede per due volte la nuova password, senza mostrarla. Questo per prendere in considerazione la possibilità di digitare errori. Solamente l'utente stesso e il super-user possono cambiare la password di un utente. OPZIONI -e Cambia la shell di login dell'utente.
Qui l'output è stato parafrasato e troncato per una questione di spazio e di copyright.
Il file system di Unix è organizzato come la struttura ramificata di un albero a partire da root. La directory root del sistema è rappresentata dal carattere di slash in avanti (/). Le directory di sistema e quelle degli utenti sono organizzate sotto la directory root. In Unix l'utente non ha una directory root; generalmente dopo il login gli utenti vengono posizionati nella loro directory home. Gli utenti possono creare altre directory sotto la loro directory home. La tabella che segue mostra alcuni comandi per la navigazione tra directory.
Tabella 3-1. Comandi di navigazione e controllo delle directory
| Comando/Sintassi | Cosa fa |
|---|---|
| cd [directory] | cambia directory |
| ls [opzioni][directory o file] | lista il contenuto della directory o i permessi del file specificato |
| mkdir [opzioni] directory | crea una directory |
| pwd | mostra la directory (corrente) di lavoro |
| rmdir [opzioni] directory | rimuove una directory |
Se si ha una certa familiarità con DOS la tabella che segue paragona i suoi simili comandi a quelli Unix in modo tale da fornire un appropriato quadro di riferimento.
Tabella 3-2. Comandi di navigazione e controllo delle directory Unix vs DOS
| Comando | Unix | DOS |
|---|---|---|
| lista il contenuto di una directory | ls | dir |
| crea una directory | mkdir | md & mkdir |
| cambia directory | cd | cd & chdir |
| rimuove una directory | rmdir | rm & rmdir |
| ritorna alla directory home dell'utente | cd | cd\ |
| mostra la directory corrente di lavoro | pwd | cd |
In ogni momento si può determinare in che punto si è nella gerarchia del file system mostrando la directory di lavoro con il comando pwd(1), esempio:
% pwd /home/frank/src
Ci si può portare in una nuova directory con il comando cd(1), cambio di directory. cd(1) accetta sia path name (percorsi) assoluti sia path name relativi.
Sintassi
cd [directory]
Esempi:
| cd (oppure chdir in alcune shell) | cambia directory |
| cd | si posiziona nella directory home dell'utente |
| cd / | si posiziona nella directory di sistema roor (/) |
| cd .. | sale di un livello di directory |
| cd ../.. | sale di due livelli di directory |
| cd /completo/path/name/da/root | cambia directory rispetto a un path name assoluto (notare lo slash iniziale) |
| cd path/da/posizione/corrente | cambia directory rispetto a un path name relativo alla posizione corrente (no slash iniziale) |
| cd ~username/directory | cambia directory rispetto alla directory home dell'utente specificato (il carattere ~ non è valido nella shell Bourne; vedere il Capitolo 5). |
La gerarchia della propria directory home si estende creando sotto-directory all'interno di essa. Questo è possibile con il comando mkdir(1), crea directory. Di nuovo si può specificare un path name assoluto o relativo della directory che si vuole creare.
Sintassi
mkdir [opzioni] directory
Opzioni generali
-p |
crea una directory intermedia (genitore), quando necessario |
-m modi |
permessi di accesso (SVR4). (Si vedranno i “modi” più avanti in questo Capitolo) |
Esempi:
% mkdir /home/frank/data
oppure se la directory di lavoro corrente è /home/frank, il seguente comando è equivalente:
% mkdir data
Per rimuovere una directory è necessario che questa sia vuota. Altrimenti bisogna prima rimuovere i file contenuti in essa. Inoltre, non si può rimuovere una directory se questa è la directory di lavoro corrente, bisogna prima uscire da quest'ultima.
Sintassi
rmdir directory
Esempi:
Per rimuovere la directory vuota /home/frank/data mentre si è in /home/frank usare:
% rmdir data
oppure
% rmdir /home/frank/data
Il comando per visualizzare le proprie directory e i propri file è ls(1). È possibile ottenere, attraverso le opzioni, informazioni circa la dimensione, il tipo, i permessi, la data di creazione, di modifica e di accesso del file.
Sintassi
ls [opzioni] [argomenti]
Opzioni generali
Quando non viene usato nessun argomento, viene mostrato il contenuto della directory corrente. Ci sono molte utili opzioni per il comando ls(1). Segue una lista di alcune di queste. Quando si usa il comando, le opzioni sono raggruppate insieme, precedute da un trattino (-).
-a |
mostra tutti i file, inclusi quelli che iniziano con un punto (.) |
-d |
mostra solo i nomi delle directory, non i file nella directory |
-F |
indica il tipo di elemento terminandolo con un simbolo: |
| directory / | |
| socket = | |
| link simbolico @ | |
| eseguibile * | |
-g |
mostra il gruppo Unix assegnato al file, richiede l'opzione -l (BSD solamente) o su una macchina SVR4, esempio Solaris, questa
opzione ha l'effetto opposto |
-L |
se il file è un link simbolico, mostra le informazioni del file o della directory a cui il link si riferisce, non le informazioni del link stesso |
-l |
listato lungo: mostra i modi, informazioni di link, il proprietario, la dimensione, la data dell'ultima modifica del file. Se il file è un link simbolico, una freccia (-->) precede il percorso del file collegato. |
Il campo modi viene fornito
dall'opzione -l e consiste di 10 caratteri. Il primo
carattere è uno dei seguenti:
| CARATTERE | SE L'ELEMENTO E' |
|---|---|
| d | directory |
| - | file ordinario |
| b | file speciale per dispositivi a blocchi |
| c | file speciale per dispositivi a caratteri |
| l | link simbolico |
| s | socket |
I 9 caratteri successivi sono raggruppati in 3 blocchi di 3 caratteri ciascuno. Indicano i permessi di accesso al file: i primi 3 caratteri si riferiscono ai permessi del proprietario del file, i successivi 3 ai permessi degli utenti del gruppo Unix assegnato al file e gli ultimi 3 caratteri ai permessi degl'altri utenti sul sistema. Possono assumere i seguenti simboli:
Esistono altri permessi, specificamente progettati per essere usati in speciali situazioni. Questi sono spiegati nelle pagine man di ls(1).
Esempi:
Per mostrare i file in una directory
% ls demofiles frank linda
Per mostrare tutti i file in una directory, inclusi i file nascosti (iniziano con un punto):
% ls -a . .cshrc .history .plan .rhosts frank .. .emacs .login .profile demofiles linda
Per avere un listato lungo:
% ls -al total 24 drwxr-sr-x 5 workshop acs 512 Jun 7 11:12 . drwxr-xr-x 6 root sys 512 May 29 09:59 .. -rwxr-xr-x 1 workshop acs 532 May 20 15:31 .cshrc -rw------- 1 workshop acs 525 May 20 21:29 .emacs -rw------- 1 workshop acs 622 May 24 12:13 .history -rwxr-xr-x 1 workshop acs 238 May 14 09:44 .login -rw-r--r-- 1 workshop acs 273 May 22 23:53 .plan -rwxr-xr-x 1 workshop acs 413 May 14 09:36 .profile -rw------- 1 workshop acs 49 May 20 20:23 .rhosts drwx------ 3 workshop acs 512 May 24 11:18 demofiles drwx------ 2 workshop acs 512 May 21 10:48 frank drwx------ 3 workshop acs 512 May 24 10:59 linda
Per creare, copiare, rimuovere file e per modificarne i permessi si possono usare i seguenti comandi.
Tabella 3-3. Comandi di gestione dei file
| Comando/Sintassi | Cosa fa |
|---|---|
| chgrp [opzioni] gruppo file | cambia il gruppo assegnato ad un file |
| chmod [opzioni] file | cambia i permessi di accesso a file o directory |
| chown [opzioni] proprietario file | cambia il proprietario di un file; può essere usato solamente dal super-user |
| cp [opzioni] file1 file2 | copia file1 in file2; file2 non dovrebbe già esistere. Questo comando crea o sovrascrive file2 |
| mv [opzioni] file1 file2 | muove (rinomina) file1 in file2 |
| rm [opzioni] file | elimina un file o una directory (-r rimuove
ricorsivamente le directory e il loro contenuto) (-i chiede
conferma prima di rimuove i file) |
Se si ha una certa familiarità con DOS la tabella che segue paragona i suoi simili comandi a quelli Unix in modo tale da fornire un appropriato quadro di riferimento.
Tabella 3-4. Comandi di gestione dei file Unix vs DOS
| Comando | Unix | Dos |
|---|---|---|
| copia un file | cp | copy |
| muove un file | mv | move (non supportato in tutte le versioni di Dos) |
| rinomina un file | mv | rename & ren |
| elimina un file | rm | erase & del |
| mostra un file a schermo | cat | type |
| mostra un file a schermo, una pagina alla volta | more, less, pg | type /p (non supportato in tutte le versioni di Dos) |
Il comando cp(1) copia il contenuto di un file in un altro file.
Sintassi
cp [opzioni] filename1 filename2
Opzioni generali
Esempi:
% cp filename1 filename2
Si hanno due copie del file, ognuna con un identico contenuto. Questi file sono completamente indipendenti tra loro e possono essere editati e modificati entrambi quando necessario. Ciascuno di essi ha il proprio inode, i propri blocchi di dati e il proprio elemento nella tabella di directory.
Il comando mv(1) rinomina (sposta) un file.
Sintassi
mv [opzioni] vecchio_file nuovo_file
Opzioni generali
-i |
interattivo (chiede conferma prima di procedere) |
-f |
non chiede la conferma quando si sovrascrive un file esistente (ignora -i) |
Esempi:
% mv vecchio_file nuovo_file
Il file nuovo_file sostituisce vecchio_file. In realtà tutto quello che è stato fatto è aver aggiornato l'elemento della tabella di directory per attribuire al file il nuovo nome. Il contenuto del file rimane come era prima della rinominazione.
Il comando rm(1) elimina un file.
Sintassi
rm [opzioni] filename
Opzioni generali
-i |
interattivo (chiede conferma prima di procedere) |
-r |
rimuove una directory ricorsivamente, rimuovendo prima i file e le directory sottostanti |
-f |
non chiede conferma prima di procedere (ignora -i) |
Esempi:
% rm filename
Visualizzando il contento della directory si vedrà che quel file non esiste
più. In realtà tutto quello che è stato fatto è aver rimosso
l'elemento dalla tabella di directory e marcato l'inode come “non usato”. Il
contenuto del file è ancora sul disco, ma ora il sistema non ha più modo di
identificare quei blocchi di dati con il nome del file eliminato. Non c'è un certo
comando per “riprendere” un file che è stato eliminato in
questo modo. Per questa ragione molti utenti alle prime armi effettuano un alias del
comando di eliminazione in rm -i dove l'opzione -i chiede di confermare prima di rimuovere il file. Simili alias
sono generalmente messi nel file .cshrc per la shell C (vedere
il Capitolo 5).
Ciascun file e directory ha permessi che stabiliscono chi può leggerlo, scriverlo e/o eseguirlo. Per scoprire i permessi assegnati a un file,
può essere usato il comando ls(1) con l'opzione
-l. Quando si ha la necessità di conoscere il gruppo
per il quale i permessi sono stati assegnati si può usare l'opzione -g insieme a ls -l (solamente BSD).
Quando si usa il comando ls -lg su un file (ls -l su SysV) l'output sarà mostrato come il seguente:
-rwxr-x--- user Unixgroup size Month nn hh:mm filename
La zona dedicata ai caratteri e trattini (-rwxr-x---) è la zona che mostra il tipo di file e i permessi del file, come spiegato nella precedente sezione. Quindi la stringa di permessi dell'esempio, -rwxr-x---, permette al proprietario user del file di leggerlo, modificarlo ed eseguirlo; gli utenti del gruppo Unixgroup del file possono leggerlo ed eseguirlo; gli altri utenti del sistema non possono accedere in alcun modo al file.
Il comando per cambiare i permessi ad un elemento (file, directory, ecc.) è chmod(1) (cambio dei modi). La sintassi richiede l'uso del comando con tre cifre (rappresentanti i permessi del proprietario (u), i permessi del gruppo (g) e i permessi degli altri utenti (o)) seguite da un argomento (che può essere un nome di un file o una lista di file e directory). Oppure può essere usato con una rappresentazione simbolica dei permessi, indicando a quale utenza questi vanno applicati.
Ogni tipo di permesso è rappresentato dal proprio numero equivalente:
lettura=4, scrittura=2, esecuzione=1
o da singoli caratteri:
lettura=r, scrittura=w, esecuzione=x
Il permesso 4 o r specifica il permesso di lettura. Se i permessi desiderati sono lettura e scrittura, il 4 (rappresentante la lettura) e il 2 (rappresentante la scrittura) sono addizionati per ottenere il permesso 6. Quindi, un permesso settato a 6 vorrà concedere un permesso di lettura e di scrittura.
Alternativamente si può usare una notazione simbolica che usa un carattere rappresentativo per l'utenza a cui ci si riferisce, uno per il permesso e uno per l'operazione, dove l'operazione può essere:
Quindi per settare i permessi di lettura e di scrittura per il proprietario del file si usa nella notazione simbolica u=rw.
Sintassi
| chmod nnn [lista argomenti] | modalità numerica |
| chmod [chi] op [perm] [lista argomenti] | modalità simbolica |
dove nnn sono i tre numeri rappresentanti i permessi del proprietario, del gruppo e degli altri utenti; chi può essere u,g,o oppure a (tutti) e perm può essere r,w,x. Nella notazione simbolica si può separare la specifica dei permessi con una virgola, come mostrato nell'esempio qui sotto.
Opzioni generali
-f |
forza (nessun messaggio di errore viene generato se la modifica non ha avuto successo) |
-R |
discesa ricorsiva attraverso la struttura delle directory e cambio dei modi |
Esempi:
Se i permessi desiderati per il file1 sono: proprietario: lettura, scrittura ed esecuzione; gruppo: lettura ed esecuzione; altri: lettura ed esecuzione; il comando da usare è:
chmod 755 file1 oppure chmod u=rwx,go=rx file1
Nota: Quando si assegnano i permessi a un file per l'utenza gruppo e per l'utenza altri è necessario che il minimo permesso di esecuzione (inteso come permesso di accesso) per la directory nella quale il file è posizionato sia abilitato. Un semplice modo per far questo è posizionarsi nella directory nella quale i permessi devo essere garantiti e digitare:
chmod 711 . oppure chmod u=rw,+x . oppure chmod u=rwx,go=x .
dove il punto (.) indica la directory corrente.
Il proprietario di un file può essere cambiato con il comando chown(8). Su molte versioni Unix questo può essere realizzato solo dal super-user, ad esempio, un utente normale non può attribuire i suoi file ad altri proprietari. chown(8) è usato come qui sotto, dove # rappresenta il prompt di shell per il super-user.
Sintassi
Opzioni generali
Esempi:
# chown nuovo_proprietario file
Con il comando chgrp(1) tutti possono cambiare il gruppo dei propri file in un altro gruppo di appartenenza.
Sintassi
chgrp [opzioni] gruppo file
Opzioni generali
Esempi:
% chgrp nuovo_gruppo file
Ci sono alcuni comandi che si possono usare per visualizzare o esaminare un file. Alcuni di questi sono editor che verranno trattati più avanti. Qui si illustreranno alcuni comandi normalmente usati per visualizzare un file.
Tabella 3-5. Comandi di visualizzazione
| Comando/Sintassi | Cosa fa |
|---|---|
| echo [stringa] | riporta in standard ouptut una stringa di testo |
| cat [opzioni] file | concatena (lista) un file |
| more (o less o pg) [opzioni] file | visualizzazione paginata di un file di testo |
| head [-numero] file | visualizza le prime 10 (o -numero) linee di un file |
| tail [opzioni] file | visualizza le ultime linee (o parte) di un file |
Il comando echo(1) viene utilizzato per ripetere l'argomento assegnato al comando nel dispositivo standard di uscita. Normalmente l'argomento termina con un carattere di alimentazione di linea, ma si può specificare un'opzione per impedirlo.
Sintassi
echo [stringa]
Opzioni generali
-n |
non stampa new-line (BSD, shell built-in) |
\c |
non stampa new-line (SVR4) |
\0n |
dove n è il codice del carattere ASCII a 8 bit (SVR4) |
\t |
tab (SVR4) |
\f |
form-feed (emissione carta) (SVR4) |
\n |
new-line (SVR4) |
\v |
tab verticale (SVR4) |
Esempi:
% echo Hello Class
oppure
% echo "Hello Class"
Per impedire il carattere di fine linea:
% echo -n Hello Class
oppure
% echo "Hello Class \c"
dove il modo utilizzato nell'ultimo esempio dipende dal comando echo(1) usato.
L'opzione \x deve
essere interna a un paio di caratteri di quoting singoli o doppi, con o senza altri
caratteri di stringa.
Il comando di concatenazione cat(1) visualizza il contenuto di un file.
Sintassi
cat [opzioni] [file]
Opzioni generali
-n |
precede ogni linea con un numero |
-v |
visualizza i caratteri non stampabili, eccetto tab, new-line e form-feed |
-e |
visualizza $ alla fine di ogni linea (prima di new-line) (quando usato con l'opzione
-v) |
Esempi:
% cat filename
Si possono specificare una serie di file su linea di comando e cat(1) li concatenerà ciascuno a turno, seguendo lo stesso ordine di immissione, esempio:
% cat file1 file2 file3
more(1), less(1) e pg permettono di visualizzare il contenuto di un file una schermata (pagina) alla volta. Inoltre permettono di ritornare sulla precedente pagina, di cercare parole, ecc. Questi comandi potrebbero non essere disponibili sul proprio sistema Unix.
Sintassi
more [opzioni] [+/schema] [filename]
less [opzioni] [+/schema] [filename]
pg [opzioni] [+/schema] [filename]
Opzioni
| more | less | pg | Azione |
|---|---|---|---|
-c |
-c |
-c |
pulisce lo schermo prima di visualizzare |
-i |
ignora differenza tra maiuscole e minuscole | ||
-w |
default | default | non esce alla fine dell'input, ma si mette in attesa di comandi |
-linee |
-linee |
# (numero di) linee di avanzamento | |
+/schema |
+/schema |
+/schema |
ricerca lo schema (pattern) |
Controlli interni
| more | visualizza (una schermata alla volta) il file specificato |
| <spazio> | per vedere la schermata successiva |
| <return>o<CR> | per avanzare di una linea |
| q | per uscire |
| h | help |
| b | torna alla schermata precedente |
| /parola | cerca parola nel resto del file |
| vedere le pagine man per altre opzioni | |
| less | simile a more(1), vedere le pagine man per le opzioni |
| pg | in SVR4 equivale a more(1) (pagina) |
Il comando head(1) visualizza l'inizio di un file.
Sintassi
head [opzioni] file
Opzioni generali
Esempi:
Di default head(1) mostra le
prime 10 linee del file. Si possono visualizzare più (o meno) linee con l'opzione
-n numero o -numero, ad esempio, per
visualizzare le prime 40 linee:
% head -40 filename
oppure
% head -n 40 filename
Il comando tail(1) visualizza la fine di un file.
Sintassi
tail [opzioni] file
Opzioni generali
Esempi:
Di default tail(1) mostra le
ultime 10 linee del file, ma si può specificare un numero differente di linee o di
byte, o un differente punto di inizio all'interno del file. Per visualizzare le ultime 30
linee di un file, usare l'opzione -numero:
% tail -30 filename
Comandi per gestire le risorse di sistema.
Tabella 4-1. Comandi per le risorse di sistema
| Comando/Sintassi | Cosa fa |
|---|---|
| chsh (passwd -e/-s) username login_shell | cambia la shell di login dell'utente (spesso solo attraverso il super-user) |
| date [opzioni] | visualizza data e ora corrente |
| df [opzioni] [risorsa] | riporta una sintesi dei blocchi del disco e degli inode liberi e usati |
| du [opzioni] [directory o file] | riporta la quantità di spazio di disco usato |
| hostname/uname | visualizza o setta (solamente super-user) il nome della macchina in uso |
| kill [opzioni] [-SEGNALE] [pid#] [%job] | manda un segnale al processo specificato dal numero di processo id (pid#) o dal numero di controllo del job (%n). Il segnale di default termina il processo |
| man [opzioni] comando | visualizza la pagina (man) del manuale relativa al comando specificato |
| passwd [opzioni] | setta o modifica la propria password |
| ps [opzioni] | mostra lo stato dei processi attivi |
| script file | salva tutto ciò che appare sullo schermo in un file fino a quando viene eseguito il comando exit |
| stty [opzioni] | setta o visualizza le opzioni del terminale di controllo |
| whereis [opzioni] comando | riporta le posizioni del file binario, del sorgente e della pagina man relative al comando specificato |
| which comando | riporta il percorso (path) del comando specificato o l'alias di shell in uso |
| who oppure w | riporta gli utenti “loggati” e i loro processi in esecuzione |
Il comando df(1) è usato per riportare il numero di blocchi del disco e di inode liberi e usati per ogni file system. Il formato dell'output e le valide opzioni sono molto specifiche dal sistema operativo e dalla versione del programma in uso.
Sintassi
df [opzioni] [risorsa]
Opzioni generali
Esempi:
{Unix prompt 1} df
Filesystem kbytes used avail capacity Mounted on
/dev/sd0a 20895 19224 0 102% /
/dev/sd0h 319055 131293 155857 46% /usr
/dev/sd1g 637726 348809 225145 61% /usr/local
/dev/sd1a 240111 165489 50611 77% /home/guardian
peri:/usr/local/backup
1952573 976558 780758 56% /usr/local/backup
peri:/home/peri 726884 391189 263007 60% /home/peri
peri:/usr/spool/mail
192383 1081 172064 1% /var/spool/mail
peri:/acs/peri/2
723934 521604 129937 80% /acs/peri/2
Il comando du(1) riporta la quantità di spazio di disco usato per i file o per le directory specificate.
Sintassi
du [opzioni] [directory o file]
Opzioni generali
-a |
mostra l'uso del disco per ogni file, non solo per le sotto-directory |
-s |
mostra solo la somma totale |
-k |
riporta in kilobyte (SVR4) |
Esempi:
{Unix prompt 3} du
1 ./.elm
1 ./Mail
1 ./News
20 ./uc
86 .
{Unix prompt 4} du -a uc
7 uc/Unixgrep.txt
5 uc/editors.txt
1 uc/.emacs
1 uc/.exrc
4 uc/telnet.ftp
1 uc/uniq.tee.txt
20 uc
Il comando ps(1) è usato per mostrare i processi correntemente eseguiti sul sistema. Il formato dell'output e le valide opzioni dipendono molto dal sistema operativo e dalla versione del programma in uso.
Sintassi
ps [opzioni]
Opzioni generali
| BSD | SVR4 | |
|---|---|---|
-a |
-e |
tutti i processi di tutti gli utenti |
-e |
ambiente di esecuzione | |
-g |
processi del gruppo amministrativo come well | |
-l |
-l |
formato lungo |
-u |
-u user |
relazione specifica di un utente |
-x |
-e |
anche i processi non eseguiti da terminali |
-f |
lista completa | |
-w |
riporta i primi 132 caratteri per linea |
Nota: Poichè il comando ps(1) è molto dipendente dal sistema, si raccomanda di consultare le pagine man del proprio sistema per i dettagli delle opzioni e per l'interpretazione dell'output di ps(1).
Esempi:
{Unix prompt 5} ps
PID TT STAT TIME COMMAND
15549 p0 IW 0:00 -tcsh (tcsh)
15588 p0 IW 0:00 man nice
15594 p0 IW 0:00 sh -c less /tmp/man15588
15595 p0 IW 0:00 less /tmp/man15588
15486 p1 S 0:00 -tcsh (tcsh)
15599 p1 T 0:00 emacs Unixgrep.txt
15600 p1 R 0:00 ps
Il comando kill(1) manda un segnale a un processo, generalmente per terminarlo.
Sintassi
kill [-SEGNALE] id-processo
Opzioni generali
Esempi:
{Unix prompt 9} kill -l
HUP INT QUIT ILL TRAP IOT EMT FPE KILL BUS SEGV SYS PIPE ALRM TERM URG STOP
TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ VTALRM PROF WINCH LOST USR1 USR2
Il segnale -KILL, anche specificato con -9 (a causa della nona posizione assunta nella lista precedente),
è il maggior segnale comunemente usato con kill(1). A differenza
di altri segnali, questo, una volta captato, non può essere ignorato dal
programma.
{Unix prompt 10} kill -9 15599
[1] + Killed emacs Unixgrep.txt
Il comando who(1) riporta chi è correntemente “loggato” nel sistema.
Sintassi
who [am i]
Esempi:
beauty condron> who wmtell ttyp1 Apr 21 20:15 (apple.acs.ohio-s) fbwalk ttyp2 Apr 21 23:21 (worf.acs.ohio-st) stwang ttyp3 Apr 21 23:22 (127.99.25.8) david ttyp4 Apr 21 22:27 (slip1-61.acs.ohi) tgardner ttyp5 Apr 21 23:07 (picard.acs.ohio-) awallace ttyp6 Apr 21 23:00 (ts31-4.homenet.o) gtl27 ttyp7 Apr 21 23:24 (data.acs.ohio-st) ccchang ttyp8 Apr 21 23:32 (slip3-10.acs.ohi) condron ttypc Apr 21 23:38 (lcondron-mac.acs) dgildman ttype Apr 21 22:30 (slip3-36.acs.ohi) fcbetz ttyq2 Apr 21 21:12 (ts24-10.homenet.)
beauty condron> who am i beauty!condron ttypc Apr 21 23:38 (lcondron-mac.acs)
Il comando whereis(1) riporta le locazioni del file sorgente, di quello binario e del file delle pagine man associate al comando.
Sintassi
whereis [opzioni] comando
Opzioni generali
-b |
riporta solamente i file binari |
-m |
riporta solamente la sezione manuale |
-s |
riporta solamente i file sorgenti |
Esempi:
brigadier: condron [69]> whereis Mail Mail: /usr/ucb/Mail /usr/lib/Mail.help /usr/lib/Mail.rc /usr/man/man1/Mail.1
brigadier: condron [70]> whereis -b Mail Mail: /usr/ucb/Mail /usr/lib/Mail.help /usr/lib/Mail.rc
brigadier: condron [71]> whereis -m Mail Mail: /usr/man/man1/Mail.1
Il comando which(1) riporta il nome del file che sarà eseguito quando il comando specificato viene invocato. Questo può essere un path name assoluto o il primo alias trovato nel proprio path.
Sintassi
which comando
Esempi:
brigadier: condron [73]> which Mail /usr/ucb/Mail
Il comando hostname(1) (uname -u su SysV) riporta il nome host della macchina nella quale l'utente è “loggato”, esempio:
brigadier: condron [91]> hostname brigadier
uname(1) ha opzioni aggiuntive per visualizzare informazioni circa l'hardware del sistema e la versione del software.
Il comando script(1) crea una documentazione della propria sessione di I/O. Usando il comando script(1) si possono catturare tutti i dati trasmessi da e per il proprio terminale visuale fino all'uscita (con exit) del programma stesso. Può essere utile durante un processo di debugging, per documentare le azioni che si stanno sperimentando o per avere una copia stampabile per una attenta lettura successiva.
Sintassi
script [-a] [file] <...> exit
Opzioni generali
Di default, typescript è il nome del file usato dal comando script(1).
Ci si deve ricordare di digitare exit per terminare la propria sessione script e chiudere così il file typescript.
Esempi:
beauty condron> script Script started, file is typescript
beauty condron> ps PID TT STAT TIME COMMAND 23323 p8 S 0:00 -h -i (tcsh) 23327 p8 R 0:00 ps 18706 pa S 0:00 -tcsh (tcsh) 23315 pa T 0:00 emacs 23321 pa S 0:00 script 23322 pa S 0:00 script 3400 pb I 0:00 -tcsh (tcsh)
beauty condron> kill -9 23315
beauty condron> date Mon Apr 22 22:29:44 EDT 1996
beauty condron> exit exit Script done, file is typescript [1] + Killed emacs
beauty condron> cat typescript Script started on Mon Apr 22 22:28:36 1996 beauty condron>ps PID TT STAT TIME COMMAND 23323 p8 S 0:00 -h -i (tcsh) 23327 p8 R 0:00 ps 18706 pa S 0:00 -tcsh (tcsh) 23315 pa T 0:00 emacs 23321 pa S 0:00 script 23322 pa S 0:00 script 3400 pb I 0:00 -tcsh (tcsh) beauty condron>kill -9 23315 beauty condron>date Mon Apr 22 22:29:44 EDT 1996 beauty condron>exit exit script done on Mon Apr 22 22:30:02 1996
beauty condron>
Il comando date(1) mostra la data e l'ora corrente. Un super-user può modificare la data e l'ora.
Sintassi
date [opzioni] [+formato]
Opzioni generali
-u |
usa Universal Time (o Greenwich Mean Time) |
+formato |
specifica il formato di output |
%a |
abbreviazione giorni, da Sabato a Domenica |
%h |
abbreviazione mesi, da Gennaio a Dicembre |
%j |
giorno dell'anno, da 001 a 366 |
%n |
new-line |
%t |
tab |
%y |
ultime due cifre dell'anno, da 00 a 99 |
%D |
formato data MM/DD/YY |
%H |
ora, da 00 a 23 |
%M |
minuti, da 00 a 59 |
%S |
secondi, da 00 a 59 |
%T |
formato ora HH:MM:SS |
Esempi:
beauty condron> date Mon Jun 10 09:01:05 EDT 1996
beauty condron> date -u Mon Jun 10 13:01:33 GMT 1996
beauty condron> date +%a%t%D Mon 06/10/96
beauty condron>