Administración básica

Para realizar esta práctica utilizaremos una de las máquinas virtuales que generamos en la práctica anterior. En esta práctica aprenderemos a utilizar la línea de comandos y a realizar todas las tareas para poder manejar un servidor con linux:

Un poco de teoría antes de empezar

Estructura del sistema de archivos

En un sistema Linux, todas las carpetas y ficheros en el sistema de fichero pende del directorio raíz que se representa con la /.

/
├── bin
├── usr
│   ├── local
│   ├── bin
│   └── ...
├── dev
│   ├── sda
│   ├── sda1
│   └── ...
├── home
│   ├── practica
│   │   ├── tema1.pdf
│   │   ├── boletin1.pdf
│   │   └── ...
│   ├── profesor
│   └── ...
└── etc
    ├── firefox
    ├── libvirt
    ├── ...
    └── ...

Rutas relativas y rutas absolutas

Una ruta absoluta será aquella que empiece por /, siempre nos dará la ruta empezando por la raíz. Por ejemplo: '/home/ubuntu/'

Una ruta relativa, siempre dependerá del directorio en el que nos encontremos previamente, si nos encontramos por ejemplo en el directorio '/home/', una ruta relativa sería 'ubuntu/'

Intérprete de órdenes o de comandos

Es un programa informático que traduce los comandos que el usuario inserta. Por defecto, el intérprete que se utilizará será bash, aunque hay otras alternativas como zsh.

Comando

Un comando es una instrucción que el usuario puede proponercionar a través de la línea de órdenes. Suelen admitir parámetros o argumentos de entrada.

Por ejemplo, existe el comando 'man', que es útil para ver manuales de otros comandos.

Este admite parámetros y argumentos, como por ejemplo:

man ls

Nos da información del manual de instrucciones del comando ls.

También podemos por ejemplo, añadir el parámetro --help, el cual contiene casi todos los comandos y nos ayuda a ver que parámetros y argumentos admiten:

man --help

Paso 1: Visualizar ficheros y directorios

pwd

Imprime el directorio actual, donde nos encontramos, por defecto suele ser la home del usuario.

pwd

Salida:

/home/ubuntu

ls

Lista los ficheros y directorios. Si no le pasamos como argumento un directorio, listará el actual.

ls

Por defecto no habrá nada, vamos a pasar darle el directorio raiz para ver la estructura mencionada al inicio de la práctica:

ls /

Salida:

bin  boot  data  dev  etc  home  initrd.img  initrd.img.old  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  snap  srv  sys  tmp  usr  var  vmlinuz  vmlinuz.old

Veamos algunas de las opciones que tiene este argumento:

• -a: muestra todo, incluso ficheros 'ocultos' (cualquier fichero que empieze

 por . es considerado 'oculto')

• -l: formato largo, donde mostramos permisos y en forma de lista

Probemos las opciones:

ls -a

Ahora si encontramos ficheros:

.  ..  .bash_history  .bash_logout  .bashrc  .profile  .ssh

Vemos al inicio . y ..:

.: hace referencia al directorio actual ..: hace referencia al directorio padre

Ahora unamos varias opciones:

ls -la /

Salida similar a la siguiente:

total 92
drwxr-xr-x  24 root root  4096 Aug 28 09:50 .
drwxr-xr-x  24 root root  4096 Aug 28 09:50 ..
drwxr-xr-x   2 root root  4096 Aug 22 12:37 bin
drwxr-xr-x   4 root root  4096 Aug 22 12:37 boot
drwx------   3 root root  4096 Aug 28 09:50 data
drwxr-xr-x  18 root root  3780 Aug 28 09:46 dev
drwxr-xr-x  93 root root  4096 Aug 28 13:51 etc
drwxr-xr-x   3 root root  4096 Aug 28 09:46 home
lrwxrwxrwx   1 root root    33 Aug 22 12:35 initrd.img -> boot/initrd.img-4.15.0-58-generic
lrwxrwxrwx   1 root root    33 Aug 22 12:35 initrd.img.old -> boot/initrd.img-4.15.0-58-generic
drwxr-xr-x  20 root root  4096 Aug 22 12:35 lib
drwxr-xr-x   2 root root  4096 Aug 22 12:34 lib64
drwx------   2 root root 16384 Aug 22 12:36 lost+found
drwxr-xr-x   2 root root  4096 Aug 22 12:34 media
drwxr-xr-x   2 root root  4096 Aug 22 12:34 mnt
drwxr-xr-x   3 root root  4096 Aug 28 09:49 opt
dr-xr-xr-x 111 root root     0 Aug 28 09:46 proc
drwx------   3 root root  4096 Aug 28 09:46 root
drwxr-xr-x  26 root root   940 Aug 28 13:51 run
drwxr-xr-x   2 root root  4096 Aug 28 09:49 sbin
drwxr-xr-x   2 root root  4096 Aug 28 09:46 snap
drwxr-xr-x   2 root root  4096 Aug 22 12:34 srv
dr-xr-xr-x  13 root root     0 Aug 28 09:46 sys
drwxrwxrwt  10 root root  4096 Aug 28 16:00 tmp
drwxr-xr-x  11 root root  4096 Aug 28 09:49 usr
drwxr-xr-x  13 root root  4096 Aug 22 12:36 var
lrwxrwxrwx   1 root root    30 Aug 22 12:35 vmlinuz -> boot/vmlinuz-4.15.0-58-generic
lrwxrwxrwx   1 root root    30 Aug 22 12:35 vmlinuz.old -> boot/vmlinuz-4.15.0-58-generic

cd

Cambiar el directorio de trabajo o directorio actual.

cd /

Esto nos mueve al directorio raiz, hagamos ahora un pwd para ver donde estamos:

pwd

Salida:

/

Ejercicio:

1. Cambiar el directorio actual a /home
2. Movernos al directorio de nuestro usuario usando rutas relativas

Solución:

cd /home
ls
cd ubuntu

Atajos

El comando cd, si no le pasamos parámetro ninguno, por defecto nos moverá a la carpeta del usuario.

cd /
cd

Si nuestro usuario es ubuntu, acabaremos en /home/ubuntu

Paso 2: Creación y modificación de ficheros y directorios

mkdir

Crea un nuevo directorio.

mkdir test

Crea una carpeta test en el directorio actual.

Comprobemos que se ha creado bien:

ls

Ahora vamos a ver un parámetro muy utilizado en mkdir, que es el -p, utilizado para crear directorios padres si no existen:

mkdir -p grandparent/parent/children

Sin el -p, este comando fallaría, pero con el -p, nos crea los directorios padres si no existen.

touch

Crea un nuevo fichero vacío.

touch file.txt
touch test/file.txt

Comprobamos que hemos creado ambos ficheros:

ls
ls test

cp

Copia un fichero o directorio. Si intentamos copiar un directorio con contenido, tendremos que usar la opción -r (recursivo)

cp file.txt file_copy.txt
cp -r test test_copy

Comprobamos:

ls
ls test_copy/

mv

Mueve un fichero o directorio. Muy similar al comando cp.

mv file_copy.txt file2.txt
mv test_copy test2

Comprobamos:

ls

rm

Borra un fichero o directorio

rm file2.txt
rm -r test2

Comprobamos:

ls

Ejercicios:

1. Crear la siguiente estructura dentro del directorio /tmp (usar los comandos mkdir, touch y cp):

/tmp ├── carpeta1 ├── carpeta2 │   ├── fichero1.txt │   └── fichero2.md └── carpeta3

   ├── fichero1.txt
   └── fichero2.md

1. Basándonos en el ejercicio anterior, cambiar la estructura a la siguiente (usar comandos mv y rm):

/tmp └── carpeta

   ├── fichero1.txt
   └── fichero2.md

Paso 3: Manejo de ficheros y directorios más avanzado

echo

Sirve para imprimir una línea de texto por pantalla o imprimir variables de entorno.

echo "Hola"

Una variable de entorno es una variable editada con algún valor, por defecto existen algunas creadas, como por ejemplo la variable HOME, que contiene el directorio del usuario:

echo $HOME

Aprovecharemos y crearemos una variable nosotros:

ME="my name"

Comprobamos:

echo $ME

> vs >>

> y >> sirve para redirigir una salida. Por ejemplo, utilizando el comando echo, podemos enviar un texto dentro de un fichero:

echo "Esto es una prueba" > file.txt

La diferencia entre > y >> es que > sobrescribe lo que haya en el fichero y añade el contenido, y >> no sobrescribe, solo añade el nuevo contenido.

Hagamos la prueba:

echo "Esto es una prueba" > file.txt
echo "Esto es una prueba2" > file.txt
echo "Esto es una prueba" >> file2.txt
echo "Esto es una prueba2" >> file2.txt

No preocuparos si el fichero no existe, se creará en caso de no existir.

cat

Sirve para mostrar el contenido de un fichero, nos vendrá bien para comprobar como ha funcionado el comando anterior.

cat file.txt
cat file2.txt

grep

Sirve para buscar patrones en ficheros y mostrarlos por la salida estándar. Muy útil a la hora de programar para buscar ciertas variables o funciones en ficheros.

Por ejemplo, vamos a buscar todas las líneas en todos los ficheros que tengamos en el directorio actual que contengan la palabra prueba:

grep -nr prueba *

El -n nor sirve para que nos muestre el número de línea, y el -r para hacer el comando recursivo y buscar dentro de las carpetas existentes. Por último, el . es donde le damos el directorio, en este caso, el directorio actual.

La salida será similar a:

file.txt:1:Esto es una prueba
file2.txt:1:Esto es una prueba
file2.txt:2:Esto es una prueba

wc

Sirve para realizar diferentes tipos de conteos, como palabras, caracteres, líneas o bytes. Algunos de los parámetros más utilizados:

• -l: cuenta el número de líneas
• -w: cuenta el número de palabras
• -m: cuenta el número de caracteres
• -c: cuenta el número de bytes

Probemos y contemos todo en el fichero file2.txt:

wc -l file2.txt
wc -w file2.txt
wc -m file2.txt
wc -c file2.txt

Podemos contar más de un fichero a la vez:

wc -l file.txt file2.txt

Nos mostrará el conteo de cada fichero y el total.

Tubería (|)

La tubería nos servirá para conectar varios comandos al mismo tiempo, veamos unos ejemplos, que siempre se entiende mejor:

cat file2.txt | grep prueba
grep -nr prueba file2.txt | wc -l

En el primer ejemplo, mostramos el contenido de file2.txt, y esta salida se la pasamos al comando grep, el cual busca las líneas que contengan prueba.

En el segundo, buscamos todas las líneas que contengan la palabra prueba, y esta salida se la pasamos al comando wc, el cual cuenta las líneas de la salida del comando grep.

Redirecciones

Vamos a ver unos conceptos antes de seguir:

• Entrada estándar: representa los datos que necesita una aplicación para

 funcionar, como por ejemplo un archivo de datos o información ingresada desde
 la terminal y es representado en la terminal como el tipo 0.

• Salida estándar: es la vía que utilizan las aplicaciones para mostrarte

 información, allí podemos ver el progreso o simplemente los mensajes que la
 aplicación quiera darte en determinado momento y es representado en la
 terminal como el tipo 1.

• Error estándar: es la forma en que los programas te informan sobre los

 problemas que pueden encontrarse al momento de la ejecución y es representado
 en la terminal como el tipo 2.

Las redirecciones nos sirven para mover la información de un tipo a otro.

Ya vimos previamente el uso de > y >>, y también el |, veamos algunas más:

• comando < fichero: Toma la entrada de fichero
• comando 2> fichero: Envía la salida de error de comando a fichero
• comando 2>&1: Envía la salida de error a la salida estándar
• comando &> fichero: Envía la salida estándar y de error a fichero; equivale a

 comando > fichero 2>&1

Paso 4: Usuarios y grupos

whoami

Sirve para obtener el usuario actual.

whoami

Lo más seguro es que nos aparezca ubuntu.

who

Es para saber quien está ahora mismo en la máquina conectado.

who

Seguramente solo estemos nosotros:

ubuntu   pts/0        2019-08-28 13:51 (192.168.122.1)

su y sudo

su (substitute user): sirve para cambiar de usuario. Por ejemplo:

su root

Aquí nos pedirá la contraseña del usuario al que queramos cambiar.

sudo (super user do): no todas las distribuciones lo integran, porque es menos seguro que su, este comando nos permite ejecutar un comando siendo otro usuario, por defecto, si no le damos usuario, lo hará con el usuario root. Si sudo nos pide contraseña, nos pide la contraseña del usuario, ya que el usuario es que el tiene permisos para usar sudo o no.

sudo ls -a /root

Si tuviéramos por ejemplo un usuario 'practica' y quisíeramos ejecutar un comando en su nombre:

sudo -u practica ls

adduser y useradd

Ambos comandos sirven para crear un nuevo usuario, pero tienen sus diferencias.

useradd es un comando del sistema, y adduser es un script escrito en perl que utiliza el comando useradd. La diferencia así de primeras es que adduser nos crear el directorio /home/usuario y useradd necesita la opción -m para hacer lo mismo. Se puede utilizar el que se quiera, aunque es más recomendable useradd, ya que funcionará igual en todas las distribuciones.

Vamos a añadir un usuario practica con su directorio en /home (notemos que necesitamos permisos de super usuario para realizar esta tarea):

sudo useradd -m practica

Vamos a comprobar que el directorio home está creado y que el usuario practica funciona:

ls /home  # veremos el directorio practica
sudo -u practica whoami  # nos dirá que somo el usuario practica

passwd

Sirve para modificar la contraseña de un usuario, por ejemplo, vamos a modificar la contraseña del usuario que hemos creado previamente:

sudo passwd practica

Nos preguntará dos veces la contraseña, y ya la tendremos actualizadas. Vamos ahora a probar ahora el comando su para cambiar de usuario:

su practica
whoami

Veremos que hemos cambiado de usuario, para cerrar este usuario, escribimos 'exit' o pulsamos 'CTLR + D'

deluser y userdel

Ambos sirven para borrar un usuario, similar a adduser y useradd, userdel es el comando y deluser el script.

Vamos a borrar el usuario que hemos creado, incluyendo el borrado de su /home (opción -r):

userdel -r practica

Comprobemos que ya no tenemos usuario ni /home:

ls /home
sudo -u practica whoami

addgroup y groupadd

Ambos sirven para crear un grupo. Los grupos sirven para agrupar a los usuarios y que estos tengan unos mismos permisos. Por ejemplo, cuando instalamos algunas herramientas como por ejemplo docker, este crea el grupo docker automáticamente para que fácilmente podamos añadir a un usuario al grupo, y este tenga los permisos para trabajar con dicha herramienta.

Vamos a crear un nuevo grupo, vamos a llamarle invitado:

sudo groupadd invitado

usermod y groups

usermod es utilizado para asignar un grupo a un usuario.

groups es utilizado para ver los grupos a los que pertenece un usuario.

Vamos a añadir a un usuario practica, lo vamos a añadir al grupo invitado y veremos los grupos a los que pertenece:

sudo useradd -m practica
sudo usermod -G invitado practica
groups practica

Veremos que el usuario práctica pertenece al grupo invitado.

delgroup y groupdel

Ambos sirven para eliminar un grupo. Vamos a eliminar el grupo que hemos creado anteriormente:

sudo groupdel invitado

Podemos observar ahora que el usuario practica no pertenece al grupo invitado:

groups practica

Paso 5: Permisos

Nomenclatura rwx y numérica

Si hacemos un ls -l, la primera cadena que nos aparece son los permisos del fichero (-rwxrw-r--), podemos dividirlo en 4 elementos:

- (rwx) (rw-) (r--) | | | | type owner group others

• type: el tipo de fichero, pudiendo ser d (directorio), l (enlace simbólico), - (fichero normal)
• owner: permisos de propietario
• group: permisos de grupo
• others: permisos para los demás usuarios

Significado de los permisos:

• r: permisos de lectura
• w: permisos de escritura
• x: permisos de ejecución

Por último, existe un modo abreviado para estos permisos que se utiliza con números.

rwx 001 en binario es 1 en decimal. Permisos de ejecución 010 en binario es 2 en decimal. Permisos de escritura 100 en binario es 4 en decimal. Permisos de lectura

La suma de los permisos, nos da el valor numérico. Veamos un ejemplo: rwx rw- r-- 111 110 100

7   6   4

chmod

Permite cambiar los permisos de acceso a un fichero o directorio. Podemos dar permisos de dos formas diferentes.

modo carácter

Veamos primero unos detalles:

Clases de usuario:

• owner (u)
• group (g)
• others (o)
• all (a)

Modificador:

• añadir (+)
• eliminar (-)
• sobrescribir (=)

Para dar permisos tendríamos que seleccionar la clase de usuario el modificador y los permisos, veamos un ejemplo:

chmod u+x file  # añadimos permisos de ejecución al usuario
chmod go-w file  # quitamos permisos de escritura al grupo y a otros usuarios
chmod u=rwx,go=r file  # Al usuario le damos todos los permisos, y al grupo y otros solo le damos permisos de lectura

Modo octal

Con el modo octacl, es como si siempre utilizáramos el modificar sobrescribir, pongamos algunos ejemplos:

chmod 744 file  # Al usuario le damos todos los permisos, y al grupo y otros solo le damos permisos de lectura
chmod 777 file  # Todos tienen permisos para todo
chmod 600 file  # solo el propietario tiene permisos de lectura y escritura

Ejemplos

Vamos a ver como funciona el tema de permisos con unos ejemplos. Vamos a crear un fichero pruebas y le vamos a quitar los permisos de escritura a nuestro usuario, y le vamos a dar permisos de escritura a otros:

touch pruebas
ls -l pruebas  # de esta forma veremos que por defecto los permisos son rw-rw-r--
chmod u-w,o+w pruebas
ls -l pruebas  # ahora los permisos deberían ser -w-rw-rw-

Una vez dado los permisos, veamos que con nuestro usuario podemos leer pero no escribir:

cat pruebas
echo "probando" > pruebas
exit

Y ahora vamos a ver que el usuario pruebas, puede leer y escribir:

su practica
cat pruebas
echo "probando" > pruebas

chown

Permite cambiar el propietario de un fichero o directorio.

Vamos por ejemplo a pasarle ahora el fichero pruebas al usuario practica:

sudo chown practica pruebas
ls -l pruebas

Veremos que el usuario actual ahora es pruebas, aunque vemos que el ls muestra lo siguiente:

-r--rw-rw- 1 practica ubuntu 9 Aug 29 09:34 pruebas

Hay que comentar un detalle, y es que los ficheros y directorios tienen asignado un usuario y un grupo, por defecto se utiliza el mismo usuario como grupo cuando creamos un nuevo fichero o directorio. Si queremos que cuando cambiemos el propietario, cambiar tambien el grupo del fichero, podemos hacerlo de la siguiente forma:

sudo chown practica:practica pruebas

Una vez hecho esto, vamos ahora a probar que los permisos siguen funcionando como antes, ahora con el usuario ubuntu, deberíamos de poder leer y escribir en el fichero pruebas, y con el usuario practica, solo leer, esto es así por que ahora el propitario es practica:

# Pruebas usuario ubuntu
cat pruebas
echo test >> pruebas
# Pruebas usuario practica
su practica
cat pruebas
echo "probando" > pruebas
exit

Paso 6: Procesos

ps

Sirve para ver que procesos están ejecutándose en el sistema, veamos un ejemplo:

ps aux  # con la opción aux mostraremos todos los procesos del sistema

Cada línea es un proceso, y cada proceso muestra su PID, usuario, cantidad de memoria y cpu utilizada, comando y otros detalles.

man kill &  # añadir el & al final de un comando hace que este se ejecute en segundo plano, por lo que se quedará abierto

La salida de este comando nos mostrará el PID que tiene ese proceso que acabamos de ejecutar, vamos a comprobarlo:

ps aux | grep "man kill"

Veremos que el PID coincide.

kill

Este comando nos servirá para matar un proceso. kill se utiliza seguido de una señal para enviar al proceso seguido de uno o varios PID. para ver las señales disponibles, podemos listarlas:

kill -l

Las más utilizadas suele ser SIGTERM y SIGKILL, la primera intenta terminar el proceso de forma poco abrupta, y la segunda suele utilizarse cuando el proceso no atiende a esta primera señal. Vamos ahora a terminar el proceso que creamos antes, si no recordamos el PID, busquémoslo de nuevo:

ps aux | grep "man kill"

Enviamos señal para terminar el proceso y comprobamos que ha terminado:

kill -SIGTERM 8470
ps aux | grep "man kill"

También podemos notar que en el listado de señales, hay unos números, podemos utilizar esos números en vez de las palabras, por ejemplo:

man kill &
kill -15 PID_COMANDO_PREVIO

Comprobamos que el proceso ha terminado correctamente:

ps aux | grep "man kill"

Paso 7: Estado CPU, RAM y Disco

top

Este comando nos servirá para ver el listado de procesos y el estado de la CPU y memoria.

Probemos el comando y observemos detalladamente la salida:

top

Para salir, pulsamos q.

df y du

df (disk free) y du (disk usage). Ambas son utilidades para mostrar el uso de los discos.

Con df mostraremos la información del espacio en cada dispositivo montado:

df

Estos comandos que nos muestran el tamaño de los ficheros, casi siempre tienen una opción para mostrarlo en un formato más legible (-h)

df -h

Mucho mejor.

Ahora veamos el comando du, el cual nos mostrará el tamaño de un fichero o directorio y sus subdirectorios, no olvidemos el -h:

du -h /home/ubuntu
du -h /home/ubuntu/pruebas

Si solo quisíeramos saber el total de una carpeta y nos nos interesan sus subcarpetas, podemos utilizar la opción -s:

du -sh /home/ubuntu

free

Sirve para ver el estado de la memoria, como siempre, opción -h:

free -h

lsblk

Nos muestra la información de todos los dispositivos de bloques (discos duros, pendrivers, CD_ROM, SSD, ...).

lsblk

En la siguiente práctica se utilizará más a fondo este comando, ya que trabajaremos con dispositivos.

Paso 8: Paquetería y repositorios

Un repositorio es un espacio centralizado donde se almacena, organiza, mantiene y difunde información digital, habitualmente archivos informáticos, que pueden contener trabajos científicos, conjuntos de datos o software.

Un paquete es un conjunto de archivos e instrucciones que indican que hacer con estos archivos.

En cualquier distribución linux, tendremos unos repositorios donde están alojados los paquetes con los diferentes programas y utilidades del sistema.

Sources

Cada distribución tiene su fichero de sources, que será donde estarán los enlaces a los repositorios que utilizará el gestor de paquetes. En el caso de ubuntu, estos repositorios se encuentran en /etc/apt/sources.list

Podemos comprobar que repositorios tenemos añadido:

cat /etc/apt/sources.list

apt/rpm/pacman

Todos estos son gestores de paquetes, cada distribución Linux utiliza uno por defecto. Por ejemplo, en debian y ubuntu se utiliza apt, en arch se usa pacman y en suse rmp. Nosotros veremos apt que es el que tra ubuntu, aunque todos son similares.

Actualizar listado de paquetes

Para actualizar el listado de paquetes utilizaremos el comando:

sudo apt update

Instalar un nuevo paquete

Para instalar un nuevo paquete, utilizaremos la orden install, por ejemplo, vamos a instalar tree, similar al ls pero muestra el arbol de directorios:

sudo apt install tree

Eliminar un paquete

Usaremos la orden purge o la orden remove, purge nos lo eliminad todo, y remove mantiene la configuración en el caso de que el paquete la tuviese. Vamos a eliminar el paquete instalado previamente:

sudo apt purge tree

Paso 9: Módulos

Los módulos del kernel de Linux son partes que podemos añadir o quitar de forma sencilla con el fin de añadir o quitar funcionalidad. Por ejemplo, algunas de estas funcionalidades son:

• Registrar temperaturas de nuestros componentes
• Hacer funcionr la tarjeta de red wifi
• Cargar los drivers de una tarjeta gráfica

lsmod

Comando para ver los módulos que estamos usando:

lsmod

lspci y usb-devices

Estos comandos nos servirán para ver el hardware que está conectado a nuestro ordenador. Con lspci veremos el listado del hardware integrado y con usb-devices el que está conectado por hardware.

Normalmente, como los módulos se utilizan para dar funcionalidad un hardware, aquí en los listado de hardware podremos ver que módulo está utilizando cada hardware:

lspci -v

Veremos una línea en algunos dispositivos que nos diga que módulo estamos usando, pongo un pequeño trozo de la salida del comando:

00:1f.2 SATA controller: Intel Corporation 82801IR/IO/IH (ICH9R/DO/DH) 6 port SATA Controller [AHCI mode] (rev 02) (prog-if 01 [AHCI 1.0])
    Subsystem: Red Hat, Inc. QEMU Virtual Machine
    Flags: bus master, fast devsel, latency 0, IRQ 35
    I/O ports at c0c0 [size=32]
    Memory at fcc1d000 (32-bit, non-prefetchable) [size=4K]
    Capabilities: <access denied>
    Kernel driver in use: ahci
    Kernel modules: ahci

Vemos que el hardware INTEl Corporation está utilizando el módulo ahci.

Probemos ahora con usb-devices:

usb-devices

Veamos un trozo de código:

T:  Bus=01 Lev=01 Prnt=01 Port=00 Cnt=01 Dev#=  2 Spd=480 MxCh= 0
D:  Ver= 2.00 Cls=00(>ifc ) Sub=00 Prot=00 MxPS=64 #Cfgs=  1
P:  Vendor=0627 ProdID=0001 Rev=00.00
S:  Manufacturer=QEMU
S:  Product=QEMU USB Tablet
S:  SerialNumber=42
C:  #Ifs= 1 Cfg#= 1 Atr=a0 MxPwr=100mA
I:  If#= 0 Alt= 0 #EPs= 1 Cls=03(HID  ) Sub=00 Prot=00 Driver=usbhid

Vemos que el teclado está utilizando el módulo usbhid

insmod

Sirve para cargar un módulo en el kernel, imaginemos que tenemos un módulo que se llama modulo1:

sudo insmod modulo1

rmmod

Sirve para eliminar un módulo de kernel. Imaginemos que queremos borrar un módulo cargado anteriormente con el nombre modulo1:

sudo rmmod modulo1