http://sl-lab.it/dokuwiki/doku.php?id=sistop:lab#slide_28_marzo_2007

--------------------------------------------------------------------------------
- Specificare l'occupazione totale di un utente in un sistema (somma delle dimensioni dei suoi file...)

#!/bin/sh
if [ $# -ne 1 ]; then
  echo "syntax: user_size <user_name>"
  exit 1
fi
ID="$(grep "^$1" /etc/passwd | cut -f 3 -d :)"
if [ "$ID" = "" ]; then
  echo "User \"${1}\" not found"
  exit 1
fi
echo "calculating..."
SUM=0
for ITEM in $(find / -user "$ID" -type f | xargs du | cut -f 1); do
  SUM=$(expr ${SUM} + ${ITEM})
done
echo "User \"${1}\" takes ${SUM} KB into the system"
exit 0

--------------------------------------------------------------------------------------------------
- Per ogni utente del sistema specificare qual è il suo file di dimensioni maggiori


#!/bin/sh
# Per ogni utente trovare il suo file di dimensione maggiore
for UID in $(cut /etc/passwd -d : -f 3 | sort -n | uniq); do
  FILE=$(find / -type f -user $UID | xargs du | sort -nr | head -1)
  if [ "$FILE" != "" ]; then
    DIM=$(echo "$FILE" | cut -f 1)
    NOME=$(echo "$FILE" | cut -f 2)
    echo "UID: $UID => File: $NOME ($DIM KB)"
  else
    echo "UID: $UID => Nessun file trovato"
  fi
done

--------------------------------------------------------------------------------------------------

3) Stampare "MUOIO!" ogni volta che un processo termina
/** sono Silvio
io ho modificato solo sys_exit.c in /usr/src/lib/syslib aggiungendo una printf("MUOIO\n");
giusto prima del return e funziona....
BUNGA BUNGA**/

Personalmente ho solo aggiunto questa riga:

kprintf ("MUOIO!\n");

Nei file:

/usr/src/kernel/system/do_exit.c
/usr/src/kernel/system/do_kill.c

nelle funzioni con il rispettivo nome [do_exit() e do_kill()]

C'era una postilla ovvero di far stampare ance il PID del processo.
Era un problema perchè all'interno del kernel il proc_nr non è il PID
 della tabella dei processi di PM ma il numero del processo della tabella del Kernel che
 non sono lo stesso numero quindi pescare quello giusto era comlicato e l'ora si faceva tarda...
quindi il prof mi ha detto che se non lo facevo non era importante e non mi ha penalizzato.
(ma questo rimanga tra me e voi...)

In /usr/src/tools/
make clean (per sicurezza ripartiamo da zero)
make image
make hdboot (credo sostituisca anche make image, provate...)

Ci sono poi due casi particolari

Modifica delle librerie: prima di make hdboot inserite anche
make libraries (mooolto lento)

Esercizio Tasto F8 (vedi thread apposito): sempre prima di make hdboot scrivete
make services

Il tuo problema sai che forse è nel reboot?!
Prova a fare un bel shutdown e al riavvio quando sei al boot loader non fare nessuna scelta, lascia che il sistema parta dopo pochi secondi [A questo proposito me ne sono successe di tutte come a te...]

--------------------------------------------------------------------------------------------------
- trovare il file più "grosso" sul sistema

find / -type f | xargs du | sort -nr | head -1
find / -type f | xargs du | sort -n | tail -1

--------------------------------------------------------------------------------------------------

Modifica al kernel richiesta: impedire che vengano creati file il cui nome cominci con la lettera m.

Intervento individuato: nei sorgenti del pm, nel file open.c c'è una funzione do_creat()

Uno dei parametri sembra essere il nome.
Basterebbe quindi inserire un if alla inizio della funzione che controlla il nome e se quest'ultimo comincia con m,
terminare con errore.
In realtà il Prof. Monga ha detto che quello non è proprio il nome del file ma una stringa che lo rappresenta (una specie di codifica interna di Minix).
Ma la risposta andava bene ugualmente.

Ricordo che la tua domanda è stata fatta a lezione...
Il nome di un file lo si trovava passando per:
/usr/src/servers/fs/open.c -> do_creat() -> common_open() -> new_node()
In questa funzione nella variabile string c'è il nome del file e basta aggiungere dopo la riga:
*ldirp = parse_path(path, string, opaque ? LAST_DIR : LAST_DIR_EATSYM);
Il seguente pezzo di codice:


code:--------------------------------------------------------------------------------
if (*string == 'M' || *string == 'm')
{
  printf ("Niente nomi che iniziano con emme!!!\n");
  return (NIL_INODE);
}

--------------------------------------------------------------------------------------------------

- Archiviare i files più grandi di 5k e più piccoli di 100k?

find / -type f -size +10 -a -size -200 | xargs tar cvf archivio.tar

--------------------------------------------------------------------------------------------------

Copiare i file da una directory all'altra senza cambiare i permessi:
cp /directory/albero1/* /directory/albero2

--------------------------------------------------------------------------------------------------

Spostare tutti i files che iniziano per m da una directory (e sottodirectory) ad un'altra
mv /directory/albero1/m* /directory/albero2

--------------------------------------------------------------------------------------------------

Trovare tutti i files eseguibili > 5k e evidenziando i 5 più grandi
find / -type f -size +10 | xargs ls -lF | grep "\*$" | tr -s ' ' ' ' | cut -d ' ' -f 5,9 | sort -n | tail -5

--------------------------------------------------------------------------------------------------

Archiviare i files modificati nell'ultima settimana
find / -type f -mtime -7 | xargs tar cvf archivio.tar

--------------------------------------------------------------------------------------------------

Trovare il processo che occcupa più memoria ram
ps -axl | sort +7 -nr | head -1 | tr -s ' ' ' ' | cut -d ' ' -f 8,12

--------------------------------------------------------------------------------------------------

Trovare i tre files più grossi per ogni utente

#!/bin/sh
for UID in $(cut /etc/passwd -d : -f 3 | sort -n | uniq); do
  echo "Utente $UID:"
  find / -type f -user $UID | xargs du | sort -nr | head -3
done

#/usr/bin/sh
cut -f 1 -d : /etc/passwd |while read user
do
   file=$(find / -type f -user $user |xargs du |sort -nr |head -1|cut -f 2)
   dimensione=$(find / -type f -user $user |xargs du |sort -nr |head -1|cut -f 1)
   if [ "$file" != "" ];then
      echo "il file " $file " di dimensione "$dimensione " e'il piu' grosso per l'utente "$user
   else
      echo "l' utente " $user "non ha file"
   fi
done

--------------------------------------------------------------------------------------------------

Archiviare tutti i files che contengono la parola "login"

find / -type f | xargs grep -l "login" | xargs tar -cvf archivio.tar

--------------------------------------------------------------------------------------------------

- Trovare tutti i file che includono la parola "login" ed archiviarli su di un file .txt

find / -type f | xargs grep -l "login" >> list.txt

--------------------------------------------------------------------------------------------------

------------------------------------|
  owner (u) | group (g) | others (o)|
+-----------+-----------+-----------+
| r   w   x | r   w   x | r   w   x |
| 4   2   1 | 4   2   1 | 4   2   1 |

find / -perm 666
find / -perm a+rw (equivalente, a = all)
trova tutti i file che sono leggibili e modificabili da ogni utente

find / -perm 755
find / -perm u+rwx,g+rx,o+rx (equivalente)
trova tutti i file che sono leggibili, modificabili ed eseguibili da parte del proprietario, e che sono leggibili ed eseguibili dal gruppo e dagli altri

find / -perm -XXX
aggiungendo un meno prima dell'espressione ottale modifico il comportamento del find, indicando che voglio cercare tutti quei file il cui bit interessato è attivato, es:

find / -perm -111
trova tutti i file che hanno il flag "eseguibile" settato per ogni utente

find / -perm -661
trova tutti i file che hanno i flag "leggibile" e "modificabile" settati per il proprietario e il gruppo, e il flag "eseguibile" per gli altri
(gli altri permessi non specificati possono essere settati o no)

--------------------------------------------------------------------------------------------------

Cercare tutti i file con SUID attivato
find / -type f -perm -004000 (testato)

--------------------------------------------------------------------------------------------------

Kernel: Stampare il messaggio quando un processo termina
Sufficiente che la printf sia all'interno della procedura pm_exit()
ovviamente nei sorgenti del PM)
che viene chiamata in qualsiasi caso: syscall exit() oppure SIGKILL o SIGTERM

NOTA: ho notato con un amico che qemu tende a crashare se il messaggio della exit non termina con un newline,
quindi vi conviene che il messaggio sia sempre qualcosa del tipo

printf("\nMESSAGGIO\n");

che per inciso produce anche un output più leggibile (per quanto possa interessare leggere "MESSAGGIO" mille volte)

--------------------------------------------------------------------------------------------------

Kernel: Stampare un messaggio quando un processo viene killato

Modificare i seguenti file:

usr/src/servers/pm/forkexit.c

oppure se non si conosce il file:

cd /usr/src/servers/pm
grep pm_exit *

1)io vado in /usr/src/servers/pm/
2)forkexit.c
3) mi porto alla fine della funzione pm_exit()
4) metto il printf
5) vado in /usr/src/tools/
6) eseguo i comandi make clean, make image, make hdboot
7) shutdown

--------------------------------------------------------------------------------------------------

- Archiviare i files più piccoli di 100KB ma più grandi di 5KB:

find / -type f -size +10 -a -size -200 | xargs ar rc archive.a

Opzioni:
r => sostituisci o aggiungi (nel caso un file non sia già presente)
c => crea l'archivio (sopprime il noioso messaggio di notifica, non fa nulla se l'archivio esiste già)
t => visualizza il contenuto (ar t archive.a)

--------------------------------------------------------------------------------------------------

- Trovare tutti i processi per ogni utente e fornirne l'occupazione in memoria???

#!/bin/sh
SUM=0
for UID in $(cat /etc/passwd | cut -d : -f 3); do
  for PROCSIZE in $(ps alx | tr -s ' ' ' ' | cut -d ' ' -f 4,8 | grep "^$UID" | cut -d ' ' -f 2); do
    SUM=$(expr $SUM + $PROCSIZE)
  done
  echo "Utente $UID : $SUM KB di processi in memoria"
  SUM=0
done

ps alx => stampa tutti i processi in formato lungo
tr -s ' ' ' ' => comprimo tutti gli spazi contigui in un solo spazio
 (fondamentale, altrimenti non funziona il cut)
cut -d ' ' -f 4,8 => estrai la 4^ e l'8^ colonna (che dopo tr sono separate da un solo spazio)
che sono l'UID del proprietario e la dimensione
 (le ho trovate osservando il comportamento dei comandi precedenti, non c'è un manuale su come farlo!)
grep "^$UID" => cerca l'UID interessato a partire dall'inizio della riga
(potrebbe confondersi con la dimensione di un processo)
Ricordo che le colonne ora avranno il formato "0 689" ovvero UID + spazio + SIZE
cut -d ' ' -f 2=> Una volta ristretto il campo dell'utente estraggo la sola colonna dei SIZE per poi sommarli tutti

--------------------------------------------------------------------------------------------------

- Trovare il processo con pid dispari che occupa più spazio in memoria?

#!/bin/sh
MAXSIZE=0
MAXPID=0
for PROC in $(ps alx | tr -s ' ' : | cut -d : -f 5,8); do
  PID=$(echo $PROC | cut -d : -f 1)
  SIZE=$(echo $PROC | cut -d : -f 2)
  if [ $PID % 2 -eq 1 -a $SIZE -gt $MAXSIZE ]; then
    MAXPID=$PID
    MAXSIZE=$SIZE
  fi
done
echo "Processo con PID dispari più esoso: $MAXPID con $MAXSIZE KB"

Spiegazione:
Dalla lista di tutti i processi comprimo tutti gli spazi contigui nel carattere ':'
che userò come separatore di colonne (lo spazio faceva danno); estraggo le colonne 5 e 8 che sono PID e SIZE
anche qui trovate osservando il comportamento dei comandi)
Le righe ora sono della forma PID:SIZE (12:552)

Estraggo i PID come prima colonna dalla variabile PROC
Estraggo i SIZE come seconda colonna dalla variabile PROC
Se il PID % 2 è uguale a 1 (dispari) e SIZE è maggiore di MAXSIZE
Aggiorno il PID e il SIZE massimi

--------------------------------------------------------------------------------------------------

-Calcolare la somma della dimensione di file eseguibili che hanno all'interno la parola copyright non sensitive

#! /bin/sh

SUM=0
for SIZEFILE in $(find / -type f | xargs grep -il "copyright" | xargs ls -lF | grep "\*$" | tr -s " " : | cut -d : -f 5); do
SUM=$(expr $SUM + $SIZEFILE)
done
echo "la somma è: $SUM"

le opzioni -il del grep mi consentono di:
-i per il case insensitive
-l per elencare il nome del file contente la parola copyright
(altrimenti mi avrebbe stampato per ogni file la riga contenente la parola copyright)

--------------------------------------------------------------------------------------------------

-Trova il processo che occupa per ogni utente più memoria

#! /bin/sh

MAXSIZE=0

for USER in $(cat /etc/passwd | cut -d : -f 3 | uniq); do

for PROC in $(ps -axl | tr -s " " : | cut -d : -f 4,8 | grep -v "SZ"); do
UID=$(echo $PROC | cut -d : -f 1)
SIZE=$(echo $PROC | cut -d : -f 2)

if [ $UID -eq $USER -a $SIZE -gt $MAXSIZE ]; then
MAXPROC=$PROC
MAXSIZE=$SIZE
fi

done
echo "il processo dell'utente $USER + grande è: $MAXPROC"
MAXPROC="nessun processo"
MAXSIZE=0
done

--------------------------------------------------------------------------------------------------

Copiare una directory mantenendo la struttura delle sottodirectory e i permessi,
evitando però di copiare il contenuto delle cartelle(i file che all'interno che non sono directory)

#/bin/sh
cpdir -p /directoryA /directoryB
for file in $(find /directoryB -type f); do
rm $file
done

oppure

#! /bin/sh
cpdir -pr /bin /bin2
rm $(find /bin2 -type f)

--------------------------------------------------------------------------------------------------

- Quali e quante estensioni ci sono nel sistema?
(per estensioni si intende qualsiasi cosa ci sia dopo il carattere “.”, es: archivio.gz)

La soluzione è questa:

find / | rev | cut -f 1 -d '.' | grep -v / | rev | sort | uniq -c | sort -n

Spiegazione:

find / trova tutto (files e directories) a partire dalla root dir
rev inverte ogni riga dell'output
cut -f 1 -d '.' estrae il primo campo di ogni riga usando il . come separatore
grep -v / eliminazione delle sole directories
rev inverte di nuovo ogni riga dell'output
sort ordina l'output
uniq -c elimina righe duplicate contandole, ora l'output è del tipo 123 gz
sort -n (non necessario) ordina i risultati numericamente

Nota:
Si può evitare il grep -v / usando cut -f 1 -d '.' -s.

Okkio che così trovi anche tutte le cartelle e file nascosti ( del tipo .cartella o .file).
Ho fatto uno script simile al tuo, escludendo cartelle e file nascosti:

find / -type f -name *.* | tr -s '/' ' ' | rev | cut -d ' ' -f 1 | rev | grep -v "^\." | rev | cut -d '.' -f 1 -s | rev | sort | uniq -c

find / -type f -name *.* cerco tutti i file che contengono un punto nel nome del file
 (i file trovati sono completi di path ad es. /root/prova/file)
tr -s '/' ' ' spazi al posto di /
rev stampo il nome del file al contrario
cut -d ' ' -f 1 estraggo il primo campo (è il nome del file al contrario). In questo
 modo ho il nome del file senza path
rev ristampo il nome del file "dritto"
grep -v "^\." escludo tutti i file che INIZIANO con un punto (sono quelli nascosti)
rev non lo ripeto più
cut -d '.' -f 1 -s estraggo il primo campo. Così ho l'estensione del file
rev
sort ordino le estensioni in ordine alfabetico, così posso eliminare le ripetizioni con uniq
uniq -c per ogni estensione ho il numero di ripetizioni

--------------------------------------------------------------------------------------------------

- Qualcuno sa cosa significa fare la statistica dei file < 10k 100k 1000k ??????????

#! /bin/sh
TOT=$(find / -type f | wc -l | tr -s ' ' : | cut -f 2 -d :)
DIECIK=$(find / -type f -size -20 | wc -l | tr -s ' ' : | cut -f 2 -d :)
CENTOK=$(find / -type f -size -200 | wc -l | tr -s ' ' : | cut -f 2 -d :)
MILLEK=$(find / -type f -size -2000 | wc -l | tr -s ' ' : | cut -f 2 -d :)
CENTO=100
STAT=$(expr $DIECIK \* $CENTO)
STAT1=$(expr $STAT / $TOT)
STAT=$(expr $CENTOK \* $CENTO)
STAT2=$(expr $STAT / $TOT)
STAT=$(expr $MILLEK \* $CENTO)
STAT3=$(expr $STAT / $TOT)
echo "I file inferiori a 10k sono il ${STAT1}%"
echo "I file inferiori a 100k sono il ${STAT2}%"
echo "I file inferiori a 1000k sono il ${STAT3}%"

--------------------------------------------------------------------------------------------------

Per trovare ogni singolo file di testo che contiene la parola "copyright" basta fare:

find / -type f | xargs grep -l "copyright" | grep "\.txt$"

--------------------------------------------------------------------------------------------------

Somma delle dimensione di tutti i file di solo testo (non eseguibili) che contengono
 al loro interno la parola copyright

#!/bin/sh

SOMMA=0
for VAR in $(find / -type f | xargs grep -l "copyright" | grep "\.txt$" | xargs du | cut -f 1); do
SOMMA=$(expr $VAR + $SOMMA)
done
echo $SOMMA

--------------------------------------------------------------------------------------------------

per ecercare un eseguibile (però è stato detto più volte) fai così

find / -type f | xargs ls -lF | tr -s ' ' ' ' | cut -d ' ' -f 5,9 | grep "\*$"


dove ls -F mette in fondo al nome del file alcuni simboli... mette un * se è eseguibile
qunidi con tr ' ' ' ' comprimo tutti gli spazi
con cut, con delimitatore lo spazio (-d ' ') selezioni i csmapi 5 e 9 (PID e SIZE)
e poi estraggo le linee che hanno * alla fine (devo mette \ davanti a * per farlo interpretare bene...
e il $ significa "cerca in fondo alla riga"

--------------------------------------------------------------------------------------------------
- Trovare tutte le dir che abbiano meno di 5 sottodirs:

#!/bin/sh
echo "Script per stampare le dir che hanno meno di 5 sottodir";

for dir in $(find / -type d);
  do
         ls -F -1 $dir | grep '/' | wc -w > a.tmp
         if [ $(cat a.tmp) -lt 6 ];
             then
                 echo $dir;
                 cat a.tmp;
             else
                 echo '';
          fi;
         rm a.tmp;
done;

--------------------------------------------------------------------------------------------------

- Trovare il file più grande di tipo testo che abbia un numero di righe pari

sizef=0
for file in $(find / -type f -name '*.txt'); do
  nrrighe=$(wc -l $file | tr -d ' ' | cut -f 1 -d /)
  size=$(du $file | cut -f 1)
  if $(expr $(expr $nrrighe % 2) -eq 0 ); then
      if $(expr $size -gt $sizef); then
          sizef=$size
          filef=$file
      fi
  fi
done
echo "Il file di testo più grande con numero di righe pari è:
echo $filef

--------------------------------------------------------------------------------------------------

Kernel:
cambiare la politica di allocazione della memoria in best fit

Indovinato: si deve cambiare il file /usr/src/servers/pm/alloc.c più esattamente la funzione alloc_mem
dove viene usato la politica firts fit.

--------------------------------------------------------------------------------------------------

- Calcolare per ogni utente il numero di file modificati nell'ultimo mese

for user in $(cut /etc/passwd -d : -f 3 | sort -n | uniq); do
item=$(find / -type f -user $user -mtime -31 | wc -l | tr -d ' ' | cut -f 1)
echo "L'utente $user ha modificato $item file nell'ultimo mese"
done

--------------------------------------------------------------------------------------------------

- Per ogni utente del sistema stampare i gruppi a cui appartiene, senza utilizzare i comandi id e groups.

for x in $(cat /etc/passwd |cut -d ':' -f 1); do
    echo "$x: ""$(for y in $(cat /etc/group|grep -s $(cat /etc/passwd|grep -s "$x"|cut -d ':' -f 3)|cut -d ':' -f 1); do
        echo -n "$y ";done)";
done

--------------------------------------------------------------------------------------------------


Trovare tutti gli script del sistema, minori di 1 k, copiarli su /tmp/script/
Aggiungerli tutti i file su un file.tar !

#!/bin/sh
mkdir script;
FILE=$(find / type -f -size +2 | xargs grep -l "#!/bin/sh" | cp * /tmp/script);

----------------------------------------------------------------

- Trovare tutti i file modificati di venerdì

#!/bin/sh

find / -type f |while read line
do
giorno=$(stat -Mtime $line |awk '{$1 print $1}')
if [ "$giorno" = "Fri" ]; then
    ls -l $line
fi
done

----------------------------------------------------------------

- Memorizzare in un archivio .ar tutti i file creati negli ultimi 2 giorni di dimensione minore di 5k.

find / -type f -size -10  -ctime -2 |xargs ar rc  filearc.ar

----------------------------------------------------------------

- Calcolare per ogni utente il numero di file modificati nell'ultimo mese

cut  -f 1 -d : /etc/passwd |while read line
do
   conta=$(find / -type f -mtime -30  -user $line|xargs ls -l|wc -l)
   echo "lo user " $line "ha modificato " $conta "file negli ultimi 30 giorni "
done

----------------------------------------------------------------

- Calcolare la dimensione totale di tutti i file .c

#/usr/bin/sh

find / -type f -name *.c |
while read line
do
   conta=$(stat -size $line)
   tot=$(expr $conta + $tot)
   echo $tot > totale
done

----------------------------------------------------------------

- Memorizzare in un archivio .ar tutti i file creati negli ultimi 2 giorni di dimensione minore di 5k.

find / -type f -size -10  -ctime -2 |xargs ar rc  filearc.ar

----------------------------------------------------------------

Kernel: Ogni volta che viene cancellato un file che inizi per 'x' stampare un messaggio

inserire in /usr/src/servers/fs/link.c 	NELLA PROCEDURA UNLINK_FILE

if (file_name[0] == 'x') printf ("File rimosso");

----------------------------------------------------------------

- Per ogni utente trovare i 3 file più vecchi del sistema..

#!\bin\sh
USERS=$(cut -d : -f 1 | sort -f | uniq);
for us in $USERS; do
	FILE=$(find / -type f -user $us | xargs ls -ltsT | tail -3);
	echo "FILE UTENTE: $us;
	echo $FILE;
done

----------------------------------------------------------------

- Calcolare il numero di righe totali che ha scritto sul filesystem un certo utente nell'ultimo mese

find / -mtime -30 |while read line ;
do;
   awk '{ if ($(ls -l $linea)) $3 == 'root' print }';
done;

find / -mtime -30 |while read line ;
do;
ls -l $line | awk '{ print $3": "$9}' | grep ^root
done;

----------------------------------------------------------------

calcolare la somma delle dimensioni dei file *.s.
#/usr/bin/sh


find / -name *.s | while read line;
do;
                        sum=$(ls -l $line| awk '{print $5}');
                ####     pippo= $(ls -l $line| awk '{sum = sum + $5} END {print sum}'
                                        ###echo $sum;
tot=$(expr $sum + $tot);
        echo $tot > tmp;
                                                done;

----------------------------------------------------------------

- Trovare tutti i file che hanno il numero di blocchi pari

#/usr/bin/sh
###sum=0;
find / |while read line;
do;
ls -l $line| awk '{if ($5%2==0) print }';
done;

----------------------------------------------------------------

kernel: scrivere un messaggio sullo schermo quando viene avviato un programma setuid root


for file in $(find / -type f -name *.s); do
sum=$(stat -size $file)
tot=$(expr $sum + $tot)
echo $tot
done

----------------------------------------------------------------

- Trovare i file più vecchi di un mese

find / -mtime -30 |while read line ;
 do;
	 awk '{ if ($(ls -l $linea)) $3 == 'root' print }';
 done;

----------------------------------------------------------------

- Mostrare, per ogni utente, il numero di file presenti sul sistema.

find / -f |xargs wc -l

-Calcolare il numero di righe totali che ha scritto sul filesystem un certo utente nell'ultimo mese

----------------------------------------------------------------

- Stampare i file che finiscono per c con un numero di caratteri dispari e visualizzare la loro data

#/usr/bin/sh

find / -name *.c |while read line ;
do;
        wc -c $line|awk '{if ($1%2 != 0 ) ls $2 print $2}'|xargs ls -l;
done;

----------------------------------------------------------------

Trovare tutti i file col numero dispari di righe (quindi sono i file di testo)

find / -f|while read line ; do wc -l $line| awk '{if (($1%2) !=0) print $line}' ;done;

----------------------------------------------------------------

Trovare tutti i file modificati di venerdi' (sia un venerdi' particolare che di venerdi' in generale)

#/usr/bin/ksh
find / -type f|while read line;
 do ; stat $line |awk '{if ($1 =="Mtime:" && $2 =="Fri") print "'${line}'" }' ;
 done;

----------------------------------------------------------------

Trovare tutti i link simbolici presenti nel sistema.
find / | while read line;do if test -h $line; then echo $line ok; fi; done

----------------------------------------------------------------

Trovare tutti i file col numero dispari di righe (quindi sono i file di testo)
find / -f|while read line ; do wc -l $line| awk '{if (($1%2) !=0) print $line}' ;done;

----------------------------------------------------------------

Trovare gli utenti ed i gruppi distinti proprietari dei file nelle directory /bin, /sbin, /usr/bin e /usr/sbin.
Riportare i comandi utilizzati.
ls -l /bin /sbin /usr/bin /usr/sbin |awk '{print $3, $4}'|sort |uniq

----------------------------------------------------------------