SISTEMA DE ARCHIVOS

En la mayoría de distribuciones, al iniciar una sesión shell, somos situados en nuestro

directorio Home de usuario. Aunque a menudo tendremos que salir de Home e ir a otras áreas
del sistema de archivos.

SISTEMA DE ARCHIVOS LINUX

Linux no usa letras de unidad en sus nombres de ruta de archivo. En Windows, la únidad física
de disco determina en nombre de la ruta, donde es asignada una letra de unidad a cada unidad
de disco física, y cada unidad contiene su propia estructura de directorios.

En Windows podemos tener:

C:\Users\Rich\My Documents\test.doc

El archivo test.doc está en el directorio My Documents, dentro del directorio Rich, dentro del
directorio Users, dentro de la unidad (o partición de disco) asignada a la letra C.

Este no es el método usado por Linux, que almacena archivos en una estructura de directorios
simple, llamado directorio virtual. El directorio virtual contiene rutas de archivo de todos los
dispositivos de almacenamiento instalados en el sistema, todo en una estructura de directorios
única.

La estructura de directorio virtual contiene un directorio base único, llamado root. A partir de
ahí, los directorios y archivos son listados bajo el root según la ruta para acceder a ellos, de
forma similar a como hace Windows.

SLASHES

Linux usa el forward slash (/) en lugar del backslash (\). El backslash denota en Linux un
carácter de escape. Por ejemplo:

/home/rich/Documents/test.doc

El archivo test.doc está en el directorio Documents, bajo el directorio rich, bajo el directorio
home, sin indicar información de la unidad donde está.

El primer disco duro instalado en Linux se llama el disco raíz (root drive). Este contiene el
núcleo del directorio virtual. Todo lo demás se construye desde aquí. En el disco raíz, Linux
crea directorios especiales llamado puntos de montaje. Los puntos de montaje serán
directorios en el directorio virtual cuando asignamos dispositivos de almacenamiento
adicionales. El directorio virtual hace que directorios y archivos aparezcan dentro de esos
directorios de punto de montaje, incluso aunque estén físicamente almacenados en un disco
diferente.

A menudo los archivos de sistema están físicamente en el disco root, mientras que los archivos
de usuario lo están en un disco diferente. Por ejemplo, el segundo disco puede estar montado
en la ubicación /home.
El sistema de archivos de Linux ha evolucionado a partir de la estructura de archivos de Unix,
donde no siempre ha habido una estructura estándar de sistema de archivos. Linux comenzó
también así, pero se ha hecho un esfuerzo por estandarizar la estructura de directorios de
Linux con el Linux Filesystem Hierarchy Standard (FHS).

Algunos de los nombres más comunes de directorio virtual en FHS:

Directory Usage

/ The root of the virtual directory. Normally, no files are placed here
/bin The binary directory, where many GNU user-level utilities are stored
/boot The boot directory, where boot files are stored
/dev The device directory, where Linux creates device nodes
/etc The system configuration files directory
/home The Home directory, where Linux creates user directories
/lib The library directory, where system and application library files are stored
/media The media directory, a common place for mount points used for removable
media
/mnt The mount directory, another common place for mount points used for
removable media
/opt The optional directory, often used to store optional software packages
/root The root user account’s Home directory
/sbin The system binary directory, where many GNU admin-level utilities are stored
/tmp The temporary directory, where temporary work files can be created and
destroyed
/usr The user-installed software directory
/var The variable directory, for files that change frequently, such as log files

Al crear una cuenta de usuario, el sistema normalmente asigna un directorio único para la
cuenta. Para movernos por la estructura de directorio virtual, lo haremos desde el prompt de
interfaz de línea de comandos (CLI).

RECORRIENDO DIRECTORIOS

Usaremos el comando cd para cambiar de directorio. El formato es simplemente:

cd destino

Este comando toma un único parámetro, el directorio de destino. Si no se especifica el destino,

tomará nuestro directorio Home.

El destino puede ser expresado de dos maneras:

 Ruta absoluta.
 Ruta relativa.

RUTAS ABSOLUTAS

Podemos referenciar un nombre de directorio dentro del directorio virtual usando una ruta
absoluta. La ruta absoluta define exactamente donde está el directorio dentro de la estructura
del directorio virtual, comenzando en el root. Por consiguiente, para referenciar el directorio
ssl que está dentro del directorio lib, que a su vez está dentro del directorio usr:

$ cd /usr/lib/ssl

En la mayoría de distribuciones, el prompt muestra el directorio actual. Podemos movernos a

cualquier nivel dentro de la estructura de directorio virtual usando una ruta absoluta.

RUTAS RELATIVAS

Las rutas relativas permite especificar un directorio de destino, relativo a nuestra situación
actual, sin tener que comenzar por root. Una ruta relativa no comienza con slash. En su lugar,
comienza o bien con un nombre de directorio (si nos vamos a mover a un directorio que está
bajo nuestro directorio actual) o un carácter especial que indique una situación relativa a
nuestro directorio actual. Dos caracteres especiales son:

 El punto (.) representa el directorio actual.

 El doble punto (..) representa el directorio padre del directorio actual.

Por ejemplo, si estamos en systemd que está bajo etc, y necesitamos ir a ssl que también está
bajo etc:

$ cd ../ssl

Podemos usar tantos dobles puntos como sea necesario:

$ cd ../../etc

ARCHIVOS LINUX

Una de las cosas que hicieron a Unix un sistema operativo único fue que trataba todo en el
sistema como un archivo (dispositivos, datos, conexiones de red, etc.). Esto simplificaba la
forma en que los programas interactuaban con el hardware y con otros programas, pues no
importa de donde vengan los datos, el sistema los maneja de la misma forma.

Sin embargo, ya que todo es un archivo, ha ciertas cosas que nos pueden causar problema,
como por ejemplo intentar identificar tipos de archivo.

TIPOS DE ARCHIVO

Los archivos Linux cubren un amplio rango de tipos de archivo. Todo desde datos de texto a
programas ejecutables. Ya que los archivos de Linux no requieren extensión, a veces puede ser
difícil decir qué archivos son programas, cuáles son datos de texto y los que son datos binarios.
Por ello tenemos el comando file, que devuelve el tipo del archivo especificado. Y si es de
datos, también intentará detectar qué contiene el fichero.

$ file myprog.c

myprog.c: C source, ASCII text

$ file myprog
myprog: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked,
interpreter /lib64/ld-linux-x86-64.so.2,
BuildID[sha1]=a0758159df7a479a54ef386b970a26f076561dfe, for GNU/Linux 3.2.0, not
stripped

En este ejemplo, el fichero myprog.c es un fichero de texto de programa C, y el fichero myprog

es un fichero binario de programa ejecutable.

NOMBRES DE ARCHIVO

Linux tiene un estándar diferente a Windows para nombrar los ficheros. Linux no requiere
extensión para identificar el tipo de fichero en el sistema (aunque se permiten). Los nombres
de fichero pueden ser de cualquier longitud (aunque 255 caracteres es un límite práctico para
que los programas no tengan problemas con ellos). Pueden contener mayúsculas, minúsculas,
números y la mayoría de caracteres especiales (los únicos no permitidos son el slash / y el
carácter NULL). Pueden contener espacios y caracteres en lenguajes extranjeros. Sin embargo,
el nombre debería siempre comenzar con una letra o un número.

Ejemplos válidos:

testing
A test file.txt
4_data_points
my.long.program.name

CASE SENSITIVITY

A diferencia de Windows, Linux distingue entre mayúsculas y minúsculas. Por ejemplo,

Test.doc es diferente de test.doc.

ARCHIVOS OCULTOS

Los archivos ocultos no aparecen en los listados normales de archivos. Linux no usa
propiedades de archivo para ocultarlos. En su lugar, usa el nombre de archivo. Los nombres
que comienzan por punto (.) se consideran archivos ocultos que no aparecerán en listados
normales cuando usamos el comando ls y no se muestran cuando usamos un gestor de
ficheros gráfico. Sin embargo, podemos usar opciones para mostrarlos con el comando ls:

$ ls

mydata.txt
mydirectory
myprog
myprog.c

$ ls -a

.
..
.bash_logout
.cache
mydata.txt
myprog.c
myprog

INODOS

Linux tiene que mantener el seguimiento de un montón de información para cada archivo del
sistema. La manera en que lo hace es usando nodos índice (inodos). Linux crea un inodo para
cada archivo del sistema, para almacenar las propiedades del archivo. Los inodos están ocultos
a la vista, y solo el sistema operativo puede acceder a ellos. Cada inodo tiene un número
asignado, llamado número de inodo. Esto es lo que Linux usa para referenciar el archivo, no el
nombre. Los números de inodo son únicos en cada partición física del disco.

Linux también crea una tabla en cada partición de disco llamada tabla de inodos. Es un listado
que coincide con cada número de inodo asignado a cada archivo en la partición de disco.
Cuando creamos y eliminamos archivos, Linux automáticamente actualiza la tabla de inodos.
Sin embargo, si el sistema sufriera un apagado abrupto (como un fallo en el suministro de
energía), la tabla de inodos podría corromperse. Afortunadamente, hay utilidades que pueden
ayudar a reorganizar la tabla de inodos y prevenir la pérdidad de datos. Aunque si la tabla de
inodos fuera irreparable, no podríamos acceder a los archivos en la partición de disco, incluso
aunque estos estuvieran aún ahí.

Para ver los números de inodo de los ficheros, usaremos la opción -i del comando ls. Podemos
combinarla con la opción -l para obtener un listado largo que muestre más detalles de los
archivos:

$ ls -il

total 36
263784 -rw-rw-r-- 2 sysadmin sysadmin 71 Dec 19 13:17 copy.c
262804 -rw-rw-r-- 1 sysadmin sysadmin 15 Dec 19 13:26 mydata.txt
395365 drwxrwxr-x 2 sysadmin sysadmin 4096 Dec 19 13:26 mydirectory
264036 -rwxrwxr-x 1 sysadmin sysadmin 16696 Dec 19 13:18 myprog
263784 -rw-rw-r-- 2 sysadmin sysadmin 71 Dec 19 13:17 myprog.c

