Ads by RevenueHits

Linuxeros Faq

Ads by Bidvertiser

Busqueda sobre Linux y software libre

Duda sobre make-kpkg en Debian

Pregunta

Hola . . .

Me encontre dos formas de compilar el kernel de linux . . .

1.-

# make dep
# make clean
# make zlilo
# make modules
# make modules_install


2.-

#make-kpkg clean
#make-kpkg -initrd --revision=versiondetukernel1
--append-to-version=nombredetukernel kernel_image kernel_headers

# dpkg -i kernel-headers-2.6.15.7-ubuntu1nombredetukernel_versiondetukernel1_i386.deb
# dpkg -i kernel-image-2.6.15.7-ubuntu1nombredetukernel_versiondetukernel1_i386.deb

A mi parecer la segunda mas comoda, pues a demas de instalar tu kernel
puedes tener un backup.

Mi dudad es la siguiente en la segunda forma al igual que en la
primera se instalan y compilan los módulos parcheados, al codigo
fuente?

Mas especificamente si a las fuentes de mi kernel le aplico :

# patch -p1 -b < /usr/src/rtai/base/arch/i386/patches/hal-linux-2.6.19-i386-1.7-01.patch ¿Tengo el mismo resultado compilando mi kernel por el primer método, o por el segundo?


Respuesta a la parte 1

usas lilo?

Esto es para la versión antigua, desde la 2.6 se simplifico el proceso.

* make clean es opcional, si tienes una compilación previa y de otra versión.
* make all = make modules & make vmlinux (bzimage|zImage)

Eso sería suficiente, luego:

* make modules_install copia los módulos -si es que compilaste
alguno- a /lib/modules/$(uname -r)

Antes era necesario un depmod -ae pero ahora no.

* make install copia el kernel y los symbols a /boot, pero este
depende de cómo tengas configurada tu distro. No es recomendable a
menos que sepas que hace y que faltaría para que arranque tu nuevo
kernel.

Respuesta a la parte 2

quizás te falte el modules_image, si es que seleccionaste algo cómo
módulo en tu configuración. Y para compilar como usuario normal puedes
añadir adelante fakeroot.

Otra respuesta a las partes 1 y 2

Un parche *no* es sólo para módulos, puede ser para
arreglar/ajustar/añadir cualquier cosa al código. Claro que lo usual es
"parches para módulos" que casi siempre son controladores de
dispositivos.

Respuesta 

a " A mi parecer la segunda mas comoda, pues a demas de instalar tu kernel"
puedes tener un backup.

La primera es manual, y no se integra con el gestor de paquetes. La
segunda es deb-like, y más automágica.

Respuesta 

a Mi dudad es la siguiente en la segunda forma al igual que en la
primera se instalan y compilan los módulos parcheados, al codigo
fuente?


Si.

Aunque siendo precisos, en la primera no instalas el kernel y no se
sabe si necestas la imagen initrd. Y en la segunda no compilas
módulos. =D

No necesitas módulos si tienes todo lo necesario integrado en el
kernel. Y no necesitas initrd si es que no necesitas cargar algún
módulo -ide, sata, raid, lvm, etc- antes de montar el sistema raiz.
Generalmente en este punto es donde mueren los valientes con un
"Panic: unable to mount root partition" :)


Otra respuesta


Esto es aplicar el parche manualmente. El primer método de compilación
es un método manual. Donde el usuario tiene que prepar el código fuente,
aplicar parches (si es necesario) y luego compilar el núcleo (kernel) y
módulos. Para finalmente instalar el nuevo núcleo y los nuevos módulos
con el propósito de que el equipo arranque con ese núcleo recién
cocinado :-)

Respuesta a ¿Tengo el mismo resultado compilando mi kernel por el primer método, o
por el segundo?

Depende si el parche es un sólo un parche, o un módulo que tienes que
seleccionar para que se compile.

De todas maneras, es recomendable que busques la "manera oficial" de
compilar en tu distro.

