Investigación

Una investigación de sistemas de archivos tipos de usuarios y sudo

Luis Angel Terrazas Arteaga

Ingeniería en redes y telecomunicaciones, Universidad Privada Domingo Savio

Sistemas Operativos II

9 de julio de 2024
 Tabla de contenido
1. Los sistemas de archivos de Linux ......................................................................... 1
1.1 Ext .............................................................................................................. 1
1.1.1 Ext2 ......................................................................................................... 1
1.1.2. Ext3 ..................................................................................................... 2
1.1.3. Ext4 ..................................................................................................... 2
2.1 XFS ............................................................................................................. 2
3.1 Btrfs ............................................................................................................ 3
4.1 F2FS............................................................................................................ 3
5.1 JFS .............................................................................................................. 4
6.1 ReiserFS ...................................................................................................... 5
2. Tipos de usuario ................................................................................................... 5
2.1 El usuario administrador ............................................................................... 5
2.2 En que momento usar root ............................................................................ 6
2.3 Cambio de usuario al usuario root ................................................................. 6
3. COMANDO SU ..................................................................................................... 6
4. COMANDO SUDO ................................................................................................ 7
5. Bibliografía ........................................................................................................ 10
 1. Los sistemas de archivos de Linux
A diferencia de Windows y macOS que están estrictamente controlados por las
corporaciones Microsoft y Apple respectivamente, Linux es un gran proyecto de código
abierto desarrollado por una comunidad de entusiastas. Su código siempre permanece
disponible para aquellos que quieran contribuir, y cualquiera es libre de modificarlo según
sus requisitos individuales o crear sus propias distribuciones sobre su base. Es por eso que
Linux existe en tantas variantes, y lo mismo ocurre con su sistema de archivos, una parte
fundamental de cualquier sistema operativo como se menciona en el artículo sobre los
conceptos básicos del sistema de archivos. Su núcleo soporta numerosos formatos, pero los
más utilizados son los de la familia Ext, XFS, Btrfs, F2FS, JFS y ReiserFS. A continuación,
están sus descripciones breves con las principales especificidades.
Tenga en cuenta: Linux también proporciona acceso de lectura y escritura a sistemas
de archivos de otras plataformas, como NTFS, FAT32 y exFAT de Windows de Microsoft,
HFS+ de macOS y ZFS de BSD, Solaris, Unix que se describen en los artículos
correspondientes.
• Ext
• XFS
• Btrfs
• F2FS
• JFS
• ReiserFS
1.1 Ext
Ext (del inglés Extended File System, Sistema de archivos extendido) se lanzó en
1992 como el primer formato diseñado específicamente para Linux. Sin embargo, tenía
limitaciones de rendimiento serias y se reemplazó pronto por Ext2. Este sistema de archivos
y sus revisiones posteriores, Ext3 y Ext4, se convirtieron en la opción predeterminada para
la gran mayoría de las distribuciones de Linux.
1.1.1 Ext2
Ha demostrado ser más eficiente debido a su estructura que se basa en el concepto
de inodos. Dicho descriptor de índice (inodo) contiene los atributos de un objeto particular,
como un archivo o un directorio, y apunta a las ubicaciones de sus datos. En Ext2, el
espacio de almacenamiento se divide en bloques que forman unidades más grandes
denominadas Grupos de bloques (Block Groups). La información sobre todos los Grupos
de bloques se almacena en la Tabla de descriptores (Descriptor Table) ubicada justo a
continuación del Superbloque (Superblock). Cada Grupo de bloques almacena inodos en su
propia Tabla de inodos (Inode Table). Adicionalmente, monitorea el estado de sus bloques e
inodos utilizando los bitmaps de bloque y de inodo respectivamente. Mientras tanto, el
nombre de un archivo o un directorio no forma parte de su inodo: los nombres se asignan a

