Teorie:

1. Ce rezulta din: $echo 1.{0..9} (+explicati)

Afiseaza: 1.0 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9
Afiseaza numerele intre cele 2 capete din paranteze, pe fiecare concatenand-ul cu “1.”

2. Efectul $(command1,command2) > file. Explicati

$(command1) întoarce rezultatul rulării ca text. $(command1,command2) - eroare?

(command1;command2) - se executa secvential. Rezultatul concatenat al comenzilor 1 și 2 (stdout fără
erori) se salvează/redirectioneaza in file

3. Ce rezulta din: $echo A1{1..2}{3..5} (+explicati)

Afiseaza: A113 A114 A115 A123 A124 A125

Afiseaza de fiecare data “A1”. Apoi ia primul numar din prima paranteza + fiecare numar din a 2-a
paranteza; repeat

4. Rezultatul $echo a{A{1,2},B{3,4}}b. Explicati

aA1b aA2b aB3b aB4b

5. Scrieți comanda ls care afișează toate numele de directoare din directorul /proc ce reprezintă
imaginea unui proces pe disc (numele directorului conține doar cifre):

ls /proc -p | grep ^[0-9]+/$

6. $ mkdir 200{7.9}-0{1..9};ls
2007-01 2007-02....
2008-01 2008-02...

7. Rezultatul comenzii: ls test[0-9]? va fi :

test01 test02 test03 ….. test10 test11

8. ls -lR/home/student | grep “.tar.gz” | uniq | wc -l => aflam nr total de linii care contin .tar.gz

ls -l => afiseaza din director informatia extensa (nume fisier, data, …. Dimensiunea)
-R => permite o parcurgere recursive
grep => filtrare la nivel de linie
uniq => ne asiguram ca toate liniile sunt unice
wc -l => numara toate liniile

9. grep ‘^guest:’ /etc/passwd || useradd guest

cauta in /etc/passwd toate intrarile care incep cu guest: iar daca userul nu exista il adauga.

10. grep “\< cu \ >” text – liniile care contin cuvantul cu

--------------------------------------------------------------------------------------------------------------------------------
 11. awk /do*/ ‘ {print $1 “:” $2 }’ lista – proceseaza liniile care incep cu do sau doar do; primul cuvant e
separat de al 2-lea prin :
Output: dorel : 10
dorin : 8
12. : cat /etc/passwd | grep ‘bash $ ‘ |awk ‘BEGIN {FS = “:”} {print NR “:” $1 “ ” $NF}’

output: 1: root /bin/bash

2: mysql /bin/bash ….

13. $ ls -l fisiere

-rw-rw-r-- 1 student student 40 March 3 20:20 list…..

$ ls -l fisiere | awk ‘BEGIN { total = 0 } {total += $5 } END {print “Total: “total } ‘
Output: Total: 413
Calculeaza suma de pe randul 5 (care e dimensiunea fisierelor) a tuturor fisierelor

14. (Redirectarea) Ce rezulta din: wc -l *.c */*.c 2>/dev/null (+explicati)

wc -l -> afiseaza numarul total de linii din fiecare fisier, si un total de linii (daca e specificat mai mult de 1
fisier)

*.c */*.c -> ia toate fisierele cu terminatia .c din folderul curent, apoi intra in toate folderele si ia toate
fisierele cu terminatia .c

2>/dev/null -> redirecteaza toate erorile de iesire aparute spre /dev/null

15. $command > file 2> &1

Rezultatul comenzii (stdout fără erori) se salvează/se redirectioneaza in file, iar 2>
redirectioneaza fisierul de erori în fișierul de ieșire

16. $ command> /dev/fd/60 2>/dev/fd/61

Redirecteaza iesirea comenzii “command” in /dev/fd/60 a carei iesire de eroare o redirecteaza
catre d/dev/fd/61

17. Ce rezulta din: $(CC) $(CFLAGS) -c $< (+explicati)

Vom folosi pentru a compila un fisier C

$(CC) -> program pentru compilarea programelor C; default ‘cc’

$(CFLAGS) -> flag-uri extra trimise compilatorului C

