Estructura de un disco duro y

manejo de archivos

Jonathan

Universidad Católica Del Maule

Facultad de ciencias de la ingeniería

Escuela de ingeniería civil informática

Organización y Manejo de Archivos

Profesor Rodrigo Cofré

0

Estructura de un disco duro y

manejo de archivos

Jonathan Nicolás Sepúlveda castillo

18.655.231-8

27 de Septiembre de 2013

Universidad Católica Del Maule

Facultad de ciencias de la ingeniería

Escuela de ingeniería civil informática

Organización y Manejo de Archivos

Profesor Rodrigo Cofré

Estructura de un disco duro y

1

Índice

0. Resumen---------------------------------------------------------------------------------------pág. 2

1. Estructura lógica de un disco duro--------------------------------------------------------- pág. 3

1.1. Master Boot Record--------------------------------------------------------------- pág. 3

1.2. Particiones-------------------------------------------------------------------------- pág. 3

1.3. Tipos de particiones--------------------------------------------------------------- pág. 4

o 1.3.1 Partición Primaria------------------------------------------------------- pág. 4

o 1.3.2 Partición Extendida---------------------------------------------------- pág. 4

o 1.3.3 Partición Lógica--------------------------------------------------------- pág. 4

1.4. Sistemas de Archivos------------------------------------------------------------- pág. 5

o 1.4.1 Windows----------------------------------------------------------------- pág. 5

o 1.4.2 Linux--------------------------------------------------------------------- pág. 5

o 1.4.3 Mac OS X--------------------------------------------------------------- pág. 6

o 1.4.4 Unix---------------------------------------------------------------------- pág. 6

2. Manejo de archivos en diferentes lenguajes de programación---------------------------pág.7

2.1 Lenguaje C-------------------------------------------------------------------------- pág.7

2.2 Lenguaje Java----------------------------------------------------------------------- pág.8

2.3 Lenguaje Pascal-------------------------------------------------------------------- pág.12

3. Conclusiones---------------------------------------------------------------------------------- pág.15

4. Recursos Digitales---------------------------------------------------------------------------- pág.16

2

Resumen

Además de la estructura física de un disco duro podemos encontrar una estructura abstracta

o “lógica”, en esta podemos principales partes: el MBR (Master Boot record) o sector de

arranque, donde se almacena la tabla de particiones entre otros. El otro son las particiones

que son los sectores donde se puede ingresar a los datos accesibles, estas particiones tienen

distintos formatos o mejor llamados sistemas de archivos, los cuales pueden variar para los

diferentes sistemas operativo.

El manejo de archivos en los diferentes lenguajes de programación es muy común y

utilizado para almacenar datos a largo plazo. Lenguajes como C, pascal o java hacen uso de

herramientas propias de de cada uno llamadas “funciones” para manipular el contenido ya

sea para abrir, escribir, leer, cerrar, borrar archivos, etc.

3

1. Estructura lógica de un disco duro

En general un disco duro en su estructura lógica está dividido en dos parte: el sector de

arranque donde encontramos el MBR (Master Boot record) y los espacios particionados/no

particionado.

1.1. Master Boot Record.

Es el primer sector (“Sector cero”), de un dispositivo de almacenamiento, como el disco

duro. Entre sus diferentes uso tenemos a veces que se emplea para el arranque del sistema

operativo con Bootstrap (“”), otro uso es para almacenar una tabla de particiones y, en

ocasiones, se usa solo para identificar un dispositivo de disco individual, aunque en algunas

máquinas esto último no se usa y es ignorado. Pero en forma general el MBR se refiere al

sector de arranque de 512 bytes.

1.2. Particiones.

Una partición de disco es el nombre que se le otorga a cualquier división (lógica) de un

disco. Los espacios particionados son las porciones accesibles del disco y, de forma

contraria, los espacios sin particionar son inaccesibles ya que aun no tienen definida una

partición. En estas particiones donde podemos almacenar datos, tener uno o más sistemas

operativos si es que tenemos distintas particiones en el disco. A cada partición del disco le

podemos dar un formato con algún sistema de archivos (NTFS, ext4, fat32, etc.). Diferente

al formato, pero muchas veces confundido, tenemos a los tipos de particiones: primarias,

extendidas y lógicas.

4

1.3. Tipos de particiones

Podemos encontrar 3 diferente tipos de particiones:

1.3.1 Partición primaria: particiones crudas o primarias del disco duro, se puede

tener un máximo de 4 de estas. Esta depende de una tabla de particiones. Un disco

físico completamente formateado, consiste en realidad de una partición primaria que

ocupa todo el espacio del disco, y posee un sistema de archivos. A este tipo de

particiones, prácticamente cualquier sistema operativo puede detectarlas y

asignarles una unidad, siempre y cuando el sistema operativo reconozca su formato

(sistema de archivos).

1.3.2 Partición extendida: partición que actúa como una partición primaria, en ella

pueden haber infinidad de unidades lógicas en su interior. Con este tipo de partición

se rompe la barrera de solo tener solo 4 particiones primarias ya que esta actúa

como una más. Solo puede existir una partición de este tipo por disco, solo sirve

para contener particiones lógicas. Es el único tipo de partición que no soporta un

formato o sistema de archivos directamente.

1.3.3 Partición lógica: ocupa un trozo o la totalidad de una partición extendida, la

cual se ha formateado con un especifico sistema de archivo (NTFS, FAT32, etc.) y

se le asignado una unidad, si el sistema operativo reconoce las particiones lógicas o

su sistema de archivos.

5

1.4 Sistemas de Archivos

Una de las grandes diferencias entre los diferentes Sistemas operativos, en lo que es la

estructura del disco duro, es los formatos o sistemas de archivos que soporta cada uno.

Podemos ver distintos S.O como:

1.4.1. Windows: este S.O tiene como principal sistema de archivos actualmente el

NTFS, este fue creado con la aparición de Windows NT, está basado en el sistema

de archivos HPFS de OS/2 de IBM. NTFS permite definir clústers (agrupación de

bloques de datos, clases, etc.) de 512 bytes, que es lo mínimo en que se puede

dividir un disco duro. Anteriormente encontramos a FAT y FAT32 que a diferencia

de NTFS tienen clúster mas grandes lo que desperdicia muchos recursos, debemos

tener en cuenta que la unidad básica de almacenamiento es el clúster, y que en

FAT32 el clúster es de 4 Kb, por lo que un archivo de 1 Kb ocupará un

clúster, del que se estarán desperdiciando 3 Kb.; Además estos 2 últimos tienen una

menos capacidad ( 32gb para FAT32 y 4gb para FAT) y estos producen una gran

fragmentación del disco duro.

1.4.2. Linux: los formatos nativos de este OS son ext2, ext3, ext4, este último

actualmente es el más usado en los S.O basados en Linux. Las principales

características de ext4 son su aumento del tamaño de ficheros a 1 Exabay = 220

Terabytes y del tamaño máximo por archivo (16 Tb), numero ilimitados de

directorios frente a los 32000 de ext3, mayor velocidad en la creación y borrado de

ficheros con respecto a sus antecesores (ext2, ext3). Además de de los formatos

nativos, Linux tiene la capacidad de reconocer otros formatos como FAT/FAT32,

NTFS, XFS, ReiserFS. Finalmente en Linux podemos ver un sistema de archivos

especial llamado SWAP, o intercambio de memoria, que tiene como objetivo

funcionar como un respaldo a la memoria RAM en momentos que esta rebalsa su

límite, trabaja como una memoria RAM adicional.

6

1.4.3. Mac OS X: actualmente capaz de arrancar y usar como partición primaria un

volumen formateado según diferentes sistemas de archivo, como HFS+, UFS, ISO,

NFS o UDF. Además se proporciona un sistema llamado VFS (Virtual File

System), que permite crear extensiones del kernel para soportar nuevos sistemas de

ficheros, por lo que en realidad cualquier sistema de archivo puede ser manejado

con el kernel de Mac OS X. Centrándonos más en el sistema de archivos nativo de

Mac OS X (HFS+) podemos encontrar las siguientes características: tiene un uso

eficiente del disco, utiliza nombres internacionales (utilizando el juego de caracteres

Unicode), posibilidad de nombre largos, de hasta 255 caracteres UTF-16,

posibilidad de almacenar datos extra junto con cada fichero (metadato) de una

forma flexible y estándar(pudiendo direccionar 232 bloques en cada volumen) y la

posibilidad de arranque en sistemas no basados en Mac OS.

1.4.4. Unix: como sistema de archivos nativo este O.S tiene a UFS. De este formato

se derivan los sistemas de archivos de MAC OS y Linux (ext4, HFS). Otro formato

es el XFS que fue creado para ser usado con grandes cantidades de datos a gran

velocidad, pero se comporta lento con ficheros pequeños, es normalmente usado en

grandes servidores y donde se maneja mucha información.

7

2. Manejo de archivos en distintos lenguajes de programación

El uso de archivos es algo muy común en informática. Pero, ¿Qué importancia tiene el

manejo de archivos?, la respuesta es la siguiente: Muchas veces en programación se ocupa

como memoria principal para almacenar datos la RAM (usando variables, arreglos,

estructuras de datos, etc.), esta tienes la limitación de que es de uso temporal, es decir,

cuando se cierra el programa y se apaga la computadora se pierden todos los datos. Muchos

programas exigen trasportar datos de un computador a otro o exigen el uso de información

obtenida en otra instancia de uso de tal programa u otro; para resolver este problema se

llega al uso de archivos, de tal forma de que se pueda almacenar información por largo

tiempo sin necesidad de mantener encendido la computadora.

En los diferentes lenguajes de programación podemos manipular archivos con diferentes

“funciones”. Podemos leer, crear, escribir, modificar un archivo. A continuación se

exponen las instrucciones para manipular archivos en los lenguajes C, Java y Pascal:

2.1 Lenguaje C

Para manejar archivos en C primero es necesario crear un puntero de tipo FILE, este

apuntara al archivo. Después es necesario abrir el archivo con la función “fopen ()”, tendrá

como argumento el nombre o dirección del archivo y el modo en que se abrirá (“r”: modo

lectura, “w”: modo escritura). Para comprobar si el archivo esta vacio o no existe basta con

usar con una condición “if”, ver si el puntero tipo FILE, creado anteriormente, es igual a

vacio (NULL) o no. Como las funciones de entrada y salida estándar de C (printf, scanf)

anteponiendo una “f” a cada función (fprintf, fscanf), se puede escribir o leer desde el

archivo colocando como primer argumento el puntero tipo FILE del archivo. Además de los

funciones anteriores tenemos a fgets () q sirve para leer cadenas de determinado largo desde

el archivo y fputs() que sirve para escribir cadenas en el archivo . Al terminar de usar el

archivo se debe cerrar con la función “fclose ()”.

Modos de apertura de un archivo con “fopen ()”:

8

Código donde se resume el manejo básico de archivos en el lenguaje C, con las funciones:

2.2 Lenguaje Java

En java al igual que C es necesario hacer un puntero de tipo “file” para señalar la ubicación

o nombre del archivo. Antes de manipular el archivo también necesitamos usar la clase

FileReader que tiene los métodos (las llamadas funciones en otros lenguajes) para poder

leer caracteres, debemos crear una instancia de esta enviándole como parámetro al puntero

tipo file. Otra clase que tenemos que usar es BufferedReader el cual contiene metodos para

leer líneas completas, la cual debe recibir como parámetro la instancia del “FileReader”.

La apertura del fichero y su posterior lectura pueden lanzar excepciones que debemos

capturar. Por ello, la apertura del fichero y la lectura debe meterse en un bloque try-catch,

este debe ser seguido de un bloque finally, el cual tendrá dentro de el la función close() para

cerrar el archivo al terminar de ocuparlo. Para poder escribir en el archivo necesitamos

crear una instancia de la clase FileWhiter que contiene métodos para tal acción. Para poder

manejar archivos binarios binarios tenemos las clases ImputStream y OutpuStream.

Además de las clases básicas en el manejo de archivos mencionados anteriormente tenemos

otros como DataImputString que se comporta igual que los FileImputStream,

RandonAccessFile para crear archivos de acceso aleatorio, entre otros.

9

// Creando instancias de las clases principales

//lectura de archivos en java

10

//Escritura en un archivo

11

// Manejo de un Archivo binario

Códigos anteriores extraídos de la página web:

http://chuwiki.chuidiang.org/index.php?title=Lectura_y_Escritura_de_Ficheros_en_Java

