En esta plática vemos cómo se desarrolla una distribución linux.

1. ¿Cómo crear una
distribución?
Mauro Parra-Miranda
mauro@masutostudios.com

2. Índice
• ¿Qué es una distribución de linux?
• Circulo virtuoso de una distro.
• Distribuciones personalizadas
• Links

3. ¡Advertencia!
• Esta es solo un vistazo al estado del arte
alrededor de la creación de una distribución.
• El demonio esta en los detalles.
• Su kilometraje puede variar - hay cosas que
se omiten u obvian, podria ser que falten
algunos pasos, depende de cada uno.
• Preguntas: mauro@masutostudios.com

4. Distro Linux

5. DistroWatch
• http://distrowatch.com/
• Ubuntu
• openSUSE
• Mint
• Fedora
• Debian

6. Linux From Scratch
• Partamos de un sistema estable. Puede ser
una distribución minima que cumpla con los
requisitos de compilación.
• U olvide todo y boteé con este LiveCD:
http://www.linuxfromscratch.org/livecd/

7. Linux From Scratch
• Crear una nueva partición: (digamos la
segunda primaria del primer disco IDE).
$ fdisk
>c
>n
>p
>2
> t 83 (linux partition)
>q

8. Linux From Scratch
• Crear el filesystem:
$ mkfs2.ext2 /dev/hda2
• Si hicimos una partición swap,
necesitariamos hacer (pensando en que esta
en la particion 3):
$ mkswap /dev/hda3
• $ mkdir /mnt/lfs ; export LFS=/mnt/lfs
$ mount /dev/hda2 /mnt/lfs

9. Linux From Scratch
• $ mkdir -v $LFS/sources
• $ chmod -v a+wt $LFS/sources
• Bajar estos fuentes al dir sources:
http://www.linuxfromscratch.org/lfs/view/
stable/chapter03/packages.html
• Y estos parches:
http://www.linuxfromscratch.org/lfs/view/
stable/chapter03/patches.html

10. Linux From Scratch
• $ echo $LFS
• $ export LFS=/mnt/lfs
• $ mkdir -v $LFS/tools
• $ sudo ln -sv $LFS/tools /
• groupadd lfs
• useradd -s /bin/bash -g lfs -m -k /dev/null lfs

11. Linux From Scratch
• $ passwd lfs
• $ chown -v lfs $LFS/tools
• $ chown -v lfs $LFS/sources
• $ su - lfs
• $ cat > ~/.bash_profile << "EOF"
exec env -i HOME=$HOME TERM=$TERM
PS1='u:w$ ' /bin/bash
EOF

12. Linux From Scratch
• $ cat > ~/.bashrc << "EOF"
set +h
umask 022
LFS=/mnt/lfs
LC_ALL=POSIX
PATH=/tools/bin:/bin:/usr/bin
export LFS LC_ALL PATH
EOF

13. Linux From Scratch
• $ source ~/.bash_profile
• Advertencia: El compilar todos estos
paquetes puede tomar MUCHO tiempo,
dependiendo de la maquina. Firefox en una
Intel Core 2 Duo con 4 G de RAM, tarda 45
minutos, por ejemplo.

14. Linux From Scratch
• binutils - 213 M (ld, as, largo ETC)
• $ patch -Np1 -i ../binutils-2.18-
configure-1.patch
$ mkdir -v ../binutils-build
$ cd ../binutils-build
$ export CC="gcc -B/usr/bin/" ../
binutils-2.18/configure --prefix=/tools --
disable-nls --disable-werror
$ make

15. Linux From Scratch
• $ make install
$ make -C ld clean
$ make -C ld LIB_PATH=/tools/lib
$ cp -v ld/ld-new /tools/bin
• gcc - 1.1 G
• linux API headers - 341M
• glibc - 407 M

16. Linux From Scratch
• Lo que ya se tiene compilado, nos genera un
sistema básico, contra el cual ligaremos los
binarios que a partir de este momento
construyamos.
• $ mv -v /tools/bin/{ld,ld-old}
$ mv -v /tools/$(gcc -dumpmachine)/bin/
{ld,ld-old}
$ mv -v /tools/bin/{ld-new,ld}
$ ln -sv /tools/bin/ld /tools/$(gcc -
dumpmachine)/bin/ld