1
los números de inodo correspondientes a través de directorios, implementados como un tipo
especial de archivos.
La mayoría de los sistemas de archivos de Linux son similares en el sentido de que
el nombre no se considera un atributo y más bien se define como un alias de un archivo en
un directorio determinado. Un objeto de archivo puede estar vinculado desde muchas
ubicaciones y existir con diferentes nombres (los llamados enlaces duros o físicos). Esto
puede conducir a dificultades graves e incluso insuperables en la recuperación de nombres
de archivos después de la eliminación de archivos o en caso de daños lógicos.
1.1.2. Ext3
Es, de hecho, una versión mejorada de Ext2 que soporta el registro por diario
(journaling). En Ext3, el registro por diario está organizado como un archivo de registro
(log) que almacena todos los cambios en el sistema de archivos y lo protege de la
corrupción en caso de falla.
1.1.3. Ext4
Se cambió el método de asignación de datos de bloques individuales a extents. La
idea detrás de esto es escribir la mayor parte de los datos del archivo en un área continua y
luego anotar sólo la dirección de su primer bloque y la cantidad de bloques en la secuencia.
Hasta cuatro extents pueden almacenarse directamente en el inodo, mientras que el resto se
organizan como un árbol B+. Además, Ext4 pospone la operación hasta que los datos estén
realmente metidos en el disco y, así minimiza la fragmentación.
En general, se considera uno de los sistemas de archivos de propósito general más
flexibles que también ha ganado reputación por su estabilidad sólida.
2.1 XFS
XFS (del inglés Extended File System, Sistema de archivos extendido) es otro
sistema de archivos maduro que fue creado por Silicon Graphics e inicialmente empleado
en los servidores IRIX de la empresa. En 2001, llegó al núcleo de Linux y ahora se soporta
en la mayoría de las distribuciones de Linux, algunas de las cuales, como, por ejemplo, Red
Hat Enterprise Linux, incluso lo usan de forma predeterminada.
Este tipo de sistema de ficheros está optimizado para almacenar archivos y
volúmenes muy grandes en un solo host. Él divide el espacio de almacenamiento en áreas
de igual tamaño denominadas Grupos de asignación (Allocation Groups). Cada uno de los
grupos opera como un sistema de archivos distinto, es decir, tiene su propio Superbloque
(Superblock) y maneja sus propias estructuras y el uso del espacio. Este último se controla
con la ayuda de los árboles B+, uno de los cuales registra el primer bloque en el área de
espacio libre continuo y el otro, el número de bloques de los que se compone. Los bloques
de almacenamiento se asignan a los archivos aplicando el mismo enfoque basado en los
extents. En XFS, todos los archivos y directorios están representados por sus inodos
individuales. La asignación de los extents puede almacenarse directamente en el inodo o
rastrearse mediante otro árbol B+ vinculado a él en caso de un archivo muy grande o
fragmentado. Y al igual que los inodos en Ext, estos no contienen los nombres que, a su
vez, están disponibles sólo en las entradas de directorio correspondientes.

2
 XFS emplea el registro por diario (journaling) para hacer cualquier actualización de
