Enlaces duros y simbólicos

1. Un archivo no es su nombre

En la vida diaria decimos «el archivo notas.txt», como si el nombre fuera el archivo. Para el sistema son tres cosas separadas, guardadas en tres lugares distintos:

El nombre lleva al inodo, y el inodo lleva a los datos. Una biblioteca funciona igual: el catálogo tiene títulos, cada título remite a una ficha, y la ficha indica en qué estante está el libro. El libro no lleva escrito en qué catálogos figura, y puede figurar en varios.

El diagrama adelanta los dos mecanismos del tema. Para entenderlos hay que mirar primero la pieza del medio.

2. El inodo

Un inodo es la estructura en la que el sistema de archivos guarda todos los datos de un archivo, salvo su nombre y su contenido. Cada inodo se identifica con un número, único dentro de su sistema de archivos.

Lo mencionamos en el tema 7, al presentar stat: lo que ese comando muestra es, precisamente, el contenido del inodo.

Lo que no guarda es el nombre. Es lo único de la línea de ls -l que no viene del inodo.

El número de inodo se ve con la opción -i de ls. Preparamos un taller, como en el tema 11, y creamos un archivo:

$ cd ~/practica
$ mkdir taller
$ cd taller
$ echo "Texto original" > original.txt
$ ls -li
total 4
1311480 -rw-rw-r-- 1 ana ana 15 oct 12 14:05 original.txt

La primera columna es el número de inodo; en tu sistema será otro. La tercera, el contador de enlaces, vale 1: este inodo tiene un solo nombre.

3. Qué es, entonces, un directorio

Si el nombre no está en el inodo, está en el directorio. Y esa es toda la función de un directorio:

Un directorio es un archivo cuyo contenido es una lista de pares: un nombre y el número del inodo al que corresponde. Cada uno de esos pares es un enlace.

Así es por dentro nuestro directorio taller. No «contiene» archivos en ningún sentido físico: contiene nombres, con una referencia a cada archivo. Con esta idea se explican varios comportamientos que encontramos en temas anteriores:

4. Enlaces duros: otro nombre para el mismo archivo

Si un nombre es solo una referencia a un inodo, nada impide que haya dos referencias al mismo. El comando ln, de link, crea una:

$ ln original.txt duro.txt
$ ls -li
total 8
1311480 -rw-rw-r-- 2 ana ana 15 oct 12 14:05 duro.txt
1311480 -rw-rw-r-- 2 ana ana 15 oct 12 14:05 original.txt

El orden de los argumentos es el de cp: primero lo que ya existe, después el nombre nuevo. El listado muestra dos líneas con el mismo número de inodo, y el contador pasó de 1 a 2.

Un enlace duro es un nombre adicional para un archivo existente. Todos los enlaces duros de un archivo señalan al mismo inodo y son equivalentes entre sí.

No se copió nada. Hay un solo archivo en el disco, con un solo contenido, y dos nombres que llevan a él. La prueba es que lo que se modifica por un nombre se ve por el otro:

$ echo "Otra frase" >> duro.txt     # agregar una línea usando un nombre…
$ cat original.txt                  # …y leer usando el otro
Texto original
Otra frase
$ ls -li
total 8
1311480 -rw-rw-r-- 2 ana ana 26 oct 12 14:10 duro.txt
1311480 -rw-rw-r-- 2 ana ana 26 oct 12 14:10 original.txt

El tamaño, la fecha, los permisos y el dueño coinciden siempre en las dos líneas, y no por sincronización: son los datos de un único inodo, mostrados dos veces.

Hay un punto que conviene subrayar, porque los nombres del ejemplo inducen a error. No hay un original y una copia. Después de crear el enlace, los dos nombres tienen exactamente el mismo rango, y el sistema no recuerda cuál fue primero. original.txt es tan «enlace duro» como duro.txt: todo nombre de archivo lo es.

5. Lo que rm hace en realidad

La consecuencia más interesante aparece al borrar:

$ rm original.txt
$ cat duro.txt                      # el contenido sigue ahí
Texto original
Otra frase
$ ls -li
total 4
1311480 -rw-rw-r-- 1 ana ana 26 oct 12 14:10 duro.txt

Se borró el «original», y el archivo está intacto. rm no borra archivos: quita un nombre. Con cada nombre que se quita, el contador del inodo baja en uno. El sistema libera el inodo y los bloques de datos solo cuando el contador llega a cero.

Por eso la operación interna del sistema se llama unlink, desenlazar, y no «borrar». En el caso habitual, con un solo nombre, quitarlo y eliminar el archivo son lo mismo, y la distinción no se nota.