17. Linux From Scratch
• gcc es inteligente, por lo que revisa los
headers y busca los que esten “mal”. Genera
headers correctos y hace una copia
“particular”. Esto puede generar problemas
en el futuro, por lo que es necesario eliminar
esos headers arreglados, porque
generaremos los correctos en el futuro
cercano.

18. Linux From Scratch
• $ gcc -dumpspecs | sed 's@/lib/ld-linux.so.
2@/tools&@g' > `dirname $(gcc -print-
libgcc-file-name)`/specs
• $ GCC_FIXED=`dirname $(gcc -print-
libgcc-file-name)`/include-fixed &&
find ${GCC_FIXED}/* -maxdepth 0 -xtype d
-exec rm -rvf '{}' ; && rm -vf `grep -l "DO
NOT EDIT THIS FILE" ${GCC_FIXED}/*`
&& unset GCC_FIXED

19. Linux From Scratch
• tcl - 36 MB (lenguaje de script)
• expect - 4 MB (herramienta para
automatizacion)
• DejaGNU - 6.2 MB (Framework para
testing)
• GCC (2da vuelta) - 865 M (con soporte a
mas lenguajes)
• binutils (2da vuelta) - 177 MB (actualización
del linker, con soporte a todo lo que hemos
compilado ya)

20. Linux From Scratch
• ncurses - 30 MB (sistemas graficos en texto)
• bash - 22 MB (shell)
• bzip2 - 4.8 MB (herramienta para
comprimir)
• coreutils - 83 MB (programas varios para
manipular archivos, cat, chroot, etc.)
• diffutils - 6.2 MB (herramientas para hacer
diff)
• E2fsprogs - 37 MB (utilidades para mantener
ext2, ext3 y ext4)

21. Linux From Scratch
• gawk - 19 MB (awk, lenguaje de
programacion)
• gettext - 83 MB (soporte para localizacion)
• grep - 6.9 MB
• gzip - 2.2 MB
• M4 - 10 MB (lenguaje de marcado)
• make - 9.6 MB
• Patch - 1.6 MB

22. Linux From Scratch
• Perl - 108 MB
• sed - 6.1 MB
• tar - 19.9 MB
• texinfo - 20 MB
• Util-linux-ng - 19 MB (utilidades varias)