El primer número del listado es el número de inodo. Podemos ver que el número de inodo de
myprog.c es el mismo que el de copy.c. Esto implica que hay un enlace duro (físico) entre
ambos archivos. Este enlace apunta a la misma localización física en el disco que el archivo
original, por lo que sus números de inodos son los mismos.

LISTAR ARCHIVOS Y DIRECTORIOS

La característica más básica del shell es la habilidad para ver qué archivos están disponibles en
el sistema. El comando ls es la herramienta para ello.

LISTADO BÁSICO

El comando ls es la forma más básica para mostrar ficheros y directorios que hay en el
directorio actual:
$ ls

copy.c mydata.txt mydirectory myprog myprog.c

El comando ls produce el listado en orden alfabético, en columnas. Si usamos un emulador de

terminal que soporta color, el comando ls puede también mostrar diferentes tipos de entradas
en diferentes colores. La variable de entorno LS_COLORS controla esta característica.
Diferentes distribuciones establecen esta variable dependiendo de las capacidades del
emulador de terminal utilizado.

Si no tenemos un emulador de terminal que soporte color, podemos usar el parámetro -F para
distinguir ficheros de directorios:

$ ls -F

copy.c mydata.txt mydirectory/ myprog* myprog.c

Este parámetro marca los directorios con un slash (/). También marca los ficheros ejecutables
con un asterisco (*). El comando ls no muestra los archivos ocultos.

El parámetro -R muestra un listado recursivo, con archivos que estén incluidos en

subdirectorios del directorio actual (lo cual puede ser muy largo).

$ ls -F -R

. ..
copy.c mydata.txt mydirectory/ myprog* myprog.c
./mydirectory:
file1 file2 file3

LISTADO MODIFICADO

El parámetro -l produce un formato de listado largo, proporcionando más información de cada

archivo:

$ ls -l

total 36
-rw-rw-r-- 2 sysadmin sysadmin 71 Dec 19 13:17 copy.c
-rw-rw-r-- 1 sysadmin sysadmin 15 Dec 19 13:26 mydata.txt
drwxrwxr-x 2 sysadmin sysadmin 4096 Dec 19 13:51 mydirectory
-rwxrwxr-x 1 sysadmin sysadmin 16696 Dec 19 13:18 myprog
-rw-rw-r-- 2 sysadmin sysadmin 71 Dec 19 13:17 myprog.c

Junto al nombre, muestra información adicional. La primera línea del listado muestra el
número total de bloques contenidos dentro del directorio. A continuación, cada línea contiene
la siguiente información acerca de cada fichero o directorio:

 El tipo de archivo, tal como si es directorio (d), fichero (-), dispositivo de caracteres (c)
o dispositivo de bloques (b).
  La cadena de permisos para el archivo, que consiste en los permisos para el usuario,
para el grupo y para otros usuarios.
 El número de hard links al archivo.
 El nombre de usuario de propietario del archivo.
 El nombre del grupo al que el archivo pertenece.
 El tamaño del archivo en bytes.
 La fecha y hora de la última modificación.
 El nombre del archivo.

PARÁMETROS DEL COMANDO LIST

El comando ls tiene montones de parámetros. Podemos verlo en las diferentes páginas del
comando man. El comando ls utiliza dos tipos de parámetros:

 Parámetros de una letra.

 Parámetros de palabra completa.

Los primeros son siempre precedidos de un guión (-). Los segundos son más descriptivos y
están precedidos de doble guión (--). Muchos parámetros tienen ambas versiones, y otros solo
un tipo. Veamos algunos de los más populares:

Letter -Word Description

-a --all Don’t ignore entries starting with a period.

-A --almost-all Don’t list the . and .. files.
--author Print the author of each file.
-b --escape Print octal values for nonprintable characters.
--block-size=size Calculate the block sizes using size-byte blocks.
-B --ignore-backups Don’t list entries with (~) symbol (backup copies).
-c Sort by time of last modification.
-C List entries by columns.
--color=when When to use colors (always, never, or auto).
-d --directory List directory entries instead of contents, and don’t
dereference symbolic links.
-F --classify Append file-type indicator to entries.
--file-type Only append file-type indicators to some filetypes (not
executable files).
--format=word Format output as across, commas, horizontal, long,
singlecolumn, verbose, or vertical.
-g List full file information except for the file’s owner.
--groupdirectories-first List all directories before files.
-G --no-group In a long listing, don’t display group names.
-h --human-readable Print sizes using K for kilobytes, M for megabytes, and G for
gigabytes.
--si Same as -h, but use powers of 1000 instead of 1024.
-i --inode Display the index number (inode) of each file.
-l Display the long listing format.
-L --dereference Show information for the original file for a linked file.
-n --numeric-uid-gid Show numeric userid and groupid instead of names.
-o In a long listing, don’t display owner names.
-r --reverse Reverse the sorting order when displaying files and directories.
-R --recursive List subdirectory contents recursively.
-s --size Print the block size of each file.
-S --sort=size Sort the output by file size.
-t --sort=time Sort the output by file modification time.
-u Display the last access time instead of last modification time
for all files.
-U --sort=none Don’t sort the output listing.
-v --sort=version Sort the output by file version.
-x List entries by line instead of columns.
-X --sort=extension Sort the output by file extension.

