Nmero: Nome:

LEIC/LERC 2013/14 - 1 Teste de Sistemas Operativos

23 de Novembro de 2011

Responda no enunciado, apenas no espao fornecido. Identifique todas as folhas.

Justifique todas as respostas. Durao: 1h30m

Grupo I [8 Val]

Considere a seguinte figura que ilustra um conjunto de transies do estado de processos em Unix.

1. [0.5 Val] Uma das transies representadas est errada. Indique qual. Justifique. Resposta: a transio B est errada, uma vez que um processo, para se bloquear, ter que estar em execuo.

2. [0.5 Val] Pressuponha que o processo est todo carregado em memria. Diga qual dos seguintes eventos pode gerar a transio etiquetada com a letra h:

1. O processo executa uma instruo do tipo test&set 2. O processo faz uma chamada ao sistema 3. O processo executa um GOTO 4. O processo incrementa o valor de uma varivel. 5. O processo chama a funo strcmp

Resposta: De todas as opes apresentadas, apenas a opo 2 (fazer uma chamada ao sistema) fora uma transio para execuo em modo ncleo.

3. [1 Val] Diga o que necessrio acontecer para que ocorra a transio etiquetada com a letra j. Resposta: Ser necessrio que o pai chame a funo wait ou termine.

Pgina 2 de 7

4. [1 Val] Diga o que necessrio acontecer para que ocorra a transio etiquetada com a letra e. Resposta: o processo termina o quantum ou um processo mais prioritrio fica executvel.

Considere o seguinte programa: #include #include main() { int i = 0; int pid = getpid(); printf ("mypid=%d, pid=%d, i=%d\n", getpid(), pid, i); for (i=1; i

Nmero: Pgina 3 de 7

3

Resposta: a funo que recalcula periodicamente a prioridade dos processos tem um custo linear com o nmero dos mesmos. Isto faz com que este escalonador tenha problemas de capacidade de escala.

Grupo II [7 Val]

Considere um restaurante do tipo self-service o qual disponibiliza os tabuleiros aos seus clientes. Os tabuleiros limpos existem num suporte tipo estante, numa pilha; de forma anloga, mas noutra pilha, os clientes depositam os tabuleiros sujos (depois de almoarem). A actividade de cada cliente, assim como a de cada empregado, representada por uma tarefa real, num sistema do tipo Unix/Linux. A pilha dos tabuleiros limpos acedida da seguinte forma (sempre na mesma extremidade da pilha, i.e. no topo): - cada cliente pode retirar um tabuleiro limpo da pilha; - os tabuleiros so retirados sempre do topo; - se no existirem tabuleiros limpos, o cliente deve aguardar que seja colocado na pilha um limpo; - havendo mais que um cliente espera de tabuleiros, deve ser respeitada a ordem de chegada dos clientes; - em qualquer instante, o empregado pode colocar um novo tabuleiro na pilha; - se o empregado tenta colocar um novo tabuleiro limpo e a pilha est cheia, o empregado desiste e volta mais tarde. Existe um outro suporte, similar ao usado para os tabuleiros limpos, i.e. em formato pilha, na qual os clientes colocam os tabuleiros sujos depois de almoarem. A pilha dos tabuleiros sujos acedida da seguinte forma (sempre na mesma extremidade da pilha, i.e. no topo): - cada cliente pode colocar um tabuleiro sujo na pilha; - os tabuleiros so colocados sempre no topo (i.e. por cima do anterior); - se no houver espao para colocar um tabuleiro sujo, o cliente deve aguardar que surja espao para tal (na sequncia da actividade do empregado, ver item seguinte); - em qualquer instante, o empregado pode retirar um tabuleiro sujo da pilha (do topo desta); - se o empregado tenta retirar um tabuleiro sujo e a pilha est vazia, o empregado desiste e volta mais tarde. Considere o pseudo-cdigo seguinte, que no possui cdigo de sincronizao. #define MAX_LIMPOS 100 #define MAX_SUJOS 50 tabuleiro_t *t_limpos[MAX_LIMPOS]; // de index 0 a index MAX_LIMPOS-1 tabuleiro_t *t_sujos[MAX_SUJOS]; // de index 0 a index MAX_SUJOS-1 // situao inicial: existem MAX_LIMPOS tabuleiros limpos na pilha int index_limpos = MAX_LIMPOS-1; // situao inicial: existem zero tabuleiros sujos na pilha int index_sujos = 0; /* cliente retira tabuleiro limpo da pilha */ 00 tabuleiro_t*

