Sistemi Operativi - User contributions [en]

SYS CALL viste a lezione.

2013-11-27T18:56:41Z

Amonaldini: /* LSEEK/READ */

==Controllo processi==
===FORK===
Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre.

esempio1:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>

void main (void){
if(fork()){
printf("uno %d %d \n", getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre
sleep(2);} //se togliessimo lo sleep;il processo figlio stamperebbe come getppid() 1,perché essendo il padre terminato e lui rimasto orfano,il nuovo padre diventa init
else
printf("due %d %d \n",getpid(), getppid() );
}
</syntaxhighlight>

esempio2(una piccola osservazione sull'eredità del buffer):
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>

void main (void){
printf("cucù! : "); //notare la differenza se nella sringa metto \n
if(fork())
printf("uno %d %d \n", getpid(), getppid() );
else
printf("due %d %d \n",getpid(), getppid() );
}

</syntaxhighlight>

esempio3(fork e malloc): 
'''(sottolineerei che lo spazio di indirizzamento è di fatto separato: i due processi hanno una analoga visione dell'indirizzamento logico, che però è specifico di ogni processo e i dati sono memorizzati fisicamente in aree di memoria diverse. am_20131110)'''
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

void main (void){
int *p;
if( fork() ){
p = malloc(sizeof(int));
*p = 45;
printf("%d %p pid : %d , ppid : %d \n",*p,p,getpid(),getppid());
sleep(2);
}
else {
p = malloc(sizeof(int));
printf("%d %p pid : %d , ppid : %d \n",*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio
sleep(1); //perché condividono lo stesso spazio di indirizzamento
}
}
</syntaxhighlight>

===_EXIT===
Termina il proceso chiamante.

esempio1:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main (int argc,char *argv[]){
_exit(0); //Sys call che termina il processo chiamante
}
</syntaxhighlight>

esempio2(atexit):
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

void at1(void){
printf("at1 \n");
}

void at2(void){
printf("at2 \n");
}

int main (int argc,char *argv[]){
printf("brutal kill \n");
atexit(at1); //funzione di libreria che termina il processo passato come argomento
atexit(at2);
}

//le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione
</syntaxhighlight>

===WAIT===
Aspetta che un processo cambi di stato.

esempio1:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main (int argc, char *argv[]){
pid_t pid;
if( pid = fork() ){
int status;
printf(" padre : %d figlio : %d \n",getpid(),pid);
sleep(10);
waitpid(pid,&status,0);
printf(" exit status %d \n",WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio
} //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.
else {
printf(" figlio : %d padre : %d \n",getpid(),getppid());
sleep(1);
exit(1);
}
}
</syntaxhighlight>

esempio2:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main (int argc, char *argv[]){
pid_t pid;
if( pid = fork() ){
int status;
printf(" padre : %d figlio : %d \n",getpid(),pid);
sleep(5);
waitpid(pid,&status,0);
if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main
printf(" exit status %d \n", WEXITSTATUS(status));
else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale
printf("signal : %d \n", WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio
}
else {
int *p;
printf(" figlio : %d padre : %d \n",getpid(),getppid());
sleep(1);
p = (int *)42;
*p = 43;
exit(2);
}
}
</syntaxhighlight>

===EXEC===
Esegue un programma.
La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.

esempio1:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main (int argc, char *argv[]){
pid_t pid;
if( pid = fork() ){
int status;
printf(" padre : %d figlio : %d \n",getpid(),pid);
sleep(5);
waitpid(pid,&status,0);
if (WIFEXITED(status))
printf(" exit status %d \n", WEXITSTATUS(status));
else if( WIFSIGNALED(status) )
printf("signal : %d \n", WTERMSIG(status) );
}
else {
char *args[] = {"ls","-l",(char *)0};
execvp("ls",args); //funzione di libreria che prende in input il path(p) e un vettore(v).
}
}
</syntaxhighlight>

esempio2:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main (int argc, char *argv[]){
pid_t pid;
if( pid = fork() ){
int status;
printf(" padre : %d figlio : %d %s \n",getpid(),pid,argv[1]);
sleep(5);
waitpid(pid,&status,0);
if (WIFEXITED(status))
printf(" exit status %d \n", WEXITSTATUS(status));
else if( WIFSIGNALED(status) )
printf("signal : %d \n", WTERMSIG(status) );
}
else {
execvp(argv[2],argv+2);
}
}
</syntaxhighlight>

==Gestione File==
* int open(const char *path, int oflag, ...); 
* int creat(const char *path, mode_t mode);
* int close(int filedes);
* off_t lseek(int filedes, off_t offset, int whence);
* ssize_t read(int filedes, void *buf, size_t nbyte);
* ssize_t write(int filedes, const void *buf, size_t nbyte);

Qualche esempio? Iniziamo con i file "con il buco" visti a lezione?

===OPEN/WRITE/CLOSE===

*Open: apre e possibilmente crea un file o un device.
*Write: scrive su il file descriptor.
*Close: chiude il file descriptor.

Esempio1:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main ( int argc , char *argv[] ){
int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666);
write( fd , argv[2] , strlen( argv[2] ) );
close( fd);
}

</syntaxhighlight>

===LSEEK/READ===

*Lseek: sposta l'offset del file descriptor.
*Read: legge da un file descriptor.

Esempio1(sparse file o file ciambella):
<syntaxhighlight lang="C">
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main ( int argc , char *argv[] ){
int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666);
write( fd , argv[2] , strlen( argv[2] ) );
lseek( fd, 1000000 , SEEK_SET );
write( fd , argv[2] , strlen( argv[2] ) );
close( fd);
}
</syntaxhighlight>

Esempio2(copia di un file):
<syntaxhighlight lang="C">
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

#define BUFFSIZE 1024

char buff[BUFFSIZE];

int main ( int argc , char *argv[] ){
int fin = open( argv[1] , O_RDONLY );
int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666);
ssize_t n;
while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){
write( fout , buff , n );
}
close( fin);
close( fout);
}
</syntaxhighlight>

Esempio3(copia di uno sparse file):
<syntaxhighlight lang="C">
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

#define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B

char buff[BUFFSIZE];

int isEmpty( char *s , int l ){
int i;
for( i = 0 ; i < l ; i++ )
if( s[i] != 0 ) return (0);
return(1);

# if 0
for ( i = 0 ; ( i < l ) && ( s[i] != 0 ) ; i++ )
;
return ( i == l ); //codice più compatto

for( i = 0 ; i < l ; i++ )
if( s[i] != 0 ) goto nonempty;
return1;
nonempty:
return0; //in stile kernel
#endif
}

int main ( int argc , char *argv[] ){
int fin = open( argv[1] , O_RDONLY );
int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666);
ssize_t n;
while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){
if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparse file.
lseek( fout , n , SEEK_CUR );
else
write( fout , buff , n );
}
close( fin);
close( fout);
}

</syntaxhighlight>

Esempio4(Buffer ed efficienza):
<syntaxhighlight lang="C">
/*eseguire lo script di cui sotto in modo da osservare come il buffer modifichi l'efficienza della copia per blocchi di byte

dd if=/dev/urandom of=casual bs=1024 count=102400
for size in 128 256 512 1024 2048 4096
do
time ./eseguibile casual ricasual $size
done
*/

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int isEmpty( char *s , int l ){
int i;
for( i = 0 ; i < l ; i++ )
if( s[i] != 0 ) return (0);
return(1);
}

int main ( int argc , char *argv[] ){
int fin = open( argv[1] , O_RDONLY );
int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666);
int buffsize = atoi( argv[3] );
char buff[buffsize];
ssize_t n;
while( ( n = read( fin , buff , buffsize ) ) != 0 ){
if (isEmpty( buff , n ) )
lseek( fout , n , SEEK_CUR );
else
write( fout , buff , n );
}
close( fin);
close( fout);
}
</syntaxhighlight>

===TRUNCATE===

*Truncate: tronca il file a una specifica lunghezza.

Esempio(viene usata per creare File Buco Nero):
<syntaxhighlight lang="C">
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main( int argc , char *argv[] ) {
int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );
ftruncate( fd , atoi( argv[2] ) );
close( fd );
}
</syntaxhighlight>

===DUP===

*Dup: duplica il file descriptor.

Esempio:
<syntaxhighlight lang="C">
#include<stdio.h>
#include<fcntl.h>
#include <unistd.h>

int main( int argc , char *argv[]){
int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );
close(1);
dup(fd); //dup2(fd,1) produce lo stesso effetto
printf("Hello World \n");
}
</syntaxhighlight>

===FUNZIONI SULLE DIRECTORY===

Esempio1:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>

int mystrcmp( const void *a , const void *b ){
char **pa = (char **)a;
char **pb = (char **)b;
return strcmp( *pa , *pb );
}

int main ( int argc , char *argv[] ){
DIR *d;
struct dirent *de;
char **names;
int i , count = 0;
d = opendir( argv[1] );
while( ( de = readdir(d) ) != NULL )
count++;
rewinddir(d);
names = (char **)calloc( count , sizeof(char *) );
count=0;
while( ( de = readdir(d) ) != NULL )
names[count++] = strdup( de->d_name );
closedir(d);
qsort( names , count , sizeof(char *) , mystrcmp );
for( i = 0 ; i < count ; i++ )
printf(" %s ", names[i] );
printf("\n");
}
</syntaxhighlight>

Esempio2:
<syntaxhighlight lang="C">
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<dirent.h>

int main( int argc , char *argv[] ){
int count;
int i;
struct dirent **de;
count = scandir( argv[1] , &de , NULL , alphasort );
for ( i = 0 ; i < count ; i++ ){
printf("%s ",de[i]->d_name);
free(de[i]);
}
printf("\n");
free(de);
}
</syntaxhighlight>