23. Linux From Scratch
• Stripping ...
$ strip --strip-debug /tools/lib/*
$ strip --strip-unneeded /tools/{,s}bin/*
$ rm -rf /tools/{info,man}
• Cambie al usuario root y haga:
$ chown -R root:root $LFS/tools

24. Linux From Scratch
• Preparando sistema virtual de archivos:
$mkdir -pv $LFS/{dev,proc,sys}
• Creando los nodos iniciales de dispositivos:
$ mknod -m 600 $LFS/dev/console c 5 1
$ mknod -m 666 $LFS/dev/null c 1 3
• Montando y poblando /dev :
$ mount -v --bind /dev $LFS/dev

25. Linux From Scratch
• Montando los sistemas de archivos virtuales:
$ mount -vt devpts devpts $LFS/dev/pts
$ mount -vt tmpfs shm $LFS/dev/shm
$ mount -vt proc proc $LFS/proc
$ mount -vt sysfs sysfs $LFS/sys

26. Linux From Scratch
• Estrategia de administración de paquetes
• Ninguna. Todo esta en tu cabeza.
• Instalar en distintos directorios:
/usr/package/foo-1 y /usr/package/foo-2 y
despues crear enlaces simbolicos para usar
uno u otro.

27. Linux From Scratch
• Symlink:
• Tienes que usar un truco para que aunque
el paquete se instale en /usr/pkg/foo,
aparezca bajo /usr para que el linker
funcione correctamente (hint: use
DESTDIR)
$ ./configure --prefix=/usr
$ make
$ make DESTDIR=/usr/pkg/libfoo/1.1
install

28. Linux From Scratch
• Marcas de tiempo.
• Obten el timestamp actual (t0).
• Instala todo.
• Con find, busca todo archivo cuyo
timestamp sea posterior a el time t0 ->
Guarda eso en un archivo.

29. Linux From Scratch
• Haciendo un seguimiento del “make install”;
se puede hacer de dos formas:
• definir LD_PRELOAD con “algo” que vaya
tomando nota cuando se ejecuten cp,
install y/o mv.
• usar strace para ir cachando las llamadas
de sistema.

30. Linux From Scratch
• Creando una lista de cada paquete, con sus
archivos relacionados.
• La instalación se lleva a cabo en un
subdirectorio “fake”, como se vio en el
estilo “Symlink” (hint: $DESTDIR).
• Asi funciona RPM, debian apt-get, el
sistema de portage de Gentoo y pkg-utils.

31. Linux From Scratch
• Hora de entrar a la jaula (corra como root):
$ chroot "$LFS" /tools/bin/env -i
HOME=/root TERM="$TERM"
PS1='u:w$ '
PATH=/bin:/usr/bin:/sbin:/usr/sbin:/tools/bin
/tools/bin/bash --login +h
• Cuando entre, bash podria quejarse con el “I
have no name!”. Que es normal, porque no
tenemos /etc/passwd aun.

32. Linux From Scratch
• Creemos/{bin,boot,etc/opt,home,lib,mnt,opt} de Linux:
$ mkdir -pv
los directorios “clasicos”
$ mkdir -pv /{media/{floppy,cdrom},sbin,srv,var}
$ install -dv -m 0750 /root
$ install -dv -m 1777 /tmp /var/tmp
$ mkdir -pv /usr/{,local/}{bin,include,lib,sbin,src}
$ mkdir -pv /usr/{,local/}share/{doc,info,locale,man}
$ mkdir -v /usr/{,local/}share/{misc,terminfo,zoneinfo}
$ mkdir -pv /usr/{,local/}share/man/man{1..8}
$ for dir in /usr /usr/local; do
ln -sv share/{man,doc,info} $dir
done
$ mkdir -v /var/{lock,log,mail,run,spool}
$ mkdir -pv /var/{opt,cache,lib/{misc,locate},local}

33. Linux From Scratch
• Crear algunos archivos básicos:
$ ln -sv /tools/bin/{bash,cat,echo,grep,pwd,stty} /bin
$ ln -sv /tools/bin/perl /usr/bin
$ ln -sv /tools/lib/libgcc_s.so{,.1} /usr/lib
$ ln -sv /tools/lib/libstdc++.so{,.6} /usr/lib
$ ln -sv bash /bin/sh
$ touch /etc/mtab
$ cat > /etc/passwd << "EOF"
root:x:0:0:root:/root:/bin/bash
nobody:x:99:99:Unprivileged User:/dev/null:/bin/false
EOF

34. Linux From Scratch
• Crear /etc/group
$ cat > /etc/group << "EOF"
root:x:0:
bin:x:1:
sys:x:2:
kmem:x:3:
tty:x:4:
tape:x:5:
daemon:x:6:
floppy:x:7:
disk:x:8:
lp:x:9:
uucp:x:10:
audio:x:11:
video:x:12:
utmp:x:13:
usb:x:14:
cdrom:x:15:
mail:x:34:
nogroup:x:99:
EOF

35. Linux From Scratch
• Arrancar el bash de nuevo, para no ver el
anuncio de “no tiene nombre”:
$ exec /tools/bin/bash --login +h
• Crear los archivos de log
$touch /var/run/utmp /var/log/{btmp,lastlog,wtmp}
$ chgrp -v utmp /var/run/utmp /var/log/lastlog
$ chmod -v 664 /var/run/utmp /var/log/lastlog

36. Linux From Scratch
• Glibc usará el API del kernel. Tenemos que
“limpiarlo” para la ejecución actual.
$ make mrproper
$ make headers_check
$ make INSTALL_HDR_PATH=dest headers_install
$ cp -rv dest/include/* /usr/include

37. Linux From Scratch
• Para instalar las man pages, entrar al
directorio y correr $make install
• Sigue el ajustar glibc para el ambiente actual.
Esto será muy delicado, incluye muchisimos
pasos.Vea las instrucciones a detalle en:
• http://www.linuxfromscratch.org/lfs/view/stable/chapter06/glibc.html

38. Linux From Scratch
• Despues del paso de la muerte, es necesario
ajustar nuestro toolchain a nuestro glibc
final.
$ mv -v /tools/bin/{ld,ld-old}
$ mv -v /tools/$(gcc -dumpmachine)/bin/{ld,ld-old}
$ mv -v /tools/bin/{ld-new,ld}
$ ln -sv /tools/bin/ld /tools/$(gcc -dumpmachine)/bin/ld

39. Linux From Scratch
• Para revisar que TODO funciona bien,
correr:
$ echo 'main(){}' > dummy.c
$ cc dummy.c -v -Wl,--verbose &> dummy.log
$ readelf -l a.out | grep ': /lib'
• Revisar que el nuevo linker se usa:
$ grep 'SEARCH.*/usr/lib' dummy.log |sed 's|; |n|g’