18. (MACRO) SRCS = def.c cauta.c calc.c

$ls${SRCS:.c=.0}

rezultatul va fi: def.o cauta.o calc.o

Algoritmul utilizat pentru substituþie este urmãtorul: se evalueazã expresia ${SRCS}
apoi se cautã sirul de caractere ce urmeazã în definitie dupã caracterul ‘:’ si este înlocuit cu sirul de
caractere de dupã semnul ‘=’.

19. ${OBJS}
&{CC} -o $@ ${OBJS} {LIB}
Tinta exemplu depinde de {OBJS}, cand se face evaluarea se vor inlocui cu valorile propriu zise.
Delimitatorul : separa numele tintei de lista de dependenta
A 2-a linie – comanda se executa daca cel putin una de pe linie e out of date (linia incepe cu un TAB)

20. .cpp.o:
$(CC) $(FLAGS) $< -o $@
regula generala
.cpp.o - regula magică, sa nu nu scrie același nume de fișier pt fișierele cu extensia .o
$(CC) - compilator C
$(FLAGS) - argumentele compilatorului
$< - lista de dependențe, lista fișierelor de intrare (cazul dat, fișierul cpp)
$@ - numele fișierului target/obiect
test : test.o
Regula generala care indica cum compilez un fisier obiect din fișier cpp cu același nume

21. $(PROJ):$(OBJS)
tlink $(LDSTART) $(OBJS)
Aceasta directiva macro creeaza link-ul referit in $(PROJ) din fisierele obiect referite in $(OBJS)
folosind linker-ul tlink. Prin $(LDSTART) sunt definite flaguri suplimentare.

22. $(EXE) : $(OBJS) $(LIB)

$(LD) -o $@ $(OBJS)
EXE - nume executabil
OBJS - Fisiere obiect; ${SRCC: .c -> .o}
SRCC - ex: main.c, info.c, dependency.c
LD = Apelul linker-ului din sistem, ex: $(CC)
CC = gcc - C compiler
$@ = Numele fișierului target $(EXE)
LIB = biblioteca
Directiva make
target: dependente
instructiuni
Linkeaza fisierele obiect din $(OBJS) si produce executabil din $(EXE) în cazul care data
modificării unui fisier obiect e mai recentă decat data fișierului executabil.

23. clean:
-$(RM) -f $(EXE) $(OBJS)

Target clean, executat prin make clean, șterge fisierele exe si obj. Șterge doar din directorul curent.
Prin conventie, trebuie definit clean
Thread
 ➔ Efectul următoarei secvențe de cod: (argumentati)

int main(void)
{
int i;
pthread_create(...);
pthread_create(...);
pthread_join(...); //garantăm ca firul si-a încheiat execuția, așteaptă ca un fir de execuție s-a
terminat
i++;
}

Programul va crea 2 fire de execuție, va aștepta ca un fir sa se încheie cu pthread_join si va