Hay una condición más para que el espacio se libere: que ningún programa tenga el archivo abierto. De ahí sale un problema clásico de administración. Se borra un registro enorme para recuperar espacio, y el disco sigue lleno: el servicio que lo escribe aún lo tiene abierto, y los datos persisten, ya sin nombre, hasta que ese servicio se reinicie.

Devolvemos al archivo su nombre anterior. Renombrar, como sabemos, tampoco toca el inodo:

$ mv duro.txt original.txt
$ ls -li
total 4
1311480 -rw-rw-r-- 1 ana ana 26 oct 12 14:10 original.txt

6. Los límites de los enlaces duros

Los enlaces duros tienen dos restricciones, que vienen de su propia naturaleza:

$ ln ~/practica/fotos album         # a un directorio: no
ln: /home/ana/practica/fotos: hard link not allowed for directory
$ ln original.txt /dev/shm/otro.txt # a otro sistema de archivos: tampoco
ln: failed to create hard link '/dev/shm/otro.txt' => 'original.txt': Invalid cross-device link

/dev/shm es un directorio que reside en la memoria y no en el disco, de modo que es un sistema de archivos distinto del de tu directorio personal; por eso sirve para la demostración.

La primera restricción tiene una excepción que el propio sistema administra, y que resuelve un asunto pendiente del tema 7: por qué la columna de enlaces de un directorio vale «2 más la cantidad de subdirectorios». Las entradas . y .. son enlaces duros.

$ mkdir sub
$ ls -ldi . sub/..
1311478 drwxrwxr-x 3 ana ana 4096 oct 12 14:15 .
1311478 drwxrwxr-x 3 ana ana 4096 oct 12 14:15 sub/..

El mismo inodo, alcanzado por dos caminos. El directorio taller tiene tres nombres: taller, en la lista de su padre; ., en su propia lista; y .., en la lista de sub. Cada subdirectorio nuevo agrega otro .., y de ahí la regla.

7. Enlaces simbólicos: un nombre que apunta a otro

El segundo tipo de enlace resuelve las dos limitaciones, con un mecanismo completamente distinto. Se crea con la opción -s:

$ ln -s original.txt blando.txt
$ ls -li
total 8
1311481 lrwxrwxrwx 1 ana ana 12 oct 12 14:18 blando.txt -> original.txt
1311480 -rw-rw-r-- 1 ana ana   26 oct 12 14:10 original.txt
1311485 drwxrwxr-x 2 ana ana 4096 oct 12 14:15 sub
$ cat blando.txt
Texto original
Otra frase

Un enlace simbólico es un archivo de un tipo especial cuyo contenido es una ruta. Cuando un programa lo abre, el sistema lo reemplaza por el archivo que esa ruta señala.

Todo en el listado lo distingue del enlace duro:

La penúltima fila resume la idea: el enlace no contiene los datos ni una referencia al inodo, sino un texto. Es el equivalente de un acceso directo de Windows, o de un cartel que dice «lo que busca está en tal lugar».

Hay un tercer nombre en uso para lo mismo. En inglés se los llama symbolic links, abreviado symlinks, o soft links, por oposición a los hard links; en español, simbólicos o blandos.

8. Quién sigue el enlace

La gran mayoría de los comandos siguen el enlace: actúan sobre el archivo señalado, sin que haya que hacer nada. Leer, editar o ejecutar a través de un enlace simbólico es lo mismo que hacerlo sobre el destino. Unos pocos actúan sobre el enlace mismo, y conviene saber cuáles:

La lógica es que los comandos que tratan del contenido siguen el enlace, y los que tratan del nombre —mover, renombrar, borrar— actúan sobre él. Borrar un enlace simbólico es siempre seguro para el archivo original.

Para averiguar adónde lleva un enlace hay dos comandos:

$ readlink blando.txt               # lo que el enlace tiene escrito
original.txt
$ realpath blando.txt               # el archivo final, como ruta absoluta
/home/ana/practica/taller/original.txt

realpath, que conocimos en el tema 6, resuelve además las cadenas: un enlace puede apuntar a otro enlace, y este a otro. El sistema las sigue hasta el final, con un límite de unos cuarenta saltos para protegerse de los ciclos.

9. Enlaces rotos

Como el enlace simbólico guarda un nombre, y no una referencia al archivo, nada lo mantiene al día. Si el destino se borra, se mueve o cambia de nombre, el enlace queda señalando a la nada:

$ mv original.txt otro.txt          # el destino cambia de nombre
$ cat blando.txt
cat: blando.txt: No such file or directory
$ ls -l blando.txt                  # el enlace existe; lo que falta es el destino
lrwxrwxrwx 1 ana ana 12 oct 12 14:18 blando.txt -> original.txt
$ mv otro.txt original.txt          # vuelve el nombre…
$ cat blando.txt                    # …y el enlace funciona otra vez
Texto original
Otra frase