40. Linux From Scratch
• La salida debe ser algo como esto:
SEARCH_DIR("/tools/i686-pc-linux-gnu/lib")
SEARCH_DIR("/usr/lib")
SEARCH_DIR("/lib");
• ¿usamos la libc adecuada?
$ grep "/lib/libc.so.6 " dummy.log
salida:
attempt to open /lib/libc.so.6 succeeded

41. Linux From Scratch
• ¿usamos el linker dinamico correcto?
$ grep found dummy.log
salida:
found ld-linux.so.2 at /lib/ld-linux.so.2
• Con esto, ya podemos seguirnos con los
demas fuentes, basicamente es ./configure,
make, make install.

42. Linux From Scratch
• ¿usamos el linker dinamico correcto?
$ grep found dummy.log
salida:
found ld-linux.so.2 at /lib/ld-linux.so.2
• Con esto, ya podemos seguirnos con los
demas fuentes, basicamente es ./configure,
make, make install.

43. Linux From Scratch
• Ahora necesitamos poner los scripts de
booteo.
• Hay que compilar/instalar el paquete LFS-
Bootscripts-20081031
• Usaremos el bootscript al estilo SysVinit.
Tenemos 6 tipos de funcionamiento:
0: halt the computer
1: single-user mode
2: multi-user mode without networking
3: multi-user mode with networking
4: reserved for customization, otherwise does the same as 3
5: same as 4, it is usually used for GUI login (like X's xdm or KDE's kdm
6: reboot the computer

44. Linux From Scratch
• Los scripts se guardan en /etc/rc.d/init.d, los
argumentos de los scripts son algo como:
start - The service is started.
stop - The service is stopped.
restart - The service is stopped and then started again.
reload - The configuration of the service is updated.
This is used after the configuration file of a service was
modified, when the service does not need to be
restarted.
status - Tells if the service is running and with which
PIDs.

45. Linux From Scratch
• Crear>el /etc/hosts "EOF"
$ cat /etc/hosts <<
# Begin /etc/hosts (network card version)
127.0.0.1 localhost
<192.168.1.1> <HOSTNAME.example.org>
[alias1] [alias2 ...]
# End /etc/hosts (network card version)
EOF

46. Linux From Scratch
• Configurando las interfaces de red:
$ for NIC in /sys/class/net/* ; do
INTERFACE=${NIC##*/} udevadm test --
action=add --subsystem=net $NIC;
done

47. Linux From Scratch
• Ejemplo de archivo ipv4 para una interfaz de
red:
$ cd /etc/sysconfig/network-devices
$ mkdir -v ifconfig.eth0
$ cat > ifconfig.eth0/ipv4 << "EOF"
ONBOOT=yes
SERVICE=ipv4-static
IP=192.168.1.1
GATEWAY=192.168.1.2
PREFIX=24
BROADCAST=192.168.1.255
EOF

48. Linux From Scratch
• Creando el /etc/resolv.conf
$ cat > /etc/resolv.conf << "EOF"
# Begin /etc/resolv.conf
domain <Your Domain Name>
nameserver <IP address of your primary nameserver>
nameserver <IP address of your secondary nameserver>
# End /etc/resolv.conf
EOF

