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................................................9Aspectos 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.........................................................................23El 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...........................................................43Proceso 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..............................................................................................54Usuarios 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...................................................................................65Gestió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 ................................................................................................84Configuració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.......................................................................109GRUB.............................................................................................................................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.............................................................................................124Actualizació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.......................................................................................................138El 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...................................................................................................160Diagnó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 Contenido1 [Ctrl]-[Alt]-[F1] Diálogo de instalación2 [Ctrl]-[Alt]-[F2] Intérprete de comandos de la shell3 [Ctrl]-[Alt]-[F3] Log de instalación4 [Ctrl]-[Alt]-[F4] Mensajes de sistema5 [Ctrl]-[Alt]-[F5] Otros mensajes7 [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/sdaCommand (m for help): pDisk /dev/sda: 255 heads, 63 sectors, 784 cylindersUnits = cylinders of 16065 * 512 bytesDevice 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 swapCommand (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 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 casospodrí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): pDisco /dev/sdb: 15.0 GB, 15020457984 bytes240 cabezas, 63 sectores/pista, 1940 cilindrosUnidades = 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): dSe ha seleccionado la partición 1

Orden (m para obtener ayuda): p

Disco /dev/sdb: 15.0 GB, 15020457984 bytes240 cabezas, 63 sectores/pista, 1940 cilindrosUnidades = cilindros de 15120 * 512 = 7741440 bytes

Disposit. Inicio Principio Fin Bloques Id Sistema



Orden (m para obtener ayuda): nAcción de la ordene Partición extendidap Partición primaria (1-4)pNúmero de partición (1-4): 1Primer cilindro (1-1940, valor predeterminado 1): [ENTER]Último cilindro o +tamaño o +tamañoM o +tamañoK (1-1940, valor predeterminado 1940): +2048M

Orden (m para obtener ayuda): nAcción de la ordene Partición extendidap Partición primaria (1-4)eNúmero de partición (1-4): 2Primer cilindro (267-1940, valor predeterminado 267): [ENTER]Último cilindro o +tamaño o +tamañoM o +tamañoK (267-1940, valor predeterminado 1940): [ENTER]

Orden (m para obtener ayuda): pDisco /dev/sdb: 15.0 GB, 15020457984 bytes240 cabezas, 63 sectores/pista, 1940 cilindrosUnidades = cilindros de 15120 * 512 = 7741440 bytes

Disposit. Inicio Principio Fin Bloques Id Sistema/dev/sdb1 1 266 2010928+ 83 Linux/dev/sdb2 267 1940 12655440 5 Extendida

Orden (m para obtener ayuda): nAcción de la ordenl Partición lógica (5 o superior) p Partición primaria (1-4)lPrimer cilindro (267-1940, valor predeterminado 267): [ENTER]Último cilindro o +tamaño o +tamañoM o +tamañoK (267-1940, valor predeterminado 1940): +1024MOrden (m para obtener ayuda): nAcción de la ordenl Partición lógica (5 o superior)p Partición primaria (1-4)lPrimer cilindro (400-1940, valor predeterminado 400): [ENTER]Último cilindro o +tamaño o +tamañoM o +tamañoK (400-1940, valor predeterminado 1940): +1024MOrden (m para obtener ayuda): pDisco /dev/sdb: 15.0 GB, 15020457984 bytes240 cabezas, 63 sectores/pista, 1940 cilindrosUnidades = cilindros de 15120 * 512 = 7741440 bytes

Disposit. Inicio Principio Fin Bloques Id Sistema/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/sdb1mke2fs 1.34 (25-Jul-2003)Filesystem label=OS type: LinuxBlock size=4096 (log=2)Fragment size=4096 (log=2)251392 inodes, 502732 blocks25136 blocks (5.00%) reserved for the super userFirst data block=016 block groups32768 blocks per group, 32768 fragments per group15712 inodes per groupSuperblock backups stored on blocks: 32768, 98304, 163840, 229376, 294912

Writing inode tables: doneCreating journal (8192 blocks): doneWriting superblocks and filesystem accounting information: done

This filesystem will be automatically checked every 32 mounts or180 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/sdb1tune2fs 1.34 (25-Jul-2003)Setting maximal mount count to -1Setting interval between check 0 secondsSetting 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 errores1 Errores corregidos2 El sistema debería ser reiniciado4 Errores de sistemas de archivos no corregidos8 Error operacional16 Error de sintaxis32 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/cdromusbdisk -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/inndK05saslauthd->../init.d/saslauthdK10psacct->../init.d/psacct...S95atd->../init.d/atdS97rhnsd->../init.d/rhnsdS99local->../rc.localS99mdmonitor->../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 = 2kernel.sysrq = 0kernel.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 completo4 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 nombredegrupo

Nombre o número del grupo para el grupo predeterminado del usuario (El grupo debe existir.)

-G listadegrupo

Lista de nombres de los grupos adicionales (además del 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/bashbin:x:1:1:bin:/bin:ftp:x:404:1::/home/ftp:/bin/bashdaemon: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:rootbin::1:root,bin,daemondaemon::2:root,bin,daemonsys::3:root,bin,admadm::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ónLas 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 packagebar-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ónS Tamaño del archivoL Enlace simbólicoT Hora de modificación de archivoD Dispositivo U Usuario propietarioG Grupo propietarioM 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 ESTInstall date: (not installed) Build Host: porky.devel.redhat.comGroup : System Environment/Base Source RPM: crontabs-1.10-5.src.rpmSize : 1004 License: Public DomainSignature : DSA/SHA1, Tue 11 Feb 2003 01:46:46 PM EST, Key ID fd372689897da07aPackager : 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 theprogram used to install, uninstall, or list the tables used to drive thecron daemon. The cron daemon checks the crontab files to see whenparticular commands are scheduled to be executed. If commands arescheduled, 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 ESTInstall date: (not installed) Build Host: porky.devel.redhat.comGroup : System Environment/Base Source RPM: crontabs-1.10-5.src.rpmSize : 1004 License: Public DomainSignature : DSA/SHA1, Tue 11 Feb 2003 01:46:46 PM EST, Key ID fd372689897da07aPackager : 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 theprogram used to install, uninstall, or list the tables used to drive thecron daemon. The cron daemon checks the crontab files to see whenparticular commands are scheduled to be executed. If commands arescheduled, 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 [email protected]. 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 downloadthe keys for packages you wish to install and install them.You can do that by running the command: rpm --import public.gpg.keyFor 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/$basearch/os/mirrorlist=http://fedora.redhat.com/download/mirrors/fedora-core-$releaseverenabled=1gpgcheck=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/$releasever/$basearch/mirrorlist=http://fedora.redhat.com/download/mirrors/updates-released-fc$releaseverenabled=1gpgcheck=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.mirrorshttp://www.las.ic.unicamp.br/pub/fedora/linux/core/$releasever/$basearch/osftp://mirror.netglobalis.net/pub/fedora/$releasever/$basearch/os

# cat /etc/yum.repos.d/sudamerica-updates.mirrorshttp://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]name=Fedora Core $releasever - $basearch - Base#baseurl=http://download.fedora.redhat.com/pub/fedora/linux/core/$releasever/$basearch/os/#mirrorlist=http://fedora.redhat.com/download/mirrors/fedora-core-$releasevermirrorlist=file:///etc/yum.repos.d/sudamerica-base.mirrorsenabled=1gpgcheck=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/$releasever/$basearch/#mirrorlist=http://fedora.redhat.com/download/mirrors/updates-released-fc$releasevermirrorlist=file:///etc/yum.repos.d/sudamerica-updates.mirrors



enabled=1gpgcheck=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/$basearch/mirrorlist=http://fedora.redhat.com/download/mirrors/fedora-core-rawhideenabled=1gpgcheck=1

FreshRPMs.net:

# cat /etc/yum.repos.d/freshrpms.repo[core]name=FreshRPMS-Corebaseurl=http://ayo.freshrpms.net/fedora/linux/$releasever/$basearch/coreenabled=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-Updatesbaseurl=http://ayo.freshrpms.net/fedora/linux/$releasever/$basearch/updatesenabled=1#gpgcheck=1[freshrpms]name=FreshRPMS-Freshbaseurl=http://ayo.freshrpms.net/fedora/linux/$releasever/$basearch/freshrpmsenabled=1#gpgcheck=1

Livna.org:

# cat /etc/yum.repos.d/livna.repo[livna]name=Livna Stablebaseurl=http://rpm.livna.org/fedora/$releasever/$basearch/RPMS.stable/enabled=1#gpgcheck=1



Dag:

# cat /etc/yum.repos.d/dag.repo[dag]name=Dagbaseurl=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]name=Fedora Core $releasever - $basearch - Basebaseurl=http://nombre_servidor/Fedora/Core/$releasever/base/

Luego configure el archivo /etc/yum.repos.d/fedora-updates.repo

[updates-released]name=Fedora Core $releasever - $basearch - Released Updatesbaseurl=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]name=Fedora Core $releasever - $basearch - Basebaseurl=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 Updatesbaseurl=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 Timeactive 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 stathp2100: printer is on device 'lpd' speed -1 queuing is enabled printing is enabled no entries daemon present

# disable hp2100

# lpc stathp2100: printer is on device 'lpd' speed -1 queuing is enabled printing is disabled no entries daemon present

# lpc stathp2100: printer is on device 'lpd' speed -1 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|restartservice 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.hourly02 4 * * * root run-parts /etc/cron.daily22 4 * * 0 root run-parts /etc/cron.weekly42 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 semanalmenteweekly# 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 directorioinclude /usr/etc/logrotate.other # directivas para el fichero de logs /var/log/messages/var/log/messages { daily errors [email protected] 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.statuslogrotate 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:

[email protected]:/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 [email protected]:/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 [email protected]:/backup/oracle.star

Para restaurar la copia de seguridad, ejecute el comando:

# cd /oracle# env RSH=/usr/bin/ssh star -xv [email protected]:/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 Linuxroot <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-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.

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=0timeout=10splashimage=(hd0,0)/grub/splash.xpm.gz

# Seccion de carga de Linuxtitle 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 Windowstitle 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# umount /media/cdrom

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 languagelang es_ES#Language modules to installlangsupport --default=es_ES#System keyboardkeyboard es#System mousemouse --emulthree generic3ps/2#Sytem timezonetimezone America/Asuncion#Root passwordrootpw --iscrypted $1$S4JF3R6X$KztfX/S8HcjepRnwB0eeD.#Reboot after installationreboot#Use text mode installtext#Install Red Hat Linux instead of upgradeinstall#Use NFS installation Medianfs --server=192.168.24.1 --dir=/RedHat#System bootloader configurationbootloader --location=mbr#Clear the Master Boot Recordzerombr yes#Partition clearing informationclearpart --all --initlabel#Disk partitioning informationpart /boot --fstype ext3 --size 100 --asprimarypart swap --size 128 --asprimarypart / --fstype ext3 --size 1 --grow --asprimary#System authorization infomationauth --useshadow --enablemd5#Network informationnetwork --bootproto=dhcp --device=eth0#Firewall configurationfirewall --disabled#XWindows configuration informationxconfig --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/hdadefault=3timeout=10splashimage=(hd0,0)/grub/splash.xpm.gztitle 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.imgtitle 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 taintediptable_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 1microcode 5184 0 (autoclean)keybdev 2976 0 (unused)mousedev 5656 1hid 22308 0 (unused)input 6208 0 [keybdev mousedev hid]usb-uhci 27468 0 (unused)usbcore 82752 1 [hid usb-uhci]ext3 91464 2jbd 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# make modules_install

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 modules_install# 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 estoes 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 240HorizSync 30.0 - 70.0VertRefresh 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 una entrada requerida.

● 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 16SubSection "Display"

Depth 24Modes "1280x1024" "1280x960" "1152x864" "1024x768" "800x600"

"640x480"EndSubSectionSubSection "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 una entrada requerida.

● 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 0666EndSection

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.

● default-point-size - Configura el tamaño de punto por defecto para cualquier 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.

● error-file - Le permite especificar la ruta y el nombre de archivo donde se 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


Documents

Administrador Red Hat Fedora v2-6