/* empregado coloca tabuleiro limpo na pilha */ 13 empregadoColocaTabuleiroLimpo

Pgina 4 de 7

clienteRetiraTabuleiroLimpo() 01 { 02 tabuleiro_t *t; 03 04 t = t_limpos[index_limpos]; 05 index_limpos--; 06 return t; 07 }

(tabuleiro_t* t) 14 { 15 index_limpos++; 16 t_limpos[index_limpos]=t; 17 }

/* cliente devolve tabuleiro sujo */ 08 clienteDevolveTabuleiroSujo(tabuleiro_t *t) 09 { 10 t_sujos[index_sujos] = t; 11 index_sujos++; 12 }

/* empregado retira tabuleiro sujo da pilha */ 18 tabuleiro_t* empregadoRetiraTabuleiroSujo() 19 { 20 tabuleiro_t *t; 21 22 index_sujos--; 23 t = t_sujos[index_sujos]; 24 return t; 25 }

1. [1 Val] Diga se o cdigo acima permite o cenrio seguinte: dois clientes podem agarrar o mesmo

tabuleiro limpo. Justifique a sua resposta sendo muito claro nas instrues que so executadas (ou no) e em que circunstncias.

Resposta: considerem-se dois clientes C1 e C2 e o t_limpos cheio. C1 executa o cdigo at a linha 04 e perde o processador. C2 ganha o processador executa a funo at ao fim retira o tabuleiro que est no topo. C1 retoma o processador e executa as linhas 05/06, retornando o mesmo tabuleiro.

2. [1 Val] Diga se o cdigo acima permite o cenrio seguinte: um cliente, ao tentar agarrar um tabuleiro limpo, caso no existam tabuleiros limpos, fica a aguardar que tal acontea (i.e. que o empregado coloque tabuleiros limpos na pilha). Justifique a sua resposta sendo muito claro nas instrues que so executadas (ou no) e em que circunstncias.

Resposta: no cdigo, o cliente retira sempre um tabuleiro sem fazer qualquer teste e sem nunca esperar. Caso no existam tabuleiros, os limites do vector so simplesmente violados.

Considere que possui semforos com contador, que pode inicializar com o valor que desejar (0-N), e sobre os quais pode executar operaes de esperar (uma unidade) e assinalar (uma unidade). Use um ou mais semforos deste tipo para responder s perguntas seguintes.

3. [2 Val] Escreva uma nova verso dos procedimentos clienteRetiraTabuleiroLimpo e

empregadoColocaTabuleiroLimpo que respeite o enunciado. No se esquea de declarar e inicializar todas as variveis que considerar necessrias.

Resposta: Semforo mutex_limpos = new Semforo (1); //iniciado com 1 unidade Semforo sem_limpos = new Semforo (MAX_LIMPOS); //iniciado com MAX_LIMPOS unidades /* cliente retira tabuleiro limpo da pilha */ tabuleiro_t* clienteRetiraTabuleiroLimpo() { tabuleiro_t *t; esperar (sem_limpos);

Nmero: Pgina 5 de 7

5

esperar (mutex_limpos); t = t_limpos[index_limpos]; index_limpos--; assinalar (mutex_limpos); return t; } /* empregado coloca tabuleiro limpo na pilha */ empregadoColocaTabuleiroLimpo (tabuleiro_t* t) { esperar (mutex limpos); if (index_limpos < MAX_LIMPOS-1) { index_limpos++; t_limpos[index_limpos]=t; assinalar (sem_limpos); } assinalar (mutex_limpos); } 4. [2 Val] Escreva uma nova verso dos procedimentos clienteDevolveTabuleiroSujo e

