El sistema de archivos de la computadora es fat ntfs. sistemas de archivos La estructura del sistema de archivos. Sistemas de archivos FAT

1. Estructura del sector FSInfo struct fat_boot_fsinfo:
   • __u32 firma1– firma 0x41615252;
   • __u32 firma2– firma 0x61417272;
   • __u32 free_clusters es el número de clústeres libres. Si el campo contiene -1, la búsqueda de clústeres libres debe comenzar desde el número de clúster 2.
2. Estructura de entrada de directorio de nombre corto struct msdos_dir_entry:
   • __s8 nombre,ext– nombre y extensión del archivo;
   • __u8 atributo– atributos de archivo;
   • __u8 ctime_ms– este campo especifica el tiempo de creación del archivo hasta ms (solo se usa FAT32);
   • __u16 ctime– tiempo de creación del archivo (solo se usa FAT32);
   • __u16 cfecha– fecha de creación del archivo (solo se utiliza FAT32);
   • fecha __u16– fecha del último acceso al archivo (solo se utiliza FAT32);
   • __u16 comienza– 16 bits superiores del número del primer grupo del archivo (solo se usa FAT32);
   • __u16hora,fecha,inicio– hora y fecha de creación del archivo, número del primer grupo de archivos;
   • tamaño __u32– tamaño del archivo (en bytes).
3. Estructura de entrada de directorio de nombre largo:
   • identificación __u8– número de elemento;
   • __u8 nombre0_4- caracteres 1 - 5 del nombre;
   • __u8 atributo– atributos de archivo;
   • __u8 alias_checksum– suma de comprobación del nombre abreviado;
   • __u8 nombre5_10- caracteres 6 - 11 del nombre;
   • __u8 nombre11_12- caracteres 12 - 13 del nombre.

Continuemos con la consideración de la implementación de software del algoritmo y determinemos el nombre de la partición en la que se creó el sistema de archivos FAT16:

#ifndef FAT16_PART_NAME

#define FAT16_PART_NAME "/dev/hda1"

#terminara si

Estructuras Globales:

estructura fat_boot_sector fbs; // estructura del sector de arranque

estructura msdos_dir_entry entrada; // estructura del elemento del directorio

Variables globales:

U16 *gordo16; // copia la tabla FAT16 aquí

U16 sector_tamaño; // tamaño del sector (de FAT16)

U16 dir_entradas; // número de descriptores de 32 bytes

// en el directorio raíz (0 para FAT32)

sectores U16; // número total de sectores en la partición

U32 gordo16_tamaño; // tamaño FAT16

U32 raíz_tamaño; // tamaño del directorio raíz

U16 byte_por_clúster; // tamaño del clúster en bytes

U16 siguiente_cluster; // siguiente grupo en la cadena

grasa int;

Comencemos con la función principal:

int principal()

numero int;

Establecemos el nombre completo del archivo cuyo contenido queremos leer. Permítame recordarle que solo trabajamos con nombres de archivo cortos. El procedimiento para trabajar con nombres largos no se trata en este artículo.

U8 *ruta_completa = "/Carpeta1/Carpeta2/texto.txt";

Abra el archivo del dispositivo:

Duro = abierto (FAT16_PART_NAME, O_RDONLY);