Podemos usar múltiples parámetros. Los parámetros con doble guión deben estar separados,
pero los de un guión pueden combinarse juntos usando solo un guión para todos. Una
combinación habitual es usar el -a para listar todos los archivos, -i para listar el inodo de cada
archivo, -l para producir un listado largo y -s para listar el tamaño de bloque de los archivos:

$ ls -sail

total 132
265238 4 drwxr-xr-x 4 sysadmin sysadmin 4096 Dec 19 13:45 .
262145 4 drwxr-xr-x 3 root root 4096 Nov 4 18:56 ..

262184 8 -rw------- 1 sysadmin sysadmin 4957 Dec 19 13:27 .bash_history

265244 4 -rw-r--r-- 1 sysadmin sysadmin 220 Feb 25 2020 .bash_logout
265240 4 -rw-r--r-- 1 sysadmin sysadmin 3771 Feb 25 2020 .bashrc
265296 4 drwx------ 2 sysadmin sysadmin 4096 Nov 4 18:57 .cache
263784 4 -rw-rw-r-- 2 sysadmin sysadmin 71 Dec 19 13:17 copy.c
262804 4 -rw-rw-r-- 1 sysadmin sysadmin 15 Dec 19 13:26 mydata.txt
395365 4 drwxrwxr-x 2 sysadmin sysadmin 4096 Dec 19 13:51 mydirectory
264036 20 -rwxrwxr-x 1 sysadmin sysadmin 16696 Dec 19 13:18 myprog
263784 4 -rw-rw-r-- 2 sysadmin sysadmin 71 Dec 19 13:17 myprog.c
265242 4 -rw-r--r-- 1 sysadmin sysadmin 807 Feb 25 2020 .profile
265302 0 -rw-r--r-- 1 sysadmin sysadmin 0 Nov 4 18:58 .sudo_as_admin_successful
263813 12 -rw------- 1 sysadmin sysadmin 10056 Dec 19 13:17 .viminfo
262207 48 -rw-rw-r-- 1 sysadmin sysadmin 49006 Nov 23 13:36 .zcompdump
265288 4 -rw-rw-r-- 1 sysadmin sysadmin 29 Nov 23 13:36 .zshrc

El primer número en el listado es el número de inodo. El segundo número es el tamaño de

bloque del archivo.

MANEJO DE DIRECTORIOS

Hay unos pocos comandos que trabajan tanto con ficheros como con directorios, y algunos
que trabajan solo con directorios.

CREAR DIRECTORIOS

Para crear un directorio usamos el comando mkdir:

$ mkdir dir3
 ELIMINAR DIRECTORIOS

Eliminar directorios puede ser peligroso. Hay muchas posibilidades de que ocurran cosas malas
si comenzamos a eliminar directorios. Bash intenta protegernos tanto como pueda. El
comando básico para eliminar un directorio es rmdir:

$ rmdir dir3
$ rmdir mydirectory

rmdir: failed to remove 'mydirectory': Directory not empty

Por defecto, el comando rmdir solo funciona para eliminar directorios vacíos. Podemos
eliminar directorios no vacíos usando el parámetro --ignore-fail-on-non-empty.

Podemos también usar el comando rm. Si lo usamos sin parámetros o con ficheros,
obtendremos un error:

$ rm mydirectory

rm: cannot remove 'mydirectory': Is a directory

Sin embargo, si realmente queremos eliminar un directorio, podemos usar el parámetro -r

para eliminar recursivamente los ficheros del directorio y luego el directorio mismo:

$ rm -r mydirectory

Si el directorio está protegido contra escritura, se pedirá confirmación de la petición de

eliminación. Podemos saltar esta pregunta agregando el parámetro -f.

MANEJO DE FICHEROS

Bash proporciona montones de comandos para manipular ficheros.

CREAR FICHEROS

En algún momento surgirá la situación de necesitar crear un fichero vacío. A veces las
aplicaciones esperan un fichero de log antes de ponerse a escribir en él. En esos casos
podemos usar el comando touch, que crea un fichero vacío:

$ touch test1
$ ls -il test1

263320 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:22 test1

El comando touch crea el nuevo fichero especificado y asigna nuentro nombre de usuario
como propietario. La longitud del fichero es cero. El comando touch puede utilizarse también
con un fichero existente, para cambiar las fechas de acceso y modificación sin alterar el
contenido del fichero:

$ touch test1
$ ls -il test1
263320 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:30 test1

Ahora la fecha de modificación está actualizada. Si queremos cambiar solo la fecha de acceso,
usaremos el parámetro -a. Para cambiar solo la fecha de modificación, usaremos el parámetro
-m.

Por defecto, touch usa la fecha actual. Podemos especificar la fecha usando el parámetro -t
con un valor timestamp específico:

$ touch -t 202112251200 test1

$ ls -l test1

-rw-rw-r-- 1 sysadmin sysadmin 0 Dec 25 2021 test1

Ahora la fecha de modificación está establecida en una fecha futura.

COPIAR FICHEROS

Otra práctica común es copiar ficheros y directorios de un origen a un destino, mediante el

comando cp. En su forma más básica, usa dos parámetros, el objeto origen y el objeto destino.
Cuando ambos son nombres de fichero, el comando cp copia el fichero origen a un nuevo
fichero con el nombre especificado como destino. El nuevo fichero actúa enteramente como
un nuevo fichero, con sus fechas actualizadas de creación y última modificación:

$ cp test1 test2
$ ls -il test*

263320 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 25 2021 test1

263324 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:27 test2

El nuevo fichero muestra un número de inodo diferente, indicando que es un fichero

completamente nuevo.

Si el fichero de destino ya existe, el comando cp sobreescribe el existente por defecto. Esto

podría ser peligroso. Agregando el parámetro -i nos preguntará si queremos sobreescribir el
fichero de destino (en caso de que ya exista):

$ cp -i test1 test2

cp: overwrite 'test2'? y

Si no contestamos (y), la copia no continuará.

También podemos copiar un fichero en un directorio existente, especificando el directorio

como destino:

$ mkdir dir1
$ cp test1 dir1
$ ls -il dir1
total 0
395391 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:31 test1

Los ejemplos anteriores usan rutas relativas, pero podemos usar rutas absolutas. Para copiar
un fichero al directorio actual:

$ cp /home/sysadmin/dir1/test1 .
$ ls -il test1

263320 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:33 test1

Como la mayoría de comandos, el comando cp tiene algunos parámetros:

Parameterf Description

-a Archive files by preserving their attributes.

-b Create a backup of each existing destination file instead of overwriting it.
-d Preserve.
-f Force the overwriting of existing destination files without prompting.
-i Prompt before overwriting destination files.
-l Create a file link instead of copying the files.
-p Preserve file attributes if possible.
-r Copy files recursively.
-R Copy directories recursively.
-s Create a symbolic link instead of copying the file.
-S Override the backup feature.
-u Copy the source file only if it has a newer date and time than the destination
(update).
-v Verbose mode, explaining what’s happening.
-x Restrict the copy to the current filesystem.

Usaremos el parámetro -p para preservar las fechas de acceso o modificación del fichero
original para el fichero copiado:

$ cp -p test1 test3
$ ls -il test*

263320 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:33 test1

263324 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:30 test2
263725 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:33 test3

El parámetro -R es poderoso. Permite copiar recursivamente el contenido de un directorio

completo en un solo comando:

$ cp -R dir1 dir2
$ ls -l dir*

dir1:
total 0
-rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:31 test1
dir2:
total 0
-rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:38 test1

Ahora dir2 es una copia completa de dir1.

También podemos usar wildcards:

$ cp test* dir2
$ ls -al dir2

total 8
drwxrwxr-x 2 sysadmin sysadmin 4096 Dec 19 14:42 .
drwxr-xr-x 5 sysadmin sysadmin 4096 Dec 19 14:38 ..
-rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:42 test1
-rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:42 test2
-rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:42 test3

Esto ha copiado todos los ficheros que comenzaban con “test” al directorio dir2.

ENLAZAR FICHEROS

Un par de parámetros del comando cp se refieren a ficheros enlazados. Si necesitamos

mantener dos o más copias del mismo fichero, en lugar de tener copias físicas separada,
podemos usar un fichero físico y múltiples copias virtuales, llamados enlaces. Un enlace es una
entrada en un directorio que apunta a la ubicación real del fichero. Hay dos tipos de enlaces en
Linux:

 Enlace simbólico o soft link.

 Enlace físico o hard link.

El hard link crea un fichero separado que contiene información acerca del fichero original y
dónde localizarlo. Cuando referenciamos un fichero hard link, es como si referenciáramos el
fichero original:

$ cp -l test1 test4
$ ls -il test*

263320 -rw-rw-r-- 2 sysadmin sysadmin 54 Dec 19 14:33 test1

263324 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:30 test2
263725 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:33 test3
263320 -rw-rw-r-- 2 sysadmin sysadmin 54 Dec 19 14:33 test4

El parámetro -l ha creado un hard link test4 para el fichero test1. El listado muestra como sus
números de inodo son el mismo (hay un único inodo), es decir, son el mismo fichero.También
el contador de links (tercer elemento de la lista) ahora muestra que ambos ficheros tienen 2
enlaces.

ENLACES DUROS Y PARTICIONES

Solo podemos crear un hard link entre ficheros que estén en la misma partición de disco. No
podemos crear enlaces entre ficheros bajo puntos de montaje separados. En ese caso,
tendrémos que usar un soft link.
El parámetro -s crea un soft link (enlace simbólico).

$ cp -s test1 test5
$ ls -il test*

263320 -rw-rw-r-- 2 sysadmin sysadmin 54 Dec 19 14:33 test1

263324 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:30 test2
263725 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:33 test3
263320 -rw-rw-r-- 2 sysadmin sysadmin 54 Dec 19 14:33 test4
263840 lrwxrwxrwx 1 sysadmin sysadmin 5 Dec 19 14:46 test5 -> test1

El nuevo test5 tiene un número de inodo diferente al de test1, indicando que Linux lo trata
como un fichero separado. El tamaño de archivo es diferente. Un fichero enlazado necesita
almacenar solo la información acerca del fichero con el que está enlazado, no el contenido del
fichero. Además, el nombre de fichero muestra la relación entre ambos ficheros, y también
cambia el número que indica la cantidad de enlaces.

