2.-A) Arranque del sistema Linux LPIC-1 Peso 3

Viene completamente explicado en wikipedia, es un poco duro de leer pero se entiende.

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

No olvidéis hacer una pequeña donación, por muy pequeña que sea en nombre del conocimiento libre. Nosotros de momento todavía no pedimos aunque cuando nadie nos ve … lloramos por ahí en alguna esquina.

Respecto a los comandos que nos piden en esta parte para la certificación:
#dmesg
Este comando nos da las líneas que circulan durante el proceso de arranque y que vemos pasar por la pantalla de manera fulgurante. Estos mensajes están en el búfer circular y este es un búfer que almacena información del Kernel y de módulos(drivers) que se cargan en él.
Al ejecutar el comando nos saldrá mucha información, así que es bueno redirigir la salida hacia un less.
#dmesg | less
#dmesg > mensajesdelarranque.txt

Hay distribuciones que nos almacenan esta información del kernel ring buffer (buffer circular) en /var/log/dmesg
El registro del sistema es syslogd y la información esta en /var/log/messages, también hay más información para ver, por si tenemos un problemón (problema gordo) en /var/log/syslog y /var/log

Depende un poco lo que veremos si estamos usando Fdora, Red Hat o Debian. Por ejemplo debian usa un demonio «bootlogd» que registra todos los mensajes que va a /dev/console

En /var/log econtramos muchos ficheros de log que pueden resultar totalmente inocuos a la hora de entenderlos, siendo sinceros no entendemos el 50% de la información que aparece y no queda otra que investigar, aunque hay ciertos consejos que pueden ayudarnos:
Los mensajes del arranque #dmesg están relacionados con el hardware, si usamos el | less recordar que podeís usar la tecla / para hacer una busqueda.
Por ejemplo podemos buscar por el nombre del chipset y así podemos ver si falla algo relacionado con él.
Si no se inicia un sistema, puede ser que estén ocultos los mensajes, dando a la tecla esc puede que nos los muestre y tengamos una idea del fallo.

Sobre la Bios y el gestor de arranque hay mucha información en internet que podéis mirar
Sobre init comentaros que al tomar el control el kernel de linux, este tiene que realizar tareas como inicializar dispositivos , montar la partición raíz y cargar y ejecutar el programa inicial del sistema, es:
/sbin/init
Este programa recibe el id (pid) = 1, al ser el primero en ser ejecutado por el sistema, después lee un fichero llamado:
/etc/inittab
El fichero inittab determina que otros programas ejecutar, script de inicialización del sistema,montaje de más particiones, iniciar servicios del sistema …

Hoy en día linux solo está utilizando el inittab para cargar los modos de ejecución y se esta dejando de usar como fichero de control de inicio. Los nuevos emplean la entrada /etc/event.d
para controlar la secuencia de inicio de init.
Ubuntu es la excepción, no tiene /etc/inittab aunque se lo podemos hacer y que contenga initdefault.

Los modos de ejecución hay del 0 al 6, os aconsejamos echarles un vistazo por tener una idea de lo que hace cada modo.Por ejemplo el modo 5 es un un modo multiusuario con acceso gráfico.
Si hacemos un:
#cat /etc/inittab
Vemos cosas como esto:
# Runlevel 0 is halt.
# Runlevel 1 is single-user.
# Runlevels 2-5 are multi-user.
# Runlevel 6 is reboot.

l0:0:wait:/etc/init.d/rc 0
l1:1:wait:/etc/init.d/rc 1
l2:2:wait:/etc/init.d/rc 2
l3:3:wait:/etc/init.d/rc 3
l4:4:wait:/etc/init.d/rc 4
l5:5:wait:/etc/init.d/rc 5
l6:6:wait:/etc/init.d/rc 6
# Normally not reached, but fallthrough in case of emergency.
z6:6:respawn:/sbin/sulogin

# What to do when CTRL-ALT-DEL is pressed.
ca:12345:ctrlaltdel:/sbin/shutdown -t1 -a -r now

También podemos hacer:
root@debianMich:/home/lacemi# grep «rc [0-6]» /etc/inittab
l0:0:wait:/etc/init.d/rc 0
l1:1:wait:/etc/init.d/rc 1
l2:2:wait:/etc/init.d/rc 2
l3:3:wait:/etc/init.d/rc 3
l4:4:wait:/etc/init.d/rc 4
l5:5:wait:/etc/init.d/rc 5
l6:6:wait:/etc/init.d/rc 6
root@debianMich:/home/lacemi#

Vemos en el ejemplo anterior la parte del /etc/inittab que indica a init como gestionar cada modo de ejecución.
id:modosdeejecución:accion:proceso
el primer número que vemos no es un número, es la letra L pero en minúsculas, no hay que confundirlo con el «1», seguido del número de ejecución que como deciamos antes van del 0 al 6.
El wait por ejemplo le indica a init que incie el proceso de ejecución y que espere a que este finalize, podemos ver la ayuda de inittab con man y veremos más acciones como respawn.

Algunos programas llaman a modos específicos como shutdown, que llama al modo de ejecución 0 para reiniciar el sistema o apagarlo.

Guía de referencia de comando Linux – Debian

http://www.esdebian.org/wiki/linea-comandos
De la mano de la comunidad Debian podemos disfrutar de una completa guía.

1.-E) Arquitectura del sistema Linux LPIC-1

Repaso sobre temas aclaratorios de Arquitectura del sistema. LPIC-1 Exámen 101.
Sobre lo visto en el apartado «1» de esta unidad.

Los distintos directorios que mencionabamos:

lacemi@debianMich:~$ ls /sys
block bus class dev devices firmware fs kernel module power

lacemi@debianMich:~$ ls /sys/block
fd0 loop0 loop1 loop2 loop3 loop4 loop5 loop6 loop7 sda sdb sr0

lacemi@debianMich:~$ ls /sys/bus
ac97 gameport isa pci_express pnp serio usb
acpi i2c pci platform scsi spi virtio

Para entender esto necesitamos saber lo siguiente:
Los Ficheros de Dispositivos en Todo sistema Unix se basan en ficheros.
Todo dispositivo tiene un fichero asociado mediante el cual podemos hacer operaciones de entrada/salida.

Hay dos tipos de ficheros de dispositivos, atendiendo al hardware que representan:
char: Dispositivos de caracteres.

block: Dispositivos de bloques.

Los ficheros de dispositivos son ficheros especiales que utilizan dos números (major y minor) para identificar un dispositivo. Éstos ficheros especiales normalmente se encuentran en la ruta /dev aunque pueden crearse en cualquier otra ruta.
La llamada a sistema mknod permite crear ficheros de dispositivos especificando ruta, tipo y el identificador de dispositivo (major y minor).
Pueden existir ficheros para dispositivos inexistentes y dispositivos para los que no hay fichero. P.e. la tarjeta de red o la salida o entrada estándar.

Solucion para el manejo de ficheros de dispositivos:
udev: Se crean y destruyen los ficheros a medida que se conectan/desconectan dispositivos. Adicionalmente permite elegir nombres para esos dispositivos y programar acciones al cambiar el estado de los mismos.

Modelo de Drivers de Dispositivos
Para facilitar y organizar la construcción de drivers, Linux ofrece una serie de estructuras y funciones auxiliares que ofrecen una visión unificada de buses, dispositivos y drivers.

Las principales estructuras son:
struct device_driver (drivers o manejadores)
struct bus_type (buses)
struct device (dispositivos)

El Modelo de Drivers de Dispositivos tiene una interfaz unificada accesible a través del sistema de ficheros virtual sysfs.
El sistema de ficheros sysfs es similar a proc pero mucho más organizado y oriendado a los dispositivos y drivers del sistema. Normalmente está montado en /sys y contiene:

/sys/block: Dispositivos de bloques de cualquier bus.
/sys/bus: Buses del sistema, donde están los dispositivos
/sys/devices: Dispositivos del sistema organizados por buses.
/sys/class: Clases de dispositivos (audio, tarjetas gráficas,de red… )
/sys/modules: Drivers registrados en el núcleo
/sys/power: Ficheros para manejar estado de energía de distintos dispositivos.
/sys/firmware: Ficheros para manejar el firmware de algunos dispositivos

Aunque no entre en el exámen, podemos poner un ejemplo de una función, por ejemplo la usada para /sys/bus:
Estructura bus_type
struct bus_type {
const char * name;
struct module * owner;
struct kset subsys; //Subsistema dentro de sysfs al que pertenece
struct kset drivers; //Drivers conocidos para ese bus
struct kset devices; //Dispositivos conectados al bus
struct klist klist_devices;
struct klist klist_drivers;
// Funcion que comprueba si el bus puede manejar un cierto dispositivo o driver
de dispositivo.
int (*match)(struct device * dev, struct device_driver * drv);
int (*probe)(struct device * dev);
int (*remove)(struct device * dev);
void (*shutdown)(struct device * dev);
//Campos omitidos…
unsigned int drivers_autoprobe:1;
};

Cada operación sobre un fichero de dispositivo debe traducirse a una llamada a una rutina de su driver.
El driver debe registrarse creando un device_driver y llamando a driver_register() para registrarlo.
Si el driver esta compilado en el kernel, el registro se produce durante la fase de carga del núcleo. Si el driver está compilado como módulo, se cargará cuando sea necesario.
Cuando se registra un driver, el kernel comprueba para cada dispositivo que quede sin manejar si el driver puede manejarlo mediante la función probe().
Aunque esté registrado, el driver aún no tiene recursos asignados.
Inicialización del Driver
Para controlar la asignación de recursos se sigue el siguiente esquema:
Un contador mantiene el número de procesos que operan o esperan para operar en fichero de dispositivo.
Al abrir el dispositivo, si este contador está a 0, se realiza la asignación de recursos al driver de
dispositivo (IRQ, marcos de página, …)
Cada vez que un proceso cierra el fichero de dispositivo, se comprueba si el contador ha llegado
a 0. Si es así se liberan todos los recursos hasta que se intente acceder de nuevo al dispositivo.
Con esto nos damos una idea de como funciona Linux. Dejamos aquí el tema pues ya no es motivo de la certificación.

1.-E) Arquitectura del sistema Linux LPIC-1

Discos PATA, SATA y SCSI

PATA:
/dev/hda
/dev/hdb
/dev/hdc
etc.
Si tenemos discos duros maestros (sabemos que pueden ser maestros o esclavos.Tenemos dos IDE para conexión, en cada unos de ellos hay un maestro y un esclavo, sino se sabe de que hablamos documentarse antes) habrá un salto y tendremos:
/dev/hda
/dev/hdc
Las particiones se identifican por números que tenemos al final del nombre.
/dev/hda1
/dev/hda2

Para unidades ópticas tendremos /dev/cdrom o /dev/dvd

SATA:
En la actualidad linux detecta los discos duros sata como SCSI
/dev/sda
O en las unidades ópticas, como el cd-rom:/dev/scd0

1.-D) Arquitectura del sistema Linux LPIC-1

#lsusb

La utilidad lsusb es importante debido a que es una aplicación orientada a los USB, muy populares hoy en día. Para su buen manejo es necesario conocer también sus drivers para linux.

El puerto USB se nos debe activar automáticamente gracias a que Linux hoy en día trae los drivers para los controladores USB habituales. Ejemplos de ellos son EHCI,OHCI(USB1.0),UHCI(1.0) y R8A66597.

lacemi@debianMich:/etc$ lsusb
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 002 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 001 Device 004: ID 064e:c107 Suyin Corp. HP webcam [dv6-1190en]

Se han detectado dos buses y solo en el primero hay conectado un dispositivo que es la cámara web para el portatil HP.

Antiguamente (no demasiado), los discos duros por USB, se detectan como SCSI debido a que antiguos driver USB todavia están cargados en el KErnel si no los hemos quitado con una compilación de Kernel, y estos detectan ese tipo de driver e interconectan el USB con el SCSI.

Linux en las ultimas versiones a migrado a un sistema de ficheros USB independiente y aparece dentro del sistema de fichero virtual /proc (El sistema de archivos /proc es un seudo sistema de archivos que contiene información sobre el sistema y sus procesos en ejecución). Recordamos que los sistemas de fichero siempre se pueden montar.

La información a los usb esta en /proc/bus/usb y a los usb se les da nombres numericos como /proc/bus/usb/002 para el segundo controlador usb y se usan para controlar un USB en lugar de utilizar los ficheros de dispositivos de /dev como harían los demas dispositivos de hardware.

Para gestionar los USB Linux utilizada herramientas, concretamente dos:

usbmgr o hotplug

usbmgr (a partir del kernel 2.4 no se usa)se ejecuta en segundo plano y modifica los cambios que se producen en el Usb como por ejemplo conectarlo y desconectarlo o si se conecta una unidad usb de DVD cargará los módulos(drivers en windows) adecuados USB.

El paquete esta en /etc/usbmgr para dispositivos especificos  y la configuracion global /etc/usbmgr/usbmgr.conf

Hotplug es el usado hoy en día y se basa en los ficheros almacenados en /etc/hotplug
Este se basa en el dispositivo usado mirando su id que los saca del mapeo de usb que se aloja en /etc/hotplug/usb/usb.usermap que a su vez tienen unos punteros apuntando a los scripts que están en /etc/hotplug/usb y se ejecutan cuando se conectan o desconectan los usb.

1.-C) Arquitectura del sistema Linux LPIC-1

Lsmod
En Linux el hardware está administrado por los drivers del kernel que viene como módulos del kernel.
Son ficheros independientes que se cargan y se descargan para dar acceso al hardware y estan almacenados en /lib/modules
Normalmente se cargan al inicio pero puede ser que quieras cargar alguno después.
$Lsmod
lsmod | sort–> sort lo usamos para ordenar.
Module Size Used by
ac 1640 0
ac97_bus 710 1 snd_ac97_codec
acpiphp 13281 0
ata_generic 2247 0
ata_piix 17704 0
auth_rpcgss 25200 1 nfsd
binfmt_misc 4875 1
bluetooth 36251 6 sco,rfcomm,bnep,l2cap
bnep 7384 2
bridge 32883 0
button 3598 0
cdrom 26487 1 sr_mod
omitimos el resto del resultado.

Como se puede ver algunos son sencillos de reconocer como el cdrom o el ac97 para audio.
La última columna nos indica que modulo es dependiente del de la primera columna. No podemos parar el módulo principal sino paramos antes el dependiente que aparece en la segunda, ya que en algún punto de la lista aparecera en la primera columna como módulo.
El valor 1 nos indica que esta en uso y el valor 0 que no está en uso.

Insmod, modprobe

Hoy en día linux carga los módulos automáticamente y no hace falta usar estos comandos, aunque pueden ser útiles para solucionar problemas de carga automática.

Con insmod debemos tener el modulo de los que depende ya descargados para poder usarlos, con modprobe cargamos ya los módulos de los que depende automáticamente, por lo tanto es el que de usar, usaríamos.

Por ejemplo: #modprobe floppy

Es sencillo su uso, modprobe seguido del módulo a cargar.

Con insmod necesitariamos floppy y floppy.ko y mirar documentación para saber que dependencias tiene cada modulo, como por ejemplo si queremos cargar un RS232 o puerto COM al Kernel.

Podemos simular el uso de modprobe para no insertar el modulo en el kernel de manera real y poder coprobar si tendría algun efecto perjudicial como desactivarnos el disco.

-a Cargar todos los módulos que coincidan con el sumistrado como argumento

-l Listar todos los módulos que coincidan

-r Quitar módulo con sus paquetes de dependencias

Para ver mas modificadores de modprobe hacer: #man modprobe

Durante el arranque del sistema modprobe revisa el contenido de tres objetos del sistema de archivos de Linux:

• el directorio  /lib/modules/`uname -r` donde se encuentran los módulos del kernel y archivos relacionados para el kernel en uso.
• el archivo de texto /etc/modules que contiene la lista de módulos opcionales que deben cargarse al kernel por omisión y
• la lista negra, que es un archivo de texto ubicado en  /etc/modprobe.d/blacklist que contiene la lista de módulos que no deben cargarse al kernel bajo ninguna circunstancia

Modprobe usa el fichero /etc/modules.conf  que podemos editar en algunas distribuciones, debian usa /etc/modules descrito más arriba.

#rmmod

Nos permite borrar módulos, aunque viene en la documentación y en los libros oficiales, no hemos visto que aparezca en los exámenes de certificación pero esta bien saber para que sirve y algun modificador que le acompañe.

Descarga uno o más módulos cargados, mientras estos no estén siendo usados.  Con la opción -r intenta descargar recursivamente módulos de los cuales el módulo especificado dependa.  El comando rmmod -a descarga todos los módulos que no estén siendo usados y no tengan dependencias, sin embargo modprobe -r borra el módulo apoyándose también en la tabla de dependencias y los modulos que dependan de él siempre que no se esten utilizando.

A partir de aqui, ya no es motivo de certificación, pero si nos viene bien para ir entendiendo Linux y preparandonos para la LPIC-2 que consta de otros dos exámenes.
MÓDULOS DEL NÚCLEO

Hay componentes del núcleo que siempre tienen que estar en memoria como el planificador de la CPU.
Sin embargo otros componentes solo tienen que estar en memoria cuando se necesitan, como el manejador de un CDWriter; un sistema de ficheros Minix, NFS; un manejador de protocolo PPP.

Estas partes del núcleo que pueden cargarse o descargarse dinámicamente en memoria, mientras el núcleo se esta ejecutando se llaman MÓDULOS.
Ventajas de los módulos
La incorporación de nuevos manejadores al núcleo es mas fácil, se pueden compilar, cargar, probar, o quitar como módulos antes de integrarlos en el núcleo.

Si el manejador está integrado en el núcleo, cada vez que hagamos modificaciones en el manejador hay que recompilar todo el núcleo y reiniciar.
El núcleo no ocupa tanta memoria principal, quedando libre para las aplicaciones.

Desventajas
Cada vez que se requiere o ya no se necesita un módulo hay que pagar el coste de leer o escribir en disco.
El código del núcleo se incrementa con el sistema de manejo de módulos.
La opción que activa que el núcleo maneje los módulos es:
Enable loadable module suport (CONFIG_MODULES) [Y/n/?]
Si se desea instalar un componente como módulo, hay que declararlo en la configuración del núcleo, ejemplo instalar el sistema de ficheros MSDOS.
DOS FAT fs support (CONFIG_FAT_FS) [M/n/y/?] M
MSDOS fs support (CONFIG_MSDOS_FS) [M/n/y/?] M
VFAT (Windows-98) fs support (CONFIG_VFAT_FS) [m/n/y/?] M
Una vez compilado el núcleo se compilan los módulos, la secuencia puede ser:
make config
make dep
make clean
make zImage
make modules
make modules_install
Finalizado este proceso, los módulos se encuentran el /lib/modules.
Los módulos se compilan como cualquier programa pero son enlazados como imágenes recargables, esto es no están asociadas a ninguna dirección.
Podemos ver los símbolos exportados por el núcleo en /proc/ksyms o utilizando el comando ksyms.

Cada módulo debe contener unos procedimientos que los manejan, incluyendo uno de inicialización cuando se carga el módulo y otro de borrado cuando se quita del núcleo.

Los comandos del super usuario para manejar manualmente los módulos son:
insmod – instalar un módulo
lsmod – lee el contenido de /proc/modules y muestra los módulos cargados en memoria, (nombre, número de páginas del módulo y procesos que los utilizan).
ejemplo de listado al ejecutar lsmod
Module: #pages: Used by:
msdos 2 1 (autoclean)
vfat 4 1 (autoclean)
fat 6 [vfat msdos] 2 (autoclean)

rmmod – quitar un módulo

Carga automática de módulos por demanda del núcleo
Cuando se monta un sistema de ficheros que no está integrado en el núcleo, el núcleo solicita al programa kerneld que cargue los módulos necesarios para este sistema de ficheros montado.

La carga dinámica y automática de módulos precisa que se compile el núcleo con la opción CONFIG_KERNELD y los IPC System V.

Se precisa al arrancar el sistema lanzar el programa demonio kerneld, que lee las peticiones del núcleo y realiza la carga o descarga de los módulos necesarios. Se ejecuta como un proceso de usuario y establece un canal de comunicación basado en mensajes (IPC) con el núcleo, por el cual el núcleo solicita mediante mensajes un modulo al programa modprobe.
Se utilizan los programas depmod y modprobe.

DEPMOD, genera un archivo de dependencias de los símbolos encontrados en los módulos.
MODPROBE, es el programa para manejo de módulos, requiere privilegios de root.

Los procedimientos del núcleo que interaccionan con modprobe y la estructura de datos principal, (se encuentran en include/linux/module.h y kernel/module.c) son:
request_module

Es la función llamada por el núcleo cuando este percibe, por la solicitud de un proceso, la necesidad de cargar un módulo.
exec_modprobe, es el programa que añade el módulo solicitado al núcleo, es llamado por kerneld.
struct module (omitimos el contenido)
request_module (omitimos el contenido)

Los ficheros que tratan con los módulos son:
incluye/linux/module.h
kernel/module.c
Contienen la estructura struc module y las llamadas al sistema utilizadas por modprobe y los comandos insmod, lsmod y rmmod son:
sys_create_module
sys_init_module
sys_delete_module
sys_get_kernel_syms

1.-B) Arquitectura del sistema Linux LPIC-1

Hal: Es la capa de abstracción del hardware y es un demonio o programa que esta ejecutandose en todo momento y suministra información sobre el hardware disponible a los demás programas del espacio de usuario.
Hace de intermediario entre el hardware y sofware, lo mismo que en Windows.
Las HAL permiten que las aplicaciones sean independientes del hardware en el que se ejecutan, ya que hacen abstracciones de tales sistemas como los buses, cache, interrupciones, etc.
Las HAL, a diferencia de las API, interactuan directamente con el hardware, en lugar de con el kernel, por lo que requieren menos tiempo de procesamiento.
HAL posee propiedades persistentes, es decir que las propiedades de un dispositivo se guardan y restauran cuando éste se vuelve a conectar.
DeviceKit es una nueva capa de abstracción diseñada para reemplazar a HAL. DeviceKit ya ha sido parcialmente implementado en distribuciones modernas como Fedora 11 y Ubuntu 9.10.

D-Bus proviene de Desktop Bus, algo así como bus de escritorio. Es un sistema de comunicación entre procesos.
D-Bus se divide en tres capas:

libdbus: Biblioteca que permite a dos aplicaciones comunicarse e intercambiar mensajes.
Un daemon que funciona como bus de mensajes, construído sobre libdbus al cual pueden conectarse varias aplicaciones.
Bibliotecas adaptadas (wrappers) para su uso en marcos (frameworks) concretos.
Los principales usos de D-Bus son:

Comunicación entre aplicaciones de escritorio en la misma sesión.
Comunicación entre el sistema operativo y la sesión de escritorio.
También es un demonio y como ejemplo podemos decir que notifica eventos, por ejemplo la disponibilidad de un nuevo dispositivo USB.

udev: udev es el gestor de dispositivos a partir del kernel 2.6. Es el encargado de manejar los archivos especiales de dispositivos de /dev. Es el sucesor de devfs y hotplug.

Problemas previos
En un sistema Linux sin udev ni devfs, el directorio /dev está poblado nodos de dispositivos o archivos de dispositivos. Cada archivo representa un dispositivo, exista éste o no físicamente en el sistema. Es un conjunto estático de ficheros, ya que los nodos no cambian.

En este modelo, la forma de acceder a los dispositivos puede que no sea siempre la misma. Por ejemplo, si se tienen dos dispositivos del mismo tipo, se llamarán dispositivo1 y dispositivo2 respectivamente. Pero si se desconectara el primero, el dispositivo2 pasaría a ser el dispositivo1 ya que hay sólo uno conectado al sistema.
Otros problemas derivados de este comportamiento:

El directorio /dev es muy grande ya que contiene archivos de dispositivos que ni siquiera se encuentran físicamente en el equipo.
Los programas deben poder detectar cuándo se ha conectado o desconectado un dispositivo, y cuál es su referencia en /dev.

udev: la solución
udev resuelve los problemas anteriores y otros más de la siguiente manera:

udev mantiene en /dev sólo las referencias a dispositivos conectados al sistema.
Permite asignar nombres fijos a dispositivos, sin importar qué otros dispositivos haya conectados o no. 
Realiza notificaciones mediante D-bus para que cualquier programa del espacio de usuarios pueda saber cuándo se conecta o desconecta un dispositivo.
Trabaja completamente en el espacio de usuario, haciendo posible que cualquier programa pueda decidir el nombre a asignarse a un dispositivo.
Respeta la forma de nombrar los dispositivos aceptada por la Linux Standard Base (LSB).

Implementación
udev se ejecuta mediante un daemon: udevd, que se encarga de detectar cuando un dispositivo se conecta o desconecta del sistema.
Cuando ocurre alguno de estos dos eventos, udevd recopila información del contexto y del propio dispositivo utilizando la entrada correspondiente en /sys para el mismo.
Las reglas definidas en /etc/udev/rules.d/ indican qué acción tomar a partir de los datos obtenidos. Generalmente lo que se hará es dar un nombre al dispositivo, crear el archivo de dispositivos apropiado y ejecutar el programa que se haya definido para que el nuevo dispositivo quede funcional.
En resumen udev es un sistema de ficheros virtual montado en /dev, que crea ficheros de dispositivos dinámicos conforme se cargan y descargan los drivers. Se puede configurar udev a través de los ficheros de /etc/udev pero no se suele tocar.

/dev /dev: Archivos de dispositivos (device files)
En los sistemas de tipo unix, existen archivos de dispositivos o archivos especiales que actúan como interfaz para un dispositivo, apareciendo en el sistema de archivos como si fuera un archivo normal.

Los archivos de dispositivos (nodos) pueden representar dispositivos propiamente dichos (un disco rígido), pero también propiedades de los mismos (particiones del disco).

Existen dos tipos de archivos de dispositivos, los character special files, y los device special files. Se diferencian en la forma en la que los datos se escriben en ellos y es leída de ellos.

Character devices
Los character devices son aquellos que transmiten o reciben los datos un caracter a la vez. Ejemplos de character devices son: teclado, mouse, modems seriales, y otros dispositivos que por lo general no soportan acceso aleatorio (random access) a los datos.

Block devices
Son los dispositivos que mueven los datos en bloques. Los discos rígidos, CD-ROMs y memorias son dispositivos de bloque. Los dispositivos de bloque soportan random access y búsqueda (seeking), y generalmente usan rutinas de entrada y salido con buffer.
Cuando un programa solicita una transferencia de información, los caracteres se van guardando en un buffer. Cuando se llena se ejecuta la acción correspondiente (transferencia de datos) y luego se vacía el buffer.

Pseudo dispositivos
Los nodos de dispositivos no necesariamente tienen que corresponderse con dispositivos físicos. Estos nodos forman el grupo de pseudo dispositivos (pseudo devices) y proveen varias funciones que que son manejadas por el sistema operativo. Algunos de los pseudo dispositivos más comunes son:

/dev/null  Recibe y descarta toda entrada y no devuelve ninguna salida.
/dev/zero  Devuelve un flujo contínuo de bits de valor NUL (cero).
/dev/loop Hace accesibe un archivo como si fuera un block device.
/dev/random  Devuelve un flujo de números aleatoreos o pseudo aleatoreos de tamaño variable.
/dev/urandom  Devuelve un flujo de números pseudo aleatoreos de tamaño variable

Creación de nodos
Los nodos se crean con la llamada de sistema mknod. Existe un comando para dicho fin con el mismo nombre. Los nodos pueden moverse o borrarse con las llamadas de sistema rename y unlink, o con los comandos mv y rm.
Algunas distribuciones de linux tienen un script llamado makedev que crea todos los dispositivos necesarios en el directorio /dev.

Convenciones de nomenclatura
Los sistemas basados en el kernel de Linux utilizan los siguientes prefijos para nombrar los dispositivos y pseudo dispositivos del directorio /dev.

fb: Frame buffer
fd: Diskette (Floppy disk)
hd: Disco rígido ATA/IDE
 hda: Dispositivo master del primer canal ATA/IDE.
 hdb: Dispositivo slave del primer canal ATA/IDE.
 hdc: Dispositivo master del segundo canal ATA/IDE.
 hdd: Dispositivo slave del segundo canal ATA/IDE.
lp: Impresoras (line printers)
parport: Puerto paralelo (Parallel port)
pt: Pseudo terminales
sd: Driver SCSI, también usado por PATA/SATA, USB, Firewire, etc.
sda: Primer dispositivo registrado.
ttyS: Terminales virtuales

Para la mayoría de estos dispositivos, a este prefijo sigue un número que identifica cada dispositivo en particular. Para los discos rígidos, se utiliza el prefijo para identificar el dispositivo y el número para identificar las particiones.

1.-A) Arquitectura del sistema Linux LPIC-1

Hotplug y Coldplug
Coldplug y Hotplug son dos formas de denominar dos tipos de periféricos según la forma de conexión a un equipo o PC.

Los periféricos coldplug (conexión en frío), no deben conectarse o desconectarse sin apagar el equipo. Por ejemplo: PCI-E, PATA, ISA …

Los dispositivos hotplug (conexión en caliente) pueden conectarse y desconectarse en funcionamiento sin tener que apagar el PC. Por ejemplo USB, SATA, Firewire …

Para ver las IRQ que se están utilizando hay que examinar el fichero /proc/interrupts
$cat /proc/interrupts
/proc es un fichero virtual que hace referencia al Kernel no a fichero que estén en el disco duro, por lo tanto en /proc tambien podremos ver procesos en ejecución.
#> ls /proc
1 2432 3340 3715 3762 5441 815 devices modules
129 2474 3358 3716 3764 5445 acpi diskstats mounts
1290 248 3413 3717 3812 5459 asound dma mtrr
133 2486 3435 3718 3813 5479 bus execdomains partitions
1420 2489 3439 3728 3814 557 dri fb self
165 276 3450 3731 39 5842 driver filesystems slabinfo
166 280 36 3733 3973 5854 fs interrupts splash
2 2812 3602 3734 4 6 ide iomem stat
2267 3 3603 3735 40 6381 irq ioports swaps
2268 326 3614 3737 4083 6558 net kallsyms sysrq-trigger
2282 327 3696 3739 4868 6561 scsi kcore timer_list
2285 3284 3697 3742 4873 6961 sys keys timer_stats
2295 329 3700 3744 4878 7206 sysvipc key-users uptime
2335 3295 3701 3745 5 7207 tty kmsg version
2400 330 3706 3747 5109 7222 buddyinfo loadavg vmcore
2401 3318 3709 3749 5112 7225 cmdline locks vmstat
2427 3329 3710 3751 541 7244 config.gz meminfo zoneinfo
2428 3336 3714 3753 5440 752 cpuinfo misc

Los directorios con números corresponden a cada proceso en ejecución; un autoenlace simbólico apunta al proceso actual. Algunos archivos virtuales proveen información sobre el hardware, tal como /proc/cpuinfo y /proc/interrupts. Otros proporcionan información relacionada a los archivos, tales como /proc/filesystems o /proc/partitions. Los archivos situados bajo /proc/sys son relacionados a la configuración de parámetros del kernel.

Los directorios con nombre numérico representan a los procesos en ejecución. Cuando un proceso termina, su directorio /proc desaparece automáticamente. Si examinas cualquiera de estos directorios mientras existen, encontrarás bastantes archivos:
attr cpuset fdinfo mountstats stat
auxv cwd loginuid oom_adj statm
clear_refs environ maps oom_score status
cmdline exe mem root task
coredump_filter fd mounts smaps wchan

Veamos más de cerca a los archivos principales:
cmdline: Contiene el comando que inicio el proceso, con todos sus parámetros.
cwd: Enlace simbólico al directorio actual de trabajo (current working directory cwd) del proceso; enlaces exe a los procesos ejecutables y enlaces root a su directorio superior.
environ: Muestras todas las variables de ambiente para el proceso.
fd: Contiene los descriptores de archivo para el proceso, mostrando cuáles archivos o dispositivos lo están usando.
maps, statm and mem: Trabaja con la memoria en uso por el proceso.
stat and status: Proveé información acerca del estatus del proceso, pero el segundo es mucho más claro que el primero.

Pero volvamos a las IRQ, al ver el cat/proc/interrupts en la salida podemos ver los drivers que utiliza cada IRQ, hacerlo y lo veréis, un claro ejemplo es floppy, otros son mas críticos como cx88 un driver de tarjetas de video capturadoras.
Hay que tener en cuenta que puede ser que no tengamos todas las IRQ instaladas, por ejemplo puede ser que hasta que no usemos un puerto paralelo no cargue la irq que le corresponde.
Por no estendernos para ver las direcciones E/S o tambien llamados puertos de entrada y salida sería en:
$cat /proc/ioports
Las direcciones DMA en $cat /proc/dma

Volviendo con las preguntas de la certificación, hay varias utilidades para administrar dispositivos de conexión en caliente:
Sysfs: Es un sistema de archivos virtual y se monta en /sys
/sys
A partir del kernel 2.6 se implementó el directorio /sys, utilizado para la configuración de PnP (plug and play). Como los archivos de /proc, los archivos de /sys representan información en la memoria del kernel y no están presentes en el disco duro. En su mayoría son archivos de texto plano ASCII con un valor por archivo.
El sistema de archivos sysfs se encarga de prestar la información de los dispositivos y controladores (disponible para el kernel) al espacio de usuario de manera que otras aplicaciones puedan también acceder a dicha información.
Esta información suele ser utilizada por HAL y udev para la monitorización y configuración dinámica de dispositivos.

Sysfs es un mecanismo para representar los objetos del kernel y sus relaciones.

Montaje de sysfs
sysfs puede montarse desde el espacio de usuario como cualquier otro filesystem de memoria:
mount -t sysfs sysfs /sys
También puede montarse automáticamente desde /etc/fstab:
sysfs   /sys   sysfs   noauto   0   0 

Directorios dentro de /sys
Los directorios que se encuentran dentro de /sys son creados al inicio del sistema, cuando los subsistemas se registran con el núcleo kobject.

Pueden encontrarse los siguientes directorios:
block:  Contiene un subdirectorio por cada dispositivo de bloque descubierto en el sistema. Dentro de cada uno hay un enlace simbólico al dispositivo físico en el arbol de dispositivos /dev.

bus:  Contiene subdirectorios por cada tipo de bus soportado por el kernel (ide, pci, scsi, usb). Cada tipo de bus representado tiene dos subdirectorios, devices y drivers.

classes:  Contiene representaciones de cada clase de dispositivo registrado en el kernel. Ejemplos de clases son graphics, input, net, printer, scsi_device, sound y tty.

devices:  Contiene la gerarquía global de dispositivos. Contiene cada dispositivo físico descubierto por los tipos de bus registrados en el kernel.

firmware:  Contiene interfaces para ver y manipular objetos y atributos específicos de firmware. Firmware se refiere al código específico de la plataforma que se ejecuta al inicio del sistema.

module:  Contiene subdirectorios por cada módulo que haya sido cargado en el kernel. Cada uno de estos subdirectorios contiene al menos un atributo: refcnt (reference count o número de usuarios), que equivale al valor mostrado en la cuarta columna de lsmod.

power:  El subsistema de alimentación o energía.

LPIC-1 CONTENIDOS

Para sacar la certificación de LPIC-1, tenemos que aprobar dos certificaciones o exámenes, el 101 y el 102. No son difíciles pero para aprobarlos hay que practicar y tener claros los contenidos que entran para el exámen.

Otra cosa que podemos hacer es apuntarnos en academias de informática donde nos puedan proporcionar una prespectiva o e información sobre los cursos que imparten. Otro día os hablaré de las academias a las que podéis acudir, no todas son específicas de esta materia.
No debemos caer en los tópicos de: «cómo sé Linux, seguro que apruebo».
La certificación es muy específica.
Vamos a ver que nos piden a día de hoy:

.-La arquitectura del Sistema.
.-Instalación de Linux y administración de los package (paquetes de instalación)
.-Comandos GNU y Unix
.-Dispositivos, Sistema de fichero Linux y la Jerarquía estándar del sistema de ficheros
.-Cada objetivo tiene un valor o peso dentro de las preguntas del examen. El rango de pesos va de 1 a 10 y indican la importancia relativa de cada objetivo. Los objetivos con mayor peso serán cubiertos en el examen con más preguntas.

________________________________________
Arquitectura del sistema
Determinar y establecer la configuración de hardware
• Peso: 2
• Los estudiantes deberían ser capaces de determinar y configurar el hardware fundamental del sistema
Áreas de Conocimiento
• Habilitar y deshabilitar periféricos integrados.
• Configurar sistemas con o sin periféricos externos como teclado.
• Diferenciar entre los distintos tipos de dispositivos de almacenamiento masivo.
• Establece el ID de hardware adecuado para diferentes dispositivos, sobre todo el dispositivo de arranque.
• Conocer las diferencias entre los dispositivos coldplug y hotplug.
• Determinar los recursos del hardware para dispositivos.
• Herramientas y utilidades para listar distinta información de hardware(por ejemplo, lsusb, lspci, etc)
• Herramientas y utilidades para manipular dispositivos USB
• Comprender sysfs, udev, hald, dbus
Términos y utilidades
• / Sys
• / Proc
• / Dev
• modprobe
• lsmod
• lspci
• lsusb
________________________________________
Arranque del sistema
• Peso: 3
• Descripción: Los candidatos deben ser capaces de guiar el sistema a través del proceso de arranque.
Áreas de Conocimiento
• Proveer comandos comunes al cargador de arranque y opciones al kernel en el arranque.
• Demostrar conocimiento de la secuencia de arranque para la BIOS hasta completar el arranque.
• Compruebe los eventos de arranque en los logs.
Términos y utilidades
• / Var / log / messages
• dmesg
• BIOS
• gestor de arranque
• Kernel
• init
________________________________________
Los niveles de ejecución y el cierre o cambio de reiniciar el sistema
• Peso: 3
• Los estudiantes deberían ser capaces de gestionar el nivel de ejecución del sistema. Este objetivo incluye el cambio de modo de usuario único, apagar o reiniciar el sistema. Los candidatos deben ser capaces de alertar a los usuarios antes de cambiar el nivel de ejecución y termina adecuadamente los procesos.
Áreas de Conocimiento
• Ajuste el nivel por defecto.
• Cambiar entre los niveles de ejecución, incluido el modo de usuario único.
• Apagado y reinicio de la línea de comandos.
• Alertar a los usuarios antes de cambiar los niveles de ejecución o cualquier otro evento importante en el sistema.
• Termine correctamente los procesos.
Términos y utilidades
• / Etc / inittab
• shutdown
• init
• / Etc / init.d
• telinit
________________________________________
Instalación de Linux y gestión de paquetes
Diseño de las capas del disco duro
• Peso: 2
• Los estudiantes deberían ser capaces de diseñar un esquema de partición de disco para un sistema Linux.
Áreas de Conocimiento
• Asignar los sistemas de archivos y espacio de intercambio swap a las particiones creadas en el disco.
• Adaptar el diseño al uso previsto del sistema.
• Asegúrese de que la partición / boot se ajusta a los requisitos de hardware para arrancar la arquitectura.
Términos y utilidades
• / (Root) sistema de archivos
• / Var sistema de archivos
• / Home sistema de archivos
• espacio de intercambio (swap)
• los puntos de montaje
• particiones
________________________________________
Instalar un gestor de arranque
• Peso: 2
• Los estudiantes deberían ser capaces de seleccionar, instalar y configurar un gestor de arranque.
Áreas de Conocimiento
• Proveer ubicaciones alternativas de arranque y las opciones de copia de seguridad de arranque.
• Instalar y configurar un gestor de arranque como GRUB.
• Interactúa con el gestor de arranque.
Términos y utilidades
• / Boot / grub / menu.lst
• grub-install
• MBR
• superbloque
• / Etc / lilo.conf
• lilo
________________________________________
Administrar bibliotecas compartidas
• Peso: 1
• Los estudiantes deberían ser capaces de determinar las librerías compartidas que dependen de los programas ejecutables e instalarlos cuando sea necesario.
Áreas de Conocimiento
• Identificar las bibliotecas compartidas.
• Identificar las ubicaciones típicas de las bibliotecas del sistema.
• Cargar las bibliotecas compartidas.
Términos y utilidades
• ldd
• ldconfig
• / Etc / ld.so.conf
• LD_LIBRARY_PATH
________________________________________
Gestión del uso de paquetes de Debian
• Peso: 3
• Los estudiantes deberían ser capaces de realizar la gestión de paquetes utilizando las herramientas de paquetes de Debian.
Áreas de Conocimiento Clave
• Instalar, actualizar y desinstalar paquetes Debian binarios.
• Encontrar los paquetes que contienen los archivos o bibliotecas específicas que pueden o no estar instalados.
• Obtenga el paquete de información, como versión, contenido, dependencias, integridad del paquete y el estado de la instalación.
Términos y utilidades
• / Etc / apt / sources.list
• dpkg
• dpkg-reconfigure
• apt-get
• apt-cache
• aptitud
________________________________________
El uso de RPM y de gestión de paquetes YUM
• Peso: 3
• Los estudiantes deberían ser capaces de realizar la gestión de paquetes con las herramientas RPM y YUM.
Áreas de Conocimiento
• Instalar, re-instalar, actualizar y eliminar paquetes con RPM y YUM.
• Obtener información sobre los paquetes RPM como la versión, el estado, dependencias, integridad y firmas.
• Determinar qué archivos ofrece un paquete, así como encontrar el paquete con sus archivos especificos.
Términos y utilidades
• rpm
• rpm2cpio
• / Etc / yum.conf
• / Etc / yum.repos.d /
• yumdownloader
________________________________________
GNU y comandos Unix
Trabajar en la línea de comandos
• Peso: 4
• Los estudiantes deberían ser capaces de interactuar con la shell y los comandos usados en la línea de comandos. De Shell se usa la bash.
Áreas de Conocimiento
• Utilizar los comandos de shell y una sola secuencia de línea de comandos para realizar tareas básicas en la línea de comandos.
• Utilizar y modificar el entorno de la shell incluyendo la definición, las referencias y exportación de variables de entorno.
• Usar y editar el historial de comandos.
• Invocar comandos dentro y fuera de la ruta definida.
Términos y utilidades
• .
• bash
• eco
• env
• exec
• export
• pwd
• set
• unset
• man
• uname
• history
________________________________________
Corrientes de proceso de texto usando filtros
• Peso: 3
• Descripción: Los candidatos deben ser capaces de aplicar filtros a flujos de texto.
Áreas de Conocimiento
• Enviar archivos de texto y los flujos de salida a través de filtros de utilidad de texto para modificar la salida usando comandos estándar de UNIX del paquete textutils GNU.
Términos y utilidades
• cat
• cut
• expand
• fmt
• head
• od
• join
• nl
• paste
• pr
• sed
• sort
• split
• tail
• tr
• unexpand
• uniq
• wc
________________________________________
Realizar la gestión de archivos básica
• Peso: 5
• Los estudiantes deberían ser capaces de utilizar los comandos básicos de Linux para administrar archivos y directorios.
Areas de Conocimiento Clave
• Copiar, mover y eliminar archivos y directorios de forma individual.
• Copiar archivos y directorios de forma recursiva.
• Eliminar archivos y directorios de forma recursiva.
• Utilizar especificaciones de comodines simples y avanzados en los comandos.
• Usando find para localizar y actuar sobre archivos basándose en el tipo, tamaño o tiempo.
• El uso de tar, cpio y dd.
Términos y utilidades
• cp
• find
• mkdir
• mv
• ls
• rm
• rmdir
• touch
• tar
• cpio
• dd
• file
• gzip
• gunzip
• bzip2
• file globbing
________________________________________
Uso de Streams, pipes y redirecciones
• Peso: 4
• Descripción: Los candidatos deben ser capaces de redirigir los streams y conectarlos con el fin de procesar de manera eficiente los datos de texto. Las tareas incluyen redirigir la entrada estándar, salida estándar y error estándar, mediante el pipe, mandando la salida de un comando a la entrada de otro comando, usando la salida de un comando como argumento a otro comando y enviando la salida a ambos stdout y archivos…
• Áreas de Conocimiento
• Redirigir la entrada estándar, salida estándar y error estándar.
• Canalizar la salida de un comando a la entrada de otro comando.
• Utilice la salida de un comando como argumento a otro comando.
• Enviar la salida a stdout y un archivo.
Términos y utilidades
• tee
• xargs
________________________________________
Crear, monitorear y matar procesos
• Peso: 4
• Los estudiantes deberían ser capaces de realizar la gestión de procesos básicos.
Áreas de Conocimiento
• Ejecutar trabajos en el primer plano y segundo plano.
• Marcar un programa para seguir funcionando después de cerrar la sesión.
• Monitorear los procesos activos.
• Seleccionar y ordenar los procesos para su visualización.
• Enviar señales a procesos.
Términos y utilidades
• &
• bg
• fg
• jobs
• kill
• nohup
• ps
• free
• killall
• uptime
• top
________________________________________
Modificar las prioridades de ejecución de procesos
• Peso: 2
• Descripción: Los estudiantes deberían poder administrar las prioridades de ejecución de procesos.
Áreas de Conocimiento
• Conocer la prioridad de una tarea creada.
• Ejecutar un programa con una prioridad mayor o menor que el valor por defecto
• Cambiar la prioridad de un proceso en ejecución.
Términos y utilidades
• nice
• ps
• renice
• top
________________________________________
Búsqueda de archivos de texto usando expresiones regulares
• Peso: 2
• Los estudiantes deberían ser capaces de manipular los archivos y datos de texto usando expresiones regulares. Este objetivo incluye la creación de expresiones regulares simples que contengan varios elementos notacionales. También incluye el uso de herramientas de expresiones regulares para realizar búsquedas a través de un sistema de archivos de contenido o archivo.
Áreas de Conocimiento
• Crear expresiones regulares simples que contengan varios elementos notacionales.
• Utilice las herramientas de expresiones regulares para realizar búsquedas a través de un sistema de archivos de contenido o archivo.
Términos y utilidades
• grep
• egrep
• fgrep
• sed
• regex
________________________________________
Realizar operaciones básicas de edición de archivos usando vi
• Peso: 3
• Los estudiantes deberían ser capaces de editar archivos de texto usando vi. Este objetivo incluye navegación vi, modos básicos de vi, inserción, edición, borrar, copiar y buscar texto.
Áreas de Conocimiento
• Navegar por un documento usando vi.
• Uso básico de los modos de vi.
• Insertar, editar, borrar, copiar y buscar texto.
Términos y utilidades
• vi
• /,?
• h, j, k, l
• i, o, a
• c, d, p, y, dd, aa
• ZZ,: w!,: q!,: e!
________________________________________
Dispositivos, sistemas de ficheros Linux, jerarquía estándar del sistema de archivos
Crear particiones y sistemas de archivos
• Peso: 2
• Los estudiantes deberían ser capaces de configurar particiones de disco y sistemas de ficheros en los medios de comunicación, tales como discos duros. Esto incluye el manejo de particiones de intercambio.
Áreas de Conocimiento
• ext2
• ext3
• xfs
• ReiserFS v3
• vfat
Términos y utilidades
• fdisk
• mkfs
• mkswap
________________________________________
Mantener la integridad de los sistemas de ficheros
• Peso: 2
• Los estudiantes deberían ser capaces de mantener un sistema de ficheros estándar, así como los datos adicionales asociados con un sistema de archivos diario.
Áreas de Conocimiento
• Verificar la integridad de los sistemas de ficheros.
• Monitoreo de espacio libre y los inodos.
• Reparación de problemas simples del sistema de archivos.
Términos y utilidades
• du
• df
• fsck
• e2fsck
• mke2fs
• debugfs
• dumpe2fs
• tune2fs
• herramientas xfs
________________________________________
Control de montaje y desmontaje de sistemas de archivos
• Peso: 3
• Los estudiantes deberían poder configurar el montaje de un sistema de archivos.
Áreas de Conocimiento
• Montar y desmontar sistemas de ficheros.
• Configurar sistemas de archivos de montaje en el arranque.
• Configurar el montaje de sistemas de archivos extraíbles.
Términos y utilidades
• / Etc / fstab
• / Media
• mount
• umount
________________________________________
Administrar cuotas de disco
• Peso: 1
• Los estudiantes deberían ser capaces de gestionar las cuotas de disco para los usuarios.
Áreas de Conocimiento
• Establecer una cuota de disco para un sistema de archivos.
• Editar, revisar y generar reportes de cuotas de usuario.
Términos y utilidades
• quota
• edquota
• repquota
• quotaon
________________________________________
Gestionar los permisos de archivos y la propiedad
• Peso: 3
• Los estudiantes deberían ser capaces de controlar el acceso a archivos a través del uso adecuado de los permisos y propietarios.
Áreas de Conocimiento
• Gestionar los permisos de acceso a los archivos y directorios.
• Utilice los modos de acceso como suid, sgid y el sticky bit para mantener la seguridad.
• Conocer cómo cambiar la máscara de creación de archivos.
• Utilice el campo de grupo para conceder acceso a archivos a los miembros del grupo.
Términos y utilidades
• chmod
• umask
• chown
• chgrp
________________________________________
Crear y cambiar enlaces duros y simbólicos
• Peso: 2
• Los estudiantes deberían ser capaces de crear y administrar enlaces duros y simbólicos a un archivo.
Áreas de Conocimiento
• Crear vínculos.
• Identificar duros y / o enlaces simbólicos.
• Copia frente a vincular archivos.
• Utilice los vínculos para apoyar las tareas de administración.
Términos y utilidades
• ln
________________________________________
Buscar archivos de sistema y colocar archivos en la ubicación correcta
• Peso: 2
• Descripción: Los candidatos deben estar familiarizados con la jerarquía estándar del sistema de ficheros (FHS), incluida la ubicación de los archivos típicos y clasificación de directorios.
Áreas de Conocimiento
• Entender la ubicación correcta de archivos en el FHS.
• Buscar archivos y los comandos en un sistema Linux.
• Conozca la ubicación y la finalidad del fichero y directorios importantes como se define en el estándar FHS.
Términos y utilidades
• find
• locate
• updatedb
• whereis
• which
• type
• / etc / updatedb.conf

CeNTOS

Si desea una distribución de Linux con una gran compatibilidad hacia atrás, un ciclo de apoyo a largo plazo (siete años),CentOS debe estar el primero de la lista. Resulta que CentOS es la distribución seleccionada por el 30% de servidores web.
Licencia fee-free y totalmente compatible con Red Hat Enterprise Linux.
Como aviso os avisamos que la imagen i386 de DVD es grande para caber un DVD + R, así que usar un DVD-R cuando las copias para CDs sean liberadas en pocos días.