Correggetemi se ho scritto delle sciocchezze.
-Pirata-

ProvaPratica 2013.05.29

2013-11-27T18:51:01Z

Amonaldini:

[Python 3]

<syntaxhighlight lang="Python">
'''
Prova Pratica di Laboratorio di Sistemi Operativi
29 maggio 2013
Esercizio 3

URL: http://www.cs.unibo.it/~renzo/so/pratiche/2013.05.29.pdf

@author: Tommaso Ognibene
'''

import os, sys

def Main(argv):
# Check number of arguments
if len(argv) != 2:
print("The function requires one argument to be passed in.")
return

# Check parameters
topDir = str(sys.argv[1])
if not os.path.isdir(topDir):
print("The parameter should be an existing directory.")
return

# Build a dictionary with key-value pair {file extension - total size}
extensionSize = { }
GetSize(topDir, extensionSize)

# Print results
PrintResults(extensionSize)

def GetSize(topDir, extensionSize):
for dirPath, dirNames, files in os.walk(topDir):
for file in files:
# 'example.mp3' -> ['example', 'mp3']
# 'example.tar.gz' -> ['example', 'tar', 'gz']
parts = file.split('.')
# ['example', 'mp3'] -> ['mp3']
# ['example', 'tar', 'gz'] -> ['tar', 'gz']
parts = parts[1:]
# ['mp3'] -> '.mp3'
# ['tar', 'gz'] -> '.tar.gz'
fileExtension = ".{0}".format(".".join(str(part) for part in parts))

# Compute the size in Bytes and update the dictionary
filePath = os.path.join(dirPath, file)
fileSize = os.path.getsize(filePath)
extensionSize[fileExtension] = extensionSize.get(fileExtension, 0) + fileSize

# Print results
def PrintResults(extensionSize):
for key, value in sorted(extensionSize.items()):
print('{0}: {1} Bytes.'.format(key, value))

if __name__ == "__main__":
sys.exit(Main(sys.argv))
</syntaxhighlight>

----

mia versione
<syntaxhighlight lang="Python">
import os, sys, copy

def dotsubstr(a):#restituisce la sottostringa .suffisso
#fcd = os.listdir('{0}'.format(arg1))
i=0
try:
while a[i]!='.':
i=i+1
return a[i:]
except IndexError:
return -1

def compliarg(li,arg):#restituisce una lista di tutti gli elementi contenenti la sottostringa arg come suffisso
res=[]
while li != []:
a=li.pop()
if a.endswith(arg): res.append(a)
return res

def listremintsect(l2,l1):#restituisce una lista res = l1 - intersezione di l1 ed l2
res=[]
while l1 != []:
a=l1.pop()
if not a in l2: res.append(a)
return res

def createpathlist(c,path):#restituisce una lista di path 'path' relativi ai file contenuti in c.
res = []
while c != []:
res.append('{0}/{1}'.format(path,c.pop()))
return res

def totsizes(d): #data una lista d di path restituisce la somma di tutti i size di d
res = 0
while d != []:
a = d.pop()
if os.path.isfile('{0}'.format(a)):
res = res + os.path.getsize('{0}'.format(a))
return res

def listsubstr(arg): #ritorna un dizionario del tipo diz[str(suffisso)] = int(size relativo al suffisso)
res = {}
fcd = os.listdir('{0}'.format(arg))
while fcd != []:
fcdtmp=copy.deepcopy(fcd) #BUGGONE SENZA COPY!!!!!!
a = fcd.pop()
b = dotsubstr(a)
if b == -1: continue
else: pass
c = compliarg(fcdtmp,b)
s=copy.deepcopy(c) #!!!!!!!!!!!!!!!!!!!!!!!!!
d = createpathlist(c,arg)
res[b] = totsizes(d)

fcd = listremintsect(s,fcd)

return res

try:
res = listsubstr(sys.argv[1])
a=list(res.keys())
while a != []:
b = a.pop()
print('{0}:\t{1}'.format(b,res[b]))
except OSError:
print("Could not solve path")

</syntaxhighlight>
-fede

----

Esercizio 1: Linguaggio C

<syntaxhighlight lang="C">
#include <sys/eventfd.h>
#include <stdio.h>
#include <unistd.h>

#define BUFFSIZE 10

int main(int argc, char *argv[]){
int efd,n,i;
char buf1[BUFFSIZE];
char buf2[BUFFSIZE];

do{
efd = eventfd(0,0);
}while(efd<0);

while(1){
if(fork()){ /*padre*/
read(0,buf1,sizeof(buf1)); /*0 indica lo standard input*/
write(efd, buf1, sizeof(buf1));
}

else{ /*figlio*/
read(efd, buf2, sizeof(buf2));
n=atoi(buf2);
for(i=0; i<n; i++) printf("x\n");
}
}
}
</syntaxhighlight>
GiuliaN. con grande aiuto da parte dei colleghi

Esercizio 3 in bash(Pirata & Fede):

<syntaxhighlight lang="bash">
#! /bin/bash

for f in "$1"/*.* ; do
somma=0
ext=${f##*.}
for file in *."$ext"
do
somma=$(expr $somma + $(stat -c%s "$file"))
done
echo -n "size of file with extension "$ext" : "
echo "$somma"
done
</syntaxhighlight>
Per (Pirata & Fede) -Bash-: ci siamo quasi...però forse rifate gli stessi calcoli un po' di volte in più del necessario ;-) (am_20131127).

ProvaPratica 2013.06.21

2013-11-25T17:19:32Z

Amonaldini: /* Bash */

[Python 3]

<syntaxhighlight lang="Python">
'''
Prova Pratica di Laboratorio di Sistemi Operativi
20 giugno 2013
Esercizio 3

URL: http://www.cs.unibo.it/~renzo/so/pratiche/2013.06.21.pdf

@author: Tommaso Ognibene
'''

import os, sys, hashlib

def Main(argv):
# Check number of arguments
if len(argv) != 1:
print("The function does not require arguments to be passed in.")
return

# Build a dictionary with key-value pair {file size - [file name]}
sameSize = { }
PopulateSameSize(sameSize)

# Build a dictionary with key-value pair {MD5 hash - [file name]}
sameContent = { }
for filePaths in sorted(sameSize.values(), key = len, reverse = True):
# No files with same size => No files with same content
if len(filePaths) < 2: break
PopulateSameContent(filePaths, sameContent)

# Print results
PrintResults(sameContent)

print("Done!")

# Populate a dictionary with key-value pair {file size - [file name]}
def PopulateSameSize(sameSize):
for dirPath, _, fileNames in os.walk(os.getcwd()):
for fileName in fileNames:
filePath = os.path.join(dirPath, fileName)
fileSize = os.path.getsize(filePath)
sameSize[fileSize] = sameSize.get(fileSize, []) + [filePath]

# Populate a dictionary with key-value pair {MD5 hash - [file name]}
def PopulateSameContent(filePaths, sameContent):
for filePath in filePaths:
md5 = GetMd5Hash(filePath)
fileRelPath = os.path.relpath(filePath, os.getcwd())
sameContent[md5] = sameContent.get(md5, []) + [fileRelPath]

# Get the MD5 hash without loading the whole file to memory
# Break the file in chunks whose size is a multiple of 128
# This takes advantage of the fact that MD5 has 128-byte digest blocks
def GetMd5Hash(filePath, blockSize = 2 ** 20):
digest = hashlib.md5()
with open(filePath, "rb") as file:
for chunk in iter(lambda: file.read(blockSize), b''):
digest.update(chunk)
return digest.hexdigest()

# Printout the lists of files having same content
def PrintResults(sameContent):
print("Lists of files having same content:")
for files in sorted(sameContent.values(), key = len, reverse = True):
if len(files) < 2: break
print("[{0}]".format(", ".join(file for file in files)))

if __name__ == "__main__":
sys.exit(Main(sys.argv))
</syntaxhighlight>

----

----

ecco la mia versione:
<syntaxhighlight lang="Python">
import os, hashlib

def fileCurrDir():#restituisce una lista res di file presenti nella directory
fcd = os.listdir('.')
res = []
for ott in fcd:
if os.path.isfile('{0}'.format(ott)):res.append(ott)
else:continue
return res

def dictsize(fl=fileCurrDir()):#restituisce un dizionario con key filesize e value lista di filenames aventi size di filesize
res = {}
for f in fl:
if os.path.getsize('{0}'.format(f)) in list(res.keys()):res[os.path.getsize('{0}'.format(f))].append(f);continue
else:pass
res[os.path.getsize('{0}'.format(f))] = list()
res[os.path.getsize('{0}'.format(f))].append(f)
return res

def dictremsa(a=dictsize()):#data un dizionario key::list rimuove tutti gli item la cui len di lista sia unitaria
tmp = list(a.keys())
for tmpkey in tmp:
if len(a[tmpkey]) < 2: a.pop(tmpkey)
else:continue
return a

def hashcontrolinsl(l1): #data una lista di nomi di file compara l hash di tutte le possibili coppie dentro l1
while l1 != []:
toTest = l1.pop()
del res[:]
res.append(toTest)
for tmp in l1:
#res.append(list[toTest,tmp])
#return res
hasher = hashlib.md5()
hasher2 = hashlib.md5()
f = open('{0}'.format(toTest), 'rb')
toHash = f.read()
hasher.update(toHash)
toTesthash = hasher.hexdigest()
f.close()
f = open('{0}'.format(tmp), 'rb')
toHash2 = f.read()
hasher2.update(toHash2)
tmphash = hasher2.hexdigest()
if tmphash==toTesthash: #print('{0} e {1} sono uguali\n'.format(toTest,tmp))
res.append(tmp)
else:continue
if len(res)>1:
print(res);res.pop(0)
for j in res:
l1.pop(l1.index(j))