empregadoRetiraTabuleiroSujo que respeite o enunciado. No se esquea de declarar e inicializar todas as variveis que considerar necessrias. Resposta:

Semforo mutex_sujos = new Semforo (1); //iniciado com 1 unidade Semforo sem_sujos = new Semforo (MAX_SUJOS); //iniciado com MAX_SUJOS unidades

/* cliente devolve tabuleiro sujo */ clienteDevolveTabuleiroSujo(tabuleiro_t *t) { esperar (sem_sujos); esperar (mutex_sujos); t_sujos[index_sujos] = t; index_sujos++; assinalar (mutex_sujos); } /* empregado retira tabuleiro sujo da pilha */ tabuleiro_t* empregadoRetiraTabuleiroSujo() { tabuleiro_t *t; esperar (mutex_sujos); if (index_sujos > 0) { index_sujos--;

t = t_sujos[index_sujos]; assinalar (sem_sujos); } else t = NULL; assinalar (mutex_sujos); return t; }

Pgina 6 de 7

5. [1 Val] Considere agora que um empregado, em vez de retirar um tabuleiro sujo de cada vez (da respectiva pilha), retira todos os tabuleiros sujos existentes. Escreva uma nova verso do procedimento empregadoRetiraTabuleiroSujo.

tabuleiro_t** empregadoRetiraTabuleiroSujo() { tabuleiro_t **pt; esperar (mutex_sujos); if (index_sujos > 0) { pt = (tabuleiro_t**) malloc (ndex_sujos*sizeof(tabuleiro *t)); while (index_sujos) { index_sujos--;

pt[index_sujos] = t_sujos[index_sujos]; assinalar (sem_sujos); } } else pt = NULL; assinalar (mutex_sujos); return pt; }

Grupo III [5 Val]

1. [1 Val] Considere o sistema de ficheiro do MS-DOS que usa uma FAT. Considere que cada bloco de 4K e um ficheiro A cujo primeiro bloco o bloco 1000 ? Considere o seguinte segmento da FAT:

ndice 999 1001 ndice 1000 1004 ndice 1001 1003 ndice 1002 EOF ndice 1003 1002 ndice 1004 1006 ndice 1005 EOF ndice 1006 1005

Qual o tamanho do ficheiro A? Resposta: o ficheiro possui os blocos 1000, 1004, 1006, 1005. Logo ter um tamanho superior a 12K e inferior a 16K.

Considere o sistema de ficheiros Linux e o estado da tabela de ficheiros abertos, assim como os inodes representados na figura seguinte (a figura apresenta as primeiras entradas da index table do inode). Assuma que o tamanho do bloco de 4K.

Nmero: Pgina 7 de 7

7

2. [1 Val] Os nomes dos ficheiros so guardados nos inodes ou nos blocos? Justifique.

Resposta: o nomes dos ficheiros esto nas directorias. O contedo das directorias guardado nos blocos de dados dos ficheiros do tipo directoria. Os inodes no guardam os nomes do ficheiro.

3. [1 Val] Se o processo p1 executar read(0, buff, 1) que bloco ser lido? Justifique.

Resposta: o offset est na posio 5000, que corresponde a um byte que est no segundo bloco. Na tabela de ndices do inode correspondente podemos ver que este bloco o 3456.

4. [1 Val] Se o processo p2 executar read(0, buff, 1) que bloco ser lido? Justifique.

Resposta: o fd 0 de P2 partilha a mesma entrada do fd 0 de P1. Logo ser na mesma o bloco 3456.

5. [1 Val] Se o processo p1 executar write(1, buff, 1) que bloco ser escrito? Justifique, explicando que passos o sistema operativo necessita de tomar neste caso.

Resposta: o processo P1 s tem um ficheiro aberto, correspondente ao fd 0. Logo a chamada ir retornar um erro.