Por otra parte, estamos suponiendo que ya configuraste tu kernel con
todas tus opciones necesarias? make (config|xconfig|gconfig)

Por que eso no es automágico.

El proceso seguro sería copiar tu configuración actual, que
generalmente las distros lo guardan en /boot/config-* con el número de
tu kernel.

# cd /path/to/linux/sources
# cp /boot/config-2.6.a.b.c.x-algo .config
# make oldconfig

Y ya tendrás un config actualizado. Sólo te faltaría make
xconfig|gconfig etc. Y luego los pasos que ya sabes ;-)

Otra respuesta


No si en el primer método no te aseguars de cumplir y seguir todos los
pasos necesarios. El primer método es genérico y sirve para cualquier
distro Linux.

El segundo método que muestras aquí es en particular para Debian. La
idea aquí es que se genera un paquete DPKG (.deb). Si usaras una distro
con paquetes RPM (CentOS/Fedora/RHEL/Suse/Mandriva/etc..) y siguieras su
procedimiento de compilar el núcleo vía paquetes, obtendrías un
archivo .rpm.

Ambos sistemas de paquetes DPKG y RPM automatizan todo el proceso manual
de compilación del núcleo (en general de cualquier programa, que se
compile mediante RPM). Cada uno de estos sistemas usa archivo(s), donde
se indica que tiene que hacerse, por ejemplo: make clean, make dep, make
bzImage, patch, etc, etc.

Muchas veces es más fácil compilar un nuevo núcleo usando la forma
manual que la forma de paquete (DPKG, RPM). Aunque esta es mi opinión
personal, quizá otros opinan que es más fácil meter mano a los paquetes
fuentes del núcleo.

Te sugiero que leas la documentación de tu distro sobre como
reconstruir/recompilar el núcleo.

Otra respuesta


Como yo lo hago a la LFS.

1.- Bajo el Kernel de www.kernel.org
2.- lo descomprimo
3.- ingreso a lo descompreso
4.- make mrproper (verifica si todo esta ok)
5.- aplico los parches que sean necesarios
6.- make menuconfig (configurar el kernel)
7.- make dep
8.- make bzimage
9.- make modules
10.- make modules-install
11. y finalmente copio la imagen creadada del kenel y el system.map a /boot, ademas de la configuración (.config) actual.

y listo el pollo.

Una observacion

Aprende no mas a usar la primera forma de compilación del núcleo, que es
la forma universal. Luego para aprender más, aprende como se construyen
paquetes DEB y RPM. Cuando aprendas hacer esto, puedes empezar a mirar
como se construye/compila un núcleo desde paquetes DEB/RPM, y ahí
tendrás toda la figura clara :-)

PD del autor del problema

Gracias por el dato, pues no lo sabía y acabo de leerlo en este sitio:

http://adf.ly/1eIF56

En esa página dice:

I used to compile kernels manually, and it involved a series of
steps to be taken in order; kernel-package was written to take
all the required steps (it has grown beyond that now, but
essentially, that is what it does). This is especially important
to novices: make-kpkg takes all the steps required to compile a
kernel, and installation of kernels is a snap. — Manoj
Srivastava, author of kernel-package

La parte clave es: "make-kpkg takes all the steps required to compile a
kernel" :-)

Aunque leyendo lo que dice ese sitio, no hay nada específico para
aplicar parches. Hasta donde pude leer --lo hice a la rápida-- hay que
aplicar los parches manualmente en el paso «3. Setup source tree»
Lo mejor sería probar para salir de dudas ;-)

> Otra cosa similar es bajar el "kernel
> source" de la distribución y reconstruir el paquete (apt-get source,
> apt-get builddep, apt-build, etc).

Mas bien, creo que intentas decir, bajar el "DEB/RPM source" (paquete
fuente) del núcleo y reconstruir desde allí a punta de apt-build, etc.

> De ambas maneras consigues un deb.

Muy cierto

Un link de ayuda

PD: http://adf.ly/1eIF9Q
--


Ads By Bidvertiser

Tienda linuxeros FAQ

29440009-121797753

Ads by Daily Motion