def hashcontroltoMajorTom(a=dictremsa()):#fa in modo che vengano "hashate" solo delle liste di file che abbiano passato il "stessadimenzione" test
hasher = hashlib.md5()
try:
obviouslyequal = a.pop(0)
print("i seguenti file hanno lo stesso contenuto... NULLA!!!!!:\n")
for oe in obviouslyequal:
print("{0}".format(oe))
except KeyError:pass
values = list(a.values())
print("\ni seguenti file contengono qualcosa ma sono uguali:\n")
for namelist in values:
hashcontrolinsl(namelist)

hashcontroltoMajorTom()
</syntaxhighlight>
-fede

==Bash==
Qualche idea per Bash... 
Si potrebbero usare: 
Per la dimensione in byte dei <file>:
fileSize=$(stat --format=%s <file>)
Per avere l'output del solo hash md5 (senza l'ausilio di altri comandi):
fileHashMd5=$(md5sum <file> | while read fileHash fileName; do echo $fileHash; done)

ProvaPratica 2013.06.21

2013-11-25T17:18:53Z

Amonaldini:

[Python 3]

<syntaxhighlight lang="Python">
'''
Prova Pratica di Laboratorio di Sistemi Operativi
20 giugno 2013
Esercizio 3

URL: http://www.cs.unibo.it/~renzo/so/pratiche/2013.06.21.pdf

@author: Tommaso Ognibene
'''

import os, sys, hashlib

def Main(argv):
# Check number of arguments
if len(argv) != 1:
print("The function does not require arguments to be passed in.")
return

# Build a dictionary with key-value pair {file size - [file name]}
sameSize = { }
PopulateSameSize(sameSize)

# Build a dictionary with key-value pair {MD5 hash - [file name]}
sameContent = { }
for filePaths in sorted(sameSize.values(), key = len, reverse = True):
# No files with same size => No files with same content
if len(filePaths) < 2: break
PopulateSameContent(filePaths, sameContent)

# Print results
PrintResults(sameContent)

print("Done!")

# Populate a dictionary with key-value pair {file size - [file name]}
def PopulateSameSize(sameSize):
for dirPath, _, fileNames in os.walk(os.getcwd()):
for fileName in fileNames:
filePath = os.path.join(dirPath, fileName)
fileSize = os.path.getsize(filePath)
sameSize[fileSize] = sameSize.get(fileSize, []) + [filePath]

# Populate a dictionary with key-value pair {MD5 hash - [file name]}
def PopulateSameContent(filePaths, sameContent):
for filePath in filePaths:
md5 = GetMd5Hash(filePath)
fileRelPath = os.path.relpath(filePath, os.getcwd())
sameContent[md5] = sameContent.get(md5, []) + [fileRelPath]

# Get the MD5 hash without loading the whole file to memory
# Break the file in chunks whose size is a multiple of 128
# This takes advantage of the fact that MD5 has 128-byte digest blocks
def GetMd5Hash(filePath, blockSize = 2 ** 20):
digest = hashlib.md5()
with open(filePath, "rb") as file:
for chunk in iter(lambda: file.read(blockSize), b''):
digest.update(chunk)
return digest.hexdigest()

# Printout the lists of files having same content
def PrintResults(sameContent):
print("Lists of files having same content:")
for files in sorted(sameContent.values(), key = len, reverse = True):
if len(files) < 2: break
print("[{0}]".format(", ".join(file for file in files)))

if __name__ == "__main__":
sys.exit(Main(sys.argv))
</syntaxhighlight>

----

----

ecco la mia versione:
<syntaxhighlight lang="Python">
import os, hashlib

def fileCurrDir():#restituisce una lista res di file presenti nella directory
fcd = os.listdir('.')
res = []
for ott in fcd:
if os.path.isfile('{0}'.format(ott)):res.append(ott)
else:continue
return res

def dictsize(fl=fileCurrDir()):#restituisce un dizionario con key filesize e value lista di filenames aventi size di filesize
res = {}
for f in fl:
if os.path.getsize('{0}'.format(f)) in list(res.keys()):res[os.path.getsize('{0}'.format(f))].append(f);continue
else:pass
res[os.path.getsize('{0}'.format(f))] = list()
res[os.path.getsize('{0}'.format(f))].append(f)
return res

def dictremsa(a=dictsize()):#data un dizionario key::list rimuove tutti gli item la cui len di lista sia unitaria
tmp = list(a.keys())
for tmpkey in tmp:
if len(a[tmpkey]) < 2: a.pop(tmpkey)
else:continue
return a

def hashcontrolinsl(l1): #data una lista di nomi di file compara l hash di tutte le possibili coppie dentro l1
while l1 != []:
toTest = l1.pop()
del res[:]
res.append(toTest)
for tmp in l1:
#res.append(list[toTest,tmp])
#return res
hasher = hashlib.md5()
hasher2 = hashlib.md5()
f = open('{0}'.format(toTest), 'rb')
toHash = f.read()
hasher.update(toHash)
toTesthash = hasher.hexdigest()
f.close()
f = open('{0}'.format(tmp), 'rb')
toHash2 = f.read()
hasher2.update(toHash2)
tmphash = hasher2.hexdigest()
if tmphash==toTesthash: #print('{0} e {1} sono uguali\n'.format(toTest,tmp))
res.append(tmp)
else:continue
if len(res)>1:
print(res);res.pop(0)
for j in res:
l1.pop(l1.index(j))

def hashcontroltoMajorTom(a=dictremsa()):#fa in modo che vengano "hashate" solo delle liste di file che abbiano passato il "stessadimenzione" test
hasher = hashlib.md5()
try:
obviouslyequal = a.pop(0)
print("i seguenti file hanno lo stesso contenuto... NULLA!!!!!:\n")
for oe in obviouslyequal:
print("{0}".format(oe))
except KeyError:pass
values = list(a.values())
print("\ni seguenti file contengono qualcosa ma sono uguali:\n")
for namelist in values:
hashcontrolinsl(namelist)

hashcontroltoMajorTom()
</syntaxhighlight>
-fede

==Bash==
Qualche idea per Bash...
Si potrebbero usare: 
Per la dimensione in byte dei <file>
fileSize=$(stat --format=%s <file>)
Per avere l'output del solo hash md5 (senza l'ausilio di altri comandi):
fileHashMd5=$(md5sum <file> | while read fileHash fileName; do echo $fileHash; done)

ProvaPratica 2013.07.18

2013-11-25T15:44:25Z

Amonaldini: /* Osservazioni */

[Python 3]

<syntaxhighlight lang="Python">
'''
Prova Pratica di Laboratorio di Sistemi Operativi
18 luglio 2013
Esercizio 3

URL: http://www.cs.unibo.it/~renzo/so/pratiche/2013.07.18.pdf

@author: Tommaso Ognibene
'''

import os, sys

def Main(argv):
# Check number of arguments
if len(argv) != 3:
print("The function requires two arguments to be passed in.")
return

# Check parameters
srcDir = str(argv[1])
dstDir = str(argv[2])
if not os.path.isdir(srcDir):
print("First argument should be an existing directory.")
return
if not os.path.isdir(dstDir):
print("Second argument should be an existing directory.")
return

# Build a dictionary with key-value pair {file base name - occurrences}
nameFreq = { }
for dirPath, dirNames, fileNames in os.walk(srcDir):
for fileName in fileNames:
fileBaseName, _ = os.path.splitext(fileName)
nameFreq[fileBaseName] = nameFreq.get(fileBaseName, -1) + 1

# Create a soft link
freq = nameFreq[fileBaseName]
linkName = "{0}{1}".format(fileBaseName, str(freq) if freq > 0 else "")
srcPath = os.path.join(os.path.abspath(dirPath), fileName)
dstPath = os.path.join(dstDir, linkName)
if not os.path.lexists(dstPath):
os.symlink(srcPath, dstPath)

print("Done!")

if __name__ == "__main__":
sys.exit(Main(sys.argv))
</syntaxhighlight>

Questa è la mia versione
<syntaxhighlight lang="Python">

import os, sys

def collectfiles(arg1,arg2):
fcd = os.listdir('{0}'.format(arg1))
while fcd != []:
B=str(fcd.pop())
C='{0}/{1}'.format(arg1,B)
if os.path.isdir('{0}'.format(C)):
collectfiles(C,arg2)
elif os.path.isfile('{0}'.format(C)):
try:
os.symlink('{0}'.format(C), '{0}/{1}'.format(arg2,B))
except OSError:
i=1
while True:
try:
os.symlink('{0}'.format(C), '{0}/{1}{2}'.format(arg2,B,i))
break
except OSError:
i=i+1

try:
collectfiles(str(sys.argv[1]),str(sys.argv[2]))
except OSError:
print("Invalid Directory!")
</syntaxhighlight>
-Fede

Leggendo la tua versione ho pensato che in effetti se i file sono """pochi""" l'hash-table non e' necessaria. E' sufficiente un controllo iterativo.
<syntaxhighlight lang="Python">
'''
Prova Pratica di Laboratorio di Sistemi Operativi
18 luglio 2013
Esercizio 3

URL: http://www.cs.unibo.it/~renzo/so/pratiche/2013.07.18.pdf

@author: Tommaso Ognibene
'''

import os, sys

def Main(argv):
# Check number of arguments
if len(argv) != 3:
print("The function requires two arguments to be passed in.")
return

# Check parameters
srcDir = str(argv[1])
dstDir = str(argv[2])
if not os.path.isdir(srcDir):
print("First argument should be an existing directory.")
return
if not os.path.isdir(dstDir):
print("Second argument should be an existing directory.")
return