Si (difícil< 0) {

error (FAT16_PART_NAME);

Salir(-1);

Leemos los primeros 10 clusters del archivo. La lectura se realiza mediante la función fat16_read_file(). Los parámetros de la función son el nombre completo del archivo y el número de clústeres para leer. La función devuelve el número de clústeres leídos o -1 si se produjo un error durante la lectura:

Num = fat16_read_file(ruta_completa, 10);

Si (numero< 0) perror("fat16_read_file");

Else printf("Leer %d clústeres ", num);

Cierre el archivo del dispositivo y salga:

cerrar (duro);

devolver 0;

La función para leer grupos de archivos es la siguiente:

int fat16_read_file(__u8 *ruta_completa, número int)

Estructura split_name sn; // estructura para almacenar las partes componentes del archivo

U8 tmp_nombre_buff; // búfer para almacenamiento temporal de elementos compuestos de la ruta completa del archivo

int estático i = 1;

int n;

U8 *tmp_buff;

U16 start_cluster, next_cluster;

Enumeramos los parámetros de la función al considerar la función principal.

Operaciones preparatorias: restablezca el búfer tmp_name_buff y la estructura struct split_name sn:

El primer carácter en un nombre de ruta absoluto de un archivo debe ser una barra diagonal (/). Vamos a ver:

Lea el sector de arranque de la partición:

Si (leer_fbs ()< 0) return -1;

El sector de arranque de lectura ahora está en la estructura global struct fat_boot_sector fbs. Copie de esta estructura el tamaño del sector, el número de entradas en el directorio raíz y el número total de sectores en la partición:

Determine el tamaño del clúster en bytes:

Byte_per_cluster = fbs.cluster_size * 512

Vamos a mostrar la información en el sector de arranque:

Printf("Id del sistema - %s ", fbs.system_id);

Printf("Tamaño del sector - %d ", tamaño_sector);

Printf("Tamaño del clúster - %d ", fbs.cluster_size);

Printf("Reservado - %d ", fbs.reservado);

Printf("Número de FAT - %d ",fbs.fats);

Printf("Dir entradas - %d ", dir_entries);

Printf("Sectores - %d ", sectores);

Printf("Medios - 0x%X ", fbs.medios);

Printf("FAT16 longitud - %u ", fbs.fat_length);

Printf("Total de secta - %u ", fbs.total_sect);

Printf("Byte por clúster - %d ", byte_per_cluster);

Calculamos el tamaño de FAT16 en bytes y lo leemos:

fat16_size = fbs.fat_length * 512;

Si (leer_fat16 ()< 0) return -1;

Leyendo el directorio raíz:

Si (leer_raíz_dentry()< 0) return -1;

El puntero dir_entry ahora está posicionado en el área de memoria que contiene las entradas del directorio raíz. El tamaño de esta área de memoria es igual al tamaño del directorio raíz (root_size).

Guarde (para control) el contenido del directorio raíz en un archivo separado:

#ifdef DEPURAR

cerrar (gordo);

#terminara si

Calcule el comienzo del área de datos:

data_start = 512 * fbs.reservado + fat16_size * fbs.fats + root_size;

Con todas las entradas en el directorio raíz, podemos acceder al contenido del archivo test.txt. Para ello, organizamos un ciclo. En el cuerpo del ciclo, analizaremos el nombre completo del archivo, resaltando sus elementos: subdirectorios (tenemos dos de ellos, Carpeta1 y Carpeta2) y el nombre del archivo deseado (test.txt).

mientras(1) (

Memset(tmp_name_buff, 0, NOMBRE_CORTO);

Memset((void *)&sn, 0, sizeof(struct split_name));

Para(n = 0 ; n< SHORT_NAME; n++, i++) {

If((tmp_name_buff[n] == "/") || (tmp_name_buff[n] == "?")) (

Yo++;

descanso;

tmp_name_buff[n] = "?";

Rellenamos la estructura struct split_name sn con la información adecuada. El llenado se realiza mediante la función split_name, y se verifica que el nombre del archivo cumpla con el formato "8.3":

< 0) {

printf("nombre no valido");

devolver -1;

Para cada elemento del nombre completo del archivo, determinamos el grupo inicial. Para hacer esto, buscamos en los elementos del directorio (comenzando desde la raíz) una entrada correspondiente al elemento de nombre completo y leemos esta entrada. El procedimiento de búsqueda se realiza mediante la función get_dentry():

If(get_entry(&sn)< 0) {

Printf("¡No hay tal archivo!");

devolver -1;

Comprobación de los atributos del archivo. Si es un directorio, lea su contenido y continúe el ciclo:

Si (dentry.attr & 0x10) (

If(read_directory(dentry.start)< 0) return -1;

Seguir;

Si se trata de un archivo, leemos los primeros num clusters. Para control, la información leída se guardará en un archivo separado:

Si (dentry.attr & 0x20) (

Start_cluster = dentry.start;

tmp_buff = (__u8 *) malloc (byte_per_cluster); // el contenido del clúster se leerá aquí

N = abierto("clúster", O_CREAT|O_RDWR, 0600); // guarda la información leída en este archivo

Si (n< 0) {

error("abrir");

devolver -1;

Para leer los clusters del archivo, organizamos un bucle:

Para(i = 0; yo< num; i++) {

Leemos el contenido del clúster en el búfer tmp_buff y lo guardamos en un archivo separado:

< 0) return -1;

< 0) {

error("escribir");

cerrar(n);

devolver -1;

Leemos de FAT16 el número del siguiente clúster ocupado por este archivo. Si este es el último grupo, rompemos el bucle y volvemos a la función principal:

#ifdef DEPURAR

Printf("OK. Leer");

Printf("siguiente clúster del archivo - 0x%X .. ", siguiente_clúster);

#terminara si

Si (próximo_clúster == EOF_FAT16) (

#ifdef DEPURAR

Printf("último grupo. ");

#terminara si

Gratis (tmp_buff);

cerrar(n);

Retorna ++i;

#ifdef DEPURAR

printf("dejar de leer");

#terminara si

Devolver yo;

El sector de arranque FAT16 es leído por la función read_fbs(). El resultado se coloca en la estructura global de fbs:

int leer_fbs()

Si (leer (duro, (__u8 *) y fbs, tamaño de (fbs))< 0) return -1;

devolver 0;

La lectura de la tabla de asignación de archivos del sistema de archivos FAT16 se realiza mediante la función read_fat16():

int read_fat16()

U64 buscar = (__u64)(fbs.reservado) * 512; // desplazamiento a FAT16 desde el comienzo de la partición

Fat16 = (vacío *) malloc (fat16_size);

Si (pred64 (duro, (__u8 *) fat16, fat16_size, buscar)< 0) return -1;

devolver 0;

El directorio raíz es leído por la función read_root_dentry():

int read_root_dentry()

U64 buscar = (__u64)fbs.reservado * 512 + fat16_size * fbs.fats; // desplazamiento al directorio raíz desde el principio de la sección

Root_size = 32 * dir_entries; // calcular el tamaño del directorio raíz

entrada_dir = (__u8 *)malloc(tamaño_raíz);

Si (!dir_entry) devuelve -1;

Memset(dir_entry, 0, root_size);

If(pred64(hard, dir_entry, root_size, seek)< 0) return -1;

devolver 0;

La lectura de un clúster que pertenece a un archivo se realiza mediante la función read_cluster(). Los parámetros de entrada de la función son el número de clúster cluster_num y un puntero al búfer __u8 *tmp_buff donde se debe colocar el resultado de la lectura. El desplazamiento al clúster en la partición se calcula mediante la fórmula (ver):

BUSCAR = DATA_START + (CLUSTER_NUM - 2) * BYTE_PER_CLUSTER,

• BUSCAR– desplazamiento a un clúster en una partición
• DATA_START– inicio del área de datos
• CLUSTER_NUM– número de secuencia del grupo
• BYTE_PER_CLUSTER– tamaño del clúster en bytes

int read_cluster(__u16 cluster_num, __u8 *tmp_buff)

U64 buscar = (__u64)(byte_per_cluster) * (cluster_num - 2) + data_start; // calcular el desplazamiento al clúster

< 0) return -1;

devolver 0;

La función read_directory lee las entradas de un directorio (no la raíz) y coloca el resultado en el área de memoria a la que apunta el puntero dir_entry:

int read_directory(__u16 start_cluster)

Int i = 1;

U16 siguiente_cluster;

Para(; ;i++) (

Asignamos memoria para almacenar el contenido del directorio, leemos el contenido del clúster inicial y obtenemos el valor del siguiente clúster de la tabla FAT16:

Si (!dir_entry) devuelve -1;

< 0) return -1;

Siguiente_cluster = fat16;

Guardemos el contenido del directorio en un archivo separado (para control):

#ifdef DEPURAR

Printf("Próximo clúster - 0x%X ", next_cluster);

Grasa = abrir("dir16", O_CREAT|O_WRONLY, 0600);

Write(fat, dir_entry, root_size);

cerrar (gordo);

#terminara si

Si se alcanza el último clúster, salga del ciclo; de lo contrario, continúe leyendo el directorio aumentando el tamaño del búfer dir_entry en un clúster más:

Si (next_cluster & EOF_FAT16) se rompe;

start_cluster = next_cluster;

devolver 0;

La función get_dentry() realiza una búsqueda en el contenido del directorio de un elemento correspondiente al archivo buscado. Los parámetros de entrada de esta función son un puntero a una estructura struct split_name *sn que contiene los elementos del nombre de archivo corto:

Int i = 0;

El búfer global dir_entry contiene una serie de entradas de directorio en las que vamos a buscar una entrada de archivo (o directorio). Para la búsqueda organizamos un ciclo. En el cuerpo del ciclo, copiamos los elementos del catálogo a la estructura de entrada global y comparamos el valor de los campos name y ext de esta estructura con los campos correspondientes de la estructura struct split_name *sn. La coincidencia de estos campos significa que hemos encontrado una entrada del archivo deseado en la matriz de elementos del directorio:

para(; ; i++) (

If(!(memcmp(dentry.name, sn->name, sn->name_len)) &&

!(memcmp(dentry.ext, sn->ext, sn->ext_len)))

descanso;

If(!dentry.nombre) devuelve -1;

#ifdef DEPURAR

Printf("nombre - %s ", dentry.nombre);

Printf("iniciar clúster - 0x%X ", dentry.start);

Printf("tamaño del archivo - %u ", dentry.size);

Printf("atrib archivo - 0x%X ", dentry.attr);

#terminara si

devolver 0;

Todo el código anterior se encuentra en el directorio FAT16, archivo fat16.c. Para obtener el módulo ejecutable, creemos un Makefile con el siguiente contenido:

INCDIR = /usr/src/linux/include

PHONY=limpio

Fat16: fat16.o división.o

Gcc -I$(INCDIR) $^ -g -o [correo electrónico protegido]

%.o: %.c

Gcc -I$(INCDIR) -DDEBUG -c $^

limpio:

Rm -f *.o

Rm -f ./fat16

Implementación de software del algoritmo para leer un archivo desde una partición lógica con el sistema de archivos FAT12

En general, el algoritmo para leer un archivo de una partición FAT12 es idéntico al algoritmo para leer un archivo de una partición FAT16. La diferencia radica en el procedimiento de lectura de elementos de la tabla FAT12. Consideramos la tabla FAT16 como una matriz simple de elementos de 16 bits. Para leer los elementos de la tabla FAT12 se propone el siguiente algoritmo:

• multiplicar el número del elemento por 1,5;
• extraer una palabra de 16 bits de FAT utilizando el resultado de la operación anterior como compensación;
• si el número de elemento es par, realice una operación AND en la palabra leída y enmascare 0x0FFF. Si el número es impar, desplace la palabra leída de la tabla 4 bits hacia los bits menos significativos.

En base a este algoritmo, implementamos la función de lectura de elementos de la tabla FAT12:

int get_cluster(__u16 cluster_num)

U16 busca;

grupo U16;

Calculamos el desplazamiento en la tabla FAT12 y leemos una palabra de 16 bits de la tabla:

Buscar = (cluster_num * 3) / 2;

Memcpy((__u8 *)&clust, (__u8 *)(fat12 + buscar), 2);

Si el número de inicio del clúster es un número par, desplazamos el valor leído de la tabla 4 bits hacia los dígitos menos significativos, si es impar, lo sumamos con 0x0FFF:

If(cluster_num % 2) cluster >>= 4;

De lo contrario, clúster &= 0x0FFF;

Este fragmento también se puede implementar en ensamblador:

" xorw %%ax, %%ax "

"por cierto $0, %%cx"

"jnc 1f"

" Shrw $4, %%dx "

"jmp2f"

"1: andw $0x0FFF, %%dx"

"2: mover %%dx, %%ax "

:"=a" (siguiente)

:"d" (clúster), "c" (núm_clúster));

Devolvemos el resultado:

grupo de retorno;

Echemos un vistazo más de cerca al algoritmo en sí. Suponga que se ha creado un archivo en una partición FAT12 que ocupa los clústeres 9 y 10. Cada elemento FAT12 es de 12 bits. Porque leemos elementos de 16 bits de la tabla, luego el desplazamiento al noveno elemento será igual a 13 bytes (9 * 1.5 = 13, descarte el resto), mientras que los 4 bits inferiores pertenecerán al octavo elemento FAT. Deben descartarse, y para ello basta desplazar el elemento leído 4 bits hacia los bits inferiores, que proporciona el algoritmo. El desplazamiento al elemento 10 será de 15 bytes, y los 4 bits altos pertenecerán al elemento 11 de la FAT. Para descartarlos, es necesario realizar una operación AND sobre el elemento 10 y la máscara 0x0FFF, que también corresponde al algoritmo anterior.

Los textos fuente del módulo para leer un archivo de una partición FAT12 se encuentran en el directorio FAT12, archivo fat12.c.

Implementación de software del algoritmo para leer un archivo desde una partición lógica con el sistema de archivos FAT32

El algoritmo para leer un archivo de una partición con el sistema de archivos FAT32 es prácticamente el mismo que para FAT16, excepto que en FAT32 el directorio raíz puede ubicarse en cualquier parte de la partición y tener un tamaño arbitrario. Por lo tanto, para hacerlo más interesante, compliquemos la tarea: supongamos que solo conocemos el número de la partición con el sistema de archivos FAT32. Para leer información de esta partición, primero debe determinar sus coordenadas: el desplazamiento de la partición desde el principio del disco. Y para esto necesitas tener una idea sobre la estructura lógica del disco duro.

La estructura lógica del disco duro.

Consideremos la estructura lógica de un disco duro que corresponde al estándar de Microsoft - "partición principal - partición extendida - particiones que no son DOS".

El espacio del disco duro se puede organizar en una o más particiones, y las particiones pueden contener una o más unidades lógicas.

En el disco duro en la dirección física 0-0-1 se encuentra el registro de arranque maestro (Master Boot Record, MBR). La estructura MBR contiene los siguientes elementos:

• cargador de arranque que no es del sistema (arranque que no es del sistema - NSB);
• tabla de descripción de partición de disco (tabla de partición, tabla de partición, PT). Se encuentra en el MBR en el desplazamiento 0x1BE y ocupa 64 bytes;
• Firma MBR. Los dos últimos bytes del MBR deben contener el número 0xAA55.

La tabla de particiones describe la ubicación y las características de las particiones en el disco duro. Las particiones de disco pueden ser de dos tipos: primaria (principal, principal) y extendida (extendida). El número máximo de particiones primarias es cuatro. La presencia de al menos una partición primaria en el disco es obligatoria. Una partición extendida se puede dividir en una gran cantidad de subsecciones: unidades lógicas. En la Tabla 7 se presenta una estructura simplificada del MBR. La tabla de particiones se encuentra al final del MBR, se asignan 16 bytes para describir la partición en la tabla.

Tabla 7. Estructura MBR

Parcialidad Tamaño, bytes 0 446 0x1BE 16 0x1CE 16 0x1DE 16 0x1EE 16 0x1FE 2

La estructura de entrada de la tabla de particiones se muestra en la Tabla 8.

Tabla 8. Estructura de la entrada de la tabla de particiones

El primer byte en el elemento de sección es el indicador de actividad de la sección (0 - inactivo, 0x80 - activo). Sirve para determinar si la partición es una partición de inicio del sistema y si es necesario iniciar el sistema operativo desde ella cuando se inicia la computadora. Solo una sección puede estar activa. El indicador de actividad de la partición va seguido de las coordenadas del comienzo de la partición: tres bytes, que indican el número de cabeza, el número de sector y el número de cilindro. Los números de cilindro y sector se dan en el formato de interrupción Int 0x13, es decir los bits 0-5 contienen el número de sector, los bits 6-7 son los dos bits más significativos del número de cilindro de 10 bits, los bits 8-15 son los ocho bits menos significativos del número de cilindro. Luego sigue el código identificador ID del sistema, que indica que esta partición pertenece a uno u otro sistema operativo. El identificador ocupa un byte. Detrás del identificador del sistema están las coordenadas del final de la sección: tres bytes que contienen los números de la cabeza, el sector y el cilindro, respectivamente. Los siguientes cuatro bytes son el número de sectores antes de la partición y los últimos cuatro bytes son el tamaño de la partición en sectores.

Por lo tanto, un elemento de tabla de partición se puede describir usando la siguiente estructura:

estructura pt_struct(

U8 de arranque; // indicador de actividad de la sección

U8 parte_inicio; // coordenadas del inicio de la sección

U8 tipo_parte; // identificador del sistema

U8 extremo_parte; // coordenadas del final de la sección

U32 sect_antes; // número de sectores antes de la partición

U32 sect_total; // tamaño de partición en sectores (número de sectores en la partición)

El elemento de la partición primaria apunta inmediatamente al sector de arranque del disco lógico (siempre hay un solo disco lógico en la partición primaria), y el elemento de la partición extendida apunta a la lista de discos lógicos formados por estructuras denominadas secundarias. MBR (MBR secundario, SMBR).

Cada disco en una partición extendida tiene su propio bloque SMBR. SMBR tiene una estructura similar a MBR, pero no tiene un registro de inicio (lleno de ceros) y solo se usan dos de los cuatro campos de descripción de partición. El primer elemento de la partición apunta a la unidad lógica, el segundo elemento apunta a la siguiente estructura SMBR de la lista. El último SMBR de la lista contiene el código de sección cero en el segundo elemento.

Volvamos a la consideración del módulo para leer un archivo de una partición FAT32.

Archivos de encabezado:

#incluir

#incluir

#incluir

#incluir

#incluir

Firma MBR:

#define FIRMA 0xAA55

Archivo del dispositivo del que se leerá la información de la partición:

#define DISPOSITIVO "/dev/hda"

Tamaño de entrada de la tabla de particiones (16 bytes):

#define PT_SIZE 0x10

La siguiente matriz de estructuras asigna el código de tipo de una sección a su asignación de caracteres:

tipos de sistemas de estructuras (

U8 part_type;

U8 *nombre_parte;

estructura systypes i386_sys_types = (

(0x00, "Vacío"),

(0x01, "FAT12"),

(0x04, "FAT16<32M"},

(0x05, "Extendido"),

(0x06, "FAT16"),

(0x0b, "Win95 FAT32"),

(0x0c, "Win95 FAT32 (LBA)"),

(0x0e, "Win95 FAT16 (LBA)"),

(0x0f, "Win95 Ext"d (LBA)"),

(0x82, "intercambio de Linux"),

(0x83, Linux)

(0x85, "Linux extendido"),

(0x07, HPFS/NTFS)

Determinemos la cantidad de elementos en la matriz i386_sys_types usando la macro PART_NUM:

#define PART_NUM (tamaño de (i386_sys_types) / tamaño de (i386_sys_types))

Establezca un límite en el número de unidades lógicas:

#definir MAX_PART 20

La siguiente matriz de estructura contendrá información sobre las unidades lógicas en el dispositivo (disco duro):

estructura pt_struct(

U8 de arranque;

U8 parte_inicio;

U8 tipo_parte;

U8 extremo_parte;

U32 sect_antes;

U32 sect_total;

)pt_t;

interior; // descriptor de archivo del dispositivo

U8mbr; // cuenta MBR aquí

El número de la partición en la que se creó el sistema de archivos FAT32:

#definir FAT32_PART_NUM 5

Sector de arranque, sector FSInfo y estructuras de entrada de directorio (definidas en el archivo ):

estructura fat_boot_sector fbs;

estructura fat_boot_fsinfo fsinfo;

estructura msdos_dir_entry entrada;

U32 *fat32 = NULO; // copia la tabla FAT32 aquí

U16 sector_tamaño; // tamaño del sector (de FAT32)

U16 dir_entradas; // 0 para FAT32

sectores U16; // número de sectores por partición

U32 fat32_size; // tamaño FAT32

U32 inicio_datos; // inicio del area de datos

U16 byte_por_clúster; // cuántos bytes hay en el clúster (tamaño del clúster en bytes)

U32 siguiente_cluster; // siguiente grupo en la cadena

U32 clúster_raíz; // Clúster ROOT - clúster inicial del directorio raíz

U8 *dir_entrada = NULL; // puntero a las entradas del directorio

U64 inicio_búsqueda = 0; // comienza el desplazamiento a la sección (en bytes)

Función principal:

int principal()

numero int = 0;

int núm_clúster = 5; // cuantos clusters leer del archivo

U8 *ruta_completa = "/Carpeta1/Carpeta2/léame"; // archivo a leer

Abrimos el dispositivo, obtenemos información sobre la tabla de particiones en el dispositivo y mostramos información sobre las particiones:

Duro = abierto (DEV_NAME, O_RDONLY);

Si (difícil< 0) {

error(DEV_NOMBRE);

Salir(-1);

Si (get_pt_info (duro)< 0) {

error("get_pt_info");

Salir(-1);

Mostrar_pt_info();

Calcule el desplazamiento inicial de la partición:

Start_seek = (__u64)(pt_t.sect_before) * 512;

Lea los grupos que pertenecen al archivo:

Num = fat32_read_file(ruta_completa, cluster_num);

Si (numero< 0) perror("fat32_read_file");

Else printf("Leer %d clústeres\n", num);

cerrar (duro);

devolver 0;

La función get_pt_info() lee la información sobre la tabla de particiones:

int get_pt_info (int duro)

Int i = 0;

U64 buscar;

Leemos la tabla de particiones del MBR y verificamos la firma:

Read_main_ptable(difícil);

Si (marcar_firmar()< 0) {

Printf("¡Firma no válida!\n");

devolver -1;

Estamos buscando el identificador de la sección extendida. Si hay uno, calculamos el desplazamiento a la partición extendida y leemos información sobre las unidades lógicas:

para(;yo< 4; i++) {

Si ((pt_t[i].type_part == 0xF) || \

(pt_t[i].type_part == 0x5) || \

(pt_t[i].type_part == 0x0C)) (

Buscar = (__u64)pt_t[i].sect_before * 512;

Read_ext_ptable(difícil, buscar);

descanso;

devolver 0;

Función de lectura de la tabla de particiones read_main_ptable():

void read_main_ptable(int duro)

Si (leer (duro, mbr, 512)< 0) {

error("leer");

cerrar (duro);

Salir(-1);

Memset((vacío *)pt_t, 0, (PT_SIZE * 4));

Memcpy((void *)pt_t, mbr + 0x1BE, (PT_SIZE * 4));

devolver;

Función de verificación de firma check_sign():

int check_sign()

signo U16 = 0;

Memcpy((void *)&sign, (void *)(mbr + 0x1FE), 2);

#ifdef DEPURAR

Printf("Firma - 0x%X\n", signo);

#terminara si

If(firma != FIRMA) devuelve -1;

devolver 0;

Función de lectura de tabla de partición extendida:

void read_ext_ptable(int duro, __u64 buscar)

numero int = 4; // a partir de esta posición, la matriz de estructuras pt_t se llenará con información sobre las unidades lógicas

U8 sonido;

Datos de entrada:

• difícil– descriptor de archivo de dispositivo;
• buscar– desplazamiento a la partición extendida desde el principio del disco (en bytes).

Para obtener información sobre los discos lógicos, organizamos un bucle:

Para(;;num++) (

Leemos el SMBR ubicado en el desplazamiento de búsqueda desde el comienzo del disco:

conjunto de memoria ((vacío *) smbr, 0, 512);

pred64 (duro, smbr, 512, buscar);

Rellenamos dos elementos de la tabla pt_t, empezando por la posición num. El primer elemento apuntará a la unidad lógica y el segundo elemento apuntará a la siguiente estructura SMBR:

Memset((vacío *)&pt_t, 0, PT_SIZE * 2);

Memcpy((void *)&pt_t, smbr + 0x1BE, PT_SIZE * 2);

Hacemos una modificación en el campo "Número del sector inicial": la cuenta regresiva es desde el comienzo del disco:

Pt_t.sect_before += (buscar / 512);

Si el código de tipo de partición es cero, entonces no hay más discos lógicos:

Si (! (pt_t.type_part)) romper;

Calcule el desplazamiento al siguiente SMBR:

Buscar = ((__u64)(pt_t.sect_before + pt_t.sect_total)) * 512;

devolver;

La función show_pt_info() muestra información sobre las unidades lógicas encontradas en el dispositivo:

vacío show_pt_info()

Int i = 0, n;

#ifdef DEPURAR

Printf("Número de particiones en disco - %d\n", PART_NUM);

#terminara si

para(; yo< MAX_PART; i++) {

If(!pt_t[i].type_part) break;

Printf("\nTipo de partición %d - ", i);

Para (n = 0; n< PART_NUM; n++) {

If(pt_t[i].type_part == i386_sys_types[n].part_type) (

Printf("%s\n", i386_sys_types[n].part_name);

descanso;

If(n == PART_NUM) printf("tipo desconocido\n");

Printf("Indicador de arranque - 0x%X\n", pt_t[i].arrancable);

Printf("Sectores en la sección %d - %d\n", i, pt_t[i].sect_total);

Printf("Sectores antes de la sección %d - %d\n\n", i, pt_t[i].sect_before);

devolver;

La lectura de grupos de archivos de una partición FAT32 se realiza mediante la función fat32_read_file(). Esta función tiene mucho en común con la función fat16_read_file(), así que vea el punto 6 para obtener comentarios detallados:

int fat32_read_file(__u8 *ruta_completa, número int)

Estructura split_name sn;

U8 tmp_nombre_buff;

Int i = 1, n;

U32 start_cluster, next_cluster;

U8 *tmp_buff;

Operaciones preparatorias: borre el búfer, la estructura y verifique la primera barra:

Memset(tmp_name_buff, 0, NOMBRE_CORTO);

Memset((void *)&sn, 0, sizeof(struct split_name));

If(ruta_completa != "/") devuelve -1;

Lectura del sector de arranque:

Si (leer_fbs ()< 0) return -1;

Memcpy((void *)§or_size, (void *)fbs.sector_size, 2);

Memcpy((void *)&dir_entries, (void *)fbs.dir_entries, 2);

Memcpy((void *)§ors, (void *)fbs.sectors, 2);

Leemos la estructura FSInfo y mostramos la firma en ella:

Si (leer_fs_info ()< 0) return -1;

Printf("Firma1 - 0x%X\n", fsinfo.firma1);

Printf("Firma2 - 0x%X\n", fsinfo.firma2);

Fat32_size = fbs.fat32_length * 512; // Tamaño FAT32 en bytes

data_start = 512 * fbs.reservado + fat32_size * 2; // inicio del campo de datos

Byte_per_cluster = fbs.cluster_size * 512; // tamaño del clúster en bytes

grupo_raíz = fbs.grupo_raíz; // número de clúster del directorio raíz

Leer FAT32:

Si (leer_fat32 ()< 0) return -1;

Asigne memoria para las entradas del directorio:

Dir_entry = (__u8 *)malloc(byte_per_cluster);

Si (!dir_entry) devuelve -1;

Leyendo el directorio raíz:

If(read_directory(root_cluster)< 0) return -1;

Analizamos la ruta completa del archivo y separamos cada elemento en componentes:

mientras(1) (

Memset(tmp_name_buff, 0, NOMBRE_CORTO);

Memset((void *)&sn, 0, sizeof(struct split_name));

Para(n = 0 ; n< SHORT_NAME; n++, i++) {

tmp_name_buff[n] = ruta_completa[i];

If((tmp_name_buff[n] == "/") || (tmp_name_buff[n] == "\0")) (

Yo++;

descanso;

tmp_name_buff[n] = "\0";

Si (nombre_dividido(tmp_nombre_buff, &sn)< 0) {

Printf("nombre no valido\n");

devolver -1;

If(get_entry(&sn)< 0) {

Printf("¡No hay tal archivo!\n");

devolver -1;

Para obtener el número de inicio del clúster en el sistema de archivos FAT32, debe usar la palabra alta del primer número de clúster del archivo: el campo starthi de la estructura dentry:

Start_cluster = (((__u32)dentry.starthi<< 16) | dentry.start);

Comprobando el byte de atributo:

If(dentry.attr & 0x10) ( // este es un directorio

If(read_directory(start_cluster)< 0) return -1;

Seguir;

If(dentry.attr & 0x20) ( // y este es un archivo

tmp_buff = (__u8 *) malloc (byte_per_cluster);

N = abierto("clúster", O_CREAT|O_RDWR, 0600);

Si (n< 0) {

error("abrir");

devolver -1;

Printf("primer cluster del archivo - 0x%X .. ", start_cluster);

Para(i = 0; yo< num; i++) {

Memset(tmp_buff, 0, byte_per_cluster);

If(read_cluster(start_cluster, tmp_buff)< 0) return -1;

Si (escribir (n, tmp_buff, byte_per_cluster)< 0) {

error("escribir");

devolver -1;

Si (próximo_clúster == EOF_FAT32) (

Gratis (tmp_buff);

cerrar(n);

Retorna ++i;

start_cluster = next_cluster;

Devolver yo;

El propósito de las tres funciones siguientes es obtener el contenido del área del sistema, es decir, sector de arranque, estructura FSInfo y tabla FAT32:

1) la función read_fbs() lee el sector de arranque:

int leer_fbs()

Si (pred64 (duro, (__u8 *) y fbs, tamaño de (fbs), start_seek)< 0) return -1;

devolver 0;

2) la función read_fs_info() lee la estructura FSInfo:

int leer_fs_info()

U64 buscar = (__u64)fbs.info_sector * 512 + start_seek;

If(pred64(hard, (__u8 *)&fsinfo, sizeof(fsinfo), buscar)< 0) return -1;

devolver 0;

3) la función read_fat32() lee la tabla FAT32:

int read_fat32()

U64 buscar = (__u64)fbs.reservado * 512 + start_seek;

Fat32 = (vacío *) malloc (fat32_size);

Si (! fat32) devuelve -1;

Si (pred64 (duro, (__u8 *) fat32, fat32_size, buscar)< 0) return -1;

devolver 0;

La función read_cluster() lee el clúster con el número especificado:

int read_cluster(__u32 cluster_num, __u8 *tmp_buff)

U64 buscar = (__u64)(byte_per_cluster) * (cluster_num - 2) + data_start + start_seek;

Si (pred64 (duro, tmp_buff, byte_per_cluster, buscar)< 0) return -1;

devolver 0;

La lectura de directorios (incluido el directorio raíz) está a cargo de la función read_directory():

int read_directory(__u32 start_cluster)

Int i = 2;

U32 siguiente_cluster;

Los parámetros de función son el clúster de catálogo inicial. Leemos el contenido del directorio en el búfer global dir_entry:

If(read_cluster(start_cluster, dir_entry)< 0) return -1;

Siguiente_cluster = fat32;

Si el directorio ocupa un clúster, salga; de lo contrario, aumente el tamaño de la memoria y continúe leyendo:

Para(; ;i++) (

start_cluster = next_cluster;

Dir_entry = (__u8 *)realloc(dir_entry, i * byte_per_cluster);

Si (!dir_entry) devuelve -1;

If(read_cluster(start_cluster, (dir_entry + (i - 1) * byte_per_cluster))< 0) return -1;

Siguiente_cluster = fat32;

If((next_cluster == EOF_FAT32) || (next_cluster == 0xFFFFFF8)) devuelve 0;

devolver 0;

La última función que veremos busca en el contenido de un directorio un elemento que coincida con el archivo que estamos buscando:

int get_dentry(struct split_name *sn)

Int i = 0;

El puntero dir_entry se establece en un área de memoria que contiene una serie de entradas de directorio en las que vamos a buscar un archivo (o directorio). Para buscar, organizamos un bucle y colocamos la entrada encontrada en la estructura de entrada global:

Para(;;i++) (

Memcpy((void *)&dentry, dir_entry + i * sizeof(dentry), sizeof(entry));

If(!(memcmp(dentry.name, sn->name, sn->name_len)) &&

!(memcmp(dentry.ext, sn->ext, sn->ext_len)))

descanso;

If(!dentry.nombre) devuelve -1;

devolver 0;

Esto concluye nuestra consideración del módulo para leer un archivo desde una partición FAT32.

El código fuente del módulo se encuentra en el directorio FAT32, archivo fat32.c.

Diferencias en la organización del almacenamiento de registros sobre archivos en directorios para sistemas de archivos FAT y EXT2

Algunas palabras sobre las diferencias en la organización del almacenamiento de registros sobre archivos en directorios para sistemas de archivos FAT y EXT2. La estructura del sistema de archivos EXT2 se ha tratado en .

Nos acabamos de familiarizar con FAT: en él, todos los elementos del directorio tienen un valor fijo. Al crear un archivo, el controlador del sistema de archivos busca la primera posición vacía y la llena con información sobre el archivo. Si la longitud del directorio no cabe en un clúster, se le asigna otro clúster, y así sucesivamente.

Considere cómo están las cosas en EXT2.

Supongamos que tenemos una partición con el sistema de archivos EXT2, el tamaño del bloque es de 4096 bytes. En esta sección, creamos un directorio. El tamaño del directorio será igual al tamaño del bloque: 4096 bytes. En el directorio, el sistema operativo crea inmediatamente dos entradas: una entrada para el directorio actual y una entrada para el directorio principal. La entrada del directorio actual ocupará 12 bytes, mientras que la entrada del directorio principal tendrá una longitud de 4084 bytes. Vamos a crear un archivo en este directorio. Después de eso, habrá tres entradas en el directorio: la entrada del directorio actual tiene una longitud de 12 bytes, la entrada del directorio principal ya tiene una longitud de 12 bytes y la creación archivo dado longitud, como probablemente hayas adivinado, 4072 bytes. Si eliminamos el archivo creado, la longitud de la entrada del directorio principal aumentará nuevamente a 4084 bytes.

Por lo tanto, al crear un archivo, el controlador del sistema de archivos EXT2 busca en el directorio una entrada de la longitud máxima y la divide, asignando espacio para una nueva entrada. Bueno, si todavía no hay suficiente espacio, se asigna un bloque más para el directorio y la longitud del directorio se vuelve igual a 8192 bytes.

Y en conclusión, una pequeña edición del artículo "Arquitectura del sistema de archivos EXT2".

Esta edición se refiere a la función get_i_num() para determinar el número de inodo del nombre del archivo. La versión anterior de esta función se veía así:

int get_i_num(char *nombre)

int i = 0, rec_len = 0;

Estructura ext2_dir_entry_2dent;

para(; yo< 700; i++) {

If(!memcmp(dent.name, name, dent.name_len)) break;

Rec_len += dent.rec_len;

Regresa dent.inode;

Versión corregida:

int get_i_num(char *nombre)

* Parámetro de función - nombre de archivo. El valor devuelto es el número de inodo del archivo.

int rec_len = 0;

Estructura ext2_dir_entry_2dent; // esta estructura describe el formato de la entrada del directorio raíz:

* El buff de búfer global contiene una matriz de entradas de directorio. Para determinar el número de inodo de un archivo, necesita encontrar

* en esta matriz hay una entrada con el nombre de este archivo. Para ello, organizamos un ciclo:

Para(;;) (

/* Copiar las entradas del directorio en la estructura dent: */

Memcpy((void *)&dent, (buff + rec_len), sizeof(dent));

* Una longitud de nombre de archivo de cero significa que hemos iterado sobre todas las entradas del directorio

* y no se encontraron entradas con el nombre de nuestro archivo. Así que es hora de volver:

If(!dent.name_len) devuelve -1;

/* La búsqueda se realiza comparando nombres de archivo. Si los nombres coinciden, salga del bucle: */

If(!memcmp(dent.name, name, strlen(name))) break;

/* Si los nombres no coinciden, pasa a la siguiente entrada: */

Rec_len += dent.rec_len;

/* Si tiene éxito, devuelve el número de inodo del archivo: */

Regresa dent.inode;

Literatura:

1. V.Kulakov. Programación a nivel de hardware: una referencia especial. 2ª ed. / - San Petersburgo: Peter, 2003 - 848 p.
2. A.V.Gordeev, A.Yu.Molchanov. sistémico software/ - San Petersburgo: Pedro - 2002
3. Meshkov V. Arquitectura del sistema de archivos ext2. - Revista "Administrador del sistema", No. 11 (12), noviembre de 2003 - 26-32 p.

En contacto con

Hay muchas formas de almacenar información y programas en un disco duro. Un sistema muy conocido que guarda diversa información en forma de archivos, agrupándolos en carpetas con una asignación única. Sin embargo, pocas personas pensaron en cómo se lleva a cabo realmente el almacenamiento físico de la información en los medios.

Para que la información se almacene en un medio físico, debe estar preparada para su uso en un sistema operativo de computadora. Sistema operativo asigna un área libre del disco para guardar información. Para hacer esto, debe dividir el disco en pequeños contenedores: sectores. Al formatear un disco a un nivel bajo, se asigna un tamaño determinado a cada sector. El sistema operativo agrupa estos sectores en clústeres. El formato de nivel superior establece todos los clústeres en el mismo tamaño, normalmente entre 2 y 16 sectores. En el futuro, se asignarán uno o más clústeres para cada archivo. El tamaño del clúster depende del sistema operativo, la capacidad del disco y la velocidad requerida.

Además del área para almacenar archivos en el disco, existen áreas necesarias para el funcionamiento del sistema operativo. Estas áreas están diseñadas para almacenar información de arranque e información para asignar direcciones de archivos a ubicaciones físicas en el disco. El área de arranque se utiliza para iniciar el sistema operativo. Después de cargar el BIOS, se lee y ejecuta el área de arranque del disco para iniciar el sistema operativo.

sistema de archivos FAT

El sistema de archivos FAT apareció con el sistema operativo Microsoft DOS, después de lo cual se mejoró varias veces. Tiene versiones FAT12, FAT16 y FAT32. El propio nombre FAT proviene del uso que hace el sistema de archivos de un tipo de base de datos en forma de "tabla de asignación de archivos" (Tabla de asignación de archivos), que contiene una entrada para cada grupo en el disco. Los números de versión se refieren al número de bits utilizados en los números de elementos de la tabla. Por lo tanto, el sistema de archivos tiene un límite en el tamaño de disco admitido. En 1987, no admitía discos de más de 32 MB. Con la llegada de Windows 95 salió una nueva version Sistema de archivos FAT32 con soporte teórico para discos de hasta 2 TB. Aparecen problemas persistentes con el soporte de discos grandes debido a la cantidad fija de elementos, limitada por la cantidad de bits utilizados para determinar la posición del clúster. Por ejemplo, la versión FAT16 no admite más de 2 16 o 65536 clústeres. El número de sectores en un clúster también es limitado.

Otro problema con los discos grandes era la incapacidad de usar el enorme espacio asignado para archivos pequeños. Debido a que la cantidad de clústeres es limitada, se aumentó su tamaño para cubrir toda la capacidad del disco. Esto conduce a un uso ineficiente del espacio al almacenar la mayoría de los archivos que no son un múltiplo del tamaño del clúster. Por ejemplo, FAT32 asigna clústeres de 16 KB para particiones de disco que van desde 16 GB a 32 GB. Para almacenar un archivo de 20 KB, necesitará dos clústeres de 16 KB, que ocuparán 32 KB en el disco. Los archivos de 1 KB ocupan 16 KB de espacio en disco. Por lo tanto, en promedio, el 30-40% de la capacidad del disco se desperdicia para almacenar archivos pequeños. Particionar un disco en particiones pequeñas le permite reducir el tamaño del clúster, pero en la práctica no se usa para discos con una capacidad de más de 200 GB.

La fragmentación de archivos tampoco es un pequeño problema del sistema de archivos. Dado que se pueden requerir varios clústeres para acomodar un archivo, que puede no estar ubicado físicamente uno tras otro, el tiempo que se tarda en leer ralentiza los programas. Por lo tanto, hay una necesidad constante de.

sistema de archivos NTFS

A principios de la década de 1990, Microsoft comenzó a desarrollar un software completamente nuevo diseñado para entornos con un mayor consumo de recursos que los usuarios domésticos típicos. Para las necesidades de las empresas y la industria, los recursos proporcionados por los sistemas operativos Windows basados ​​en DOS se han vuelto insuficientes. Microsoft Corporation trabajó con IBM en el sistema operativo OS/2 con el sistema de archivos HPFS (High Performance File System). El desarrollo corporativo no trajo éxito y pronto cada empresa siguió su propio camino. Microsoft ha desarrollado varias versiones del sistema operativo sistemas Windows NT, sobre el que se basan Windows 2000 y Windows XP. Cada uno de ellos utiliza su propia versión del sistema de archivos NTFS, que sigue evolucionando.

NTFS (Sistema de archivos de nueva tecnología) es el sistema de archivos estándar para los sistemas operativos basados ​​en Windows NT. Fue diseñado para reemplazar FAT. NTFS es más flexible que FAT. Sus áreas de sistema almacenan principalmente archivos en lugar de estructuras fijas como FAT, lo que les permite modificarlos, expandirlos o moverlos durante el uso. Un ejemplo simple es la tabla maestra de archivos (MFT). MFT es un tipo de base de datos con diversa información sobre archivos en un disco. Los archivos pequeños (1 KB o menos) se pueden almacenar directamente en la MFT. Para archivos grandes, NTFS asigna clústeres, pero a diferencia de FAT, el tamaño del clúster generalmente no supera los 4 KB y el método de compresión incorporado elimina los problemas con el espacio no utilizado asignado para los archivos. Y en NTFS puedes usar .

El sistema de archivos NTFS está diseñado para un entorno multiusuario y tiene mecanismos integrados de seguridad y control de acceso. Por ejemplo, los sistemas operativos Windows 2000 y Windows XP (excepto "Home Edition") le permiten establecer permisos de acceso para archivos individuales y cifrarlos. Sin embargo, un alto nivel de seguridad complica el trabajo de los usuarios comunes con una computadora. Debe tener mucho cuidado al establecer contraseñas y permisos de archivos para no perder datos importantes.

Además de todas las demás tareas, cumple su objetivo principal: organiza el trabajo con datos de acuerdo con una determinada estructura. Para estos fines, se utiliza el sistema de archivos. A continuación se presentará qué es un FS y qué puede ser, así como otra información al respecto.

descripción general

El sistema de archivos es una parte del sistema operativo que es responsable de colocar, almacenar y eliminar información en los medios, proporcionar esta información a los usuarios y aplicaciones y garantizar su uso seguro. Además, es ella quien ayuda en la recuperación de datos en caso de falla de hardware o software. Por eso es tan importante el sistema de archivos. ¿Qué es FS y qué puede ser? Hay varios tipos:

Para discos duros, es decir, dispositivos con acceso aleatorio;

Para cintas magnéticas, es decir, dispositivos con acceso serial;

para medios ópticos;

Sistemas virtuales;

Sistemas de red.5

La unidad lógica de almacenamiento de datos en el sistema de archivos es un archivo, es decir, una colección ordenada de datos que tiene un nombre específico. Todos los datos utilizados por el sistema operativo se presentan en forma de archivos: programas, imágenes, textos, música, videos, así como controladores, bibliotecas, etc. Cada uno de estos elementos tiene un nombre, tipo, extensión, atributos y tamaño. Entonces, ahora que lo sabe, el sistema de archivos es una colección de dichos elementos, así como formas de trabajar con ellos. Según cómo se utilice y qué principios se le apliquen, se pueden distinguir varios tipos principales de SF.

Enfoque del programa

Entonces, si se considera un sistema de archivos (qué es y cómo trabajar con él), debe tenerse en cuenta que se trata de una estructura de varios niveles, en su nivel superior hay un interruptor de sistema de archivos que proporciona una interfaz entre el sistema y una aplicación específica. Convierte las solicitudes de archivos a un formato aceptado por el siguiente nivel: los controladores. Ellos, a su vez, se refieren a controladores de dispositivos específicos que almacenan la información necesaria.

Para las aplicaciones cliente-servidor, los requisitos de rendimiento del sistema de archivos son bastante altos. Los sistemas modernos están diseñados para brindar acceso eficiente, soporte para medios de gran volumen, protección de datos contra accesos no autorizados y mantenimiento de la integridad de la información.

sistema de archivos FAT

Este tipo fue desarrollado en 1977 por Bill Gates y Mark McDonald. Originalmente se usó en OS 86-DOS. Si hablamos de qué es el sistema de archivos FAT, vale la pena señalar que inicialmente no era compatible con discos duros, pero solo funcionaba con medios flexibles de hasta 1 megabyte. Ahora esta restricción ya no es relevante, y Microsoft utilizó este FS para MS-DOS 1.0 y versiones posteriores. FAT usa ciertas convenciones de nomenclatura de archivos:

El nombre debe comenzar con una letra o número, y puede contener cualquier carácter ASCII, excepto espacios y elementos especiales;

La longitud del nombre no debe tener más de 8 caracteres, después se coloca un punto y luego se indica la extensión, que consta de tres letras;

Los nombres de archivo pueden utilizar cualquier mayúscula y minúscula y no se distinguen ni se conservan.

Dado que FAT se diseñó originalmente para el sistema operativo DOS de un solo usuario, no preveía el almacenamiento de datos sobre el propietario o los derechos de acceso. Por el momento, este sistema de archivos es el más extendido, la mayoría lo soporta en mayor o menor grado, su versatilidad hace posible su uso en volúmenes que están siendo trabajados por diferentes sistemas operativos. Este es un FS simple que no puede evitar la corrupción de archivos debido al apagado incorrecto de la computadora. Como parte de los sistemas operativos basados ​​en él, existen utilidades especiales que verifican la estructura y corrigen las inconsistencias de los archivos.

sistema de archivos NTFS

Este FS es el más preferido para trabajar con Windows NT, ya que fue desarrollado específicamente para él. El sistema operativo incluye la utilidad de conversión, que convierte volúmenes con FAT y HPFS a volúmenes NTFS. Si hablamos de qué es el sistema de archivos NTFS, vale la pena señalar que ha ampliado significativamente la capacidad de controlar el acceso a ciertos directorios y archivos, introdujo muchos atributos, implementó herramientas dinámicas de compresión de archivos, tolerancia a fallas y admite los requisitos de la estándar POSIX. En este FS, puede usar nombres de hasta 255 caracteres, mientras que un nombre corto se genera de la misma manera que en VFAT. Al comprender qué es el sistema de archivos NTFS, vale la pena señalar que, en caso de falla del sistema operativo, puede recuperarse, por lo que el volumen del disco permanecerá disponible y la estructura del directorio no sufrirá.

Características de NTFS

En un volumen NTFS, cada archivo está representado por una entrada en la tabla MFT. Las primeras 16 entradas de la tabla están reservadas por el propio sistema de archivos para almacenar información especial. La primera entrada describe la tabla de archivos en sí. Cuando se destruye el primer registro, se lee el segundo para encontrar el archivo MFT espejo, donde el primer registro es idéntico a la tabla principal. El centro lógico del disco contiene una copia del archivo de arranque. La tercera entrada de la tabla contiene el archivo de registro, que se utiliza para la recuperación de datos. La decimoséptima y posteriores entradas de la tabla de archivos contienen información sobre los archivos y directorios que se encuentran en el disco duro.

El registro de transacciones contiene el conjunto completo de operaciones que cambian la estructura del volumen, incluidas las operaciones para crear archivos, así como cualquier comando que afecte la estructura del directorio. El registro de transacciones está diseñado para recuperar NTFS de un bloqueo del sistema. La entrada del directorio raíz contiene una lista de los directorios y archivos que se encuentran en el directorio raíz.

Características de EFS

El Sistema de cifrado de archivos (EFS) es una característica de Windows que puede almacenar información en un disco duro en un formato cifrado. El cifrado se ha convertido en la protección más sólida que puede ofrecer este sistema operativo. En este caso, el cifrado para el usuario es una acción bastante sencilla, para ello solo es necesario marcar la casilla en las propiedades de la carpeta o archivo. Puede especificar quién puede leer dichos archivos. Los archivos se cifran cuando se cierran y, cuando se abren, están automáticamente listos para su uso.

Características de RAW

Los dispositivos diseñados para el almacenamiento de datos son los componentes más vulnerables, que con mayor frecuencia están sujetos a daños no solo físicos, sino también lógicos. Ciertos problemas de hardware pueden ser fatales, mientras que otros tienen soluciones. A veces los usuarios tienen una pregunta: "¿Qué es el sistema de archivos RAW?"

Como sabe, para escribir cualquier información en un disco duro o en una unidad flash, la unidad debe tener un sistema de archivos. Los más comunes son FAT y NTFS. Y RAW ni siquiera es el sistema de archivos en el que solemos pensar. De hecho, este es un error lógico de un sistema ya instalado, es decir, su ausencia real para Windows. Muy a menudo, RAW se asocia con la destrucción de la estructura del sistema de archivos. Después de eso, el sistema operativo no solo accede a los datos, sino que tampoco muestra información técnica sobre el equipo.

Características de UDF

El formato de disco universal (UDF) está diseñado para reemplazar CDFS y agregar soporte para dispositivos de DVD-ROM. Si hablamos de lo que es, entonces esta es una nueva implementación de la versión anterior para la cual cumple con los requisitos Se caracteriza por ciertas características:

Los nombres de archivo pueden tener hasta 255 caracteres;

El nombre puede estar en mayúsculas o minúsculas;

La longitud máxima de la ruta es de 1023 caracteres.

A partir de Windows XP, este sistema de archivos es de lectura/escritura.

Este FS se usa para unidades flash que se supone que se usan cuando se trabaja con diferentes computadoras que ejecutan diferentes sistemas operativos, en particular Windows y Linux. Fue EXFAT el que se convirtió en el "puente" entre ellos, ya que puede trabajar con los datos recibidos del sistema operativo, cada uno de los cuales tiene su propio sistema de archivos. Qué es y cómo funciona quedará claro en la práctica.

conclusiones

Como queda claro de lo anterior, cada sistema operativo utiliza ciertos sistemas de archivos. Están destinados a almacenar estructuras de datos ordenadas en medios físicos. Si de repente, cuando usa una computadora, tiene una pregunta sobre cuál es el sistema de archivos final, entonces es muy posible que cuando intentó copiar un determinado archivo a los medios, recibió un mensaje sobre el tamaño excedido permitido. Por eso es necesario saber en qué sistema de archivos qué tamaño de archivo se considera aceptable para que no te encuentres con problemas a la hora de transferir información.

Sistemas de gestión de archivos.

sistema de archivos GRASA. Sistemas de archivos VFATyFAT32.

1. Áreas de una unidad lógica

2. Sector de arranque

3. Tabla de asignación de archivos

4. Directorio raíz

5. Sistema de archivos VFAT

6. Sistema de archivos FAT32

En el sistema de archivos FAT, el espacio en disco de cualquier unidad lógica se divide en dos áreas:

área del sistema y

el área de datos.

área del sistema se crea e inicializa al formatear y, posteriormente, se actualiza al manipular la estructura del archivo.

El área del sistema consta de los siguientes componentes:

· el sector de arranque que contiene el registro de arranque (boot record) ;

Sectores reservados (pueden no serlo);

· tablas de asignación de archivos (FAT, tabla de asignación de archivos);

Directorio raíz (RAÍZ) .

Estos componentes se encuentran en el disco uno tras otro.

Área de datos contiene archivos de directorio subordinados a la raíz.

A diferencia del área del sistema, se puede acceder al área de datos a través de la interfaz de usuario de DOS.

sector de arranque

El registro de arranque se forma durante el formateo (por ejemplo, FORMAT) El formato del sector de arranque depende del sistema operativo e incluso de la versión.

El sector de arranque es el primero en una unidad lógica. Contiene un registro de arranque.

El registro de arranque consta de dos partes:

Bloque de parámetros de disco: a menudo llamado. Bloque de parámetros del BIOS (BPB) o BPB extendido (para versiones anteriores del sistema operativo)

Programas de arranque del sistema operativo (bootstrap del sistema).

Los dos primeros bytes del registro de arranque son el comando para saltar incondicionalmente al cargador del sistema: JMP 3Eh. En el tercer byte - NOP (90h).

A esto le sigue un bloque de parámetros del disco y, después, el cargador del sistema operativo.

El bloque de parámetros del disco contiene la siguiente información

tamaño del sector,

el número de sectores en el clúster,

el número de sectores reservados,

el número de copias FAT,

el número máximo de elementos ROOT,

el número de sectores en la tabla FAT,

el número de sectores por pista,

Etiqueta de volumen

nombre del sistema de archivos

y otros parámetros (byte-descripción del medio en el desplazamiento 0Ah = F8H- ferrocarril de cualquier capacidad; F0-disquete 1,44, 3,5’’).

Los registros de arranque de varios sistemas operativos generalmente difieren en la estructura del bloque de parámetros. Algunos tienen campos adicionales.

Nos familiarizaremos con el registro de arranque en detalle en el trabajo de laboratorio.

Entre el sector de arranque y FAT puede haber sectores reservados que sean de servicio para el sistema de archivos o que no se utilicen. El número de sectores reservados se define en BPB. (En vista de formato - Sectores reservados al inicio - si = 1, entonces es MBR)

Para ver y editar, así como guardar y restaurar un registro de arranque, puede usar utilidadeditor de disco.

Tabla de asignación de archivos

T Tabla de asignación de archivos (Tabla de asignación de archivos - FAT) es esencialmente un mapa del área de datos.

El área de datos se divide en los llamados clústeres. Un clúster es uno o más sectores contiguos de un área de datos. Por otro lado, un clúster es la unidad direccionable más pequeña de espacio en disco asignada a un archivo. Aquellos. un archivo o directorio ocupa un número entero de clústeres. Para crear y escribir un nuevo archivo en el disco, el sistema operativo le asigna varios clústeres de disco libres. Estos clústeres no tienen que seguirse unos a otros. Para cada archivo, se almacena una lista de todos los números de clúster que se proporcionan a este archivo.

En los disquetes, el clúster ocupa uno o dos sectores, y en los discos duros, según el tamaño de la partición:

para particiones con una capacidad de 16-127 MB - 4 sectores en un clúster (tamaño del clúster - 2 KB);

para particiones con una capacidad de 128-255 MB - 8 sectores en un clúster (4 KB);

para particiones con una capacidad de 256-511 MB - 16 sectores en un clúster (8 KB);

para particiones con una capacidad de 512-1023 MB - 32 sectores en un clúster (16 KB);

para particiones con una capacidad de 1024-2047 MB ​​​​- 64 sectores en un clúster (32 KB).

Dividir un área de datos en grupos en lugar de usar sectores le permite:

· reducir el tamaño de la tabla FAT;

Reducir la fragmentación de archivos

Reduce la longitud de las cadenas de archivos. Þ acelerar el acceso a los archivos.

Sin embargo, un tamaño de clúster demasiado grande conduce a un uso ineficiente del área de datos, especialmente en el caso de una gran cantidad de archivos pequeños (después de todo, se pierde en promedio la mitad de un clúster por cada archivo).

En los sistemas de archivos modernos (FAT32, HPFS, NTFS) este problema se resuelve limitando el tamaño del clúster (máximo 4 KB)

Cada elemento de la tabla FAT (12, 16 o 32 bits) corresponde a un clúster de discos y caracteriza su estado: libre, ocupado o un clúster defectuoso.

· Si el grupo se asigna a cualquier archivo (es decir, está ocupado), el elemento FAT correspondiente contiene el número del siguiente grupo de archivos;

· el último grupo del archivo está marcado con un número en el rango FF8h - FFFh (FFF8h - FFFFh);

· si el clúster está libre, contiene el valor cero 000h (0000h);

· Un clúster que no se puede utilizar (fallido) se marca con el número FF7h (FFF7h).

Así, en la tabla FAT, los clústeres que pertenecen al mismo archivo se vinculan en cadenas.

Primer elemento de FAT describe el entorno del sector de arranque. Su primer byte es el mismo que el byte descriptor de medio del medio de almacenamiento (offset 0ah- ver Tabla 4) y es igual a 0F0h para flexible magnetico 3,5 dm. disco o 0F8h para disco duro. Los siguientes 5 bytes (7 bytes) para el formato de 12 bits (16 bits) contienen el valor 0FFh.

La tabla de asignación de archivos se almacena inmediatamente después del registro de arranque del disco lógico, su ubicación exacta se describe en un campo especial en el sector de arranque.

Se almacena en dos copias idénticas que se suceden. Cuando se destruye la primera copia de la tabla, se utiliza la segunda.

Debido al hecho de que FAT se usa mucho cuando se accede a un disco, generalmente se carga en la RAM (en el búfer de E / S o en el caché) y permanece allí el mayor tiempo posible.

La principal desventaja de FAT es el manejo lento de archivos. Al crear un archivo, la regla funciona: se selecciona el primer clúster libre. Esto conduce a la fragmentación del disco y cadenas de archivos complejas. De ahí la ralentización en el trabajo con archivos.

Para ver y editar la tabla FAT, puede usar utilidadeditor de disco.

Directorio raízRAÍZ

La información detallada sobre el archivo en sí se almacena en otra estructura llamada directorio raíz. Cada disco lógico tiene su propio directorio raíz (RAÍZ, inglés - raíz).

Directorio raíz describe archivos y otros directorios. El elemento de directorio es un descriptor de archivo (descriptor).

El descriptor de cada archivo y directorio lo incluye

nombre (8 bytes)

extensión (3)

fecha de creación o última modificación (2)

hora de creación o última modificación (2)

atributos (1) (archivo, atributo de directorio, atributo de volumen, sistema, oculto, solo lectura)

longitud del archivo (para directorio - 0) (4)

un campo reservado que no se utiliza (10)

· el número del primer grupo en la cadena de grupos asignados al archivo o directorio; habiendo recibido este número, el sistema operativo, refiriéndose a la tabla FAT, también encontrará todos los demás números de clúster de archivos (2 bytes).

Entonces, el usuario inicia el archivo para su ejecución. El sistema operativo busca un archivo con el nombre deseado mirando las descripciones de archivo en el directorio actual. Cuando el elemento requerido se encuentra en el directorio actual, el sistema operativo lee el número del primer grupo de este archivo y luego determina los números de grupo restantes de la tabla FAT. Los datos de estos grupos se leen en la RAM y se combinan en una sección continua. El sistema operativo transfiere el control al archivo y el programa comienza a ejecutarse.

Para ver y editar el directorio ROOT, también puede usar utilidadeditor de disco.

Comentario. Recientemente, los volúmenes de los mecanismos de disco han superado con creces el tamaño máximo permitido aceptable para FAT: 8,4 GB. Este límite se explica por los valores máximos posibles en la dirección del sector, para los cuales solo se asignan 3 bytes. Por lo tanto, en la gran mayoría de los casos, cuando se trabaja en un entorno de sistema Windows, no se utiliza FAT (se utiliza FAT32 o NTFS).

sistema de archivosVFAT

El sistema de archivos VFAT (virtual FAT) apareció por primera vez en Windows for Workgroups 3.11 y fue diseñado para E/S de archivos en modo protegido.

Este sistema de archivos se usa en Windows 95. También es compatible con Windows NT 4.

VFAT es el sistema de archivos de 32 bits "nativo" de Windows95. Está controlado por el controlador VFAT.VXD.

Administra varios sistemas de archivos y aplicaciones administrador del sistema de archivos instalado -Administrador de sistemas de archivos instalables.

VFAT usa código de 32 bits para todas las operaciones de archivos y puede usar controladores de modo protegido de 32 bits.

PERO, las entradas de la tabla de asignación de archivos siguen siendo de 12 o 16 bits, por lo que se utiliza la misma estructura de datos (FAT) en el disco. Aquellos. F formato de tablaVFAT es lo mismo, al igual que el formato FAT.

VFAT junto con nombres "8.3" admite nombres de archivo largos. (A menudo se dice que VFAT es FAT con soporte para nombres largos).

Hay un mecanismo especial para convertir nombres largos en cortos y viceversa.

Recuerda que la longitud del nombre para DOS está sujeta a la regla “8.3”, es decir, la longitud del nombre no debe exceder los 8 caracteres, a extensiones - 3. La característica principal del sistema de archivos. ventanas 95 para el usuario es que longitud máxima del nombre de archivo en ventanas 95 puede tener hasta 256 caracteres, incluyendo espacios. La longitud del nombre del archivo está limitada por la ruta al archivo: la longitud total de la ruta y el nombre del archivo no puede exceder los 260 caracteres.

Al crear un archivo enWindows95 le da dos nombres a la vez: largo y corto (8.3). Un nombre corto se forma a partir de uno largo eliminando espacios y símbolos / : * ? “ “< >YO. Para un nombre de archivo de ocho caracteres, se utilizan los primeros seis caracteres restantes del nombre largo, el carácter “~” (tilde) y el número de serie. Una extensión de tres letras usa los tres primeros caracteres después del último punto en el nombre de archivo largo.

Por ejemplo, nombres cortos para archivos (en el siguiente orden)

Artículo sobre Windows 95.DOS

Próximo artículo sobre Windows 95.DOS

Artículo sobre Windows NT.DOS

Microsoft Office.HTML

Microsoft Windows. HTML

se verá así

Al mismo tiempo, en la estructura ROOT, junto con el descriptor habitual (llamado alias) para un archivo o directorio, se crean descriptores especiales en los que se almacena el nombre largo. Para descriptores especiales, se establecen los atributos Solo lectura (solo lectura), Sistema (sistema), Oculto (oculto), Etiqueta de volumen (Etiqueta de volumen). El número de descriptores especiales depende de la longitud del nombre.

El descriptor especial se refiere al número de clúster O. El número real del primer clúster asignado a un archivo o directorio está en el descriptor estándar (alias) que sigue inmediatamente a los especiales.

Para volúmenes VFAT, no puede utilizar otras utilidades que no sean las utilidades que "entienden" VFAT

La principal desventaja de VFAT son las grandes pérdidas por agrupamiento con grandes tamaños de disco lógico y restricciones en el tamaño del propio disco lógico.

sistema de archivosFAT32

Esta es una nueva implementación de la idea de usar la tabla FAT.

FAT 32 es un sistema de archivos de 32 bits completamente independiente.

Utilizado por primera vez en Windows OSR2 (OEM Service Release 2).

FAT32 se usa actualmente en Windows 98 y Windows ME.

Contiene numerosas mejoras y adiciones sobre implementaciones FAT anteriores.

1. Uso mucho más eficiente del espacio en disco debido a que utiliza clústeres más pequeños (4 KB) - se estima que ahorra hasta un 15%.

2. Tiene un registro de arranque extendido que le permite crear copias de estructuras de datos críticas Þ aumenta la resistencia del disco a las violaciones de las estructuras del disco

3. Puede usar una copia de seguridad FAT en lugar de una estándar.

4. Puede mover el directorio raíz, en otras palabras, el directorio raíz puede estar en una ubicación arbitraria Þ elimina el límite en el tamaño del directorio raíz (512 elementos, ya que se suponía que ROOT ocuparía un clúster).

5. Estructura de directorio raíz mejorada

Se agregaron campos adicionales:

tiempo de creación (2)

fecha de creación (2)

fecha del último acceso (2)

Palabra alta del número de grupo inicial

palabra baja del número de grupo inicial

· suma de control

Todavía hay múltiples descriptores para un nombre de archivo largo.

Para volúmenes FAT32, no puede utilizar otras utilidades que no sean las utilidades que "entienden" FAT32