implementa i++
5. Completați următoarea secvență de cod if(global_var){
astfel încât P1 trimite un semnal SIGUSR1 lui P2, //variabila globala
la primirea semnalului P2 va trimite un mesaj rescrisa de SIGUSR1
prin pipe către P3:
write(descriptor[1], &mesaj,
void handler(int sig){ sizeof(mesaj));
global_var = 1;
} close(descriptor[1]);
main(){
signal(SIGUSR1, handler); if ( waitpid(ppid, &status, 0) == -1 ) {
int descriptor[2];
pipe(descriptor); perror("waitpid failed");
pid_t id = fork();
if(id) { return EXIT_FAILURE;
//P1
kill(id, SIGUSR1); }
if ( waitpid(id, &status, 0) == -1 ) { return EXIT_SUCCESS;
perror("waitpid }
failed"); }
return EXIT_FAILURE; }
} else {
return EXIT_SUCCESS; //P3
} else { close(descriptor[1]);
char mesaj[20] = “Mesaj”; read(descriptor[0], &mesaj, sizeof(mesaj));
pid_t ppid = fork();
if(ppid) { close(descriptor[0]);
//P2 return EXIT_SUCCESS;
close(descriptor[0]); }
while(1){ }
}
5. Completati următoarea secvența de cod pid_t pid1, pid2;
astfel incat P3 să-și încheie execuția doar cand void handler(sigNum)
primește un semnal SIGUSR1 de la P2, de {
asemenea nu trebuie ca în sistem sa ramana exit(0);
procese zombie: }
main(){
pid_t val, val2;
int main()
if(val=fork()){
if(val2=fork()){ {
//P1 if(pid1=fork())
} else { {
//P2 if(pid2=fork())
} {//P1
} else { exit(0);
//P3 }
} else
} {//P2
wait(10);
kill((int)getppid(),SIGUSR1);
exit(0);
}
}
else
{//P3
signal(SIGUSR1,handler);
while(1);
}
return 0;
}
5. Pipes: pid_c = fork();
pipe(channel_ab); if (pid_c > 0) \\
pid_b = fork(); {

if (pid_b > 0) /* Still process B. Receive messages from A

using channel_ab[0], send messages to C using
{ channel_bc[1]. */
/* Process A... Send messages to B using close(channel_bc[0]);
channel_ab[1] */
msg_size = read(channel_ab[0], buffer, size);
close(channel_ab[0]);
write(channel_bc[1], msg, size);
write(channel_ab[1], msg, size);
} else if (pid_c == 0) {
} else if (pid_b == 0) {
/* Process C. Receive messages from B using
/* Process B */ channel_bc[0]. */
close(channel_ab[1]); msg_size = read(channel_bc[0], buffer, size);
}
pipe(channel_bc); }

6. Thread care sa afiseze mesaj invers: fprintf(stderr,"first thread error\n");

//funcþia ce va fi executatã de thread-uri exit(1);
void* print_message( void *ptr ){ }

char *message; // “adoarme” procesul pãrinte pentru o secundã.

message = (char *) ptr; sleep(1);
printf("%s ", message); // creearea celui de al doilea thread – tipãreºte
World
return NULL;
if(pthread_create( &thread2, NULL,
} &print_message,
int main(){ (void*)message2)){
pthread_t thread1, thread2; fprintf(stderr,"second thread error\n");
char *message1 = "Hello"; exit(1);
char *message2 = "World\n"; }
// creearea primului thread – tipãreºte Hello sleep(1);
if (pthread_create( &thread1, NULL, exit(0);
&print_message,
}
(void*)message1)){
‘pwd’ ls -l => fisierele din directorul curent

$ => pentru a accesa variabila

${data[10]} – returneaza valoarea stocata in sirul data la pozitia 10
echo ${#sir[*]} - aflam lungimea sirului
echo ${#sir[@]} – aflam lungimea sirului

Grep
grep ‘^student’ /etc/password - toate liniile care incep cu student
grep ‘bin/bash $’ /etc/password - toate liniile care se termina cu bin/bash
grep ‘^$’ /etc/password - toate liniile goale se vor afisa
grep “\< cu \ >” text – liniile care contin cuvantul cu

Variabile Predefinite

NF – nr de campuri de pe linia curenta

NR – nr inregistrarii (1, 2….)
FS – separatorul de camp

LDFLAGS – macro ce nu continue nici o valoare

Rm = rm – pentru a sterge fisiere
#clear - curatam continutul
$< - numele fisierului current care a fost match-uit

make all – compileaza toate fisierele executabile

make install – copiaza in directorul de instalare toate resursele, fisierele executabile
Redirectarea iesirii si a intrarii:

● Creare a unui fisier prin care iesirea standard a comenzii cat este redirectata catre fisierul ce va fi
creat. Caracterul > ce aer rol de a indica redirectarea iesirii standard catre o alta comanda.
○ $ cat > text
● Indica redirectarea iesirii standard catre o alta comanda in cazul fisierelor, datele vor fi
concatenate la sfarsitul fisierului.
○ $ ls -l /usr.bin >> text
● Redirectarea iesirii de eroare>
○ & ls /usr/bin 2>text.err
● Redirectarea intrarii standard
○ $ wc -l < /etc/passwd