sus metadatos. Todos los cambios se escriben primero en el Registro (Journal) antes de que
se modifiquen los bloques reales, lo que permite su recuperación instantánea en caso de
contratiempos. En general, este tipo de sistema de archivos es altamente escalable y
funciona muy bien en el hardware de servidor.
3.1 Btrfs
Btrfs (del inglés B-tree File System, Sistema de archivos del árbol B) es uno de los
formatos de nueva generación más populares para Linux y se está esforzando mucho para
hacerlo estable. Fue desarrollado por Oracle y se soporta por el núcleo principal de Linux
desde 2009. Fedora y SUSE ya lo emplean de forma predeterminada.
Btrfs está ajustado para funcionar en una amplia gama de dispositivos, desde
teléfonos inteligentes hasta servidores de gama alta. Además, cuenta con unas
características de un administrador de volúmenes lógicos, puede distribuirse entre múltiples
almacenamientos y brinda un montón de otras posibilidades avanzadas.
Como sugiere su nombre, Btrfs se basa en gran medida en los árboles B, cada uno
compuesto por nodos internos y hojas. Un nodo interno apunta a un nodo secundario o una
hoja, mientras que una hoja contiene un elemento con cierta información. El diseño y el
contenido reales de un elemento dependen del tipo de árbol B dado. El árbol B Raíz (Root
B-tree), cuya ubicación está disponible en el Superbloque (Superblock), tiene referencias al
resto de los árboles B. El árbol B Fragmentos (Chunk B-tree) gestiona el mapeo de
direcciones lógicas a físicas, mientras que el árbol B Dispositivos (Device B-tree) vincula a
la inversa los bloques físicos de los dispositivos subyacentes con sus direcciones virtuales.
El árbol B Sistema de archivos (File System B-tree) es responsable de la distribución de
archivos y carpetas. Los archivos pequeños se almacenan allí mismo, en los elementos
extents internos. Los grandes se colocan afuera en las áreas contiguas llamadas extents. En
este caso, un elemento de extent refiere a todos los extents que contienen los datos del
archivo. Los elementos de directorio incluyen nombres de archivo y apuntan a sus
elementos de inodo. Los elementos de inodo, a su vez, se utilizan para almacenar otras
propiedades, como el tamaño, los permisos, etc.
Btrfs es un sistema de archivos que usa Copy-on-Write (CoW) o Copiar en escrito
(VACA). En lugar de emplear el registro (journal), él hace copias de los bloques antes de
modificarlos y luego escribe estos datos en una ubicación libre diferente. Este mecanismo
ayuda a evitar el riesgo de corrupción de datos en caso de que se interrumpa una
actualización, por ejemplo, debido a una pérdida de energía. Gracias a esta y a una amplia
variedad de otras características atractivas, Btrfs está ganando cada vez más adeptos entre
los usuarios modernos de Linux.
4.1 F2FS
F2FS (del inglés Flash-Friendly File System, Sistema de archivos compatible con
memoria flash) es otro formato que fue introducido por Samsung Electronics en 2012. Ha
sido diseñado específicamente para los dispositivos de almacenamiento basados en la
memoria flash NAND y, por lo tanto, se utiliza más ampliamente en los teléfonos
inteligentes modernos y medios de almacenamiento portátiles (extraíbles).

3
 F2FS funciona aplicando el enfoque del sistema de ficheros con estructura de
registro (LFS o log-structured file systema) y tiene en cuenta las peculiaridades de los
dispositivos de memoria flash, como el tiempo de acceso constante y el número limitado de
ciclos de reescritura de datos. En lugar de crear un solo fragmento grande para escribir,
F2FS ensambla bloques en fragmentos separados (hasta 6) que se escriben
simultáneamente.
Él divide el espacio de almacenamiento en segmentos de tamaño fijo. Los
segmentos consecutivos forman una sección y varias secciones constituyen una zona. La
asignación de datos en ellos se realiza con la ayuda de nodos. Estos últimos vienen en tres
tipos: directos, indirectos e inodos. Un inodo almacena los metadatos, incluidos el nombre,
el tamaño y otras propiedades del archivo; un nodo directo indica la ubicación de sus
bloques de datos, mientras que un nodo indirecto apunta a los bloques en otros nodos. Las
direcciones físicas de estos nodos se pueden encontrar en la Tabla de direcciones de nodos
(Node Address Table o NIT). El contenido en sí se almacena en el Área principal (Main
Area). Las secciones en ella separan los bloques de datos de los bloques de nodos con
información de servicio. El estado de uso de todos los bloques se registra en la Tabla de
información de segmento (Segment Information Table o SIT). El Área de resumen de
segmento (Segment Summary Area o SSA) especifica qué bloques están asignados a qué
nodo.
Cuando se le faltan segmentos libres, F2FS se limpia en segundo plano, cuando el
sistema está inactivo. El algoritmo de limpieza selecciona los segmentos a limpiar en
función del número de bloques utilizados según la tabla SIT o por su "antigüedad".
La organización descrita hace que F2FS funcione bastante bien en los
almacenamientos de estado sólido. Sin embargo, hasta ahora, se ha aplicado principalmente
en los dispositivos portátiles y rara vez se ha encontrado en los equipos de escritorio y
servidores.
5.1 JFS
JFS (del inglés Journaled File System, Sistema de archivos de registro) fue creado
por IBM en 1990. La versión original, a veces denominada JFS1, se implementó en el
sistema operativo AIX de la empresa. Más tarde, se lanzó JFS2 que se llegó a Linux
después de hacerse de código abierto.
Un volumen JFS se compone de regiones denominadas Grupos de asignación
(Allocation Groups) cada uno de los cuales contiene uno o más Conjuntos de archivos
(FileSets). Todos los archivos y directorios están descritos por sus inodos individuales,
mientras que el contenido real está representado por uno o más extents. Todos los extents
están indexados por un árbol B+ dedicado. El contenido de los directorios pequeños se
almacena dentro de sus inodos, mientras que los más grandes están organizados como
árboles B+. Los árboles B+ también controlan el uso del espacio de almacenamiento: el
primer árbol almacena los bloques iniciales de los extents libres y el segundo, el número de
extents libres. JFS también tiene un área de registro separada y escribe en ella cada vez que
se producen cambios en los metadatos.