49. Linux From Scratch
• Haciendo booteable nuestro sistema.
Crearemos primero un fstab.
$ cat > /etc/fstab << "EOF"
# Begin /etc/fstab
# file system mount-point type options #dump fsck order
/dev/<xxx> / <fff> defaults 1 1
/dev/<yyy> swap swap pri=1 0 0
proc /proc proc defaults 0 0
sysfs /sys sysfs defaults 0 0
devpts /dev/pts devpts gid=4,mode=620 0 0
tmpfs /dev/shm tmpfs defaults 0 0
# End /etc/fstab
EOF

50. Linux From Scratch
• Instalar el kernel:
$ make mrproper
$ make LANG=<host_LANG_value> LC_ALL=
menuconfig
$ make
$ make modules_install
$ cp -v arch/x86/boot/bzImage /boot/lfskernel-2.6.27.4
$ cp -v System.map /boot/System.map-2.6.27.4
$ cp -v .config /boot/config-2.6.27.4
$ install -d /usr/share/doc/linux-2.6.27.4
$ cp -r Documentation/* /usr/share/doc/linux-2.6.27.4

51. Linux From Scratch
• Instalando grub:
$ dd if=/boot/grub/stage1 of=/dev/fd0
bs=512 count=1
$ dd if=/boot/grub/stage2 of=/dev/fd0
bs=512 seek=1
$ grub
> root (hd0,3)
> setup (hd0)
> quit

52. Linux From Scratch
• Añadir entrada pal host:
cat >> /boot/grub/menu.lst << "EOF"
title Red Hat
root (hd0,2)
kernel /boot/kernel-2.6.5 root=/dev/hda3
initrd /boot/initrd-2.6.5
EOF

53. Linux From Scratch
• Y si quieres que funcione windows:
$ cat >> /boot/grub/menu.lst << "EOF"
title Windows
rootnoverify (hd0,0)
chainloader +1
EOF
• echo 6.4 > /etc/lfs-release
• Reiniciar -> $ shutdown -r now

54. Linux From Scratch
• Creando el bonito menu:
$ cat > /boot/grub/menu.lst << "EOF"
# Begin /boot/grub/menu.lst
# By default boot the first menu entry.
default 0
# Allow 30 seconds before booting the default.
timeout 30
# Use prettier colors.
color green/black light-green/black
# The first entry is for LFS.
title LFS 6.4
root (hd0,3)
kernel /boot/lfskernel-2.6.27.4 root=/dev/hda4
EOF

55. T2 SDE
• http://en.wikipedia.org/wiki/T2_SDE
• T2 es un kit “creador de distribuciones”.
• http://t2-project.org/documentation/
buildintro.html

56. T2 SDE

57. T2 SDE
• Arquitecturas soportadas:
• Alpha, ARM, AVR32, Blackfin, IA64,
Motorola 68k, MIPS, MIPS64, PowerPC,
PowerPC64, SPARC, SPARC64, SuperH,
x86, x86-64
• Puppy Linux esta basado en T2.
http://www.puppylinux.org/

58. Gentoo
• Una opción para instalar Gentoo es desde
cero, es decir, tu únicamente instalas la base
minima y de ahi compilas todo. Tambien
conocida como Stage 1.
• En el proceso, aprendes mucho de lo que
requieres para tener un linux completo.
• http://en.wikipedia.org/wiki/Gentoo_Linux

59. Moblin
• Proyecto de Intel para optimizar Linux,
especialmente pensado para las netbooks.
• http://moblin.org
• http://moblin.org/documentation/test-drive-
moblin

60. Moblin
• Menos uso de memoria
• Tamaño minimo en el disco
• Ahorro de bateria.
• Eficiencia optima, asi como boteo rapido.

61. Moblin
• Crea un proyecto
• Crear un target, especifico a una netbook
• proveer de los “fsets” que desea el usuario
que tenga la imagen, lo que magicamente se
incluiran los archivos que te interesan.
• Selección de la interface grafica
• Herramientas para poner esto en un usb o
un CD.

62. Moblin

63. Links
• Linux from scratch - http://
www.linuxfromscratch.org
• Libro de Linux from scratch - http://
www.linuxfromscratch.org/lfs/read.html
• Moblin Image creator - http://moblin.org/
projects/moblin-image-creator
• http://t2-project.org/documentation/
buildintro.html

64. Masuto Studios
http://www.masutostudios.com