12

2.3 Lenguaje Pascal

En Pascal podemos almacenar registros en archivos. En primer lugar debemos crear una

variable de tipo FILE que sirve para apuntar a la estructura del archivo (alias), aquí se

indica el tipo de contenido del archivo. Después se debe asignar el alias a un archivo con la

función Assign, es decir se estable una relación entre el nombre y la ubicación física con un

nombre corto (alias). Una vez establecida la relación hay que abrir el archivo en modo

lectura/escritura con la función Reset o crear el archivo usando la función Rewrite. con Se

debe validad la apertura del archivo, para esto se utiliza la variable IoResult , este

almacena un numero diferente a “0” retornado por la función Reset si el archivo no se

puede abrir, basta con utilizar este valor en una condición “if”. Se puede almacenar todos

los campos de un registro en el archivo con la función White, al utilizarla se almacena una

variable del tipo “Record” que representa un bloque de datos o campos, esta función tiene 2

argumentos: el alias del archivo donde se desea almacena y la variable que se desea grabar.

También tenemos la función Read que nos permite cargar los campos de un registro de un

archivo y copiarlo a la memoria RAM, esta función tiene 2 argumentos al igual que White.

Para cerrar el archivo se ocupa la función Close donde se le indica el alias del archivo.

Además de la funciones anteriores, que son la básicas, tenemos otras como seek para re

posicionar el apuntador, FilePos para conocer la posición del apuntador, Eof para detectar

el final del archivo, Rename para cambiar el nombre del archivo, Erase para borrar

archivos, entre otros.

Códigos mostrando algunas operaciones básicas del manejo de archivo en Pascal:

//creación de alias

//función Assign y

Reset

13

// Validar apertura de archivo

//Función White

//Cerrando un archivo Close (alias);

14

3. Conclusiones

En el disco duro, en su estructura lógica, los sistemas de archivos tiene la misión de

administrar la forma de almacenar la información. Cada sistema de archivos tiene una

capacidad máxima, forma de administrar los bloques del disco duro, eficacia con diferentes

cantidades de información, entre otros.

Mediante las funciones podemos manipular archivos en distintos lenguajes, mediante esto

podemos almacenar información a largo plazo a diferencia de almacenar datos en variables

que desaparecen al terminar la ejecución.

15

4. Recursos Digitales

Lectura y escritura de ficheros en java,

http://chuwiki.chuidiang.org/index.php?title=Lectura_y_Escritura_de_Ficheros_en_Java

[visitado el 25 -09 – 2013].

Manejo de Archivos en JAVA,

http://geovinmorales.siems.com.gt/umg/cursos/progra_avanzada/archivos.html

[visitado el 22 – 09 -2013].

Particiones y sistema de archivos en Linux,

http://www.aquihayapuntes.com/particiones-y-sistemas-de-archivos-en-linux.html

[visitado el 14 – 09 - 2013].

Estructura lógica del disco duro,

http://www.wikiteka.com/apuntes/estructura-logica-del-disco-duro/

[visitado el 15 – 09 -2013].

Unix File System,

http://es.wikipedia.org/wiki/Unix_File_System

[visitado el 14 - 09 - 2013]

Manejo de archivos en Pascal [PDF], autor Ing. Bruno López Tekeyas ,

https://www.google.cl/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&ved=0CDAQFjAA&

url=http%3A%2F%2Fwww.itnuevolaredo.edu.mx%2Ftakeyas%2FApuntes%2FAdministraci

on_Archivos%2FApuntes%2FManejo%2520de%2520Archivos%2520en%2520Pascal%2FM

anejo%2520de%2520Archivos%2520en%2520Pascal.pdf&ei=WJxDUpmRIo6O9AStroHoBw

&usg=AFQjCNFeHZ4c2VVjIn5RMizfrQ_s6DNr4g&sig2=1YgP0Y8bOLzeoH-

QngvWyg&bvm=bv.53217764,d.eWU

[visitado el 14 – 09 -2013].

Programación en C- Manejo de archivos,

http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C/Manejo_de_archivos

[visitado 22 – 09 -2013].

Hierarchical File System, http://es.wikipedia.org/wiki/Hierarchical_File_System

[visitado el 15- 09 2013]