4
 En general, JFS se considera un sistema de archivos rápido y confiable. Aún así,
rara vez se mejora y ahora está cayendo en desuso, siendo superado por opciones más
modernas.
6.1 ReiserFS
ReiserFS es un formato alternativo de Linux que está optimizado para almacenar
una gran cantidad de archivos pequeños. Fue diseñado por Namesys en 2001 y trajo una
serie de características nuevas que se consideraron muy innovadoras en el momento de su
presentación. No obstante, finalmente, su mantenimiento se entregó a voluntarios debido a
ciertos problemas técnicos.
ReiserFS se basa en el árbol S+ compuesto por nodos internos y secundarios (hoja).
Esta estructura se utiliza para gestionar todos los archivos, directorios y metadatos.
Contiene elementos de cuatro tipos básicos: directos, indirectos, de directorio y de
estadísticas. Los elementos directos contienen datos reales, los indirectos vinculan a ciertos
bloques de datos, los de directorio representan entradas en un directorio y los de
estadísticas incluyen propiedades de archivos y carpetas. Cada elemento tiene su clave
única que se usa para ubicarlo en el árbol. Esta clave incluye el identificador, la dirección y
el tipo del elemento.
Los archivos y fragmentos de archivos que no ocupan todo el bloque se combinan y
se almacenan directamente en los nodos hoja (secundarios) del árbol S+. Este mecanismo
se denomina tail-packing (empaquetado de cola) y ayuda a reducir la cantidad del espacio
desperdiciado y la fragmentación. Además, ReiserFS no realiza ningún cambio
directamente en el árbol S+: primero lo escribe en el Registro (Journal) y luego lo copia en
la ubicación requerida en el almacenamiento.
Con todo, ReiserFS tiene buenas capacidades de búsqueda y permite asignar
archivos pequeños de manera compacta. Pero este formato ya no se soporta activamente y
es poco probable que siga siendo relevante en el futuro próximo.

2. Tipos de usuario
Básicamente, hay dos tipos de usuarios en los sistemas basados en GNU/Linux o Unix: el
administrador (root) y el resto de usuarios.
Nos vamos a centrar en sistemas basados en GNU/Linux, en concreto utilizaremos Ubuntu.
Sin embargo, la mayor parte de lo explicado se puede utilizar en cualquier sistema
GNU/Linux o Unix.
2.1 El usuario administrador
El usuario root es el usuario utilizado para administrar el sistema. Este usuario puede
realizar cualquier tarea de administración sobre el sistema. Es decir, este usuario puede
hacer cualquier cosa con el sistema.
Este “poder” es peligroso, porque cualquier fallo ocasionado con la cuenta de root puede
afectar a la seguridad de todo el sistema. Hay que tener en cuenta, que cualquier aplicación

