Risultati da 1 a 22 di 22

Discussione: Uso del terminale e dei comandi ~ Conoscere il proprio hardware ~ Ottimizzazione notebook e netbook




  1. #1
    Divinità L'avatar di jones
    Iscritto dal
    03-Apr-2010
    Località
    Clary's Grove
    Post
    10,801
    ID PSN
    Fiddler_Jones
    Profilo Mercatino
    visualizza
    ID utente
    80580

    Predefinito Uso del terminale e dei comandi ~ Conoscere il proprio hardware ~ Ottimizzazione notebook e netbook

    IL TERMINALE

    Salve, ho pensato di scrivere questa mini guida perché, come tutti, sono stato anche io un super-newbie di linux, e ogni volta che dovevo aprire un terminale lo temevo quanto un attacco alieno. In queste righe leggerete i comandi basilari, quelli più utili, qualche trucchetto per poter addomesticare per bene il terminale e infine qualche istruzione sulla scrittura dei temutissimi "script". Prima di iniziare ho bisogno di dire che il terminale non ha solo questo nome, potete chiamarlo anche bash, shell o console. Beh, per iniziare direi di fare la cosa più ovvia, apriamolo:

    jones@YaHa-Toshiba:~$

    Sembra arabo vero? Non è così, lasciate che vi spieghi il significato di questa criptica riga:

    jones: è l'utente che sta usando il terminale in quel momento
    @: si legge "at", si tradurrebbe "a", con un po' di libertà di traduzione potete leggerlo come "è connesso a"
    YaHa-Toshiba: niente più che il nome del PC che stiamo usando
    ~: cartella in cui ci troviamo, ~ indica la cartella home, quindi in questo momento ci troviamo nella home dell'utente jones
    $: privilegi limitati, l'ultimo simbolo da informazioni sulle azioni che l'utente può svolgere sul sistema, il simbolo del dollaro significa che jones ha i privilegi di un semplice utente.

    In breve: jones è connesso a YaHa-Toshiba, si trova nella sua home e ha i privilegi di un semplice utente.
    Proviamo a cambiare le carte in tavola, digitate:

    su

    Spoiler:
    *Attenzione: se come distro avete ubuntu dovete sapere che l'utente root (l'amministratore) è disabilitato, e una volta dato questo comando vi chiederà una password che non esiste. Per riabilitarlo digitate:

    sudo passwd root

    Inserite prima la vostra password e poi per due volte quella che sarà la nuova password dell'utente root, non preoccupatevi se il cursore non si muove, è una semplice dimostrazione di sicurezza.


    Ed ecco che la riga si sarà trasformata in:

    root@YaHa-Toshiba:/home/jones#

    Notate che ora l'utente collegato al PC YaHa-Toshiba è root, non più jones, per cui il simbolo ~ è stato sostituito da '/home/jones', dato questa cartella non è la home di root e il nome non può essere contratto. Ultimo ma non meno importante, il simbolo che indica i privilegi è passato da $ a #. Questo vuol dire che l'utente root non ha i privilegi di un normale utente, ha i privilegi di amministratore. Il cancelletto alla fine della riga iniziale di un terminale indica un accesso illimitato alle risorse del sistema.

    COMANDI BASE

    Bene, vorrei dirvi che i preamboli sono completi ma non è così, prima di elencare qualche comando, è importante conoscere la sintassi generica. Quando digitate un comando apparirà grosso modo così:

    comando -[opzione1] -[opzione2] [argomento1] [argomento2]

    notate bene che le opzioni possono essere scritte anche in altri modi, facciamo un esempio con un comando che ha due opzioni, -f e -w, scrivere:

    comando -f -w [argomento]

    o scrivere

    comando -fw [argomento]

    è equivalente.

    Non troverete i comandi sempre in questa forma, spesso l'argomento può essere sottointeso, oppure non ci sono opzioni aggiuntive da dare. In ogni caso, iniziamo finalmente a vedere i comandi basilari:

    pwd, print working directory.
    Spoiler:
    Sintassi: pwd
    Stampa a schermo la directory su cui ci troviamo in questo momento. Esempio:

    Codice:
    jones@YaHa-Toshiba:~$ pwd
    /home/jones
    Semplice.


    cat, catenate.
    Spoiler:
    Sintassi: cat [argomento]
    Mostra il contenuto di un file. Esempio:
    Codice:
    jones@YaHa-Toshiba:~$ cat ciao.txt
    questa è una prova del comando "cat"
    Ovvero prende il file "ciao.txt" e ne mostra il contenuto, che in questo caso è la riga: questa è una prova del comando "cat"


    ls, list.
    Spoiler:
    Sintassi: ls -[opzioni] [argomento]
    Fa un elenco di tutti i file che ci sono in una data cartella, se l'argomento non è specificato, elenca i file nella cartella in cui ci troviamo. Esempi:

    Codice:
    jones@YaHa-Toshiba:~$ ls
    Documenti                   Musica          Scrivania         terminal.txt
    guida linux formattata.txt  Penna           s.txt             wep-01.ivs
    Immagini                    Scaricati       Terminal Lessons
    Codice:
    jones@YaHa-Toshiba:~$ ls -a
    .              .gdesklets                  Penna
    ..             .gegl-0.0                   .pki
    .adobe         .gimp-2.6                   .profile
    .aMule         .gksu.lock                  .pulse
    .aptitude      .gnome2                     .pulse-cookie
    .bash_history  .gnome2_private             .recently-used.xbel
    .bash_logout   .gnupg                      Scaricati
    .bashrc        .gstreamer-0.10             Scrivania
    .bogofilter    .gtk-bookmarks              s.txt
    .cache         guida linux formattata.txt  .sudo_as_admin_successful
    .camel_certs   .gvfs                       Terminal Lessons
    .compiz        .ICEauthority               terminal.txt
    .config        .icedteaplugin              .themes
    .dbus          .icons                      .thumbnails
    Documenti      Immagini                    wep-01.ivs
    .esd_auth      .local                      .wine
    .evolution     .macromedia                 .Xauthority
    .face          .mission-control            .xsession-errors
    .fontconfig    Musica                      .xsession-errors.old
    .gconf         .nautilus
    .gconfd        .netx
    Codice:
    jones@YaHa-Toshiba:~$ ls /home/jones/Documenti
    20100118_ACTA_Agreement.pdf                                     Programmazione
    30011f.cpp                                                      lista_armi_accessori_FF13.txt
    prova.sh                                                        asap.pdf
    eBooks                                                          rec.txt
    Elettronica                                                     script-compiz
    fbnames                                                         Stampa
    Testi                                                           Traduzione_Valkyria_Chronicles_by_JrpgWorld.doc
    Instr.txt                                                       Università
    Ip.htm                                                          US20100177174.pdf
    issue31_it.pdf                                                  Varie
    kismet.pdf                                                      words_italian.win.txt
    Linux Images                                                    wpa
    MyGod.txt                                                       yes.txt
    netw.txt                                                        yo.txt
    Codice:
    jones@YaHa-Toshiba:~$ ls -al
    drwxr-xr-x 42 jones jones    4096 2010-10-29 10:19 .
    drwxr-xr-x  3 root  root     4096 2010-10-11 03:59 ..
    drwx------  3 jones jones    4096 2010-10-11 02:42 .adobe
    drwxr-xr-x  4 jones jones    4096 2010-10-26 16:50 .aMule
    drwx------  2 jones jones    4096 2010-10-16 22:12 .aptitude
    -rw-------  1 jones jones    3266 2010-10-29 08:48 .bash_history
    -rw-r--r--  1 jones jones     220 2010-10-11 03:59 .bash_logout
    -rw-r--r--  1 jones jones    3353 2010-10-11 03:59 .bashrc
    drwx------  2 jones jones    4096 2010-10-11 02:45 .bogofilter
    drwx------ 16 jones jones    4096 2010-10-29 09:54 .cache
    drwx------  2 jones jones    4096 2010-05-13 19:43 .camel_certs
    drwx------  3 jones jones    4096 2010-10-11 04:04 .compiz
    drwxr-xr-x 17 jones jones    4096 2010-10-15 09:49 .config
    drwx------  3 jones jones    4096 2010-10-11 04:03 .dbus
    drwxr-xr-x 12 jones jones    4096 2010-10-16 16:43 Documenti
    -rw-------  1 jones jones      16 2010-10-11 04:03 .esd_auth
    drwx------  8 jones jones    4096 2010-10-29 08:35 .evolution
    -rw-r--r--  1 jones jones   29605 2010-10-11 02:36 .face
    drwxr-xr-x  2 jones jones    4096 2010-10-28 16:05 .fontconfig
    drwx------  5 jones jones    4096 2010-10-29 09:54 .gconf
    drwx------  2 jones jones    4096 2010-10-29 10:10 .gconfd
    drwx------  7 jones jones    4096 2010-10-27 22:39 .gdesklets
    drwx------  4 jones jones    4096 2010-10-19 02:17 .gegl-0.0
    drwxr-xr-x 22 jones jones    4096 2010-10-27 20:33 .gimp-2.6
    -rw-r-----  1 jones jones       0 2010-10-27 22:01 .gksu.lock
    drwx------ 10 jones jones    4096 2010-10-23 21:17 .gnome2
    drwx------  2 jones jones    4096 2010-10-11 02:10 .gnome2_private
    drwx------  2 jones jones    4096 2010-10-12 18:55 .gnupg
    drwxr-xr-x  2 jones jones    4096 2010-10-11 02:37 .gstreamer-0.10
    -rw-r--r--  1 jones jones     137 2010-10-29 09:54 .gtk-bookmarks
    -rw-r--r--  1 jones jones   25539 2010-10-27 01:51 guida linux formattata.txt
    dr-x------  2 jones jones       0 2010-10-29 09:54 .gvfs
    -rw-------  1 jones jones   13680 2010-10-29 09:54 .ICEauthority
    drwxr-xr-x  3 jones jones    4096 2010-10-21 18:33 .icedteaplugin
    drwxr-xr-x  2 jones jones    4096 2010-10-11 02:20 .icons
    drwxr-xr-x  8 jones jones    4096 2010-10-27 20:22 Immagini
    drwxr-xr-x  3 jones jones    4096 2010-10-11 04:03 .local
    drwx------  3 jones jones    4096 2010-10-11 02:42 .macromedia
    drwx------  3 jones jones    4096 2010-10-11 03:00 .mission-control
    drwxr-xr-x 28 jones jones    4096 2010-10-11 03:00 Musica
    drwxr-xr-x  2 jones jones    4096 2010-10-11 04:03 .nautilus
    drwxr-xr-x  3 jones jones    4096 2010-10-21 18:33 .netx
    drwxr-xr-x  7 jones jones    4096 2010-10-18 21:03 Penna
    drwx------  3 jones jones    4096 2010-10-11 02:42 .pki
    -rw-r--r--  1 jones jones     675 2010-10-11 03:59 .profile
    drwx------  2 jones jones    4096 2010-10-29 09:54 .pulse
    -rw-------  1 jones jones     256 2010-10-11 04:03 .pulse-cookie
    -rw-------  1 jones jones  162313 2010-10-29 10:19 .recently-used.xbel
    drwxr-xr-x  6 jones jones    4096 2010-10-28 17:46 Scaricati
    drwxr-xr-x  2 jones jones    4096 2010-10-27 22:15 Scrivania
    -rw-r--r--  1 jones jones   22129 2010-10-26 15:40 s.txt
    -rw-r--r--  1 jones jones       0 2010-10-11 02:16 .sudo_as_admin_successful
    drwx------  2 jones jones    4096 2010-01-21 02:10 Terminal Lessons
    -rw-r--r--  1 jones jones    5559 2010-10-29 10:19 terminal.txt
    drwxr-xr-x  2 jones jones    4096 2010-10-11 02:20 .themes
    drwx------  4 jones jones    4096 2010-10-11 02:20 .thumbnails
    -rw-r--r--  1 jones jones 1550830 2010-10-25 21:27 wep-01.ivs
    -rwxrw-r--  1 jones jones 1840130 2010-10-25 21:27 we_all_like_this
    drwxr-xr-x  4 jones jones    4096 2010-10-28 16:07 .wine
    -rw-------  1 jones jones       0 2010-10-24 12:07 .Xauthority
    -rw-------  1 jones jones    2272 2010-10-29 09:55 .xsession-errors
    -rw-------  1 jones jones   20356 2010-10-29 08:48 .xsession-errors.old
    Nel primo esempio non c'è niente da spiegare, il comando ls fa il banale elenco di quello che c'è nella cartella home.
    Nel secondo esempio ho aggiunto l'opzione -a, contrazione di all, indica a ls di elencare tutto, anche i file nascosti (che come avrete immaginato sono quelli con il punto avanti). Piccola curiosità, noterete che ci sono due file particolari, che sono presenti ovunque, sono . e .., e indicano rispettivamente la cartella in cui ci troviamo in questo istante, e la cartella appena precedente nell'albero delle directory (ad esempio se ci troviamo in /home/jones il .. indica la cartella /home )
    Nel terzo esempio metto per la prima volta l'argomento, ovvero /home/jones/Documenti, e indico di listare i file presenti nella cartella Documenti.
    Nell'ultimo esempio torno a non mettere l'argomento, quindi indico di elencare i file della cartella home, ma oltre ad elencarli tutti grazie all'opzione che abbiamo già visto (-a) indico di elencarli in formato lungo, grazie all'opzione -l. In questo modo otteniamo molte più informazioni sui file elencati, anche se a prima vista sono difficili da interpretare. Vi spiego come si leggono prendendone uno a caso:

    -rwxrw-r-- 1 jones jones 1840130 2010-10-25 21:27 we_all_like_this

    Partendo da destra abbiamo: Nome del file - Data ultima modifica - Dimensione file - Gruppo proprietario - Utente proprietario - Informazioni sui permessi e sul tipo di file. In questo caso l'utente proprietario è jones, il gruppo proprietario è jones, la dimensione (in byte) è 1840130 e la data di creazione è il 25 ottobre 2010, alle 21:27.
    Prendiamo ora l'ultima parte:
    -rwxrw-r--
    Cosa vuol dire precisamente? Per capirlo, dividiamo questa riga in triplette partendo da sinistra:
    -|rwx|rw-|r--|
    -: Il primo segno, indica che tipo di file è, dato che non c'è niente vuol dire che ci troviamo di fronte a un file semplice, se fosse stato una cartella ad esempio, al posto del trattino avremmo trovato una d (directory)
    rwx: La prima tripletta indica i permessi del proprietario sul file, in queso caso di lettura (r), scrittura (w) ed esecuzione (x)
    rw-: La seconda tripletta indica i permessi del gruppo sul file. Qui abbiamo i permessi di lettura (r), scrittura (w) ma non di esecuzione, infatti invece della x, all'ultimo posto troviamo un trattino.
    r--: L'ultima tripletta indica i permessi di tutti gli altri utenti che non sono i proprietari del file, né che facciano parte del gruppo proprietario del file, che in questo caso possono solo leggere, ma non possono né scrivere, né eseguire il file.


    chmod, change mode.
    Spoiler:
    Sintassi: chmod [argomento1] [argomento2]
    Cambia i permessi di un file. Esempi:

    Codice:
    jones@YaHa-Toshiba:~$ chmod +x hearing.sh
    Codice:
    jones@YaHa-Toshiba:~$ chmod 755 hearing.sh
    Nel primo esempio quello che faccio è prendere il file hearing.sh e dargli i permessi di esecuzione grazie all'argomento +x. Oltre a dare permessi di esecuzione potevamo toglierli, oppure potevamo modificare i permessi di lettura o scrittura, sostituendo la +x (che ricordo, significa "dai i permessi di esecuzione al file) con:
    -x: togli i permessi di esecuzione
    +r: dai i permessi di lettura
    -r: togli i permessi di lettura
    +w: dai i permessi di scrittura
    -w: togli i permessi di scrittura

    Nel secondo esempio invece uso un metodo molto più raffinato per modificare i permessi del file. Ricordate la riga rwx|rw-|r-- presa in esempio con il comando ls? Bene, il comando chmod dato in questo modo sfrutta proprio questa riga, o meglio, sfrutta la sua traduzione in binario. Tento di spiegarmi. Prendiamo quella riga e traduciamola in binario, in che modo? Dove ci sono lettere mettiamo un bell'1 e dove ci sono i trattini mettiamo un bello 0: 111|110|100, ora traduciamo le triplette di numeri da binario a decimale: 111 = 7, 110 = 6, 100 = 4, quindi 764.
    Spoiler:
    Per chi fosse completamente a digiuno di informatica e matematica: per convertire un numero da base binaria a base decimale esiste più di un metodo, ma per i nostri scopi possiamo fare riferimento ad una semplice tabella per convertire i primi 7 numeri naturali:

    000 = 0
    001 = 1
    010 = 2
    011 = 3
    100 = 4
    101 = 5
    110 = 6
    111 = 7

    e se avessimo bisogno di estendere questa tabella? molto semplice: continuiamo a incolonnare i numeri in base 10 sotto al 7, sempre in ordine crescente, e aggiungiamo una colonna ai nostri numeri binari, che diventeranno di 4 cifre. le cifre da aggiungere saranno, partendo dall'alto, otto 0 e otto 1. prolunghiamo anche le altre tre colonne: la terza sarà formata alternativamente da quattro 0 e quattro 1, la seconda da due 0 e due 1, la prima da uno 0 e un 1, così:

    0000 = 0
    0001 = 1
    0010 = 2
    0011 = 3
    0100 = 4
    0101 = 5
    0110 = 6
    0111 = 7
    1000 = 8
    1001 = 9
    1010 = 10
    1011 = 11
    1100 = 12
    1101 = 13
    1110 = 14
    1111 = 15


    se volessimo proseguire, aggiungiamo un'altra colonna con sedici 0 e sedici 1, e via così.. si tratta di un semplice metodo ricorsivo. a questo punto il meccanismo dovrebbe essere chiaro, e ci permetterà di convertire velocemente e senza calcoli complessi numeri bianari di poche cifre o numeri decimali non troppo grandi.

    Bene, i permessi di hearing.sh, secondo chmod, sono attualmente 764. Dando il comando chmod 755 hearing.sh cambiamo in maniera inequivocabile i permessi del file, per capire come basta fare il discorso inverso:
    - Traduciamo i singoli numeri in binario e disponiamoli a triplette: 111|101|101
    - Sostituiamo gli 1 con lettere e gli 0 con trattini: rwx|r-x|r-x
    E voilà, il nostro file ha i suoi nuovi permessi: l'utente proprietario può leggere, scrivere ed eseguire, il gruppo proprietario, così come gli altri, possono leggere ed eseguire, ma non scrivere.
    Vi metto un altro esempio per farvi capire meglio:
    chmod 666 hearing.sh
    In binario: 110|110|110
    In lettere: rw-|rw-|rw-
    In conclusione: Permessi di lettura e scrittura a tutti, ma di esecuzione a nessuno. È piuttosto complicato da spiegarlo, l'importante è ricordare:
    Guardando in decimale: il primo numero indica i permessi dell'utente proprietario, il secondo indica i permessi del gruppo proprietario, l'ultimo i permessi di tutti gli altri.
    Guardando in binario le singole triplette: La prima cifra indica i permessi di lettura, la seconda quelli di scrittura e l'ultima quelli di esecuzione.
    Fate qualche esperimento controllando di volta in volta con il comando ls -l e vedrete che vi sarà molto più chiaro


    chown, change owner.
    Spoiler:
    Sintassi: chown [argomento1].[argomento2] [argomento3]
    Cambia utente e gruppo proprietario di un file.
    NB: Per cambiare il proprietario di un file bisogna avere i privilegi di amministratore, ergo mettete un "sudo" (superuser do) avanti al comando, o fate il login come root (comando su). Esempio:

    Codice:
    root@YaHa-Toshiba:/home/jones# chown asdrubale.prove s.txt
    Quello che facciamo è semplice: prendiamo il file s.txt e diciamo che il nuovo utente proprietario è asdrubale, è il nuovo gruppo proprietario è prove. Ricordate: [argomento1] indica il nome del nuovo utente proprietario del file, [argomento2] il nome del nuovo gruppo proprietario del file, e vanno separati da un punto.


    cd, change directory.
    Spoiler:
    Sintassi: cd [argomento]
    Il nome dovrebbe farvi capire cosa fa questo comando, niente più che spostarsi dalla directory in cui ci troviamo, alla directory specificata nell'argomento. Esempi:

    Codice:
    jones@YaHa-Toshiba:~$ cd Documenti/
    jones@YaHa-Toshiba:~/Documenti$
    Codice:
    jones@YaHa-Toshiba:~$ cd ..
    jones@YaHa-Toshiba:/home$
    Il primo esempio ci sposta dalla nostra home alla cartella Documenti che si trova in essa. Da qui capite che se ci troviamo in una cartella, per indicare una sua sottocartella non c'è bisogno di dire il suo nome "per intero", basta solo l'ultimo pezzo. Ad esempio, se mi trovo in /home/jones e voglio indicare la cartella Documenti al suo interno, la posso dare al terminale semplicemente come Documenti/, se invece mi voglio riferire alla cartella documenti Documenti nella home di asdrubale (sempre trovandomi nella home di jones), devo per forza di cose darla al terminale con il suo nome completo: /home/asdrubale/Documenti/.
    Il secondo esempio invece ci porta dalla cartella nostra home (che ricordo essere /home/jones) alla cartella /home, che è la cartella che contiene tutte le home degli utenti. (come ho spiegato nella descrizione del comando ls, il .. indica la cartella precedente nell'albero delle directory alla cartella in cui ci troviamo quando digitiamo il comando).


    cp, copy.
    Spoiler:
    Sintassi: cp -[opzioni] [argomenti]
    Copia uno o più file in una data cartella o in quella in cui ci troviamo. Esempi:

    Codice:
    jones@YaHa-Toshiba:~$ cp s.txt s_copia.txt
    Codice:
    jones@YaHa-Toshiba:~$ cp s.txt s_copia.txt /home/jones/Documenti
    Codice:
    jones@YaHa-Toshiba:~$ cp -i s.txt /home/jones/Documenti
    cp: sovrascrivo `/home/jones/Documenti/s.txt'?
    Codice:
    jones@YaHa-Toshiba:~$ cp -r /home/jones/Documenti /home/jones/Documenti_Copia
    Nel primo esempio prende il file s.txt e lo copia, chiamando la sua copia s_copia.txt.
    Nel secondo esempio copia i file s.txt e s_copia.txt nella cartella /home/jones/Documenti
    Nel terzo esempio grazie all'opzione -i, prima di copiare il file s.txt nella cartella chiede se vogliamo sovrascriverlo al file s.txt se esiste già nella cartella /home/jones/Documenti (dovrebbe dato che lo abbiamo copiato noi poco prima).
    Nell'ultimo esempio, grazie all'opzione -r, prende la cartella /home/jones/Documenti e la copia dentro la cartella /home/jones/Documenti_Copia, se non esiste la crea.


    mv, move.
    Spoiler:
    Sintassi: mv [argomento1] [argomento2]
    Muove un file o una cartella da una posizione a un altra, viene usato anche per rinominare i file. Esempi:

    Codice:
    jones@YaHa-Toshiba:~$ mv avatar.jpg /home/jones/Immagini
    Codice:
    jones@YaHa-Toshiba:~$ mv avatar.jpg immagine_personale.jpg
    Codice:
    jones@YaHa-Toshiba:~$ mv /Università /Documenti
    Nel primo esempio sposta il file avatar.jpg nella cartella immagini, nel secondo esempio rinomina il file avatar.jpg in immagine_personale.jpg, nell'ultimo esempio sposta la cartella /Università nella cartella /Documenti, oppure, se la cartella /Documenti non esiste, rinomina la cartella /Università e la chiama /Documenti.


    rm, remove.
    Spoiler:
    Sintassi: rm -[opzioni] [argomenti]
    Elimina definitivamente file e cartelle. Esempi:

    Codice:
    jones@YaHa-Toshiba:~$ rm settembre.txt
    Codice:
    jones@YaHa-Toshiba:~$ rm agosto.txt foto_me_figo.png
    Codice:
    jones@YaHa-Toshiba:~$ rm -rf /home/jones/documenti_vecchi/
    Nel primo esempio eliminiamo semplicemente il file settembre.txt.
    Nel secondo esempio eliminiamo i file agosto.txt e foto_me_figo.png.
    Nell'ultimo esempio sfruttiamo due opzioni, la -r, che indica di eliminare la cartella /home/jones/documenti_vecchi ricorsivamente, e cioè eliminare definitivamente non solo la cartella, ma anche file e sottocartelle al suo interno, e l'opzione -f, che invece indica di ignorare qualunque avviso o conferma possa uscire in output.


    mkdir, make directory.
    Spoiler:
    Sintassi: mkdir -[opzioni] [argomenti]
    Crea una cartella. Esempi:

    Codice:
    jones@YaHa-Toshiba:~$ mkdir prova
    Codice:
    jones@YaHa-Toshiba:~$ mkdir -m 666 prova_2
    Nel primo esempio creiamo una nuova cartella di nome "prova" nella directory in cui ci troviamo.
    Nel secondo esempio creiamo una nuova "prova_2" nella directory in cui ci troviamo, e in più decidiamo a priori i permessi da dargli (come visto nel comando chmod), in questo caso diamo libertà di lettura e scrittura a tutti.
    Si possono creare più cartelle semplicemente aggiungendo il nome della nuova cartella separato con uno spazio dal nome dell'altra cartella da creare.



    rmdir, remove directory.
    Spoiler:
    Sintassi: rmdir [argomenti]
    elimina una cartella vuota. Esempio:

    Codice:
    jones@YaHa-Toshiba:~$ rmdir prova prova_2
    In questo esempio eliminiamo le cartelle create precedentemente con mkdir.
    Per eliminare una cartella non vuota guardate il comando rm


    TRUCCHI PER DOMARE IL TERMINALE

    In questo paragrafo troverete delle banali scorciatoie, utilissime a chi utilizza il terminale abbastanza spesso:

    - Scorciatoie da tastiera:
    Ctrl+C: indica di chiudere il programma in esecuzione nel terminale
    Ctrl+Z: indica di fermare in programma e metterlo in background. Per tornare all'applicazione digitate 'fg'
    Ctrl+R: vi aiuta a completare il comando che andate a inserire, se avete digitato il comando precedentemente, se premete ctrl+r e poi mettete p, probabilmente vi completerà quella p in pwd
    Ctrl+Shift+N: apri una nuova finestra di terminale
    Ctrl+Shift+T: apri una nuova scheda di terminale
    Ctrl+Shift+C: copia
    Ctrl+Shift+V: incolla
    Terzo tasto del mouse: incolla
    PagDown: scrivi il simbolo ~

    - Il simbolo tilde (~) indica la directory home per l'utente che utilizza il terminale. Per l'utente jones la tilde è sinonimo di '/home/jones', per l'utente asdrubale invece di '/home/asdrubale', per l'utente root invece della cartella root '/'.

    - Autocompletamento tramite il pulsante tab: Premere il pulsante tab indica al cursore di completare automaticamente il comando che stiamo scrivendo in caso non ci siano altre opzioni disponibili, nel caso ci siano le mostra tutte. Esempio: ci troviamo nella home e c'è un file che si chiama "perdincibacco.txt" e non c'è nessun altro file o cartella che inizia per p, se digitiamo:
    rm p[TAB]
    quella p viene automaticamente completata in perdincibacco.txt
    Se invece nella home ci sono i file perdincibacco.txt e periodo_esami.txt, digitando
    rm p[TAB]
    ce lo completa automaticamente fino a
    rm per
    premendo di nuovo tab per due volte (la prima per dire "autocompleta", la seconda per dire "ok se non puoi autocompletare mostrami le opzioni") in questo modo:
    rm per[TAB][TAB]
    esce l'elenco delle possibilità di completamento, e vi troverete avanti a una schermata del genere:
    Codice:
    jones@YaHa-Toshiba:~$ rm per
    perdincibacco.txt     periodo_esami.txt
    jones@YaHa-Toshiba:~$ rm per
    con il cursore pronto a scrivere, basterà aggiungere una lettera unica di uno dei file
    rm peri[TAB]
    ed ecco che si autocompleta in
    rm periodo_esami.txt

    - Freccia su: riscrive l'ultimo comando digitato, digitandola ancora scrive il penultimo comando digitato, e così via.

    - Comando clear: Se avete il terminale troppo incasinato, magari dopo aver dato il comando ls, e cercate un po' di pulizia, basta il comando clear per avere di nuovo una schermata pulita

    - Avviare un programma da terminale: Basta scrivere il comando corrispondente al programma in un terminale perché si avvii (molto spesso è proprio il nome del programma), in questo modo potrete vedere tutte le linee di errore o di "warning" che altrimenti sarebbero salvate in un file log chissà dove. Utile quando c'è qualcosa che non va e volete scoprire cosa per una ricerca di soluzione più mirata.

    - Avviare un programma da terminale in background: [nomecomando] &

    - Grido d'aiuto. Può capitare di non ricordare la sintassi esatta di un comando, o magari l'opzione adatta alla situazione, niente paura, scrivete:
    comando --help oppure comando -h per una breve guida a tutte le opzioni disponibili e alla sintassi corretta.
    man comando per il manuale dettagliato del comando da usare


    COMANDI UTILI, COMANDI AVANZATI

    Eccovi qui, dovreste ormai avere un po' di familiarità in più con la riga di comando, sopratutto grazie ai vari TIPS descritti nel paragrafo sopra. Ora però iniziamo con qualche comando utile, e con qualcuno un tantino più avanzato. Per prima cosa dovete sapere che molti di questi comandi hanno bisogno dei privilegi di amministrazione, sapete già come fare, quindi non specificherò ogni volta che ci sia bisogno di fare il login come root o mettere sudo avanti a un comando.
    Bene, inizio con l'elencare una manciata di comandi molto semplici (non perdo neanche tempo a fare esempi), ma che sono utili, o lo saranno per i paragrafi successivi della guida:

    date: Stampa su schermo data e orario
    cal: Stampa su schermo un calendario
    free: Mostra l'uso della ram e della memoria swap
    reboot: riavvia il sistema
    poweroff: spegne il sistema
    halt: forza lo spegnimento del sistema
    sleep [argomento]: Aspetta X secondi e poi ci ridà il controllo della linea di comando ([argomento] è un numero)
    echo [argomento]: Stampa su schermo l'argomento
    espeak [argomento]: Come echo, solo che invece di stamparlo su schermo lo legge ad alta voce
    ping [argomento]: manda dei pacchetti a un indirizzo (l'argomento), e misura il tempo di risposta. Utile conoscere l'opzione -c N, che indica il conteggio, N è un numero e indica a ping quante volte mandare ill pacchetto all'indirizzo stabilito.
    more [argomento]: Stampa su schermo l'argomento, esattamente come cat, soltanto che permette lo scorrimento verso il basso per gli output più lunghi
    less [argomento]: Evoluzione di more, in più permette anche lo scorrimento verso l'alto
    grep [stringa da ricercare] [dove ricercare]: Cerca la stringa selezionata nel testo selezionato, ha varie opzioni, consiltabili tramite il comando grep --help

    Bene, questi possono bastare, ora iniziamo a vedere qualcosa qualcosa un tantino più complesso.

    Processi: Comandi top, kill, killall, nice, renice, pidof
    Spoiler:
    Codice:
    jones@YaHa-Toshiba:~$ top
    
    top - 17:33:28 up 4 min,  2 users,  load average: 1.22, 0.90, 0.40
    Tasks: 193 total,   1 running, 192 sleeping,   0 stopped,   0 zombie
    Cpu(s):  1.7%us,  0.7%sy,  0.0%ni, 97.5%id,  0.1%wa,  0.0%hi,  0.0%si,  0.0%st
    Mem:   3849052k total,   624168k used,  3224884k free,    43268k buffers
    Swap:   975868k total,        0k used,   975868k free,   230572k cached
    
      PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                                                     
     1314 root      20   0  154m  27m  10m S    4  0.7   0:06.62 Xorg                                                        
     1623 jones     20   0  318m  18m  11m S    4  0.5   0:00.72 gnome-terminal                                              
     1646 jones     20   0 19376 1388  968 R    1  0.0   0:00.09 top                                                         
        1 root      20   0 23744 1988 1296 S    0  0.1   0:01.24 init                                                        
        2 root      20   0     0    0    0 S    0  0.0   0:00.00 kthreadd                                                    
        3 root      20   0     0    0    0 S    0  0.0   0:00.00 ksoftirqd/0                                                 
        4 root      RT   0     0    0    0 S    0  0.0   0:00.00 migration/0                                                 
        5 root      RT   0     0    0    0 S    0  0.0   0:00.00 watchdog/0                                                  
        6 root      RT   0     0    0    0 S    0  0.0   0:00.00 migration/1                                                 
        7 root      20   0     0    0    0 S    0  0.0   0:00.00 ksoftirqd/1                                                 
        8 root      RT   0     0    0    0 S    0  0.0   0:00.00 watchdog/1                                                  
        9 root      RT   0     0    0    0 S    0  0.0   0:00.00 migration/2                                                 
       10 root      20   0     0    0    0 S    0  0.0   0:00.06 ksoftirqd/2                                                 
       11 root      RT   0     0    0    0 S    0  0.0   0:00.00 watchdog/2                                                  
       12 root      RT   0     0    0    0 S    0  0.0   0:00.00 migration/3                                                 
       13 root      20   0     0    0    0 S    0  0.0   0:00.24 ksoftirqd/3                                                 
       14 root      RT   0     0    0    0 S    0  0.0   0:00.00 watchdog/3
    Come potete vedere, top fa una lista di tutti i processi in esecuzione, in ordine di utilizzo CPU. Osservando la tabella troviamo varie colonne:
    PID: Process ID, in pratica ogni volta che si avvia un processo, il sistema assegna a quel processo un ID, ovvero un numero per identificare univocamente quel processo.
    USER: L'utente che ha avviato il processo
    NI: Livello di NICE o priorità, lo spiegherò meglio più avanti quando arriveremo al comando apposito: nice
    %CPU, %MEM: Percentuale d'uso di CPU e MEMORIA
    COMMAND: Nome del comando.
    Come vedete il comando top si aggiorna ogni 3 secondi, dicendovi di volta in volta i valori dei processi elencati.
    Digitando M(maiuscola): Noterete che non sono più ordinati in base all'utilizzo di CPU, ma alla percentuale di memoria usata.
    Ora invece digitate u(minuscola): Vi chiederà di inserire un utente, in questo modo vi focalizzerete soltanto sui processi dell'utente specificato:

    Codice:
    top - 18:00:35 up 31 min,  2 users,  load average: 1.38, 1.27, 1.10
    Tasks: 174 total,   1 running, 173 sleeping,   0 stopped,   0 zombie
    Cpu(s):  0.8%us,  0.9%sy,  0.0%ni, 98.2%id,  0.0%wa,  0.0%hi,  0.1%si,  0.0%st
    Mem:   3849052k total,   721836k used,  3127216k free,    43808k buffers
    Swap:   975868k total,        0k used,   975868k free,   298884k cached
    Which user (blank for all): jones
      PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                                                     
     1314 root      20   0  176m  48m  27m S    1  1.3   1:01.71 Xorg                                                        
     1438 jones      9 -11  345m 6572 4964 S    1  0.2   0:26.80 pulseaudio                                                  
     1656 jones     20   0  763m  57m  40m S    1  1.5   0:47.44 vlc                                                         
      952 syslog    20   0  120m 1180  976 S    0  0.0   0:00.19 rsyslogd                                                    
     1722 jones     20   0  318m  18m  11m S    0  0.5   0:00.96 gnome-terminal                                              
     1799 jones     20   0 19276 1372  968 R    0  0.0   0:00.03 top                                                         
        1 root      20   0 23744 1988 1296 S    0  0.1   0:01.24 init                                                        
        2 root      20   0     0    0    0 S    0  0.0   0:00.00 kthreadd                                                    
        3 root      20   0     0    0    0 S    0  0.0   0:00.07 ksoftirqd/0                                                 
        4 root      RT   0     0    0    0 S    0  0.0   0:00.00 migration/0                                                 
        5 root      RT   0     0    0    0 S    0  0.0   0:00.00 watchdog/0                                                  
        6 root      RT   0     0    0    0 S    0  0.0   0:00.00 migration/1                                                 
        7 root      20   0     0    0    0 S    0  0.0   0:00.07 ksoftirqd/1                                                 
        8 root      RT   0     0    0    0 S    0  0.0   0:00.00 watchdog/1                                                  
        9 root      RT   0     0    0    0 S    0  0.0   0:00.00 migration/2                                                 
       10 root      20   0     0    0    0 S    0  0.0   0:00.09 ksoftirqd/2                                                 
       11 root      RT   0     0    0    0 S    0  0.0   0:00.00 watchdog/2
    Dando invio diventa:

    Codice:
    top - 18:01:33 up 32 min,  2 users,  load average: 1.61, 1.32, 1.12
    Tasks: 174 total,   2 running, 172 sleeping,   0 stopped,   0 zombie
    Cpu(s):  1.5%us,  0.9%sy,  0.0%ni, 97.5%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
    Mem:   3849052k total,   725276k used,  3123776k free,    43808k buffers
    Swap:   975868k total,        0k used,   975868k free,   301668k cached
    
      PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                                                     
     1618 jones     20   0  376m  37m  16m S    2  1.0   0:30.34 gedit                                                       
     1438 jones      9 -11  345m 6572 4964 S    2  0.2   0:27.85 pulseaudio                                                  
     1656 jones     20   0  763m  57m  40m S    1  1.5   0:48.15 vlc                                                         
     1722 jones     20   0  318m  18m  11m S    1  0.5   0:01.44 gnome-terminal                                              
     1434 jones     20   0  330m  13m   9m S    0  0.4   0:02.44 metacity                                                    
     1550 jones     20   0  271m  17m  10m S    0  0.5   0:01.48 wnck-applet                                                 
     1458 jones     20   0  590m  36m  21m S    0  1.0   0:05.43 nautilus                                                    
     1404 jones     20   0  457m  13m 9576 S    0  0.4   0:00.89 gnome-settings-                                             
     1455 jones     20   0  337m  19m  11m S    0  0.5   0:01.15 gnome-panel                                                 
     1532 jones     20   0 29180 1072  848 S    0  0.0   0:01.00 syndaemon                                                   
     1799 jones     20   0 19276 1472 1064 R    0  0.0   0:00.05 top                                                         
     1354 jones     20   0  233m 8440 6480 S    0  0.2   0:00.22 gnome-session                                               
     1394 jones     20   0  295m  14m 8404 S    0  0.4   0:00.56 gnome-power-man                                             
     1505 jones     20   0  365m  10m 8064 S    0  0.3   0:00.09 e-addressbook-f                                             
     1554 jones     20   0  358m  16m  12m S    0  0.4   0:00.63 clock-applet                                                
     1692 jones     20   0  4148  332  160 S    0  0.0   0:00.02 xdg-screensaver                                             
     1384 jones     20   0 11988  296    0 S    0  0.0   0:00.00 ssh-agent
    Giusto per dire due opzioni da dare in pasto a top, per vederne altre digitate h(minuscola) e c'è un breve elenco, ma per vederle davvero tutte è meglio guardare il manuale (man top).

    Ora vediamo un po' come usare queste informazioni, la prima cosa che mi viene in mente da fare su un processo attivo, è chiuderlo. Si fa in questo modo:

    kill [PID]

    Già, proprio così, quando volete chiudere un programma tramite terminale dovete dire a linux di ucciderlo. Ad esempio dando:

    kill 1656

    Quello che sto facendo (stando all'ultima tabella di top) è terminare il processo VLC.
    Se il processo non risponde, allora si aggiunge l'opzione -9:

    kill -9 1656

    Che vuol dire "forza l'uscita del processo 1656".
    Oltre al comando kill, per uccidere un processo si può usare il comando killall, che uccide non solo uno specifico processo, ma tutte le istanze di un processo. Se ad esempio avessi aperto due volte vlc, ognuna avrebbe un PID diverso, e dare il comando kill [PID], ne terminerebbe solo una. Invece posso dare:

    killall vlc

    Che si prende cura di uccidere tutte le istanze di vlc.

    Ora invece di uccidere un processo, vediamo come manipolarne la priorità. Quando ho spiegato il comando top ho rimandato la spiegazione della colonna NI, quella spiegazione arriva adesso: per NI si intende NICE, che è il livello di priorità che quei processi hanno sul processore, più il numero è basso, più la priorità è alta. In genere i processi avviati da un normale utente hanno un livello di priorità di 0 su una scala che va da -20 a +19.
    Per assegnare priorità a un processo basta il comando nice, si usa in questo modo:

    nice -n 10 vlc

    In questo caso sto avviando vlc con un livello di nice di 10, quindi, con priorità più bassa rispetto al normale, invece con:

    nice -n -15 rhythmbox

    Avviamo rhythmbox con livello di nice -15, quindi priorità altissima.
    *Attenzione: solo root può avviare processi con livello di nice negativo.

    Se invece vogliamo cambiare la priorità di un processo già attivo, dobbiamo usare il comando renice:

    renice 2 -p PID

    Ovvero: Assegna un livello di nice di 2 al processo che gira con il PID specificato.
    *Attenzione: solo l'utente root può abbassare il livello di nice e quindi alzare la priorità. Ad esempio io utente non privilegiato posso passare un processo da 0 a 3 e poi da 3 a 7, ma non posso passarlo da 7 a 3.

    Ultima cosa da dire sui processi, il comando pidof, che non fa altro che elencare i PID del programma specificato:

    pidof vlc

    da in output: 1656.


    Web Browsing e installazione pacchetti
    Spoiler:
    Advanced Package Tool, meglio conosciuto come apt: Si usa per installare e rimuovere i pacchetti, e il suo utilizzo è davvero semplicissimo.
    Ha un file di cache con elenco e descrizione di tutti i pacchetti disponibili, in modo da poterli richiamare anche da offline. Tutto ciò che avete bisogno di sapere per poter utilizzare apt al meglio sono i questi semplici comandi:

    apt-get update: Aggiorna la cache

    apt-get upgrade: Aggiorna i pacchetti installati

    apt-get install [nome pacchetto]: Installa il pacchetto e risolvi le dipendenze. Questo è il comando base di apt. Per installare il pacchetto vlc ad esempio basta dare in pasto al terminale:

    apt-get install vlc

    In modo da scaricare VLC assieme ai pacchetti e librerie di cui ha bisogno, e piazzarlo nel posto adeguato (cioè Applicazioni -> Audio e Video)

    apt-get remove [nome pacchetto]: Rimuovi il pacchetto

    apt-get purge [nome pacchetto]: Rimuovi il pacchetto e i suoi file di configurazione

    apt-get autoremove: rimuovi i pacchetti inutilizzati o inutili (datelo di tanto in tanto)

    apt-cache search [stringa da cercare]: Cerca nella cache i pacchetti con nel nome o nella descrizione ciò che abbiamo scelto. Comando fondamentale, sempre per seguire l'esempio di vlc, se sopra avessimo digitato

    apt-get install Vlc

    Non avremmo trovato un bel niente, perché Linux tiene conto delle maiuscole e minuscole, quindi digitando

    apt-cache search Vlc

    invece avremmo un risultato del genere:
    Codice:
    root@YaHa-Toshiba:/# apt-cache search Vlc
    freeplayer - wrapper around vlc for French ADSL FreeBox
    getstream - DVB streaming application
    gnome-media-player - A simple media player for GNOME
    hdhomerun-config - Configuration utility for Silicon Dust HD HomeRun
    hdhomerun-config-gui - GUI Configuration utility for Silicon Dust HD HomeRun
    libavbin0 - cross-platform media decoding library
    libhdhomerun-dev - Development library for Silicon Dust HD HomeRun
    libhdhomerun1 - Library for Silicon Dust HD HomeRun
    mythbuntu-lirc-generator - Mythbuntu Lirc Configuration Generator
    phonon-backend-vlc - Phonon VLC backend
    phonon-backend-vlc-dbg - Phonon VLC backend debugging symbols
    pidgin-mpris - sets your available message to your currently playing track
    pidgin-musictracker - Plugin for Pidgin which displays the current music track in your status
    x264 - video encoder for the H.264/MPEG-4 AVC standard
    dvd95 - DVD9 to DVD5 converter
    dvblast - semplice e potente applicazione per streaming dvb
    libvcdinfo-dev - library to extract information from VideoCD (development files)
    libvcdinfo0 - libreria per estrarre informazioni da VideoCD
    libvlc-dev - development files for libvlc
    libvlc5 - multimedia player and streamer library
    libvlccore-dev - development files for libvlccore
    libvlccore4 - base library for VLC and its modules
    mimms - scaricatore di flussi mms (es. mms://)
    mozilla-plugin-vlc - plugin multimediale basato su VLC per browser web
    remuco-vlc - duplex remote control for media players - VLC adapter
    videolan-doc - documentazione per la soluzione streaming VideoLAN
    vlc - multimedia player and streamer
    vlc-data - Common data for VLC
    vlc-dbg - debugging symbols for vlc
    vlc-nox - multimedia player and streamer (without X support)
    vlc-plugin-fluidsynth - FluidSynth plugin for VLC
    vlc-plugin-ggi - GGI video output plugin for VLC
    vlc-plugin-jack - Jack audio plugins for VLC
    vlc-plugin-notify - LibNotify plugin for VLC
    vlc-plugin-pulse - PulseAudio plugin for VLC
    vlc-plugin-sdl - SDL video and audio output plugin for VLC
    vlc-plugin-svg - SVG plugin for VLC
    vlc-plugin-svgalib - SVGAlib video output plugin for VLC
    vlc-plugin-zvbi - VBI teletext plugin for VLC
    Quindi noteremmo che il nome del pacchetto che ci interessa è vlc, e non Vlc, quindi possiamo correggere la sintassi del comando in: apt-get install vlc.
    Oppure possiamo usarlo proprio per cercare un software adatto a noi, ad esempio dando apt-cache search chess andiamo a cercare se c'è un gioco di scacchi da poter installare (ce ne sono diversi).

    apt-cache show [nome pacchetto]: Stampa tutte le informazioni disponibili sul pacchetto. Quando abbiamo qualche dubbio su un pacchetto che abbiamo trovato, basta dare questo comando per avere tutte le informazioni disponibili.


    Bene, ora sapete il necessario alla gestione dei pacchetti installati sulla vostra macchina, vediamo un secondo qualche altra cosa da fare con un terminale e una connessione a internet.
    Dovete sapere che tanto tempo fa (20 anni fa circa), non era sempre possibile lavorare in modalità grafica, per cui tutto si faceva in modalità testuale. Tutto. Anche Navigare in rete. Vi sembrerà strano è così e per fare questo ci sono tre bei programmi che arrivano in nostro aiuto: lynx, links e elinks. Sono semplici browser, niente di più e niente di meno.

    lynx è il browser storico di linux, molto bello, ma altrettanto antiquato, ormai è meglio usare links o un suo fork (una sorta di scissione): elinks. L'uso è semplice, basta digitare:

    elinks www.google.it

    e voilà, ci troviamo su google come lo abbiamo sempre conosciuto, o meglio quasi come lo abbiamo sempre conosciuto. Oppure dare il comando liscio:

    elinks

    In modo che ci chieda lui l'url da aprire. Da quì possiamo navigare grazie alle freccette su e giù della tastiera (la freccia destra apre il link selezionato), e inserire il testo nei campi dove possiamo. Il tasto ESC apre un piccolo menu molto intuitivo. Premere G oppure T ci fa inserire un URL per raggiungere un nuovo sito e così via. Insomma è tutto molto semplice.
    Non dico che dovete abbandonare i vostri cari Firefox e Chromium per navigare, solo che se avete un amico in difficoltà perché ha in qualche como incasinato l'ambiente grafico, beh, diventano utili per poter trovare una soluzione in rete.

    NB: Ci sono buone probabilità che nessuno di questi browser sia incluso nella vostra distro. Beh, ora sapete come fare a installarlo quindi è inutile che ve lo dica no?


    Gestione dischi esterni: mount, umount e fdisk
    Spoiler:
    Prima di addentrarmi nel discorso sul come gestire le memorie di massa da terminale, devo prima dare delle nozioni base, su come linux sceglie di chiamare i dispositivi (device) esterni, e in particolare gli Hard Disk Drive.

    In un sistema operativo basato su Linux tutte le periferiche si trovano nella cartella /dev, quindi vi si trovano anche gli HDD esterni o le flash drive (penne usb). Appena colleghiamo uno di questi dispositivi, ecco che nella cartella /dev compare un file, a indicare il dispositivo appena collegato.
    Facciamo un esempio pratico.
    L'HDD esterno che ho appena collegato prende il nome di: /dev/sdb
    Vediamo un po' di spiegare perché si chiami così:

    /dev = Come ho già detto, è la cartella dove si trovano tutti i device
    sd = Tipo di collegamente, indica il collegamento SATA, se fosse stato un disco IDE avremmo trovato una h al posto della s.
    b = Numerazione, la b vuol dire che è il secondo dispositivo di questo tipo collegato al PC, verosimilmente avrò un altro HDD collegato che ha preso il nome /dev/sda (ovvero l'HDD primario). Un terzo dispositivo con collegamento sata prenderà il nome di sdc, e così via.

    Infine ci sono i numeri che indicano le partizioni. Ad esempio sdb1 indica la prima partizione del HDD /dev/sdb, sdb2 ne indica la seconda, e così via.

    Ora sapete dove si trovano gli HDD che collegate, potete usare quella cartella per leggere e scriverci sopra giusto? No. Quello è un nome simbolico, non potete leggere o scrivere su quella periferica esterna, dovete prima presentarla a Linux, e dopo che Linux ha conosciuto l'HDD esterno, prima di poterlo staccare, dobbiamo lasciare che si salutino. In gergo tecnico queste due operazioni si chiamano "operazione di montaggio su una directory" e "operazione di smontaggio da una directory", e si eseguono grazie ai comandi mount e umount.

    Il comando mount è quello che permette di montare la partizione. Funziona così:

    mount [dispositivo] [directory sulla quale montarlo] --> mount /dev/sdb1 /media/HDD_Backup

    Ovvero: monta l'HDD esterno /dev/sdb1 sulla directory /media/HDD_Backup. D'ora in avanti leggere e scrivere nella cartella /media/HDD_Backup sarà l'equivalente di leggere e scrivere sull'HDD /dev/sdb, nella sua prima partizione.

    Una volta montato l'HDD e fatto tutto ciò che abbiamo bisogno di fare, arriva il momento di smontarlo, grazie al comando umount:

    umount [directory sulla quale è montato il dispositivo] --> umount /media/HDD_Backup

    NB1: La cartella su cui montiamo un device deve esistere. Se non esiste il comando mount ci da errore.
    NB2: Se la cartella su cui montiamo l'HDD esiste e non è vuota, tutti i file contenuti vengono resi invisibili e intoccabili finché è montato, potremo di nuovo vedere quei file una volta smontato.
    NB3: Non è possibile montare un HDD esterno tutto insieme contemporaneamente, sempre una partizione per volta, ognuna in una diversa directory.

    Ecco una serie di comandi che mi trovo spesso a dare:

    Codice:
    jones@YaHa-Toshiba:~$ su
    root@YaHa-Toshiba:/home/jones# cd /media
    root@YaHa-Toshiba:/media# mkdir HDD_Backup
    root@YaHa-Toshiba:/media# mount /dev/sdb1 HDD_Backup/
    root@YaHa-Toshiba:/media# cp -r /home/jones/Documenti/Università HDD_Backup/22_11_2010/
    root@YaHa-Toshiba:/media# rm -rf HDD_Backup/25_10_2010/
    root@YaHa-Toshiba:/media# umount HDD_Backup/
    root@YaHa-Toshiba:/media# exit
    jones@YaHa-Toshiba:/media$_
    Che se sono stato un bravo insegnante vi significherà: Diventa root, spostati in media dove creerai una cartella chiamandola HDD_Backup, monta la prima partizione di /dev/sdb su questa cartella, dopodiché copia tutto il contenuto della directory /home/jones/Documenti/Università nella directory HDD_Backup/22_11_2010, elimina la directory HDD_Backup/25_10_2010, smonta l'HDD esterno e torna ad essere un utente normale.

    Ora che abbiamo imparato a far riconoscere i device esterni al sistema, vediamo un po' come formattarli a nostro piacimento, tramite il comando fdisk.

    fdisk è un comando molto potente, usato per formattare le memorie esterne da terminale. L'uso è semplice: si manda il comando fdisk seguito dal nome che Linux ha assegnato al device che vogliamo formattare:

    fdisk /dev/sda

    Una volta lanciato il comando ci uscirà una laconica scritta:

    Command (m for help):

    Come avete intuito, digitate m per un aiuto:

    Codice:
       a   toggle a bootable flag
       b   edit bsd disklabel
       c   toggle the dos compatibility flag
       d   delete a partition
       l   list known partition types
       m   print this menu
       n   add a new partition
       o   create a new empty DOS partition table
       p   print the partition table
       q   quit without saving changes
       s   create a new empty Sun disklabel
       t   change a partition's system id
       u   change display/entry units
       v   verify the partition table
       w   write table to disk and exit
       x   extra functionality (experts only)
    Sono molti sotto-comandi, e non ve li spiegherò tutti, sono qui per insegnarvi le basi di fdisk, da usare soltanto in casi di emergenza, per tutti i casi di ordinaria amministrazione c'è gparted.
    Comunque, ecco le lettere che ci interessano:

    d: delete a partition. Dare come comando la lettera d indica a fdisk di eliminare una partizione. Appena digitiamo d e diamo invio ci chiederà quale partizione eliminare. A quel punto inseriamo il numero a quella partizione associato e diamo invio.
    Voilà, partizione eliminata (se è presente una sola partizione la eliminerà automaticamente, senza bisogno che la selezioniamo).

    n: add a new partition. Crea una nuova partizione. Prima ci fa scegliere se la partizione deve essere primaria o estesa, digitando p per primaria o e per estesa [non fa molta differenza il tipo di partizione, scegliete primaria se potete], poi il numero da assegnare alla partizione (per creare la prima partizione digitiamo 1, per la seconda digitamo 2 e così via), infine la dimensione.
    fdisk vi chiederà di impostare la dimensione tramite i "cilindri" della memoria esterna, che sono per farla breve e con una spiegazione molto lontana dalla rigorosa definizione, un determinato modo di vedere e numerare gli spazi fisici dove sono contenuti i singoli bit.
    Come primo cilindro usate il valore predefinito (che è di solito 1, o comunque il primo cilindro libero), come ultimo cilindro invece potete scegliere esattamente la quantità di memoria da destinare alla partizione, semplicemente anteponendo un + al valore scelto, ovvero:
    +500M = Per una partizione di 500 MB
    +20G = Per una partizione di 20 GB
    oppure potete utilizzare il valore predefinito perché fdisk assegni alla partizione tutto lo spazio disponibile.

    t: change a partition's system id. In poche parole, cambia il file system della partizione. Per cambiare il file system della partizione ci chiede di inserire il suo codice esadecimale, basta digitare L per avere una tabella con tutti i file system supportati e i corrispettivi codici esadecimali, ma riporto qui sotto quelli più usati per comodità:
    7 - HTFS/NTFS (file system windows)
    b - FAT32 (file system universale)
    82 - Area di Swap
    83 - Partizione Linux corrente (al momento ext4)
    af - HFS (file system apple)

    p: print partition table. Stampa la tabella delle partizioni, un ottimo comando per farsi un'idea di come è divisa la nostra memoria, sia prima che dopo le nostre operazioni con fdisk. Dandolo vi uscirà una cosa del genere:
    Codice:
    Dispositivo Boot      Start         End      Blocks   Id  System
    /dev/sda1   *           1          52      409600   27  Sconosciuto
    /dev/sda2              52       19508   156284928    7  HPFS/NTFS
    /dev/sda3           19508       38914   155874358    5  Esteso
    /dev/sda5           19508       19630      975872   82  Linux swap / Solaris
    /dev/sda6           19630       38914   154897461   83  Linux
    Piuttosto semplice da leggere. "Dispositivo" indica la partizione, "Boot" indica se tale partizione va avviata al boot del PC (l'accensione), "Start" indica il cilindro iniziale, "End" quello finale, "Blocks" indica la dimensione della partizione in byte, "Id" indica il codice esadecimale dei file system e "System" ci dice esplicitamente qual è.

    q: quit without saving changes. Esci senza applicare le modifiche concordate. Se digitate q e date invio uscirete da fdisk e troverete il vostro disco esterno nelle stesse condizioni di quando lo avete collegato.

    w: write table to disk and exit. Esci ed applica le modifiche concordate. Una volta creata una nuova tabella di partizioni, bisogna dare il comando w perché questa tabella venga scritta sul disco

    *Importante: la memoria che andiamo a formattare, deve essere smontata


    Creare o modificare un file di testo con nano.
    Spoiler:
    Potrà capitare nella nostra esperienza linuxiana, di aver bisogno di creare un testo, senza la possibilità di avviare l'interfaccia grafica, quindi senza poter usare editor di testo molto gettonati come gedit. Dovete sapere che esistono vari editor di testo che girano in console, quali vim, o quello che preferisco, nano.

    nano è semplicissimo da avviare, basta digitare nel terminale

    nano [argomento]

    per:

    - Iniziare a scrivere un file nuovo che si chiami [argomento]
    - Modificare il file [argomento]

    una volta aperto, l'uso di nano è piuttosto intuitivo, si digita normalmente ciò che si vuole scrivere, ci si muove con le freccette e si usano varie opzioni e scorciatoie da tastiera che si trovano in bella vista in basso:

    Ctrl + G = Stampa una breve guida
    Ctrl + O = Salva
    Ctrl + X = Esci, se ci sono modifiche non salvate chiede se salvarle prima di uscire
    Ctrl + K = Prende la riga in cui ci troviamo, la elimina dal testo e la mette nel buffer
    Ctrl + U = Incolla quello che c'è nel buffer
    Ctrl + T = Esegue un controllo ortografico

    E tante altre opzioni che probabilmente non userete mai.


    PIPELINING, CONCATENAMENTO DI COMANDI

    Spesso abbiamo bisogno di dare più comandi di seguito, o di dare comandi a seconda se i precedenti abbiano avuto successo o meno, per fare questo ci vengono in aiuto speciali caratteri del terminale, che hanno significati "speciali":

    ; = Semplicemente esegue un comando dopo l'altro di fila, senza nessuna condizione o opzione.

    Dare una cosa del genere in pasto al terminale: ls; espeak "these are your files"

    indica di elencare tutti i file e dire "these are your files"


    | = Manda l'output del primo comando come argomento del secondo comando.

    Ad esempio:

    Codice:
    jones@YaHa-Toshiba:~/Documenti$ ls | grep Valkyria
    Traduzione_Valkyria_Chronicles_by_JrpgWorld.doc
    jones@YaHa-Toshiba:~/Documenti$
    Fa una lista di tutto ciò che c'è in /home/jones/Documenti, poi però manda quella lista come argomento di grep, e quindi diventa un: cerca tra la lista di tutto ciò che c'è in Documenti, le righe con scritto Valkyria nel nome.
    Si sfrutta massicciamente il simbolo | nel terminale con i comandi grep, more e less, per ovvi motivi.


    || = Vuol dire "se il primo comando ha successo, non svolgere il secondo. Se invece il primo comando fallisce, prosegui ad eseguire il secondo."

    Ad esempio:

    ping -c 1 192.168.1.1 || echo "Il router è spento"

    Manda un solo pacchetto all'indirizzo 192.168.1.1, se il pacchetto non arriva, il comando fallisce, quindi viene eseguito il secondo comando, e cioè viene stampato su schermo la frase: "Il router è spento"


    && = Opposto di ||. Vuol dire "se, e solo se il primo comando ha successo, esegui anche il secondo, altrimenti fermati"

    Un esempio tipo quello precedente può essere:

    ping -c 1 192.168.1.1 && echo "Il router è acceso"


    > = Manda il risultato del primo comando in un file che si chiamerà come il secondo argomento.

    Ad esempio scrivere:

    ls /home/jones/Documenti > listato_file_documenti.txt

    Vuol dire "crea un file che si chiami listato_file_documenti.txt con all'interno l'output del comando ls, ovvero la lista di tutti i file contenuti nella cartella documenti". Se il file "listato_file_documenti.txt" esiste già, lo sovrascrive.

    >> = Come il simbolo >, soltanto che se il file dove scrivere già esiste, non cancella il contenuto, ma lo aggiunge in fondo.


    PRIMI SCRIPT

    Script di bash, o script di console, parole che fanno tremare i novizi di Linux, sono molto simpatiche a chi invece ne capisce il funzionamento.
    Uno script non è altro che un file contenente una sequenza di comandi messe in fila, assieme a varie istruzioni di condizione o di loop per le quali eseguire i comandi. Di solito il file contenente questi comandi e istruzioni (cioè lo script) viene salvato con estenzione ".sh".
    Uno script su Linux va sempre iniziato con la seguente riga:

    #!/bin/bash

    Che è "l'interprete". Ovvero indica al sistema operativo di prendere tutto ciò che abbiamo scritto dai comandi della bash.

    *Attenzione: di solito tutte le righe che iniziano con il simbolo '#' vengono ignorate dal terminale, che le interpreta come commenti del programmatore.

    Dopo la prima riga viene quello che si dice il corpo dello script, cioè tutti i comandi e le condizioni che sono contenuti in esso.

    Ad esempio, scriviamo uno script del genere:

    Codice:
    #!/bin/bash
    
    echo "questo è il mio primo script"
    echo "non fa niente di interessante, è solo una prova"
    echo "ecco una lista dei file della cartella in cui mi trovo, di cui io sono il proprietario"
    #Questo è un commento e viene ignorato
    ls -la | grep jones
    NB: Andando a capo viene sottointeso il punto e virgola alla fine di un comando.

    Salviamo questo file con un nome (ad esempio primo_script.sh), e da questo momento possiamo mandare questa serie di comandi scrivendo:

    bash primo_script.sh

    oppure:

    sh primo_script.sh

    oppure, se diamo al file i permessi di esecuzione (chmod +x primo_script.sh), semplicemente con:

    ./primo_script.sh

    Questi tre comandi equivalgono a tutta la serie di comandi messa nello script, cioè stampare su schermo ciò che abbiamo scritto di stampare, listare tutti i file nella cartella in cui stiamo lavorando (compresi i file nascosti) in formato lungo, e mandare il risultato di questa operazione a grep che eliminerà tutte le righe che non contengono la stringa "jones".

    Capirete che l'utilità di questa roba è quasi nulla al momento. Per apprezzare per bene gli script devo mostrarvi tutti gli elementi di cui si possono comporre, ovvero: variabili, costrutti e funzioni.


    VARIABILI:

    Le variabili non sono altro che elementi il cui valore varia a seconda di come vogliamo che cambi, o di come gli eventi che accadono in console le fanno cambiare.
    Una variabile si dichiara grazie al segno '=':

    VARIABILE1=variabile
    VARIABILE2="questa è una variabile"
    VARIABILE3=192.168.1.1
    VARIABILE4=$(pidof vlc)
    VARIABILE5=$1


    NB: è consuetudine che il nome della variabile sia tutto maiuscolo, ma non è obbligatorio, nulla ci vieta di chiamare una variabile "variabile" oppure "VaRIabIlE".

    Nel primo caso nella variabile VARIABILE1 troviamo "variabile" e si dice che quello è il suo valore. Nel secondo caso il valore della variabile VARIABILE2 è "questa è una variabile". Nel terzo caso invece è 192.168.1.1 . Nel quarto caso, particolarmente importante, è il risultato del comando tra parentesi, ergo il pid di vlc, nel mio caso 1656 (se vlc non avesse nessuna istanza il valore di VARIABILE4 sarebbe nullo). Nell'ultimo caso invece, ancora più importante, il valore della variabile è uguale al primo argomento che immettiamo dopo il nome dello script.

    Le variabili vengono interpretate dal terminale esattamente come se fossero i loro valori. Ad esempio dare il comando:

    echo $VARIABILE2

    è lo stesso che scrivere

    echo "questa è una variabile"

    Oppure

    kill $VARIABILE4

    e

    kill 1656

    Sono comandi equivalenti.

    Il valore della VARIABILE5 invece, come ho detto è il valore che immettiamo come primo argomento dopo il nome dello script.
    Ad esempio, abbiamo uno script del tipo:

    Codice:
    #!/bin/bash
    
    UTENTE=$1
    
    echo "vi presento la home dell'utente $UTENTE"
    
    ls /home/$UTENTE
    Quando andiamo ad avviare lo script, questo avrà bisogno di un argomento per essere avviato, argomento che andrà a essere il valore della variabile.
    Cioè, se io, dopo aver salvato quello script come "ls_home_utente_personalizzato.sh", lo avvio con:

    sh ls_home_utente_personalizzato.sh jones

    "jones" andrà ad essere inserito come valore della variabile UTENTE, e quindi avrò come output una riga di testo con scritto "vi presento la home dell'utente jones" seguito dal listato di tutta la roba che c'è in /home/jones.
    Se avessi voluto una variabile che prendeva come valore il secondo argomento dello script avrei dovuto scrivere VARIABILE5=$2, per il terzo $3 e così via.

    NB: Perché il terminale capisca che stiamo utilizzando una variabile, dobbiamo anteporre il simbolo $ prima del nome, come avete visto negli esempi sopra.


    OPERAZIONI CON LE VARIABILI - Se abbiamo una variabile numerica, possiamo svolgere operazioni matematiche con il suo valore, tramite i classici segni di operazione e con una sintassi un po' particolare. Prendiamo ad esempio le variabili N=3 e M=5.

    Per prima cosa, prima di svolgere operazioni del genere abbiamo bisogno farle precedere dal comando let:

    let [operazione]

    poi l'operazione deve essere posta questa forma:

    [variabile dove mettere il risultato]=[operazione da svolgere]

    ad esempio:

    let N=$N+4

    Prende la variabile N e la somma con il numero 4, mette il risultato nella variabile N, il cui nuovo valore sarà 7. Oppure:

    let N=$M-1

    Prende la variabile M e ci sottrae due, mettendo il risultato nella variabile N, il cui nuovo valore sarà 3

    let N=$N*$M

    Prende le variabili N e M e le moltiplica, mettendo il risultato in N, il cui nuovo valore sarà 6.

    NB: In [variabile dove mettere il risultato] non è necessario mettere il simbolo $ perché il terminale capisca che sia una variabile, in [operazione da svolgere] invece si.


    COSTRUTTI:

    Negli script, come nella programmazione, si sfruttano pesantemente i costrutti if, for e while, usati per "pilotare" i comandi dello script.


    IF - Se una condizione è vera, esegue un comando, altrimenti va oltre. La sintassi è la seguente:

    if [ [condizione] ] ; then [ serie di comandi ] ; fi

    *Attenzione: Le parentesi quadre della condizione sono incluse nella sintassi del comando if (vedete gli esempi sotto).

    Le condizioni vengono espresse nella stessa forma delle opzioni dei comandi, eccone alcune:

    -r: verifica se il file è leggibile
    -w: verifica se il file è scrivibile
    -x: verifica se il file è eseguibile
    -eq: verifica di uguaglianza
    -lt: verifica se è minore
    -gt: verifica se è maggiore
    -z: verifica se la lunghezza della variabile è 0 (cioè se la variabile è nulla)
    !: inverte il senso della condizione

    *tutte le altre condizioni le potete trovare nell'immenso manuale della bash (comando: man bash)

    Qualche esempio:

    if [ -r guida_terminale_backup_ftw.txt ] ; then echo "il file è leggibile" ; fi

    Qui semplicemente esegue una verifica di leggibilità sul file guida_terminale_backup_ftw.txt. Se, e solo se il file risulta leggible, stampa su schermo la frase "il file è leggibile", se il file non risulta leggibile perché non abbiamo i permessi, o perché magari è danneggiato o non esiste, non stampa niente ed esegue direttamente eventuali comandi dopo il fi.

    L'esempio contrario, per mostrare l'uso del '!' è questo:

    if [ ! -r guida_terminale_backup_ftw.txt ] ; then echo "il file non è leggibile" ; fi

    In questo caso invece, il comando echo viene eseguito soltanto se il file guida_terminale_backup_ftw.txt non è leggibile.

    Altro esempio:

    N=8
    M=9
    if [ $N -lt $M ] ; then echo "$N è più piccolo di $M" ; fi


    Dopo la dichiarazione e assegnazione di due variabili, controlla se la variabile N sia minore della variabile M, se così stampa su schermo la frase indicata. Altrimenti, passa oltre.
    Ancora:

    PID=$(pidof vlc)
    if [ -z $PID ] ; then echo "vlc non è in esecuzione, lo avvio" ; vlc ; fi


    Al costrutto if faccio verificare se la lunghezza della variabile PID è zero, cioè se il comando "pidof vlc" non ha dato output, cioè se vlc non è attivo. Solo in quel caso esegue il comando echo seguito dal comando vlc (che avvia vlc), altrimenti continua ad eseguire ciò che trova dopo fi.


    IF/ELSE - Se una condizione è vera, esegue un comando, altrimenti ne esegue un altro. La sintassi è:

    if [ [condizione] ] ; then [ serie di comandi ] ; else [ serie di comandi ] ; fi

    Un esempio simile a uno dei precedenti:

    N=5 ; M=11
    if [ $N -gt $M ] ; then echo "$N è più grande di $M" ; else echo "$M è più grande di $N" ; fi ; echo "fine esempio"

    Piuttosto semplice. Se N è più grande di M esegue il comando

    echo "$N è più grande di $M"

    Altrimenti esegue il comando

    echo "$M è più grande di $N"

    In ogni caso dopo verrà eseguito il comando

    echo "fine esempio"


    FOR = Inizia un loop di assegnazione variabili ed esegue un comando ogni volta che la variabile cambia. Sintassi:

    for [nome variabile] in [contenuti variabile] ; do [comando] ; done.

    Un po' difficile da capire in questo modo, e anche difficile da spiegare altrimenti. Spero che qualche esempio vi chiarisca le idee:

    for CIBO in cornetto crostata ; do echo $CIBO ; done

    Assegna alla variabile CIBO gli elementi che si trovano dopo 'in' e come comando a ogni giro esegue la stampa su schermo della variabile. L'ordine è questo:

    - Crea una variabile e la chiama CIBO
    - Assegna alla variabile il primo elemento dopo in
    - Esegue il comando dopo il do
    - Torna indietro e assegna alla variabile il secondo elemento dopo in
    - Esegue il comando dopo il do
    - Torna indietro e vede che non c'è nessun altro elemento dopo l'in
    - Esce dal ciclo

    Come elementi da assegnare alle variabili possiamo anche eseguire dei comandi. Ad esempio

    for FILE in $(ls /home/jones) ; do espeak $FILE ; done

    In questo caso, alla variabile FILE vengono assegnati uno per volta tutti gli elementi dell'output del comando 'ls /home/jones', ovvero il listato di tutti i file che si trovano nella cartella home dell'utente jones, dopodiché vengono letti ad alta voce. Vi assicuro che è uno spasso

    Un altro esempio, tratto da un problema del nostro buon .Bucch, è questo:
    Citazione Originariamente Scritto da .Bucch
    Devo eliminare tutte le immagini, contenute in una cartella e annesse sottocartelle e sotto-sottocartelle (beh avete capito) con rm o qualsiasi altro comando da terminale. Specificando l'estensione magari, così da poterlo attuare a tutti i tipi file.
    Questa ne è la semplice soluzione:

    for IMMAGINI in *jpg */*jpg */*/*jpg; do rm "$IMMAGINI" ; done

    Che fa il listato di tutti i file che abbiano per nome qualunque carattere e che finiscono con jpg (ovvero tutti i file con estensione .jpg) nella cartella in cui ci troviamo in questo momento, in tutte le sue sotto-cartelle e in tutte le sotto-cartelle delle sotto-cartelle, e li assegna a uno a uno alla variabile IMMAGINI, che viene poi utilizzata come argomento del comando rm per eliminare suddetto file.

    Spoiler:
    Angolo del programmatore curioso: Sempre il nostro buon .Bucch, mi ha posto una domanda che potrebbe interessare chi di voi ha studiato, o sta studiando programmazione:

    Citazione Originariamente Scritto da .Bucch
    nel ciclo for se volessi usarlo come nella programmazione java/c/php, cioè che gli assegno una variabile contatore e la incremento ad ogni loop finchè non raggiunge il valore che decido io come dovrei fare?
    Il ciclo for della bash è diverso dai cicli for degli altri linguaggi di programmazione, il suo utilizzo, così come il suo scopo sono diversi dal for che già conoscete. Però qualcuno degli utilizzi del for "classico" può essere emulato grazie al comando seq:

    seq [argomento1] [argomento2]

    Che stampa la sequenza di i tutti i numeri dal primo al secondo argomento:

    seq 1 4

    Ha come output:

    1
    2
    3
    4


    Quindi a rigor di logica, dare un comando:

    for i in $(seq 1 4) ; do [vari comandi] ; done

    è equivalente al

    for (int i=1; i<=4; i++) {
    [vari comandi]
    }

    Del c++

    Cioè esegue la reiterazione della serie di comandi [vari comandi] per 4 volte, assegnando alla variabile i dapprima il valore 1, poi lo incrementa di un'unità finché non raggiunge il valore 4.

    Ad esempio un programma in c++ con codice sorgente:

    Codice:
    #include <iostream>
    using namespace std;
    
    int main () 
    {
      for (int i=1; i<=4; i++)
      {
        cout << i;
        cout << endl;
      }
      return 0;
    }
    È equivalente allo script:

    Codice:
    #!/bin/bash
    
    for i in $(seq 1 4) ; do echo $i ; done



    WHILE - Continua a eseguire uno o più comandi, finché una condizione è verificata o compare un comando d'uscita

    while [ [condizione] ] ; do [comandi] ; done

    Le condizioni sono esattamente le stesse che si usano nel costrutto if.

    Anche qui partiamo con qualche esempio:

    N=0
    while [ $N -lt 2 ] ; do let N=$N+1 ; echo $N ; done


    - Assegna il valore 0 alla variabile N
    - Controlla se N è minore di 2
    - È minore di 2, quindi entra nel corpo del ciclo while
    - Somma 1 a N, il valore di N è ora 1
    - Stampa su schermo il valore di N (cioè 1)
    - Torna sopra, controlla di nuovo se N è minore di 2
    - Lo è, quindi torna nel ciclo while
    - Somma 1 a N, il valore di N è ora 2
    - Stampa su schermo il valore di N (cioè 2)
    - Torna sopra, controlla ancora una volta se N è minore di 2
    - Non lo è, esce dal ciclo e esegue eventuali comandi dopo il done

    Molto spesso il costrutto while viene messo per generare cicli infiniti, cioè dei cicli che non hanno mai fine, per eseguire continuamente la stessa serie di comandi. Un ciclo infinito si può generare sia mettendo una condizione che non diventerà mai falsa (se all'esempio di sopra togliamo il 'let N=$N+1' diventa un ciclo infinito) oppure in questi semplici modi:

    while true; do [comandi] ; done
    while :; do [comandi] ; done


    Che sono equivalenti, scegliete voi quale usare.

    Per casi del genere però si può usare il comando break, che forza l'uscita del ciclo, nel caso succeda qualcosa, esempio:

    Codice:
    while :; do
      VAR=$(ls ~)
      if [ -z $VAR ]
        then break
      fi
      echo "sono un vero figo, ho molti file"
      sleep 2
    done
    Che continua all'infinito a meno ché non si verifichi la condizione nell'if che gli fa eseguire il comando break, provocando l'uscita istantanea dal ciclo per eseguire le istruzioni successive al done.

    NB: Per i cicli infiniti è opportuno mettere nel corpo del while il comando sleep per non affaticare eccessivamente il processore


    FUNZIONI:

    Una funzione in uno script è semplicemente una serie di comandi, che definiamo con un nome, tale nome ogni volta che viene chiamato richiama i comandi nel corpo della funzione. Una sorta di script nello script.
    Le funzioni si dichiarano anteponendo function al nome della funzione, e mettendo il corpo della funzione tra parentesi graffe:

    Codice:
    #!/bin/bash
    
    function listjpg {
    
    ls *.jpg || echo "non ci sono immagini JPG"
    
    }
    
    D=$(pwd)
    
    echo "ecco le immagini JPG nella cartella $D"
    listjpg
    In questo caso, lo script è equivalente a questo:

    Codice:
    #!/bin/bash
    
    D=$(pwd)
    
    echo "ecco le immagini JPG nella cartella $D"
    ls *.jpg || echo "non ci sono immagini JPG"
    Cioè la banale sostituzione del corpo della funzione, dovunque vi sia il nome della stessa (che poi è ciò che avviene realmente in fase di esecuzione)

    NB: Una funzione deve essere definita prima di essere usata.


    IN THE END:

    Ecco uno script che ho creato, molto semplice, eppure molto utile:

    Codice:
    #!/bin/bash
    
    IP="192.168.1.15"
    
    #Funzione che avvia transmission se non è attivo
    function avvia_transmission { 
    
    if [ -z $PID ]
      then transmission 
    fi
    
    }
    
    While :; do #ciclo infinito
      PID=$(pidof transmission)
      ping -c 1 $IP || avvia_transmission #se il PC nemico non risponde, avvia transmission
        if [ ! -z $PID ] #se transmission è attivo
        then ping -c 1 $IP && kill $PID #se il PC nemico risponde, uccidi transmission
        fi
      sleep 10; #dormi per 10 secondi
    done
    Questo script l'ho creato perché mio fratello vuole andare su facebook di domenica mattina (folle), quindi il fatto che io di sabato notte lascio transmission attivo che mangia tutta la banda gli darebbe fastidio, e pretendeva che mi svegliassi (ancora più folle) per spegnere transmission qualora avesse dovuto navigare. Per fortuna essere nerd serve a qualcosa e ho creato questo scriptino che:

    - Se il PC di mio fratello è acceso, e transmission è attivo, lo chiude
    - Se il PC di mio fratello è acceso, e transmission è chiuso, non fa niente
    - Se il PC di mio fratello è spento, e transmission è attivo, non fa niente
    - Se il PC di mio fratello è spento, e transmission è chiuso, lo avvia

    Oramai dovreste avere tutti gli strumenti per capire alla perfezione il funzionamento di questo script senza la mia spiegazione

    *Attenzione: per chiunque abbia una connessione un po' più decente della mia, non è necessaria una soluzione così bruta, si può modificare lo script in modo da castrare la banda di transmission e mettergli un limite, ad esempio di 10 Kb/s in download e upload, semplicemente sostituiendo i comandi

    transmission

    e

    kill $PID

    Con dei comandi esclusivi di trasmission che permettono di manipolarlo da remoto. I comandi in questione sono:

    transmission-remote -d 10 -u 10 (per limitare la banda, -d indica il limite di download e -u quello di upload)
    transmission-remote -D -U (per sbloccare il limite banda)

    Inoltre non ci sarebbe bisogno di controllare ogni volta se transmission sia acceso o meno, quindi la funzione "avvia_transmission" sarebbe superflua così come il costrutto if nel corpo dello script.

    In conclusione lo script diventerebbe:

    Codice:
    #!/bin/bash
    
    IP="192.168.1.15"
    
    While :; do
      ping -c 1 $IP || transmission-remote -D -U
      ping -c 1 $IP && transmission-remote -d 10 -u 10
      sleep 10;
    done
    Per fiera della semplicità

    THE END. YA-HA!


    Ringrazio OniXenon per le solite correzioni grammaticali e piccole aggiunte, e .Bucch per i suoi "post free" che hanno portato a ottimi esempi e approfondimenti


    Ultima modifica di Stemaa; 16-02-17 alle 13:43:21

  2. #2
    Professionista L'avatar di freax
    Iscritto dal
    30-Nov-2007
    Post
    1,297
    Profilo Mercatino
    visualizza
    ID utente
    40858

    Linux Conoscere l'hardware installato sulla propria macchina con Linux

    Conoscere l'hardware installato sulla propria macchina con Linux

    Prerequisiti
    lshw installato sulla macchina

    Breve descrizione di lshw
    Lshw è una utility da usare da un terminale, esiste anche un wrapper gtk ovvero lshw-gtk .
    Lshw necessita dei diritti di root per produrre un resoconto affidabile e completo .
    Lshw funziona con tutti e 3 i rami del kernel linux attualmente più diffusi , ovvero il 2.6.x , il 2.4.x e il 2.2.x .
    Per più informazioni fare riferimento alla pagina ufficiale del progetto http://ezix.org/project/wiki/HardwareLiSter .

    Uso
    lshw non ha bisogno di argomenti o flag per produrre un output, semplicemente come detto gli vanno attribuiti i diritti di root, quindi il seguente comando produrrà delle informazioni in base alla configurazione hardware del proprio pc

    Codice:
    sudo lshw
    come si noterà lshw, di default, tende ad essere "verbose" ovvero prolisso nello sciorinare informazioni, questo può tradursi in una complicata lettura del testo a video, soprattutto quando semplicemente cerchiamo informazioni basilari e generiche, come ad esempio il semplice nome e/o modello della x periferica ; a tal fine si può usare la flag -short, ovvero :

    Codice:
    sudo lshw -short
    si noterà che questa volta l'output sarà molto più succinto e soprattutto molto più leggibile per la mente e l'occhio umano ; da notare anche l'utilità del contenuto della colonna "Device" soprattutto per dischi e periferiche di rete, la colonna "Class", invece, ci indica la famiglia di appartenenza del dispositivo oggetto di quella riga .
    Lshw, infatti, distingue tra varie categorie, quali :

    Spoiler:
    system informazioni riferite all'intera macchina
    bridge solitamente qui troviamo bus e controller interni ( AGP, PCI, PCMCIA, etc )
    memory memorie ad accesso casuale, banchi di memoria, qualsiasi spazio che possa contenere e/o eseguire dati ( RAM, BIOS, firmware, etc )
    processor esecutori , di norma CPU e particolari controller
    address indirizzi di memoria
    storage controller, solitamente IDE o SCSI, atti alla memorizzazione dei dati
    disk memorie ad accesso diretto ( CD, DVD, HDD, etc )
    tape memorie ad accesso sequenziale ( DAT, DDS ) - in larga parte in disuso
    bus bus di collegamento ( USB, firewire, SCSI )
    network interfacce di rete ( Ethernet, FDDI, WiFi, Bluetooth, etc )
    display adattatore video ( EGA/VGA, UGA, etc )
    input periferiche di input ( keyboards, mice, joysticks, etc )
    printer stampanti
    multimedia periferiche multimediali ( schede audio, schede TV, schede di acquisizione, etc )
    communication porte seriali e modem
    power alimentazione ( batteria e alimentatore )
    volume volumi, partizioni, filesystem
    generic classe assegnata a periferiche non classificabili nelle altre classi


    pertanto volendo ottenere informazioni solo riguardo ai dispositivi di rete installati nella macchina basterà dare il seguente comando :

    Codice:
    sudo lshw -c network
    per combinare più categorie basta ripetere la flag -c accompagnata dal nome della categoria, ovvero per conoscere il contenuto delle categorie processor e display va dato il comando :

    Codice:
    sudo lshw -c processor -c display
    Come interpretare l'output di lshw:

    lshw mostra i nodi con attributi in una struttura ad albero, come semplice testo, HTML, XML o graficamente utilizzando la GUI.
    Ogni nodo può avere sotto-nodi e un certo numero di attributi, proprietà, risorse e valori di configurazione.

    Attributi:
    • id -> Identificativo interno usato da lshw.
    • class -> classe della periferica (vedi la lista delle classi).
    • description -> descrizione del nodo hardware.
    • vendor -> fornitore/produttore della periferica.
    • product -> nome della periferica.
    • version -> versioend i rilascio della periferica.
    • serial -> serial number della periferica.
    • capacity -> capacity* massima della periferica.
    • size -> size* attuale della periferica.
    • clock -> clock, in Hz, del bus della periferica.
    • width -> ampiezza di indirizzamento della periferica (32 o 64 bit).
    • slot -> slot dove la periferica è connessa.
    • logicalname -> nome logico usato dal sistema per identificare la periferica.
    • dev -> numero della periferica.
    • businfo -> informazioni sul bus della periferica.
    • pysid -> identificativo fisico.


    Note:
    - *size e capacity possono avere diversi significati a seconda della periferica a cui si riferiscono: per un processore, size è la frequenza del processore in hertz; per un disco, è il suo spazio libero attuale in byte (e capacity fa riferimento alla sua dimensione totale non formattata, includendo settori danneggaiti); per una scheda di rete, size e capacity fanno riferimento alla largehzza di banda in bit al secondo.
    - L'attributo size di un nodo è sempre ninore o uguale a quello di capacity
    - L'attributo serial si riferisce al numero di serie della periferica per i dischi, memorie, processori, schede varie, ecc. Viene invece usato per riportare l'indirizzo MAC per le schede di rete e per il GUID delle partizioni di un disco.

    Capabilities:
    L'attributo Capabilities è usato per riportare le caratteristiche del nodo a cui fa riferimento. L'esatto significato di ogni caratteristica dipende dal tipo di nodo, può essere, per esempio, la presenza di un coprocessore aritmetico per una CPU, l'abilità di una scheda di rete di trasferire a 1GB/s, ecc.
    In molti casi le capabilities riportate da lshw sono documentate (entrambe le versioni XML e HTML riportano un commneto per ogni caratteristica, inoltre questi commenti sono mostrati se si utilizza l'interfaccia grafica).

    Testo originale in inglese da: http://ezix.org/project/wiki/HardwareLiSter.


    Alcuni esempi:


    lshw -short
    Spoiler:
    Codice:
    bucch@Heaven ~ $ sudo lshw -short
    H/W path             Device      Class       Description
    ========================================================
                                     system      Maximus Formula
    /0                               bus         Maximus Formula
    /0/0                             memory      64KiB BIOS
    /0/4                             processor   Intel(R) Core(TM)2 Quad  CPU   Q9450  @ 2.66GHz
    /0/4/5                           memory      128KiB L1 cache
    /0/4/6                           memory      12MiB L2 cache
    /0/3f                            memory      4GiB System Memory
    /0/3f/0                          memory      2GiB DIMM DDR2 Synchronous 800 MHz (1.2 ns)
    /0/3f/1                          memory      DIMM [empty]
    /0/3f/2                          memory      2GiB DIMM DDR2 Synchronous 800 MHz (1.2 ns)
    /0/3f/3                          memory      DIMM [empty]
    /0/100                           bridge      82X38/X48 Express DRAM Controller
    /0/100/1                         bridge      82X38/X48 Express Host-Primary PCI Express Bridge
    /0/100/1/0                       display     Radeon HD 3870
    /0/100/1/0.1                     multimedia  Radeon HD 3870 Audio device
    /0/100/1a                        bus         82801I (ICH9 Family) USB UHCI Controller #4
    /0/100/1a.1                      bus         82801I (ICH9 Family) USB UHCI Controller #5
    /0/100/1a.2                      bus         82801I (ICH9 Family) USB UHCI Controller #6
    /0/100/1a.7                      bus         82801I (ICH9 Family) USB2 EHCI Controller #2
    /0/100/1b                        multimedia  82801I (ICH9 Family) HD Audio Controller
    /0/100/1c                        bridge      82801I (ICH9 Family) PCI Express Port 1
    /0/100/1c.5                      bridge      82801I (ICH9 Family) PCI Express Port 6
    /0/100/1c.5/0        eth0        network     88E8056 PCI-E Gigabit Ethernet Controller
    /0/100/1d                        bus         82801I (ICH9 Family) USB UHCI Controller #1
    /0/100/1d.1                      bus         82801I (ICH9 Family) USB UHCI Controller #2
    /0/100/1d.2                      bus         82801I (ICH9 Family) USB UHCI Controller #3
    /0/100/1d.7                      bus         82801I (ICH9 Family) USB2 EHCI Controller #1
    /0/100/1e                        bridge      82801 PCI Bridge
    /0/100/1e/3                      bus         VT6306/7/8 [Fire II(M)] IEEE 1394 OHCI Controller
    /0/100/1f                        bridge      82801IR (ICH9R) LPC Interface Controller
    /0/100/1f.2          scsi0       storage     82801 SATA RAID Controller
    /0/100/1f.2/0        /dev/cdrom  disk        DVD-RAM GH22LS30
    /0/100/1f.2/1        /dev/sda    disk        150GB WDC WD1500HLFS-0
    /0/100/1f.2/1/1      /dev/sda1   volume      100MiB Windows NTFS volume
    /0/100/1f.2/1/2      /dev/sda2   volume      110GiB Windows NTFS volume
    /0/100/1f.2/1/3      /dev/sda3   volume      1907MiB Linux swap volume
    /0/100/1f.2/1/4      /dev/sda4   volume      27GiB EXT4 volume
    /0/100/1f.2/2        /dev/sdb    disk        320GB ST3320620AS
    /0/100/1f.2/2/1                  volume      596GiB HPFS/NTFS partition
    /0/100/1f.2/3        /dev/sdc    disk        320GB ST3320613AS
    /0/100/1f.2/0.0.0    /dev/sdd    disk        1TB WDC WD10EARS-00Y
    /0/100/1f.2/0.0.0/1  /dev/sdd1   volume      931GiB Windows NTFS volume
    /0/100/1f.3                      bus         82801I (ICH9 Family) SMBus Controller



    Per ottenere informazioni su...:


    Processore

    Spoiler:

    Se vogliamo conoscere le caratteristiche del processore che montiamo possiamo saperle con il comando sudo lshw -c processor
    Codice:
    bucch@Heaven ~ $ sudo lshw -c processor
      *-cpu                   
           description: CPU
           product: Intel(R) Core(TM)2 Quad  CPU   Q9450  @ 2.66GHz
           vendor: Intel Corp.
           physical id: 4
           bus info: cpu@0
           version: Intel(R) Core(TM)2 Quad CPU Q9450 @ 2.66GHz
           serial: To Be Filled By O.E.M.
           slot: LGA775
           size: 2666MHz
           capacity: 3800MHz
           width: 64 bits
           clock: 333MHz
           capabilities: fpu fpu_exception wp vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall x86-64 constant_tsc arch_perfmon pebs bts rep_good aperfmperf pni dtes64 monitor ds_cpl vmx smx est tm2 ssse3 cx16 xtpr pdcm sse4_1 lahf_lm tpr_shadow vnmi flexpriority
    Nell'esempio troviamo:
    Il modello, sotto l'attributo product che in questo caso è un Core 2 Quad Q9450.
    Il produttore, Intel, sotto l'attrivuto vendor.
    L'identificativo fisico della periferica, (physical id) che è 4.
    Poi troviamo il numero seriale (serial), il socket usato dal processore (slot), la frequenza attuale del processore (size) e la massima che può raggiungere secondo il fornitore (capacity), l'ampiezza d'indirizzamento (width), il clock del bus in questo caso dell'FSB (clock) e infine tutte le istruzioni e funzioni che supporta (capabilities)


    Memorie

    Spoiler:

    Con il comando sudo lshw -c memory possiamo sapere le varie memorie fisiche installate sul pc, ovviamente esclusi i dischi rigidi.
    Codice:
    bucch@Heaven ~ $ sudo lshw -c memory
      *-firmware              
           description: BIOS
           vendor: American Megatrends Inc.
           physical id: 0
           version: 1403 (09/10/2009)
           size: 64KiB
           capacity: 1984KiB
           capabilities: isa pci pnp apm upgrade shadowing escd cdboot bootselect socketedrom edd int13floppy1200 int13floppy720 int13floppy2880 int5printscreen int9keyboard int14serial int17printer int10video acpi usb ls120boot zipboot biosbootspecification
      *-cache:0
           description: L1 cache
           physical id: 5
           slot: L1-Cache
           size: 128KiB
           capacity: 128KiB
           capabilities: internal write-back data
      *-cache:1
           description: L2 cache
           physical id: 6
           slot: L2-Cache
           size: 12MiB
           capacity: 12MiB
           capabilities: internal write-back instruction
      *-memory
           description: System Memory
           physical id: 3f
           slot: System board or motherboard
           size: 4GiB
         *-bank:0
              description: DIMM DDR2 Synchronous 800 MHz (1.2 ns)
              product: PartNum0
              vendor: Manufacturer0
              physical id: 0
              serial: SerNum0
              slot: DIMM0
              size: 2GiB
              width: 64 bits
              clock: 800MHz (1.2ns)
         *-bank:1
              description: DIMM [empty]
              product: PartNum1
              vendor: Manufacturer1
              physical id: 1
              serial: SerNum1
              slot: DIMM1
         *-bank:2
              description: DIMM DDR2 Synchronous 800 MHz (1.2 ns)
              product: PartNum2
              vendor: Manufacturer2
              physical id: 2
              serial: SerNum2
              slot: DIMM2
              size: 2GiB
              width: 64 bits
              clock: 800MHz (1.2ns)
         *-bank:3
              description: DIMM [empty]
              product: PartNum3
              vendor: Manufacturer3
              physical id: 3
              serial: SerNum3
              slot: DIMM3
    Nell'esempio ci vengono mostrati più nodi appartenenti alla classe memory, sono nel nostro caso:
    *-firmware: il bios della scheda madre.
    *-cache:0 e *-cache:1 sono le memorie cache, rispettivamente di livello 1 (L1) e livello 2 (L2) integrate nel processore.
    *-memory è la RAM del sistema, che ha come sotto-nodi i vari slot presenti, banchi installati e relative informazioni (*-bank:0, *-bank:1, *-bank:2 e *-bank:3).



    Scheda di rete
    Spoiler:

    Per conoscere le interfacce di rete installate, invece, utilizziamo il comando sudo lshw -c network
    Codice:
    bucch@Heaven ~ $ sudo lshw -c network
      *-network               
           description: Ethernet interface
           product: 88E8056 PCI-E Gigabit Ethernet Controller
           vendor: Marvell Technology Group Ltd.
           physical id: 0
           bus info: pci@0000:02:00.0
           logical name: eth0
           version: 12
           serial: 00:11:22:33:44:55
           size: 100MB/s
           capacity: 1GB/s
           width: 64 bits
           clock: 33MHz
           capabilities: pm vpd msi pciexpress bus_master cap_list rom ethernet physical tp 10bt 10bt-fd 100bt 100bt-fd 1000bt 1000bt-fd autonegotiation
           configuration: autonegotiation=on broadcast=yes driver=sky2 driverversion=1.28 duplex=full firmware=N/A ip=192.168.1.2 latency=0 link=yes multicast=yes port=twisted pair speed=100MB/s
           resources: irq:44 memory:feafc000-feafffff ioport:d800(size=256) memory:feac0000-feadffff
    Dall'output del comando si può innanzitutto vedere come su questo pc ci sia installata solo una scheda di rete di tipo Ethernet (description), modello del controller di rete 88E8056 PCI-E Gigabit Ethernet Controller (product), costruito dalla Marvell (vendor).
    Altre informazioni utili sono il nome logico con cui il sistema la riconosce: eth0 (logical name), l'indirizzo MAC univoco di questa scheda [modificato per questioni di sicurezza ndr] (serial), la largehzza di banda utilizzata al momento 100MB/s (size) e la massima che può raggiungere 1GB/s (capacity).
    Come ultime informazioni troviamo le caratteristiche della scheda (capabilities), le impostazioni di configurazione attualmente in uso dal sistema (configuration) e le risorse che gli sono state assegnate (resources)


    ___________________________________

    a cura di freax e .Bucch


    Ultima modifica di OniXenon; 09-12-11 alle 13:14:56

  3. #3
    Proxy I Love You L'avatar di .Take
    Iscritto dal
    13-Mar-2009
    Località
    /
    Post
    1,211
    Profilo Mercatino
    visualizza
    ID utente
    58309

    Linux Ottimizzazione di GNU/Linux su notebook

    Se avete un portatile vi starete chiedendo:"Perchè se premo Fn+Vol_su o Fn+Vol_giù il volume sale e scende, mentre se provo con quello della luminosità non funziona?"

    Mistero della Fede.
    Per esperienza personale vi consiglio il metodo qua sotto che è il più facile e più efficiente.

    Qua sotto vi riporto 2 script per aumentare e diminuire la luminosità

    Questo è il codice per diminuire la luminosità dello schermo sui portatili.Aprire il programma Menu→Accessori→Editor di testo Gedit e copiare pari pari il codice qua sotto.

    Codice:
    #!/bin/bash
    bright=$(cat /sys/class/backlight/acpi_video0/brightness)
    let "bright = $bright - 2"
    echo $bright > /sys/class/backlight/acpi_video0/brightness
    Salvate il file con il nome lum-.sh nella vostra /home.

    Cliccate con il tasto desto e andate su Proprietà.Poi cliccate su Permessi e spuntate la scritta "Consentire l'esecuzione del file come programma".

    Chiudete.

    Ora facciamo la stessa cosa ma questo è per aumentare la luminosità

    Codice:
    #!/bin/bash
    bright=$(cat /sys/class/backlight/acpi_video0/brightness)
    let "bright = $bright + 2"
    echo $bright > /sys/class/backlight/acpi_video0/brightness
    Salvate il file con il nome lum+.sh nella vostra /home.

    Cliccate con il tasto desto e andate su Proprietà.Poi cliccate su Permessi e spuntate la scritta "Consentire l'esecuzione del file come programma".

    Chiudete.


    Ora l'ultimo passo Menu→Preferenze→Scorciatoie da tastiera cliccate su aggiungi

    Nome: Luminosità +
    Comando: bash -c "sudo /home/vostro_nome/lum+.sh"

    Cliccate su applica e scegliete la combinazione di tasti da usare per aumentare la luminosità.

    Nome: Luminosità -
    Comando: bash -c "sudo /home/vostro_nome/lum-.sh"

    Cliccate su applica e scegliete la combinazione di tasti da usare per diminuire la luminosità.

    Io personalmente uso il tasto Win+Freccia Su e Win+Freccia Giu.
    Il tasto Fn a qualcuno lo prende e ad altri no.

    Installare Powernowd

    Piccolo e simpatico programma per scegliere a quale frequenza far funzionare la vostra CPU.

    Prima di tutto installiamolo

    Codice:
    sudo apt-get install powernowd
    Fatto ciò date il comando

    Codice:
    sudo gedit /etc/init.d/powernowd
    Vi si aprirà un file, ora modificate solo la riga che scrivo in grassetto

    Codice:
    #! /bin/sh
    # Init script for powernowd
    #
    ### BEGIN INIT INFO
    # Provides:          powernowd
    # Required-Start:    $syslog $local_fs $time
    # Required-Stop:     $syslog $local_fs
    # Default-Start:     2 3 4 5
    # Default-Stop:         1
    # Short-Description: Start powernowd .
    ### END INIT INFO
    
    
    PATH=/sbin:/bin:/usr/sbin:/usr/bin
    DAEMON=/usr/sbin/powernowd
    NAME=powernowd
    DESC=powernowd
    OPTIONS="-q -m 2"
    
    test -x $DAEMON || exit 0
    Salvate e chiudete il file.

    Adesso cliccate su un pannello, con il tasto destro del mouse, Aggiungi al Pannello → Variazione Frequenza CPU.

    Apparirà una nuova icona sul pannello(ovviamente!) se cliccate vedrete diverse opzioni: Powersave, Performance, Ondemand, Conservative e le varie frequenze che la vostra CPU usare.

    La configurazione qua sopra fa partire, in automatico all'avvio del pc, la modalità Ondemand ovvero: la CPU viene portata alla frequenza più bassa supportata, lavora a quella frequenza, finchè non necessità di più "potenza" e quindi sfrutta la CPU fino a quando serve.
    Una volta finita la richiesta la frequenza ritorna alla più bassa.

    Molto utile per il risparmio energetico.


    Ultima modifica di OniXenon; 09-12-11 alle 13:15:11

    Thank You

  4. #4
    Novizio L'avatar di Suse98
    Iscritto dal
    08-Jan-2012
    Post
    1
    Profilo Mercatino
    visualizza
    ID utente
    129314

    Predefinito

    Gran bella guida jones.
    Volevo aggiungere che nelle distribuzioni dove c'è root col comando
    Codice:
    su -
    si hanno i permessi di root al 100% :
    Codice:
    luigi@linux-7mg0:~> su -
    Password: 
    linux-7mg0:~ #
    ;
    c'è una differenza da su o sudo, la differenza è che se digito su o sudo lui mi dà i permessi di root al mio utente, ma se digito su - lui mi dà i permessi di root al 100%, è come se accedo da root e apro una console.
    Ciao


    SUSE LINUX Rilascio 12.1 (Asparagus) Kernel Linux 3.1.0-1.2-desktop GNOME 3.2.1 ATI Radeon HD 3870 Driver Open GNOME 3.2.1 : Gallium 0.4 on AMD RV670
    Wii

  5. #5

  6. #6
    Divinità L'avatar di Sino
    Iscritto dal
    09-Dec-2005
    Località
    Svizzera
    Post
    15,006
    Xbox Live
    Sino384
    Profilo Mercatino
    visualizza
    ID utente
    19939

    Predefinito

    Ciao a tutti,

    sto creando i miei primi script grazie alla guida di jones (che bomba!)

    Uno dei primi script che sto creando, solo per scervellarmi con le variabili e con if/then/else, consiste nel

    fare il ping ad un determinato server (variabile 1),
    con una certa deadline (variabile 2),
    e salvarlo in un determinato file (variabile 3).

    Ovviamente l'obiettivo è che in mancanza di un determinato valore lo script esegue un valore standard (es. specificando solo il server fa il ping 5 volte e lo salva in log.txt)
    Qui entrano in gioco gli if/else/then e sembra funzionare bene

    Il problema sorge quando l'utente non intromette la prima variabile (e quindi lo script legge la seconda variabile, valore della deadline ping, come prima variabile, ecc..)

    Per questo motivo volevo sapere se è possibile assegnare alle variabili una lettera per renderlo più simile ad un normale programma.

    Ad es vorrei
    VAR1 con -s
    VAR2 con -t
    VAR3 con -w

    In questo modo l'utente può scrivere tipo

    Codice:
    sh pinger.sh -t 4 -w file.txt
    e il programma è in grado di riconoscere che il primo valore è in realtà associato alla seconda variabile, ecc..

    Non so se mi sono spiegato

    Scrivo da un pc separato perchè uso solo una versione con terminale di linux (per rendere il tutto ancora più tricky!)
    Ma più tardi posso postare lo script se aiuta a capire quello che vorrei ottenere.



  7. #7
    Legend of forum L'avatar di ale54
    Iscritto dal
    08-Sep-2009
    Località
    cislago(VA)
    Post
    8,111
    Profilo Mercatino
    visualizza
    ID utente
    65354

    Predefinito

    ragazzi mi servirebbe un aiuto.
    avete presente per partizionare i dischi rigidi? bene bisogna usare per forza fdisk? in ogni caso quando lo lancio e gli metto la directory del disco dice che non me la prende. es. /dev/sda o /dev/hda


    Firma non a Norma

  8. #8
    Signore L'avatar di DarkAvenger
    Iscritto dal
    02-Jan-2011
    Località
    Perugia
    Post
    2,058
    Xbox Live
    lollo360
    Steam
    DarkAvenger36
    3DS
    4167-4950-4146
    ID Wiiu
    DarkAvenger36
    Profilo Mercatino
    visualizza
    ID utente
    98288

    Predefinito

    Citazione Originariamente Scritto da ale54 Visualizza Messaggio
    ragazzi mi servirebbe un aiuto.
    avete presente per partizionare i dischi rigidi? bene bisogna usare per forza fdisk? in ogni caso quando lo lancio e gli metto la directory del disco dice che non me la prende. es. /dev/sda o /dev/hda
    Non puoi usare gparted?



  9. #9
    Legend of forum L'avatar di ale54
    Iscritto dal
    08-Sep-2009
    Località
    cislago(VA)
    Post
    8,111
    Profilo Mercatino
    visualizza
    ID utente
    65354

    Predefinito

    Citazione Originariamente Scritto da DarkAvenger Visualizza Messaggio
    Non puoi usare gparted?
    Provo grazie.

  10. #10
    Legend of forum L'avatar di ale54
    Iscritto dal
    08-Sep-2009
    Località
    cislago(VA)
    Post
    8,111
    Profilo Mercatino
    visualizza
    ID utente
    65354

    Predefinito

    ragazzi mi sa che c'è un pproblema di fondo. io sto utilizzando un SO di linux virtualizzato su windows. non è che bisogna fare qualcos'altro per avviare fdisk? che poi io vorrei far "finta di partizionare il disco" quindi mi sa che devo creare un file che lo veda come disco.


    Firma non a Norma

  11. #11
    Legend of forum L'avatar di ale54
    Iscritto dal
    08-Sep-2009
    Località
    cislago(VA)
    Post
    8,111
    Profilo Mercatino
    visualizza
    ID utente
    65354

    Predefinito

    ragazzi c'è un problema. con l'emulatore, almeno con qemu , non riesco a vedere le directory, ne i device.
    quindi ho installato ubuntu e va beh. pero se qualcuno mi spiega come si fa anche con l'emulatore ne sarei grato.


    Firma non a Norma

  12. #12
    Signore L'avatar di DarkAvenger
    Iscritto dal
    02-Jan-2011
    Località
    Perugia
    Post
    2,058
    Xbox Live
    lollo360
    Steam
    DarkAvenger36
    3DS
    4167-4950-4146
    ID Wiiu
    DarkAvenger36
    Profilo Mercatino
    visualizza
    ID utente
    98288

    Predefinito

    Citazione Originariamente Scritto da ale54 Visualizza Messaggio
    ragazzi c'è un problema. con l'emulatore, almeno con qemu , non riesco a vedere le directory, ne i device.
    quindi ho installato ubuntu e va beh. pero se qualcuno mi spiega come si fa anche con l'emulatore ne sarei grato.
    Spiega bene qual'è il problema che non si capisce nulla da questo post



  13. #13
    Legend of forum L'avatar di ale54
    Iscritto dal
    08-Sep-2009
    Località
    cislago(VA)
    Post
    8,111
    Profilo Mercatino
    visualizza
    ID utente
    65354

    Predefinito

    Citazione Originariamente Scritto da DarkAvenger Visualizza Messaggio
    Spiega bene qual'è il problema che non si capisce nulla da questo post
    non capisco quale siano le directory accessibili e usabili su un linux emulato.....se metto /usr/ non va. se metto /dev/... non va neanche.
    o magari è solo un problema di qemu.


    Firma non a Norma

  14. #14
    Legend of forum L'avatar di ale54
    Iscritto dal
    08-Sep-2009
    Località
    cislago(VA)
    Post
    8,111
    Profilo Mercatino
    visualizza
    ID utente
    65354

    Predefinito

    ciao. avrei una vera richiesta riguardo uno script.
    dovrei contare tutte le parole di un certo tipo, ad esempio hello e world in tutti i tipi di file .c e .h in tutta la directory home.
    ho cominciato con: find -name *.c -or *.h | wc -w
    manca tutto il resto
    thanks


    Firma non a Norma

  15. #15
    Doom Affectioned L'avatar di L'imperatore
    Iscritto dal
    12-Sep-2008
    Località
    Lecce
    Post
    714
    Steam
    The_Spartan
    Profilo Mercatino
    visualizza
    ID utente
    50879

    Predefinito

    Citazione Originariamente Scritto da ale54 Visualizza Messaggio
    ciao. avrei una vera richiesta riguardo uno script.
    dovrei contare tutte le parole di un certo tipo, ad esempio hello e world in tutti i tipi di file .c e .h in tutta la directory home.
    ho cominciato con: find -name *.c -or *.h | wc -w
    manca tutto il resto
    thanks
    Per fare una cosa del genere ci vuole sicuramente un piccolo script.

    Codice:
    number=0
    word=$1
    files=$(find /home | egrep '\.h$|\.c$
    for file in $files
    do
    number=number+$(cat $file | wc -w $word)
    done
    echo Ho trovato $number volte la parola $word
    Copia questo testo, incollalo in un file ("script.sh") e fallo partire scrivendo ./script.sh (ricordati di cambiare i permessi con chmod), e passagli come parametro la parola di cui vuoi contare l'occorrenza.

    EDIT: egrep non l'ho mai usato, quindi se non funziona non uccidermi


    Ultima modifica di L'imperatore; 13-05-16 alle 00:21:12

  16. #16
    L'avatar di Stemaa
    Iscritto dal
    18-Oct-2008
    Post
    18,409
    Profilo Mercatino
    visualizza
    ID utente
    52221

    Predefinito

    Con l'ultimo aggiornamento di Windows 10 (Anniversary Update) è possibile eseguire i comandi della shell di Linux su Windows, senza emulatori o altri software. Ecco come fare:

    - Aprire Pannello di Controllo – Programmi – Programmi e Funzionalità – Attivazione o disattivazione delle funzionalità di Windows

    - Abilitare la funzionalità Windows Subsystem For Linux

    - Riavviare il PC

    - Attivare la modalità sviluppatore tramite: Impostazioni – Aggiornamento e sicurezza – Per sviluppatori

    - È possibile avviare la shell cercando bash con Cortana e cliccare sul risultato della ricerca

    - Al primo avvio sarà richiesta conferma per l’installazione di Ubuntu su Windows, che verrà scaricato dal Windows Store ed installato in un pochi minuti








    Ultima modifica di Stemaa; 01-10-16 alle 21:02:15

  17. #17
    Legend of forum L'avatar di ale54
    Iscritto dal
    08-Sep-2009
    Località
    cislago(VA)
    Post
    8,111
    Profilo Mercatino
    visualizza
    ID utente
    65354

    Predefinito

    Qualcuno ha mai usato dumpe2fs ? Io lo devo usare per vedere i blocchi liberi presenti nel disco. Il punto è che se creo nuovi files( occupando nuovo spazio) le informazioni che mi dumpe2fs si aggiornano solo ad un riavvio del sistema. Com'è possibile ?

    Ho risolto


    Ultima modifica di ale54; 27-01-17 alle 20:25:34

  18. #18
    Legend of forum L'avatar di ale54
    Iscritto dal
    08-Sep-2009
    Località
    cislago(VA)
    Post
    8,111
    Profilo Mercatino
    visualizza
    ID utente
    65354

    Predefinito

    Ciao a tutti. Vorrei chiedere se si può creare uno script usando solo comandi nella bash e quindi senza creare prima un file di testo.

  19. #19
    Legend of forum L'avatar di ale54
    Iscritto dal
    08-Sep-2009
    Località
    cislago(VA)
    Post
    8,111
    Profilo Mercatino
    visualizza
    ID utente
    65354

    Predefinito

    !importante: come si fa a stampare (in un file) una linea intera di comandi che quindi contengono caratteri speciali?

    grazie mille.
    edit:risolto


    Ultima modifica di ale54; 15-02-17 alle 16:25:38
    Firma non a Norma

  20. #20
    Legend of forum L'avatar di ale54
    Iscritto dal
    08-Sep-2009
    Località
    cislago(VA)
    Post
    8,111
    Profilo Mercatino
    visualizza
    ID utente
    65354

    Predefinito

    volevo segnalare che "purtroppo" la data specificata in ls -l per ogni file NON è la data di creazione ma di ultima modifica.


    Firma non a Norma

  21. #21
    L'avatar di Stemaa
    Iscritto dal
    18-Oct-2008
    Post
    18,409
    Profilo Mercatino
    visualizza
    ID utente
    52221

    Predefinito

    Citazione Originariamente Scritto da ale54 Visualizza Messaggio
    volevo segnalare che "purtroppo" la data specificata in ls -l per ogni file NON è la data di creazione ma di ultima modifica.
    Hai ragione, grazie per la segnalazione.



  22. #22
    Legend of forum L'avatar di ale54
    Iscritto dal
    08-Sep-2009
    Località
    cislago(VA)
    Post
    8,111
    Profilo Mercatino
    visualizza
    ID utente
    65354

    Predefinito

    Citazione Originariamente Scritto da L'imperatore Visualizza Messaggio
    Per fare una cosa del genere ci vuole sicuramente un piccolo script.

    Codice:
    number=0
    word=$1
    files=$(find /home | egrep '\.h$|\.c$
    for file in $files
    do
    number=number+$(cat $file | wc -w $word)
    done
    echo Ho trovato $number volte la parola $word
    Copia questo testo, incollalo in un file ("script.sh") e fallo partire scrivendo ./script.sh (ricordati di cambiare i permessi con chmod), e passagli come parametro la parola di cui vuoi contare l'occorrenza.

    EDIT: egrep non l'ho mai usato, quindi se non funziona non uccidermi
    giusto per farmi il figo. ti scrivo come si faceva su una linea:
    find -name "*.c" -or -name "*.h" -type f | xargs grep -oh -E "parola|parola2" | sort | uniq -c


    Firma non a Norma

Tag per Questa Discussione

Segnalibri

Segnalibri

Permessi di Scrittura

  • Tu non puoi inviare nuove discussioni
  • Tu non puoi inviare risposte
  • Tu non puoi inviare allegati
  • Tu non puoi modificare i tuoi messaggi
  •