Administrador Red Hat Fedora v2-6

Administración del sistema operativo Red Hat/Fedora Linux
Tabla de contenido
Instalación del sistema operativo Red Hat/Fedora Linux................................................9

Aspectos básicos del hardware.......................................................................................10
La CPU........................................................................................................................10
Memoria.......................................................................................................................11
Buses...........................................................................................................................11
Controladores y periféricos.........................................................................................12
Espacios de direcciones..............................................................................................12
Cronómetros................................................................................................................13
Interrupciones..............................................................................................................13
Instalación de Red Hat Linux...........................................................................................14
Nombres de Dispositivo en Linux................................................................................14
Crear un CD-ROM de arranque de instalación...........................................................15
Arranque de la instalación desde un USB pen drive.................................................. 15
Interfaz gráfica de usuario del programa de instalación.............................................15
Nota sobre las consolas virtuales................................................................................16
Opciones de arranque adicionales..............................................................................16
Opciones del kernel.....................................................................................................17
Selección de un método de instalación.......................................................................17
Instalación desde un CD-ROM....................................................................................18
Instalación desde un disco duro..................................................................................18
Preparación para la instalación de red........................................................................19
Instalación a través de NFS........................................................................................19
Instalación a través de FTP.........................................................................................19
Instalación a través de HTTP......................................................................................19
Particionamiento automático de discos...........................................................................20
Esquema de particionamiento recomendado..............................................................20
Configuración del gestor de arranque.............................................................................21
El archivo anaconda-ks.cfg..............................................................................................22
Administración del sistema de archivos.........................................................................23
El sistema de ficheros......................................................................................................24
El Second Extended File system (EXT2)....................................................................24
El inodo EXT2..............................................................................................................25
El Superbloque............................................................................................................26
El desciptor de grupo ..................................................................................................27
El sistema de archivos EXT3......................................................................................28
Gestión de particiones.....................................................................................................29
Cantidad máxima de particiones.................................................................................29
Numeración de particiones..........................................................................................29
Usando fdisk................................................................................................................30
Creación del sistema de archivos....................................................................................31
Ajustando parámetros del sistema de archivos ext2/ext3...........................................31
Montado de sistemas de archivos ..............................................................................32
Ejemplo de la adición de un disco con sistema de archivos ext3...............................35
Verificación y reparación del sistema de archivos ext2/ext3...................................... 38
Gestión del espacio Swap...............................................................................................39
Añadir el espacio Swap...............................................................................................39
Utilización de autofs.........................................................................................................41
Proceso de arranque, inicio y cierre del sistema...........................................................43
Proceso de arranque.......................................................................................................44
Vista detallada del proceso de arranque.....................................................................44
El BIOS........................................................................................................................45
El gestor de arranque..................................................................................................45
Gestores de arranque para otras arquitecturas..........................................................46
El kernel.......................................................................................................................46
Programa /sbin/init.......................................................................................................47
Ejecutar programas adicionales en el momento de arranque.................................... 48
Uso de sysctl ...................................................................................................................49
Niveles de ejecución de SysV Init...................................................................................49
Niveles de ejecución....................................................................................................50
Utilidades de los niveles de ejecución........................................................................ 51
Cierre del sistema............................................................................................................52
Administración de usuarios..............................................................................................54
Usuarios y grupos............................................................................................................55
Herramientas de administración de usuarios y grupos...............................................55
Configuración de usuarios desde la línea de comandos................................................ 56
Añadir un usuario........................................................................................................56
Añadir un grupo...........................................................................................................57
Vencimiento de la contraseña.....................................................................................57
El archivo /etc/passwd.................................................................................................58
El archivo /etc/group....................................................................................................59
Grupos de usuario privado..........................................................................................59
Directorios de grupos..................................................................................................60
Contraseñas Shadow......................................................................................................61
El archivo /etc/shadow.................................................................................................61
Configuración de la autenticación...................................................................................62
Métodos de autenticación...........................................................................................63
Instalación y gestión de paquetes...................................................................................65
Gestión de paquetes........................................................................................................66
Metas de diseño RPM.................................................................................................66
Instalación de paquetes RPM.....................................................................................67
Paquete ya instalado...................................................................................................68
Archivos en conflicto....................................................................................................68
Dependencias no resueltas.........................................................................................69
Desinstalación.............................................................................................................69
Actualización...............................................................................................................70
Refrescamiento...........................................................................................................70
Consultas.....................................................................................................................71
Verificación..................................................................................................................72
Verificando la firma del paquete......................................................................................73
Importar claves............................................................................................................74
Verificación de la firma de paquetes...........................................................................74
Técnicas de uso de rpm..................................................................................................75
Yellowdog Updater Modified (YUM)................................................................................77
Configuración de YUM................................................................................................77
Utilización de YUM......................................................................................................80
Creación de un repositorio yum local..........................................................................81
Creación del repositorio base para YUM....................................................................81
Creación del repositorio updates para YUM...............................................................82
Configuración de los equipos para utilizar el repositorio YUM local...........................82
La herramienta up2date..............................................................................................83
Herramientas del sistema ................................................................................................84
Configuración de la impresora.........................................................................................85
Añadir una impresora local..........................................................................................86
Añadir una impresora IPP...........................................................................................86
Añadir una impresora UNIX (LPD) remota..................................................................87
Añadir una impresora Samba (SMB)..........................................................................87
Añadir una impresora Novell NetWare (NCP).............................................................88
Añadir una impresora JetDirect...................................................................................89
Selección del modelo de impresora............................................................................89
Guardar y restaurar el archivo de configuración.............................................................90
Administración de trabajos de impresión........................................................................ 91
Deshabilitando las impresoras y las colas de impresión.................................................92
Compartir una impresora.................................................................................................93
Opciones de la cola.....................................................................................................93
El demonio crond.............................................................................................................94
Configuración de crontab............................................................................................94
Crontab predeterminados............................................................................................95
La heramienta tmpwatch.................................................................................................95
El servicio Syslog ............................................................................................................96
Configuración de Syslog.............................................................................................97
Las facilidades y su utilización....................................................................................98
Las prioridades............................................................................................................98
Acciones......................................................................................................................99
Comunicación con Syslog.........................................................................................100
Rotación de las trazas del sistema................................................................................101
Administrando copias de seguridad..............................................................................103
Salvando datos..........................................................................................................103
STAR – Unique Standard Tape Archiver..................................................................103
Características del comando star..............................................................................103
Realizando una copia de seguridad..........................................................................104
Ejemplos de utilización de las opciones del comando star.......................................106
Realizando copias de seguridad incrementales....................................................... 107
Haciendo copias de seguridad remotas....................................................................108
Gestores de arranque y autoinstalación.......................................................................109
GRUB.............................................................................................................................110
Proceso de arranque en un sistema x86 y GRUB....................................................110
Funciones de GRUB..................................................................................................111
Terminología de GRUB.............................................................................................112
Nombres de dispositivos...........................................................................................112
Nomenclatura de dispositivos en GRUB...................................................................112
Nombres de archivos y listas de bloques..................................................................113
Sistema de archivos raíz de GRUB.......................................................................... 114
Interfaces de GRUB..................................................................................................114
Orden de uso de Interfaces.......................................................................................115
Comandos de GRUB.................................................................................................115
Archivo de configuración de menú de GRUB........................................................... 117
Comandos especiales del archivo de configuración.................................................117
Estructura del archivo de configuración....................................................................118
Cambiar los niveles de ejecución en el tiempo de arranque.................................... 118
Instalaciones Kickstart...................................................................................................119
Cómo realizar una instalación de Kickstart?.............................................................119
Opciones de Kickstart...............................................................................................119
Usando el archivo kickstart.......................................................................................120
Configuración de un servidor de instalación.............................................................120
Configuración del servidor NFS................................................................................122
Reconfiguración del kernel.............................................................................................124
Actualización del kernel.................................................................................................125
Preparación de la actualización................................................................................125
Realizando la actualización.......................................................................................127
Verificación de la imagen de disco RAM inicial........................................................ 128
Configuración del gestor de arranque.......................................................................128
Módulos del kernel.........................................................................................................129
Utilidades del módulo del kernel...............................................................................130
Construcción de un kernel personalizado.....................................................................132
Preparación para la construcción..............................................................................132
Construcción del Kernel............................................................................................133
Construcción de un kernel monolítico...........................................................................136
Resumen de pasos necesarios para construir un kernel personalizado.................. 136
El sistema X Window.......................................................................................................138
El lanzamiento X11R6.8................................................................................................139
Entornos de escritorio....................................................................................................140
Gestores de ventanas....................................................................................................140
Archivos de configuración del servidor X......................................................................141
El archivo xorg.conf...................................................................................................142
La estructura de Xorg................................................................................................142
Sección ServerFlags.................................................................................................142
Sección ServerLayout...............................................................................................143
Sección Files.............................................................................................................144
Sección Module.........................................................................................................144
Sección InputDevice..................................................................................................145
Sección Monitor.........................................................................................................146
Sección Device..........................................................................................................147
Sección Screen.........................................................................................................148
DRI.............................................................................................................................149
Fuentes..........................................................................................................................150
Fontconfig..................................................................................................................150
Añadir fuentes a Fontconfig......................................................................................150
Añadir fuentes TrueType...........................................................................................151
Sistema de fuentes base de X..................................................................................151
Configuración de xfs..................................................................................................151
Añadir fuentes a xfs...................................................................................................153
Niveles de ejecución y X................................................................................................153
Nivel de ejecución 3..................................................................................................153
Nivel de ejecución 5..................................................................................................154
Ejecutando aplicaciones remotas con X11................................................................... 156
Lanzando una aplicación remota..............................................................................157
Utilización de X remoto con SSH..............................................................................157
Sesiones gráficas remotas (XDMCP)....................................................................... 158
Sesión gráfica remota con GDM...............................................................................158
Configuración de gdm para aceptar conexiones XDMCP........................................ 158
Solución de problemas...................................................................................................160
Diagnóstico y solución de problemas X........................................................................ 161
Modo de rescate ...........................................................................................................161
Incapaz de Iniciar Linux ............................................................................................162
Problemas Hardware/Software ................................................................................162
Iniciar el modo monousuario directamente ..............................................................163
Disco de inicio................................................................................................................164
1
Instalación del sistema operativo Red Hat/Fedora Linux

Instalación de Red Hat Linux
Aspectos básicos del hardware
Un sistema operativo debe trabajar íntimamente con el hardware que le sirve de

cimientos. El sistema operativo necesita ciertos servicios que solo pueden
suministrar el hardware. Para entender totalmente el sistema operativo Linux, se
necesita entender los aspectos básicos del hardware que hay debajo.
La CPU
La CPU, o mejor, microprocesador, es el corazón de cualquier computadora. El

microprocesador calcula, realiza operaciones lógicas y gestiona flujos de datos
leyendo instrucciones desde la memoria y ejecutándolas. En los primeros días de la
informática los componentes funcionales del microprocesador eran unidades
separadas (y grandes físicamente). Fue entonces cuando se acuñó el término
Unidad Central de Proceso (Central Processing Unit). El microprocesador
moderno combina esos componentes en un circuito integrado, grabado en una
pequeña pieza de silicio. Los términos CPU, microprocesador y procesador se usan
de manera intercambiable en este libro.
Los microprocesadores operan sobre datos binarios; estos son datos compuestos
de unos y ceros. Estos unos y ceros corresponden a interruptores eléctricos que
están encendidos o apagados. Igual que 42 es un número decimal que significa ``4
decenas y 2 unidades'', un número binario es una serie de dígitos binarios, cada
uno representando una potencia de 2.
Los microprocesadores pueden realizar operaciones aritméticas como sumar,

multiplicar y dividir, y operaciones lógicas como “¿es X mayor que Y?'”.
La ejecución del procesador viene gobernada por un reloj externo. Este reloj, el
reloj del sistema, envía pulsos de reloj regulares al procesador y, a cada pulso de
reloj, el procesador hace algún trabajo. Por ejemplo, un procesador podría ejecutar
una instrucción a cada pulso de reloj. La velocidad del procesador se describe en
términos de la frecuencia de pulsos del reloj del sistema. Un procesador de 100Mhz
recibirá 100 000 000 pulsos de reloj cada segundo. Puede llevar a confusión
describir la potencia de una CPU por su frecuencia de reloj ya que diferentes
procesadores realizan diferentes cantidades de trabajo a cada pulso de reloj. De
todos modos, si el resto de las características son iguales, una mayor velocidad de
reloj significa un procesador más potente.
Las instrucciones ejecutadas por el procesador son muy simples; por ejemplo
“copia en el registro Y el contenido de la posición X de la memoria”. Los registros
son el almacén interno del microprocesador, se usan para almacenar datos y
realizar operaciones sobre ellos. Las operaciones realizadas pueden hacer que el
Red Hat Certified Engineer 10

procesador deje de hacer los que estaba haciendo y salte a otra instrucción en otra
parte de la memoria. Estos pequeños ladrillos dan al microprocesador moderno un
poder casi ilimitado ya que puede ejecutar millones o incluso miles de millones de
instrucciones por segundo.
Las instrucciones deben ser obtenidas de la memoria para ejecutarlas. Las propias
instrucciones pueden hacer referencia a datos en la memoria, y esos datos deben
ser obtenidos de la memoria y guardados en ella cuando se requiera.
Para obtener información de la CPU que está utilizando el sistema ejecute el

comando:
# cat /proc/cpuinfo
Memoria
Todos los sistemas tienen una jerarquía de memoria, con memoria de diferentes
velocidades y tamaños en diferentes puntos de la jerarquía. La memoria más
rápida se conoce como memoria caché y es una memoria que se usa para
almacenar temporalmente contenidos de la memoria principal. Este tipo de
memoria es muy rápida pero cara, por tanto la mayoría de los procesadores tienen
una pequeña cantidad de memoria caché en el chip y más memoria caché en el
sistema (en la placa). Algunos procesadores tienen una caché para contener
instrucciones y datos, pero otros tienen dos, una para instrucciones y la otra para
datos. El procesador Alpha tiene dos memorias caché internas; una para datos (la
Caché-D) y otra para instrucciones (la Caché-I). La caché externa (o Caché-B)
mezcla los dos juntos. Finalmente está la memoria principal, que comparada con
la memoria caché externa es muy lenta. Comparada con la caché en la CPU, la
memoria principal se arrastra.
Las memorias caché y principal deben mantenerse sincronizadas (coherentes). En

otras palabras, si una palabra de memoria principal se almacena en una o más
posiciones de la caché, el sistema debe asegurarse de que los contenidos de la
caché y de la memoria sean los mismos. El trabajo de coherencia de la caché es
llevado a cabo parcialmente por el hardware y parcialmente por el sistema
operativo. Esto es cierto también para un número de tareas principales del sistema,
donde el hardware y el software deben cooperar íntimamente para alcanzar sus
objetivos.
Puede obtener información de la memoria del sistema ejecutando el comando:

# cat /proc/meminfo
Buses
Los componentes individuales de la placa del sistema están conectados entre sí
11 Ing. Iván Ferreira

por sistemas de conexión múltiple conocidos como buses. El bus de sistema está
dividido en tres funciones lógicas; el bus de direcciones, el bus de datos y el
bus de control. El bus de direcciones especifica las posiciones de memoria
(direcciones) para las transferencias de datos. El bus de datos contiene los datos
transferidos El bus de datos es bidireccional; permite escribir datos en la CPU y
leerlos desde la CPU. El bus de control contiene varias lineas que se usan para
dirigir señales de sincronismo y control a través del sistema. Existen muchos tipos
de bus, por ejemplo los buses ISA y PCI son formas populares de conectar
periféricos al sistema.
Para obtener información del bus pci ejecute:

# cat /proc/pci
Información de los dispositivos existentes en los demás buses del sistema, pueden
ser obtenidos consultando el directorio:
/proc/bus
Controladores y periféricos
Los periféricos son dispositivos reales, como tarjetas gráficas o discos controlados
por chips controladores que se encuentran en la placa del sistema, o en tarjetas
conectadas a ella. Los discos IDE son controlados por el chip controlador IDE, y los
discos SCSI por los chips controladores de disco SCSI, y así sucesivamente. Estos
controladores están conectados a la CPU y entre ellos por una variedad de buses.
La mayoría de los sistemas construidos actualmente usan buses PCI e ISA para
conectar entre sí los principales componentes del sistema. Los controladores son
procesadores como la propia CPU, se pueden ver como asistentes inteligentes de
la CPU. La CPU tiene el control sobre todo el sistema.
Todos los controladores son diferentes, pero usualmente tienen registros que los
controlan. El software que se ejecute en la CPU debe ser capaz de leer y escribir
en esos registros de control. Un registro puede contener un estado que describa un
error. Otro puede ser usado para propósitos de control; cambiando el modo del
controlador. Cada controlador en un bus puede ser accedido individualmente por la
CPU, esto es así para que el software gestor de dispositivos pueda escribir en sus
registros y así controlarlo, La banda IDE es un buen ejemplo, ya que ofrece la
posibilidad de acceder a cada unidad en el bus por separado. Otro buen ejemplo es
el bus PCI, que permite acceder a cada dispositivo (por ejemplo una tarjeta gráfica)
independientemente.
Espacios de direcciones
El bus del sistema conecta la CPU con la memoria principal y está separado de los
buses que conectan la CPU con los periféricos. El espacio de memoria en el que

existen los periféricos hardware se conoce colectivamente como espacio de I/O

(por Input/Output, Entrada/Salida). El espacio de I/O puede estar subdividido a su
vez, pero no nos preocuparemos demasiado sobre eso de momento. La CPU
puede acceder a la memoria en el espacio del sistema y a la memoria en el espacio
de I/O, mientras que los controladores sólo pueden acceder a la memoria en el
espacio del sistema indirectamente, y sólo con la ayuda de la CPU. Desde el punto
de vista del dispositivo, digamos un controlador de disquetes, verá sólo el espacio
de direcciones en el que se encuentran sus registros de control (ISA) y no la
memoria del sistema.
Típicamente, una CPU tendrá instrucciones separadas para acceder al espacio de

memoria y al espacio de I/O. Por ejemplo, puede haber una instrucción que
signifique “lee un byte de la dirección de I/O 0x3f0 y ponlo en el registro X”. Así es
exactamente como controla la CPU a los periféricos hardware del sistema, leyendo
y escribiendo en sus registros en el espacio de I/O. En qué lugar del espacio I/O
tienen sus registros los periféricos comunes (controlador IDE, puerta serie,
controlador de disco flexible, y demás) ha sido definido por convenio a lo largo de
los años conforme la arquitectura del PC se ha desarrollado. Sucede que la
dirección 0x3f0 del espacio I/O es la dirección de uno de los registros de control de
la puerta serie (COM1).
Existen ocasiones en las que los controladores necesitan leer o escribir grandes
cantidades de datos directamente desde o a la memoria del sistema. Por ejemplo,
cuando se escriben datos del usuario al disco duro. En este caso, se usan
controladores de Acceso Directo a Memoria (Direct Memory Access - DMA)
para permitir que los periféricos hardware accedan directamente a la memoria del
sistema, pero este acceso está bajo el estricto control y supervisión de la CPU.
Para obtener información del espacio de direcciones ejecute el comando:

# cat /proc/ioports
Cronómetros
Todos los sistemas operativos necesitan saber la hora, y así, la placa madre
incluye un dispositivo especial llamado el Reloj de Tiempo Real (Real Time Clock
- RTC). Este dispositivo suministra dos cosas: una hora del día fiable y un
cronómetro preciso. El RTC tiene su propia batería, de forma que siga funcionado
incluso cuando el PC no esté encendido, así es como el equipo “sabe”' siempre la
fecha y hora correctas. El cronómetro permite que el sistema operativo planifique
de manera precisa el trabajo esencial.
Interrupciones
Linux usa distintos componentes físicos para llevar a cabo trabajos muy diferentes.
El dispositivo de vídeo maneja el monitor, el dispositivo IDE maneja los discos, y

así sucesivamente. Puede manejar estos dispositivos de forma sincronizada, es

decir, puede enviar una petición de alguna operación (como escribir un bloque de
memoria a disco) y luego esperar que la operación se complete. Este método,
aunque funciona, es muy poco eficiente y el sistema operativo pasaría mucho
tiempo «ocupado sin hacer nada» mientras espera que cada operación finalice.
Una manera mejor y más eficiente sería realizar la petición y luego realizar otra, un
trabajo más útil que luego se interrumpiría cuando el dispositivo haya finalizado la
petición. Con este esquema puede haber muchas peticiones pendientes hacia los
dispositivos en el sistema, todas al mismo tiempo.
Algunas interrupciones son fijas por convenio de la arquitectura del hardware y

entonces el controlador simplemente pide esa interrupción cuando se haya
inicializado. Esto es lo que hace el controlador de la disquetera; siempre pide la
IRQ 6 (IRQ = Interrupt ReQuest, petición de Interrupción). Puede haber
ocasiones en las que un controlador no sepa qué interrupción va a usar el
dispositivo. Esto no es un problema para los controladores de dispositivos PCI ya
que siempre saben cual es su número de interrupción. Desafortunadamente no hay
ninguna manera fácil de que los controladores de dispositivos ISA encuentren su
número de interrupción.
Para obtener información de las interrupciones utilizadas ejecute el comando:

# cat /proc/interrupts
Instalación de Red Hat Linux
Antes de instalar Red Hat Linux verifique que cumple los requisitos de espacio en
disco para la instalación.
La instalación de Red Hat Linux requiere de una partición utilizada como área de
intercambio de memoria (swap) de al menos el mismo tamaño que la memoria
RAM. Los archivos del sistema operativo requieren entre 500 M a 5 GB
dependiendo de los paquetes seleccionados.
Nombres de Dispositivo en Linux
En Linux, los nombres de disco y de particiones pueden ser diferentes de otros

sistemas operativos. Para crear y montar particiones, necesita conocer los nombres
que utiliza Linux. Este es el esquema básico de nomenclatura:
● La primera unidad de disquete se llama /dev/fd0.
● La segunda unidad de disquete se llama /dev/fd1.
● El primer disco SCSI se llama /dev/sda.

● El segundo disco SCSI se llama /dev/sdb, etcétera.
● El primer CD-ROM SCSI se llama /dev/scd0.
● El disco maestro de la controladora IDE primaria se llama /dev/hda. El disco

esclavo de la controladora IDE primaria se llama /dev/hdb.
● El disco maestro de la controladora IDE secundaria se llama /dev/hdc. El

disco esclavo de la controladora IDE secundaria se llama /dev/hdd.
● Los dispositivos USB son reconocidos como dispositivos SCSI, por tanto su
nombre de dispositivo será /dev/sd<x>. Siendo <x> una letra disponible
dependiendo de la cantidad de discos SCSI existentes en el sistema.
Las particiones de cada disco se representan añadiendo un número decimal al

nombre del disco: sda1 y sda2 representan la primera y segunda partición del la
primera unidad de disco SCSI de su sistema.
He aquí un ejemplo de la vida real. Supongamos que tiene un sistema con dos
discos SCSI. El primer disco se llama por tanto sda, y el segundo sdb. Si la unidad
sda tiene 3 particiones, éstas se llamarán sda1, sda2 y sda3. Lo mismo se aplica para el
disco sdb y sus particiones.
Crear un CD-ROM de arranque de instalación
En el directorio images/ encontrará el archivo boot.iso. Este archivo ISO puede ser
usado para iniciar el programa de instalación. Deberá quemar el archivo boot.iso a
un CD grabable y la máquina debe estar configurada para arrancar desde el CD-
ROM.
Arranque de la instalación desde un USB pen drive
Si no puede arrancar desde el CD-ROM, pero puede iniciar desde un dispositivo

USB, como un USB pen drive, la siguiente alternativa de inicio esta disponible.
Para iniciar desde un USB pen drive, utilice el comando dd para copiar la imagen
diskboot.img desde el directorio /images/ del CD-ROM 1. Por ejemplo:
dd if=diskboot.img of=/dev/sda
El BIOS debe soportar iniciar desde un dispositivo USB.
Interfaz gráfica de usuario del programa de instalación

Si ha utilizado la interfaz de usuario en modo gráfico (GUI) con anterioridad, este

proceso le será muy familiar. Use el ratón para navegar por las pantallas, pulse los
botones o rellene los campos de texto. Puede también utilizar las teclas [Tab] e
[Intro] para navegar.
Si no quiere utilizar el programa de instalación GUI, está disponible el programa de

instalación en modo texto. Para utilizarlo, ejecute el siguiente comando de
arranque:
boot: linux text
Nota sobre las consolas virtuales
El programa de instalación de Red Hat Linux ofrece más que las ventanas de
diálogo del proceso de instalación. Además de darle la posibilidad de insertar
comandos desde el intérprete de comandos de la shell, tiene a su disponibilidad
muchos tipos diferentes de mensajes. El programa de instalación despliega estos
mensajes en cinco consolas virtuales, entre las que puede cambiarse usando una
combinación de teclas.
Consola Combinación de teclas Contenido

1 [Ctrl]-[Alt]-[F1] Diálogo de instalación
2 [Ctrl]-[Alt]-[F2] Intérprete de comandos de la shell
3 [Ctrl]-[Alt]-[F3] Log de instalación
4 [Ctrl]-[Alt]-[F4] Mensajes de sistema
5 [Ctrl]-[Alt]-[F5] Otros mensajes
7 [Ctrl]-[Alt]-[F7] Pantalla gráfica de X
Opciones de arranque adicionales
Aunque para un usuario resulta más sencillo arrancar desde un CD-ROM y ejecutar
una instalación gráfica, en ocasiones hay instalaciones en las que puede ser
necesario realizar el arranque con un método distinto. En esta sección se describen
las opciones de arranque adicionales que hay disponibles para el sistema Red Hat
Linux.
Si no desea realizar una instalación gráfica, puede iniciar una instalación en modo
texto mediante el siguiente comando de arranque:
boot: linux text
as imágenes ISO ahora tienen un md5sum integrado. Para probar la integridad

checksum de una imagen ISO, en el indicador de comandos de arranque de la

instalación, escriba:
boot: linux mediacheck
Si el programa de instalación no detecta correctamente el hardware instalado,

probablemente deberá reiniciar la instalación en modo experto. Para usar el modo
experto, escriba el siguiente comando de arranque:
boot: linux noprobe
Para ejecutar la instalación en modo texto en modo experto utilice:

boot: linux text noprobe
Si necesita realizar una instalación en modo serie, escriba el siguiente comando:

boot: linux console=<dispositivo>
Si tiene un disco de controlador de dispositivo (driver disk), especialmente para

controladoras de disco, puede informar al programa de instalación con la opción.
Se solicitará el disco controlador durante la instalación del sistema:
boot: linux dd
Para ejecutar la instalación en modo texto a través del puerto serie, utilice:
boot: linux text console=<dispositivo>
En el comando anterior, <dispositivo> es el dispositivo que está utilizando (como

ttyS0 o ttyS1). Por ejemplo, linux text console=ttyS0,115200n8. Esto es
especialmente útil para servidores sin tarjeta de video incorporada.
Opciones del kernel
Estas opciones se pueden transmitir directamente al kernel. Si por ejemplo, se

desea que el kernel utilice toda la RAM en un sistema de 2 GB, introduzca:
boot: linux mem=2048M
Esto puede ser útil especialmente en sistemas que comparten la memoria RAM con
la tarjeta de video.
Selección de un método de instalación
Es posible iniciar el programa de instalación desde la unidad de CD y continuarla a

partir de otra fuente de instalación. Para seleccionar el método de instalación utilice
la siguiente opción de arranque:

boot: linux askmethod
La instalación puede ser realizada desde:
● CD-ROM: Si posee un lector de CD-ROM y tiene el CD-ROM de Red Hat

Linux, puede utilizar este método.
● Disco duro: Si ha copiado las imágenes ISO de Red Hat Linux en el disco
duro local, puede utilizar este método.
● Imagen NFS: Si está realizando la instalación desde un servidor NFS

utilizando imágenes ISO o una imagen réplica de Red Hat Linux, puede
utilizar este método.
● FTP: Si está realizando la instalación directamente desde un servidor FTP,

utilice este método.
● HTTP: Si está realizando la instalación directamente desde un servidor Web

HTTP, utilice este método.
Instalación desde un CD-ROM
Para instalar Red Hat Linux desde un CD-ROM, escoja CD-ROM y seleccione OK.
Cuando el programa se lo indique, inserte el CD de Red Hat Linux en el lector de
disco (si no arrancó desde una unidad de CD). Una vez que el CD esté en la
unidad de CD-ROM, seleccione OK, y presione [Intro].
Instalación desde un disco duro
Las instalaciones desde un disco duro solamente funcionan con los sistemas de
archivos ext2, ext3 o FAT. Si tiene un sistema de archivos diverso de los que
aparecen aquí como reiserfs, no podrá llevar a cabo este tipo de instalación.
Las instalaciones desde el disco duro usan imágenes ISO (o de CD-ROM).
La pantalla “Selección de la partición” se puede aplicar sólo si está realizando la

instalación desde una partición del disco (es decir, si ha seleccionado Disco duro
en el Método de instalación. Esta ventana de diálogo le permite nombrar la
partición del disco y el directorio desde el que está instalando Red Hat Linux.
Introduzca el nombre del dispositivo de la partición que contiene las imágenes ISO.
También hay un campo etiquetado Directorio que contiene imágenes. Si las
imágenes ISO no se encuentran en el directorio root de esa partición introduzca el
recorrido hacia las imágenes ISO (por ejemplo, si las imágenes ISO están en
/iso/rhel, introduzca /iso/rhel).

Preparación para la instalación de red
Si está llevando a cabo una instalación de red, la ventana de diálogo Configurar

TCP/IP aparecerá. Este diálogo le pedirá su IP y otras direcciones de red. Puede
escoger configurar la dirección IP y la máscara del dispositivo a través de DHCP o
manualmente.
Instalación a través de NFS
La ventana de NFS aparece solamente si está realizando una instalación desde un

servidor NFS.
Introduzca el nombre de dominio completo o la dirección IP del servidor NFS.
A continuación, introduzca el nombre del directorio exportado. Introduzca el

directorio que contiene el directorio RedHat/.
Instalación a través de FTP
La ventana de FTP aparece solamente si está realizando una instalación desde un

servidor FTP si seleccionó FTP en el Método de instalación). Esta pantalla le
permite identificar el servidor FTP desde el que está realizando la instalación de
Red Hat Linux.
Introduzca el nombre o la dirección IP del sitio FTP desde el que está instalando y
el nombre del directorio que contiene los archivos de instalación RedHat para su
arquitectura. Por ejemplo si el sitio FTP contiene el directorio
/mirrors/redhat/i386/RedHat, introduzca /mirrors/redhat/i386. Si todo ha salido bien,
aparece un mensaje que le indica que se ha aceptado base/hdlist.
Instalación a través de HTTP
La ventana de HTTP aparece solamente si está realizando una instalación desde

un servidor HTTP si seleccionó HTTP en la ventana Método de instalación). Esta
pantalla le pedirá información sobre el servidor HTTP desde el que está realizando
la instalación de Red Hat Linux.
Introduzca el nombre o la dirección IP del sitio HTTP desde el que está instalando y
el nombre del directorio que contiene los archivos de instalación RedHat para su
arquitectura. Por ejemplo si el sitio HTTP contiene el directorio
/mirrors/redhat/i386/RedHat, introduzca /mirrors/redhat/i386. Si todo se ha
especificado correctamente, aparecerá un mensaje indicándole que base/hdlist ha

sido recuperado.
Particionamiento automático de discos
El particionamiento automático le permite tener control de los datos que se han

eliminado en su sistema. Tiene las siguientes opciones:
● Eliminar todas las particiones Linux del sistema: seleccione esta opción
para eliminar tan sólo las particiones Linux (particiones creadas en una
instalación Linux previa). No borrará el resto de particiones que tenga en el
disco(s) duro(s) (tal como VFAT o particiones FAT32).
● Eliminar todas las particiones del sistema: seleccione esta opción para
eliminar todas las particiones de su disco duro (esto incluye las particiones
creadas por otros sistemas operativos tales como Windows 95/98/NT/2000).
● Mantener todas las particiones y usar el espacio libre existente:

seleccione esta opción para conservar los datos y las particiones actuales,
presumiendo que tiene suficiente espacio disponible en los discos duros.
Para revisar y realizar los cambios necesarios en las particiones creadas con el
particionamiento automático, seleccione la opción Revisar.
Esquema de particionamiento recomendado
A no ser que tenga razones para hacerlo de otro modo, le recomendamos que cree
las siguientes particiones:
● Una partición swap Las particiones swap se usan para soportar la memoria
virtual. En otras palabras, los datos se escriben en la partición swap cuando
no hay suficiente RAM para almacenar los datos que su sistema está
procesando. El tamaño mínimo de la partición swap debería ser igual al de la
memoria RAM que tiene el sistema.
Hasta red hat 2.1 existía una limitación del tamaño de la partición de swap
hasta 2 GB para cada espacio swap. Esto era debido a que el comando
mkswap no soportaba la creación de áreas de swap mayores a 2 GB. En red
Hat Enterprise Linux 3 y superior, el comando mkswap permite la creación de
particiones swap mayores a 2 GB.
Red Hat Enterprise Linux 2.1 soporta hasta 32 particiones de 2 GB. Total 64
GB.
Red Hat Enterprise Linux 3 y superiores soportan particiones de swap mas

grandes y esta dado por el límite del tamaño del dispositivo de bloques. Red

Hat Enterprise Linux tiene 1 TB como límite del tamaño de los dispositivos
de bloques, por tanto es 1 TB.
● Una partición /boot (100MB) la partición montada sobre /boot contiene el

kernel del sistema operativo (que permitirá al sistema arrancar Red Hat
Linux), junto a otros archivos utilizados para el proceso de arranque. Debido
a las limitaciones de la mayoría de las BIOS de los ordenadores, se
aconseja crear una partición pequeña para guardar estos archivos. Para la
mayoría de los usuarios, una partición de arranque de 100 MB es suficiente.
● Una partición root (500MB - 5.0GB) aquí es donde se ubica "/" (el
directorio raíz). En esta instalación, todos los archivos (excepto los
almacenados en /boot) se encuentran en la partición raíz. Una partición raíz
de 500 MB permitirá una instalación mínima, mientras que una partición de
5.0GB le permitirá instalar todos los paquetes.
Configuración del gestor de arranque
El gestor de arranque es el primer software que se ejecuta cuando se arranca el

ordenador. Es responsable de la carga y de la transferencia del control al software
del sistema operativo del kernel. El kernel, por otro lado, inicializa el resto del
sistema operativo.
El GRUB (GRand Unified Bootloader) que se instala por defecto, es un gestor de

arranque muy potente ya que puede cargar una gran variedad de sistemas
operativos gratuítos así como sistemas operativos de propietarios con el sistema de
cargado en cadena (el mecanismo para cargar sistemas operativos no soportados
mediante la carga de otro gestor de arranque, tal como DOS o Windows).
Puede instalar el gestor de arranque en uno de los dos sitios siguiente:
● El master boot record (MBR) Este es el sitio recomendado para instalar un

gestor de arranque, a no ser que el MBR esté ocupado por el gestor de
arranque de otro sistema operativo. El MBR es un área especial del disco
duro que la BIOS de su ordenador carga automáticamente y el punto más
próximo en el que el gestor de arranque puede tomar el control de la
secuencia de arranque. Si lo instala en el MBR, al arrancar su máquina,
GRUB presentará un indicador de comandos de arranque. Podrá entonces
iniciar Red Hat Linux o cualquier otro sistema operativo que le haya indicado
al gestor de arranque.
● El primer sector de la partición raíz Se recomienda si está utilizando otro

gestor de arranque en su sistema. En este caso, el otro gestor de arranque
tendrá el control en un primer momento. Podrá configurar ese gestor de
arranque para que inicie GRUB, que iniciará a su vez Red Hat Linux.

El archivo anaconda-ks.cfg
El programa de instalación de Red Hat Linux también crea un archivo kickstart de

muestra basado en las opciones que seleccionó durante la instalación. Se escribe
al archivo /root/anaconda-ks.cfg. Debería ser capaz de modificarlo en cualquier
editor de texto o procesador de texto que pueda guardar archivos como texto
ASCII. También podrá usar la herramienta system-config-kickstart para realizar
modificaciones al archivo desde la GUI.

2
Administración del sistema de archivos

El sistema de ficheros
Una de los rasgos más importantes de Linux es su soporte para diferentes

sistemas de ficheros. Ésto lo hace muy flexible y bien capacitado para coexistir con
muchos otros sistemas operativos. Linux soporta los sistemas de ficheros; ext2,
ext3, minix, umsdos, msdos, vfat, proc, smb, ncp, iso9660, sysv, hpfs, affs and ufs,
ntfs, jfs, ReiserFS entre otros.
Un importante desarrollo tuvo lugar cuando se añadió en sistema de ficheros EXT

en Linux. El sistema de ficheros real se separó del sistema operativo y servicios del
sistema a favor de un interfaz conocido como el sistema de Ficheros Virtual, o VFS.
VFS permite a Linux soportar muchos, incluso muy diferentes, sistemas de

ficheros, cada uno presentando un interfaz software común al VFS. Todos los
detalles del sistema de ficheros de Linux son traducidos mediante software de
forma que todo el sistema de ficheros parece idéntico al resto del kernel de Linux y
a los programas que se ejecutan en el sistema. La capa del sistema de Ficheros
Virtual de Linux permite al usuario montar de forma transparente diferentes
sistemas de ficheros al mismo tiempo.
El Second Extended File system (EXT2)
El sistema de ficheros EXT2, como muchos sistemas de ficheros, se construye con

la premisa de que los datos contenidos en los ficheros se guarden en bloques de
datos.
Estos bloques de datos son todos de la misma longitud y, si bien esa longitud
puede variar entre diferentes sistemas de ficheros EXT2 el tamaño de los bloques
de un sistema de ficheros EXT2 en particular se decide cuando se crea (usando
mke2fs).
El tamaño de cada fichero se redondea hasta un numero entero de bloques. Si el

tamaño de bloque es 1024 bytes, entonces un fichero de 1025 bytes ocupará dos
bloques de 1024 bytes. Desafortunadamente esto significa que por media se
desperdicia un bloque por fichero.
No todos los bloques del sistema de ficheros contienen datos, algunos deben
usarse para mantener la información que describe la estructura del sistema de
ficheros.
EXT2 define la topologia del sistema de ficheros describiendo cada fichero del
sistema con una estructura de datos inodo. Un inodo describe que bloques ocupan
los datos de un fichero y también los permisos de acceso del fichero, las horas de

modificación del fichero y el tipo del fichero. Cada fichero en el sistema de ficheros
EXT2 se describe por un único inodo y cada inodo tiene un único número que lo
identifica. Los inodos del sistema de ficheros se almacenan juntos en tablas de
inodos. Los directorios EXT2 son simplemente ficheros especiales (ellos mismos
descritos por inodos) que contienen punteros a los inodos de sus entradas de
directorio.
En la figura de abajo se presenta la organización del sistema de archivos EXT2:
El sistema de ficheros EXT2 divide las particiones lógicas que ocupa en Grupos de
Bloque (Block Groups). Cada grupo duplica información crítica para la integridad
del sistema de ficheros ya sea valiéndose de ficheros y directorios como de
bloques de información y datos. Esta duplicación es necesaria por si ocurriera un
desastre y el sistema de ficheros necesitara recuperarse.
El inodo EXT2
En el sistema de ficheros EXT2, el inodo es el bloque de construcción básico; cada

fichero y directorio del sistema de ficheros es descrito por un y sólo un inodo. Los

inodos EXT2 para cada Grupo de Bloque se almacenan juntos en la table de

inodos con un mapa de bits que permite al sistema seguir la pista de inodos
reservados y libres.
El inodo proporciona la siguiente información del archivo:
● Modo Esto mantiene dos partes de información; qué inodo describe y los
permisos que tienen los usuarios. Para EXT2, un inodo puede describir un
ficheros, directorio, enlace simbólico, dispositivo de bloque, dispositivo de
caracter o FIFO.
● Información de propietario Los identificadores de usuario y grupo de los

dueños de este fichero o directorio. Esto permite al sistema de ficheros
aplicar correctamente el tipo de acceso,
● Tamaño El tamaño en del fichero en bytes,
● Marcas de tiempo La hora en la que el inodo fue creado y la última hora en

que se modificó,
● Bloques de datos Punteros a los bloques que contienen los datos que este
inodo describe. Los doce primeros son punteros a los bloques físicos que
contienen los datos descritos por este inodo y los tres últimos punteros
contienen más y más niveles de indirección. Por ejemplo, el puntero de
doble indirección apunta a un bloque de punteros que apuntan a bloques de
punteros que apuntan a bloques de datos. Esto significa que ficheros
menores o iguales a doce bloques de datos en longitud son más fácilmente
accedidos que ficheros más grandes. Si el archivo ocupa más de doce
bloques de datos, se utilizan los punteros indirectos para permitir referenciar
a más bloques de datos que conforman el archivo.
El Superbloque
El Superbloque contiene una descripción del tamaño y forma base del sistema de
ficheros (Tipo de sistema de archivos). La información contenida permite al
administrador del sistema de ficheros usar y mantener el sistema de ficheros.
Normalmente sólo se lee el Superbloque del Grupo de Bloque 0 cuando se monta

el sistema de ficheros pero cada Grupo de Bloque contiene una copia duplicada en
caso de que se corrompa sistema de ficheros. Entre otra información contiene el:
● Magic Number Esto permite al software de montaje comprobar que es

realmente el Superbloque para un sistema de ficheros EXT2.
● Revision Level Los niveles de revisión mayor y menor permiten al código de

montaje determinar si este sistema de ficheros soporta o no características
que sólo son disponibles para revisiones particulares del sistema de

ficheros. También hay campos de compatibilidad que ayudan al código de

montaje determinar que nuevas características se pueden usar con
seguridad en ese sistema de ficheros,
● Mount Count and Maximum Mount Count Juntos permiten al sistema

determinar si el sistema de ficheros fue comprobado correctamente. El
contador de montaje se incrementa cada vez que se monta el sistema de
ficheros y cuando es igual al contador máximo de montaje se ejecuta la
comprobación del sistema de archivos,
● Block Group Number El número del Grupo de Bloque que tiene la copia de
este Superbloque,
● Block Size El tamaño de bloque para este sistema deficheros en bytes, por
ejemplo 1024 bytes,
● Blocks per Group El número de bloques en un grupo. Como el tamaño de

bloque éste se fija cuando se crea el sitema de ficheros,
● Free Blocks EL número de bloques libres en el sistema de ficheros,
● Free Inodes El número de Inodos libres en el sistema de ficheros,
● First Inode Este es el número de inodo del primer inodo en el sistema de

ficheros. El primer inodo en un sistema de ficheros EXT2 raíz seria la
entrada directorio para el directorio '/'.
El desciptor de grupo
Cada Grupo de Bloque tiene una estructura de datos que lo describe. Como el
Superbloque, todos los descriptores de grupo para todos los Grupos de Bloque se
duplican en cada Grupo de Bloque en caso de corrupción del sistema de fichero.
Cada Descriptor de Grupo contiene la siguiente información:
● Blocks Bitmap El número del bloque que contiene el mapa de bits de

bloques reservados para este Grupo de Bloque. Se usa durante la reseva y
liberación de bloques,
● Inode Bitmap El número del bloque que contiene el mapa de bits de inodos
reservados para este Grupo de Bloques. Se usa durante la reserva y
liberación de inodos,
● Inode Table El número del bloque inicial para la tabla de inodos de este
Grupo de Bloque. Cada tabla de inodos contiene un contador de inodos y
bloques libres.

El sistema de archivos EXT3
Básicamente, el sistema de archivos ext3 es una versión mejorada de ext2. Las

mejoras introducidas proporcionan las siguientes ventajas:
● Disponibilidad Tras un corte eléctrico o una caída inesperada del sistema

(también se denomina cierre no limpio del sistema), se debe comprobar con
el programa e2fsck cada sistema de archivos ext2 montado en la máquina
para ver si es consistente. El proceso de comprobación lleva mucho tiempo
y puede prolongar el tiempo de arranque del sistema de un modo
significativo, especialmente si hay grandes volúmenes que contienen un
elevado número de archivos. Durante este proceso, no se puede acceder a
los datos de los volúmenes.
Con la característica journaling del sistema de archivos ext3 ya no es

necesario realizar este tipo de comprobación en el sistema de archivos
después de un cierre no limpio del sistema. En el sistema ext3, únicamente
se realiza una comprobación de consistencia en los casos puntuales en los
que se producen determinados errores de hardware, como, por ejemplo,
fallos en el disco duro. El tiempo empleado para recuperar un sistema de
archivos ext3 tras un cierre no limpio del sistema no depende del tamaño del
sistema de archivos ni del número de archivos, sino del tamaño del journal
(diario), utilizado para mantener la consistencia en el sistema. Por defecto, la
recuperación del tamaño del "journal" tarda alrededor de un segundo, según
la velocidad del hardware.
● Integridad de los datos El sistema de archivos ext3 proporciona una

integridad superior de los datos si se produce un cierre no limpio del
sistema. El sistema de archivos ext3 le permite seleccionar el tipo y el nivel
de protección de los datos. Por defecto, Red Hat Linux configura los
volúmenes ext3 para que el nivel de consistencia de los datos sea elevado
en relación con el estado del sistema de archivos.
● Velocidad El sistema de archivos ext3, aparte de permitir escribir datos más

de una vez, en la mayoría de los casos tiene un rendimiento superior al que
proporciona ext2 porque los "journals" de ext3 optimizan el movimiento de
los cabezales de los discos duros. Se pueden seleccionar tres modos de
journaling para optimizar la velocidad, pero, como contrapartida, la integridad
de los datos se verá afectada.
● Fácil transición La migración de ext2 a ext3 es muy sencilla y se pueden

aprovechar las ventajas de un sólido sistema de archivos con journaling sin
tener que volver a dar formato al sistema, simplemente con el comando
tune2fs.

Gestión de particiones
Un disco puede dividirse en diferentes particiones. Se puede acceder a cada

partición como si fuera un disco separado. Además cada partición tiene un tipo que
se usa para indicar como esta almacenada la información en la partición.
En el primer sector del disco está el registro de arranque maestro junto a la tabla de
particiones. El registro de arranque (como su nombre indica) se usa para arrancar
el sistema. La tabla de particiones contiene información acerca del lugar y el
tamaño de cada partición. Hay tres clases de particiones:
● Primarias: Las más usadas, debido al límite del tamaño de la tabla de

particiones, sólo pueden tenerse hasta cuatro particiones primarias en un
disco.
● Extendidas: Una partición extendida no tiene datos ella misma; en su lugar,

actúa como "soporte" de particiones lógicas; solo puede tenerse una
partición extendida por disco y deberá ocupar todo el espacio restante
disponible en el disco.
● Unidades Lógicas: Se puede crear cualquier número de particiones lógicas

de un tamaño inferior o igual a la partición extendida.
Cantidad máxima de particiones
Un disco IDE puede tener como máximo 63 particiones, Un disco SCSI puede tener
como máximo 15 particiones.
Numeración de particiones
Cada partición en Linux es representada por un número. Cada partición primaria y

extendida se numera consecutivamente a partir del número uno. Las unidades
lógicas siempre comienzan a enumerarse consecutivamente desde el número
cinco. Es decir:
● <dispositivo>1 Es la primera partición primaria en dispositivo.
● <dispositivo>2 Es la segunda partición primaria o la partición extendida de

dispositivo.
● <dispositivo>3 Es la tercera partición primaria o la partición extendida de

dispositivo.
● <dispositivo>4 Es la cuarta partición primaria o la partición extendida de

dispositivo.

● <dispositivo>5 Es la primera unidad lógica en dispositivo. El número de

partición es independientemente de la cantidad de particiones primarias que
se hayan creado. La primera unidad lógica siempre tendrá como número de
partición 5.
● <dispositivo>6 Es la segunda unidad lógica en dispositivo.
Por ejemplo, si usted crea una partición primaria y una extendida con dos unidades
lógicas tendría las particiones 1, 2, 5 y 6 respectivamente.
Usando fdisk
Esta es la herramienta tradicional de partición de disco de Linux. Este comando

permite configurar las particiones de un disco por medio de la línea de comandos.
Existen opciones que deben ser conocidas a modo de operar el comando fdisk. La
sintaxis es la siguiente:
fdisk [-l] <dispositivo>
La opción -l indica a fdisk que simplemente muestre la tabla de particiones del

dispositivo.
Una vez iniciado fdisk, puede utilizar los siguientes comandos:
Comando Descripción
m Manual - Muestra la ayuda.
p Print - Muestra la tabla de particiones actual.
n New - Crear una nueva partición. Primero le solicitará el número de
partición, luego el cilindro de inicio y final, el cilindro de inicio es
recomendado que acepte el propuesto y el cilindro final puede
especificar de la forma +(N)M, lo cual indica al comando fdisk que
cree una partición de N MB.
d Delete - Borrar una partición. Le solicitará el número de la partición
que desea borrar.
t Toogle – Cambia el tipo de partición. Deberá realizar este
procedimiento por ejemplo para indicar que la partición creada será
de tipo swap.
w Write - Guarda los cambios en la tabla de particiones de disco.
q Quit - Sale sin guardar los cambios en la tabla de particiones del
disco.
a Active - Activa o desactiva una partición para el arranque. La
partición activa es aquella que contiene el cargador de arranque. Si

Comando Descripción
el cargador de arranque está en el MBR, la partición activa será la

primera.
Ejemplo:
# fdisk /dev/sda
Command (m for help): p
Disk /dev/sda: 255 heads, 63 sectors, 784 cylinders
Units = cylinders of 16065 * 512 bytes
Device Boot Begin Start End Blocks Id System
/dev/sda1 * 1 1 26 208813+ 83 Linux native
/dev/sda2 27 27 784 6088635 5 Extended
/dev/sda5 27 27 645 4972086 83 Linux native
/dev/sda6 646 646 776 1052226 83 Linux native
/dev/sda7 777 777 784 64228+ 82 Linux swap
Command (m for help): q
Creación del sistema de archivos
Una vez creada la partición se debe crear el sistema de archivos en ella, para ello
use el comando mkfs. La sintaxis del comando es como sigue:
mkfs -t tipo [opciones] dispositivo
En la actualidad mkfs es un front end para los varios tipos de creadores de

sistemas de archivos (mkfs.tipofs).
Ejemplo: Para crear un sistema de archivos en la primera partición del primer disco
scsi ejecute el comando:
# mkfs -t ext3 /dev/sda1
Ajustando parámetros del sistema de archivos ext2/ext3
El comando tune2fs es usado para modificar parámetros del sistema de archivos

ext2/ext3. La sintaxis es la siguiente:
tune2fs [opciones] filesystem
Las opciones mas comunes para el comando tune2fs son:
Opción Descripción
-c Ajusta el contador de montaje máximo entre verificaciones del

sistema de archivos. Si es 0 se deshabilita esta opción.

-i Ajusta el intervalo de tiempo entre verificaciones, por defecto cada 6
meses se realizará una verificación del sistema de archivos al
momento de montado.
-j Agrega un diario (journal) convirtiendo un sistema de archivos ext2
en ext3.
-L Establece una etiqueta para el volúmen.
-m Especifica el porcentaje de espacio reservado en el sistema de
archivos para el usuario root. Este espacio permite que el sistema
de archivos se llene por completo y el usuario root pueda realizar
tareas de recuperación. Por defecto 5 %.
Ejemplo:
Para migrar un filesystem de tipo ext2 a ext3, sin destruir los datos, ejecute el
siguiente comando:
# tune2fs -j /dev/sda1
# tune2fs -c0 -i0 -m0 /dev/sda1
Para mostrar los parámetros actuales del sistema de archivos utilice el comando:
dumpe2fs [-h] filesystem
Montado de sistemas de archivos
Como se explicó anteriormente las particiones de los discos en Linux se montan en

directorios como /, /home y /usr. El sistema tiene un fichero llamado /etc/fstab en el
cual se especifican dónde y en que forma se montan los diferentes dispositivos.
Cada línea en este fichero describe un dispositivo, indicando los siguientes
aspectos para cada uno:
● Nombre del dispositivo o etiqueta: Ejemplos: /dev/hda1, /dev/sdc1,

/dev/fd0, LABEL=/home, LABEL=/cursos, etc.
● Directorio donde se monta: Ejemplos: /, /mnt/floppy, /tmp, etc.
● Sistema de ficheros: Ejemplos: ext3, vfat, nfs, swap, iso9660, auto, etc.
● Opciones de montaje: Ejemplos: ro, rw, exec, auto, user, etc.
● Dos valores númericos: el primero toma los valores 0 ó 1 indicando si al

dispositivo se le hará dump o no, esta opción es obsoleta. El segundo

número expresa la prioridad que tiene el dispositivo cuando se chequea la
integridad del file system durante el inicio del sistema.
Las opciones de montaje son numerosas. Las más usadas se listan a continuación:
auto Indica que el dispositivo se monta siempre que se inicie el sistema.
La opuesta es noauto.
rw Indica que el dispositivo se monta con permisos de lectura y
escritura.
ro Indica que el dispositivo se monta con permisos de lectura
solamente.
owner Indica que el primer usuario distinto de root conectado al sistema
localmente tiene derechos a montar y desmontar el dispositivo (se
adueña de este).
user Indica que cualquier usuario puede montar y solo el mismo usuario
podrá desmontar el dispositivo. La opción opuesta es nouser.
users Indica que cualquier usuario puede montar y cualquiera también,
puede desmontar el dispositivo.
suid Indica que el permiso “s” tenga efecto para los ejecutables presentes
en el dispositivo. La opción opuesta es nosuid.
exec Indica que los binarios ejecutables almacenados en el dispositivo se
pueden ejecutar. La opción opuesta es noexec.
async Expresa que todas las operaciones de entrada y salida se hacen de
forma asíncrona, o sea, no necesariamente en el momento en que
se invocan. La opción opuesta es sync.
dev Indica que se interprete como tal a los dispositivos especiales de
bloques y de caracteres presentes en el dispositivo. La opción
opuesta es nodev.
defaults es una opción equivalente a la unión de rw, suid, dev, exec, auto,
nouser y async.
Actualmente para cada dispositivo con sistema de ficheros ext3 en lugar de

especificar su nombre en el fichero fstab se puede indicar una etiqueta o
identificador asociado. La forma utilizada es LABEL=<etiqueta> o UUID=<uuid>. Esta
posibilidad hace más robusta la configuración ante la realización de cambios en los
discos duros ya sea porque se incluyan nuevos o se reordenen los existentes. Para
ver o cambiar la etiqueta de un dispositivo se puede emplear el comando e2label.
Ejemplos de líneas en el fichero /etc/fstab son:

LABEL=/ / ext2 defaults 1 1

/dev/sda7 /home ext3 defaults 1 2
/dev/cdrom /media/cdrom iso9660 noauto,owner,ro 0 0
/dev/fd0 /media/floppy auto noauto,owner 0 0
/dev/sda2 swap swap defaults 0 0
/dev/sdc1 /d0 ext3 ro,noexec,owner,noauto 1 0
Para montar y desmontar los dispositivos se emplean los comandos mount y umount
respectivamente. Estos mantienen una lista de los dispositivos montados en el
fichero /etc/mtab.
Sintaxis:
mount [opciones] [dispositivo] [punto_montaje]
umount [opciones] <punto_montaje>|<dispositivo>
Algunas opciones:
-a En el caso de mount monta todos los dispositivos que tienen la
opción auto en el fichero fstab, y para umount desmonta todo lo que
está en el fichero /etc/mtab.
-t <tipo> Indica el tipo de sistema de archivos a montar.
-o <opciones> Especifica las opciones de montaje (separadas por comas).
Cuando se especifican en el fichero fstab las características del montaje de un

dispositivo, para montarlo no es necesario indicarlo todo, basta con poner el
nombre del dispositivo o el directorio donde se monta por defecto.
Ejemplos:
Monta todos los dispositivos con sistemas de archivos ext3 y con la opción auto en
el fichero /etc/fstab
# mount -a -t ext2
Monta un pen drive en el directorio /media/usbdisk
# mount /dev/sdb1 /media/usbdisk
Monta el cdrom. Toma las especificaciones del fichero /etc/fstab
# mount /dev/cdrom
O
# mount /media/cdrom

Desmonta todo los dispositivos con sistema de archivos NFS especificados en

/etc/mtab
# umount -a -t nfs
Desmonta el cdrom
# umount /media/cdrom
Siempre que un dispositivo esté siendo utilizado por el sistema no se podrá

desmontar. Este emitirá un mensaje de error como en el siguiente ejemplo:
umount: /media/cdrom: device is busy
Un dispositivo puede estar ocupado por el simple hecho de tener posicionado un

shell en el directorio donde se montó, haber lanzado un ejecutable en segundo
plano desde ese directorio, o haber montado otro dispositivo en un subdirectorio del
mismo. Para lograr el objetivo será necesario eliminar todos estos casos.
Ejemplo de la adición de un disco con sistema de archivos ext3
1. Particionar el disco, en este ejemplo se crearán una partición primaria de 2GB,

una partición extendida con 2 unidades lógicas de 1GB.
# fdisk /dev/sdb
El número de cilindros para este disco está establecido en 1940.

No hay nada malo en ello, pero es mayor que 1024, y en algunos casos
podría causar problemas con:
1) software que funciona en el inicio (p.ej. versiones antiguas de LILO)
2) software de arranque o particionamiento de otros sistemas operativos
(p.ej. FDISK de DOS, FDISK de OS/2)
Orden (m para obtener ayuda): p
Disco /dev/sdb: 15.0 GB, 15020457984 bytes

240 cabezas, 63 sectores/pista, 1940 cilindros
Unidades = cilindros de 15120 * 512 = 7741440 bytes
Disposit. Inicio Principio Fin Bloques Id Sistema

/dev/sdb1 1 555 4195768+ b Win95 FAT32
Orden (m para obtener ayuda): d

Se ha seleccionado la partición 1


Orden (m para obtener ayuda): n

Acción de la orden
e Partición extendida
p Partición primaria (1-4)
p
Número de partición (1-4): 1
Primer cilindro (1-1940, valor predeterminado 1): [ENTER]
Último cilindro o +tamaño o +tamañoM o +tamañoK (1-1940, valor predeterminado
1940): +2048M

Acción de la orden
e Partición extendida
e
Número de partición (1-4): 2
1940): [ENTER]


/dev/sdb1 1 266 2010928+ 83 Linux
/dev/sdb2 267 1940 12655440 5 Extendida

Acción de la orden
l Partición lógica (5 o superior)
l
1940): +1024M

Acción de la orden
l Partición lógica (5 o superior)
l
1940): +1024M


/dev/sdb1 1 266 2010928+ 83 Linux
/dev/sdb2 267 1940 12655440 5 Extendida
/dev/sdb5 267 399 1005448+ 83 Linux
/dev/sdb6 400 532 1005448+ 83 Linux
Orden (m para obtener ayuda): w

¡Se ha modificado la tabla de particiones!
Llamando a ioctl() para volver a leer la tabla de particiones.

Se están sincronizando los discos.

2. Crear el sistema de archivos.

# mkfs -t ext3 /dev/sdb1
mke2fs 1.34 (25-Jul-2003)
Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
251392 inodes, 502732 blocks
25136 blocks (5.00%) reserved for the super user
First data block=0
16 block groups
32768 blocks per group, 32768 fragments per group
15712 inodes per group
Superblock backups stored on blocks:
32768, 98304, 163840, 229376, 294912
Writing inode tables: done

Creating journal (8192 blocks): done
Writing superblocks and filesystem accounting information: done
This filesystem will be automatically checked every 32 mounts or

180 days, whichever comes first. Use tune2fs -c or -i to override.
Repita el comando para cada una de las particiones primarias o unidades lógicas
de tipo Linux (83) creadas.
3. Ajustar los parámetros para el sistema de archivos creado.

# tune2fs -c0 -i0 -m0 /dev/sdb1
tune2fs 1.34 (25-Jul-2003)
Setting maximal mount count to -1
Setting interval between check 0 seconds
Setting reserved blocks percentage to 0 (0 blocks)
Repita el comando para cada uno de los sistemas de archivos ext3 creados.
6. Creamos los puntos de montaje para cada sistema de archivos.

# mkdir /d0
# mkdir /d1
.
.
.
Repita el comando para cada una de los sistemas de archivos creados. Seleccione
el nombre que desee para el directorio el cual será el punto de montaje. No es
requisito que el directorio se encuentre en la raíz del sistema.
7. Editamos el archivo /etc/fstab para el montado al inicio de los sistemas de

archivos.
# vi /etc/fstab
/dev/hda1 /d0 ext3 defaults 0 0

/dev/hda2 /d1 ext3 defaults 0 0
.
.
.

8. Montamos los sistemas de archivos.

# mount /d0
# mount /d1
.
.
.
Verificación y reparación del sistema de archivos ext2/ext3
El comando fsck permite hacer una verificación y reparación del sistema de

archivos ext2/ext3. Si el sistema de archivos es ext3, fsck normalmente aplicará el
journal y terminará.
El comando fsck verificará que:
● Que todos los bloques sean referenciados en al menos una lista, nunguno
se encuentre duplicado en una lista o sea referenciado por más de una lista.
● Que un inodo utilizado tenga una entrada en un directorio, y que los

directorios no referencien a inodos libres.
● Que el tamaño del archivo y la cantidad de bloques que ocupa concuerden.
El comando fsck no realiza una verificación de la superficie del disco duro, es decir,
no buscará bloques defectuosos que no puedan ser leídos o escritos. Sin embargo,
puede instruirse al comando fsck que utilice el comando badblocks para actualizar la
tabla de bloques dañados con la opción -c. Nunca es requerido ejecutar badblocks
sobre discos SCSI.
La sintaxis del comando fsck es la siguiente:

fsck [opciones] [filesystem]
Entre las opciones más comunes se encuentran:
-s Serializar operaciones. Es útil para cuando se realizan
verificaciones múltiples.
-A ntenta verificar todos los sistemas de archivos definidos en el
/etc/fstab.
-C Despliega una barra de progreso para aquellos sistemas de
archivos que están siendo verificados.
-y Responder Si a todas las preguntas.

Sólo el usuario root puede ejecutar el comando fsck y debe ser corrido sobre
sistemas de archivos que no estén montados, de lo contrario, puede provocar
corrupción de datos. Para verificar el sistema de archivos root “/”, deberá montarlo
como sólo lectura.
El fsck devuelve los siguientes códigos de salida (exit code):
Código Descripción
0 Sin errores
1 Errores corregidos
2 El sistema debería ser reiniciado
4 Errores de sistemas de archivos no corregidos
8 Error operacional
16 Error de sintaxis
32 Cancelado por petición del usuario
128 Error de bibliotecas compartidas
Gestión del espacio Swap
El Espacio swap en Linux es usado cuando la cantidad de memoria física (RAM)

está llena. Si el sistema necesita más recursos de memoria y la memoria física está
llena, las páginas inactivas de la memoria se mueven al espacio swap. Mientras
que el espacio swap puede ser de ayuda para las máquinas con poca memoria
RAM, no debería considerarse como algo que pueda sustituir a más RAM. El
espacio Swap se encuentra en discos duros, que tienen un tiempo de acceso más
lento que la memoria física.
El espacio Swap puede ser una partición swap dedicada (recomendable), un

archivo swap o una combinación de particiones y archivos swap.
Añadir el espacio Swap
A veces es necesario añadir más espacio swap después de la instalación. Por

ejemplo, puede actualizar la cantidad de RAM en su sistema de 1 GB a 2 GB, pero
hay tan sólo 1 GB de espacio swap. Sería conveniente aumentar la cantidad de
espacio swap hasta 2 GB sobre todo si lleva a cabo operaciones de uso intensivo
de memoria o si ejecuta aplicaciones que requieran gran cantidad de memoria.
Tiene dos opciones: añadir una partición swap o un archivo swap. Se recomienda

que añada una partición swap, pero a veces no resulta fácil si no cuenta con
espacio libre disponible.
Para añadir una partición swap ( asumiendo que /dev/sdb2 es la partición que
quiere agregar):
1. El disco duro no puede estar en uso (no puede tener particiones montadas, y no
se puede tener activado el espacio swap)
2. Cree la partición swap usando fdisk. Ejecute el comando:

# fdisk /dev/sdb2
Cree la partición (n), cambie el tipo de sistema de archivos a linux swap (t) ID 82
y salga guardando las modificaciones (w)
3. Ahora que tiene la partición swap, use el comando mkswap para configurar la
partición swap. En el indicador de comandos shell como root, escriba lo siguiente:
# mkswap /dev/sdb2
4. Para activar la partición swap inmediatamente, escriba el comando siguiente:

# swapon /dev/sdb2
5. Para activarlo cuando se arranca, edite /etc/fstab para incluir:
/dev/sdb2 swap swap defaults 0 0
La próxima vez que se arranque el sistema, activará la nueva partición swap.
6. Después de añadir la nueva partición swap y de haberla activado, asegúrese de

que está activa visualizando el resultado del comando cat /proc/swaps o free.
Para añadir un archivo swap:
1. Determine el tamaño del nuevo archivo swap y multiplique por 1024 para
determinar el tamaño de bloque.
2. En el intérprete de comandos, como root, escriba el siguiente comando con

count lo que equivale al tamaño de bloque deseado:
# dd if=/dev/zero of=/d0/swapfile bs=1024k count=1024
3. Configure el archivo swap con el comando:

# mkswap /d0/swapfile
4. Para activar el archivo swap inmediatamente pero no automáticamente cuando

se arranca:

# swapon /d0/swapfile
5. Para activarlo cuando se arranca, edite /etc/fstab para incluir:
/d0/swapfile swap swap defaults 0 0
La próxima vez que se arranque el sistema, se activará el nuevo archivo swap.
6. Después de haber añadido el nuevo archivo swap y de haberlo activado,

asegúrese de que está activado visualizando el resultado del comando cat
/proc/swaps o free.
Utilización de autofs
Autofs controla la operación de los demonios automount, normalmente es invocado

al inicio.
Autofs consultará el archivo de configuración /etc/auto.master para encontrar

puntos de montaje del sistema. El auto.master define los puntos de montaje y
apunta a otro archivo describiendo los sistemas de archivos a ser montados en ese
punto de montaje.
El formato del archivo /etc/auto.master es el siguiente:
/punto_montaje mapa opciones
El primer campo es el punto de montaje a ser monitoreado, el segundo campo es el

archivo mapa a consultar para este punto de montaje, y el tercer campo especifica
las opciones de montaje para todos los sistemas de archivos en ese punto de
montaje.
Ejemplo del archivo /etc/auto.master:
# /misc /etc/auto.misc --timeout=60
El directorio misc será monitoreado y se montarán automáticamente los sistemas de

archivos especificados en el archivo mapa /etc/auto.misc y se desmontarán luego
de sesenta segundos.
El formato del archivo mapa es el siguiente:

clave [-opciones] ubicación
Campo Descripción
Clave Subdirectorio dentro del directorio especificado en /etc/auto.master

Campo Descripción
que actuarán como punto de montaje para el sistema de archivos

especificado.
Opciones Opciones de montado del sistema de archivos.
Ubicación De dónde los sistemas de archivos serán montados.
Ejemplo del archivo mapa /etc/auto.misc
cdrom -fstype=iso9660,ro :/dev/cdrom

usbdisk -fstype=auto :/dev/fd0
De la configuración de los archivos /etc/auto.master y /etc/auto.misc obtenemos

que el directorio /misc será monitoreado. Si se realiza una solicitud al directorio
/misc/cdrom se montará automáticamente el dispositivo /dev/cdrom como sólo lectura
en ese directorio y se desmontará luego de sesenta segundos. Si se realiza una
solicitud al directorio /misc/usbdisk se montará automáticamente el dispositivo
/dev/sdb1 en ese directorio.

3
Proceso de arranque, inicio y cierre del sistema

Una de las características más importantes y poderosas de Red Hat Linux es el

método abierto y configurable para el inicio y cierre del sistema operativo. Los
usuarios son libres de configurar muchos aspectos del proceso de arranque,
incluyendo qué programas se lanzarán al momento de arranque. De forma
parecida, el cierre del sistema finaliza los procesos de forma organizada y
configurable, aunque la personalización de este proceso casi nunca es necesaria.
Entender el funcionamiento del proceso de arranque y cierre no solo le permitirá

personalizar fácilmente Red Hat Linux, sino que también le facilitará resolver
problemas relacionados con el inicio y el cierre del sistema.
Proceso de arranque
A continuación obtendrá las etapas básicas del proceso de arranque para un

sistema x86:
● La BIOS del sistema comprueba y lanza la primera etapa del gestor de

arranque del MBR del disco duro primario.
● La primera etapa del gestor de arranque se autocarga en memoria y lanza la

segunda etapa del gestor de arranque desde la partición /boot/.
● La segunda etapa del gestor de arranque carga el kernel en memoria, lo cual

en su momento carga los módulos necesarios y monta la partición root para
sólo-lectura.
● El kernel transfiere el control del proceso de arranque al programa

/sbin/init.
● El programa /sbin/init carga todos los servicios y herramientas de espacio

del usuario y monta todas las particiones listadas en /etc/fstab.
● El usuario se presenta con un intérprete de comandos de registro para el

sistema Linux apenas arrancado.
Ya que la configuración del proceso de arranque es más común que la del proceso
de cierre, en el resto de la sección se discutirá el modo en el que el proceso de
arranque funciona y cómo se puede personalizar para satisfacer sus necesidades.
Vista detallada del proceso de arranque

El inicio del proceso de arranque varía dependiendo de la plataforma de hardware

usada. Sin embargo, una vez que se encuentra el kernel y se carga el sistema, el
proceso de arranque por defecto es idéntico a través de todas las arquitecturas.
Esta sección se basa en la arquitectura x86.
El BIOS
Cuando un ordenador x86 se carga, el procesador busca al final de la memoria del

sistema por Basic Input/Output System o el programa BIOS y lo ejecuta. El BIOS
controla no sólo el primer paso del proceso de arranque, sino que también
proporciona una interfaz de bajo nivel para dispositivos periféricos. Por este motivo
se escribe tan sólo en modo lectura, memoria permanente y está siempre
disponible para el uso.
Otras plataformas usan programas diferentes para ejecutar tareas a bajo nivel
equivalentes a aquellas del BIOS en el sistema x86. Por ejemplo, los ordenadores
basados en Itanium usan Interfaz de Firmware extensible (EFI) Shell.
Una vez que se haya cargado, la BIOS chequea los periféricos y localiza un
dispositivo con el que arrancar el sistema. Habitualmente, en primer lugar
comprueba cualquier disquete y unidades de CD-ROM presente por los medios de
arranque, y a continuación si esto falla, echa un vistazo a las unidades de disco
duro del sistema. El orden de las unidades necesario para arrancar puede ser
controlado con una configuración del BIOS. El BIOS carga en memoria cualquier
programa que resida en el primer sector de este dispositivo, llamado Master Boot
Record o MBR. La MBR sólo tiene 512 bytes de tamaño y contiene las
instrucciones de código de máquina para el arranque del equipo, llama un gestor
de arranque así como también la tabla de particiones. Una vez que el BIOS haya
encontrado y cargado el gestor de arranque en memoria, le deja el control del
proceso de arranque a éste.
El gestor de arranque
Esta sección revisa los gestores de arranque para la plataforma x86. Dependiendo
de la arquitectura del sistema, el proceso de arranque diferirá ligeramente.
Bajo Red Hat Linux están disponibles dos gestores de arranque: GRUB o ELILO
para plataformas Itanium.
Los gestores de arranque de Linux para la plataforma x86 se dividen en dos

etapas. La primera es un código binario de máquina pequeña en el MBR. Su única
función es la de localizar el gestor de arranque de la segunda etapa y cargar la
primera parte de éste en memoria.
GRUB es el gestor de arranque más nuevo y tiene la ventaja de ser capaz de leer
particiones ext2 y ext3 y cargar su archivo de configuración /boot/grub/grub.conf al

momento de arranque.
Una vez que el gestor de arranque de la segunda etapa está en memoria, presenta
al usuario con la pantalla inicial, gráfica de Red Hat Linux mostrando los diferentes
sistemas operativos o kernels que para los que ha sido configurado para arrancar.
En esta pantalla el usuario puede usar las flechas de dirección para escoger el
sistema operativo o kernel con el que desea arrancar y presione la tecla [Intro]. Si
no se presiona ninguna tecla, el gestor de arranque carga la selección
predeterminada luego de un período de tiempo de espera (también configurable).
Una vez que el gestor de arranque de la segunda etapa haya determinado qué
kernel arrancar, localizará el binario del kernel correspondiente en el directorio
/boot/. El kernel binario es llamado usando el siguiente formato /boot/vmlinuz-
<kernel-version> (donde <kernel-version> corresponde a la versión del kernel
especificada en las configuraciones del gestor de arranque).
El gestor de arranque luego coloca la imagen apropiada de initial RAM disk,

conocida como initrd, en la memoria. El initrd es usado por el kernel para cargar
controladores necesarios para arrancar el sistema. Esto es muy importante si
posee unidades de disco duro SCSI o si está usando el sistema de ficheros ext3.
Una vez que el kernel y la imagen initrd se cargan en memoria, el gestor de

arranque controla el proceso de arranque para el kernel.
Gestores de arranque para otras arquitecturas
Una vez que el kernel de Red Hat Linux arranca y pasa el proceso de arranque al
comando init, los mismos acontecimientos suceden en cada arquitectura
exactamente en el mismo modo. La única diferencia entre el proceso de arranque
de cada arquitectura está en la aplicación que se usa para encontrar y cargar el
kernel.
El kernel
Cuando el kernel se carga, inmediatamente se inicializa y configura la memoria del

ordenador y los diferentes hardware conectado al sistema, incluyendo
procesadores, subsistemas de entrada/salida y dispositivos de almacenamiento. A
continuación buscará la imagen initrd en una ubicación predeterminada en
memoria, la descomprimirá, la montará y cargará todos los controladores
necesarios. A continuación inicializa los dispositivos virtuales relacionados con el
sistema de ficheros, tal como LVM o software RAID antes de desmontar la imagen
del disco initrd y liberar toda la memoria que la imagen del disco ocupó
anteriormente.
El kernel luego crea un dispositivo root, monta la partición root como sólo lectura y
libera cualquier memoria no utilizada.

Llegados a este punto, el kernel está cargado en memoria y operativo. Sin

embargo, como no hay aplicaciones de usuario que permitan la entrada
significativa de datos al sistema, no se puede hacer mucho más.
Para configurar el entorno de usuario, el kernel inicia el programa /sbin/init.
Programa /sbin/init
El programa /sbin/init (también llamado init) coordina el resto del proceso de

arranque y configura el ambiente del usuario.
Cuando el comando init arranca, se vuelve el padre o abuelo de todos los

procesos que comienzan automáticamente en el sistema Red Hat Linux. Primero,
ejecuta el script /etc/rc.d/rc.sysinit, que establece la ruta a otros programas,
activa el swap, controla los sistemas de archivos y y se encarga de todo lo que el
sistema necesita tener hecho al momento de la inicialización.
El comando init luego ejecuta el script /etc/inittab, que describe cómo el sistema
debería configurarse en cada nivel de ejecución de SysV init. Entre otras cosas,
/etc/inittab configura el nivel de ejecución por defecto y establece que
/sbin/update debería de ejecutarse cuando se arranque un nivel de ejecución en
concreto.
A continuación, el comando init configura la librería de función de fuente,

/etc/rc.d/init.d/functions, para el sistema. Esto indica el modo en que empezar o
matar un programa y cómo determinar el PID del programa.
El programa init inicia todos los procesos de fondo buscando en el directorio

apropiado rc por el nivel de ejecución especificado por defecto en /etc/inittab.
Los directorios rc están numerados para corresponder al nivel de ejecución que
represente. Por ejemplo, /etc/rc.d/rc5.d/ es el directorio para el nivel de ejecución
5.
Cuando se arranca el nivel de ejecución 5, el programa init consulta el directorio

/etc/rc.d/rc5.d/ para determinar qué procesos iniciar o parar.
A continuación un ejemplo de listado del directorio /etc/rc.d/rc5.d/:
K05innd->../init.d/innd
K05saslauthd->../init.d/saslauthd
K10psacct->../init.d/psacct
.
.
.
S95atd->../init.d/atd
S97rhnsd->../init.d/rhnsd
S99local->../rc.local
S99mdmonitor->../init.d/mdmonitor

Como puede ver, ninguno de los scripts que inician y cierran los servicios están
localizados en el directorio /etc/rc.d/rc5.d/. Casi todos los ficheros en
/etc/rc.d/rc5.d/ son enlaces simbólicos apuntando a los scripts localizados en el
directorio /etc/rc.d/init.d/. Los enlaces simbólicos se usan en cada uno de los
directorios rc de manera que los niveles de ejecución puedan ser reconfigurados al
crear, modificar y eliminar los enlaces simbólicos sin que afecte a los scripts
actuales a los que se refiere.
El nombre de cada enlace simbólico inicia con K o S. Los enlaces K son procesos
eliminados en ese nivel de ejecución, mientras que aquellos que inician por S son
procesos iniciados.
El comando init en primer lugar detiene todos los enlaces simbólicos de K en el

directorio mediante la ejecución del comando /etc/rc.d/init.d/<command> stop, en el
que <command> es el proceso a matar. A continuación inicia todos los enlaces
simbólicos S al ejecutar /etc/rc.d/init.d/<command> start.
Cada uno de los enlaces simbólicos se numera para dictaminar el orden de inicio.
Puede cambiar el orden en el que los servicios inician o paran al cambiar el
número. Mientras más bajo es el número, más rápido se arrancará. Los enlaces
simbólicos con el mismo número se inician de modo alfabético.
Después que el comando init ha progresado a través del directorio adecuado rc

para el nivel de ejecución, el script /etc/inittab bifurca los procesos /sbin/mingetty
para cada consola virtual (intérpretes de comando de registro, login) ubicada para
el nivel de ejecución. Los niveles de ejecución del 2 al 5 obtienen todas las seis
consolas virtuales, mientras que el nivel de ejecución 1 (modo usuario único)
obtiene tan sólo uno y lo niveles de ejecución del 0 al 6 no obtienen ninguno. El
proceso /sbin/mingetty abre las rutas de la comunicación para los dispositivos tty,
establece sus modos, imprime el indicador de inicio de sesión, toma el nombre del
usuario, e inicia el proceso de inicio de sesión para el usuario.
En el nivel de ejecución 5, el /etc/inittab ejecuta un script llamado /etc/X11/prefdm.

El script ejecuta prefdm ejecuta su gestor de pantalla preferido para X gdm, kdm, o
xdm, dependiendo de los contenidos del archivo /etc/sysconfig/desktop.
En este punto, el sistema está operando en el nivel de ejecución nivel 5 y

mostrando la pantalla de inicio de sesión.
Ejecutar programas adicionales en el momento de arranque
El script /etc/rc.d/rc.local lo ejecuta el comando init en tiempo de arranque, o

cuando se cambien niveles de ejecución. El agregar comandos a este script es una
forma fácil de realizar tareas necesarias como arrancar servicios especiales o
inicializar dispositivos sin tener que escribir scripts complejos de inicialización en el
directorio /etc/rc.d/init.d/ y creando los enlaces simbólicos.

Uso de sysctl
El comando /sbin/sysctl es usado para visualizar, configurar y automatizar

configuraciones del kernel en el directorio /proc/sys/.
Para tener una vista rápida de todas las variables configurables en el directorio
/proc/sys/, escriba el comando /sbin/sysctl -a como root. Esto creará una lista
grande y exhaustiva, de la cual le mostramos una pequeña parte:
net.ipv4.route.min_delay = 2
kernel.sysrq = 0
kernel.sem = 250 32000 32 128
Esta es la misma información que verÌa si echara un vistazo a cada uno de los
archivos individualmente. La única diferencia es la localización del archivo. Por
ejemplo, el archivo /proc/sys/net/ipv4/route/min_delay está representado por
net.ipv4.route.min_delay, con las barras oblicuas del directorio sustituÌdas por
puntos y la porción asumida proc.sys.
El comando sysctl se puede usar en vez de echo para asignar valores a los
archivos en los que se puede escribir en el directorio /proc/sys/. Por ejemplo, en
vez de usar el comando:
# echo 1 > /proc/sys/kernel/sysrq
Utilice el comando sysctl equivalente como se muestra:
sysctl -w kernel.sysrq="1"
kernel.sysrq = 1
A pesar de que es muy útil durante las pruebas el poder rápidamente efectuar
configuraciones de valores simples en /proc/sys/, esto no funciona bien en un
ambiente de producción puesto que las configuraciones especiales en /proc/sys/
se pierden cuando se vuelve a arrancar el sistema. Para conservar las
configuraciones personalizadas, añadalas al archivo /etc/sysctl.conf.
Cada vez que el sistema arranque, el programa init ejecuta el script

/etc/rc.d/rc.sysinit. Este script contiene un comando para ejecutar sysctl
mediante el uso de /etc/sysctl.conf para determinar los valores pasados al kernel.
Cualquier valor añadido a /etc/sysctl.conf surtirá efecto cada vez que el sistema
arranque.
Niveles de ejecución de SysV Init
El sistema de niveles de ejecución SysV init provee de un proceso estándar para

controlar cuáles programas init lanza o detiene cuando se inicializa un nivel de

ejecución. SysV init fué escogido porque es más fácil de usar y más flexible que el
proceso tradicional init estilo BSD.
Los ficheros de configuración para SysV init están en el directorio /etc/rc.d/.

Dentro de este directorio, se encuentran los scripts rc, rc.local, rc.sysinit, y,
opcionalmente, los scripts rc.serial así como los siguientes directorios:
init.d/
rc0.d/
rc1.d/
rc2.d/
rc3.d/
rc4.d/
rc5.d/
rc6.d/
El directorio init.d/ contiene los scripts usados por el comando /sbin/init cuando
se controlan los servicios. Cada uno de los directorios numerados representa los
seis niveles de ejecución predeterminados configurados por defecto bajo Red Hat
Linux.
Niveles de ejecución
Los niveles de ejecución son un estado, o modo, definido por los servicios listados
en el SysV directorio /etc/rc.d/rc<x>.d/, donde <x> es el número de nivel de
ejecución.
La idea detrás de los niveles de ejecución de SysV init gira alrededor del hecho que
sistemas diferentes se pueden usar de formas diferentes. Por ejemplo, el servidor
corre de forma más eficiente sin tener que arrastrar recursos del sistema creados
por el sistema X. Otras veces, el administrador del sistema puede necesitar operar
el sistema en un nivel más bajo de ejecución para realizar tareas de diagnóstico,
como reparar corrupción del disco duro, cuando no es posible que ningún otro
usuario esté usando el sistema.
Las características de un nivel de ejecución dado determinan qué servicios son

detenidos o iniciados por init. Por ejemplo, el nivel de ejecución 1 (modo único
usuario) detiene cualquier servicio de red, mientras que el nivel 3 arranca estos
servicios. Asignando servicios específicos a ser detenidos o arrancados en un nivel
dado, init puede fácilmente cambiar el modo de la máquina sin que el usuario tenga
que manualmente arrancar o detener servicios.
Los siguientes niveles de ejecución están definidos por defecto para Red Hat Linux:
Nivel Descripción
0 Detener el sistema

Nivel Descripción
2 Sin usar (usuario-definible)

3 Modo texto multiusuario completo
4 Sin usar (usuario-definible)
5 Modo gráfico multiusuario completo (con una pantalla de inicio de
sesión basada en X)
6 Reiniciar
Generalmente, los usuarios utilizan Red Hat Linux al nivel de ejecución 3 o nivel de
ejecución 5 ambos modos multiusuario. Ya que los niveles de ejecución 2 y 4 no
son usados, los usuarios a veces personalizan estos niveles para cubrir
necesidades específicas.
El nivel de ejecución por defecto para el sistema está listado en /etc/inittab. Para
saber el nivel de ejecución por defecto de un sistema, busque por la línea similar a
la que se muestra abajo cerca de la parte superior de /etc/inittab:
id:5:initdefault:
El nivel de ejecución predeterminado en el ejemplo de arriba es cinco, como indica

el número después del punto y coma. Para cambiarlo, modifique /etc/inittab como
usuario root.
Es posible cambiar al nivel de ejecución por defecto al momento de arranque

modificando los argumentos pasados del gestor de arranque al kernel.
Utilidades de los niveles de ejecución
Una de las mejores formas de configurar los niveles de ejecución es usando

initscript utility. Estas herramientas están diseñadas para simplificar las tareas de
mantener archivos en la jerarquía del directorio SysV init y descargan a los
administradores de sistemas de tener que directamente manipular numerosos
enlaces simbólicos en los subdirectorios de /etc/rc.d/.
Red Hat Linux ofrece tres de tales utilidades:
● /sbin/chkconfig - La utilidad /sbin/chkconfig es una herramienta de línea de

comandos sencilla para mantener la jerarquía del directorio
/etc/rc.d/init.d.
● /sbin/ntsysv - La utilidad basada en ncurses /sbin/ntsysv provee de una

interfaz interactiva basada en texto, que muchos encuentran más fácil de
usar que chkconfig.

● Herramienta de configuración de servicios - El programa de interfaz

gráfica Herramienta de configuración de servicios system-onfig-services es
una utilidad flexible basada en GTK2 para la configuración de niveles de
ejecución.
Cierre del sistema
Para apagar Red Hat Linux, el usuario root puede ejecutar el comando
/sbin/shutdown. La página man de shutdown tiene una lista completa de opciones, pero
las dos más usadas son:
# /sbin/shutdown -h now
# /sbin/shutdown -r now
Después de apagar todo, la opción -h detendrá la máquina, y la opción -r la

reiniciará.
Los usuarios no root pueden usar los comandos reboot y halt para apagar el equipo
mientras se está en niveles de ejecución 1 hasta 5. Sin embargo, no todos los
sistemas operativos Linux soportan esta característica.
Si la computadora no se apaga, tenga cuidado de no apagar la computadora hasta

que aparezca un mensaje indicando que el sistema ha sido detenido.
Si no espera por este mensaje puede significar que no todas las particiones de
discos duros han sido desmontadas, y puede llevar a un sistema de archivos
corrupto.

4
Administración de usuarios
Usuarios y grupos
El control de los usuarios y grupos es un elemento clave en la administración de

sistemas de Red Hat Linux.
Los usuarios pueden ser gente real, es decir, cuentas ligadas a un usuario físico en
particular o cuentas que existen para ser usadas por aplicaciones específicas.
Los grupos son siempre expresiones lógicas de organización, reuniendo usuarios

para un propósito común. Los usuarios dentro de un mismo grupo pueden leer,
escribir o ejecutar archivos que pertenecen al grupo.
Cada usuario y grupo tiene un número de identificación único llamado user id (UID)
y un group id (GID).
Cuando se crea un archivo se asigna a un usuario y a un grupo. De la misma

manera se asignan los permisos de lectura, escritura y ejecución para el propietario
del archivo, para el grupo y para cualquier otro usuario en un host. El usuario y el
grupo de un archivo particular, así como los permisos en ese archivo, pueden ser
cambiados por un root o, en la mayoría de los casos, por el creador del archivo.
Una de las tareas más importantes de cualquier administrador del sistema, es la de

administrar adecuadamente usuarios y grupos, así como asignar y revocar
permisos.
Herramientas de administración de usuarios y grupos
La gestión de usuarios y grupos ha sido tradicionalmente tediosa, pero Red Hat

Linux posee algunas herramientas y convenciones que facilitan a los
administradores su gestión.
La forma más fácil de manejar usuarios y grupos es a través de la aplicación

gráfica Administrador de usuarios, system-config-users.
Las siguientes herramientas de línea de comandos también se pueden utilizar para

manejar usuarios y grupos:
● useradd, usermod y userdel — Métodos estándar de la industria para añadir,

eliminar y modificar cuentas de usuarios.
● groupadd, groupmod y groupdel — Métodos estándar de la industria para añadir,

eliminar y modificar grupos de usuarios.

● pwck, grpck— Herramientas para la verificación de contraseñas, grupo y

archivos shadow asociados.
● pwconv, pwunconv — Herramientas para la conversión a contraseñas shadow y

de vuelta a contraseñas estándar.
Configuración de usuarios desde la línea de comandos
Si prefiere las herramientas de línea de comandos o no tiene el sistema X Window

instalado, use este capítulo para configurar usuarios y grupos.
Añadir un usuario
Para añadir un usuario al sistema ejecute el comando useradd para crear una
cuenta de usuario bloqueada:
useradd <nombre_usuario>
Desbloquee la cuenta ejecutando el comando passwd para asignar una contraseña y

configurar el vencimiento de la misma:
passwd <nombre_usuario>
Las opciones de línea de comandos más comunes son:
-c comentario Comentario para el usuario
-d home-dir Directorio principal a ser usado en vez del directorio
predeterminado /home/nombredeusuario
-e fecha Fecha en que la cuenta será desactivada usando el formato de
fecha YYYY-MM-DD
-f días Número de días que pasarán después que la contraseña ha
caducado hasta que la cuenta se desactivará (Si se especifica 0, la
cuenta será desactivada inmediatamente después que la
contraseña expire. Si se especifica -1, la cuenta no se desactivará
después que la contraseña caduque.)
-g Nombre o número del grupo para el grupo predeterminado del
nombredegrupo
usuario (El grupo debe existir.)
-G Lista de nombres de los grupos adicionales (además del
listadegrupo
predeterminado), separados por comas, de los cuales el usuario es
miembro (Los grupos deben existir.)
-m Crea el directorio principal si no existe

-M No crea el directorio principal
-n No crea un grupo de usuario privado para el usuario
-r Crea una cuenta de sistema con un UID menor que 500 y dentro
del directorio principal.
-p contraseña La contraseña encriptada con crypt
-s Línea de comando de conexión del usuario, predeterminada a
/bin/bash
-u uid ID de usuario, el cual debe ser único y mayor que 499
Añadir un grupo
Para agregar un grupo al sistema, use el comando groupadd:
groupadd <nombre_grupo>
Las opciones de línea de comandos más comunes son:
-g gid ID para el grupo, el cual debe ser único y mayor que 499.
-r Crea un grupo de sistema con un GID menor que 500.
-f Sale con un error si el grupo ya existe. (El grupo no es alterado.) Si
se especifica -g y -f, pero el grupo ya existe, la opción -g es
ignorada.
Vencimiento de la contraseña
Para configurar el vencimiento de la contraseña para un usuario desde el intérprete

de comandos, use el comando chage, seguido de una opción:
-m días Especifica el número mínimo de días entre los cuales el usuario
debe cambiar su contraseña. Si el valor es 0, la contraseña no
caduca.
-M días Especifica el número máximo de días durante los cuales la
contraseña es válida. Cuando el número de días especificado por
esta opción más el número de días especificado con la opción -d es
menor que el día actual, el usuario debe cambiar su contraseña
antes de usar la cuenta.

-d días Especifica el número de días desde Enero 1, 1970 que la
contraseña fué cambiada.
-I días Especifica el número de días inactivos después de la expiración de
la contraseña antes de bloquear la cuenta. Si el valor es 0, la
cuenta no es bloqueada después que la contraseña caduca.
-E fecha Especifica la fecha en la cual la cuenta es bloqueada, en el formato
YYYY-MM-DD. También se puede usar el número de días
transcurridos desde Enero 1, 1970 en lugar de la fecha.
-W días Especifica el número de días antes de la fecha de expiración de la
contraseña para advertir al usuario.
Si el administrador del sistema desea que un usuario configure su contraseña la

primera vez que éste se conecte, la contraseña del usuario puede ser configurada
a que expire de inmediato, obligando al usuario a cambiarla inmediatamente
después de conectarse la primera vez.
El archivo /etc/passwd
El archivo /etc/passwd contiene la lista de usuarios en el sistema, una línea por

usuario. Es consultado cuando el usuario ingresa al sistema para determinar su
UID; en muchos casos, podría contener también la contraseña encriptada, aunque
la tendencia actual es retener la contraseña encriptada en otro archivo, /etc/shadow,
con permisos de acceso más restringidos. En este último caso, el proceso de login
consulta ambos archivos, /etc/passwd y /etc/shadow.
Los campos de /etc/passwd y /etc/shadow están separados por ":", al igual que la
mayoría de los archivos de configuración en UNIX.
Ejemplo de entradas en /etc/passwd:
root:x:0:0::/root:/bin/bash
bin:x:1:1:bin:/bin:
ftp:x:404:1::/home/ftp:/bin/bash
daemon:x:2:2:daemon:/sbin:
El archivo /etc/passwd contiene los siguientes campos, de izquierda a derecha:
● Nombre de login
● Contraseña encriptada
● Identificador del usuario (UID)
● Identificador de grupo primario (GID)

● Información de usuario (campo "GECOS") Se usa ahora, sin una sintaxis fija,
para contener información del usuario. El comando finger interpreta este
campo como una lista separada por comas conteniendo: 1) nombre en la
vida real, 2) edificio y número de oficina, 3) teléfono interno, 4) teléfono
domiciliario. El comando chfn permite al usuario cambiar su información
propia.
● El directorio HOME del usuario
● Shell o programa inicial.
El archivo /etc/group
El archivo /etc/group contiene los nombres de los grupos UNIX definidos en el

sistema y una lista de sus miembros. Hay una línea por cada grupo. Los campos
están separados por ":".
Ejemplo de entradas en /etc/group:
root::0:root
bin::1:root,bin,daemon
daemon::2:root,bin,daemon
sys::3:root,bin,adm
adm::4:root,adm,daemo
Cada línea contiene:
● Nombre del grupo: algunos sistemas piden 8 caracteres o menos.
● Contraseña encriptada: histórico, no se usa.
● Número GID: número único identificador del grupo.
● Lista de integrantes: nombres de usuarios de los integrantes del grupo

separados por comas, sin blancos.
Grupos de usuario privado
Red Hat Linux utiliza un esquema de grupo de usuario privado (UPG), lo que
hace más fácil de manejar los grupos de UNIX.
Se crea un UPG siempre que se añade un nuevo usuario al sistema. Un UPG tiene
el mismo nombre que el usuario para el cual se crea y ese usuario es el único
miembro de ese UPG.
Los UPGs hacen que sea más seguro configurar los privilegios por defecto para un

nuevo archivo o directorio lo que permite a ambos, tanto el usuario como al grupo
de ese usuario hacer modificaciones al archivo o directorio.
El parámetro que determina qué permisos son aplicados a un nuevo archivo o

directorio es llamado un umask y es configurado en el archivo /etc/bashrc.
Tradicionalmente, en sistemas UNIX el umask es configurado a 022, lo que sólo

permite al usuario que crea el archivo o directorio realizar modificaciones. Bajo este
esquema, todos los demás usuarios incluyendo miembros del grupo del creador no
tienen derecho a realizar ninguna modificación. Sin embargo, bajo el esquema
UPG, esta "protección de grupo" no es necesaria puesto que cada usuario tiene su
propio grupo privado.
Directorios de grupos
Muchas organizaciones de IT (del inglés Information Technologies) prefieren crear

un grupo para cada proyecto importante y luego asignar personas al grupo si estos
necesitan acceso a los archivos de ese proyecto. Usando este esquema tradicional,
el manejo de archivos ha sido difícil pues cuando alguien crea un archivo, este es
asociado con el grupo primario al cual pertenece. Cuando una persona individual
trabaja en múltiples proyectos, se hace difícil asociar los archivos correctos con el
grupo correcto. Usando el esquema UPG, sin embargo, los grupos son
automáticamente asignados a archivos creados dentro de un directorio con el bit
SGID configurado, lo que hace muy simple el manejo de proyectos de grupos que
comparten un directorio común.
Digamos, por ejemplo, que un grupo de personas trabajan con archivos en el

directorio /datos/contabilidad/. Algunas personas son de confianza como para
modificar el directorio, pero ciertamente no todos. Entonces primero cree un grupo
contab, como se muestra en el siguiente comando:
# /usr/sbin/groupadd contab
Para poder asociar los contenidos del directorio con el grupo contab, escriba:
# chown -R root.contab /datos/contabilidad/
Ahora es posible añadir los usuarios adecuados al grupo con el comando gpasswd:
# /usr/bin/gpasswd -a <nombre_usuario> contab
Permita a los usuarios crear archivos dentro del directorio y configure el bit SGID, el
cual asigna que todo lo que se cree en el directorio el mismo grupo del directorio
padre (contab). Use el comando siguiente:
# chmod 2775 /datos/contabilidad
En este punto, puesto que cada usuario tiene por defecto su umask en 002, todos los

miembros del grupo contab pueden crear y modificar archivos en el directorio

/datos/contabilidad/ sin que el administrador tenga que cambiar los permisos de
los archivos cada vez que un usuario escriba nuevos archivos.
Contraseñas Shadow
En entornos multiusuario es muy importante utilizar contraseñas shadow

(proporcionadas por el paquete shadow-utils). Haciendo esto se mejora la
seguridad de los archivos de autenticación del sistema. Por esta razón, el programa
de instalación de Red Hat Linux activa por defecto las contraseñas shadow.
Lo siguiente es una lista de las ventajas de las contraseñas shadow sobre el

método antiguo de almacenar contraseñas en los sistemas basados en UNIX.
● Mejora la seguridad del sistema al mover las contraseñas encriptadas desde

el archivo /etc/passwd que puede leer todo el mundo, a /etc/shadow, el cual
sólo puede ser leído por el usuario root.
● Almacena información sobre la vigencias de las contraseñas.
● Permite el uso del archivo /etc/login.defs para reforzar las políticas de

seguridad.
La mayoría de las utilidades proporcionadas por el paquete shadow-utils funcionan

adecuadamente sin importar si las contraseñas shadow están activadas o no. Sin
embargo, puesto que la información sobre la vigencia de las contraseñas es
almacenada exclusivamente en el archivo /etc/shadow, cualquier comando que cree
o modifique la información sobre la vigencia de las contraseñas, no funcionará.
Abajo se muestra una lista de los comandos que no funcionan a menos que se
activen las contraseñas shadow:
● chage
● gpasswd
● Las opciones /usr/sbin/usermod -e o -f
● Las opciones /usr/sbin/useradd -e o -f
El archivo /etc/shadow
El archivo /etc/shadow contiene una línea por usuario y solo es visible por root.
Provee además información relativa a cambio de contraseñas y expiración de la
cuenta.

Ejemplo de entradas en /etc/shadow:
root:1eklLr8RdBuao:10461:0:::::
bin:*:9797:0:::::
ftp:*:9797:0:::::
daemon:*:9797:0:::::
Contiene los siguientes campos:
● Nombre de login: el mismo nombre que en /etc/passwd;
● Contraseña encriptada: bajo las mismas condiciones que en /etc/passswd;

la contraseña encriptada es desplazada del /etc/passwd al /etc/shadow,
dejando en /etc/passwd una x en este campo.
● Fecha de úlimo cambio de contraseña: registra la fecha en que el usuario

cambió por última vez su contraseña.
● Mínima cantidad de días entre cambios de contraseña: una vez

cambiada una contraseña, el usuario no puede volver a cambiarla hasta que
haya transcurrido esta cantidad de días como mínimo. No se recomienda
fijar este valor; si ha habido una violación de seguridad puede ser necesario
cambiar la contraseña de inmediato, sin tener que esperar.
● Máxima cantidad de días entre cambios de contraseña: obliga a los

usuarios a cambiar su contraseña periódicamente. En Linux, este valor se
suma al campo de inactividad antes de bloquear la cuenta.
● Cantidad de días de adelanto para avisar expiración de contraseña:

avisa al usuario de la necesidad del cambio de contraseña, a partir de esta
cantidad de días antes de la fecha límite.
● Cantidad de días de inactividad antes de expirar la cuenta: Linux, son

días de gracia después del máximo sin cambiar contraseña y antes de
bloquear la cuenta.
● Fecha de expira de la contraseña: día contado a partir del 1-1-1970, en

que la cuenta expirará. Si el campo está en blanco, la cuenta no expira
nunca. Si ha transcurrido esta fecha, el campo debe ser repuesto por el
administrador para rehabilitar la cuenta.
● Banderas: reservado para usos futuros.
Configuración de la autenticación
Para cambiar la configuración de autenticación después de finalizar la instalación,

use el comando system-config-authentication, authconfig o authconfig-tui.

Escriba el comando authconfig en la línea de comandos. Si no es usuario root, se le

pedirá la contraseña root para continuar.
Métodos de autenticación
Las opciones de autenticación que puede seleccionar son:
● Habilitar contraseñas MD5 le permite usar una contraseña larga (de hasta
256 caracteres), en vez de las ocho letras.
● Habilitar contraseñas shadow proporciona un método seguro para

conservar contraseñas. Las contraseñas se almacenan en /etc/shadow, al
que tan sólo se puede acceder como root.
● Habilitar NIS le permite ejecutar un grupo de ordenadores en el mismo

dominio Network Information Service con una contraseña común y un fichero
de grupo. Puede escoger desde las siguientes opciones:
– Dominio NIS le permitirá especificar el dominio o grupo de ordenadores

al que pertenece su sistema.
– Usar broadcast para encontrar el servidor NIS le permitirá hacer un

broadcast en su red local para encontrar el servidor NIS.
– Servidor NIS hace que su ordenador utilice un servidor NIS específico,

en vez de enviar un broadcast a toda la red para encontrar el servidor
NIS disponible.
● Activar LDAP le dice a su ordenador que utilice LDAP para algunas o todas
las autenticaciones. LDAP consolida ciertos tipos de información en el seno
de su organización. Por ejemplo, todas las diferentes listas de usuarios que
puede haber en la organización se pueden unir en un sólo directorio LDAP.
– Servidor LDAP le permite acceder a un servidor específico (mediante su

dirección IP) que esté ejecutando el protocolo LDAP.
– LDAP Base DN le permite buscar información acerca de los usuarios

mediante su Distinguished Name (DN).
– Usar TLS (Transport Layer Security) esta opción permite a LDAP

enviar información encriptada de nombres de usuario y contraseñas al
servidor LDAP antes de la autenticación.
● Activar Kerberos Kerberos es un sistema de seguridad que proporciona

servicios de autentificación en red. Puede elegir entre tres opciones:
– Reino esta opción le permite acceder a una red que utiliza Kerberos,

compuesta por uno o varios servidores (también conocidos como KDCs)

y un número potencialmente alto de usuarios.
– KDC Esta opción le permite acceder al Centro de Distribución de Claves

(Key Distribution Center, KDC), una máquina que emite tickets de
Kerberos (a veces se llama también Ticket Granting Server o TGS).
– Servidor de Administración Esta opción le permite acceder a un

servidor que ejecute kadmind.
● Activar la autenticación SMB Configura PAM para usar un servidor SMB

para la autenticación de usuarios. Deberá proporcionar dos tipos de
información:
– Servidor SMB Indica qué servidor SMB contactará su estación de trabajo

para la autenticación.
– Grupo de trabajo SMB Indica en qué grupo de trabajo están los

servidores SMB.

5
Instalación y gestión de paquetes

Gestión de paquetes
Todo el software en un sistema Red Hat Linux está dividido en paquetes RPM los
cuales pueden ser instalados, actualizados o eliminados. Esta parte describe como
manejar los paquetes RPM en un sistema Red Hat Linux usando herramientas
gráficas y de línea de comandos.
El Administrador de paquetes (RPM) es un sistema de empaquetado abierto que

trabaja en Red Hat Linux además de otros sistemas Linux y UNIX y que está a la
disposición de cualquiera. Red Hat, Inc. fomenta el uso de RPM por parte de otros
vendedores para sus propios productos. RPM se puede distribuir bajo los términos
de GPL.
RPM facilita las actualizaciones de sistema para el usuario final. Es posible instalar,
desinstalar y actualizar paquetes RPM por medio de comandos breves. RPM
mantiene una base de datos de los paquetes instalados y de sus archivos, y usted
puede hacer consultas y verificaciones poderosas en su sistema. Si prefiere una
interfaz gráfica, puede utilizar la Herramienta de administración de paquetes
system-config-packages para ejecutar muchos comandos RPM.
Durante las actualizaciones, RPM maneja cuidadosamente los archivos de

configuración para que usted nunca pierda sus modificaciones de personalización
algo que no lograra hacer con archivos .tar.gz normales.
RPM permite al desarrollador tomar el código fuente del software y empaquetarlo

en paquetes binarios y de fuente para los usuarios finales. Este proceso es
bastante sencillo y se controla desde un único archivo y parches opcionales
creados por usted mismo. Esta clara delineación de fuentes originarias y sus
parches y las instrucciones de construcción facilitan el mantenimiento del paquete
al ir apareciendo nuevas versiones del software.
Metas de diseño RPM
Podría ser útil conocer las metas de diseño de RPM para poder aprender a usar
RPM:
● Predisposición a la actualización Al usar RPM es posible actualizar

componentes individuales de su sistema sin tener que reinstalarlos
completamente. Cuando obtenga una versin nueva de un sistema operativo
basado en RPM (como Red Hat Linux), no es necesario efectuar
reinstalaciones en su mquina (como debe hacerse con sistemas operativos
basados en otros sistemas de empaquetado). RPM permite actualizaciones

inteligentes, in situ y completamente automatizadas en su sistema. Los

archivos de configuración en los paquetes se conservan no obstante las
actualizaciones, y as no perder sus personalizaciones. No existen archivos
de actualización específicos para actualizar un paquete porque se utiliza el
mismo archivo RPM para instalar y actualizar el paquete en su sistema.
● Consultas poderosas RPM fue ideado para proporcionar opciones de

consulta poderosas. Se pueden efectuar búsquedas por toda su base de
datos para encontrar un paquete o sólo algún archivo. También es posible
averiguar a cual paquete pertenece un determinado archivo y de dónde
proviene el paquete. Los archivos contenidos en el paquete RPM están en
un archivo comprimido, con un encabezado binario personalizado que
contiene información til sobre el paquete y su contenido, permitiéndole
consultar paquetes individuales rápida y sencillamente.
● Verificación de sistema Otra característica poderosa es la de verificar

paquetes. Si está preocupado porque borra un archivo importante para algún
paquete, verifique el paquete. Se le notificar si hay anomalías. En este
punto, puede reinstalar el paquete si es necesario. Cualquier archivo de
configuración que haya modificado ser preservado durante la reinstalación.
● Fuentes originarias Un objetivo crucial ha sido el de permitir el uso de

fuentes de software originario, tal y como ha sido distribuido por los autores
originales del software. Con RPM tendrá las fuentes originarias junto con
cualquier parche que haya sido usado además de las instrucciones de
construcción completas. Esta es una ventaja importante por varios motivos.
Si por ejemplo sale una versión nueva de un programa, no necesariamente
necesita empezar desde cero para que se compile. Puede revisar el parche
para ver lo que tal vez necesitara hacer. Usando esta técnica se ven
fácilmente todos los elementos predeterminados y compilados en el
programa y todos los cambios que se le han hecho al software para construir
adecuadamente.
El objetivo de mantener las fuentes originarias podrá parecer importante sólo para
los desarrolladores, pero el resultado también sera software de más alta calidad
para los usuarios finales. Quisiéramos dar las gracias a la gente de distribución de
BOGUS por haber ideado el concepto de la fuente originaria.
Instalación de paquetes RPM
Los paquetes RPM normalmente tienen nombres de archivo como foo-1.0-

1.i386.rpm. El nombre de archivo incluye el nombre de paquete (foo), versión (1.0),
lanzamiento (1) y arquitectura (i386). La instalación de un paquete es tan simple
como teclear el siguiente comando en el intérprete de comandos de shell:
# rpm -ivh foo-1.0-1.i386.rpm

Si la instalación es correcta verá lo siguiente:

Preparing... ########################################### [100%]
1:foo ########################################### [100%]
Como podrá ver, RPM imprime el nombre del paquete y luego imprime una serie de
almohadillas (#) mientras se instala el paquete como una especie de medidor de
progreso.
Si empieza con la versión 4.1 del RPM, la firma del paquete se autentica en el
momento de la instalación o de la actualización del paquete. Si la verificación de la
firma falla, verá el siguiente mensaje de error:
error: V3 DSA signature: BAD, key ID 0352860f
Si se trata de una nueva firma en el cabezal, verá el siguiente error:

error: Header V3 DSA signature: BAD, key ID 0352860f
Si no tiene instalada la clave apropiada para verificar la firma, el mensaje dirá

NOKEY y será como lo siguiente:
warning: V3 DSA signature: NOKEY, key ID 0352860f
Paquete ya instalado
Si ya está instalado un paquete de la misma versión, verá:

Preparing... ########################################### [100%]
package foo-1.0-1 is already installed
Si desea instalar el paquete de todos modos y la versión que está intentando

instalar ya está instalada, podrá usar la opción --replacepkgs, la cual le dirá a RPM
que ignore el error:
# rpm -ivh --replacepkgs foo-1.0-1.i386.rpm
Esta opción es útil si se borraron los archivos instalados del RPM o si desea que se
instalen los archivos de configuración originales del RPM.
Archivos en conflicto
Si intenta instalar un paquete que contiene un archivo que ya ha sido instalado por
otro paquete o una versión más antigua del mismo paquete, verá lo siguiente:
Preparing... ########################################### [100%]
file /usr/bin/foo from install of foo-1.0-1 conflicts with file from package
bar-2.0.20

Para hacer que RPM ignore este error, use la opción --replacefiles:
rpm -ivh --replacefiles foo-1.0-1.i386.rpm
Dependencias no resueltas
Los paquetes RPM pueden "depender" de otros paquetes, lo cual significa que
requieren de la instalación de otros paquetes para poder ejecutarse
adecuadamente. Si intenta instalar un paquete que tiene una dependencia no
resuelta, verá lo siguiente:
Preparing... ########################################### [100%]
error: Failed dependencies:
bar.so.2 is needed by foo-1.0-1
Suggested resolutions:
bar-2.0.20-3.i386.rpm
Si está instalando un paquete oficial de Red Hat, se le sugerirá resolver la

dependencia de este paquete. Encuentre este paquete en los CD-ROMs de Red
Hat Linux o en el sitio FTP (o espejo) y añádalo al comando:
# rpm -ivh foo-1.0-1.i386.rpm bar-2.0.20-3.i386.rpm
Si se realiza la instalación correctamente, verá lo siguiente:

Preparing... ########################################### [100%]
1:foo ########################################### [ 50%]
2:bar ########################################### [100%]
Si desea forzar la instalación de todas maneras (no es una buena idea ya que el
paquete no funcionará correctamente), use la opción –nodeps.
Desinstalación
Desinstalar un paquete es tan simple como instalarlo. Teclee el siguiente comando

en el intérprete de comandos de la shell:
# rpm -e foo
Podría encontrarse con un error de dependencia cuando esté desinstalando un

paquete si otro paquete instalado depende del que está tratando de eliminar. Por
ejemplo:
Preparing... ########################################### [100%]
error: removing these packages would break dependencies:
foo is needed by bar-2.0.20-3.i386.rpm
Para hacer que RPM ignore este error y desinstale el paquete de todos modos (que

tampoco es buena idea ya que al hacerlo, el paquete que depende de él

probablemente dejará de funcionar correctamente), use la opción --nodeps.
Actualización
Actualizar un paquete es parecido a instalarlo. Teclee el siguiente comando en un

intérprete de comandos de la shell:
# rpm -Uvh foo-2.0-1.i386.rpm
Lo que no se ve arriba es que RPM ha desinstalado automáticamente cualquier

versión antigua del paquete foo. De hecho, tal vez desee usar -U siempre para
instalar paquetes, ya que funcionará aunque no haya versiones precedentes del
paquete instaladas.
Ya que RPM lleva a cabo la actualización inteligente de paquetes con archivos de

configuración, tal vez vea un mensaje como el siguiente:
saving /etc/foo.conf as /etc/foo.conf.rpmsave
Este mensaje significa que los cambios hechos al archivo de configuración podrían
no ser "compatibles" con el archivo de configuración nuevo en el paquete, así que
RPM ha almacenado su archivo original y ha instalado uno nuevo. Debería
averiguar cuáles son las diferencias entre los dos archivos de configuración y
resuelva el problema tan pronto como le sea posible para asegurarse que su
sistema continúe funcionando correctamente.
La actualización es en realidad una combinación de las actividades de

desinstalación e instalación, así que durante una actualización RPM, podrá
encontrar errores de desinstalación e instalación, además de cualquier otro tipo de
error. Si RPM cree que usted está tratando de actualizar a un número de versión de
paquete más antiguo, aparecerá lo siguiente:
package foo-2.0-1 (which is newer than foo-1.0-1) is already installed
Para hacer que RPM "actualice" de todos modos, use la opción --oldpackage:
rpm -Uvh --oldpackage foo-1.0-1.i386.rpm
Refrescamiento
Refrescar un paquete es parecido a actualizarlo. Teclee el siguiente comando en

un intérprete de comandos shell:
# rpm -Fvh foo-1.2-1.i386.rpm
La opción de refrescamiento RPM compara las versiones de los paquetes

especificados en la línea de comandos con las versiones de los paquetes que ya

han sido instalados en su sistema. Cuando la opción de refrescamiento de RPM
elabora una versión más reciente de un paquete ya instalado, éste será actualizado
a la versión más reciente. Sin embargo, la opción de refrescamiento de RPM no
instalará un paquete si no existe un paquete previamente instalado del
mismo nombre. Esto no es igual a la opción de actualización de RPM, ya que una
actualización sí instalará paquetes, no importa si ya esté instalada una versión más
antigua de un paquete.
La opción de refrescamiento de RPM funciona ya sea para paquetes individuales

que para un grupo de paquetes. Si usted acaba de descargar una gran cantidad de
paquetes diferentes y sólo desea actualizar los paquetes que ya estaban instalados
en su sistema, la solución es el refrescamiento. Si utiliza la opción de
refrescamiento, antes de usar RPM no tendrá que eliminar ningún paquete
indeseado del grupo que ha descargado.
En este caso, puede ejecutar el comando siguiente:

# rpm -Fvh *.rpm
RPM actualizará automáticamente sólo los paquetes que ya estén instalados.
Consultas
Use el comando rpm -q para hacer consultas a la base de datos de los paquetes
instalados. El comando rpm -q foo imprimirá el nombre de paquete, versión y
número de lanzamiento del paquete foo instalado:
foo-2.0-1
En vez de especificar el nombre del paquete, se pueden usar las siguientes

opciones con -q para especificar lo(s) paquete(s) que desea consultar. Se llaman
Opciones de especificación de paquetes:
-a Consulta todos los paquetes actualmente instalados.
-f <archivo> Consultará el paquete que posea <archivo>. Cuando especifique

un archivo, deberá especificar la ruta completa del archivo
(/usr/bin/ls, por ejemplo).
-p <paquete> Consulta un paquete rpm no instalado. Debe especificar la ruta
al archivo rpm.
Hay varias maneras de especificar qué información mostrar sobre los paquetes
consultados. Las siguientes opciones sirven para seleccionar el tipo de información

que usted está buscando. Se llaman Opciones de selección de información.
-i Muestra información del paquete como el nombre, la
descripción, la versión, el tamaño, la fecha de construcción, la
fecha de instalación, el distribuidor, y otra información
miscelánea.
-l Muestra la lista de archivos contenidos en el paquete.
-s Muestra el estado de todos los archivos en el paquete.
-d Muestra una lista de archivos marcados como documentación
(páginas de manual, páginas de información, archivos LÉAME,
etc.).
-c Muestra una lista de archivos marcados como archivos de
configuración. Estos son los archivos que usted cambia después
de la instalación para adaptar el paquete a su sistema.
Para acceder a opciones que muestran listas de archivos, puede añadir -v al

comando para que muestre las listas en un formato ls -l conocido.
Verificación
La verificación de un paquete tiene que ver con comparar la información sobre

archivos instalados de un paquete con la misma información del paquete original.
Entre otras cosas, la verificación compara el tamaño, la suma MD5, los permisos, el
tipo, el dueño y el grupo de cada archivo.
El comando rpm -V verifica un paquete. Usted puede utilizar cualquiera de las

Opciones de selección de paquete de la lista para pedir que se especifiquen los
paquetes que desea verificar. Un modo sencillo de verificar es rpm -V foo, que
verifica si todos los archivos en el paquete foo se encuentran en el mismo estado
en que estaban cuando originalmente fueron instalados. Por ejemplo:
Para verificar un paquete que contiene un determinado archivo:

# rpm -Vf /bin/vi
Para verificar TODOS los paquetes instalados:

# rpm -Va
Para verificar un paquete instalado contra un archivo de paquete RPM

# rpm -Vp foo-1.0-1.i386.rpm

Este comando puede ser útil si sospecha que sus bases de datos de RPM están
dañadas.
Si todo fue verificado correctamente, no habrá salida. Si se encuentran

discrepancias, serán mostradas. El formato de la salida es una cadena de ocho
caracteres (una c identifica un archivo de configuración) seguido por el nombre del
archivo. Cada uno de los ocho caracteres señala el resultado de una comparación
entre un atributo del archivo al valor de ese atributo escrito en la base de datos de
RPM. Un sólo . (punto) significa que ha pasado la prueba. Los siguientes
caracteres señalan que ciertas pruebas no han sido pasadas:
Prueba Descripción
5 MD5 suma de verificación

S Tamaño del archivo
L Enlace simbólico
T Hora de modificación de archivo
D Dispositivo
U Usuario propietario
G Grupo propietario
M Modo
? Archivo que no se puede leer
Si ve alguna salida, use su buen juicio para determinar si debería quitar o reinstalar
el paquete o resolver el problema de otra manera.
Verificando la firma del paquete
Si desea verificar si algún paquete ha sido dañado o alterado examine sólo la suma
md5 tecleando el siguiente comando en un intérprete de comandos de shell
(sustituya <archivo-rpm> con el nombre de archivo de su paquete):
# rpm -K --nogpg <archivo-rpm>
Aparecerá el mensaje <archivo-rpm>: md5 OK. Este breve mensaje significa que el
archivo no ha sido dañado al momento de la descarga. Si desea un mensaje más
detallado, reemplace -K por -Kvv en el comando.
Por otra parte, ¿cuánto es de fiable el desarrollador que creó el paquete? Si el

paquete está firmado con la clave GnuPG del desarrollador, sabrá que el
desarrollador de verdad es quien dice ser.

Se puede firmar un paquete RPM usando la Gnu Privacy Guard (o GnuPG), para
ayudarle a asegurarse que el paquete descargado es de fiar.
GnuPG es una herramienta para comunicación segura; reemplaza completa y

gratuitamente la tecnología de encriptación de PGP, un programa electrónico de
privacidad. Con GnuPG usted puede autentificar la validez de los documentos y
encriptar/descifrar datos de y hacia otros destinatarios. Además, GnuPG es capaz
de descifrar y verificar archivos PGP 5.x.
Durante la instalación de Red Hat Linux, GnuPG está instalado por defecto. De
este modo podrá usar inmediatamente GnuPG para verificar cualquier paquete que
reciba desde Red Hat. En primer lugar necesitará importar la clave pública privada
de Red Hat.
Importar claves
Para verificar los paquetes de Red Hat tiene que importar las claves de GPG de
Red Hat. Para ello, ejecute el siguiente comando en el intérprete de comandos de
la shell:
# rpm --import /usr/share/rhn/RPM-GPG-KEY
Para ver la lista de todas las claves instaladas para la verificación de RPM, ejecute
el comando:
# rpm -qa gpg-pubkey*
Para la clave de Red Hat, la salida incluye:

gpg-pubkey-db42a60e-37ea5438
Para mostrar más detalles sobre una clave determinada, use rpm -qi seguido de la
salida del anterior comando:
# rpm -qi gpg-pubkey-db42a60e-37ea5438
Verificación de la firma de paquetes
Para controlar la firma GnuPG de un archivo RPM después de importar la clave del
constructor GnuPG, use el siguiente comando (sustituya <archivo-rpm> con el
nombre de archivo de su paquete RPM):
# rpm -K <archivo-rpm>
Si todo va bien, verá el siguiente mensaje: md5 gpg OK. Esto significa que el paquete
no está dañado.

Técnicas de uso de rpm
RPM es una herramienta útil ya sea para administrar su sistema que para
diagnosticar y solucionar problemas. La mejor manera de comprender todas sus
opciones es viendo algunos ejemplos.
Tal vez usted haya borrado algunos archivos accidentalmente, pero no está seguro
de lo que ha eliminado. Si desea verificar su sistema entero y ver lo que podría
hacer falta, podría intentarlo con el siguiente comando:
# rpm -Va
Si faltan algunos archivos o parecen dañados, probablemente debería o reinstalar

el paquete o desinstalarlo y luego reinstalarlo.
Tal vez alguna vez verá un archivo que no reconoce. Para saber a qué paquete
pertenece, teclearía:
# rpm -qf /usr/X11R6/bin/ghostview
La salida es parecida a lo siguiente:

gv-3.5.8-22
Podemos combinar los dos ejemplos de arriba en la siguiente hipótesis. Digamos

que está teniendo problemas con /usr/bin/paste. Le gustaría verificar el paquete al
cual pertenece ese programa, pero no sabe a cuál paquete pertenece paste.
Simplemente teclee el siguiente comando:
# rpm -Vf /usr/bin/paste
y se verificará el paquete correcto.
¿Desea encontrar más información sobre un determinado programa? Puede

intentar el siguiente comando para localizar la documentación que acompañaba el
paquete al cual pertenece ese programa:
# rpm -qdf /usr/bin/free
La salida debería ser parecida a la siguiente:

/usr/share/doc/procps-2.0.11/BUGS
/usr/share/doc/procps-2.0.11/NEWS
/usr/share/doc/procps-2.0.11/TODO
/usr/share/man/man1/free.1.gz
/usr/share/man/man1/oldps.1.gz
/usr/share/man/man1/pgrep.1.gz
/usr/share/man/man1/pkill.1.gz
/usr/share/man/man1/ps.1.gz
/usr/share/man/man1/skill.1.gz
/usr/share/man/man1/snice.1.gz
/usr/share/man/man1/tload.1.gz

/usr/share/man/man1/top.1.gz
/usr/share/man/man1/uptime.1.gz
/usr/share/man/man1/w.1.gz
/usr/share/man/man1/watch.1.gz
/usr/share/man/man5/sysctl.conf.5.gz
/usr/share/man/man8/sysctl.8.gz
/usr/share/man/man8/vmstat.8.gz
Podría encontrar un RPM nuevo y no saber para qué sirve. Para encontrar
información sobre él, use el siguiente comando:
# rpm -qip crontabs-1.10-5.noarch.rpm
La salida es parecida a lo siguiente:

Name : crontabs Relocations: (not relocateable)
Version : 1.10 Vendor: Red Hat, Inc.
Release : 5 Build Date: Fri 07 Feb 2003 04:07:32
PM EST
Install date: (not installed) Build Host: porky.devel.redhat.com
Group : System Environment/Base Source RPM: crontabs-1.10-5.src.rpm
Size : 1004 License: Public Domain
Signature : DSA/SHA1, Tue 11 Feb 2003 01:46:46 PM EST, Key ID fd372689897da07a
Packager : Red Hat, Inc. <http://bugzilla.redhat.com/bugzilla>
Summary : Root crontab files used to schedule the execution of programs.
Description :
The crontabs package contains root crontab files. Crontab is the
program used to install, uninstall, or list the tables used to drive the
cron daemon. The cron daemon checks the crontab files to see when
particular commands are scheduled to be executed. If commands are
scheduled, then it executes them.
Quizás desea ver qué archivos instala el RPM crontabs. Ingrese lo siguiente:
# rpm -qlp crontabs-1.10-5.noarch.rpm
La salida será de la siguiente manera:

Name : crontabs Relocations: (not relocateable)
Version : 1.10 Vendor: Red Hat, Inc.
Release : 5 Build Date: Fri 07 Feb 2003 04:07:32
PM EST
Install date: (not installed) Build Host: porky.devel.redhat.com
Group : System Environment/Base Source RPM: crontabs-1.10-5.src.rpm
Size : 1004 License: Public Domain
Signature : DSA/SHA1, Tue 11 Feb 2003 01:46:46 PM EST, Key ID fd372689897da07a
Packager : Red Hat, Inc. <http://bugzilla.redhat.com/bugzilla>
Summary : Root crontab files used to schedule the execution of programs.
Description :
The crontabs package contains root crontab files. Crontab is the
program used to install, uninstall, or list the tables used to drive the
cron daemon. The cron daemon checks the crontab files to see when
particular commands are scheduled to be executed. If commands are
scheduled, then it executes them.
Estos son solamente algunos ejemplos. Al usarlo, descubrirá muchos más usos
para RPM.

Yellowdog Updater Modified (YUM)
Yum es un actualizador automatico y administrador de paquetes para sistemas

basados en rpm.
● Yum provee:
● Multiples repositorios.
● Archivo simple de configuracion.
● Calculo correcto de dependencias.
● Interface simple.
Configuración de YUM
Antes de utilizar yum y para obtener el potencial total de yum, debemos importar la
clave GPG de Fedora. Para seguridad adicional, todos los paquetes del proyecto
Fedora son firmados con la clave pública fedora@redhat.com. Si intenta realizar
una actualización sin importar la clave, vera lo siguiente:
# yum update
You have enabled checking of packages via GPG keys. This is a good thing.
However, you do not have any GPG public keys installed. You need to download
the keys for packages you wish to install and install them.
You can do that by running the command:
rpm --import public.gpg.key
For more information contact your distribution or package provider.
La clave GPG de Fedora ha sido instalado en el sistema durante la instación inicial,

de tal forma que importar la clave es un proceso simple:
# rpm --import /usr/share/{rhn,rpm-*}/RPM-GPG-KEY
Ahora el comando yum update se ejecutará correctamente.
Es importante conocer como agregar repositorios de terceros quienes pueden

ofrecer paquetes no disponibles directamente desde el proyecto Fedora. El archivo
de configuración por defecto es /etc/yum.conf, el cual contiene la sección [main], y
toda la información de los repositorios está almacenada en los archivos
/etc/yum.repos.d como archivos .repo.
La configuración por defecto utiliza los siguientes sitios mirror:

# cat /etc/yum.repos.d/fedora.repo
[base]

name=Fedora Core $releasever - $basearch - Base

#baseurl=http://download.fedora.redhat.com/pub/fedora/linux/core/$releasever/$base
arch/os/
mirrorlist=http://fedora.redhat.com/download/mirrors/fedora-core-$releasever
enabled=1
gpgcheck=1
# cat /etc/yum.repos.d/fedora-updates.repo
[updates-released]
name=Fedora Core $releasever - $basearch - Released Updates
#baseurl=http://download.fedora.redhat.com/pub/fedora/linux/core/updates/$releasev
er/$basearch/
mirrorlist=http://fedora.redhat.com/download/mirrors/updates-released-
fc$releasever
enabled=1
gpgcheck=1
La lista de sitios mirror actualizada puede obtenerse de la dirección

http://fedora.redhat.com/download/mirrors.html
La configuración debería modificarse para utilizar sitios mirror que se encuentren

geográficamente mas cerca o sean mas rápidos. Fíjese en los sitios mirror para los
paquetes base y updates y seleccione el mas apropiado. Guarde estos URLs en
archivos de texto dentro del directorio /etc/yum.repos.d/, por ejemplo:
# cat /etc/yum.repos.d/sudamerica-base.mirrors
http://www.las.ic.unicamp.br/pub/fedora/linux/core/$releasever/$basearch/os
ftp://mirror.netglobalis.net/pub/fedora/$releasever/$basearch/os
# cat /etc/yum.repos.d/sudamerica-updates.mirrors
http://www.las.ic.unicamp.br/pub/fedora/linux/core/updates/$releasever/$basearch/
ftp://mirror.netglobalis.net/pub/fedora/updates/$releasever/$basearch/
Las variables $releasever y $basearch son reemplazadas por la versión de Linux y

arquitectura utilizada respectivamente.
Luego de crear los archivos actualice el archivo por defecto fedora.repo y fedora-
updates.repo para que utilicen la lista personalizada de sitios mirror, como sigue:
# cat /etc/yum.repos.d/fedora.repo
[base]
#baseurl=http://download.fedora.redhat.com/pub/fedora/linux/core/$releasever/$base
arch/os/
#mirrorlist=http://fedora.redhat.com/download/mirrors/fedora-core-$releasever
mirrorlist=file:///etc/yum.repos.d/sudamerica-base.mirrors
enabled=1
gpgcheck=1
# cat /etc/yum.repos.d/fedora-updates.repo
[updates-released]
#baseurl=http://download.fedora.redhat.com/pub/fedora/linux/core/updates/$releasev
er/$basearch/
#mirrorlist=http://fedora.redhat.com/download/mirrors/updates-released-
fc$releasever
mirrorlist=file:///etc/yum.repos.d/sudamerica-updates.mirrors

enabled=1
gpgcheck=1
De esta forma utilizará los repositorios para sudamerica en lugar de la lista de

mirrors por defecto.
El fuerte de yum es la facilidad con la que puede agregar repositorios de terceros.

Para agregar un repositorio, simplemente agregue archivos .repo. He aquí unos
archivos de configuración para unos repositorios comunes:
Fedora Development:
# cat /etc/yum.repos.d/fedora-devel.repo
[development]
name=Fedora Core $releasever - Development Tree
#baseurl=http://download.fedora.redhat.com/pub/fedora/linux/core/development/$base
arch/
mirrorlist=http://fedora.redhat.com/download/mirrors/fedora-core-rawhide
enabled=1
gpgcheck=1
FreshRPMs.net:
# cat /etc/yum.repos.d/freshrpms.repo
[core]
name=FreshRPMS-Core
baseurl=http://ayo.freshrpms.net/fedora/linux/$releasever/$basearch/core
enabled=1
#gpgcheck=1
#[extras]
#name=Fedora Linux $releasever - $basearch - extras
#baseurl=http://ayo.freshrpms.net/fedora/linux/$releasever/$basearch/extras
#enabled=0
#gpgcheck=1
#[alternatives]
#name=Fedora Linux $releasever - $basearch - alternatives
#baseurl=http://ayo.freshrpms.net/fedora/linux/$releasever/$basearch/alternatives
#enabled=0
#gpgcheck=1
[updates]
name=FreshRPMS-Updates
baseurl=http://ayo.freshrpms.net/fedora/linux/$releasever/$basearch/updates
enabled=1
#gpgcheck=1
[freshrpms]
name=FreshRPMS-Fresh
baseurl=http://ayo.freshrpms.net/fedora/linux/$releasever/$basearch/freshrpms
enabled=1
#gpgcheck=1
Livna.org:
# cat /etc/yum.repos.d/livna.repo
[livna]
name=Livna Stable
baseurl=http://rpm.livna.org/fedora/$releasever/$basearch/RPMS.stable/
enabled=1
#gpgcheck=1

Dag:
# cat /etc/yum.repos.d/dag.repo
[dag]
name=Dag
baseurl=http://apt.sw.be/fedora/$releasever/en/$basearch/dag/
enabled=1
#gpgcheck=1
La opción enabled habilita el repositorio, la opción gpgcheck debería ser deshabilitada

a menos que se cuente con la clave pública del sitio de descarga.
Utilización de YUM
Lo primero es actualizar la cabecera de rpms desde el repositorio.

# yum check-update
Para actualizar todo el sistema ejecute:

# yum update
Para actualizar un paquete especifico ejecute:

# yum update <paquete>
Para instalar un paquete que no tiene actualmente ejecute:

# yum install <paquete>
Para buscar un paquete puede utilizar el comando:

# yum search <texto_de_busqueda>
Suponiendo que una dependencia solicite una biblioteca que no es un paquete en

si, como libc6.1-1.so.2, como lo obtiene?
Ejecute:
# yum provides libc6.1-1.so.2
Para desinstalar un paquete ejecute:

# yum remove <paquete>
Para eliminar paquetes en cache que son viejos y cabeceras no necesarias ejecute
el comando:
# yum clean all

Para obtener informacion de un paquete ejecute el comando:

# yum info <paquete>
Creación de un repositorio yum local
Si se tienen varias computadoras que deben ser actualizadas via yum, entonces
debería considerar la creación de un repositorio local yum. Esto no solo conserva
ancho de banda, sino mejora la respuesta de yum para instalar programas
adicionales. Además, la ejecución de yum a través de LAN en lugar de WAN es
mucho mas rápida. La desventaja es que probablemente este descargando
actualizaciones no necesarias para sus máquinas.
Creación del repositorio base para YUM
Para crear un repositorio local yum, necesitará un servidor Web. La configuración

por defecto proporcionada con Red Hat/Fedora es suficiente.
Cree una carpeta yum en DocumentRoot:

# mkdir /var/www/html/yum
Ahora, puede crear una estructura de directorios para almacenar los archivos. Yum
soporta multiples repositorios, de tal forma que puede actuar como servidor para
cualquier versión de Fedora en el mismo servidor. La estructura utilizada para
almacenar los archivos será:
/var/www/html/yum/Fedora/Core/<version>/base
Siendo <version> un número entero correspondiente con la versión de Fedora

utilizada.
Copie el contenido de cada CD de Fedora al directorio base.

# cp /media/cdrom/Fedora/RPMS/*.rpm /var/www/html/yum/Fedora/Core/<version>/base
Ahora debe crear el archivo de metadatos XML para el repositorio, para ello
necesitará el paquete createrepo.
# yum install createrepo
Para crear el archivo de metadatos XML para el directorio de RPMS base ejecute:
# createrepo /var/www/html/yum/Fedora/Core/<version>/base
Si el comando se ejecuta correctamente, los archivos de metadatos serán creados

en un directorio llamado /var/www/html/yum/Fedora/Core/<version>/base/repodata.

Creación del repositorio updates para YUM
El tener su propio repositorio base es excelente para la instalación de software,

pero puede sacar provecho de tener su propio repositorio de actualizaciones. La
creación de uno es tan fácil como la creación de un directorio base. La estructura
para el directorio de actualizaciones será:
/var/www/html/yum/Fedora/Core/updates/<version>/
Luego, obtenga una copia de las actualizaciones, las cuales pueden ser obtenidas
de cualquier servidor de descarga de archivos de Fedora, o algún mirror listado en
http://fedora.redhat.com/download/mirrors.html. Existen servidores identificados
como rsync. Para descargar los archivos, puede utilizar el comando rsync:
# rsync -avz rsync://distro.ibiblio.org/fedora-linux-core/updates/<version>/i386
--exclude=debug/ /var/www/html/yum/Fedora/Core/updates/<version>/
Puede crear una tarea cron para mantener actualizado el repositorio updates.
Luego de descargar todos los paquetes a la carpeta updates, ejecute nuevamente

el comando createrepo para generar los metadatos XML.
# createrepo /var/www/html/yum/Fedora/Core/updates/<version>/
Si el comando se ejecuta correctamente, los archivos de metadatos serán creados

en un directorio llamado /var/www/html/yum/Fedora/Core/updates/<version>/repodata.
Una vez creados los repositorios asegúrese de iniciar el servicio httpd:
# service httpd start
Configuración de los equipos para utilizar el repositorio YUM local
Una vez creado el repositorio yum, es necesario indicar a los equipos que lo utilicen.
Esto se hace configurando el archivo /etc/yum.repos.d/fedora.repo:
[base]
baseurl=http://nombre_servidor/Fedora/Core/$releasever/base/
Luego configure el archivo /etc/yum.repos.d/fedora-updates.repo

[updates-released]
baseurl=http://nombre_servidor/Fedora/Core/updates/$releasever/
Ahora, simplemente ejecute el comando yum update para actualizar los sistemas.
Si comparte los archivos a través de NFS, no necesita un servidor web para actuar
como repositorio, puede configurar yum para que utilice el repositorio via NFS,

utilizando como protocolo file://, por ejemplo, el archivo

/etc/yum.repos.d/fedora.repo sería como sigue:
[base]
baseurl=file:///recurso_nfs/Fedora/Core/$releas ever/base/
El archivo /etc/yum.repos.d/fedora-updates.repo sería como sigue

[updates-released]
name=F edora Core $releasever - $basearch - Released Updates
baseurl=file:///recurso_nfs/Fedora/Core/updates/$releasever/
La herramienta up2date
Red Hat Enterprise Linux proporciona la herramienta up2date para mantener

actualizado el sistema si cuenta con una subscripción a Red Hat Network. La
herramienta up2date también puede utilizar repositorios yum para la instalación y
actualización de paquetes.
Para lograr esto, debe editar el archivo /etc/sysconfig/rhn/sources, por ejemplo:
# tipo etiqueta del canal url
yum enterprise-base http://nombre_servidor/Enterprise/$releasever/base/

6
Herramientas del sistema

Configuración de la impresora
La Herramienta de configuración de impresoras permite a los usuarios configurar

una impresora en Red Hat Linux. Esta herramienta ayuda a mantener el archivo de
configuración de la impresora, los directorios spool y los filtros de impresión.
En Red Hat Linux, CUPS es el sistema de impresión predeterminado.
Para usar la Herramienta de configuración de impresoras debe tener privilegios

como root. Para iniciar la aplicación, seleccione Botón de menú principal (en el
Panel) => Configuración del sistema => Impresión, o escriba el comando system-
config-printer. Este comando determina automáticamente si ejecutará la versión
gráfica o la versión basada en texto dependiendo de si el comando es ejecutado
desde el ambiente gráfico X Window o desde una consola basada en texto.
Puede forzar a la Herramienta de configuración de impresoras a ejecutarse como

una aplicación basada en texto usando el comando system-config-printer-tui
desde el intérprete de comandos.
Se pueden configurar los siguientes tipos de colas de impresión:
● Conectada-localmente una impresora directamente conectada al

computador a través de un puerto paralelo o USB.
● Conectada CUPS (IPP) una impresora conectada a un sistema CUPS

diferente que puede ser accedida sobre una red TCP/IP (por ejemplo, una
impresora conectada a otro sistema Red Hat Linux corriendo CUPS en la
red).
● Conectada UNIX (LPD) una impresora conectada a un sistema UNIX

diferente que puede ser accedida sobre una red TCP/IP (por ejemplo, una
impresora conectada a otro sistema Red Hat Linux corriendo LPD en la red).
● Conectada Windows (SMB) una impresora conectada a un sistema

diferente el cual está compartiendo una impresora sobre una red SMB (por
ejemplo, una impresora conectada a una máquina Microsoft Windows.
● Conectada Novell (NCP) una impresora conectada a un sistema diferente el

cual usa la tecnología de red Novell NetWare.
● Conectada JetDirect una impresora conectada directamente a la red a

través de HP JetDirect en vez de a un computador.

Añadir una impresora local
Para añadir una impresora local, tal como una conectada al puerto paralelo o USB
en su computador, haga clic en Nuevo en la ventana principal de la Herramienta de
configuración de impresoras. Haga clic en Siguiente para proceder.
Introduzca un nombre único para la impresora en el campo de texto Nombre. El

nombre de la impresora no puede contener espacios y debe comenzar con una
letra. El nombre de la impresora puede contener letras, números, guiones (-), y
rayas (_). Opcionalmente, introduzca una descripción corta para la impresora, la
cual puede contener espacios.
Seleccione Conectado localmente desde el menú Seleccionar el tipo de cola y

seleccione el dispositivo. El dispositivo es usualmente /dev/lp0 para una impresora
paralela o /dev/usb/lp0 para una impresora USB.
El próximo paso es seleccionar el tipo de impresora.
Añadir una impresora IPP
Una impresora de red IPP es una impresora conectada a un sistema Linux

diferente en la misma red ejecutando CUPS o una impresora configurada para usar
IPP en otro sistema operativo. Por defecto, la Herramienta de configuración de
impresoras navega la red en busca de impresoras compartidas IPP. (Esta opción
se puede cambiar seleccionando Acción => Compartir desde el menú.) Cualquier
impresora IPP compartida aparecerá en la ventana principal.
Si tiene un cortafuegos (firewall) configurado en el servidor de impresión, este debe

ser capaz de enviar y recibir conexiones en el puerto de entrada UDP 631. Si tiene
un cortafuegos configurado en el cliente (la computadora enviando la petición de
impresión), se le debe permitir enviar y aceptar conexiones en el puerto 631.

Después de hacer clic en Siguiente. Seleccione Conectada CUPS (IPP) desde el

menú Seleccionar un tipo de cola.
Aparecen los campos de texto para las opciones siguientes:
● Servidor El nombre de la máquina o dirección IP de la máquina remota a la

cual la impresora está conectada.

● Ruta La ruta de la cola de impresión en la máquina remota. Ej.

/printers/hp2100.
Añadir una impresora UNIX (LPD) remota
Para agregar una impresora UNIX remota, tal como una conectada a un sistema
Linux diferente en la misma red, haga clic en el botón Nuevo en la ventana
principal de la Herramienta de configuración de impresoras.

Seleccione Conectada UNIX (LPD) desde el menú Seleccionar el tipo de cola y

haga clic en Siguiente.
Aparecen los campos de texto para las opciones siguientes:
● Servidor El nombre de la máquina o la dirección IP de la máquina remota a

la cual la impresora está conectada.
● Cola La cola de impresión remota. La impresora por defecto es usualmente

lp.
Haga clic en Siguiente para continuar.
Añadir una impresora Samba (SMB)
Para añadir una impresora que es accedida usando el protocolo SMB (tal como una
impresora conectada a un sistema Microsoft Windows), haga clic en el botón
Nuevo en la ventana principal de la Herramienta de configuración de impresoras.

Seleccione Conectada a Windows (SMB) desde el menú Seleccionar un tipo de

cola, y haga click en Siguiente. Si la impresora está conectada a un sistema
Microsoft Windows, seleccione este tipo de cola.

Los recursos compartidos SMB son detectados y listados automáticamente. Haga

clic en la flecha al lado de cada nombre de recurso compartido para ampliar la lista.
Desde la lista ampliada, seleccione una impresora.
Si la impresora que está buscando no aparece en la lista, haga clic en el botón

Especificar a la derecha. Aparecerán los campos de texto para las siguientes
opciones:
● Grupo de trabajo El nombre del grupo de trabajo Samba para la impresora

compartida.
● Servidor El nombre del servidor compartiendo la impresora.
● Compartir (Recurso compartido) El nombre de la impresora compartida en

la cual desea imprimir. Este nombre debe ser el mismo que el definido como
la impresora Samba en la máquina Windows remota.
● Nombre de usuario El nombre de usuario con el que debe conectarse para

acceder a la impresora. Este usuario debe existir en el sistema Windows y el
usuario debe tener permiso para accesar la impresora. El nombre de usuario
predeterminado es típicamente guest para los servidores Windows, o
nobody para los servidores Samba.
● Contraseña La contraseña (si se necesita) para el usuario especificado en

el campo Nombre de usuario.
Haga clic en Siguiente para continuar. La Herramienta de configuración de

impresoras luego intenta conectarse a la impresora compartida. Si la impresora
compartida requiere un nombre de usuario y contraseña, aparecerá una ventana de
diálogo pidiéndole que proporcione un nombre de usuario válido y contraseña. Si
se especificó un nombre de recurso compartido incorrecto, puede cambiarlo aquí
también. Si un nombre de grupo de trabajo es requerido para conectarse al recurso
compartido, se puede especificar en esta caja de diálogo. Esta ventana de diálogo
es la misma que la mostrada cuando se hace clic sobre el botón Especificar.
Añadir una impresora Novell NetWare (NCP)
Para añadir una impresora Novell NetWare (NCP), haga clic en el botón Nuevo en
la ventana principal de la Herramienta de configuración de impresoras.


Seleccione Conectada Novell (NCP) del menú Seleccionar un tipo de cola.
Aparecerán campos de texto para las opciones siguientes:
● Servidor El nombre de la máquina o dirección IP del sistema NCP al cual la

impresora está conectada.
● Cola La cola remota para la impresora en el sistema NCP.
● Usuario El nombre del usuario que debe conectarse para accesar la

impresora.
● Contraseña La contraseña para el usuario especificado en el campo

Usuario.
Añadir una impresora JetDirect
Para agregar una impresora JetDirect, haga click en el botón Nuevo en la ventana
principal de la Herramienta de configuración de impresoras.

Aparecerán los campos de texto para las siguientes opciones:
● Impresora El nombre de la máquina o dirección IP de la impresora

JetDirect.
● Puerto El puerto en la impresora JetDirect que está escuchando por trabajos

de impresión. El puerto predeterminado es 9100.
Selección del modelo de impresora
Después de seleccionar el tipo de cola de impresión, el próximo paso es

seleccionar el modelo de la impresora.
Si no fue detectado automáticamente, seleccione el modelo de la lista. Las

impresoras son divididas por fabricantes. Seleccione el nombre del fabricante

desde el menú. Los modelos de impresoras son actualizados cada vez que un
nuevo fabricante es seleccionado. Seleccione el modelo de impresora de la lista.
El controlador de la impresora recomendado es escogido basado en el modelo de

impresora seleccionado. El controlador de la impresora procesa los datos que
desea imprimir en un formato que la impresora pueda entender. Puesto que hay
una impresora local conectada a su computador, necesita un controlador de
impresora para procesar los datos que son enviados a la misma.
Si está configurando una impresora remota (IPP, LPD, SMB, or NCP), el servidor
de impresión remoto usualmente tiene su propio controlador de impresión. Si
selecciona un controlador de impresión adicional en su computador local, los datos
son filtrados múltiples veces y convertido a un formato que la impresora no puede
entender.
Para asegurarse de que los datos no son filtrados más de una vez, primero trate de
seleccionar Genérico como el fabricante y Cola de impresora sin formato o
Impresora Postscript como el modelo de impresora. Después de aplicar los
cambios, imprima una página de prueba para probar la nueva configuración. Si la
prueba falla, el servidor de impresión remoto puede que no tenga un controlador de
impresora configurado. Intente seleccionando un controlador de acuerdo al
fabricante y modelo de la impresora remota, aplique los cambios e imprima una
página de prueba.
Guardar y restaurar el archivo de configuración
Cuando la configuración de la impresora es guardada usando la Herramienta de

configuración de impresoras, la aplicación crea su propio archivo de configuración
que es usado para crear los archivos en el directorio /etc/cups. Puede usar las
opciones de línea de comandos para guardar o restaurar el archivo de la
Herramienta de configuración de impresoras.
Si el directorio /etc/cups o el archivo /etc/printcap es guardado y restaurado a las

mismas ubicaciones, la configuración de la impresora no es restaurada porque
cada vez que el demonio de impresión es iniciado, crea un nuevo archivo
/etc/printcap desde el archivo especial de configuración Herramienta de
configuración de impresoras. Cuando se esté haciendo un respaldo de los archivos
de configuración del sistema, use el método siguiente para guardar los archivos de
configuración de la impresora(s).
Para guardar la configuración de su impresora, escriba este comando como root:

# /usr/sbin/system-config-printer-tui --Xexport > settings.xml
Su configuración es guardada al archivo settings.xml.

Si se guarda este archivo, se puede usar para restaurar las configuraciones de la

impresora. Esto es muy útil si la configuración de la impresora es borrada, si Red
Hat Linux es reinstalado o si se necesita la misma configuración de impresoras en
múltiples sistemas. El archivo debería guardarse en un sistema diferente antes de
ser reinstalado. Para restaurar la configuración, escriba este comando como root:
# /usr/sbin/system-config-printer-tui --Ximport < settings.xml
Si ya tiene un archivo de configuración (ya ha configurado una o más impresoras

en el sistema) e intenta importar otro archivo de configuración, el archivo de
configuración existente será sobreescrito. Si quiere conservar su configuración
existente y agregar la configuración en el archivo guardado, puede mezclar los
archivos con el comando siguiente (como root):
# /usr/sbin/system-config-printer-tui --Ximport --merge < settings.xml
Su lista de impresoras consistirá de las impresoras que ha configurado en el

sistema así como también las impresoras que importó desde el archivo de
configuración guardado. Si el archivo de configuración importado tiene una cola de
impresión con el mismo nombre de una cola existente en el sistema, la cola de
impresión desde el archivo importado sobreescribirá la impresora existente.
Después de importar el archivo de configuración (con o sin el comando merge),

debe reiniciar el demonio de impresión. Si está usando CUPS, escriba el comando:
# /sbin/service cups restart
Administración de trabajos de impresión
Cuando usted envía un trabajo de impresión al demonio de impresión, tal como

imprimir un archivo de texto desde Emacs o imprimir una imagen desde El GIMP, el
trabajo de impresión es añadido al spool de la cola de impresión. El spool de la
cola de impresión es una lista de los trabajos de impresión que han sido enviados a
la impresora e información acerca de cada petición de impresión, tal como el
estado de la petición, el nombre del usuario de la persona que envió la petición, el
nombre de la máquina que lo envió, el número de trabajo, etc.
Para ver una lista de los trabajos de impresión en el spool de impresión desde el
intérprete de comandos, escriba el comando lpq. Las últimas pocas líneas de la
salida de este comando, serán similares a lo siguiente:
Rank Owner/ID Class Job Files Size Time
active user@localhost+902 A 902 sample.txt 2050 01:20:46
Si desea cancelar un trabajo de impresión, encuentre el número del trabajo de la

petición con el comando lpq y luego use el comando lprm y el número de trabajo.
Ejemplo:

# lprm 902
Para borrar todos los trabajos ejecute el comando:

# lprm -
Deshabilitando las impresoras y las colas de impresión
Los comandos enable y disable puede ser utilizado para controlar la impresión de
los trabajos en la cola de impresión. La sintaxis del comando es la siguiente:
/usr/bin/disable destino(s)
/usr/bin/enable destino(s)
Las colas de impresión deshabilitadas aún aceptarán solicitudes de impresión pero

no comenzarán a imprimir hasta que sean habilitadas.
Los comandos accept y reject permiten o deniegan trabajos de impresión. La

sintaxis del comando es:
reject destinos(s)
accept destino(s)
Con el comando reject la impresora no aceptará nuevos trabajos de impresión

hasta que se ejecute el comando accept nuevamente.
Utilice el comando lpc stat para identificar el estado de la impresora:
# lpc stat
hp2100:
printer is on device 'lpd' speed -1
queuing is enabled
printing is enabled
no entries
daemon present
# disable hp2100
# lpc stat
hp2100:
queuing is enabled
printing is disabled
no entries
daemon present
# lpc stat
hp2100:
queuing is disabled
printing is disabled
no entries
daemon present
En el ejemplo podemos observar que primeramente se detiene la cola de

impresión, luego se detiene la recepción de nuevos trabajos de impresión.
Compartir una impresora
La habilidad de la Herramienta de configuración de impresoras de compartir las

opciones de configuración sólo puede ser usada si está usando el sistema de
impresión CUPS.
El permitir a otros usuarios en un computador diferente en la red imprimir a una

impresora configurada para su sistema se llama compartir la impresora. Por
defecto, las impresoras configuradas con la Herramienta de configuración de
impresoras no están compartidas.
Para compartir una impresora configurada, arranque la Herramienta de

configuración de impresoras y seleccione una impresora desde la lista. Luego
seleccione Acción => Compartir desde el menú desplegable.
En la pestaña Cola, seleccione la opción para hacer la cola disponible a otros

usuarios.
Opciones de la cola
Después de seleccionar compartir la cola, por defecto, todas las máquinas pueden
imprimir a la impresora compartida. Permitir a todos los sistemas en la red imprimir
a la cola puede ser un poco peligroso, especialmente si el sistema está
directamente conectado a la Internet. Se recomienda que esta opción sea
cambiada seleccionando la entrada Todas las máquinas y haciendo clic en el botón
Modificar.
La pestaña General establece configuraciones para todas las impresoras,

incluyendo aquellas que no son visualizadas con la Herramienta de configuración
de impresoras. Hay dos opciones:
● Encuentra automáticamente colas compartidas remotas Seleccionada

como predeterminada, esta opción activa la navegación IPP, lo cual significa
que cuando otras máquinas en la red difunden las colas que tienen, las colas
son automáticamente agregadas a la lista de impresoras disponibles en el
sistema; no se requiere configuración adicional para una impresora que es
encontrada desde la navegación IPP. Esta opción no comparte
automáticamente las impresoras configuradas en el sistema local.
● Activar el protocolo LPD Esta opción permite a la impresora recibir

trabajos de impresión de clientes configurados para usar el protocolo LPD
usando el servicio cups-lpd, el cual es un servicio xinetd.

El demonio crond
Crond es el demonio cron que se utiliza para la programación de tareas periódicas

con un margen mínimo de un minuto, tanto de administración del sistema como
propias de cualquier usuario.
El demonio cron se inicia o se detiene como cualquier otro servicio del sistema de
la distribución correspondiente, por ejemplo:
/etc/rc.d/initd/crond start|stop|restart
service crond start|stop|restart
aunque lo habitual es que se lance automáticamente al arrancar el sistema

operativo.
Los ficheros de configuración de los distintos usuarios se almacenan en el

directorio /var/spool/cron y un fichero de configuración del sistema llamado
/etc/crontab. Cuando el demonio cron, llamado crond, está activo comprueba con
minuto de frecuencia si hay alguna modificación de algún fichero de configuración o
algún proceso que lanzar y en caso afirmativo lo ejecuta. Cron toma la salida del
proceso, estándar y de errores, y se la envía al usuario correspondiente, a root en
caso del crontab del sistema. Si queremos cambiar el usuario que recibe este
mensaje de correo podemos utilizar la variable MAILTO.
Configuración de crontab
Cada usuario puede tener y gestionar su propio fichero de configuración para cron.
Bueno, hay dos ficheros, /etc/cron.allow y /etc/cron.deny donde se pueden poner
restricciones. En caso de existir el fichero /etc/cron.allow, sólo los usuarios
incluidos en este fichero podrán disponer de un crontab propio. Si no existe
/etc/cron.allow pero sí existe un fichero /etc/cron.deny, cualquier usuario incluido
en este último fichero no podrá disponer de fichero contab propio. Si existen
ambos, cron.allow prevalecerá. Si no existen ninguno, todos pueden usar el
demonio cron.
Los ficheros de configuración de crontab no están diseñados para editarse

directamente por el usuario; aunque son ficheros de texto estos ficheros se
modifican mediante la orden crontab. La orden crontab se puede utilizar como:
crontab [ -u usuario ] fichero
crontab [ -u usuario ] { -l | -r | -e }
Las opciones son:

-u Se utiliza para indicar el usuario cuyo crontab queremos
gestionar. Evidentemente sólo root podrá usar la orden crontab
con esta opción. La ausencia de esta opción supone que es el
usuario que ejecuta la orden el que gestiona su propio crontab.
-l Muestra el crontab activo en la salida estándar.
-r Elimina el crontab
-e Se usa para crear y editar el crontab activo mediante el editor
especificado en las variables de entorno EDITOR. El crontab
modificado se instala automáticamente al salir del editor
guardando los cambios.
Crontab predeterminados
Los sistemas, para facilitar la programación de tareas de administración, disponen

de un crontab estándar que permite ejecutar tareas cada hora, cada día, cada se
mana o cada mes; se crea un directorio para cada una de estas tareas y todos los
ficheros ejecutables que pongamos allí, normalmente guiones de shell, se
ejecutarán automáticamente. Los directorios en cuestión son, /etc/cron.hourly,
/etc/cron.dail, /etc/cron.weekly y /etc/cron.monthly.
El fichero /etc/crontab que ejecuta los contenidos de estos directorios quedaría

como:
01 * * * * root run-parts /etc/cron.hourly
02 4 * * * root run-parts /etc/cron.daily
22 4 * * 0 root run-parts /etc/cron.weekly
42 4 1 * * root run-parts /etc/cron.monthly
La heramienta tmpwatch
La herramienta tmpwatch permite borrar archivos que no han sido accedidos durante
un periodo de tiempo dado. Utiliza el demonio crond para ejecutarse diariamente y
el archivo de script de tmpwatch puede ser localizado en el directorio
/etc/cron.daily. Puede modificar el script tmpwatch en este directorio según su
necesidad.
La sintaxis del comando tmpwatch es la siguiente:
tmpwatch [-u|-m|-c] [-faqstv] [--verbose] [--force] [--all] [--test] \

[--fuser ] [--atime|--mtime|--ctime] [--quiet] <hours> <dirs>
Las opciones son:

-u, --atime Decide si se deben borrar los archivos en base al tiempo de
acceso. Esta es la opción por defecto.
-m, --mtime Decide si se deben borrar los archivos en base al tiempo de
modificación del archivo.
-c, --ctime Decide si se deben borrar los archivos en base al tiempo de
modificación del inodo.
-a, --all Remueve todos los tipos de archivos, no sólo regulares y
directorios.
-d, --nodirs No remover directorios.
-f, --force Remover aún sin permiso de escritura.
-t, --test No remover los archivos.
-s, --fuser Verifica con el comando fuser si los archivos están siendo
utilizados.
-v, --verbose Muestra información detallada.
Ejemplo del archivo /etc/cron.daily/tmpwatch:
/usr/sbin/tmpwatch 240 /tmp /var/tmp
Este archivo se ejecutará diariamente y verificará todos los archivos y directorios en

los directorios /tmp y /var/tmp. Si los archivos no fueron accedidos desde hace 240
horas, serán borrados.
El servicio Syslog
Una de las posibilidades que existen para detectar problemas en un sistema

operativo, sea este servidor o no, es a través de las trazas o logs que generan las
distintas aplicaciones que en él se ejecutan, incluyendo el propio kernel. Una traza
no es más que un mensaje breve que normalmente va acompañado de la fecha y
hora en que se produce, el nombre de la máquina donde se produce y el programa
que la origina.
Las trazas se pueden clasificar de acuerdo a su importancia. Algunas son

puramente informativas como pueden ser aquellas que avisan que un servicio
inició; mientras que otras, en cambio, pueden indicar una emergencia grave, como
puede ser un fallo físico en algún dispositivo.
En Linux el programa que implementa el servicio de trazas se nombra Syslog. Este

es un producto portado para varias plataformas Unix. En el caso de Linux funciona

a través de un par de demonios nombrados syslogd, que se encarga de las trazas

generales, y klogd, que manipula las trazas del kernel. El servicio permite almacenar
las trazas en ficheros (agrupados en el directorio /var/log), mostrarlas a través de
una terminal, enviarlas a otra máquina donde se ejecute syslogd, entre otras
posibilidades. En Linux también existe un poderoso mecanismo que permite la
rotación de las trazas guardadas en ficheros.
El script de inicio que manipula los demonios del servicio de trazas es

/etc/rc.d/init.d/syslog. Puede controlar el servicio utilizando el comando service:
service syslog start|stop|restart|reload
Para permitir la recepción de los logs de otras máquinas se debe ejecutar el

demonio con la opción -r. Para ello se podrá modificar el script
/etc/rc.d/init.d/syslog y luego reiniciar el demonio a través del propio script.
Configuración de Syslog
El fichero de configuración principal del servicio de logs es /etc/syslog.conf. Cada

entrada en este fichero consta de dos campos: el selector y la acción separados
por espacios. El selector a su vez se divide en la facilidad y la prioridad que se
separan por un punto. La facilidad indica el subsistema que produce el log y la
prioridad indica cuan importante es este. Todos los logs de una prioridad
específica o mayor se tratan bajo la misma acción, aunque esto se puede adecuar
en la versión actual del daemon. El campo acción indica a donde se enviarán los
logs. Como se expresó anteriormente, no siempre las trazas van a parar a un
fichero, también puede ser a una terminal, una máquina específica, un conjunto de
usuarios o a todos los usuarios conectados.
Sintácticamente el fichero de configuración del sistema de trazas posee las

siguientes reglas:
● Los comentarios, como casi siempre, van precedidos por “#”.
● Una línea se puede truncar utilizando “\”.
● El selector se separa de la acción mediante espacios.
● La facilidad se separa de la prioridad por un punto.
● Varios selectores para una misma acción se separan por “;”. En este caso
cada selector sobrescribe al anterior en la lista que se refiera a la misma
facilidad.
● Para indicar todas las facilidades o todas las prioridades se emplea “*”.
● Varias facilidades para una misma prioridad se separan por “,”.

● La prioridad especial none indica que no se haga ninguna acción para esa
facilidad.
● Para indicar que una acción se refiere sólo a la prioridad especificada y no a

las mayores que ella se coloca un signo “=” delante de la prioridad.
● Para indicar que una acción se refiere a todas con excepción de una
prioridad se coloca esta precedida de un signo “!”.
● Para indicar en la acción una máquina se precede el nombre de esta con

“@”.
● Para separar una lista de usuarios en la acción se utiliza “,”.
● Para indicar la acción “todos los usuarios conectados” se emplea “*”.
Las facilidades y su utilización
Facilidades Descripción
auth,authpriv Mensajes de seguridad y autorización.
cron Mensajes de los daemons at y cron.
daemon Mensajes del resto de los daemons.
kern Mensajes del kernel.
lpr Mensajes del subsistema de impresión.
mail Mensajes del subsistema de correo electrónico.
news Mensajes del subsistema de noticias.
security Es igual a auth. Se encuentra en desuso.
syslog Mensajes del propio subsistema de logs.
user Mensajes genéricos de los usuarios.
uucp Mensajes del subsistema UUCP.
Local0 - local7 Reservadas para uso local.
Las prioridades
Prioridades Descripción
debug Mensajes de depuración de un programa.
info Mensajes informativos.

Prioridades Descripción
notice Mensajes de sucesos significativos pero normales.
warning Mensajes de advertencia.
warn Es igual a warning. Está en desuso.
err Mensajes de error.
crit Mensajes que indican condiciones críticas.
alert Mensajes de alerta. Se debe emprender una acción al
momento.
emerg El sistema se ha vuelto inoperable.
panic Es igual a emerg. Está en desuso.
Acciones
El campo acción es una regla que describe el término abstracto “archivo log”. Un
archivo log puede no ser un archivo real. Es posible especificar las siguientes
acciones:
● Archivo regular: Los mensajes son registrados en archivos reales. El

archivo se especifica utilizando una ruta absoluta, iniciando con /.
Si especifica el archivo con un signo menos delante, se omite la

sincronización del archivo luego de cada registro. Tenga en cuenta que
puede perder información si el sistema cae justo antes de un intento de
escritura.
● Terminal o consola: Si el archivo especificado es un tty, entonces los

mensajes son enviados a esa terminal, lo mismo sucede con el archivo
especial /dev/console.
● Equipo remoto: Para enviar mensajes a otro host, anteponga al nombre de

host el signo @. El host remoto debe estar configurado para aceptar
mensajes de otros hosts, esto se hace configurando el archivo
/etc/sysconfig/syslog, para indicar al demonio syslog que inicie con la opción
-r.
● Lista de usuarios: Es posible especificar uno o mas usuarios separados por

coma, Si han iniciado sesión en el sistema, visualizarán el mensaje. Esto no
es un mensaje de correo electrónico.
● Todos los usuarios del sistema: Los mensajes de emergencia son

enviados frecuentemente a todos los usuarios. Para especificar esto, utilice
un asterisco (*).

A continuación se muestran algunos ejemplos:

kern.* /var/log/kernel
kern.crit @sion.redhat.com.py
kern.crit /dev/console
kern.info;kern.!err /var/log/kernel-info
lpr.* /var/log/lpr
*.=info;*.=notice;\
mail,news, lpr.none /var/log/messages
*.alert root,pepe
*.=emerg *
*.warning /var/log/warnings
*.* /dev/tty12
Comunicación con Syslog
Una de las formas de utilizar el servicio Syslog para manipular las trazas de
nuestras aplicaciones es a través del comando logger. Este constituye una interfaz
para comunicarse con el demonio, pues permite enviar mensajes especificando su
contenido y un selector, para que Syslog los manipule de acuerdo a su
configuración.
Sintaxis: logger [opciones] <mensaje>
Algunas opciones:
-p <selector> Permite indicar el selector, o sea el par <facilidad>.<prioridad>.
Por defecto es user.notice.
-t <marca> Permite asociarle al mensaje una marca o identificador. Por
defecto es la palabra logger.
-i Coloca además el ID del proceso logger que envía la traza.
Ejemplos:
# logger -p kern.info "La versión del kernel ha sido actualizada"
# logger -p mail.warning -t Prueba "Detuve el daemon sendmail. Pepe"

Rotación de las trazas del sistema
La herramienta que se utiliza para rotar las trazas en Linux es logrotate. Esta
permite la rotación automática, compresión, eliminación o envío por correo de los
ficheros de logs. Esta herramienta posee un fichero de configuración que por
defecto es /etc/logrotate.conf. En este se indican básicamente un conjunto de
acciones globales para todos los ficheros de trazas y un conjunto de acciones
particulares para cada fichero. Algunas de las acciones o directivas son:
compress Comprime el fichero una vez rotado. La
opuesta es nocompress.
copytruncate Trunca el fichero actual y comienza
nuevamente a escribir en él.
create [permisos] [dueño] [grupo] Después de la rotación se creará un fichero
nuevo con el mismo nombre que el anterior
especificando los permisos en notación
numérica, el dueño y el grupo. De no
especificarse alguno de estos campos se
asumirán los del fichero anterior.
daily, weekly, monthly Indican que la rotación se haga diaria,
semanal, o mensual, respectivamente.
errors <dirección> Se enviarán por correo los errores durante el
proceso de rotación a la dirección
especificada.
extension <ext> Se coloca la extensión especificada a los
ficheros después de la rotación. Si estos se
comprimen se añade además .gz.
notifempty Si el fichero está vacío no se rota. Por defecto
se hace lo opuesto (ifempty).
include <fichero | directorio> Permite incluir otros ficheros de configuración
o todos los contenidos en un directorio.
missingok Si el fichero de logs no existe se genera un
mensaje de error.
postrotate/endscript Todo lo que esté entre estas directivas se
ejecutará después de la rotación.
prerotate/endscript Todo lo que esté entre estas directivas se
ejecutará antes de la rotación.
rotate <n> El fichero será rotado n veces antes de ser
borrado.

size <n> El fichero se rotará cuando alcance el tamaño
n. Si se pone k después de n indicará que se
expresa el tamaño en kilobytes y M para
megabytes.
Ejemplos:
# rota por defecto semanalmente
weekly
# rota hasta cuatro veces cada fichero por defecto
rotate 4
# los errores se envían a root por defecto
errors root
# crea un nuevo fichero después de rotar el viejo
create
# no rota si está vacío el fichero a rotar
notifempty
# incluye todos los ficheros en este directorio
include /usr/etc/logrotate.other
# directivas para el fichero de logs /var/log/messages
/var/log/messages {
daily
errors pepe@disaic.colombus.cu
rotate 5
postrotate
/usr/bin/killall -HUP syslogd # envía la señal HUP al daemon syslog
endscript
}
# directivas para el fichero de logs hipotético /var/log/mylogs

/var/log/mylogs {
compress
rotate 3
size 100k
postrotate
/etc/rc.d/init.d/my_script reload > /dev/null
endscript
}
Existe una tarea cron diaria que se encarga de rotar las trazas a través del
comando logrotate. Para verla puede hacerse:
# cat /etc/cron.daily/logrotate
En el fichero /var/lib/logrotate.status se almacena la fecha en que se rotó cada

fichero de log por última vez. Ejemplo:
# less /var/lib/logrotate.status
logrotate state -- versión 2
"/var/log/messages" 2001-6-15
"/var/log/secure" 2001-6-15
"/var/log/maillog" 2001-6-15

Administrando copias de seguridad
Una de las tareas más comunes del administrador de sistemas es ayudar a los
usuarios a recuperar archivos perdidos o dañados. Para cumplir esta tarea
efectivamente debe establecer procedimientos de copias de seguridad de archivos
en intervalos regulares y frecuentes.
Salvando datos
Es importante que todos los archivos, tanto de sistema como de usuarios, sean
protegidos ante pérdidas. Por tanto debería hacer una copia de seguridad de todo
el sistema. La mayoría de los archivos son estáticos, no varían frecuentemente y
no existe necesidad de salvarlos tan frecuentemente como los archivos de datos,
los cuales son dinámicos y cambian constantemente.
La copia de seguridad de cada sistema de archivos es un sólo proceso. Para

facilitar el proceso de backup, organize sus sistemas de archivos de tal forma a que
archivos dinámicos están en sistemas de archivos independientes y son salvados
regularmente, y los archivos estáticos están en sistemas de archivos que son
salvados ocasionalmente.
STAR – Unique Standard Tape Archiver
La herramienta star es un comando de copias de seguridad muy veloz parecido al

tar, con mayores funcionalidades.
El comando star archiva y extrae múltiples archivos de y a un único archivo

llamado “archivo tar” o tarfile. Un archivo tar es normalmente un dispositivo de
cinta, pero puede ser cualquier archivo.
Características del comando star
El star soporta cabeceras extendidas tar, que definen un nuevo estándar para ir
mas allá de las limitaciones del formato tradicional tar. Esto permite entre otras
cosas, almacenar todas las marcas de tiempo, archivos de tamaño arbitrario y
archivos sin limitaciones del tamaño en el nombre .
Por defecto utiliza una tubería FIFO para optimizar el flujo de datos desde/hacia el
dispositivo de cinta. Esto permite mantener al dispositivo de cinta en movimiento
durante toda la copia de seguridad.
Soporta el archivado y restauración de Listas de Control de Acceso (ACL) de

archivos.

Soporta el archivado y restauración del contexto de seguridad de archivos en

sistemas con SELinux habilitado.
Es en un gran porcentaje (aproximadamente 25%) mas rápido el el tradicional tar.
Realizando una copia de seguridad
Para realizar una copia de seguridad de un directorio o sistema de archivos, se

utiliza el comando star con la opción -c (Create). En su forma mas simple, la
sintaxis del comando seria:
star -c f=nombre_archivo_tar archivo1 directorio1 ... archivoN directorioN
El destino especificado con la opción f= puede ser un archivo en disco o un

dispositivo de cinta. En linux, el nombre del dispositivo de cinta es normalmente
/dev/st0. Por ejemplo, para realizar una copia de seguridad de directorios a un
archivo debera ejecutar el siguiente comando:
# star -c f=/tmp/aplicaciones.star /prod/aplicaciones /dev/aplicaciones
El comando anterior archivara el contenido de los directorio /prod/aplicaciones y

/dev/aplicaciones en el archivo tar /tmp/aplicaciones.star.
Para verificar el contenido de una copia de seguridad realizada con star, se utiliza
la opción -t (table of contents). Para listar el contenido del archivo tar creado en
el ejemplo anterior seria:
# star -t f=/tmp/aplicaciones.star
Para restaurar un archivo contenido en un archivo tar, debe utilizar la opción -x

(extract). Si no se especifica el archivo a extraer, se extraen todos los archivos
contenidos en el archivo tar, si se especifica un directorio, se extrae el directorio y
su contenido, si se especifica uno o mas archivos, solo se extraen los archivos.
Es importante resaltar que al especificar el nombre del archivo o directorio a

extraer, no debe indicar la barra inicial de los nombres de los archivos, debido a
que por defecto la barra inicial es removida durante la extracción, permitiendo
extraer el archivo relativamente al directorio donde se encuentra.
Por ejemplo:
Extraer todos los archivos existentes en un archivo tar:

# star -x f=/tmp/aplicaciones.star
Extraer un directorio y su contenido:

# star -x f=/tmp/aplicaciones.star prod/aplicaciones
Extraer un archivo especifico existente en un archivo tar:

# star -x f=/tmp/aplicaciones.star dev/aplicaciones/msgtas.c
Ahora que la sintaxis basica del comando star ha sido presentada, comenzaremos
la revision de las opciones que pueden especificarse al comando star. Para una
lista completa de las opciones, consulte la pagina del manual star(1).
-c Create. Crea un nuevo archivo tar
-t Table of contents. Lista el contenido de un archivo tar
-x Extract. Extrae el contenido de un archivo tar
-v Verbose. Incrementa el nivel de detalle de la operación,
generalmente utilizado para listar los archivos a medida que son
archivados.
-u Update. Permite agregar solo los archivos nuevos a un archivo
tar, actualizándolo en lugar de archivar todo nuevamente.
-acl Access Control List. Permite el archivado y recuperación de
las listas de control de acceso de los archivos.
bs= Block Size. Configura el tamaño de bloques de salida en bytes.
Puede especificar los valores agregando al numero las letras k
(kilo), m (mega).
C=dir Ejecuta la operación chdir(2) antes de archivar o extraer los
archivos tar.
-j Utiliza una tubería bzip2 al archivar o extraer los archivos.
list=<archivo> Obtiene la lista de archivos a ser archivados o extraídos desde
un archivo. El archivo especificado contiene una lista de
nombres de archivos, cada uno en una nueva linea.
-M, -xdev No desciende puntos de montaje. Esto es útil cuando se realizan
copias de seguridad de un sistema de archivos completo.
--multivol Permite dividir los archivos en múltiples volúmenes en caso de
ser necesario.
pattern= Especifica un patron de concordancia. Permite seleccionar o
excluir archivos de la lista de archivos.
-U Unconditional. Por defecto, un archivo mas viejo que se
encuentra en el archivo tar, no reemplazara al archivo mas
nuevo que se encuentra en disco.
-V Invierte el orden de la lista especificada en el patrón de

concordancia.
-z Utiliza una tubería gzip al archivar o extraer los archivos.
-xattr Almacena o extrae los atributos extendidos. Esto es necesario
en sistemas con SELinux habilitado.
-H=exustar Especifica el tipo de cabecera. Es necesario especificar esta
opción si se están almacenando o extrayendo atributos
extendidos o listas de control de acceso de archivos.
-p Restaura los archivos y directorios con sus permisos originales.
-/ No remueve la barra inicial de los nombres de archivos durante
una operación de extracción. Esto podria ser peligroso y
restaurar el archivo sobre el archivo original, en lugar de permitir
restaurarlo en una ubicación alternativa.
Ejemplos de utilización de las opciones del comando star
Es momento de utilizar eficientemente las opciones presentadas anteriormente, a

continuación se presentaran algunos ejemplos de utilización del comando star.
En este ejemplo, se realiza la copia de seguridad del directorio /oradata a un

dispositivo de cinta. Se habilita la opción de múltiples volúmenes y se especifica el
tamaño de bloques para ajustarse al valor optimo para el dispositivo de cinta,
redireccionando la salida y el error estándar a archivos de registro.
# star -cv –multivol bs=256k f=/dev/st0 /oradata
El siguiente ejemplo, realiza una copia de seguridad del directorio /app a un archivo
tar comprimido con bzip2.
# star -cjv f=/tmp/app.star.bz2 /app
En este ejemplo se lista el contenido del archivo creado anteriormente.

# star -tj f=tmp/app.star.bz2
El siguiente ejemplo, realiza una copia de seguridad de los archivos de zona de un

servidor DNS que tiene SELinux habilitado.
# star -cv -xattr -H=exustar bs=256k f=/dev/st0 /var/named
El siguiente ejemplo extrae todos los archivos contenidos en el dispositivo de cinta

al directorio /restore, de forma incondicional conservando los permisos de los
archivos.

# star -xpU f=/dev/st0 -C /restore
En este ejemplo, se utiliza un patron de concordancia para extraer archivos que

comienzan con z que se encuentran en el directorio app del dispositivo de cinta, el
carácter especial asterisco “*” debe ser escapado con la barra invertida.
# star -xpU f=/dev/st0 pattern=app/z\*
En el siguiente ejemplo, se hace una copia de seguridad del sistema de archivos

raíz, sin respaldar los sistemas de archivos montados.
# star -cv -xdev bs=256k f=/dev/st0 /
Realizando copias de seguridad incrementales
En la mayoría de los sistemas, el intervalo de copia es diario, pero puede

seleccionar cualquier otro intervalo de tiempo. No es necesario salvar todos los
archivos en un sistema de archivos en cada copia, es posible copiar sólo aquellos
que han cambiado desde la copia previa. Esto es conocido como copias de
seguridad incrementales.
Con la herramienta star, puede realizar nueve niveles de copias de seguridad

incrementales. Por ejemplo, mientras en nivel 0 copia todo un sistema de archivos,
el 1 copia solo los archivos que cambiaron desde el último nivel 0, y un nivel 7
copia solo los archivos que cambiaron desde la última copia 6.
Puede organizar una estrategia de copias como la siguiente:
Dom Lun Mar Mier Jue Vie Sab
0 1 2 3 4 5 6
Cada domingo realiza una copia completa del sistema, y diariamente una copia de
los archivos que cambiaron desde la copia del día anterior. Esto reduce el tiempo
de copia de seguridad. Sin embargo, si es necesario restaurar el sistema, deben
ser restauradas todas las copias en orden a partir del 0. Esto incrementa el tiempo
de restauración que generalmente es mas crítico que el tiempo de copias de
seguridad.
Para realizar copias de seguridad incrementales con el comando star, es necesario

utilizar la opción level=N, siendo N un numero indicando el nivel de la copia de
seguridad, así como la opción wtardumps.
Para crear una copia de seguridad nivel 0, ejecute el siguiente comando:

# star -c -xdev -sparse -acl -link-dirs level=0 -wtardumps f=nombre_archivo_tar \

-C /punto_de_montaje
Para crear copia de seguridad nivel 1, ejecute el siguiente comando:

# star -c -xdev -sparse -acl -link-dirs level=1 -wtardumps f=archivo_tar \
-C /punto_de_montaje
La restauración debían realizarse en un sistema de archivos vacío. El proceso de

restauración inicia con la restauración de la última copia de seguridad nivel 0.
Luego es necesario restaurar la última copia incremental de cada nivel en orden
ascendente.
Para extraer la copia de seguridad nivel 0 ejecute:

# cd /punto_montaje
# star -xpU -restore f=archivo_tar
Para extraer la copia de seguridad nivel 1 ejecute el mismo comando:

# cd /punto_montaje
# star -xpU -restore f=archivo_tar
Así sucesivamente hasta restaurar todas las copias incrementales de cada nivel
existente.
Haciendo copias de seguridad remotas
Es posible utilizar star en conjunto con ssh para realizar copias de seguridad a
traves de la red. Primero deberá configurar la variable de entorno RSH para indicar
que el método de conexión al servidor remoto es ssh. Luego, deberá indicar el
nombre del archivo tar destino, de la siguiente forma:
f=usuario@host.dominio:/archivo_tar
Por ejemplo, para realizar una copia de seguridad del sistema de archivos /oracle a
través de la red utilizando ssh, al servidor host.domain en el directorio /backup,
ejecute el siguiente comando:
# env RSH=/usr/bin/ssh star -cvM f=usuario@host.dominio:/backup/oracle.star
/oracle
Para listar el contenido de un archivo tar que se encuentra en un host remoto

ejecute el siguiente comando:
# env RSH=/usr/bin/ssh star -cvM f=usuario@host.dominio:/backup/oracle.star
Para restaurar la copia de seguridad, ejecute el comando:

# cd /oracle
# env RSH=/usr/bin/ssh star -xv f=usuario@host.dominio:/backup/oracle.star

7
Gestores de arranque y autoinstalación

Antes de poder ejecutar Red Hat/Fedora Linux, debe ser cargado en memoria por
un programa especial llamado gestor de arranque. El programa de gestor de
arranque existe en el disco duro primario del sistema (o en otros dispositivos) y es
responsable de la carga del kernel de Linux con sus archivos necesarios, o, en
algunos casos, de otros sistemas operativos en la memoria.
Cada arquitectura de sistemas que pueda ejecutar Red Hat Linux usa un gestor de
arranque diferente. Por ejemplo, la arquitectura Alpha usa el gestor de arranque
aboot, mientras que la arquitectura Itanium usa el gestor de arranque ELILO.
Este capítulo explica comandos y opciones de configuración para los cargadores

de arranque suministrados con Red Hat Linux para la arquitectura x86: GRUB.
GRUB
GNU GRand Unified Boot loader o GRUB es un programa que habilita al usuario
a seleccionar qué sistema operativo instalado o kernel descargar en el momento de
arranque del sistema. Permite también que el usuario transmita argumentos al
kernel.
Proceso de arranque en un sistema x86 y GRUB
Esta sección explica con más detalle el papel específico que desempeña GRUB al
arrancar un sistema x86.
GRUB se carga a sí mismo en la memoria en las diferentes etapas:
● La etapa 1 o cargador de arranque primario se lee en la memoria con el

BIOS desde el MBR[1].El gestor de arranque primario existe en menos de
512 bytes de espacio en disco entre el MBR y es capaz de cargar bien sea
la etapa 1.5 o la etapa 2 del gestor de arranque.
● El gestor de arranque de la etapa 1 lee en la memoria al gestor de arranque

de la etapa 1.5. si es necesario Determinado hardware requiere un paso
intermedio para obtener el cargador de arranque de la etapa 2. Esto sucede
a menudo cuando la partición /boot está por encima de 1024 cilindros de
disco duro o cuando se usa el modo LBA. Este cargador de arranque de la
etapa 1.5 se encuentra en la partición /boot o en una pequeña parte del
MBR y la partición /boot.
● La etapa 2 o el gestor de arranque secundario se lee en la memoria. El

gestor de arranque secundario visualiza el menú GRUB y el entorno del

comando. Esta interfaz le permite seleccionar qué sistema operativo o kernel
de Linux arrancar, pasar argumentos al kernel o ver los parámetros del
sistema, tales como la RAM disponible.
● El gestor de arranque secundario lee el sistema operativo o el kernel y initrd

en la memoria. Una vez que GRUB determina qué sistema operativo iniciar,
éste lo carga en la memoria y transfiere el control de la máquina a dicho
sistema operativo.
El método de arranque usado para arrancar Red Hat Linux se conoce como
método de carga directa porque el gestor de arranque carga el sistema operativo
directamente. No existe punto medio entre el gestor de arranque y el kernel.
El proceso de arranque usado por otros sistemas operativos puede variar. Por
ejemplo, los sistemas operativos de Microsoft DOS y Windows, así como otros
sistemas operativos de propietarios, se cargan mediante un método de arranque de
carga encadenada. Bajo este método, el MBR señala el primer sector de la
partición que tiene el sistema operativo. Allí encuentra los archivos necesarios para
arrancar el sistema operativo.
GRUB soporta ambos métodos de arranque, directo y carga encadenada,

permitiendo arrancar desde casi cualquier sistema operativo.
Funciones de GRUB
GRUB contiene una serie de funciones que lo convierten en el método favorito

respecto al resto de gestores de arranque disponibles para la arquitectura x86. A
continuación tiene una lista de las características más importantes:
GRUB proporciona un entorno pre-OS basado en comandos verdaderos para

máquinas x86. Esto proporciona una flexibilidad máxima en la carga de los
sistemas operativos con determinadas opciones o con la recopilación de
información sobre el sistema. Durante muchos años arquitecturas que no son x-86
han usado entornos previos al sistema operativo que permiten arrancar el sistema
desde una línea de comandos.
GRUB soporta el modo Direccionamiento Lógico de Bloques (LBA). El modo LBA

coloca la conversión de direccionamiento utilizada para buscar archivos en la
unidad de disco duro del firmware y se utiliza en muchos discos IDE y en todos los
discos duros SCSI. Antes de LBA, los gestores de arranque encontraban la
limitación del cilindro 1024 del BIOS, donde el BIOS no podía encontrar un archivo
después de ese cabezal de cilindro del disco. El soporte LBA permite que GRUB
arranque los sistemas operativos desde las particiones más allá del límite de 1024
cilindros, siempre y cuando el BIOS del sistema soporte el modo LBA. Las
revisiones más modernas de la BIOS soportan el modo LBA.

GRUB puede leer las particiones ext2. Esto permite que GRUB acceda a su archivo
de configuración, /boot/grub/grub.conf, cada vez que el sistema arranca,
eliminando la necesidad que tiene el usuario de escribir una nueva versión de la
primera etapa del gestor de arranque al MBR en caso de que se produzcan
cambios de la configuración. El único caso en el que el usuario necesitaría
reinstalar GRUB en el MBR es en caso de que la localización física de la partición
/boot se traslade en el disco.
Terminología de GRUB
Una de las cuestiones más importantes que deben entenderse antes de utilizar
GRUB es cómo el programa hace referencia a los dispositivos, por ejemplo, a los
discos duros y a las particiones. Esta información es muy importante si desea
configurar GRUB para arrancar varios sistemas operativos.
Nombres de dispositivos
Suponga que un sistema tiene más de un disco duro. El primer disco duro del
sistema es llamado (hd0) por GRUB. La primera partición en ese disco es llamada
(hd0,0), y la quinta partición en el segundo disco duro es llamada ( hd1,4). En
general, la nomenclatura utilizada para los sistemas de archivos al usar GRUB se
desglosa del siguiente modo:
(<tipo-dispositivo><numero-dispositivo-bios>,<numero-particion>)
Los paréntesis y las comas son muy importantes en el nombre.
● <tipo-dispositivo> hace referencia a si es un disco duro (hd) o una unidad de

disquete (fd).
● <número-dispositivo-bios> es el número de dispositivo según la BIOS del

sistema, empezando desde 0. El orden es aproximadamente equivalente al
modo en el que el kernel de Linux organiza los dispositivos con letras, donde
la letra a en hda corresponde al número 0, y la letra b en hdb corresponde al
número 1, y así sucesivamente.
● <número-partición> hace referencia al número de una partición concreta en

dicho dispositivo. Al igual que en el caso de <número-dispositivo-bios>, la
numeración de las particiones empieza por 0.
Nomenclatura de dispositivos en GRUB
GRUB usa las reglas siguientes para denominar los dispositivos y las particiones
No es relevante si los discos duros que utiliza son IDE o SCSI. Todos los discos
duros empiezan con hd. Las unidades de disquete empiezan con fd.

Para especificar todo un dispositivo sin respetar sus particiones, simplemente debe
suprimir la coma y el número de partición. Esto es importante para indicarle a
GRUB que configure el registro MBR para un disco concreto. Por ejemplo, (hd0)
especifica la MBR en el primer dispositivo y (hd3) especifica la MBR en el cuarto
dispositivo.
Si tiene varios discos duros, es muy importante saber el orden de la unidad de

arranque de la BIOS. Esto es muy sencillo si sólo tiene discos IDE o SCSI, pero si
tiene una combinación de ambos, el asunto se complica un poco.
Nombres de archivos y listas de bloques
Al escribir comandos en GRUB que hagan referencia a un archivo, como una lista
de menús que debe usarse para permitir el arranque de varios sistemas operativos,
debe incluir el archivo inmediatamente después de especificar el dispositivo y la
partición.
Una especificación de archivo de ejemplo que haga referencia a un nombre de

archivo absoluto se organiza del modo siguiente:
(<tipo-dispositivo><numero-dispositivo-bios>,<numero-particion>)/ruta/al/archivo
La mayoría de las veces, un usuario especificará los archivos por la ruta del
directorio en esa partición más el nombre del archivo.
También puede especificar archivos a GRUB que no aparecen realmente en el

sistema de archivos, tal como un gestor de arranque de cadena que aparece en los
primeros bloques de la partición. Para especificar estos archivos, deberá indicar
una lista de bloques, que indique a GRUB, bloque por bloque, la ubicación exacta
del archivo en la partición. Puesto que un archivo puede estar formado por varios
conjuntos de bloques, hay un modo específico de escribir listas de bloques. Cada
ubicación de sección de archivo se describe con un número de desplazamiento de
bloques seguido de un número de bloques de ese punto de desplazamiento, y las
secciones se colocan juntas de forma ordenada y separadas por comas.
La siguiente es una lista de bloques de ejemplo:

0+50,100+25,200+1
Esta lista de bloques indica a GRUB que debe utilizar un archivo que empieza en el
primer bloque de la partición y que usa los bloques del 0 al 49, del 99 al 124, y el
199.
Saber cómo escribir listas de bloques es útil al utilizar GRUB para cargar sistemas
operativos que usan el método de carga encadenada, como Microsoft Windows.
Puede suprimir el número de desplazamiento de bloques si empieza por el bloque

0. Por ejemplo, el archivo de carga encadenada de la primera partición del primer

disco duro tendrá el nombre siguiente:
(hd0,0)+1
Lo siguiente muestra el comando chainloader con una designación de lista de

bloques similar en la línea de comandos de GRUB después de establecer el
dispositivo correcto y la partición adecuada como raíz:
chainloader+1
Sistema de archivos raíz de GRUB
Algunos usuarios se confunden con el uso del término sistema de archivos en

GRUB. Es importante recordar que el sistema de archivos raíz de GRUB no tiene
nada que ver con el sistema de archivos raíz de Linux.
El sistema de archivos raíz de GRUB es la partición raíz de un dispositivo concreto.

GRUB usa esta información para montar el dispositivo y carga los archivos desde
el mismo.
Con Red Hat Linux, una vez que GRUB ha cargado la partición raíz (que es lo
mismo que la partición /boot y contiene el kernel de Linux), el comando kernel
puede ejecutarse con la localización del archivo del kernel como una opción. Una
vez que el kernel de Linux inicia, establece el sistema de archivos raíz con los
cuales los usuarios de Linux están familiarizados. El sistema de archivos root de
GRUB original y los montajes deben olvidarse en este punto; la única finalidad de
su existencia era arrancar el archivo del kernel.
Interfaces de GRUB
GRUB dispone de tres interfaces eficaces que proporcionan distintos niveles de

funcionalidad. Cada una de estas interfaces le permite arrancar el kernel de Linux u
otros sistemas operativos.
Las interfaces son como sigue:
● Interfaz de menú: Si el programa de instalación de Red Hat Linux ha

configurado automáticamente GRUB, ésta es la interfaz que ya conoce. En
esta interfaz hay un menú de sistemas operativos o kernels preconfigurados
con sus propios comandos de arranque en forma de lista ordenada por
nombre, después de arrancar el sistema por primera vez. Puede utilizar las
teclas de flecha para seleccionar una opción en lugar de la selección por
defecto y pulsar la tecla [Intro] para arrancar el sistema. Como alternativa, se
puede establecer un período de inactividad, de modo que GRUB inicie la
carga de la opción por defecto.

Presione la tecla [e] para entrar en la interfaz del editor o la tecla [c] para
cargar la interfaz de línea de comandos.
● Interfaz del editor de entrada del menú: Para tener acceso al editor de
entradas del menú, presione la tecla [e] desde el menú del gestor de
arranque. Los comandos de GRUB de dicha entrada se muestran aquí y
puede alterar estas líneas de comandos antes de arrancar el sistema
operativo agregando una línea de comandos ([o] inserta una nueva línea
después de la línea actual y [O] inserta una nueva línea antes de ella),
modificandola ([e]), o borrando una ([d]).
Una vez realizados los cambios, la tecla [b] ejecuta los comandos y arranca
el sistema operativo. Con la tecla [Esc] se omiten los cambios y el usuario
vuelve a la interfaz de menú estándar. Con la tecla [c] se carga la interfaz de
línea de comandos.
● Interfaz de línea de comandos: Esta es la interfaz de GRUB más básica,

pero también la que proporciona un mayor control. En esta interfaz puede
escribir cualquier comando de GRUB seguido de la tecla [Intro] para
proceder a la ejecución correspondiente. Esta interfaz cuenta con algunas
funciones similares a las de shell avanzadas, incluyendo el uso de [Tab]
para autocompletar, y las combinaciones de teclas con [Ctrl] al escribir
comandos, tales como [Ctrl]-[a] para moverse al comienzo de la línea y
[Ctrl]-[e] para moverse al final. Además, las teclas de flecha, [Inicio], [Fin],
y [Supr] funcionan de forma similar al bash shell.
Orden de uso de Interfaces
Cuando GRUB carga la segunda etapa de su gestor de arranque, primero busca

por su archivo de configuración. Cuando lo encuentra, lo utiliza para crear la lista
de menú y despliega la interfaz de menú.
Si no puede encontrar el archivo de configuración o si éste no se puede leer, GRUB

carga la interfaz de línea de comandos para permitirle al usuario escribir
manualmente los comandos necesarios para completar el proceso de arranque.
En el caso de que el archivo de configuración no sea válido, GRUB imprimirá el

error y solicitará la introducción de valores. Esto puede ser muy útil, porque podrá
ver con exactitud donde está el problema y corregirlo en el archivo. Si pulsa
cualquier tecla se volverá a cargar la interfaz de menú, donde podrá modificar la
opción de menú y corregir el problema según el error que GRUB haya notificado. Si
la corrección falla, GRUB informa del error y puede empezar de nuevo.
Comandos de GRUB

GRUB permite varios comandos en su línea de comandos. Algunos de los

comandos aceptan opciones después del nombre y estas opciones deben ir
separadas del comando por comas y de otras opciones de esa línea por caracteres
de espacio.
En la lista siguiente se indican los comandos más útiles:
boot Arranca el sistema operativo o gestor de
encadenamiento que se ha especificado y cargado
previamente.
chainloader <nombre-archivo> Carga el archivo especificado como gestor de
encadenamiento. Para extraer el archivo en el
primer sector de la partición especificada, puede
utilizar +1 como nombre de archivo.
displaymem Muestra el uso actual de memoria, en función de la
información de la BIOS. Esto es útil si no está
seguro de la cantidad de RAM que tiene un sistema
y todavía tiene que arrancarlo.
initrd <nombre-archivo> Le permite especificar un disco RAM inicial para
utilizarlo al arrancar. initrd es necesario cuando el
kernel necesita ciertos módulos para poder arrancar
adecuadamente, tales como cuando la partición se
formatea con el sistema de archivos ext3.
install Instala GRUB en la MBR del sistema.
kernel Indica la ruta al archivo kernel Linux
root <dispositivo-particion> Configura la partición raíz de GRUB para que sea el
dispositivo y la partición concreta, por ejemplo,
(hd0,0), y monta la partición de modo que se puedan
leer los archivos.
rootnoverify <dispositivo- Configura la partición raíz de GRUB para que sea el
particion>
dispositivo y la partición concreta, por ejemplo,
(hd0,0), y monta la partición de modo que se puedan
leer los archivos.
Para el sistema Red Hat Linux, es probable que tenga una línea similar a la
siguiente:
kernel /vmlinuz-<version> ro root=/dev/sda3
Esta línea especifica que el archivo vmlinuz se carga desde un sistema de archivos
raíz de GRUB, por ejemplo, (hd0,0). También se transfiere una opción al kernel que
especifica que el sistema de archivos raíz del kernel del Linux debe encontrarse, al
cargarse, en sda3, la tercera partición en el primer disco duro. Después de esta

opción se pueden indicar varias opciones del kernel, si es necesario.
Hay otros comandos disponibles aparte de los indicados. Escriba info grub para
obtener una lista completa de los comandos.
Archivo de configuración de menú de GRUB
El archivo de configuración /boot/grub/grub.conf, usado para crear la lista en la

interfaz de menú de GRUB de los sistemas operativos para el arranque,
básicamente permite al usuario seleccionar un grupo predefinido de comandos
para su ejecución.
Comandos especiales del archivo de configuración
Los comandos siguientes sólo pueden usarse en el archivo de configuración de

menú de GRUB:
color <normal> <selected> Le permite configurar los colores específicos que se
usarán en el menú. Se configuran dos colores: uno
de fondo y otro de primer plano. Use nombres de
colores simples, tales como red/black. Por ejemplo:
color red/black green/blue
default <nombre-título> Nombre del título por defecto de la entrada que se
cargará si se supera el tiempo de inactividad de la
interfaz de menú.
fallback <nombre-título> Si se utiliza, el nombre de título de la entrada que
deberá probarse si falla el primer intento.
hiddenmenu Si se utiliza, no se podrá mostrar la interfaz de menú
de GRUB ni cargar la entrada por defecto default si
caduca el período timeout. El usuario puede ver el
menú estándar de GRUB si pulsa la tecla [Esc].
password <contraseña> Si se utiliza, el usuario que no conozca la contraseña
no podrá modificar las entradas de esta opción de
menú.
timeout Si se utiliza se establece la cantidad de tiempo, en
segundos, antes de que GRUB cargue la entrada
designada por el comando default.
splashimage Especifica la ubicación de la imagen de pantalla de
fondo que se utilizará al arrancar.
title Establece el título que se utilizará con un grupo de
comandos concreto para cargar un sistema

operativo.
# Se puede usar al principio de una línea para insertar
comentarios en el archivo de configuración de menú.
Estructura del archivo de configuración
El archivo de configuración de menú de GRUB es /boot/grub/grub.conf. Los

comandos para configurar las preferencias globales para la interfaz de menú están
ubicados al inicio del archivo, seguido de las diferentes entradas para cada sistema
operativo o kernels listados en el menú.
El siguiente es un ejemplo de archivo de configuración de menú muy básico

diseñado para arrancar bien sea Red Hat Linux o Microsoft Windows 2003:
default=0
timeout=10
splashimage=(hd0,0)/grub/splash.xpm.gz
# Seccion de carga de Linux

title Linux (2.6.18-1.2798)
root (hd0,1)
kernel /vmlinuz-2.6.18-1.2798 ro root=/dev/sda3 rhgb quiet
initrd /initrd-2.6.18-1.2798.img
# Seccion de carga de Windows

title Windows 2003
rootnoverify (hd0,0)
chainloader(hd0,0)+1
Este archivo indicará a GRUB que cree un menú con Red Hat Linux como el
sistema operativo predeterminado y que establezca un arranque automático
después de 10 segundos. Se proporcionan dos secciones, una para cada entrada
de sistema, con comandos específicos para la tabla de partición de cada sistema.
Cambiar los niveles de ejecución en el tiempo de arranque
Bajo Red Hat Linux, es posible cambiar el nivel de ejecución predeterminado en el

momento de arranque.
Si está usando GRUB como gestor de arranque, siga los pasos siguientes:
En la pantalla gráfica del gestor de arranque GRUB, seleccione la etiqueta de

arranque Red Hat Linux y pulse [e] para editarla.
Vaya en la parte inferior a la línea del kernel y pulse [e] para editarla.

En el intérprete de comandos, escriba el número del nivel de ejecución en el que

desea arrancar (desde 1 a 5), o las palabras single o emergency y presione
[ENTER].
Volverá a la pantalla de GRUB con la información sobre el kernel. Pulse [b] para
arrancar el sistema.
Instalaciones Kickstart
Muchos administradores de sistemas prefirieren usar un método de instalación

automatizado para instalar Red Hat Linux en sus maquinas. Para cubrir esta
necesidad, Red Hat crea el método de instalación kickstart. Usando kickstart, un
administrador de sistemas puede crear un archivo conteniendo las respuestas a
todas las preguntas que normalmente se le preguntarán durante una instalación
típica de Red Hat Linux.
Los archivos kickstart se pueden mantener en un servidor de sistema único y ser

ledos por computadores individuales durante la instalación. Este método de
instalación puede soportar el uso de un slo archivo kickstart para instalar Red Hat
Linux en múltiples máquinas, haciéndolo ideal para administradores de sistemas y
de red.
Kickstart le permite automatizar la instalación de Red Hat Linux.
Cómo realizar una instalación de Kickstart?
Las instalaciones de Kickstart pueden realizarse usando un CD-ROM, un disco

duro local, o a través de NFS, FTP, o HTTP.
Para usar kickstart, debe:
● Crear un archivo kickstart.
● Crear un disquete de arranque con el archivo o hacer el kickstart disponible

en la red.
● Hacer el árbol de instalación disponible.
● Iniciar la instalación de kickstart indicando la opción apropiada durante el

inicio de la instalación.
Opciones de Kickstart
Exite una gran cantidad de opciones que pueden ser utilizadas en un archivo

Kickstart para indicar los valores a ser utilizados durante la instalación. Para un
detalle de todas las opciones, refiérase al manual Red Hat Enterprise Linux:
System Administration Guide.
Para simplificar la creación de un archivo kickstart puede utilizar un archivo

anaconda-ks.cfg de cualquier sistema existente y realizar los cambios apropiados a
este archivo.
Si prefiere usar una interfaz gráfica para la creación de su archivo kickstart, puede
usar la aplicación de configuración Kickstart, system-config-kickstart.
Usando el archivo kickstart
Para iniciar la instalación automática desde un disquete, copie el archivo kickstart

generado con el nombre ks.cfg a un disquete formateado con vfat. Luego inicie el
equipo con el cd de instalación o un disco de instalación y digite como opción de
arranque:
boot: linux ks=floppy
Configuración de un servidor de instalación
El servidor de instalación es un equipo Linux que actúa como servidor NFS y en el

recurso exportado se encuentran los archivos de instalación de Linux. Para
configurar un servidor de instalación usted necesitará un equipo con los siguientes
paquetes instalados:
● NFS (nfs-utils)
● DHCPD
Cree un directorio que contenga la estructura de directorio de los CDs de

instalación.
# mkdir /RedHat
# mount /dev/cdrom /media/cdrom
# cp -varf /media/cdrom/* /RedHat
Realice los mismos comandos para todos los CDs de instalación.
Las instalaciones NFS también pueden usar imágenes ISO para la instalación en
lugar de copiar el árbol de instalación. Luego de ubicar las imágenes requeridas en
un directorio en el servidor NFS, seleccione la instalación vía NFS. Deberá
entonces especificar al programa de instalación el directorio en el cual se
encuentran las imágenes para realizar la instalación.

Cree un directorio /RedHat/kickstart
# mkdir /RedHat/kickstart
Ejecute la herramienta system-config-kickstart. Cree un archivo de configuración

de instalación. Asegúrese de especificar el servidor y directorio NFS correctos.
Ejemplo:
#Generated by Kickstart Configurator
#System language
lang es_ES
#Language modules to install
langsupport --default=es_ES
#System keyboard
keyboard es
#System mouse
mouse --emulthree generic3ps/2
#Sytem timezone
timezone America/Asuncion
#Root password
rootpw --iscrypted $1$S4JF3R6X$KztfX/S8HcjepRnwB0eeD.
#Reboot after installation
reboot
#Use text mode install
text
#Install Red Hat Linux instead of upgrade
install
#Use NFS installation Media
nfs --server=192.168.24.1 --dir=/RedHat
#System bootloader configuration
bootloader --location=mbr
#Clear the Master Boot Record
zerombr yes
#Partition clearing information
clearpart --all --initlabel
#Disk partitioning information
part /boot --fstype ext3 --size 100 --asprimary
part swap --size 128 --asprimary
part / --fstype ext3 --size 1 --grow --asprimary
#System authorization infomation
auth --useshadow --enablemd5
#Network information
network --bootproto=dhcp --device=eth0
#Firewall configuration
firewall --disabled
#XWindows configuration information
xconfig --depth=24 --resolution=800x600 --defaultdesktop=GNOME
#Package install information
%packages --resolvedeps
@ X Window System
@ GNOME Desktop Environment
@ Editors
@ Graphical Internet
@ Text-based Internet
@ Office/Productivity
@ Authoring and Publishing
@ Server Configuration Tools
@ Administration Tools
@ System Tools

Salve el archivo en /RedHat/kickstart/ como ks.cfg.
Configuración del servidor NFS
Edite el archivo exports:

# vi /etc/exports
Agregue la siguiente lineas:

/RedHat *(ro,async)
Reinicie los servicios de NFS:

# service nfs restart
Cree un archivo /etc/dhcpd.conf apropiado
# vi /etc/dhcpd.conf
Ejemplo
ddns-update-style none;
option domain-name "redhat.com.py";
option routers 192.168.24.1;
option broadcast-address 192.168.24.255;
subnet 192.168.24.0 netmask 255.255.255.0 {}
filename "/RedHat/kickstart/";
next-server nfsinstall.redhat.com.py;
host pc01 {
hardware ethernet 00:c0:df:0d:0c:fe;
fixed-address 192.168.24.10;
option host-name "pc01.data.edu.py";
filename "/RedHat/kickstart/ks.cfg";
}
Note que debería reemplazar el valor en filename con el nombre del archivo
kickstart (o el directorio donde el archivo existe) y el valor de next-server con el
nombre del servidor NFS (No es necesario si el mismo servidor DHCP el servidor
NFS).
Si el nombre del archivo retornado por el servidor BOOTPD/DHCP termina en barra

(/), entonces es interpretado como una ruta, no como un archivo. En este caso, el
sistema cliente monta esa ruta usando NFS, y busca un archivo particular. El
nombre del archivo que el cliente busca es:
<ip-addr>-kickstart
Donde <ip-addr> es reemplazado por la dirección IP del cliente en notación decimal,

por ejemplo 192.168.24.30-kickstart.
Reinicie el servicio dhcpd:
# service dhcpd restart
Inicie los equipos que desea instalar con el CD 1 de instalación y en el prompt

digite:
linux ks
La instalación automática iniciara e instalará el sistema a través de la red.

8
Reconfiguración del kernel

Actualización del kernel
El kernel que viene con Red Hat Linux está personalizado por el equipo de
desarrollo del kernel de Red Hat para asegurar su integridad y compatibilidad con
el hardware soportado. Antes que Red Hat libere un kernel, debe pasar un conjunto
de evaluaciones rigurosas para asegurar su calidad.
Los kernels Red Hat Linux están empaquetados en formato RPM para as hacerlos
ms fácil de actualizar y verificar. Por ejemplo, cuando el paquete RPM kernel
distribuido por Red Hat, Inc. es instalado, una imagen initrd es creada; por lo tanto
no es necesario usar el comando mkinitrd después de instalar un kernel diferente.
También modifica el fichero de configuración del gestor de arranque para incluir el
nuevo kernel, tanto si se instala LILO o GRUB.
Preparación de la actualización
Red Hat Linux ahora se distribuye con el kernel 2.6. Las características de un
kernel tal como se distribuye con Red Hat Linux son:
● Asynchronous I/O: Las aplicaciones no deben pausar luego de emitir

mensajes de I/O de lectura hasta que éstas se completen.
● Granularidad SMP Incrementada: particularmente en el subsistema de I/O

SCSI . Permite mayor ancho de banda de I/O en sistemas SMP con múltiple
adaptadores de I/O.
● Mejoras en el SMP Scheduler: Mejora el rendimiento incrementando el hit-

rate de caché de CPU y reduciendo la contención en sistemas SMP con
mejoras en el bloqueo (spinlock).
● Eliminación Bounce Buffer: Reduce I/O relacionado a operaciones de

copia de memoria en sistemas con memoria > 1GB.
● Generic logical CPU Scheduler : Maneja cpu multi-núcleo y con

hypertheading.
● Object-based reverse Mapping VM: Aumenta el rendimiento en sistemas

de memoria limitada.
● Read Copy Update: Optimización del Algoritmo SMP para estructuras de

datos del sistema operativo.

● Soporte SMP y NUMA mejorado: Aumenta el rendimiento y la escalabilidad

para servidores grandes.
● Network interrupt mitigation (NAPI): Aumenta el rendimiento en sistemas

con altas cargas de red.
● Conforma con la Interface LSB (Linux Standard Base): soporta una API
Linux estándar
● Multiple mejoras para incrementar el rendimiento de bases de datos.
● Mejoras en los sistemas de archivos: Aumento del rendimiento en

sistemas de archivos ext3. Expansión dinámica de tamaños de sistemas de
archivos hasta 8 TB.
● Logical Volume Manager (LVM): Proporciona nuevas características tales

como snapshots de lectura/escritura y una herramienta de administración
GUI.
● Mayor segurdad: Soporte para control de acceso mandatorio (SELinux).
● Compatibilidad multimedia mejorada y soporte mejorado para USB.
Antes de actualizar el kernel, tome algunas precauciones. La primera es

asegurarse que tiene un disco de arranque en caso de que haya problemas. Si el
gestor de arranque no está configurado apropiadamente para arrancar el nuevo
kernel, no será capaz de arrancar su sistema a menos que tenga un disquete de
arranque.
Para crear una imágen de disco de arranque para su sistema, conéctese como
usuario root y en el intérprete de comandos teclee el siguiente comando:
# /sbin/mkbootdisk --iso --device <archivo.iso> `uname -r`
Queme la imagen iso en un CD-ROM y reinicie la máquina con el disco de

arranque. Verifique que funciona antes de continuar.
Para determinar cuáles paquetes del kernel están instalados, ejecute el comando
siguiente en el intérprete de comandos:
# rpm -qa | grep kernel
La salida contendrá alguno o todos de los siguientes paquetes, dependiendo del

tipo de instalación que haya realizado (el número de la versión puede variar).
De la anterior salida, puede determinar qué paquetes necesita descargar para

actualizar el kernel. El único paquete necesario para un sistema con un único
procesador es el kernel.

Si tiene un ordenador con más de un procesador, necesita el paquete kernel-smp

que contiene el soporte para más de un procesador y hasta 16 GB de memoria.
También se recomienda instalar el paquete kernel en el caso de que el kernel con
varios procesadores no funcione correctamente con el sistema.
Si tiene un ordenador con una memoria superior a 4 GB (y hasta 64 GB), necesita

el paquete kernel-hugemem para que el sistema pueda usar más de cuatro gigabytes
de memoria. De todas maneras, se recomienda instalar el paquete kernel por si
ocurriera algún error. El paquete kernel-hugemem existe sólo para la arquitectura
i686.
El paquete kernel-doc contiene documentación sobre desarrollo del kernel y no es

necesario. Se recomienda si el sistema es usado para desarrollos del kernel.
En el nombre del archivo, cada paquete del kernel contiene la arquitectura para la
cual el paquete fue construido. El formato es kernel-<variante>-<version>.<arq>.rpm
donde <variante> es smp, utils, etc, y <arq> es una de las siguientes:
● x86_64 para la arquitectura AMD64
● ia64 para la arquitectura Intel® Itanium™
● ppc64 para la arquitectura IBM® eServer™ pSeries™
● ppc64 para la arquitectura IBM® eServer™ iSeries™
● s390 para la arquitectura IBM® S/390®
● s390x para la arquitectura IBM® eServer™ zSeries®
● i686: Kernels x86 optimizados para distintos procesadores como Intel®

Pentium® II, Intel® Pentium® III, Intel® Pentium® 4, AMD Athlon®, and
AMD Duron® .
Realizando la actualización
Después de obtener todos los paquetes necesarios, es hora de actualizar el kernel

existente. En el intérprete de comandos de la shell como root, cámbiese al
directorio que contiene los paquetes RPM y siga los pasos.
Use siempre el argumento -i con el comando rpm para mantener el viejo kernel. Si
la opción -U es usada para actualizar el paquete kernel, se sobreescribirá el kernel
instalado actualmente (la versión del kernel y la versión x86 pueden variar):
# rpm -ivh kernel-<version>.i386.rpm
Si el sistema es un sistema multiprocesador, instale también los paquetes kernel-

smp (la versión del kernel y la versión x86 pueden variar):
# rpm -ivh kernel-smp-<version>.i686.rpm
Si el sistema contiene más de 16 GB de RAM, hasta 64 GB de RAM, deberá

instalar el paquete kernel-hugemem.
# rpm -ivh kernel-hugemem-<version>.i686.rpm
El próximo paso es verificar que la imagen del disco inicial RAM ha sido creada.
Verificación de la imagen de disco RAM inicial
Si el sistema usa un controlador SCSI o un sistema de archivos ext3, necesitará un

disco RAM inicial. El propósito de dicho disco es permitir a un kernel modular tener
acceso a los módulos que son necesarios para arrancar antes de que el kernel
tenga acceso a los dispositivos donde los módulos normalmente residen.
El disco RAM inicial puede ser creado con el comando mkinitrd. Sin embargo, este
paso es ejecutado automáticamente si el kernel y sus paquetes asociados son
instalados o actualizados desde los paquetes RPM distribuidos por Red Hat, Inc.;
por tanto, no necesita ser ejecutado manualmente. Para verificar que fue creado,
use el comando ls -l /boot para asegurarse de que el archivo initrd-<version>.img
fue creado (la versión debería coincidir la versión del kernel que acaba de instalar).
Ahora que ya tiene instalado el nuevo kernel, necesita verificar que el gestor de
arranque está configurado para cargar el nuevo kernel.
Configuración del gestor de arranque
El paquete RPM kernel configura el gestor de arranque GRUB para arrancar el

nuevo kernel si cualquiera de estos gestores de arranque es instalado. Sin
embargo, no configura el gestor de arranque para cargar el nuevo kernel por
defecto.
Es una buena idea confirmar que el gestor de arranque se ha configurado

correctamente. Esto es un paso crucial. Si el gestor de arranque esta configurado
de forma incorrecta, no podrán arrancar el sistema. Si esto ocurre, arranque el
sistema con el disquete de arranque que creó anteriormente e intente configurar de
nuevo el gestor de arranque.
Asegúrese que el fichero /boot/grub/grub.conf contenga la sección title con la

misma versión del paquete kernel que acaba de instalar (lo mismo para los
paquetes kernel-smp o kernel-hugemem):
# Note that you do not have to rerun grub after making changes to this file
# NOTICE: You have a /boot partition. This means that

# all kernel and initrd paths are relative to /boot/, eg.

# root (hd0,0)
# kernel /vmlinuz-version ro root=/dev/hda2
# initrd /initrd-version.img
#boot=/dev/hda
default=3
timeout=10
splashimage=(hd0,0)/grub/splash.xpm.gz
title Red Hat Linux (2.4.20-2.47.1)
root (hd0,0)
kernel /vmlinuz-2.4.20-2.47.1 ro root=LABEL=/
initrd /initrd-2.4.20-2.47.1.img
title Red Hat Linux (2.6.11)
root (hd0,0)
kernel /vmlinuz-2.6.11 ro root=LABEL=/
initrd /initrd-2.6.11.img
Si ha creado una partición separada para /boot, el camino al kernel y la imagen

initrd será relativo a la partición /boot.
Observe que el nuevo kernel no está configurado para ser el kernel por defecto.
Para configurar GRUB para que arranque el nuevo kernel por defecto, cambie el
valor de la variable default al número del título de la sección que contiene el nuevo
kernel. La cuenta comienza con 0. Por ejemplo, si el nuevo kernel es el segundo
título en la sección, configure default a 1.
Comience evaluando el nuevo kernel reiniciando el computador y vigilando los

mensajes para asegurarse de que el hardware es detectado adecuadamente.
Módulos del kernel
El kernel de Linux tiene un diseño modular. En el momento de arranque, sólo se

carga un kernel residente mínimo en memoria. Por ello, cuando un usuario solicita
alguna característica que no esta presente en el kernel residente, se carga
dinámicamente en memoria un módulo kernel, también conocido algunas veces
como un controlador.
Durante la instalación, se prueba el hardware en el sistema. Basado en esta prueba

y en la información proporcionada por el usuario, el programa de instalación decide
qué módulos necesita cargar en el momento de arranque. El programa de
instalación configura el mecanismo de carga dinámica para que funcione de forma
transparente.
Si se añade un nuevo hardware después de la instalación y este requiere un

módulo kernel, el sistema debe ser configurado para cargar el módulo adecuado
para el nuevo hardware. Cuando el sistema es arrancado con el nuevo hardware,
se ejecuta el programa Kudzu detecta el nuevo hardware si es soportado y
configura el módulo necesario para él. El módulo también puede ser especificado
manualmente modificando el archivo de configuración del módulo,
/etc/modules.conf para las versiones 2.4 de kernel y /etc/modprobe.conf para las
versiones 2.6 de kernel.

Por ejemplo, si un sistema incluye un adaptador de red SMC EtherPower 10 PCI, el

archivo de configuración del módulo contiene la línea siguiente:
alias eth0 tulip
Si una segunda tarjeta de red es añadida al sistema y es idéntica a la primera

tarjeta, añada la línea siguiente al archivo /etc/modules.conf o /etc/modprobe.conf
según la version del kernel que esta utilizando:
alias eth1 tulip
Consulte el Manual de referencia de Red Hat Linux para una lista alfabética de
módulos de kernel y hardware soportado por los módulos.
Utilidades del módulo del kernel
Está disponible un grupo de comandos para el manejo de módulos kernel. Use

estos comandos para determinar si un módulo ha sido cargado exitósamente o
cuando se esté probando módulos diferentes para una nueva pieza de hardware.
El comando /sbin/lsmod muestra una lista de los módulos cargados actualmente.

Por ejemplo:
Module Size Used by Not tainted
iptable_filter 2412 0 (autoclean) (unused)
ip_tables 15864 1 [iptable_filter]
nfs 84632 1 (autoclean)
lockd 59536 1 (autoclean) [nfs]
sunrpc 87452 1 (autoclean) [nfs lockd]
soundcore 7044 0 (autoclean)
ide-cd 35836 0 (autoclean)
cdrom 34144 0 (autoclean) [ide-cd]
parport_pc 19204 1 (autoclean)
lp 9188 0 (autoclean)
parport 39072 1 (autoclean) [parport_pc lp]
autofs 13692 0 (autoclean) (unused)
e100 62148 1
microcode 5184 0 (autoclean)
keybdev 2976 0 (unused)
mousedev 5656 1
hid 22308 0 (unused)
input 6208 0 [keybdev mousedev hid]
usb-uhci 27468 0 (unused)
usbcore 82752 1 [hid usb-uhci]
ext3 91464 2
jbd 56336 2 [ext3]
Por cada línea, la primera columna es el nombre del módulo, la segunda columna
es el tamaño del módulo y la tercera es el recuento de usos.
La información después del recuento de usos varía un poco por módulo. Si se lista
(unused) en la línea del módulo, el módulo no está siendo usado actualmente. Si

(autoclean) está en la línea para el módulo, este puede ser limpiado

automáticamente por el comando rmmod -a. Cuando se ejecuta este comando,
cualquier módulo que este etiquetado con autoclean, que no ha sido usado desde la
acción previa de autoclean, será cargado. Red Hat Linux no realiza esta acción de
autoclean por defecto.
Si el nombre de un módulo esta listado al final de la línea entre corchetes, el

módulo entre corchetes es dependiente del módulo listado en la primera columna
de la línea. Por ejemplo, en la línea
usbcore 82752 1 [hid usb-uhci]
los módulo del kernel hid y usb-uhci dependen del módulo usbcore.
La salida /sbin/lsmod es la misma que la salida de /proc/modules.
Para cargar un módulo del kernel, use el comando /sbin/modprobe seguido del
nombre del módulo. Por defecto, modprobe intenta cargar el módulo desde los
subdirectorios /lib/modules/<kernel-version>/kernel/drivers/. Hay un subdirectorio
para cada tipo de módulo, tal como el subdirectorio net/ para los controladores de
interfaces de red. Algunos módulos del kernel tienen dependencias, es decir que
otros módulos deben ser cargados antes para que el otro se cargue. El comando
/sbin/modprobe verifica estas dependencias y carga los módulos necesarios antes
de cargar el módulo específico.
Por ejemplo, el comando

# /sbin/modprobe hid
carga cualquier dependencia de módulos y luego el módulo hid.
Para imprimir a la pantalla todos los comandos a medida en que /sbin/modprobe los
ejecuta, use la opción -v. Por ejemplo:
# /sbin/modprobe -v hid
El comando /sbin/insmod también existe para cargar módulos kernel; sin embargo
no resuelve dependencias. Por ello se recomienda el uso de /sbin/modprobe.
Para descargar módulos del kernel, use el comando /sbin/rmmod seguido por el
nombre del módulo. La utilidad rmmod sólo descarga módulos que ya no son usados
y que no son una dependencia de otro módulo en uso.
Por ejemplo, el comando

# /sbin/rmmod hid
baja el módulo del kernel hid.

Otra utilidad muy conveniente es modinfo. Use el comando /sbin/modinfo para

mostrar información sobre el módulo del kernel. La sintaxis general es:
/sbin/modinfo [options] <module>
Las opciones incluyen -d, lo cual muestra una breve descripción del módulo, y -p lo
que lista los parámetros que el módulo soporta. Para una lista completa de las
opciones, consulte la página del manual de modinfo.
Construcción de un kernel personalizado
Mucha gente nueva en Linux pregunta "¿Por qué construir mi propio kernel?". Dado
el avance realizado con el uso de módulos para el kernel, la respuesta más
acertada a esta pregunta es, "A menos que sepa por qué construir su propio kernel,
probablemente no lo necesite".
El kernel entregado con Red Hat Linux y a través del sistema de Errata de Red Hat
Linux proporciona soporte para la mayoría del hardware moderno y características
del kernel. Para la mayoría de los usuarios, no necesita ser recompilado. Esta
sección es proporcionada como una guía para aquellos usuarios que deseen
recompilar su kernel y aprender un poco más sobre ello, para usuarios que quieren
compilar una característica experimental en el kernel, etc.
Preparación para la construcción
Antes de construir un kernel personalizado, es extremadamente importante

asegurarse de que tiene un disquete de arranque de emergencia en caso de que
se cometa un error. Después de preparar el disquete, prúebelo para asegurarse de
que funciona correctamente.
En versiones anteriores de Red Hat/Fedora Linux, para recompilar el kernel, debía

tener instalado el paquete kernel-source.
Actualmente, para evitar la redundancia de paquetes, Fedora/Red Hat ya no

incluyen el paquete kernel-source proporcionado por versiones anteriores. Los
usuarios que requieren acceso al kernel de Fedora/Red Hat original pueden
encontrarlos en el paquete kernel-<version>.src.rpm.
Consulte siempre las Notas de la Versión (Release Notes) para información

exacta de como obtener y construir el árbol del kernel.
Para crear el árbol del kernel fuente ejecute los siguientes pasos:
1. Obtenga el archivo kernel-<version>.src.rpm de una de las siguientes

fuentes:

● El directorio SRPMS de la imagen de CD iso SRPMS.
● A través de FTP, descargando del sitio de Fedora/Red Hat o

kernel.org.
● En Red Hat Enterprise, a través del comando:
# up2date –get-source kernel
● En Fedora Core:
# yum install yum-utils
# yumdownloader --source kernel
2. Instale el paquete kernel-<version>.src.rpm usando el siguiente comando:
# rpm -Uvh kernel-<version>.src.rpm
3. Prepare la fuente del kernel usando los siguientes comandos:

# cd /usr/src/redhat/SPECS
# rpmbuild -bp --target $(uname -m) kernel.spec
4. El árbol del las fuentes del kernel serán ubicadas en el directorio

/usr/src/redhat/BUILD/kernel-<version>. Es buena idea mover el directorio
linux-<version> resultante al directorio /usr/src:
# cd /usr/src/redhat/BUILD/kernel-<version>
# mv linux-<version> /usr/src/
# cd /usr/src
# ln -s ./linux-<version> linux
# cd /usr/src/linux
Construcción del Kernel
Las instrucciones de esta sección se aplican a construir un kernel modular.
Para construir un kernel para la arquitectura x86 (realice todos los pasos como
root):
Abra un intérprete de comandos y cámbiese al directorio /usr/src/linux/. Todos los

comandos desde este punto en adelante deben ser ejecutados desde este
directorio.
# cd /usr/src/linux
Es importante que empiece la construcción del kernel con el árbol de las fuentes en
perfectas condiciones. Esto es, es recomendable que comience con el comando
make mrproper. Esto borrará cualquier fichero de configuración remanente de
configuraciones previas que pueda estar disperso por el árbol de las fuentes. Si ya

tiene un fichero de configuración funcional /usr/src/linux/.config, haga una copia

de respaldo en un directorio diferente antes de ejecutar este comando.
# cp .config config.bak
# make mrproper
Se recomienda que use la configuración del kernel de Red Hat Linux por defecto
como punto de partida. Para hacer esto, copie el archivo de configuración para la
arquitectura del sistema desde el directorio /usr/src/linux/configs/ a
/usr/src/linux/.config. También puede copiar la configuración actual existente en
el directorio /boot. Si el sistema tiene más de cuatro gigabytes de memoria, copie el
archivo que contiene la palabra clave smp, si tiene mas de 16 GB de memoria,
utilice hugemem. Puede además generar un archivo .config ejecutando el comando:
# make oldconfig
Luego, personalice el kernel.
Los otros métodos disponibles para la configuración del kernel incluyen:
● make config Un programa de texto interactivo. Los componentes le son

presentados de forma lineal y los va respondiendo uno a uno. Este método
no requiere el Sistema X Window y no le permite cambiar sus respuestas a
preguntas previas.
● make menuconfig Un programa de modo de texto, basado en menú. Los

componentes le son presentados en un menú categorizado; seleccione los
componentes deseados de la misma manera usada en el programa de
instalación en modo texto de Red Hat Linux. Cambie la etiqueta
correspondiente al punto que quiera incluir: [*] (incorporado), [ ] (excluido),
<M> (modularizado), o < > (posibilidad de modularizar). Este método no
requiere el Sistema X Window.
● make oldconfig Este es un script no interactivo que configurará su fichero de

configuración con los valores predeterminados. Si está usando el kernel
predeterminado de Red Hat, creará un fichero de configuración para el
kernel que manejará Red Hat Linux en su arquitectura. Esto es útil para
configurar su kernel con una configuración predeterminada que funciona, y
entonces poder desactivar las características que no quiera usar.
Al iniciar la herramienta de configuración se mostrarán las distintas categorías.

Dentro de cada categoría hay componentes. Seleccione y (yes), m (module), o n
(no) al lado del componente para compilarlo en el kernel, compilarlo como un
módulo kernel o no compilarlo. Para obtener más detalles de un componente,
utilice el botón help.

Solo para el kernel 2.4
Después de crear el archivo /usr/src/linux/.config, use el comando make dep

para configurar las dependencias correctamente.
# make dep
Use el comando make clean para preparar el árbol fuente para construir.
# make clean
Se le recomienda que aporte un número de versión modificada al kernel

personalizado de manera que no sobreescriba el kernel ya existente. El método
descrito aquí es el más sencillo para recuperar el sistema en caso de problemas. Si
está interesado en otras posibilidades, puede encontrar más detalles en
http://www.redhat.com/mirrors/LDP/HOWTO/Kernel-HOWTO.html o en el Makefile
en /usr/src/linux.
Por defecto, /usr/src/linux/Makefile incluye la palabra custom al final de la línea que

empieza por EXTRAVERSION. Añadir a la cadena le permitirá tener
contemporáneamente en su sistema el kernel antiguo en funcionamiento y el kernel
nuevo.
Si el sistema contiene más de un kernel personalizado, un buen método es anexar

la fecha al final (u otro identificador).
Compile el kernel con make bzImage. Este comando creará el archivo kernel
arch/i386/boot/bzImage.
# make bzImage
Compile cualquier módulo que haya configurado con make modules.

# make modules
Use el comando make modules_install para instalar los módulos del kernel (aún si
no se compiló ninguno). Observe el guión (_) en el comando. Esto instala los
módulos kernel en la ruta del directorio /lib/modules/<KERNELVERSION>/kernel/drivers
(donde KERNELVERSION es la versión especificada en el Makefile).
# make modules_install
Use make install para copiar su nuevo kernel y sus ficheros asociados a los
directorios apropiados. Este comando además generará la imagen initrd necesaria
para el kernel compilado y agregará una entrada en el archivo de configuración del
cargador de arranque para iniciar el kernel.
# make install

Si posee un adaptador SCSI y ha compilado el driver SCSI driver como un módulo

o si ha construido un kernel con el soporte ext3 como un módulo (predeterminado
en Red Hat Linux), se necesitará la imagen initrd.
Aunque la imagen initrd y las modificaciones del gestor de arranque han sido
creadas, debería verificar que ha sido realizado correctamente y también
asegurarse de usar la versión del kernel personalizado.
Construcción de un kernel monolítico
Para construir un kernel monolítico, sigua los mismos pasos que al compilar un
kernel modulari, con unas pocas excepciones.
Cuando configure el kernel, no compile nada como módulo. En otras palabras, sólo
responda Yes o No a las preguntas. También, debería responder No a kmod support y
module version (CONFIG_MODVERSIONS) support.
Omita los siguiente pasos:

# make modules
Añada la línea kernel en grub.conf la opción nomodules.
Resumen de pasos necesarios para construir un kernel personalizado
El siguiente es un resumen del procedimiento de construcción de un kernel

presentado anteriormente. No encontrará descripción de lo que hace cada
comando, pero podrá visualizar rápidamente los pasos necesarios para crear un
kernel.
# cd /usr/src/linux
# vi Makefile (1)
# cp .config config.bak
# make mrproper
# cp /boot/config-version .config
# make menuconfig (2)
# make dep (3)
# make clean
# make bzImage
# make modules
# make install
(1) Edite el makefile y cambie la variable EXTRAVERSION.
(2) Puede utilizar make config, make menuconfig o make xconfig.

(3) Solo necesario para la compilación de un kernel version 2.4

9
El sistema X Window
El sistema X Window
El sistema X Window
Mientras que el corazón de Red Hat Enterprise Linux es el kernel, para muchos
usuarios, la cara del sistema operativo es el entorno gráfico proporcionando por el
Sistema X Window, también llamado simplemente X.
En el mundo UNIX, los entornos de ventanas han existido desde hace décadas,
siendo éstos precursores de muchos de los utilizados en los sistemas operativos
actuales. A través de los años X se ha convertido en el entorno gráfico (GUI)
predominante para sistemas operativos del tipo UNIX.
El entorno gráfico para Red Hat Enterprise Linux es suministrado por la Fundación
X.Org, una implementación de código abierto creada para manejar el desarrollo y la
estrategia para el sistema X y sus tecnologías asociadas. X.Org es un proyecto de
gran escala que se apoya en un gran número de desarrolladores en todo el mundo.
Presenta una amplia gama de soporte para diferentes dispositivos de hardware y

arquitecturas, así como la posibilidad de ejecutarse en diferentes sistemas
operativos y plataformas. Este lanzamiento de Red Hat Enterprise Linux incluye
específicamente el lanzamiento X11R6.8 del sistema X Window.
El sistema X Window utiliza una arquitectura cliente-servidor. El servidor de X (el

binario Xorg) escucha por conexiones desde las aplicaciones cliente X a través de
la red o una interfaz local de loopback. El servidor gestiona la comunicación con el
hardware, que puede ser una tarjeta gráfica, un monitor, un teclado o un ratón. Las
aplicaciones cliente de X existen en el espacio
El lanzamiento X11R6.8
Red Hat Enterprise Linux 4 utiliza la versión X11R6.8 como la base del sistema X
Window, la cual incluye muchas mejoras de tecnología de punta para X.Org tales
como soporte para la aceleración de hardware 3D, la extensión XRender para
fuentes anti-alias, un diseño modular basado en controladores y soporte para
hardware de vídeo y dispositivos de entrada modernos.
Los archivos relacionados a X11R6.8 residen principalmente en dos ubicaciones:
● /usr/X11R6/Contiene el servidor X y algunas aplicaciones cliente así como

también archivos de cabecera X, bibliotecas, módulos y documentación.
● /etc/X11/ Contiene archivos de configuración para aplicaciones cliente y

servidor de X. Esto incluye archivos de configuración para el servidor X
mismo, el servidor de fuentes fs, los manejadores de display de X y muchos
otros componentes base.

El sistema X Window
Es importante resaltar que el archivo de configuración para la nueva arquitectura de

fuentes basado en Fontconfig es /etc/fonts/fonts.conf (que deja obsoleto al
archivo /etc/X11/XftConfig).
Debido a que el servidor X realiza tareas avanzadas en una amplia variedad de

formaciones de hardware, requiere una configuración detallada. El programa de
instalación instala y configura X automáticamente, a menos que los paquetes
X11R6.8 no se seleccionen para la instalación. Sin embargo, si la tarjeta de vídeo o
el monitor cambian, X necesitará ser reconfigurado. La mejor forma de hacer esto
es usando la Herramienta de configuración de X (system-config-display).
Entornos de escritorio
Un entorno de escritorio une diferentes clientes de X, los cuales cuando se usan

juntos crean un ambiente de usuario gráfico común y una plataforma de desarrollo.
Los entornos de escritorio tienen características avanzadas las cuales permiten a

los clientes X y a otros procesos comunicarse unos con otros y permitir a todas las
aplicaciones escritas para funcionar en ese ambiente a que realicen tareas
avanzadas, tales como operaciones de arrastrar y soltar.
Red Hat Linux proporciona dos entornos de escritorio:
● GNOME Es el entorno de escritorio por defecto en Red Hat Linux basado en

el conjunto de herramientas gráficas GTK+ 2.
● KDE Un entorno de escritorio alternativo basado en el conjunto de

herramientas gráficas Qt 3.
Ambos entornos GNOME y KDE tienen aplicaciones de productividad avanzadas,

tales como procesadores de palabras, hojas de cálculo y navegadores Web así
como herramientas para personalizar la apariencia de la GUI. Adicionalmente, si
ambas librerías están presentes, la GTK+ 2 y la Qt, las aplicaciones KDE pueden
ejecutarse en GNOME y viceversa.
Puede utilizar el comando switchdesk para cambiar el entorno de escritorio utilizado.
La sintaxis del comando es:

switchdesk [ KDE | GNOME | FVWM2 ]
Gestores de ventanas
Los gestores de ventanas son programas clientes de X que son o parte del entorno
de escritorio o, en otros casos, standalone. Su propósito principal es controlar la

El sistema X Window
forma en que las ventanas gráficas son posicionadas, redimensionadas o movidas.

Los manejadores de ventanas controlan las barras de títulos, el comportamiento del
foco, los vínculos del botón del ratón y teclas especificadas por el usuario.
Se incluyen cuatro gestores de ventanas con Red Hat Linux:
● kwin El gestor de ventanas KWin es el manejador por defecto para el

entorno KDE. Es un manejador de ventanas que soporta temas
personalizados.
● metacity El gestor de ventanas Metacity es el manejador por defecto del

entorno GNOME. Es un manejador de ventanas simple y eficiente que
también soporta temas personalizados.
● mwm El gestor de ventanas Motif, es un gestor básico tipo standalone.

Puesto que está diseñado para ser un gestor standalone, no se debería
utilizar en conjunto con los entornos de escritorios GNOME o KDE.
● twm El minimalista Administrador de pestañas de ventanas, el cual

proporciona el conjunto de herramientas más básicas de cualquier gestor de
ventanas y puede ser usado bien sea standalone o con un entorno de
escritorio. Es instalado como parte de XFree86.
Estos gestores de ventanas pueden ejecutarse sin los entornos de escritorio para
poder obtener una impresión de sus diferencias. Teclee el comando xinit -e <ruta-
al-gestor-de-ventanas>, donde <ruta-al-gestor-de-ventanas> es la ubicación del
archivo binario de gestor de ventanas. El archivo binario puede ser encontrado
escribiendo which <nombre-de-gestor-de-ventanas>.
Archivos de configuración del servidor X
El servidor X es un binario ejecutable (/usr/X11R6/bin/Xorg) que carga

dinámicamente cualquier módulo de servidor X necesario en el momento de
ejecución desde el directorio /usr/X11R6/lib/modules/. Algunos de estos módulos
son cargados automáticamente por el servidor, mientras que otros son opcionales y
deben ser especificados en el archivo de configuración del servidor X.
El servidor X y los archivos de configuración asociados son almacenados en el

directorio /etc/X11/.
El archivo de configuración para el servidor X es /etc/X11/xorg.conf. Cuando se

instala Red Hat Enterprise Linux, los archivos de configuración para X son creados
usando la información reunida sobre el hardware del sistema durante el proceso de
instalación.

El sistema X Window
El archivo xorg.conf
Mientras que casi nunca se necesita editar manualmente el /etc/X11/xorg.conf, es

muy útil conocer sobre las varias secciones y los parámetros opcionales
disponibles, especialmente cuando se estén solucionando problemas.
La estructura de Xorg
El archivo /etc/X11/xorg.conf está formado de muchas secciones diferentes las

cuales hacen referencia a aspectos específicos del hardware del sistema.
Cada sección comienza con una línea Section "<nombre-seccion>" (donde <nombre-
seccion> es el título para la sección) y termina con una línea EndSection. Dentro de
cada sección, hay líneas conteniendo nombres de opciones y al menos un valor de
opción, ocasionalmente visto en comillas.
Las líneas que comienzan con un símbolo de numeral o almohadilla [#] no son
leídas por el servidor y son usadas como comentarios.
Algunas opciones dentro del archivo de configuración aceptan un switch boleano el

cual activa o desactiva la característica. Los valores boleanos son:
● 1, on, true, yes - Activa la opción.
● 0, off, false, no - Desactiva la opción.
Lo siguiente son algunas de las secciones más importantes ordenadas como

aparecen en un archivo de configuración típico.
Sección ServerFlags
La sección opcional ServerFlags contiene varios parámetros globales del servidor.

Cualquier parámetro en esta sección puede ser sobreescrito por opciones
colocadas en la sección ServerLayout
Las entradas dentro de la sección ServerFlags están en sus propias líneas y

comienzan con el término Option seguido por una opción encerrada en dobles
comillas ["].
A continuación un ejemplo de la sección ServerFlags:
Section "ServerFlags"
Option "DontZap" "true"
EndSection
La siguiente es una lista de algunas de las opciones más útiles:

El sistema X Window
● "DontZap" "<booleano>" - Cuando el valor de <booleano> está configurado a

verdadero, esta configuración previene el uso de la combinación de teclas
[Ctrl]-[Alt]-[Retroceso] para terminar inmediatamente el servidor X.
● "DontZoom" "<booleano>" - Cuando el valor de <booleano> está colocado a

verdadero, esta configuración previene moverse a lo largo de las
resoluciones de vídeo configuradas usando las combinaciones de teclas
[Ctrl]-[Alt]-[Keypad-Mas] y [Ctrl]-[Alt]-[Keypad-Menos]
Sección ServerLayout
La sección ServerLayout vincula los dispositivos de entrada y salida controlados por

el servidor X. Como mínimo, esta sección debe especificar un dispositivo de salida
y al menos dos dispositivos de entrada (un teclado y un ratón).
El ejemplo siguiente ilustra una sección ServerLayout típica:
Section "ServerLayout"
Identifier "Default Layout"
Screen 0 "Screen0" 0 0
InputDevice "Mouse0" "CorePointer"
InputDevice "Keyboard0" "CoreKeyboard"
EndSection
Las entradas siguientes son usadas a menudo en la sección ServerLayout:
● Identifier - Especifica un nombre único para esta sección ServerLayout.
● Screen - Especifica el nombre de la sección Screen a ser usado con el

servidor X. Pueden estar presentes más de una opción Screen.
Lo siguiente es un ejemplo de una entrada Screen típica:
Screen 0 "Screen0" 0 0
El primer número en esta entrada de ejemplo Screen (0) indica que el primer
conector del monitor o head en la tarjeta de vídeo usa la configuración
especificada en la sección Screen con el identificador "Screen0".
Si la tarjeta de vídeo tiene más de una cabeza, será necesaria otra entrada
Screen con un número diferente y un identificador de sección Screen.
Los números a la derecha de "Screen0" proporcionan las coordenadas

absolutas X y Y para la esquina superior izquierda de la pantalla (0 0 por
defecto).
● InputDevice - Especifica el nombre de una sección InputDevice a ser usada

con el servidor X.

El sistema X Window
Al menos deben haber dos entradas InputDevice: una para el ratón por
defecto y una para el teclado por defecto. Las opciones CorePointer y
CoreKeyboard indican que estos son el ratón y teclado principales.
● Option "<nombre-opcion>" - Una entrada opcional que especifica parámetros

extra para esta sección. Cualquier sección listada aquí sobreescriben
aquellas listadas en la sección ServerFlags.
Reemplace <nombre-opcion> con una opción válida listada para esta sección
en la página man X.
Es posible crear más de una sección ServerLayout. Sin embargo, el servidor sólo
leerá la primera sección que aparezca a menos que se especifique una sección
ServerLayout alterna como una línea de argumento.
Sección Files
La sección Files configura la ruta para servicios vitales al servidor X, tal como la
ruta de la fuente.
El siguiente ejemplo ilustra una sección Files:

Section "Files"
RgbPath "/usr/X11R6/lib/X11/rgb"
FontPath "unix/:7100"
EndSection
Las siguientes entradas son usadas comúnmente en la sección Files:
● RgbPath - Especifica la ubicación de la base de datos de colores RGB. Esta

base de datos define todos los esquemas de color en X y los junta para
valores RGB específicos.
● FontPath - Especifica dónde el servidor X debe ser conectado para obtener

las fuentes desde el servidor de fuentes xfs.
Por defecto, la FontPath es unix/:7100. Esto le dice al servidor X para obtener

información de fuentes usando sockets de dominio UNIX para la
comunicación entre procesos (IPC) en el puerto 7100.
● ModulePath - Un parámetro opcional el cual especifica directorios alternativos

el cual almacena módulos de servidor X.
Sección Module

El sistema X Window
La sección Module especifica cuales módulos del directorio /usr/X11R6/lib/modules/

cargará el servidor X. Los módulos añaden funcionalidad adicional al servidor X.
El ejemplo siguiente ilustra una sección Module típica:

Section "Module"
Load "dbe"
Load "extmod"
Load "fbdevhw"
Load "glx"
Load "record"
Load "freetype"
Load "type1"
Load "dri"
EndSection
Sección InputDevice
Cada sección InputDevice configura un dispositivo de entrada para el servidor X.

Los sistemas típicamente tienen al menos dos secciones InputDevice, un teclado y
un ratón.
El ejemplo siguiente ilustra una sección InputDevice típica para un ratón:
Section "InputDevice"
Identifier "Mouse0"
Driver "mouse"
Option "Protocol" "IMPS/2"
Option "Device" "/dev/input/mice"
Option "Emulate3Buttons" "no"
EndSection
Las entradas siguientes son comúnmente usadas en la sección InputDevice:
● Identifier- Especifica un nombre único para esta sección InputDevice. Esto

es una entrada requerida.
● Driver - Especifica el nombre del controlador del dispositivo que X debe

cargar para el dispositivo.
● Option - Especifica las opciones necesarias pertinentes al dispositivo.
Para un ratón, estas opciones incluyen:
– Protocol - Indica el protocolo usado por el ratón, tal como IMPS/2.
– Device - Indica la ubicación del dispositivo físico.
– Emulate3Buttons- Especifica si se va a permitir a un ratón de dos botones

a que se comporte como uno de tres cuando se presionen ambos
botones simultáneamente.

El sistema X Window
Consulte la página man para una lista de las opciones válidas para esta
sección.
Por defecto la sección InputDevice tiene comentarios para permitir a los usuarios
configurar opciones adicionales.
Sección Monitor
Cada sección Monitor configura un tipo de monitor usado por el sistema. Mientras
una sección Monitor es lo mínimo, pueden ocurrir varias instancias para cada tipo
de monitor en uso con la máquina.
La mejor forma de configurar un monitor es configurando X durante la instalación o

usando la Herramienta de configuración de X. Para más información sobre el uso
de la Herramienta de configuración de X refiérase al capítulo llamado Audio, Vídeo
y entretenimiento general en el Manual del principiante de Red Hat Linux.
Este ejemplo muestra una sección de Monitor típica:

Section "Monitor"
Identifier "Monitor0"
VendorName "Monitor Vendor"
ModelName "DDC Probed Monitor - ViewSonic G773-2"
DisplaySize 320 240
HorizSync 30.0 - 70.0
VertRefresh 50.0 - 180.0
EndSection
Tenga cuidado cuando modifique manualmente valores en la sección Monitor de los

archivos de configuración. Valores inapropiados pueden dañar o destruir su
monitor. Consulte la documentación sobre monitores para un listado de parámetros
seguros.
A continuación se muestran entradas comunes usadas en la sección Monitor:
● Identifier- Proporciona un nombre único para esta sección Monitor. Esta es

una entrada requerida.
● VendorName - Parámetro opcional que muestra el nombre del fabricante del

monitor.
● ModelName - Parámetro opcional que muestra el nombre del modelo del

monitor.
● DisplaySize - Un parámetro opcional que especifica, en milímetros, el tamaño

físico del área de dibujo del monitor.
● HorizSync - Especifica el rango de la frecuencia de sincronización horizontal

El sistema X Window
compatible con el monitor en kHz. Estos valores ayudan al servidor X a

determinar la validez de las entradas Modeline especificadas para el monitor.
● VertRefresh - Lista de los rangos de frecuencias de refresco verticales

soportados por el monitor, en Hz. Estos valores se usan como referencia
para que el servidor X sepa cuando deberá utilizar cada una de las entradas
que aparecen en Modeline con este monitor.
● Modeline - Un parámetro opcional el cual especifica los modos de vídeo

adicionales para el monitor en resoluciones particulares, con ciertas
resoluciones de refrescamiento de sincronización horizontal y vertical. Vea la
página man de X para una explicación más detallada de las entradas
Modeline.
● Option "<nombre-opcion>" - Una entrada opcional la cual especifica

parámetros extra para la sección. Reemplace <nombre-opcion> con una
opción válida listada para esta sección en la página man de X.
Sección Device
Cada sección Device configura una tarjeta de vídeo en el sistema. Mientras una
sección Device es lo mínimo, instancias adicionales pueden ocurrir para cada tarjeta
de vídeo instalada en la máquina.
El siguiente ejemplo ilustra una sección Device típica para una tarjeta de vídeo:
Section "Device"
Identifier "Videocard0"
Driver "mga"
VendorName "Videocard vendor"
BoardName "Matrox Millennium G200"
VideoRam 8192
Option "dpms"
EndSection
Las siguientes entradas son usadas comúnmente en la sección Device:
● Identifier- Especifica un nombre único para esta sección Device. Esta es

● Driver - Especifica cuál controlador debe cargar el servidor X para poder

utilizar la tarjeta de vídeo. Se puede encontrar una lista de los controladores
en /usr/X11R6/lib/X11/Cards, el cual es instalado con el paquete hwdata.
● VendorName - Un parámetro opcional el cual especifica el fabricante de la

tarjeta de vídeo.
● BoardName - Un parámetro opcional el cual especifica el nombre de la tarjeta

de vídeo.

El sistema X Window
● VideoRam - Un parámetro opcional el cual especifica la cantidad de RAM

disponible en la tarjeta de vídeo en kilobytes. Este valor sólo es necesario
para tarjetas de vídeo que el servidor X no puede probar para detectar la
cantidad de RAM.
● BusID - Una entrada opcional la cual especifica la ubicación del bus de la

tarjeta de vídeo. Esta opción es necesaria solamente para sistemas con
múltiples tarjetas.
● Screen- Una entrada opcional la cual especifica que conector de monitor o

cabezal en la tarjeta de vídeo configura la sección Device. Esta opción es útil
solamente para tarjetas de vídeo con múltiples cabezales.
Si múltiples monitores son conectados a diferentes cabezales en la misma

tarjeta de vídeo, deben existir secciones Device separadas y cada una de
estas secciones debe tener un valor Screen diferente.
Los valores para la entrada Screen deben ser enteros. El primer cabezal en la
tarjeta de vídeo tiene un valor de 0. El valor para cada cabezal adicional
incrementa este valor en uno.
● Option "<nombre-opcion>" - Una entrada opcional la cual especifica

parámetros extra para la sección. Reemplace <nombre-opcion> con una
opción válida listada para esta sección en la página man de X.
Una de las opciones más comunes es "dpms", la cual activa la conformidad

de energía Service Star para el monitor.
Sección Screen
Cada sección Screen vincula una tarjeta de vídeo (o cabezal) a un monitor

referenciando la sección Device y la sección Monitor para cada uno. Mientras que
una sección Screen es lo mínimo, pueden ocurrir instancias adicionales para cada
combinación de tarjeta de vídeo y monitor presente en la máquina.
El ejemplo siguiente ilustra una sección Screen típica:
Section "Screen"
Identifier "Screen0"
Device "Videocard0"
Monitor "Monitor0"
DefaultDepth 16
SubSection "Display"
Depth 24
Modes "1280x1024" "1280x960" "1152x864" "1024x768" "800x600"
"640x480"
EndSubSection
SubSection "Display"
Depth 16

El sistema X Window
Modes "1152x864" "1024x768" "800x600" "640x480"

EndSubSection
EndSection
Las siguientes entradas son usadas a menudo en la sección Screen:
● Identifier- Especifica un nombre único para esta sección Screen. Esta es

● Device - Especifica el nombre único de una sección Device. Esta es una

entrada requerida.
● Monitor - Especifica el nombre único de una sección Monitor. Esta es una

entrada requerida.
● DefaultDepth - Especifica la profundidad del color por defecto en bits. En el

ejemplo anterior, el valor por defecto es 16, lo que proporciona miles de
colores. Múltiples entradas de DefaultDepth son permitidas, pero al menos
una debe estar presente.
● SubSection "Display" - Especifica los modos de la pantalla disponibles en una

profundidad de color particular. Una sección Screen puede tener múltiples
subsecciones Display, pero debe haber al menos una para la profundidad de
color especificada en la entrada DefaultDepth.
● Option "<option-name>" - Una entrada opcional que especifica parámetros

extra para la sección. Reemplace <option-name> con una opción válida
listada para esta sección en la página man.
DRI
La sección opcional DRI especifica parámetros para Direct Rendering

Infrastructure (DRI). DRI es una interfaz que permite a las aplicaciones de
software 3D sacar provecho de las capacidades de aceleración de hardware 3D
incorporadas en la mayoría del hardware moderno de vídeo. Además, DRI puede
mejorar el rendimiento de 2D a través de la aceleración de hardware, si es
soportado por el controlador de la tarjeta.
Esta sección es ignorada a menos que DRI esté activada en la sección Module.
El ejemplo siguiente muestra una sección DRI típica:

Section "DRI"
Group 0
Mode 0666
EndSection
Puesto que tarjetas de vídeo diferentes utilizan DRI de formas diferentes, no

El sistema X Window
modifique estos valores para esta sección sin primero referirse a

http://dri.sourceforge.net/.
Fuentes
Red Hat Linux utiliza dos métodos para manejar fuentes y mostrarlas bajo X. El
subsistema de fuentes más nuevo Fontconfig simplifica la gestión de fuentes y
proporciona características avanzadas, tales como anti-aliasing. Este sistema es
usado automáticamente para aplicaciones programadas usando el conjunto de
herramientas Qt 3 o GTK+ 2.
Por compatibilidad, Red Hat Linux incluye el subsistema de fuentes original,

llamado el subsistema de fuentes nucleo de X. Este sistema, el cual tiene más de
15, está basado en el Servidor de fuentes de X (xfs).
Esta sección discute cómo configurar fuentes para X usando ambos sistemas.
Fontconfig
El subsistema de fuentes Fontconfig permite a las aplicaciones accesar

directamente fuentes en el sistema y usar Xft u otros mecanismos de traducción de
fuentes para interpretar fuentes Fontconfig con anti-aliasing avanzados. Las
aplicaciones gráficas pueden usar la librería Xft con Fontconfig para dibujar texto a
la pantalla.
Con el tiempo, el subsistema de fuentes Fontconfig/Xft reemplazará el subsistema

de fuentes base de X.
Es importante resaltar que Fontconfig comparte el archivo de configuración

/etc/fonts/fonts.conf, el cual sustituye al /etc/X11/XftConfig. El archivo de
configuración Fontconfig no debería se modificado manualmente.
Añadir fuentes a Fontconfig
Añadir fuentes al subsistema Fontconfig es un proceso bastante directo.
Para añadir fuentes para todo el sistema, copie las nuevas fuentes en el directorio
/usr/share/fonts/local/.
Para añadir fuentes para un usuario individual, copie las nuevas fuentes en el
directorio .fonts/ en el directorio principal del usuario.
Utilice el comando fc-cache para actualizar la información caché de la fuente, como

en el ejemplo siguiente:

El sistema X Window
fc-cache <path-to-font-directory>
En este comando, sustituya <path-to-font-directory> con el directorio conteniendo

las nuevas fuentes (bien sea /usr/share/fonts/local/ o ~/.fonts/).
Añadir fuentes TrueType
Mientras Linux viene con una selección de fuentes ya instalada, existe una
selección mucho mayor de fuentes TrueType disponibles en la web e incluído con
productos que cualquier otro tipo de fuente.
Inicialmente cree un directorio para almacenar las fuentes TrueType:

# mkdir /usr/X11R6/lib/X11/fonts/TTF
Copie las fuentes a ese directorio y ejecute los siguientes comandos:

# cd /usr/X11R6/lib/X11/fonts/TTF
# ttmkfdir > fonts.scale
# mkfontdir
Si verifica el contenido del directorio debería encontrar dos archivos además de los
archivos de fuente, “fonts.scale” y “fonts.dir”. Estos archivos simplemente
contienen una lista de los nombres de las fuentes para cada fuente TrueType.
Finalmente debe agregar el nuevo directorio a la lista de ubicaciones en la cual

Xwindows buscará las fuentes:
chkfontpath -a /usr/X11R6/lib/X11/fonts/TTF
Para agregar nuevas fuentes repita el mismo procedimiento, sin embargo el

comando chkfontpath se ejecuta una sola vez, solamente cada vez que se desea
agregar un directorio.
Sistema de fuentes base de X
Por compatibilidad, Red Hat Linux todavía proporciona el subsistema de fuentes

base de X, el cual utiliza el servidor de fuentes X (xfs) para proporcionar fuentes a
las aplicaciones clientes X.
El servidor X busca por un servidor de fuentes especificado en la entrada FontPath

bajo la sección Files del archivo de configuración.
Configuración de xfs

El sistema X Window
El script /etc/rc.d/init.d/xfs inicia el servidor xfs. Se pueden configurar muchas

opciones en el archivo /etc/X11/fs/config.
La siguiente es una lista de las opciones más usadas:
● alternate-servers - Configura una lista de servidores alternativos de fuentes

que podrán ser utilizados en el caso de que el servidor actual no esté
disponible. Los diferentes servidores deberán estar separados por comas.
● catalogue - Lista ordenada de rutas que contienen las fuentes a utilizar. Cada
ruta hacia las fuentes deberá estar separada por una coma antes de que
comience otra nueva ruta en la lista.
Puede utilizar la cadena :unscaled inmediatamente después de la ruta hacia

las fuentes para hacer que las fuentes no escalables se carguen antes que
el resto de las fuentes de la ruta. Entonces, podrá especificar la ruta
completa de nuevo de tal forma que las otras fuentes que sean escalables
puedan ser cargadas.
● client-limit - Configura el número de clientes que el servidor de fuentes

podrá servir antes de comenzar a denegar las conexiones. El número por
defecto es 10.
● clone-self Permite al servidor de fuentes clonar una nueva versión de sí

mismo si se llega al límite definido por el parámetro client-limit. Por
defecto, esta opción está configurada como on.
● - Configura el tamaño de punto por defecto para cualquier

default-point-size
fuente que no especifique este valor. El valor de esta opción está estimado
en décimas de puntos. El valor por defecto de 120 se corresponde a fuentes
de 12 puntos.
● default-resolutions - Especifica una lista de resoluciones soportadas por el

servidor X. Cada resolución de la lista debe estar separada por una coma.
● deferglyphs - Especifica si retrasar la carga de glyphs (el gráfico usado para

visualmente representar una fuente). Para desactivar esta característica
utilice none, para activarla para todas las fuentes utilice all, o para activar
esta característica solamente para fuentes de 16-bit use 16.
● - Le permite especificar la ruta y el nombre de archivo donde se

error-file
almacenarán los informes de error de xfs.
● no-listen - Dice a xfs que no escuche utilizando un protocolo en particular.

Por defecto, esta opción está configurada con tcp para evitar que xfs
escuche utilizando puertos TCP, por motivos de seguridad. Si planea
utilizarxfs para servir fuentes a estaciones de trabajo en red, deberá borrar
esta línea.

El sistema X Window
● port - Especifica el puerto TCP en el cual xfs escuchará si no-listen no existe

o está entre comentarios.
● use-syslog - Especifica si utilizar el registro de errores del sistema.
Añadir fuentes a xfs
Para añadir fuentes al subsistema base de fuentes de X (xfs), siga los pasos
siguientes:
Si aún no existe, cree un directorio llamado /usr/share/fonts/local/ usando el

comando siguiente como usuario root:
# mkdir /usr/share/fonts/local/
Si es necesario la creación del directorio /usr/share/fonts/local/, se debe añadir a

la ruta xfs usando el comando siguiente como root:
# chkfontpath --add /usr/share/fonts/local/
Copie el nuevo archivo de fuente en el directorio /usr/share/fonts/local/
Actualice la información de la fuente emitiendo el siguiente comando como root:

# ttmkfdir -d /usr/share/fonts/local/ -o /usr/share/fonts/local/fonts.scale
Reinicie el servidor de fuentes xfs utilizando el comando siguiente como root:

# service xfs reload
Niveles de ejecución y X
En la mayoría de los casos, la instalación por defecto de Red Hat Linux configura
una máquina para arrancar en un entorno de conexión gráfico, conocido como nivel
de ejecución 5. Es posible, sin embargo, arrancar en el modo multiusuario de sólo
texto llamado nivel de ejecución 3 y comenzar una sesión X desde allí.
Nivel de ejecución 3
Cuando estamos en el nivel de ejecución 3, la forma habitual de iniciar una sesión

X es escribiendo el comando startx. El comando startx es un front-end del
programa xinit el cual lanza el servidor X y conecta los clientes X al mismo. Ya
que usted debe de haber entrado en el sistema con su usuario cuando realice este
procedimiento a partir del nivel de ejecución 3, startx no lanzará un gestor de

El sistema X Window
visualización o autenticará al usuario.
Cuando startx comienza, busca un archivo .xinitrc en el directorio principal del

usuario para definir el entorno de escritorio y posiblemente otras aplicaciones
clientes X a ejecutar. Si este archivo .xinitrc no se encuentra, se utilizará el
archivo por defecto /etc/X11/xinit/xinitrc.
El script por defecto xinitrc luego buscará por los archivos definidos por el usuario
y archivos de sistema por defecto, incluyendo .Xresources, .Xmodmap y .Xkbmap en el
directorio principal del usuario y Xresources, Xmodmap y Xkbmap en el directorio
/etc/X11/. Los archivos Xmodmap y Xkbmap, si existen, son usados por la utilidad
xmodmap para configurar el teclado. Los archivos Xresources son leídos para
asignar valores de preferencia específicos a aplicaciones.
Después de configurar estas opciones, el script xinitrc ejecuta todos los scripts
localizados en el directorio /etc/X11/xinit/xinitrc.d/. Un script muy importante en
este directorio es xinput, el cual configura los parámetros tales como el idioma por
defecto.
Luego, el script xinitrc intenta ejecutar .Xclients en el directorio principal del

usuario y cambia a /etc/X11/xinit/Xclients si no lo puede encontrar. El propósito
del archivo Xclients es arrancar el entorno de escritorio o posiblemente, sólo un
gestor de ventanas básico. El script .Xclients en el directorio principal del usuario
inicia el entorno de escritorio especificado por el usuario en el archivo .Xclients-
default. Si .Xclients no existe en el directorio principal del usuario, el script
estándar /etc/X11/init/Xclients intenta iniciar otro entorno de escritorio, intentando
primero con GNOME y luego con KDE seguido por twm.
El usuario es devuelto a una sesión de modo texto después de desconectarse de X

del nivel de ejecución 3.
Nivel de ejecución 5
Cuando el sistema arranca en el nivel de ejecución 5, se lanza una aplicación

cliente de X especial, llamada un gestor de visualización. Un usuario debe
autenticarse usando el gestor de visualización antes de que se inicien cualquier
entorno de escritorio o gestores de ventanas.
Dependiendo de los entornos de escritorio instalados en su máquina, estan

disponibles tres gestores de visualización diferentes para manejar la autenticación
de los usuarios.
● gdm - Es el gestor de visualización por defecto para Red Hat Linux y permite
que los usuarios puedan configurar los parámetros de idioma, cierre del
sistema, reinicio o conexión al sistema.
● kdm - es el gestor de visualización de KDE que permite a los usuarios

El sistema X Window
apagar, reiniciar o conectarse al sistema.
● xdm - Este es un gestor de visualización muy básico que sólo permite que el
usuario se conecte al sistema.
Cuando arranque en el nivel de ejecución 5, el script prefdm determina el gestor de

visualización preferido haciendo referencia al archivo /etc/sysconfig/desktop.
Refiérase al archivo /usr/share/doc/initscripts-<version-number>/sysconfig.txt
(donde <version-number> es el número de la versión del paquete initscripts) para ver
un listado de las opciones disponibles para este archivo.
Cada uno de los gestores de visualización hace referencia al archivo

/etc/X11/xdm/Xsetup_0 para configurar la pantalla de conexión. Una vez que el
usuario se conecte al sistema, el script /etc/X11/xdm/GiveConsole corre para asignar
la propiedad de la consola para el usuario. Luego, el script /etc/X11/xdm/Xsession se
ejecuta para llevar a cabo muchas de las tareas que son normalmente realizadas
por el script xinitrc cuando arranca X desde el nivel de ejecución 3, incluyendo la
configuración del sistema y los recursos del usuario, así como también ejecutar los
scripts en el directorio /etc/X11/xinit/xinitrc.d/.
El usuario puede especificar cuál entorno de escritorio desea utilizar cuando se

autentican usando los gestores de visualización gdm o kdm seleccionándolo desde
el menú Session (accesado al seleccionar Botón de menú principal [en el Panel] =>
Preferencias => Más Preferencias => Sesiones). Si el entorno de escritorio no es
especificado en el gestor de visualización, el script /etc/X11/xdm/Xsession verificará
los archivos .xsession y .Xclients en el directorio principal del usuario para decidir
cuál entorno de escritorio cargar. Como último recurso el archivo
/etc/X11/xinit/Xclients es usado para seleccionar un entorno de escritorio o gestor
de ventanas para usarse de la misma forma que en el nivel de ejecución 3.
Cuando el usuario termina una sesión X en la visualización por defecto (:0) y se

desconecta, el script /etc/X11/xdm/TakeConsole se ejecuta y vuelve a asignar la
propiedad de la consola al usuario root. El gestor de visualización original, que
continúa ejecutándose después que el usuario se conecta, toma el control
liberando un nuevo gestor de visualización. Esto reinicia el servidor XFree86,
despliega una nueva ventana de conexión y reinicia el proceso completo otra vez.
El usuario es devuelto al gestor de visualización después de desconectarse de X

desde el nivel de ejecución 5.
Para más información sobre cómo los gestores de visualización controlan la

autenticación de los usuarios, consulte /usr/share/doc/gdm-<version-number>/README
(donde <version-number> es el número de la versión para el paquete gdm instalado)
y la página man de xdm.

El sistema X Window
Ejecutando aplicaciones remotas con X11
Cada aplicación gráfica en X Window lee al iniciarse la variable de entorno

DISPLAY para averiguar a qué pantalla debe enviar sus gráficos. Esto junto con la
capacidad de red del Sistema X Window hace posible ejecutar aplicaciones
gráficas remotamente. Es decir, se utiliza la capacidad de CPU de una máquina
mientras se utiliza la aplicación desde otra máquina distinta. Todo el GUI (graphical
user interface, interfaz gráfica de usuario) aparece en la máquina desde la que se
opera. No se nota que se utilizan dos ordenadores.
Todas las aplicaciones X Window, se llamen gimp, xterm, konqueror, netscape, ...
realmente son clientes de red que se conectan a un servidor, el servidor X. La
función de este servidor X es comunicarse con el hardware gráfico, dibujar las
imágenes en la pantalla, leer las entradas del ratón y del teclado. Los clientes (sus
programas como gimp, netscape ...) envían al servidor instrucciones sobre cómo
pintar cuadros y botones. A cambio reciben del servidor los eventos de ratón y
teclado. Obviamente se necesita algún tipo de autentificación, de otra forma
cualquiera podría estropear la pantalla de cualquier otro. Existen dos programas
para controlar el acceso:
● xhost - usando este programa puede dar permiso a cualquier usuario en una
máquina dada a escribir gráficos en su pantalla. Ejemplo: usted está sentado
frente a una máquina llamada mercurio. Para permitir el acceso a cualquier
programa en el host venus a su pantalla debería escribir el comando:
# xhost +venus
● xauth - es una autentificación basada en cookies y mucho más sofisticada.

Con xauth se puede dar acceso a los usuarios de forma individual. Es
mucho más seguro que xhost. La autentificación usa una cookie alojada en
el fichero .Xauthority en el directorio personal de los usuarios. Si la máquina
remota tiene una cookie válida en este fichero entonces se garantizará el
acceso. Para copiar la cookie desde la máquina frente a la que está sentado
(mercurio) al host desde donde quiere lanzar el programa (venus) puede
usar uno de los siguientes métodos:
# xauth extract - mercurio:0.0 | ssh venus /usr/X11R6/bin/xauth merge
o
# scp ~/.Xauthority venus:
Al lanzar un programa (cliente) ocurre lo siguiente:
1. El cliente busca en la variable de entorno DISPLAY el servidor, si no intenta

conectarse al servidor en este host.
2. El servidor comprueba si el cliente tiene permiso para enviarle "imágenes". Si el

El sistema X Window
cliente está autorizado entonces el servidor dibujará la imagen en la pantalla.
La variable de entorno DISPLAY tiene la siguiente sintaxis:
# export DISPLAY=nombre_host:número_display.número_pantalla
Un ejemplo para podría ser:

# export DISPLAY=mercurio:0.0
Lanzando una aplicación remota
Después de toda la teoría veamos ahora un ejemplo práctico. Estamos otra vez
sentados frente al ordenador llamado mercurio y queremos ejecutar algo
remotamente desde venus.
Dígale a su servidor X qué clientes desde venus tienen permiso para dibujar
imágenes en su pantalla:
# xhost +venus
haga login al host remoto venus:

# telnet venus
ahora ha hecho login a venus y cada comando que usted lance será ejecutado en
venus
# export DISPLAY=mercurio:0.0
inicie el programa. Por ejemplo:

# xterm &
Utilización de X remoto con SSH
Inicialmente se debe configurar el servidor ssh para aceptar X11 Forwarding; en el

archivo /etc/ssh/sshd_config:
X11Forwarding yes
Conectarse al equipo remoto utilizando la opción -X de ssh:
# ssh -X usuario@host
# xterm &

El sistema X Window
Sesiones gráficas remotas (XDMCP)
Cuando se tienen distintas máquinas en una LAN y se desea aprovechar el poder y

recursos de una de estas y ahorrar trabajó, una sesión gráfica remota será de gran
utilidad. Lograr esto es muy fácil. Se puede hacer de dos formas, una accediendo
vía SSH, RHS o Telnet, y la otra utilizando alguna de las pantallas de acceso
gráfico, como GDM.
Sesión gráfica remota con GDM
GDM tiene una característica poco usada, pero muy útil. El método será de mucha
utilidad suponiendo que se tiene un servidor central con buena cantidad de
memoria y un buen microprocesador y lo más nuevo en software, y en la red de
área local (LAN) se tienen una o varias máquinas con muy poco espacio en disco
y/o poco poder en el microprocesador, o resulta mucho trabajo instalarles todo un
sistema optimizado y personalizado.
El objetivo será entonces querrás que los usuarios puedan utilizar el servidor con
mayor poder y recursos para que se ejecuten ahí las sesiones gráficas y así tener
un mayor control en toda la red.
Configuración de gdm para aceptar conexiones XDMCP
En el servidor, abra una terminal como superusuario y ejecute el comando gdmsetup,

vaya a la pestaña de XDMCP y de allí a la pestaña XDMCP, deben habilitarse las
casillas de "Activar XDMCP" y "Honrar peticiones indirectas".
Como medida de seguridad, deshabilite el acceso de root tanto local como

remotamente en la pestaña seguridad.
En los clientes, debe respaldarse y editarse el archivo /etc/X11/prefdm y debe

hacerse que contenga únicamente lo siguiente, considerando que se debe poner la
ruta completa de X:
#!/bin/sh
/usr/X11R6/bin/X -query dirección_IP_del_Servidor
Ejemplo:
#!/bin/sh
/usr/X11R6/bin/X -query 192.168.1.254
Deben re-iniciarse los servidores X de las máquinas clientes.
Las máquinas clientes verán a GDM ejecutándose como si se estuviese en el

mismo servidor, y permitirá iniciar GNOME o KDE o cualquier otro entorno gráfico

El sistema X Window
utilizado. Si cuenta con buenos adaptadores de red, ni siquiera se notará si se está

en un cliente o en el servidor.
Si lo prefiere, también puede iniciar el servidor de vídeo remoto simplemente

ejecutando
/usr/X11R6/bin/X -query dirección_IP_del_Servidor
desde el prompt de cualquier terminal.

10
Solución de problemas
Diagnóstico y solución de problemas X
El sistema de ventanas X es robusto y estable, pero ocasionalmente pueden

suceder problemas. Puede intentar varias cosas para intentar solucionar problemas
de X:
● Los menejadores de sesión crean archivos de registro en su directorio

HOME, como ~/.xsession-errors. Verifique estos archivos así como el
/var/log/messages y /var/log/XFree86.0.log
● Problemas con los archivos .xinitrc o .Xclients, pruebe eliminar o renombrar

estos archivos.
● Verifique la variable de entorno DISPLAY y asegúrese de tener permiso de

acceso a X con el comando xhost.
● Asegúrese que el directorio /usr/X11R6/bin está en su variable PATH.
● Verifique el espacio en disco, si algún sistema de archivos se ha llenado,

puede provocar que el sistema X no inicie.
● Verifique que el archivo /etc/hosts está correctamente configurado, debe

existir una entrada para la interface loopback y una entrada para el nombre
de host del equipo.
● Asegúrese que el servidor de fuentes está en ejecución.
Modo de rescate
Cuando las cosas salen mal, siempre hay que corregir los problemas. A pesar de
todo, estos métodos requieren que usted comprenda muy bien cómo funciona el
sistema.
El modo de rescate consiste en la posibilidad de poder tener un entorno Linux

completo que se pueda iniciar desde un disquete o un CD, o utilizando cualquier
otro método. Tal y como su nombre indica, el modo de rescate se proporciona para
que usted rescate algo. En el modo de operación normal, su sistema Red
Hat/Fedora Linux utiliza los ficheros que se encuentran en el disco duro de su
sistema para realizar todo: ejecutar programas, almacenar sus ficheros, y mucho
más. A pesar de esto, hay ocasiones en las que no podrá hacer que su sistema
Linux se ejecute suficientemente bien como para tener acceso a los ficheros de su
disco duro.

Al usar el modo rescate, podrá acceder a esos ficheros, incluso aunque no pueda
ejecutar Linux desde ese disco.
Normalmente, será necesario que entre en el modo rescate por dos razones:
• Es incapaz de hacer iniciar Linux.
• Está teniendo problemas con el hardware o con el software, y quiere recuperar

algunos ficheros importantes y sacarlos del disco duro de su sistema.
A continuación, veremos más de cerca cada uno de estos escenarios.
Incapaz de Iniciar Linux
Este tipo de problemas suele estar relacionado con la instalación de otro sistema
operativo después de haber instalado Red Hat Linux. Algunos sistemas operativos
asumen que no existe ningún otro sistema operativo en su ordenador y
sobreescriben el Master Boot Record (MBR) que en un principio contenía el gestor
de arranque LILO o GRUB.
Si se sobreescribe el cargador de arranque de esta manera, no podrá iniciar Red

Hat/Fedora Linux a no ser que entre en modo rescate.
Problemas Hardware/Software
Esta categoría contiene una amplia variedad de situaciones diferentes. Dos

ejemplos serían un disco duro que se ha caído y ha dejado de funcionar, o que se
olvide de ejecutar LILO tras haber compilado un nuevo kernel. En ambas
situaciones, puede que no le sea posible iniciar Red Hat Linux.
Si puede iniciar en modo rescate, puede que consiga resolver el problema o al

menos conseguir copias de los ficheros más importantes que tenga en su sistema.
Para inciar su sistema en modo rescate, teclee el siguiente comando en la línea de
comandos al iniciar la instalación:
boot: linux rescue
Puede llegar a esta línea de comandos de diferentes maneras:
● Iniciando su sistema a partir CD 1 de instalación de Red Hat/Fedora Linux.
● Iniciando desde la red o desde un disco de inicio creado con mkbootdisk.
Una vez tenga su sistema en modo rescate, se le aparecerá una línea de

comandos en la consola virtual.

Si su sistema de ficheros principal no está dañado, podrá montarlo y ejecutar

cualquiera de las utilidades standard de Linux.
Por ejemplo, si su sistema de ficheros principal está en /dev/sda5, podrá montar

esta partición con el siguiente comando:
# mkdir /mnt/disco
# mount -t ext3 /dev/hsa5 /mnt/disco
En el comando anterior, /mnt/disco es el nombre de un directorio que usted debería

haber creado.
Si no puede montar el disco podrá fsck para verificar la integridad del disco. Está
ejecutando Linux en modo rescate. Si no conoce el nombre de sus particiones
Linux, puede intentar deducir cuales son. Montar particiones que no existen no es
peligroso.
Iniciar el modo monousuario directamente
Si su sistema inicia pero no le permite entrar al nivel de ejecución configurado,

generalmente 3 o 5, inicio, o ha olvidado la contraseña del root, puede iniciar el
modo monousuario directamente. Intente reiniciar especificando una de las
siguientes opciones en la línea de comandos del cargador de arranque.
Si está usando el gestor de arranque por defecto, GRUB, puede entrar a modo
usuario único haciendo lo siguiente:
En el menú del gestor de arranque, escriba para entrar al modo de edición.

Se le presentará con un listado de entrada de arranque. Busque una línea que sea
parecida a la siguiente:
kernel /vmlinuz-2.4.18-0.4 ro root=/dev/sda2
Pulse la tecla de la flecha hasta que línea aparezca evidenciada y pulse [a].
Presione la barra espaciadora para agregar un espacio en blanco, luego agregue la

palabra single para indicarle a GRUB que arranque en modo usuario único de
Linux. Presione para que el cambio tome efecto.
Se le devolverá a la pantalla de modo de modificación. Pulse y GRUB arrancará el

modo de Linux como usuario único.
En modo monousuario, el ordenador se inicia en el nivel de ejecución 1. Se

montará su sistema de ficheros local, pero la red no se activará. Podrá tener
acceso a un indicador de comandos de sistema.
En modo emergencia, iniciará en el entorno más reducido posible. El sistema de

ficheros principal se montará en sólo lectura y no se configurará casi nada. La

principal ventaja del modo de emergencia sobre el modo linux single es que sus
ficheros init no se cargarán. Si su init está corrupto o no funciona, podrá montar
los sistemas de ficheros para recuperar datos que se podrían perder durante una
reinstalación.
Si desea realizar una modificación de algún archivo de configuración, debe

remontar el sistema de archivos en modo lectura escritura:
# mount -o rw,remount /
Disco de inicio
Es muy recomendado que genere un disco de inicio durante la instalación o

mientras el equipo está funcionando correctamente, para generar un disco de inicio
ejecute el comando:
# mkbootdisk --iso --device bootdisk.iso `uname -r`
El disco de inicio le permite iniciar el servidor si existen problemas con el sector de

arranque. El servidor iniciará el cargador de arranque desde el CD y luego
continuará con el proceso de inicio normal desde el disco local.
Una vez iniciado, puede realizar tareas de verificación del entorno de inicio, por
ejemplo, asegurarse que el archivo /etc/grub/grub.conf están correctamente
configurados.
Para reinstalar grub ejecute el comando:

# grub-install /dev/<device>
Donde <device> es el MBR del disco correspondiente o la partición activa.
Además puede realizar una copia del mbr de un disco con el siguiente comando:
# dd if=/etc/sda of=/etc/sda.mbr bs=512 count=1
Guarde el archivo sda.mbr, puede utilizarlo para restaurar el MBR posteriormente

con el comando:
# dd if=/etc/sda.mbr of=/etc/sda bs=512 count=1

Administrador Red Hat Fedora v2-6

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Administrador Red Hat Fedora v2-6

Enviado por

Direitos autorais:

Formatos disponíveis

Administración del sistema operativo Red Hat/Fedora Linux

Instalación del sistema operativo Red Hat/Fedora Linux................................................9

Instalación del sistema operativo Red Hat/Fedora Linux

Instalación de Red Hat Linux

Aspectos básicos del hardware

Un sistema operativo debe trabajar íntimamente con el hardware que le sirve de

La CPU, o mejor, microprocesador, es el corazón de cualquier computadora. El

Los microprocesadores pueden realizar operaciones aritméticas como sumar,

Red Hat Certified Engineer 10

Para obtener información de la CPU que está utilizando el sistema ejecute el

Las memorias caché y principal deben mantenerse sincronizadas (coherentes). En

Puede obtener información de la memoria del sistema ejecutando el comando:

Los componentes individuales de la placa del sistema están conectados entre sí

11 Ing. Iván Ferreira

Para obtener información del bus pci ejecute:

Red Hat Certified Engineer 12

existen los periféricos hardware se conoce colectivamente como espacio de I/O

Típicamente, una CPU tendrá instrucciones separadas para acceder al espacio de

Para obtener información del espacio de direcciones ejecute el comando:

13 Ing. Iván Ferreira

así sucesivamente. Puede manejar estos dispositivos de forma sincronizada, es

Algunas interrupciones son fijas por convenio de la arquitectura del hardware y

Para obtener información de las interrupciones utilizadas ejecute el comando:

Instalación de Red Hat Linux

Nombres de Dispositivo en Linux

En Linux, los nombres de disco y de particiones pueden ser diferentes de otros

● La primera unidad de disquete se llama /dev/fd0.

● La segunda unidad de disquete se llama /dev/fd1.

● El primer disco SCSI se llama /dev/sda.

Red Hat Certified Engineer 14

● El segundo disco SCSI se llama /dev/sdb, etcétera.

● El primer CD-ROM SCSI se llama /dev/scd0.

● El disco maestro de la controladora IDE primaria se llama /dev/hda. El disco

● El disco maestro de la controladora IDE secundaria se llama /dev/hdc. El

Las particiones de cada disco se representan añadiendo un número decimal al

Crear un CD-ROM de arranque de instalación

Arranque de la instalación desde un USB pen drive

Si no puede arrancar desde el CD-ROM, pero puede iniciar desde un dispositivo

El BIOS debe soportar iniciar desde un dispositivo USB.

Interfaz gráfica de usuario del programa de instalación

15 Ing. Iván Ferreira

Si ha utilizado la interfaz de usuario en modo gráfico (GUI) con anterioridad, este

Si no quiere utilizar el programa de instalación GUI, está disponible el programa de

Nota sobre las consolas virtuales

Consola Combinación de teclas Contenido

Opciones de arranque adicionales

as imágenes ISO ahora tienen un md5sum integrado. Para probar la integridad

Red Hat Certified Engineer 16

Si el programa de instalación no detecta correctamente el hardware instalado,

Para ejecutar la instalación en modo texto en modo experto utilice:

Si necesita realizar una instalación en modo serie, escriba el siguiente comando:

Si tiene un disco de controlador de dispositivo (driver disk), especialmente para

En el comando anterior, <dispositivo> es el dispositivo que está utilizando (como

Opciones del kernel

Estas opciones se pueden transmitir directamente al kernel. Si por ejemplo, se

Selección de un método de instalación

Es posible iniciar el programa de instalación desde la unidad de CD y continuarla a

17 Ing. Iván Ferreira

boot: linux askmethod

La instalación puede ser realizada desde:

● CD-ROM: Si posee un lector de CD-ROM y tiene el CD-ROM de Red Hat

● Imagen NFS: Si está realizando la instalación desde un servidor NFS

● FTP: Si está realizando la instalación directamente desde un servidor FTP,

● HTTP: Si está realizando la instalación directamente desde un servidor Web