# Traverse the directory tree and create a soft link for each file
for dirPath, _, fileNames in os.walk(srcDir):
for fileName in fileNames:
# 'example.pdf' -> 'example'
# 'example.xml' -> 'example'
fileBaseName, _ = os.path.splitext(fileName)
linkName = fileBaseName
srcPath = os.path.join(os.path.abspath(dirPath), fileName)
dstPath = os.path.join(dstDir, linkName)
i = 0
while os.path.isfile(dstPath):
# 'example' will point to 'example.pdf'
# 'example1' will point to 'example.xml'
i += 1
linkName = fileBaseName + str(i)
dstPath = os.path.join(dstDir, linkName)
if not os.path.lexists(dstPath):
os.symlink(srcPath, dstPath)

print("Done!")

if __name__ == "__main__":
sys.exit(Main(sys.argv))
</syntaxhighlight>

----
Ecco la mia versione in bash

<syntaxhighlight lang="Bash">
#! /bin/bash

BornAgainFede () {
for f in "$1"/*; do
bn=$(basename "$f")
if [[ -f $f ]] ; then
if [[ -h "$2"/"$bn" ]] ; then
i=1
while [[ -h "$2"/"$bn$i" ]] ; do
let "i += 1"
done
ln -s "$1"/"$bn" "$2"/"$bn$i"
else
ln -s "$1"/"$bn" "$2"/"$bn"
fi
fi
if [[ -d $f ]] ; then
BornAgainFede "$1"/"$bn" "$2"
fi
done
}

BornAgainFede "$1" "$2"
</syntaxhighlight>
-Fede

==Osservazioni==
Per prima cosa, bel lavoro! 
Di seguito riporto alcune osservazioni che mi sono venute in mente, prendetele assolutamente con soli fini "costruttivi"!
* Se non sbaglio, i due programmi (quello di Tommaso e quello di Fede) hanno un comportamento diverso per quanto concerne l'interpretazione del nome file e, in particolare, dell'estensione:
** Per Tommaso:
*** dir1/example.pdf --> example
*** dir1/example.txt --> example1
*** dir1/dirX/example.pdf --> example2
** Per Fede:
*** dir1/example.pdf --> example.pdf
*** dir1/example.txt --> example.txt
*** dir1/dirX/example.pdf --> example.pdf1
** interpretando in modo "stringente" del testo dell'esercizio avrei ipotizzato un comportamento come quello di Fede.
* Nel codice sorgente c'è in generale poco "commento". Commentare il codice è essenziale: permette ad altri di capire immediatamente le scelte implementative fatte e permette a voi di capire al volo il perché di queste scelte nel caso dobbiate riprendere in mano il vostro codice dopo un po' di tempo. Quindi: commentate!!!
* Bash si presta molto all'esercizio

ProvaPratica 2013.07.18

2013-11-25T15:41:57Z

Amonaldini:

ProvaPratica 2013.07.18

2013-11-25T15:40:03Z

Amonaldini:

[Python 3]

<syntaxhighlight lang="Python">
'''
Prova Pratica di Laboratorio di Sistemi Operativi
18 luglio 2013
Esercizio 3

URL: http://www.cs.unibo.it/~renzo/so/pratiche/2013.07.18.pdf

@author: Tommaso Ognibene
'''

import os, sys

def Main(argv):
# Check number of arguments
if len(argv) != 3:
print("The function requires two arguments to be passed in.")
return

# Check parameters
srcDir = str(argv[1])
dstDir = str(argv[2])
if not os.path.isdir(srcDir):
print("First argument should be an existing directory.")
return
if not os.path.isdir(dstDir):
print("Second argument should be an existing directory.")
return

# Build a dictionary with key-value pair {file base name - occurrences}
nameFreq = { }
for dirPath, dirNames, fileNames in os.walk(srcDir):
for fileName in fileNames:
fileBaseName, _ = os.path.splitext(fileName)
nameFreq[fileBaseName] = nameFreq.get(fileBaseName, -1) + 1

# Create a soft link
freq = nameFreq[fileBaseName]
linkName = "{0}{1}".format(fileBaseName, str(freq) if freq > 0 else "")
srcPath = os.path.join(os.path.abspath(dirPath), fileName)
dstPath = os.path.join(dstDir, linkName)
if not os.path.lexists(dstPath):
os.symlink(srcPath, dstPath)

print("Done!")

if __name__ == "__main__":
sys.exit(Main(sys.argv))
</syntaxhighlight>

Questa è la mia versione
<syntaxhighlight lang="Python">

import os, sys

def collectfiles(arg1,arg2):
fcd = os.listdir('{0}'.format(arg1))
while fcd != []:
B=str(fcd.pop())
C='{0}/{1}'.format(arg1,B)
if os.path.isdir('{0}'.format(C)):
collectfiles(C,arg2)
elif os.path.isfile('{0}'.format(C)):
try:
os.symlink('{0}'.format(C), '{0}/{1}'.format(arg2,B))
except OSError:
i=1
while True:
try:
os.symlink('{0}'.format(C), '{0}/{1}{2}'.format(arg2,B,i))
break
except OSError:
i=i+1

try:
collectfiles(str(sys.argv[1]),str(sys.argv[2]))
except OSError:
print("Invalid Directory!")
</syntaxhighlight>
-Fede

Leggendo la tua versione ho pensato che in effetti se i file sono """pochi""" l'hash-table non e' necessaria. E' sufficiente un controllo iterativo.
<syntaxhighlight lang="Python">
'''
Prova Pratica di Laboratorio di Sistemi Operativi
18 luglio 2013
Esercizio 3

URL: http://www.cs.unibo.it/~renzo/so/pratiche/2013.07.18.pdf

@author: Tommaso Ognibene
'''

import os, sys

def Main(argv):
# Check number of arguments
if len(argv) != 3:
print("The function requires two arguments to be passed in.")
return

# Check parameters
srcDir = str(argv[1])
dstDir = str(argv[2])
if not os.path.isdir(srcDir):
print("First argument should be an existing directory.")
return
if not os.path.isdir(dstDir):
print("Second argument should be an existing directory.")
return

# Traverse the directory tree and create a soft link for each file
for dirPath, _, fileNames in os.walk(srcDir):
for fileName in fileNames:
# 'example.pdf' -> 'example'
# 'example.xml' -> 'example'
fileBaseName, _ = os.path.splitext(fileName)
linkName = fileBaseName
srcPath = os.path.join(os.path.abspath(dirPath), fileName)
dstPath = os.path.join(dstDir, linkName)
i = 0
while os.path.isfile(dstPath):
# 'example' will point to 'example.pdf'
# 'example1' will point to 'example.xml'
i += 1
linkName = fileBaseName + str(i)
dstPath = os.path.join(dstDir, linkName)
if not os.path.lexists(dstPath):
os.symlink(srcPath, dstPath)

print("Done!")

if __name__ == "__main__":
sys.exit(Main(sys.argv))
</syntaxhighlight>

----
Ecco la mia versione in bash

<syntaxhighlight lang="Bash">
#! /bin/bash

BornAgainFede () {
for f in "$1"/*; do
bn=$(basename "$f")
if [[ -f $f ]] ; then
if [[ -h "$2"/"$bn" ]] ; then
i=1
while [[ -h "$2"/"$bn$i" ]] ; do
let "i += 1"
done
ln -s "$1"/"$bn" "$2"/"$bn$i"
else
ln -s "$1"/"$bn" "$2"/"$bn"
fi
fi
if [[ -d $f ]] ; then
BornAgainFede "$1"/"$bn" "$2"
fi
done
}

BornAgainFede "$1" "$2"
</syntaxhighlight>
-Fede

==Osservazioni==
Per prima cosa, bel lavoro! 
Di seguito riporto alcune osservazioni che mi sono venute in mente, prendetele assolutamente con soli fini "costruttivi"!
* Se non sbaglio, i due programmi (quello di Tommaso e quello di Fede) hanno un comportamento diverso per quanto concerne l'interpretazione del nome file e, in particolare, l'estensione: 
** Per Tommaso:
*** dir1/example.pdf --> example
*** dir1/example.txt --> example1
*** dir1/dirX/example.pdf --> example2
** Per Fede:
*** dir1/example.pdf --> example.pdf
*** dir1/example.txt --> example.txt
*** dir1/dirX/example.pdf --> example.pdf1
** interpretando in modo "stringente" del testo dell'esercizio avrei ipotizzato un comportamento come quello di Fede.
* Nel codice sorgente c'è in generale poco "commento". Commentare il codice è essenziale: permette ad altri di capire immediatamente le scelte implementative fatte e permette a voi di capire al volo il perché di queste scelte nel caso dobbiate riprendere in mano il vostro codice dopo un po' di tempo.

Comandi visti alle lezioni.

2013-11-20T18:53:33Z

Amonaldini:

mi sembra una buon idea fare una tabellina con commandi importanti visti alle lezioni, e una breve descrizione di che fanno e che parametri ricevono. non ne ho tutti scritti, allora mi raccomando- aggiungete pure!

ps- e' possibile fare una tabella?

at

cat- concatenare file

chmod- cambia mode

echo- stampa il testo

false- non fa niente - restituisce 1 (falso)

ln- linka tra due file (-s crea il link simbolico)

mkdir- crea una cartella

nologin- prevenire unpriviliggiati utenti di loggare al sistema

od

pwd- stampa l'indirizzio alla cartella in cui sono

touch- crea un file

true- non fa niente (retituisce 0 vero)

umask - stabilisce i permessi standard (i bit accesi nella umask vengono normalmente spenti)

whoami- stampa l'id dell'utente

su- switch user

----
Daniele F. & Federico A.

----

Abbiamo messo qualche comando con relativa descrizione, speriamo vi possano aiutare e che non ci siano troppi errori.

----

Informazioni e Aiuti:

* '''man''' ''file'' : (manual) apre il manuale, se esiste, alla pagina relativa a ''file''.
** '''man''' ''[-k]'' ''file'' : elenca tutte le pagine di manuale con la parola ''file''.
** '''man''' ''[n]'' ''file'' : apre la sezione n (1 eseguibili e comandi, 2 system calls, 3 libreria...) relativa a ''file''; (p.e. ''man 2 open'' apre la pagina relativa alla system call "open".).
* '''info''' ''file'' : apre il documento informativo relativo a 'file'.
* '''help''' ''[file]'' : visualizza alcuni comandi utili o informazioni su ''file''.

----

Comandi per Cartelle e File:

* '''ls''' ''[path]'' : (list) visualizza la lista dei file/directory nella directory corrente o nel path indicato.
** '''ls''' ''[-l]'' : visualizza la lista estesa (privilegi, n* hard link, proprietario, dimensione, ultima modifica, nome file/directory) dei file/directory nella directory corrente.
* '''pwd''' : (print working directory) visualizza il percorso della directory corrente.
* '''cd''' ''[path]'' : (change directory) entra nella directory specificata da ''path'' altrimenti torna al root dell'utente.
* '''rm''' ''file'' : (remove) elimina ''file''.
** '''rm''' ''[-Rf]'' ''file/path'' : elimina in modo ricorsivo e forzato i file e le directory nel ''path'' specificato.
* '''rmdir''' ''dir'' : (remove directory) elimina ''dir'' se vuota.
* '''mkdir''' ''dir'' : (make directory) crea la directory ''dir'' (può essere anche specificato un path).
* '''mv''' ''source'' ''dest'' : (move) muovi (o rinomina) il file ''source'' nel path ''dest''.
* '''touch''' ''file'' : crea ''file'' o se esiste già cambia la data di ultima modifica.
* '''ln''' ''target'' ''link'' : crea un link al file o directory ''target''.
** '''ln''' ''[-s]'' ''target'' ''link'' : (soft link) link simbolico.
** '''ln''' ''[-p]'' ''target'' ''link'' : (hard link) link fisico a file (non è possibile fare link a directory).

----

Comandi di Gestione e Analisi Sistema:

* '''ps ''' : (process status) visualizza il report dei processi attivi.
** '''pstree''' : visualizza l'albero dei processi attivi.
* '''df''' : (disk free) visualizza lo spazio occupato del disco dai file di sistema.
* '''du''' : (disk usage) visualizza una stima dell'utilizzo del disco di ogni singolo file/directory.
* '''groupadd''' ''group'' : crea il nuovo gruppo ''group''.
* '''useradd''' ''username'' : crea il nuovo utente ''username''.
* '''adduser''' ''username'' : crea il nuovo utente ''username'' (in maniera più veloce).
* '''groupdel''' ''group'' : elimina il gruppo indicato.
* '''userdel''' ''username'': elimina l'utente indicato.
* '''deluser''' ''username'': elimina l'utente indicato (in maniera più veloce).
* '''chmod''' ''par'' ''file'' : (change mode) modifica i privilegi di ''file'' tramite i valori/caratteri di ''par''.
* '''chown''' ''file'' : (change owner) cambia il proprietario e il gruppo di ''file''.
* '''chgrp''' ''group'' ''file'' : (change group) cambia il gruppo di ''file'' in ''group''.
* '''su''' ''[username]'' : (switch user) cambia utente.
* '''whoami''' : visualizza l'utente che usa il comando.

----

Comandi Ctrl:

* '''^S''' : sospende la visualizzazione.
* '''^Q''' : riattiva la visualizzazione.
* '''^C''' : cancella un'operazione.
* '''^D''' : fine del file.
* '''^V''' : tratta il carattere di controllo sequenze come se fosse carattere normale.

----

Comandi Vari:

* '''true''' : restituisce 0.
* '''false''' : restituisce 1.
* '''od''' ''[file]'' : stampa una rappresentazione in base ottale di ''file'' (esadecimale con -x).
* '''kill''' ''pid'' : termina il processo con id ''pid''.
* '''errno''' : (error number) ultimo errore restituito.
* '''strerror''' : (string error) stringa corrispondente all'ultimo errore.
* '''echo''' ''string'' : stampa a video ''string''.
* '''time''' ''command'' : ???
* '''dd''' : ???

----
[[User:Ferra1993|Ferra1993]] ([[User talk:Ferra1993|talk]]) 17:45, 7 November 2013 (CET)
| [[User:Fede|Fede]] ([[User talk:Fede|talk]]) 17:49, 7 November 2013 (CET)

SYS CALL viste a lezione.

2013-11-20T15:46:31Z

Amonaldini:

SYS CALL viste a lezione.

2013-11-20T15:45:17Z

Amonaldini:

==FORK==
Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre.

esempio1:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>

void main (void){
if(fork()){
printf("uno %d %d \n", getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre
sleep(2);} //se togliessimo lo sleep;il processo figlio stamperebbe come getppid() 1,perché essendo il padre terminato e lui rimasto orfano,il nuovo padre diventa init
else
printf("due %d %d \n",getpid(), getppid() );
}
</syntaxhighlight>

esempio2(una piccola osservazione sull'eredità del buffer):
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>

void main (void){
printf("cucù! : "); //notare la differenza se nella sringa metto \n
if(fork())
printf("uno %d %d \n", getpid(), getppid() );
else
printf("due %d %d \n",getpid(), getppid() );
}

</syntaxhighlight>

esempio3(fork e malloc): 
'''(sottolineerei che lo spazio di indirizzamento è di fatto separato: i due processi hanno una analoga visione dell'indirizzamento logico, che però è specifico di ogni processo e i dati sono memorizzati fisicamente in aree di memoria diverse. am_20131110)'''
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

void main (void){
int *p;
if( fork() ){
p = malloc(sizeof(int));
*p = 45;
printf("%d %p pid : %d , ppid : %d \n",*p,p,getpid(),getppid());
sleep(2);
}
else {
p = malloc(sizeof(int));
printf("%d %p pid : %d , ppid : %d \n",*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio
sleep(1); //perché condividono lo stesso spazio di indirizzamento
}
}
</syntaxhighlight>

==_EXIT==
Termina il proceso chiamante.

esempio1:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main (int argc,char *argv[]){
_exit(0); //Sys call che termina il processo chiamante
}
</syntaxhighlight>

esempio2(atexit):
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

void at1(void){
printf("at1 \n");
}

void at2(void){
printf("at2 \n");
}

int main (int argc,char *argv[]){
printf("brutal kill \n");
atexit(at1); //funzione di libreria che termina il processo passato come argomento
atexit(at2);
}

//le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione
</syntaxhighlight>

==WAIT==
Aspetta che un processo cambi di stato.

esempio1:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main (int argc, char *argv[]){
pid_t pid;
if( pid = fork() ){
int status;
printf(" padre : %d figlio : %d \n",getpid(),pid);
sleep(10);
waitpid(pid,&status,0);
printf(" exit status %d \n",WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio
} //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.
else {
printf(" figlio : %d padre : %d \n",getpid(),getppid());
sleep(1);
exit(1);
}
}
</syntaxhighlight>

esempio2:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main (int argc, char *argv[]){
pid_t pid;
if( pid = fork() ){
int status;
printf(" padre : %d figlio : %d \n",getpid(),pid);
sleep(5);
waitpid(pid,&status,0);
if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main
printf(" exit status %d \n", WEXITSTATUS(status));
else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale
printf("signal : %d \n", WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio
}
else {
int *p;
printf(" figlio : %d padre : %d \n",getpid(),getppid());
sleep(1);
p = (int *)42;
*p = 43;
exit(2);
}
}
</syntaxhighlight>

==EXEC==
Esegue un programma.
La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.

esempio1:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main (int argc, char *argv[]){
pid_t pid;
if( pid = fork() ){
int status;
printf(" padre : %d figlio : %d \n",getpid(),pid);
sleep(5);
waitpid(pid,&status,0);
if (WIFEXITED(status))
printf(" exit status %d \n", WEXITSTATUS(status));
else if( WIFSIGNALED(status) )
printf("signal : %d \n", WTERMSIG(status) );
}
else {
char *args[] = {"ls","-l",(char *)0};
execvp("ls",args); //funzione di libreria che prende in input il path(p) e un vettore(v).
}
}
</syntaxhighlight>

esempio2:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main (int argc, char *argv[]){
pid_t pid;
if( pid = fork() ){
int status;
printf(" padre : %d figlio : %d %s \n",getpid(),pid,argv[1]);
sleep(5);
waitpid(pid,&status,0);
if (WIFEXITED(status))
printf(" exit status %d \n", WEXITSTATUS(status));
else if( WIFSIGNALED(status) )
printf("signal : %d \n", WTERMSIG(status) );
}
else {
execvp(argv[2],argv+2);
}
}
</syntaxhighlight>

Correggetemi se ho scritto delle sciocchezze.
-Pirata-

==Gestione File==
* int open(const char *path, int oflag, ...); 
* int creat(const char *path, mode_t mode);
* int close(int filedes);
* off_t lseek(int filedes, off_t offset, int whence);
* ssize_t read(int filedes, void *buf, size_t nbyte);
* ssize_t write(int filedes, const void *buf, size_t nbyte);

Qualche esempio? Iniziamo con i file "con il buco" visti a lezione?

Comandi visti alle lezioni.

2013-11-12T11:43:13Z

Amonaldini:

mi sembra una buon idea fare una tabellina con commandi importanti visti alle lezioni, e una breve descrizione di che fanno e che parametri ricevono. non ne ho tutti scritti, allora mi raccomando- aggiungete pure!

ps- e' possibile fare una tabella?

at

cat- concatenare file

chmod- cambia mode

echo- stampa il testo

false- non fa niente - restituisce 1 (falso)

ln- linka tra due file (-s crea il link simbolico)

mkdir- crea una cartella

nologin- prevenire unpriviliggiati utenti di loggare al sistema

od

pwd- stampa l'indirizzio alla cartella in cui sono

touch- crea un file

true- non fa niente (retituisce 0 vero)

umask - stabilisce i permessi standard (i bit accesi nella umask vengono normalmente spenti)

whoami- stampa l'id dell'utente

su- switch user

----
Daniele F. & Federico A.

----

Abbiamo messo qualche comando con relativa descrizione, speriamo vi possano aiutare e che non ci siano troppi errori.

----

Informazioni e Aiuti:

* '''man''' ''file'' : (manual) apre il manuale, se esiste, alla pagina relativa a ''file''.
** '''man''' ''[-k]'' ''file'' : elenca tutte le pagine di manuale con la parola ''file''.
** '''man''' ''[n]'' ''file'' : apre la sezione n (1 eseguibili e comandi, 2 system calls, 3 libreria...) relativa a ''file''; (p.e. ''man 2 open'' apre la pagina relativa alla system call "open".).
* '''info''' ''file'' : apre il documento informativo relativo a 'file'.
* '''help''' ''[file]'' : visualizza alcuni comandi utili o informazioni su ''file''.

----

Comandi per Cartelle e File:

* '''ls''' ''[path]'' : (list) visualizza la lista dei file/directory nella directory corrente o nel path indicato.
** '''ls''' ''[-l]'' : visualizza la lista estesa (privilegi, n* hard link, proprietario, dimensione, ultima modifica, nome file/directory) dei file/directory nella directory corrente.
* '''pwd''' : (print working directory) visualizza il percorso della directory corrente.
* '''cd''' ''[path]'' : (change directory) entra nella directory specificata da ''path'' altrimenti torna al root dell'utente.
* '''rm''' ''file'' : (remove) elimina ''file''.
** '''rm''' ''[-Rf]'' ''file/path'' : elimina in modo ricorsivo e forzato i file e le directory nel ''path'' specificato.
* '''rmdir''' ''dir'' : (remove directory) elimina ''dir'' se vuota.
* '''mkdir''' ''dir'' : (make directory) crea la directory ''dir'' (può essere anche specificato un path).
* '''mv''' ''source'' ''dest'' : (move) muovi (o rinomina) il file ''source'' nel path ''dest''.
* '''touch''' ''file'' : crea ''file'' o se esiste già cambia la data di ultima modifica.
* '''ln''' ''target'' ''link'' : crea un link al file o directory ''target''.
** '''ln''' ''[-s]'' ''target'' ''link'' : (soft link) link simbolico.
** '''ln''' ''[-p]'' ''target'' ''link'' : (hard link) link fisico a file (non è possibile fare link a directory).

----

Comandi di Gestione e Analisi Sistema:

* '''ps ''' : (process status) visualizza il report dei processi attivi.
** '''pstree''' : visualizza l'albero dei processi attivi.
* '''df''' : (disk free) visualizza lo spazio occupato del disco dai file di sistema.
* '''du''' : (disk usage) visualizza una stima dell'utilizzo del disco di ogni singolo file/directory.
* '''groupadd''' ''group'' : crea il nuovo gruppo ''group''.
* '''useradd''' ''username'' : crea il nuovo utente ''username''.
* '''adduser''' ''username'' : crea il nuovo utente ''username'' (in maniera più veloce).
* '''groupdel''' ''group'' : elimina il gruppo indicato.
* '''userdel''' ''username'': elimina l'utente indicato.
* '''deluser''' ''username'': elimina l'utente indicato (in maniera più veloce).
* '''chmod''' ''par'' ''file'' : (change mode) modifica i privilegi di ''file'' tramite i valori/caratteri di ''par''.
* '''chown''' ''file'' : (change owner) cambia il proprietario e il gruppo di ''file''.
* '''chgrp''' ''group'' ''file'' : (change group) cambia il gruppo di ''file'' in ''group''.
* '''su''' ''[username]'' : (switch user) cambia utente.
* '''whoami''' : visualizza l'utente che usa il comando.

----

Comandi Ctrl:

* '''^S''' : sospende la visualizzazione.
* '''^Q''' : riattiva la visualizzazione.
* '''^C''' : cancella un'operazione.
* '''^D''' : fine del file.
* '''^V''' : tratta il carattere di controllo sequenze come se fosse carattere normale.

----

Comandi Vari:

* '''true''' : restituisce 0.
* '''false''' : restituisce 1.
* '''od''' ''[file]'' : stampa una rappresentazione in base ottale di ''file'' (esadecimale con -x).
* '''kill''' ''pid'' : termina il processo con id ''pid''.
* '''errno''' : (error number) ultimo errore restituito.
* '''strerror''' : (string error) stringa corrispondente all'ultimo errore.
* '''echo''' ''string'' : stampa a video ''string''.

----
[[User:Ferra1993|Ferra1993]] ([[User talk:Ferra1993|talk]]) 17:45, 7 November 2013 (CET)
| [[User:Fede|Fede]] ([[User talk:Fede|talk]]) 17:49, 7 November 2013 (CET)

Python Programma tieni punteggio.

2013-11-12T11:27:31Z

Amonaldini:

Ho voglia di organizzare un torneo di 105, per chi non lo conoscesse e` il gioco che ha ispirato UNO solamente un po' piu complesso.
Ma, prima di poterci giocare avevo intenzione di fare un programma in python il cui scopo è quello di tenere il punteggio del torneo e, all`occorrenza, quello di crearmi un file.txt con tutti i nomi dei partecipanti e i relativi punteggi, in ordine decrescente.
Ovviamente in qualsiasi momento si dovra poter aggiungere un partecipante, diminuirne o aumentarne il punteggio, eliminarlo dal torneo.
Il programma che ho in mente non e specializzato per il centocinque ma è un generico "tieni punteggio metti in ordine decrescente e scrivi file nel formato "NOME GIOCATORE \t\t PUNTEGGIO"" per così dire.
Ecco come mi immagino la struttura del programma (ma che probabilmente fara schifo perche non ho mai fatto niente di utile):
* Una directory con dentro dei file.py ciascuno dei quali grazie alla libreria 'pickle' interagisce con un file che sarà appunto info.pck e, ciascuno dei quali ha un compito ben preciso: sorting decrescente, generare il file.txt, aggiungere un partecipante, rimuovere un partecipante, etc...
* Ciascuno di questi file python poi verrà interpellato dall`utente direttamente da console tramite degli script posti in /usr/bin.
Ho deciso di usare questa implementazione cosi che semmai volessi aggiungere qualche nuova feature al programma, non dovro mai modificare né i vecchi script né i file.py ma dovrò semplicemente creare le nuove feature e farle interagire con il file.pck.
Prima di andare avanti volevo qualche opinione o consiglio riguardo alla struttura sopra descritta, ed eventualmente migliorie o magari una struttura completamente diversa.
*Fede

----
Questo esempio ci apre sicuramente spunti di riflessione sulla persistenza: interessante! 
Aggiungo qualche idea... 
Le operazioni che si ipotizzano sui partecipanti sono le CRUD: necessarie. Per usabilità aggiungerei anche qualche operazioni per elencare o ricercare i partecipanti già inseriti.
Al fine di distinguere partecipanti omonimi si potrebbe pensare di creare un'astrazione specifica di "Partecipante" (verso l'OOP), così da caratterizzarlo ulteriormente (ID?, data iscrizione al torneo?...tutto quello che ci viene in mente...).
Per la parte di (de)serializzazione si utilizza pikle: interessante "guardare" dentro al file serializzato o, eventualmente, provare a creare una nostra libreria di serializzazione: attenzione agli oggetti che, anche indirettamente, hanno riferimenti a se stesso! 
am_20131112 
----
*Primo modulo.py, Starter.py:

<syntaxhighlight lang="python"> import pickle
scelta = 'y'
infotorneo = {}
while scelta == 'y':
a = raw_input("Nome Giocatore:" ) #a = input("Nome Giocatore:" )
infotorneo[a] = 0 #Inizialmente nel torneo tutti hanno punteggio 0.
scelta = raw_input("Vuoi inserire altri Giocatori? (y/n)" ) #scelta = input("Vuoi inserire altri Giocatori? (y/n)" )
while (scelta != 'y' and scelta != 'n'):
scelta = raw_input("Specificare y/n" ) #scelta = input("Specificare y/n" )

f = open(".info.pck","w")
pickle.dump(infotorneo, f)
f.close() </syntaxhighlight>

----
*il modulo cambiapunteggiodi.py, poi gli mettero un controllo per verificare l`esistenza di Giocatore:

<syntaxhighlight lang="python"> import pickle
f = open(".info.pck","r")
infotorneo = {}
infotorneo = pickle.load(f)
f.close()
scelta = 'y'
while (scelta == 'y'):
Giocatore = raw_input("Di chi vuoi cambiare il punteggio?" )
NuovoPunteggio = raw_input("Inserire nuovo punteggio." )
infotorneo[Giocatore] = NuovoPunteggio
scelta = raw_input("Vuoi cambiare il punteggio di un altro giocatore?(y/n)" )
while(scelta != 'y' and scelta != 'n'):
scelta = raw_input("Specificare y/n")

f = open(".info.pck","w")
pickle.dump(infotorneo, f)
f.close() </syntaxhighlight>

Python Programma tieni punteggio.

2013-11-12T11:26:30Z

Amonaldini:

Ho voglia di organizzare un torneo di 105, per chi non lo conoscesse e` il gioco che ha ispirato UNO solamente un po' piu complesso.
Ma, prima di poterci giocare avevo intenzione di fare un programma in python il cui scopo è quello di tenere il punteggio del torneo e, all`occorrenza, quello di crearmi un file.txt con tutti i nomi dei partecipanti e i relativi punteggi, in ordine decrescente.
Ovviamente in qualsiasi momento si dovra poter aggiungere un partecipante, diminuirne o aumentarne il punteggio, eliminarlo dal torneo.
Il programma che ho in mente non e specializzato per il centocinque ma è un generico "tieni punteggio metti in ordine decrescente e scrivi file nel formato "NOME GIOCATORE \t\t PUNTEGGIO"" per così dire.
Ecco come mi immagino la struttura del programma (ma che probabilmente fara schifo perche non ho mai fatto niente di utile):
* Una directory con dentro dei file.py ciascuno dei quali grazie alla libreria 'pickle' interagisce con un file che sarà appunto info.pck e, ciascuno dei quali ha un compito ben preciso: sorting decrescente, generare il file.txt, aggiungere un partecipante, rimuovere un partecipante, etc...
* Ciascuno di questi file python poi verrà interpellato dall`utente direttamente da console tramite degli script posti in /usr/bin.
Ho deciso di usare questa implementazione cosi che semmai volessi aggiungere qualche nuova feature al programma, non dovro mai modificare né i vecchi script né i file.py ma dovrò semplicemente creare le nuove feature e farle interagire con il file.pck.
Prima di andare avanti volevo qualche opinione o consiglio riguardo alla struttura sopra descritta, ed eventualmente migliorie o magari una struttura completamente diversa.
*Fede

----
Questo esempio ci apre sicuramente spunti di riflessione sulla persistenza: interessante!
Aggiungo qualche idea:
Le operazioni che si ipotizzano sui partecipanti sono le CRUD: necessarie. Per usabilità aggiungerei anche qualche operazioni per elencare o ricercare i partecipanti già inseriti.
Al fine di distinguere partecipanti omonimi si potrebbe pensare di creare un'astrazione specifica di "Partecipante" (verso l'OOP), così da caratterizzarlo ulteriormente (ID?, data iscrizione al torneo?...tutto quello che ci viene in mente...).
Per la parte di (de)serializzazione si utilizza pikle: interessante "guardare" dentro al file serializzato o, eventualmente, provare a creare una nostra libreria di serializzazione: attenzione agli oggetti che, anche indirettamente, hanno riferimenti a se stesso!
am_20131112
----
*Primo modulo.py, Starter.py:

<syntaxhighlight lang="python"> import pickle
scelta = 'y'
infotorneo = {}
while scelta == 'y':
a = raw_input("Nome Giocatore:" ) #a = input("Nome Giocatore:" )
infotorneo[a] = 0 #Inizialmente nel torneo tutti hanno punteggio 0.
scelta = raw_input("Vuoi inserire altri Giocatori? (y/n)" ) #scelta = input("Vuoi inserire altri Giocatori? (y/n)" )
while (scelta != 'y' and scelta != 'n'):
scelta = raw_input("Specificare y/n" ) #scelta = input("Specificare y/n" )

f = open(".info.pck","w")
pickle.dump(infotorneo, f)
f.close() </syntaxhighlight>

----
*il modulo cambiapunteggiodi.py, poi gli mettero un controllo per verificare l`esistenza di Giocatore:

<syntaxhighlight lang="python"> import pickle
f = open(".info.pck","r")
infotorneo = {}
infotorneo = pickle.load(f)
f.close()
scelta = 'y'
while (scelta == 'y'):
Giocatore = raw_input("Di chi vuoi cambiare il punteggio?" )
NuovoPunteggio = raw_input("Inserire nuovo punteggio." )
infotorneo[Giocatore] = NuovoPunteggio
scelta = raw_input("Vuoi cambiare il punteggio di un altro giocatore?(y/n)" )
while(scelta != 'y' and scelta != 'n'):
scelta = raw_input("Specificare y/n")

f = open(".info.pck","w")
pickle.dump(infotorneo, f)
f.close() </syntaxhighlight>

Python Programma tieni punteggio.

2013-11-12T11:25:33Z

Amonaldini:

Ho voglia di organizzare un torneo di 105, per chi non lo conoscesse e` il gioco che ha ispirato UNO solamente un po' piu complesso.
Ma, prima di poterci giocare avevo intenzione di fare un programma in python il cui scopo è quello di tenere il punteggio del torneo e, all`occorrenza, quello di crearmi un file.txt con tutti i nomi dei partecipanti e i relativi punteggi, in ordine decrescente.
Ovviamente in qualsiasi momento si dovra poter aggiungere un partecipante, diminuirne o aumentarne il punteggio, eliminarlo dal torneo.
Il programma che ho in mente non e specializzato per il centocinque ma è un generico "tieni punteggio metti in ordine decrescente e scrivi file nel formato "NOME GIOCATORE \t\t PUNTEGGIO"" per così dire.
Ecco come mi immagino la struttura del programma (ma che probabilmente fara schifo perche non ho mai fatto niente di utile):
* Una directory con dentro dei file.py ciascuno dei quali grazie alla libreria 'pickle' interagisce con un file che sarà appunto info.pck e, ciascuno dei quali ha un compito ben preciso: sorting decrescente, generare il file.txt, aggiungere un partecipante, rimuovere un partecipante, etc...
* Ciascuno di questi file python poi verrà interpellato dall`utente direttamente da console tramite degli script posti in /usr/bin.
Ho deciso di usare questa implementazione cosi che semmai volessi aggiungere qualche nuova feature al programma, non dovro mai modificare né i vecchi script né i file.py ma dovrò semplicemente creare le nuove feature e farle interagire con il file.pck.
Prima di andare avanti volevo qualche opinione o consiglio riguardo alla struttura sopra descritta, ed eventualmente migliorie o magari una struttura completamente diversa.
*Fede

---
Questo esempio ci apre sicuramente spunti di riflessione sulla persistenza: interessante!
Aggiungo qualche idea:
Le operazioni che si ipotizzano sui partecipanti sono le CRUD: necessarie. Per usabilità aggiungerei anche qualche operazioni per elencare o ricercare i partecipanti già inseriti.
Al fine di distinguere partecipanti omonimi si potrebbe pensare di creare un'astrazione specifica di "Partecipante" (verso l'OOP), così da caratterizzarlo ulteriormente (ID?, data iscrizione al torneo?...tutto quello che ci viene in mente...).
Per la parte di (de)serializzazione si utilizza pikle: interessante "guardare" dentro al file serializzato o, eventualmente, provare a creare una nostra libreria di serializzazione: attenzione agli oggetti che, anche indirettamente, hanno riferimenti a se stesso!
am_20131112
----
*Primo modulo.py, Starter.py:

<syntaxhighlight lang="python"> import pickle
scelta = 'y'
infotorneo = {}
while scelta == 'y':
a = raw_input("Nome Giocatore:" ) #a = input("Nome Giocatore:" )
infotorneo[a] = 0 #Inizialmente nel torneo tutti hanno punteggio 0.
scelta = raw_input("Vuoi inserire altri Giocatori? (y/n)" ) #scelta = input("Vuoi inserire altri Giocatori? (y/n)" )
while (scelta != 'y' and scelta != 'n'):
scelta = raw_input("Specificare y/n" ) #scelta = input("Specificare y/n" )

f = open(".info.pck","w")
pickle.dump(infotorneo, f)
f.close() </syntaxhighlight>

----
*il modulo cambiapunteggiodi.py, poi gli mettero un controllo per verificare l`esistenza di Giocatore:

<syntaxhighlight lang="python"> import pickle
f = open(".info.pck","r")
infotorneo = {}
infotorneo = pickle.load(f)
f.close()
scelta = 'y'
while (scelta == 'y'):
Giocatore = raw_input("Di chi vuoi cambiare il punteggio?" )
NuovoPunteggio = raw_input("Inserire nuovo punteggio." )
infotorneo[Giocatore] = NuovoPunteggio
scelta = raw_input("Vuoi cambiare il punteggio di un altro giocatore?(y/n)" )
while(scelta != 'y' and scelta != 'n'):
scelta = raw_input("Specificare y/n")

f = open(".info.pck","w")
pickle.dump(infotorneo, f)
f.close() </syntaxhighlight>

SYS CALL viste a lezione.

2013-11-10T08:40:45Z

Amonaldini:

* FORK
Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre.

esempio1:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>

void main (void){
if(fork()){
printf("uno %d %d \n", getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre
sleep(2);} //se togliessimo lo sleep;il processo figlio stamperebbe come getppid() 1,perché essendo il padre terminato e lui rimasto orfano,il nuovo padre diventa init
else
printf("due %d %d \n",getpid(), getppid() );
}
</syntaxhighlight>

esempio2(una piccola osservazione sull'eredità del buffer):
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>

void main (void){
printf("cucù! : "); //notare la differenza se nella sringa metto \n
if(fork())
printf("uno %d %d \n", getpid(), getppid() );
else
printf("due %d %d \n",getpid(), getppid() );
}

</syntaxhighlight>

esempio3(fork e malloc): 
(sottolineerei che lo spazio di indirizzamento è di fatto separato: i due processi hanno una analoga visione dell'indirizzamento logico, che però è specifico di ogni processo e i dati sono memorizzati fisicamente in aree di memoria diverse. am_20131110)
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

void main (void){
int *p;
if( fork() ){
p = malloc(sizeof(int));
*p = 45;
printf("%d %p pid : %d , ppid : %d \n",*p,p,getpid(),getppid());
sleep(2);
}
else {
p = malloc(sizeof(int));
printf("%d %p pid : %d , ppid : %d \n",*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio perché condividono lo stesso spazio di indirizzamento
sleep(1);
}
}
</syntaxhighlight>

* WAIT
Aspetta che un processo cambi di stato.

esempio1:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main (int argc, char *argv[]){
pid_t pid;
if( pid = fork() ){
int status;
printf(" padre : %d figlio : %d \n",getpid(),pid);
sleep(10);
waitpid(pid,status,0);
printf(" exit status %d \n",WEXITSTATUS(status));
}
else {
printf(" figlio : %d padre : %d \n",getpid(),getppid());
sleep(1);
exit(1);
}
}
</syntaxhighlight>

esempio2:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main (int argc, char *argv[]){
pid_t pid;
if( pid = fork() ){
int status;
printf(" padre : %d figlio : %d \n",getpid(),pid);
sleep(5);
waitpid(pid,status,0);
if (WIFEXITED(status))
printf(" exit status %d \n", WEXITSTATUS(status));
else if(WIFSIGNALED(status) )
printf("signal : %d \n", WTERMSIG(status) );
}
else {
int *p;
printf(" figlio : %d padre : %d \n",getpid(),getppid());
sleep(1);
p = (int *)42;
*p = 43;
exit(2);
}
}
</syntaxhighlight>

Correggetemi se ho scritto delle sciocchezze.
(Pirata)

SYS CALL viste a lezione.

2013-11-10T08:40:10Z

Amonaldini:

* FORK
Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre.

esempio1:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>

void main (void){
if(fork()){
printf("uno %d %d \n", getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre
sleep(2);} //se togliessimo lo sleep;il processo figlio stamperebbe come getppid() 1,perché essendo il padre terminato e lui rimasto orfano,il nuovo padre diventa init
else
printf("due %d %d \n",getpid(), getppid() );
}
</syntaxhighlight>

esempio2(una piccola osservazione sull'eredità del buffer):
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>

void main (void){
printf("cucù! : "); //notare la differenza se nella sringa metto \n
if(fork())
printf("uno %d %d \n", getpid(), getppid() );
else
printf("due %d %d \n",getpid(), getppid() );
}

</syntaxhighlight>

esempio3(fork e malloc):
(sottolineerei che lo spazio di indirizzamento è di fatto separato: i due processi hanno una analoga visione dell'indirizzamento logico, che però è specifico di ogni processo e i dati sono memorizzati fisicamente in aree di memoria diverse. am_20131110)
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

void main (void){
int *p;
if( fork() ){
p = malloc(sizeof(int));
*p = 45;
printf("%d %p pid : %d , ppid : %d \n",*p,p,getpid(),getppid());
sleep(2);
}
else {
p = malloc(sizeof(int));
printf("%d %p pid : %d , ppid : %d \n",*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio perché condividono lo stesso spazio di indirizzamento
sleep(1);
}
}
</syntaxhighlight>

* WAIT
Aspetta che un processo cambi di stato.

esempio1:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main (int argc, char *argv[]){
pid_t pid;
if( pid = fork() ){
int status;
printf(" padre : %d figlio : %d \n",getpid(),pid);
sleep(10);
waitpid(pid,status,0);
printf(" exit status %d \n",WEXITSTATUS(status));
}
else {
printf(" figlio : %d padre : %d \n",getpid(),getppid());
sleep(1);
exit(1);
}
}
</syntaxhighlight>

esempio2:
<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main (int argc, char *argv[]){
pid_t pid;
if( pid = fork() ){
int status;
printf(" padre : %d figlio : %d \n",getpid(),pid);
sleep(5);
waitpid(pid,status,0);
if (WIFEXITED(status))
printf(" exit status %d \n", WEXITSTATUS(status));
else if(WIFSIGNALED(status) )
printf("signal : %d \n", WTERMSIG(status) );
}
else {
int *p;
printf(" figlio : %d padre : %d \n",getpid(),getppid());
sleep(1);
p = (int *)42;
*p = 43;
exit(2);
}
}
</syntaxhighlight>

Correggetemi se ho scritto delle sciocchezze.
(Pirata)

Main Page

2013-11-08T10:05:58Z

Amonaldini:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizi a caso del Prof.]]

[[Python Programma tieni punteggio.]]

[[Comandi visti alle lezioni.]]

----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

Commandi visti alle lezioni.

2013-11-08T10:05:36Z

Amonaldini: Amonaldini moved page Commandi visti alle lezioni. to Comandi visti alle lezioni.

#REDIRECT [[Comandi visti alle lezioni.]]

Comandi visti alle lezioni.

2013-11-08T10:05:36Z

Amonaldini: Amonaldini moved page Commandi visti alle lezioni. to Comandi visti alle lezioni.

mi sembra una buon idea fare una tabellina con commandi importanti visti alle lezioni, e una breve descrizione di che fanno e che parametri ricevono. non ne ho tutti scritti, allora mi raccomando- aggiungete pure!

ps- e' possibile fare una tabella?

at

cat- concatenare file

chmod- cambia mode

echo- stampa il testo

false- non fa niente

ln- linka tra due file (-s crea il link simbolico)

mkdir- crea una cartella

nologin- prevenire unpriviliggiati utenti di loggare al sistema

od

pwd- stampa l'indirizzio alla cartella in cui sono

touch- crea un file

true- non fa niente

umask

whoami- stampa l'id dell'utente

su- swicth user

----
Daniele F. & Federico A.

----

Abbiamo messo qualche comando con relativa descrizione, speriamo vi possano aiutare e che non ci siano troppi errori.

----

Informazioni e Aiuti:

* '''man''' ''file'' : (manual) apre il manuale, se esiste, alla pagina relativa a ''file''.
** '''man''' ''[-k]'' ''file'' : elenca tutte le pagine di manuale con la parola ''file''.
** '''man''' ''[n]'' ''file'' : apre la pagina relativa a ''file(n)''; (p.e. ''man 2 open'' apre la pagina relativa alla funzione (2) open).
* '''info''' ''file'' : apre il documento informativo relativo a 'file'.
* '''help''' ''[file]'' : visualizza alcuni comandi utili o informazioni su ''file''.

----

Comandi per Cartelle e File:

* '''ls''' ''[path]'' : (list) visualizza la lista dei file/directory nella directory corrente o nel path indicato.
** '''ls''' ''[-l]'' : visualizza la lista estesa (privilegi, n* hard link, proprietario, dimensione, ultima modifica, nome file/directory) dei file/directory nella directory corrente.
* '''pwd''' : (print working directory) visualizza il percorso della directory corrente.
* '''cd''' ''[path]'' : (change directory) entra nella directory specificata da ''path'' altrimenti torna al root dell'utente.
* '''rm''' ''file/dir'' : (remove) elimina ''file/dir''.
** '''rm''' ''[-Rf]'' ''file/path'' : elimina in modo ricorsivo e forzato i file e le directory nel ''path'' specificato.
* '''rmdir''' ''dir'' : (remove directory) elimina ''dir'' se vuota.
* '''mkdir''' ''dir'' : (make directory) crea la directory ''dir'' (può essere anche specificato un path).
* '''mv''' ''source'' ''dest'' : (move) muovi (o rinomina) il file ''source'' nel path ''dest''.
* '''touch''' ''file'' : crea ''file'' o se esiste già cambia la data di ultima modifica.
* '''ln''' ''target'' ''link'' : crea un link al file o directory ''target''.
** '''ln''' ''[-s]'' ''target'' ''link'' : (soft link) link simbolico.
** '''ln''' ''[-p]'' ''target'' ''link'' : (hard link) link fisico a file (non è possibile fare link a directory).

----

Comandi di Gestione e Analisi Sistema:

* '''ps ''' : (process status) visualizza il report dei processi attivi.
** '''pstree''' : visualizza l'albero dei processi attivi.
* '''df''' : (disk free) visualizza lo spazio occupato del disco dai file di sistema.
* '''du''' : (disk usage) visualizza una stima dell'utilizzo del disco di ogni singolo file/directory.
* '''groupadd''' ''group'' : crea il nuovo gruppo ''group''.
* '''useradd''' ''username'' : crea il nuovo utente ''username''.
* '''adduser''' ''username'' : crea il nuovo utente ''username'' (in maniera più veloce).
* '''groupdel''' ''group'' : elimina il gruppo indicato.
* '''userdel''' ''username'': elimina l'utente indicato.
* '''deluser''' ''username'': elimina l'utente indicato (in maniera più veloce).
* '''chmod''' ''par'' ''file'' : (change mode) modifica i privilegi di ''file'' tramite i valori/caratteri di ''par''.
* '''chown''' ''file'' : (change owner) cambia il proprietario e il gruppo di ''file''.
* '''chgrp''' ''group'' ''file'' : (change group) cambia il gruppo di ''file'' in ''group''.
* '''su''' ''[username]'' : (switch user) cambia utente.
* '''whoami''' : visualizza l'utente che usa il comando.

----

Comandi Ctrl:

* '''^S''' : sospende la visualizzazione.
* '''^Q''' : riattiva la visualizzazione.
* '''^C''' : cancella un'operazione.
* '''^D''' : fine del file.
* '''^V''' : tratta il carattere di controllo sequenze come se fosse carattere normale.

----

Comandi Vari:

* '''true''' : restituisce 0.
* '''false''' : restituisce 1.
* '''kill''' ''pid'' : termina il processo con id ''pid''.
* '''errno''' : (error number) ultimo errore restituito.
* '''strerror''' : (string error) stringa corrispondente all'ultimo errore.
* '''echo''' ''string'' : stampa a video ''string''.

----
[[User:Ferra1993|Ferra1993]] ([[User talk:Ferra1993|talk]]) 17:45, 7 November 2013 (CET)
| [[User:Fede|Fede]] ([[User talk:Fede|talk]]) 17:49, 7 November 2013 (CET)

Main Page

2013-11-08T10:05:21Z

Amonaldini: Undo revision 145 by Amonaldini (talk)

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizi a caso del Prof.]]

[[Python Programma tieni punteggio.]]

[[Commandi visti alle lezioni.]]

----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

Main Page

2013-11-08T10:01:43Z

Amonaldini: