Archivo de la etiqueta: linux

Comandos de Linux: Conocer el espacio libre y ocupado en disco

A petición de Varis, pongo la descripción de un par de comandos de Linux que sirven para conocer cuanto espacio libre u ocupado tenemos en el disco duro:

  • df: Muestra el espacio libre del disco
  • du -u fichero1 … ficheroN: Muestra el total que ocupan los ficheros
  • du -s directorio: Muestra el espacio que ocupa el directorio

Si a estos comandos le añadimos además el parámetro “-h“, las cantidades saldrán en un formato de facil lectura (gigabyte, megabyte, etc.) teniendo en cuenta la cifra.

Si quereis conocer más comandos útiles para Linux, podeis pasaros por “Comandos de Linux con ejemplos“.

Anuncios

emerge Gentoo

Gentoo¡Por fin me he pasado a Gentoo!
Desde que me compré el portatil había querido instalarle esta distribución, pero principalmente por falta de tiempo no había podido hacerlo hasta ahora.
Para quien no la conozca, Gentoo (pronunciado en español yentú) es una distribución Linux basada en Portage, el sistema de paquetes de BSD. Podeis encontrar una explicación más detallada aquí.
Una de sus mayores ventajas es su versatilidad, ya que te permite crearte tu sistema desde cero, incluso compilando todos los paquetes con parametros de optimización específicos para tu máquina, lo que aumenta con creces el rendimiento.
La forma básica de instalar un paquete es muy sencilla gracias a la utilidad emerge. Por ejemplo, si queremos añadir a nuestro sistema el navegador Firefox, solo tendremos que teclear:

emerge mozilla-firefox

Los pasos que he seguido para instalar esta distribución son los que se explican en el manual oficial en castellano (apoyandome también en el inglés, porque la traducción no siempre es del todo correcta).
Por si a alguien le interesa, los parametros CFLAGS y CXXFLAGS que he usado en mi portatil (que tiene un procesador Intel Centrino Dothan a 1,5 GHz) son los siguientes:

CFLAGS=”-march=pentium4 -O2 -pipe -fomit-frame-pointer -frename-registers -fprefetch-loop-arrays -mfpmath=387 -falign-functions=64 -ffast-math -fPIC”
CXXFLAGS=”-march=pentium4 -O3 -pipe -fomit-frame-pointer -fprefetch-loop-arrays -mfpmath=387 -falign-functions=64 -ffast-math -fPIC”

He optado por empezar desde el Stage 1, es decir, compilarlo todo, para que así aproveche al maximo los recursos de mi equipo. La verdad es que para tenerlo todo listo he tardado varios días, pero creo que la espera ha merecido la pena.
Despues de instalar el sistema base, he seguido alguna de las guías de configuración del escritorio, como por ejemplo la de XOrg, Gnome, Alsa, etc.
También me han sido utiles el Manual para castellanizar Gentoo , The Gentoo Framebuffer, Bootsplash & Grubsplash How-To y la Documentación sobre Guiones de inicio.
Aún se me quedan otras cosas en el tintero que espero poder ir comentando en sucesivos posts.

Guadalinex 2004

GuadalinexYa ha salido la versión 2004 de la distribución Linux Guadalinex. Para quienes no la conozcan, decir que esta basada en Debian y es de tipo LiveCD (se ejecuta directamente desde el CD-ROM), aunque también se puede instalar en el disco duro (que es lo que yo he hecho). Además, trae por defecto el entorno de escritorio Gnome.
La verdad es que es bastante completa, e incluso me funcionan cosas como el Bluetooth, lo que me permite sincronizar fácilmente mi móvil con el Ximian Evolution.
Ahora solo me queda recompilar el kernel para darle soporte a mi procesador Centrino e instalar los drivers WiFi. Si consigo que estas dos cosas vayan bien, probablemente quite el Windows XP de mi portátil, el cual ahora mismo uso solo en casos puntuales en los que no me queda más remedio.

Sobre el Agali Hackmeeting 2K4

Como le prometí a Cek, voy a intertar hacer un resumen del Hackmeeting que tuvo lugar hace un par de fin de semanas aquí en El Puerto.

Aunque había un monton de eventos programados, lo que más me interesaba eran las conferencias, en las cuales aprendí mucho del estado actual del mundillo del Linux.
Por ejemplo, la que más me entusiasmo fue la conferencia sobre Mono. Para quien no lo sepa, Mono es la adaptación libre de la plataforma .NET de Microsoft. ¿Que quiere decir esto? Pues que un programa compilado en .NET bajo Windows, ahora es posible ejecutarlo sobre Linux, Mac o cualquier otra sistema que tenga Mono, o viceversa (aunque todavía tiene algunas limitaciones). Yo mismo vi con mis propios ojos como compilaban un programa en Linux y lo ejecutaban perfectamente en Windows!!!

Aparte de las conferencias, gracias a algunos de los participantes descubrí el escritorio Gnome, para mi gusto (ahora que ya lo he probado bastante) mucho mejor que KDE. O como me decía uno de los organizadores citando a Icaza: “KDE es como la Pepsi, todo el mundo lo conoce, esta muy bien y blablabla, pero en cambio, Gnome es mas como un buen vino, algo de calidad”.

Bueno tampoco quiero explayarme mucho, ya que toda la información, incuyendo fotos, conferencias, etc. lo podeis encontrar en la web de Agali.

Frikeando

Siguiendo el ejemplo de Awacate, yo también me he animado a escribir un post desde Links (un navegador en modo texto para Linux). Aunque yo voy a intentar que salgan correctamente los carácteres acentuados 😛
Seguro que ahora mi puntuació en los frikitests es mayor 🙂

P.D.: Ahora que lo pienso, este es mi primer post desde Linux!!!

— Actualización —
Y ya que estamos, nada mejor que editar esta entrada tan friki usando mi Pocket PC conectada al ordenador mediante Bluetooth 😀

(Nota: Para facilitar su comprensión, en esta guía supondremos que la versión actual de nuestro núcleo es la 2.6.4 y la nueva que vamos a compilar es la 2.6.8 aplicándole el patch de la 2.6.9-rc1)

  1. Arrancamos Linux
  2. Si estamos en entorno gráfico, abrimos una consola
  3. Si no hemos arrancado como root, simulamos un login:

    su

    Introducimos el password del root

  4. Comprobamos la versión del núcleo que tenemos:

    uname -sr

  5. Abrimos un navegador y comprobamos en kernel.org la versión estable más reciente (Es la que aparece en la linea que pone: The latest stable version of the Linux kernel is…)
  6. La descargamos en /usr/src/ (el enlace de descarga es la letra F que aparece a la derecha de la fecha del kernel). Apuntad la extensión del archivo descargado (tar.bz2 o tar.gz) para usarlo posteriormente en la descompresión
  7. Si nuestra máquina cuenta con algún componente no soportado por la última versión estable del núcleo, pero si por una proxima versión de la que actualmente solo existe un parche (como me sucede a mi con mi procesador Intel Centrino “Dothan”), descargaramos también el parche al mismo directorio que el kernel (yo tuve que descargar el prepatch 2.6.9-rc1).
  8. Cerramos el navegador y volvemos a la consola
  9. Entramos en el directorio /usr/src/

    cd /usr/src/

  10. Comprobamos el contenido del directorio:

    ls -l

    En caso de existir un enlace simbolico llamado linux@, lo borramos:

    rm linux

    En cambio, si linux es un directorio, lo renombramos a linux-2.6.4:

    mv linux linux-2.6.4

  11. Descomprimimos el nuevo kernel (se llamará linux-2.6.8.EXT, donde EXT indica la extensión):

    En caso de que la extensión sea tar.bz2

    tar -jvxf linux-2.6.8.tar.bz2

    O si es tar.gz

    tar -zxvf linux-2.6.8.tar.gz

  12. Creamos un enlace simbolico al directorio de la nueva versión:

    ln -s linux-2.6.8 linux

  13. Entramos en el directorio linux:

    cd linux

  14. Parcheamos el kernel (esto solo es necesario si hemos descargado un parche como se indico anteriormente):

    bzcat ../patch-2.6.9-rc1.bz2 | patch -p1

  15. Si ya habíamos compilado anteriormente el núcleo, ejecutamos:

    make mrproper

  16. Hacemos un listado del directorio /boot/:

    ls -la /boot/

    En caso de que exista en ese directorio el archivo de configuración para la compilación del núcleo actual (será un archivo que contenga la palabra config), lo copiamos al directorio linux (en el que nos encontramos):

    cp nombre_del_archivo_config .config

    Y despues ejecutariamos:

    make oldconfig

    Con esto actualizariamos el archivo .config con las opciones del nuevo núcleo. Si en este proceso nos hace alguna pregunta, simplemente pulsaremos INTRO para seleccionar la opción por defecto.

  17. Ahora pasaremos a configurar el kernel, para ello tenemos tres opciones:

    Modo grafico xwindows:

    make xconfig

    Modo grafico de consola:

    make menuconfig

    Modo consola:

    make config

    Yo recomiendo que utilizeis la primera o en todo caso la segunda opción.
    Configuramos las opciones que necesitemos y una vez acabemos salvamos el archivo de configuración y salimos del asistente.

    (Nota: Podeis copiar el archivo .config a otro lugar para su posterior uso en otras compilaciones. Yo lo que hago es copiarlo al directorio /boot/ renombrandolo a .config-2.6.9-rc1)

  18. Ahora llega el momento de compilar, para ello ejecutamos:

    make dep && make clean && make bzImage

    Según la potencia de nuestra máquina puede tardar un buen rato.

  19. Una vez compilado el núcleo, le toca el turno a los módulos:

    make modules && make modules_install

    Esto también tardará otro rato (probablemente más que la compilación del núcleo)

  20. Copiamos el fichero System.map y el núcleo obtenido (que se encuentra en /usr/src/linux/arch/i386/boot/bzImage, si nuestra arquitectura es i386) al directorio /boot , con los nombres System.map-2.6.9-rc1 y vmlinuz-2.6.9-rc1:

    cd /boot
    cp /usr/src/linux/System.map System.map-2.6.9-rc1
    cp /usr/src/linux/arch/i386/boot/bzImage vmlinux-2.6.9-rc1

    Conviene además que creemos en ese directorio unos enlaces simbólicos System.map y vmlinuz apuntando a ellos:

    rm System.map
    ln -s System.map-2.6.9-rc1 System.map
    rm vmlinuz
    ln -s vmlinuz-2.6.9-rc1 vmlinuz

  21. Por último, actualizaremos si es necesario el fichero de configuración de nuestro gestor de arranque. En teoría no hace falta, ya que al arrancar se usa el System.map y vmlinuz que son enlaces simbolicos que ahora apuntan al las nuevas versiones, aunque nunca esta de más añadir una entrada para el antiguo núcleo por si el nuevo falla.

    Para ello editaremos el archivo /etc/lilo.conf (si utilizamos LILO) o /boot/grub/menu.lst (si usamos GRUB) y haremos los cambios pertinentes, o también podemos utilizar la utilidad de configuración del gestor de arranque que traiga nuestra distribución de Linux (la mayoría de modernas distribuciones trae una).

  22. Luego reiniciaremos la maquina, que arrancará con el nuevo núcleo, como comprobaremos con:

    uname -sr

Para realizar esta guía me he basado en otras disponibles en Internet, como por ejemplo:
Guía de compilación del núcleo Linux para torpes 😉
Como compilar un Kernel paso a paso
Cómo parchear el kernel