En lugar de usar el comando cp para enlazar ficheros, podemos usar el comando ln. Por
defecto, el comando ln crea hard links. Si queremos soft links, deberemos usar el parámetro -s.

MANEJO DE FICHEROS ENLAZADOS

Hay que tener cuidado al copiar ficheros enlazados. Si usamos el comando cp para copiar un
fichero que está enlazado a otro fichero origen, todo lo que estamos haciendo es crear otra
copia del fichero origen, lo que puede confundir.

En lugar de copiar el fichero enlazado, podemos crear otro enlace al fichero original. Podemos
tener muchos enlaces al mismo fichero sin problema. Sin embargo, lo que no queremos es
crear soft links a otros ficheros que ya son soft links. Esto crea una cadena de enlaces que no
solo puede resultar confuso, sino que dicha cadena puede ser fácilmente rota, causando todo
tipo de problemas.

RENOMBRAR FICHEROS

En Linux, renombrar ficheros se llama mover ficheros. El comando mv está disponible tanto
para ficheros como para directorios:

$ mv test2 test6
$ ls -il test*

263320 -rw-rw-r-- 2 sysadmin sysadmin 54 Dec 19 14:48 test1

263725 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:33 test3
263320 -rw-rw-r-- 2 sysadmin sysadmin 54 Dec 19 14:48 test4
263840 lrwxrwxrwx 1 sysadmin sysadmin 5 Dec 19 14:48 test5 -> test1
263324 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:30 test6

Al mover el fichero hemos cambiado el nombre de fichero, pero mantenido el mismo número
de inodo y valor timestamp. Mover un fichero con soft links es un problema:

$ mv test1 test8
$ ls -il test*

263725 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:33 test3

263320 -rw-rw-r-- 2 sysadmin sysadmin 54 Dec 19 14:48 test4
263840 lrwxrwxrwx 1 sysadmin sysadmin 5 Dec 19 14:48 test5 -> test1
263324 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:30 test6
263320 -rw-rw-r-- 2 sysadmin sysadmin 54 Dec 19 14:48 test8

El fichero test4 que usa un hard link aún usa el mismo número de inodo, lo cual está bien. Sin
embargo, el fichero test5 ahora apunta a un fichero no válido, y ya no es un enlace válido. Si
nuestra terminal soporta colores, es probable que aparezca en color rojo.

También podemos usar el comando mv para mover directorios:

$ mv dir2 dir4

El contenido completo del directorio no ha cambiado. Solo ha cambiado en este caso el

nombre del directorio.

ELIMINAR FICHEROS

En Linux usaremos el comando rm para eliminar ficheros. El formato es:

$ rm -i test3

rm: remove regular empty file 'test3'? y

$ ls -il test*

263320 -rw-rw-r-- 2 sysadmin sysadmin 54 Dec 19 14:48 test4

263840 lrwxrwxrwx 1 sysadmin sysadmin 5 Dec 19 14:48 test5 -> test1
263324 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 14:30 test6
263320 -rw-rw-r-- 2 sysadmin sysadmin 54 Dec 19 14:48 test8

De igual modo que con el comando rmdir, podemos usar el parámetro -i para que nos
pregunte. No existe papelera en el CLI. Una vez eliminado un fichero, ya no es recuperable.

WILDCARDS

Los comandos ls, cp, mv y rm pueden trabajar con más de un fichero o directorio. Para ello
utilizaremos una técnica llamada globbing. Globbing es básicamente la técnica de usar
caracteres wildcard dentro de un nombre de fichero o directorio. Esto permite especificar un
patrón que coincida con múltiples archivos. Hay dos caracteres básicos que usar:

 Símbolo de interrogación (?), que representa un único carácter.

 Símbolo de asterisco (*), que representa cero o más caracteres.

Por ejemplo, especificando file?.txt en un comando rm, eliminará cualquier fichero que
comience por “file” seguido de un carácter, y que acabe con .txt:

$ ls -il file*
265217 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 15:05 file.txt
265214 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 15:05 file11.txt
263855 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 15:04 file1.txt
265146 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 15:04 file2.txt

$ rm file?.txt
$ ls -il file*

265217 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 15:05 file.txt

265214 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 15:05 file11.txt

Usaremos el asterisco para que coincida con cero o más caracteres:

$ rm file*
$ ls -il file*

ls: cannot access 'file*': No such file or directory

QUOTING

Otra posibilidad es que debamos usar ficheros o directorios que contengas espacios en sus
nombres. Esto es totalmente válido en Linux, pero puede causarnos algún problema:

$ ls -l long*

-rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 15:09 'long file name.txt'

$ rm long file name.txt

rm: cannot remove 'long': No such file or directory

rm: cannot remove 'file': No such file or directory
rm: cannot remove 'name.txt': No such file or directory

El problema es que, por defecto, el comando rm usa un espacio para indicar el fin de un
nombre de fichero, por lo que piensa que queremos eliminar tres ficheros separados (long, file
y name.txt). Por ello necesitamos acotar (quoting) los nombres que contengan espacios:

$ rm 'long file name.txt'

$ ls -il long*

ls: cannot access 'long*': No such file or directory

Se pueden usar tanto comillas simples como comillas dobles.

CASE SENSITIVITY

Hay que tener en cuenta que Linux es case-sensitive, por lo que ficheros y directorios pueden
contener mayúsculas y minúsculas:

$ ls -il *.txt
263725 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 15:13 file1.txt
263855 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 15:12 File1.txt

$ rm file1.txt
$ ls -il *.txt

263855 -rw-rw-r-- 1 sysadmin sysadmin 0 Dec 19 15:12 File1.txt

Si no estamos seguros de si un carácter puede ir en mayúsculas o minúsculas, podemos usar el

símbolo de interrogación para representar cualquier carácter:

$ rm ?ile1.txt

ENCONTRAR ARCHIVOS

A menudo puede ser difícil encontrar los archivos que buscamos. Por ello Linux proporciona
varias características para buscar.

COMANDO WHICH

Podemos usar el comando which para encontrar dónde están almacenados programas y
utilidades. Por ejemplo, si tenemos dos versiones de un programa instaladas en el sistema, o si
no estamos seguros de si un comando está construido dentro del shell Linux o proporcionado
como utilidad separada. El formato es:

$ which touch

/usr/bin/touch

La salida del comando which muestra la ruta completa donde el comando está almacenado. Si
tenemos dos versiones de un programa, mostrará la que correrá cuando lo escribamos en la
línea de comandos. Si necesitamos usar una versión diferente, tendríamos que usar la ruta
completa al fichero de programa.

COMANDO LOCATE

Muchas distribuciones contienen el comando locate por defecto. Si no es así, normalmente se

encuentra en el paquete mlocate.

El comando locate usa una base de datos que realiza un seguimiento de la situación de
ficheros en el sistema. Cuando usamos el comando locate, busca en la base de datos para
encontrar el fichero solicitado. Este proceso es a menudo más rápido que andar buscando en
el sistema de archivos.

La clave para el comando locate es la información contenida en la base de datos. Solo puede
encontrar ficheros que han sido indizados en la base de datos. La información en la base de
datos es actualizada por el programa llamado updatedb. Linux corre este programa en
background. Hay que tener cierto cuidado al usar el comando locate, pues podemos encontrar
más de lo que buscábamos.
$ locate touch

/snap/core18/1932/bin/touch
/snap/core18/1932/lib/udev/hwdb.d/70-touchpad.hwdb
/snap/core18/1932/lib/udev/rules.d/70-touchpad.rules
/snap/core18/1932/usr/bin/touch
/snap/core18/1944/bin/touch
/snap/core18/1944/lib/udev/hwdb.d/70-touchpad.hwdb
/snap/core18/1944/lib/udev/rules.d/70-touchpad.rules
/snap/core18/1944/usr/bin/touch
/usr/bin/touch
...

El comando locate devuelve cualquier fichero que contenga la palabra touch en su nombre.
Necesitaremos filtrar los resultados para encontrar el fichero que buscamos.

Otro lado negativo del comando locate es que no puede encontrar ningún fichero agregado
recientemente hasta la siguiente ejecución del programa updatedb. Algunos sistemas lo hacen
de forma habitual, cada ciertos minutos, mientras que otros pueden tenerlo programado para
que corra solo una o dos veces al día.

COMANDO WHEREIS

El comando whereis es similar al which en que busca una ocurrencia específica del fichero que
estamos buscando. Sin embargo, solo busca en directorios de ficheros binarios, directorios de
librerías y directorios de documentación, lo que ayuda a agilizar el proceso de búsqueda. Esto
es bueno para encontrar no solo comandos, sino también ficheros de documentación que los
acompañen:

$ whereis touch

touch: /usr/bin/touch /usr/share/man/man1/touch.1.gz

En el ejemplo, el comando whereis devuelve la ubicación del fichero de programa de touch, y

la ubicación de la página de manual asociada con dicho programa.

COMANDO FIND

El último recurso para encontrar ficheros es el comando find. Hace una búsqueda física a
través del árbol de directorio virtual buscando un fichero específico. Cuanto mayor sea el área
de búsqueda, más tardará en responder. El área de búsqueda se especifica como primer
parámetro del comando find:

$ find /home/sysadmin -name myprog -print

/home/sysadmin/myprog

En el ejemplo se restringe la búsqueda al directorio /home/sysadmin, para encontrar el fichero

llamado myprog. La opción -name el nombre de fichero a buscar, y la opción -print le dice al
comando find que muestre los resultados.
El comando find puede buscar ficheros basándose en montones de criterios diferentes además
de por el nombre, como la fecha de creación, el propietario del fichero, el tamaño del fichero o
incluso por permisos del fichero. Por ejemplo, para buscar todos los ficheros por encima de 1
MB, o listar todos los ficheros que sean mayores de 5000 caracteres:

$ find . -size +5000c -print

./.zcompdump
./myprog
./.viminfo

El parámetro +5000c le dice al comando find que busque por ficheros (en el directorio actual)
que tengan un tamaño de más de 5000 caracteres.

Algunas opciones útiles:

Option Description
-amin n File was last accessed n minutes ago.
-atime n File was last accessed n days ago.
-ctime n File was last changed n minutes ago.
-inum n Match the file inode number to the number specified.
-name pattern Match the file name to the pattern specified.
-perm pattern Match the file permissions to the pattern specified.
-size n Match the file size to the amount specified.
-user name Match the file owner to the name specified.

ARCHIVADO

Cuantos más datos necesitemos almacenar, más espacio en disco se requiere. Aunque los
tamaños de disco hayan ido aumentando con el tiempo, todavía existen límites. Para ayudar
con esto, podemos usar algunas herramientas de archivado de ficheros para comprimir los
ficheros de datos usados para almacenaje y compartición.

COMPRESIÓN

En Windows se suele usar el formato de compresión de archivos zip. La utilidad de compresión

PKZip llegó a ser tan usada, que de hecho Microsoft la llegó a incorporar en su sistema
operativo a partir de Windows XP.

Linux proporciona algunas herramientas para comprimir ficheros. Esto a veces puede conducir
a confusión al intentar descargar y extraer ficheros comprimidos:

Utility Extension Description

bzip2 .bz2 Uses the Burrows-Wheeler block sorting text compression

algorithm and human coding
compress .Z Original Unix file compression utility, but starting to fade away
into obscurity
gzip .gz The GNU Project’s compression utility; uses the open-source
Lempel-Ziv_Welch coding
xz .xz A general-purpose compression utility gaining in popularity
zip .zip The Unix version of the PKZip program for Windows

La utilidad compress puede trabajar con ficheros comprimidos en sistemas Unix estándar, pero
no se encuentra a menudo installada por defecto en los sistemas Linux. Si descargamos un
fichero con una extensión .Z, podemos normalmente instalar el paquete compress del
repositorio. La utilidad zip crea directorios comprimidos que pueden ser extraidos en sistemas
Windows, pero no tiene el mejor algoritmo de compresión si estamos manteniendo los
ficheros en un sistema Linux.

La utilidad gzip es la herramienta de compresión más popular en Linux. Es una creación del
GNU Project, como intento de crear una versión libre de la utilidad original compress de Unix.
Este paquete incluye tres ficheros principales:

 gzip para comprimir ficheros.

 gzcat para mostrar los contenidos de ficheros de texto comprimidos.
 gunzip para descomprimir ficheros.

El comando gzip comprime el fichero especificado. Podemos especificar más de uno o incluso
usar wildcards:

$ gzip my*

En el ejemplo se comprime cada archivo del directorio actual que comience por “my”.

CREAR FICHEROS DE ARCHIVO

Aunque el comando gzip no solo puede comprimir datos, sino también archivar los datos en un
único fichero, no es la utilidad estándar usada para archivar grandes cantidades de datos en
Unix o Linux. La más popular desde lejos como herramienta de archivado en Unix y Linux es el
comando tar. El comando tar fue originalmente usado para hacer backup de ficheros en un
dispositivo de cinta (tape).

Sin embargo, también puede escribir la salida en un fichero. Es común ver ficheros de código
fuente empaquetados en un fichero tar (a menudo llamado un tarball) para su distribución.

El formato del comando tar:

tar function [options] object1 object2

El parámetro function define qué debería hacer el comando tar. dichas funciones pueden ser:

Function Description

-a Appends an existing tar archive file to another tar archive file

-c Creates a new tar archive file
-d Checks the differences between a tar archive file and the filesystem files
-r Appends files to an existing tar archive file
-t Lists the contents of an existing tar archive file
-u Appends files to an existing tar archive file that are newer than a file with the
same in the archive
-x Extracts files from an existing tar archive file
Cada función usa una o más opciones para definir un comportamiento específico para el
fichero tar. Opciones que podemos usar con tar:

Option Description

-C dir Changes to the specified directory

-f file Outputs results to the file (or device) specified
-j Redirects output to the bzip2 command for compression
-P Preserves all file permissions
-v Lists files as they are processed
-z Redirects the output to the gzip command for compressions

Aunque la combinación de varias funciones con varias opciones parece complicado para
recordar, en la práctica nos encontraremos usado simplemente un puñado de combinaciones
para hacer las tareas habituales. La siguiente sección echa un vistazo a los escenarios de
archivado más comunes que podríamos encontrar.

ESCENARIOS DE ARCHIVADO

Normalmente hay solo tres cosas básicas que necesitaremos hacer con el comando tar:

 Archivar ficheros para crear un tarball.

 Listar los ficheros contenidos en un tarball.
 Extraer los ficheros que hay en un tarball.

Esto ayuda a simplificar las características de función y opción que necesitamos recordar para
el comando tar. Podemos comenzar creando un nuevo fichero de archivado:

$ tar –cvf test.tar test/ test2/

Este comando crea un fichero de archivado llamado test.tar que contiene los contenidos de los
directorios test y test2. La opción -v es útil ya que va mostrando los ficheros a medida que van
siendo agregados al tarball.

Para mostrar los contenidos del fichero tarball:

$ tar –tf test.tar

La función -t lista los contenidos del tarball a la salida estándar por defecto, que es la pantalla.
Los ficheros no son extraidos, solo listados.

Finalmente, para extraer los ficheros del tarball:

$ tar –xvf test.tar

Esto extrae los contenidos de fichero test.tar al directorio actual. Si el fichero tar fue creado a
partir de una estructura de directorios, la estructura de directorios entera es recreada
comenzando a partir del directorio actual.