Disponemos de un disco duro de 20 GB de capacidad. Hay establecida sobre él, una única partición que contiene un sistema de ficheros del tipo FAT32 en el que cada agrupamiento (cluster) consta de 16 sectores de 512 bytes cada uno. ¿Cuántos sectores del disco se necesitarán para almacenar cada copia la FAT? Razona tu respuesta.
En primer lugar se calcula lo que ocupa la FAT, que es el tama˜no del enlace
(32 bits) por el n´umero de entradas de la tabla que, a su vez, es el tama˜no del
disco dividido por el tama˜no del agrupamiento y que en este problema son
20GB/(16 ∗ 512bytes) = 20 ∗ 217 entradas. Luego la tabla ocupa 20 ∗ 217 ∗ 32bits = 20 ∗ 219 bytes.
Si se divide lo que ocupa la tabla por el tama˜no del agrupamiento se obtiene
el n´umero de agrupamientos que ocupa la tabla: 20 ∗ 219/(16 ∗ 512) = 20 ∗26 = 1280 agrupamientos, que multiplicado por 16, que es el n´umero de
sectores por agrupamiento, se obtiene el n´umero total de sectores que es
20480.
La policía ha arrestado al sospechoso de un delito. Al analizar el contenido de su ordenador piensan que pueden inculparle pues el contenido del mismo
es el siguiente:
Número De bloque de datos | Contenido |
10 | He |
11 | Sido |
12 | Yo |
13 | No |
14 | Sigan |
15 | Buscando |
Como experto informático, pides consultar el contenido de la FAT, que es el siguiente:
Número de entrada en la FAT | Contenido |
10 | 11 |
11 | EOF |
12 | 13 |
13 | 10 |
14 | 15 |
15 | 12 |
¿Apoyarías la opinión de la policía? Razona tu respuesta.
En un sistema de archivos FAT, los bloques se asignan como una lista enlazada
que finaliza con la posici´on fin de lista EOF. Es posible recuperar
datos utilizando los enlaces partiendo desde esa posici´on EOF hacia atr´as.
La reconstrucci´on de la lista de bloques ser´a:
14 → 15 → 12 → 13 → 10 → 11 → EOF
La informaci´on de esa lista de bloques ser´a:
sigan → buscando → yo → no → he → sido → EOF
#include <stdio.h>
#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>
#include <unistd.h>
#include <stdbool.h>
#define MAX 10
#define FIN -1
int
sem t huecos, elementos;
int generar dato (void) { return random() %256;} int numero aleatorio(void) { return random() %100;}void ∗productor (void ∗p) {int
int
n= numero aleatorio();
printf ("Productor con %d datos\n", n);
for
sem wait (&huecos);
buffer[pos productor]= dato;
pos productor= (pos productor+ 1) %MAX;
sem post (&elementos);
}
buffer[pos productor]= FIN;
sem post (&elementos);
pthread exit (NULL);
}void ∗consumidor(void ∗p){int
bool
while
dato= buffer[pos consumidor];
sem post (&huecos);
if
continuar= false;
else
pos consumidor= (pos consumidor+1) %MAX;
}
}pthread exit (NULL);
}int main (int argc, char ∗argv[]) {pthread t hiloproductor, hiloconsumidor;
sem init (&elementos, 0, 0);
sem init (&huecos, 0, MAX);
pthread create (&hiloproductor, NULL, productor, NULL);
pthread create (&hiloconsumidor, NULL, consumidor, NULL);
pthread join (hiloproductor, NULL);
pthread join (hiloconsumidor, NULL);
sem destroy (&huecos);
sem destroy (&elementos);
return
}0;{ printf ("Numero aleatorio: %d\n", dato);(dato== FIN)(continuar) { sem wait (&elementos);continuar= true;pos consumidor= 0, dato;sem wait (&huecos);(num= 0; num< n; num++) { dato= generar dato();num, dato, n;pos productor= 0;buffer[MAX];
