eigenen Kernel bauen

[iwow]

Hallo,

ich versuche gerade einen eigenen Kernel für die FB zu bauen.

1.) buildroot von enrik installiert (soweit alles OK, eigenen Programme kann ich übersetzen und auf der FB starten)

2.) unter build_mipsel/kernel_build habe ich das Makefile angepasst (CROSS_COMPILE und KERNEL_MAKE_PATH) und die Datei "version" von build_mipsel/avm_gpl-build-644-359/GPL/version nach build_mipsel kopiert

3.) danach in build_mipsel/kernel_build ein make GPL angeworfen.

Nun habe ich unter build_mipsel/kernel_build/kernel/linux-2.4.17_mvl21 ein ram_zimage.bin das ich laut Anleitugn von enrik wie folgt bearbeiten muss

$ dd if=ram_zimage.bin of=ram_zimage_pad256.bin bs=256 conv=sync
$ # seit xx.03.22 hängt ein zusätzliches squashfs mit Modulen am kernel.image!
$ dd if=orig.kernel.image bs=512 skip=1173 | cat ram_zimage_pad256.bin - >kernel.image

Das geht aber laut enrik nur, wenn das neue Image so groß ist wie das alte.
Woher aber weiß ich, ob mein Image so groß wie das alte ist?
Gibt es nicht einen einfacheren Weg, das squashfs mit den Modulen aus dem Orginal Image zu extraieren und zusammen mit meinem neuen zu einem gemeinsamen Image zusammen zu bauen?

Gibt es evtl. dafür im buildroot System schon angepasste Makefiles (die ich noch nicht gefunden habe

Danke

Gruß iwow

 

[haveaniceday]

Hi iwow,
für mein "mod-0.52" hatte ich ein kleines Programm geschrieben.
Einfach mit "make find-squashfs" übersetzen.
Aufruf dann: find-squashfs <kernel.image>

Viele Grüße,

haveaniceday

PS: Das .c-file ist auch in den Skripten von Thread 6666 mod-0.52 mit drin.

cat ./tools/find-squashfs/find-squashfs.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include <stdlib.h>

#include <errno.h>

static void howto(name)
char name[];
{
        fprintf(stderr,"Call me: %s kernel.image\n",name);
        exit(1);
}

int main(argc,argv)
int argc;
char **argv;
{
FILE *fd;
long size;
long *start,*point,count;

/* start signature of squashfs */
long search = 'sqsh' ;

        if ( argc != 2 )
                howto(argv[0]);
        fd = fopen(argv[1],"r");
        if ( fd == NULL )
        {
                fprintf(stderr,"Unable to open <%s> errno: %d\n",argv[1],errno);
                howto(argv[0]);
        }
        /* get size */
        size=fseek(fd, 0L, SEEK_END);
        size=ftell(fd);
        fprintf(stderr,"The size of <%s> is %ld\n",argv[1],size);
        fseek(fd, 0L, SEEK_SET);

        start= (long *)malloc(size);

        fread(start,size,1,fd);
        fclose(fd);

        for ( point=start,count=0;count < size ; count +=4 ,++point)
        {
                if ( *point == search )
                {
                        fprintf(stderr,"Squashfs signature found at %ld\n",count);
                        break;
                }
        }
        if ( count < size )
        {
                fd=fopen("kernel.raw","w");
                if ( fd == NULL )
                {
                        fprintf(stderr,"Create kernel.raw: errno %d\n",errno);
                        exit(99);
                }
                fwrite(start,count/4L,sizeof(long),fd);
                fclose(fd);
                fprintf(stderr,"kernel.raw created\n");
                fd=fopen("kernelsquashfs.raw","w");
                if ( fd == NULL )
                {
                        fprintf(stderr,"Create kernelsquashfs.raw: errno %d\n",errno);
                        exit(99);
                }
                fwrite(point,(size-count)/4L,sizeof(long),fd);
                fclose(fd);
                fprintf(stderr,"kernelsquashfs.raw created\n");
        }
        else
        {
                fprintf(stderr,"Strange, no squashfs signature found...\n");
                exit(99);
        }

        free(start);
        exit(0);
}

 

[olistudent]

Aus dem neuesten buildroot von Enrik kommt doch schon ein fertiger Kernel mit Filesystem raus.
Warum nimmst du nicht einfach den?

Und, so weit ich weiß, sucht das dumpsquashfs von Enrik nach dem squashfs-Image im ganzen File. Müßte als auch funktionieren...

MfG Oliver