5
que se ejecute con la cuenta de root, tendrá los mismos permisos que root, por tanto, podrá
hacer cualquier cosa en el sistema. Por tanto es necesario tomar una serie de medidas de
seguridad para evitar problemas con el uso de la cuenta de root.
2.2 En que momento usar root
Usar la cuenta de root solo cuando sea necesario. Para ello, el administrador del sistema
deberá contar con una cuenta de usuario normal, que será la que utilice para trabajar con el
sistema. Cuando necesite realiza alguna tarea de administración, se cambiará a la cuenta de
root para llevarla a cabo. Una vez terminada la tarea de administración, vuelve a su cuenta
normal.
No permitir inicio de sesión con la cuenta root. Aunque esta medida no es necesaria, si está
siendo utilizada cada vez más. De esta forma, se obliga a que el administrador del sistema
tenga que tener una cuenta de usuario normal y acceder al sistema a través de ésta. Es una
manera de forzar el cambio a root solo cuando sea necesario.
2.3 Cambio de usuario al usuario root
El sistema proporciona una serie de mecanismos para poder cambiar al usuario root desde
una cuenta de usuario normal o para ejecutar comandos como usuario root. Por supuesto,
solo podrá hacer este cambio aquel o aquellos usuarios que queramos que tengan permisos
de administración.
Para seleccionar qué usuario puede llevar a cabo tareas de administración como root, hay
dos técnicas de protección básicas: conocer la contraseña de root e iniciar sesión como root
o configurar el sistema para que ciertos usuarios puedan ejecutar comandos como si fueran
root.
La primera opción, proporcionar la contraseña de root e iniciar sesión, conlleva
proporcionar cierta información sensible a uno o varios usuarios y, sobre todo, facilita la
vulnerabilidad del sistema. Al trabajar como root de forma continua, se facilita la
posibilidad de cometer un error humano a la hora de trabajar con la cuenta al aumentar el
tiempo que estamos en el sistema como root.
La segunda opción se basa en mantener una lista con los usuarios que pueden ejecutar
tareas como root. De tal forma que, cuando un usuario quiera realizar una operación de
administración, se comprueba si ese usuario pertenece o no a la lista de usuarios con
permisos de administración. Si pertenece, se comprueba si realmente es quien dice ser,
pidiendo una contraseña. Esta opción es más facil de mantener y permite realizar, hasta
cierto punto, seguimiento de las operaciones realizadas.

3. COMANDO SU
El comando su permite cambiar de usuario. Permite convertirse en otro usuario durante una
sesión, sin tener que cerrar una sesión e iniciar otra.
Para obtener más información sobre este comando podemos consultar su página de manual.

6
Figura 1 ejemplo del comando su

Fuente: [Link]

Si ejecutamos el comando su sin parámetros estamos tratando de cambiar de usuario al

usuario root. Si conocemos su contraseña podremos continuar como root hasta que
queramos salir con el comando exit.
Figura 2 ejemplo de la terminal

Fuente: [Link]

Se puede observar como el prompt del sistema ha cambiado al cambiar de usuario. Ahora
podríamos realizar las acciones que queramos en el sistema.
Figura 3 ejemplo de terminal

Fuente: [Link]

Para terminar el trabajo como root y volver a nuestro usuario, tan solo tendríamos que
ejecutar el comando exit.

4. COMANDO SUDO
El comando sudo permite a un usuario con privilegios ejecutar comandos como root. Es
decir, permite ejecutar un comando concreto como administrador para realizar tareas
administrativas.

7
Cada comando que queramos ejecutar como root debemos precederlo con el comando sudo.
Por ejemplo, si queremos ejecutar el comando ls /root como root tenemos que ejecutar
delante sudo.
Figura 4 ejemplo de terminal

Fuente: [Link]

Al tratar de ejecutar sudo, nos pide nuestra contraseña de usuario para autenticarnos.
Durante un tiempo, el sistema «nos recuerda» y no nos pide contraseña en esta terminal.
La ventaja de esta solución está en evitar errores humanos, puesto que tan solo
ejecutaremos un comando concreto como root y después seguiremos con nuestra sesión
como usuario.
Para más información sobre sudo podemos consultar su página de manual.
Figura 5 ejemplo de terminal

Fuente: [Link]

Para que un usuario pueda ejecutar comandos como root, debe estar configurado en el
fichero /etc/sudoers. En este documento no se explica cómo añadir usuarios a la lista de
usuarios con privilegios de root, aunque con la ayuda de man se puede realizar sin
problemas. Podemos consultar la página de ayuda de sudoers, con el comando man sudoers.

8
Figura 6 ejemplo de terminal

Fuente: [Link]

9
 5. Bibliografía

Apuntes de Sistemas Informáticos - Tema 8 - DAW. (s. f.). [Link]

[Link]/sistemas-informaticos/ut8/administracion-basica-del-sistema-

[Link]

Dell. (2024, 8 mayo). Explicación sobre los tipos y las definiciones de particiones y directorios de

Ubuntu Linux. Dell Colombia. [Link]

co/000131456/explicacion-sobre-los-tipos-y-definiciones-de-particiones-y-directorios-de-

ubuntu-linux

10