PDF de programación - Capítulo 19. Estructura de los sistemas de ficheros

Capítulo 19. Estructura de los sistemas de
ficheros

19.1. Objetivos

Indagar la estuctura de sistemas de ficheros en disco. Use la máquina virtual que usó en la práctica
anterior.

19.2. Documentación de las transparencias

Las transparencias relevantes para realizar esta práctica son:
- Páginas 22-25 de las transparencias de Unix

19.3. Ficheros dispersos (con agujeros)

En muchos sistemas de ficheros no es necesario que tengan espacio asignado los bloques (unidades
de asignación de espacio en disco) que sólo contienen ceros. Estos bloques no asignados se
denominan agujeros. Demuéstrelo con este pequeño programa (ponagujero.c)1, viendo la longitud
del fichero que crea con ls -l fichero y viendo lo que ocupa con du fichero (en unidades de 1k2
). También puede usar ls -ls fichero para ver todo.

#define _FILE_OFFSET_BITS 64
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <locale.h>

static char *p;

static void uso(void) { fprintf(stderr, "Uso:\n

%s f n\n", p); exit(1); }

static void error(void) { perror(p); exit(errno); }

int main(int argc, char *argv[]) {

int fd;
p= argv[0];
if (argc != 3) uso();
setlocale(LC_ALL, "");
if ((fd = open(argv[1], O_WRONLY | O_CREAT | O_TRUNC, 0666))<0) error();;
char dato=’!’;
if (lseek(fd, atoll(argv[2]), SEEK_SET)<0) error();
if (write(fd, &dato, 1)<1) error();
exit(0);

}

Por ejemplo

./ponagujero f10000 10000

1

Capítulo 19. Estructura de los sistemas de ficheros

ls -l f10000
du f10000
ls -ls f10000

19.4. Uso de disco

Utilice el programa ponagujero para ver lo que ocurre para cada sistema de ficheros creados en la
práctica de Administración de discos:

• ¿Qué ficheros se han podido crear? ¿Qué sistema de ficheros permite ficheros más grandes?
• De los que se han podido crear, ¿cuanto disco usan? ¿por qué?
Ejercítelo al menos con segundo parámetro igual a 1, 1000, 10000, 100000, 1000000, 10000000,
100000000, 1000000000 y 10000000000, examinando el fichero generado. Puede usar este
programilla, creaficheros.sh, para ir más deprisa:

#!/bin/bash

for sf in msdos minix ext3 ext4-1k ext4-2k ext4-4k
do

for long in 1 1000 10000 100000 1000000 10000000 100000000 1000000000 10000000000 100000000000 1000000000000
do

echo Probando $long en $sf
./ponagujero /mnt/$sf/f$long $long
ls -ls /mnt/$sf/f$long

done

done

Repita el experimento con ponagujero2.c (modifique creaficheros.sh para automatizarlo).

#define _FILE_OFFSET_BITS 64
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <locale.h>

static char *p;

static void uso(void) { fprintf(stderr, "Uso:\n

%s f n\n", p); exit(1); }

static void error(void) { perror(p); exit(errno); }

int main(int argc, char *argv[]) {

int fd;
p= argv[0];
if (argc != 3) uso();
setlocale(LC_ALL, "");
if ((fd = open(argv[1], O_WRONLY | O_CREAT | O_TRUNC, 0666))<0) error();;
char dato=’!’;
if (write(fd, &dato, 1)<1) error();
if (lseek(fd, atoll(argv[2]), SEEK_SET)<0) error();

2

Capítulo 19. Estructura de los sistemas de ficheros

if (write(fd, &dato, 1)<1) error();
exit(0);

}

19.5. Copia creando agujeros
Observe que este programa de copia (cpaguj.c):

#define TAMANO 1024

#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <locale.h>

static char *p;
static void uso(void) { fprintf(stderr, "Uso:\n
static void error(void) { perror(p); exit(errno); }

%s orig dest\n", p); exit(1); }

int main(int argc, char* argv[]) {

char buf[TAMANO];
int leidos, escritos, origen, destino, i;
size_t longitud= 0;
p= argv[0];
if (argc != 3) uso();
setlocale(LC_ALL, "");
if ((origen = open(argv[1], O_RDONLY)) < 0) error();
if ((destino = open(argv[2], O_CREAT|O_WRONLY|O_TRUNC, 0644)) < 0) error();
for (;;) {

if ((leidos = read(origen, buf, TAMANO)) < 0) error();
longitud += leidos;
if (leidos > 0) {

for (i= 0; (buf[i]==0) && (i<leidos); i++);
if (i == leidos) { if (lseek(destino, leidos, SEEK_CUR) < 0) error(); }
else { if ((escritos = write(destino, buf, leidos)) < leidos) error(); }

}
else {

if (ftruncate(destino, longitud) < 0) error();
close(origen);
close(destino);
exit(0);

}

}

}

crea agujeros, si puede, cuando encuentra secuencias de ceros, cosa que cpsimple (de la práctica de
entrada/salida básica) no hace. Observe también que el programa cp del sistema también lo hace (al
menos con la opción --sparse=always).
Haga una copia del fichero f1000000 con distintos programas de copia de ficheros, cpsimple,
cpaguj y cp sobre distintos tipos de sistemas de archivos (ext3 y ext4). Compare el uso de disco
entre el origen y el destino de la copia completando la tabla de la sección de resultados pedidos.
Puede usar este programilla, copiaficheros.sh, para ir más deprisa:

3

Capítulo 19. Estructura de los sistemas de ficheros

#!/bin/bash

PATH=$PATH:.:../es_basica
f=f1000000

for sf in ext3 ext4-1k
do

d=/mnt/$sf
$d/$f $d/x1
cpsimple
$d/$f $d/x2
cpaguj
cpaguj
$d/x1 $d/x3
cp --sparse=always $d/$f $d/x4
cp --sparse=always $d/x1 $d/x5
du
$d/$f $d/x?

done

19.6. Ficheros ofrecidos

En el directorio usodisco:

• ponagujero.c.
• ponagujero2.c.
• creaficheros.sh.
• copiaficheros.sh.
• cpaguj.sh.

19.7. Resultados pedidos

• Para cada uno de los sistemas de ficheros complete las tablas siguientes con el tamaño y el uso de

disco de los ficheros creados (si se han podido crear sin error; en caso contrario no ponga nada).
Justifique brevemente los resultados indicando si se crean los ficheros y si tienen agujeros o no.

ponagujero msdos

minix

ext3

ext4-1k

ext4-2k

ext4-4k

1
1000
10000
100000
1000000
10000000
100000000
1000000000

4

ponagujero msdos

minix

ext3

ext4-1k

ext4-2k

ext4-4k

Capítulo 19. Estructura de los sistemas de ficheros

10000000000

100000000000

1000000000000

ponagujero2msdos

minix

ext3

ext4-1k

ext4-2k

ext4-4k

1
1000
10000
100000
1000000
10000000
100000000
1000000000
10000000000

100000000000

1000000000000

• Para cada los sistemas de ficheros ext3 y ext4-1k complete las tablas siguientes con el uso de disco

del origen y destino de la copia. Justifique brevemente los resultados. Use strace para ver las
diferencias entre cpaguj y cp.

operación en ext3
cpsimple
/mnt/ext3/f1000000
/mnt/ext3/x1
cpaguj /mnt/ext3/f1000000
/mnt/ext3/x2
cpaguj /mnt/ext3/x1
/mnt/ext3/x3
cp --sparse=always
/mnt/ext3/f1000000
/mnt/ext3/x4
cp --sparse=always
/mnt/ext3/x1
/mnt/ext3/x5

operación en ext4-1k
cpsimple
/mnt/ext4-1k/f1000000
/mnt/ext4-1k/x1

origen

destino

origen

destino

5

Capítulo 19. Estructura de los sistemas de ficheros

origen

destino

operación en ext4-1k
cpaguj
/mnt/ext4-1k/f1000000
/mnt/ext4-1k/x2
cpaguj /mnt/ext4-1k/x1
/mnt/ext4-1k/x3
cp --sparse=always
/mnt/ext4-1k/f1000000
/mnt/ext4-1k/x4
cp --sparse=always
/mnt/ext4-1k/x1
/mnt/ext4-1k/x5

Notas

1. El tipo off_t es de 32 bits por defecto. Puede hacerse de 64 bits si definimos previamente en el

código la macro _FILE_OFFSET_BITS como 64, que es lo que hace el programa.

2. El manual puede decir que son de 512 bytes, lo que no es cierto en el laboratorio. Puede forzarlo
con la opción -k. En cambio stat sí reporta el uso en unidades de 512 octetos. Ambos los llaman
bloques, pero no tienen que ver ni con la unidad de asignación de espacio, ni con la de
transferencia.

6