El mensaje de cat es confuso, porque nombra a blando.txt, que sí existe. Lo que no existe es aquello a lo que apunta. Es un enlace roto, y ls suele mostrarlo en rojo.

El final del ejemplo muestra la otra cara. Al reaparecer un archivo con ese nombre, el enlace vuelve a funcionar, y funcionaría igual si fuera un archivo completamente distinto. Un enlace simbólico apunta a un nombre, sea cual sea el archivo que lo lleve. Un enlace duro apunta a un archivo, sea cual sea su nombre. Esa es la diferencia esencial entre los dos.

Los enlaces rotos se acumulan con el tiempo. find los localiza:

$ find ~ -xtype l                   # enlaces simbólicos cuyo destino no existe

10. La trampa de las rutas relativas

El enlace guarda la ruta tal como se la escribió. Si es relativa, surge una pregunta: ¿relativa a qué? La respuesta no es la que se espera, y es la causa de la mayoría de los enlaces rotos recién creados.

Se ve al mover el enlace. Sigue diciendo original.txt, pero ahora ese nombre se busca en otro directorio:

$ mv blando.txt sub/
$ cat sub/blando.txt                # busca sub/original.txt, que no existe
cat: sub/blando.txt: No such file or directory
$ rm sub/blando.txt

El mismo error se comete al crear un enlace en otro directorio. Parece natural escribir ln -s original.txt sub/blando.txt, porque desde donde estás original.txt es una ruta válida. El enlace nace roto. Hay tres formas correctas:

$ ln -s ../original.txt sub/blando.txt            # relativa, pensada desde «sub»
$ cat sub/blando.txt
Texto original
Otra frase
$ ln -sr original.txt sub/relativo.txt            # -r: que ln calcule la ruta relativa
$ ln -s ~/practica/taller/original.txt sub/absoluto.txt   # absoluta
$ ls -l sub
total 0
lrwxrwxrwx 1 ana ana 38 oct 12 14:26 absoluto.txt -> /home/ana/practica/taller/original.txt
lrwxrwxrwx 1 ana ana 15 oct 12 14:24 blando.txt -> ../original.txt
lrwxrwxrwx 1 ana ana 15 oct 12 14:25 relativo.txt -> ../original.txt

Es el mismo criterio del tema 6. Para enlaces dentro de un proyecto que puede copiarse o moverse entero, relativas; para un atajo personal hacia un lugar fijo del sistema, absolutas. Y después de crear un enlace, comprobarlo: un ls -l o un cat lleva un segundo.

11. Enlaces a directorios

Los enlaces simbólicos sí pueden apuntar a directorios, y es uno de sus usos más frecuentes:

$ ln -s ~/practica/fotos album
$ ls -ld album
lrwxrwxrwx 1 ana ana 24 oct 12 14:30 album -> /home/ana/practica/fotos
$ cd album
$ pwd                               # la ruta lógica: por donde entré
/home/ana/practica/taller/album
$ pwd -P                            # la ruta física: donde estoy
/home/ana/practica/fotos
$ cd ..                             # vuelve por donde entré: a taller

Es la situación que vimos en el tema 6 con /bin, y ahora se entiende completa. La shell recuerda el camino por el que entraste, y cd .. lo desanda, aunque el padre real de fotos sea otro.

Con los enlaces a directorios, una barra al final cambia el significado de la ruta:

$ rm album                          # solo el enlace; ~/practica/fotos sigue en su lugar

12. Duro, simbólico o copia

En la práctica, el que se usa a diario es el simbólico. Es más flexible, y sobre todo es visible: cualquiera que liste el directorio ve que es un enlace y adónde va. El enlace duro es discreto hasta el punto de pasar inadvertido, y queda para usos específicos. Ninguno de los dos reemplaza a una copia cuando se quieren dos versiones independientes, ni sirve de respaldo: si el contenido se daña, se daña para todos los nombres.

Para saber qué nombres comparten un inodo, find tiene dos condiciones: -samefile archivo, y -inum número.

13. Dónde se usan

Los enlaces simbólicos están por todo el sistema. Algunos de los que tienes en tu equipo:

$ ls -l /bin /etc/localtime /usr/bin/python3
lrwxrwxrwx 1 root root  7 abr 22  2024 /bin -> usr/bin
lrwxrwxrwx 1 root root 50 oct  5 09:10 /etc/localtime -> /usr/share/zoneinfo/America/Argentina/Buenos_Aires
lrwxrwxrwx 1 root root 10 ago  7  2024 /usr/bin/python3 -> python3.12

El segundo uso está muy desarrollado en Debian y Ubuntu, con el sistema de alternativas. El editor por defecto que mencionamos en el tema 13 es una cadena de enlaces:

$ readlink /usr/bin/editor
/etc/alternatives/editor
$ readlink /etc/alternatives/editor
/bin/nano
$ realpath /usr/bin/editor
/usr/bin/nano

Los enlaces duros son menos visibles. Su aplicación más ingeniosa son las copias de seguridad incrementales: cada respaldo diario parece un árbol completo, pero los archivos que no cambiaron son enlaces duros a los del día anterior y no ocupan espacio. Se puede borrar cualquier día sin afectar a los demás, porque los datos sobreviven mientras quede un nombre.

14. ln y sus opciones

La sintaxis de ln es la de cp, y una regla ayuda a no invertir los argumentos: primero lo que existe, después lo que se crea.

ln -s /usr/share/doc documentacion
   │  │              │
   │  │              └─ el nombre nuevo: el enlace que se crea
   │  └─ el destino: adónde apunta (lo que ya existe)
   └─ simbólico; sin esta opción, el enlace es duro

Tres observaciones. Si se omite el segundo argumento, el enlace se crea en el directorio actual, con el mismo nombre que el destino. ln -s no comprueba que el destino exista: crea sin protestar un enlace a cualquier texto, y por eso hay que verificar. Y para cambiar el destino de un enlace existente, la forma habitual es ln -sfn nuevo-destino enlace.

Queda desarmar el taller, con las comprobaciones de costumbre:

$ cd ~/practica
$ ls taller taller/sub
taller:
original.txt  sub

taller/sub:
absoluto.txt  blando.txt  relativo.txt
$ rm -r taller
$ ls
fotos  informe.txt  notas.txt  tareas.txt

Y la referencia del tema:

En el tema 15 cerramos el bloque con la operación inversa a dispersar archivos: reunir muchos en uno solo, y reducir su tamaño, con tar y los compresores.

15. Resumen

• Un archivo consta de tres piezas: el nombre, guardado en el directorio; el inodo, con sus datos administrativos; y el contenido, en bloques del disco.
• El inodo guarda tipo, permisos, dueño, tamaño, fechas, ubicación de los datos y la cantidad de nombres que lo señalan. No guarda el nombre.
• Un directorio es una lista de nombres con el número de inodo de cada uno. Cada par es un enlace.
• Un enlace duro es otro nombre para el mismo inodo. Se crea con ln. Todos los nombres son equivalentes.
• rm quita un nombre y resta uno al contador de enlaces. Los datos se liberan cuando el contador llega a cero.
• Los enlaces duros no pueden apuntar a directorios ni cruzar de un sistema de archivos a otro.
• Un enlace simbólico es un archivo aparte que contiene una ruta. Se crea con ln -s y se reconoce por la l y la flecha en ls -l.
• Los comandos que usan el contenido siguen el enlace; rm y mv actúan sobre el enlace mismo.
• Si el destino desaparece, el enlace simbólico queda roto. El enlace duro, en cambio, mantiene vivo el archivo.
• Una ruta relativa guardada en un enlace se resuelve desde el directorio donde está el enlace.
• Un enlace a un directorio se borra con rm enlace, sin -r y sin barra final.
• Los enlaces simbólicos se usan para compatibilidad de rutas, selección entre alternativas, versiones y atajos.

16. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Ejecuta ls -li ~/practica y stat ~/practica/notas.txt. Ubica el número de inodo y el contador de enlaces en las dos salidas.
2. En un directorio de /tmp, crea un archivo con una línea de texto y tres enlaces duros. Verifica el contador. Borra los nombres de a uno, observando el contador cada vez.
3. Modifica el archivo con nano a través de uno de sus enlaces duros y comprueba el cambio por otro. Algunos editores, al guardar, crean un archivo nuevo y rompen el enlace: mira si los números de inodo siguen coincidiendo.
4. Crea un enlace simbólico a /etc/hostname en tu directorio de pruebas. Compara ls -l, ls -lL, readlink y realpath sobre él.
5. Crea un enlace simbólico a un archivo que no existe. ¿Protesta ln? Encuéntralo con find -xtype l, y luego crea el archivo que faltaba y prueba otra vez.
6. Reproduce la trampa de la sección 10: crea un subdirectorio, y un enlace dentro de él con una ruta relativa incorrecta. Corrígelo de las tres maneras.
7. Crea un enlace simbólico a /usr/share/doc llamado docs. Entra en él, compara pwd con pwd -P, y observa adónde lleva cd ... Borra el enlace correctamente.
8. Copia un enlace simbólico con cp y con cp -a, y compara los resultados con ls -l.
9. Busca con find /etc -maxdepth 1 -type l los enlaces que hay en /etc, y sigue uno hasta su destino final.
10. Averigua con readlink y realpath a qué programa apuntan realmente /usr/bin/vi y /usr/bin/editor.