Themen

1

Lowlevel-Coding / x86-Startup

« am: 15. December 2015, 23:34 »

Hallo zusammen,

habe mir mal ein wenig Code zusammen gebastelt, um die AP-Prozessoren zu starten.
Leider bekomme ich bei den IPIs immer Fehlercodes zurück.

Hier ist meine LAPIC-Initialisierung des BSP:

Code: [Auswählen]

static __inline int __MaskLVT(ApicRegister i_register) {
    UInt32 value;

    int retval = CPU_ApicRead(i_register, &value);
    if (ESuccess != retval)
        return retval;

    return CPU_ApicWrite(i_register, value | (1 << 16));
}

static __inline int __CleanLApic() {
    UInt32 maxLvt;

    int retval = CPU_ApicRead(LocalApicVersion, &maxLvt);
    if (ESuccess != retval)
        return retval;
    maxLvt = (maxLvt >> 16) & 0xff;

    if (3 <= maxLvt) {
        retval = CPU_ApicWrite(LvtError, 0xfe | (1 << 16));
        if (ESuccess != retval)
            return retval;
    }

    retval = __MaskLVT(LvtTimer);
    if (ESuccess != retval)
        return retval;
    retval = __MaskLVT(LvtLInt0);
    if (ESuccess != retval)
        return retval;
    retval = __MaskLVT(LvtLInt1);
    if (ESuccess != retval)
        return retval;
    if (4 <= maxLvt) {
        retval = __MaskLVT(LvtPerformanceMonitoringCounters);
        if (ESuccess != retval)
            return retval;
    }

    retval = CPU_ApicWrite(LvtTimer, 1 << 16);
    if (ESuccess != retval)
        return retval;
    retval = CPU_ApicWrite(LvtLInt0, 1 << 16);
    if (ESuccess != retval)
        return retval;
    retval = CPU_ApicWrite(LvtLInt1, 1 << 16);
    if (ESuccess != retval)
        return retval;
    if (3 <= maxLvt) {
        retval = CPU_ApicWrite(LvtError, 1 << 16);
        if (ESuccess != retval)
            return retval;
    }
    if (4 <= maxLvt) {
        retval = CPU_ApicWrite(LvtPerformanceMonitoringCounters, 1 << 16);
        if (ESuccess != retval)
            return retval;
    }

    return ESuccess;
}

static __inline int __InitializeLogicDestination() {
    UInt32 value;
    int retval = CPU_ApicWrite(DestinationFormat, 0xffffffff);
    if (ESuccess != retval)
        return retval;
    retval = CPU_ApicRead(LogicalDestination, &value);
    if (ESuccess != retval)
        return retval;
    value &= ~(0xff << 24);

    UInt32 cpuId;
    retval = CPU_GetProcessorId(&cpuId);
    if (ESuccess != retval)
        return retval;
    value |= ((1 << cpuId) << 24);

    return CPU_ApicWrite(LogicalDestination, value);
}

int CPU_ApicInitialize() {
    UInt32 value;

    /* disable the PIC */
    CPU_IOPortWriteByte(0xa1, 0xff);
    CPU_IOPortWriteByte(0x21, 0xff);

    int retval = __CleanLApic();
    if (ESuccess != retval)
        return retval;

    retval = __InitializeLogicDestination();
    if (ESuccess != retval)
        return retval;

    /* set the task priority */
    retval = CPU_ApicRead(TaskPriority, &value);
    if (ESuccess != retval)
        return retval;
    value &= ~0xff;
    retval = CPU_ApicWrite(TaskPriority, value);
    if (ESuccess != retval)
        return retval;

    /* all done - activate the lapic */
    retval = CPU_ApicRead(SpuriousInterruptVector, &value);
    if (ESuccess != retval)
        return retval;
    value &= ~0xff;
    value |= (1 << 8) | 0xff;
    retval = CPU_ApicWrite(SpuriousInterruptVector, value);
    if (ESuccess != retval)
        return retval;

    return ESuccess;
}

Wenn ich über das MSR prüfe, ob die LAPIC aktiv ist, bekomme ich auch eine positive Rückmeldung.

Hier mein SMP-Init-Code (dabei verwende ich INIT-INIT-STARTUP):

Code: [Auswählen]

static __inline int __BootApplicationProcessor(UInt16 i_cpuCount, UInt32 i_stacks[]) {
    UIntPtr size = (UIntPtr)__trampoline_smp_end - (UIntPtr)__trampoline_smp_start;
    UInt32* stackPtr = (UInt32*)(0x7000 + size - 8);
    UInt8 acpis[i_cpuCount];
    UInt32 status;

    int retval = ACPI_GetProcessorInformation(acpis);
    if (ESuccess != retval) {
        KLog(Error, "Unable to get processor information: %d\n", retval);
        return retval;
    }

    UInt32 ownId;
    retval = CPU_GetProcessorId(&ownId);
    if (ESuccess != retval) {
        KLog(Error, "Unable to get the own CPU-ID: %d\n", retval);
        return retval;
    }

    UInt32 low, high;
    CPU_ReadMsr(0x1B, &low, &high);
    if (0 == (0x800 & low)) {
        KLog(Error, "LAPIC is not disabled\n");
        return -ENoPermission;
    }

    UInt32 value;
    retval = CPU_ApicRead(ErrorStatus, &value);

    for (UInt16 i = 0, c = 0; i < i_cpuCount; i++) {
        if (ownId == acpis[i])
            continue;

        *stackPtr = i_stacks[c++];
        KLog(Info, "Bringing up CPU #%u...", acpis[i]);
        currentBootId = acpis[i];

        KLog(Debug, "Sending INIT-IPI-1...");
        retval = __SendIPI(0xc500, &status);
        if (ESuccess != retval)
            return retval;
        KLog(Debug, "%#x\n", status);

        __UDelay(10000);

        KLog(Debug, "Sending INIT-IPI-2...");
        retval = __SendIPI(0x8500, &status);
        if (ESuccess != retval)
            return retval;
        KLog(Debug, "%#x\n", status);

        retval = CPU_ApicRead(ErrorStatus, &value);
        if (ESuccess != retval)
            return retval;

        KLog(Debug, "Sending STARTUP-IPI...");
        retval = __SendIPI(0x600 | (0x7000 >> 12), &status);
        if (ESuccess != retval)
            return retval;
        KLog(Debug, "%#x\n", status);

        __UDelay(300);
        __WaitForApic(&status);
        __UDelay(200);

        retval = CPU_ApicRead(ErrorStatus, &value);
        UInt32 accept = value & 0xef;

        if (0 == accept && 0 == status) {
            while ((UInt32)~0x0 != currentBootId) ;
            continue;
        }

        if (0 != accept)
            KLog(Error, "APIC-delivery: %#x\n", accept);
        if (0 != status)
            KLog(Error, "APIC not delivered: %#x\n", status);

        return -EBusy;
    }

    return ESuccess;
}

status innerhalb der __SendIPI-Aufrufe gibt immer 0x1000 zurück.
Ich sorge durch io_delay auch dafür, dass ich die erforderliche Zeit warte, damit die APs genug Zeit bekommen.

Getestet ist der Code unter QEmu.

Sieht einer von euch den Fehler?
Die APIC-IDs hole ich mir über die ACPI-MADT-Tabelle.

Viele Grüße
rizor

2

Lowlevel-Coding / ELF-Relocatables

« am: 23. December 2014, 13:09 »

Hallo zusammen,

ich sitze gerade daran einen modularen Kernel zu bauen und versuche ELF zu verstehen.
Für Executables ist es ja recht einfach, aber Relocatables verwirren mich etwas.
Hier mal meine Interpretation, wie ich den ganzen Spaß zu interpretieren und zu laden habe:

Wenn ich Abhängigkeiten zu anderen Modulen habe, wird eine .plt-Sektion angelegt, die eigentlich nichts anderes als ein großes Array ist,
in das ich die entsprechenden absulten Adressen der Funktionen eintragen muss, oder?
Dann habe ich noch eine .got.plt.
Die ist dafür da, dass ich die Relocation meines Moduls anpassen kann und die richtigen Stellen in der .plt angesprungen werden, oder?

Dann habe ich noch .rel.dyn. Was mache ich damit? Anhand des Namens sehe ich, dass es dabei um die Relocation geht, aber so ganz kapiere ich den Teil noch nich.

Allerdings verstehe ich nicht wozu .dynsym und .dynstr da sind.
Was soll ich mit denen anfangen?
.dynsym sehe ich momentan als eine Art Offset-Tabelle an, die mir angibt welche Funktionen zu welcher Sektion und zu welchen Offset gehören.
Ist das richtig?
Aber dafür hätte ich doch auch .symtab. Die sagen doch genau das Gleiche aus, oder?

Grüße
rizor

3

OS-Design / Code-Dispatcher

« am: 31. January 2013, 15:52 »

Hi zusammen,

ich versuche gerade die Module meines Kernels so umzubauen, dass sie abhängig von der Architektur optimalen Code ausführen.
z.B. Es soll eine generische memset funktion geben und dann noch eine optimierte, damit die Hardware optimal ausgenutzt wird.
Das wollte ich so machen, dass mein Module-Loader die Funktionen entsprechend wählt, bzw. dass das Modul anhand der Architektur sagt, welche Funktionen genutzt werden sollen.

Habt ihr Ideen, wie man das am Effektivsten umsetzen kann?

Grüße,
rizor

4

Lowlevel-Coding / Relocatable ELF

« am: 14. September 2012, 07:51 »

Hi zusammen,

ich bastel mir gerade einen ELF-Loader, der relocatable ELFs behandeln soll.
Irgendwie scheint sich die Section-Header-String-Table aber anders zusammen zu setzen, als bei normalen ELFs.
Der Section-Name-Index lässt sich in der Shstrtbl nicht finden.
Muss ich für solche Fälle woanders nachschauen?

Grüße,
rizor

5

Softwareentwicklung / Grub unter CentOS

« am: 21. August 2012, 22:53 »

Hi zusammen,

ich habe mal meine Entwicklungsumgebung geändert und irgendwie funktioniert mein Floppy-Skript nicht mehr,
seitdem ich CentOS verwende.

Hier das Skript:

Code: [Auswählen]

#generate the image
dd of=$Image bs=1024 seek=1440 count=0
mkdosfs $Image

#copy the image
mkdir -p /mnt/floppy
mount -oloop $Image /mnt/floppy
mkdir -p /mnt/floppy/grub
cp $Grub/stage* /mnt/floppy/grub/
cp $Kernel /mnt/floppy/
#generate menu.lst
sed -e "s/%%KERNEL%%/Kernel/" Scripts/Grub/GrubV1.lst.in > /mnt/floppy/grub/menu.lst
umount /mnt/floppy

#install grub
grub --batch --no-floppy <<EOT 1>/dev/null || exit 1
device (fd0) $Image
install (fd0)/grub/stage1 (fd0) (fd0)/grub/stage2 p (fd0)/grub/menu.lst
quit
EOT

Es ist nicht möglich eine bootfähige Floppy zu erstellen.
Wenn ich das Skript von Hand abarbeite, bekomme ich bei dem `install`-Befehl den Error 21: Selected disk does not exist

Hat einer von euch Erfahrung mit CentOS?

rizor

6

Lowlevel-Coding / div64

« am: 21. August 2012, 17:13 »

Hi zusammen,

ich habe ein Problem mit meiner Assembler-Funktion zur Division einer 64-bit Zahl.

Hier der Code:

Code: [Auswählen]

__asm__ volatile("div %%ecx"
                 "xchg %%ebx, %%eax;"
                 "div %%ecx;"
                 "xchg %%edx, %%ebx;" : "=a"(quot), "=b"(rem)
                                      : "a"(high), "b"(low),
                                        "c"(base), "d"(0));

Als Fehlermeldung bekomme ich ein "invalid register constraint".
Hatte gesehen, dass in Tyndur dann =A verwendet wird.
Da bekomme ich aber die Meldung, dass er das Register nicht in BREG finden kann.
Übersehe ich da was, oder ist mein GCC komisch eingestellt?

rizor

7

Softwareentwicklung / Archiv in Datei linken

« am: 15. August 2012, 14:31 »

Hallo zusammen,

endlich finde ich mal wieder Zeit an meinem Kernel zu arbeiten.
Wie kann ich eine beliebige Datei in eine Sektion meines Kernels linken?
Ich weiß, dass das mit dem NASM geht, aber den möchte ich nicht verwenden.

Grüße,
rizor

8

Lowlevel-Coding / GDT-Alignment

« am: 06. January 2012, 22:41 »

Nabend zusammen,

ich habe derzeit ein komisches Problem.
Meine GDT funktioniert nur, wenn ich die GDT an die Page-Size ausrichte.
Habe alle GDT-Eintraege ueberprueft und die sind korrekt.
Wenn ich die GDT an 8-Byte ausrichte (laut Intel die optimale Position), bekomme ich einen GPF.
Woran kann das liegen?

Hier mal die Eintraege aus der GDT:

Code: [Auswählen]

{{value = 0, mapping = {segment0 = 0, base0 = 0, accessed = 0,
      segment_r_rw = 0, direction = 0, exec = 0, segment = 0, privilege = 0,
      present = 0, segment1 = 0, zero = 0, size = 0, granularity = 0, base1 = 0}},
  {value = 58434644969848831, mapping = {segment0 = 65535, base0 = 0,
      accessed = 0, segment_r_rw = 1, direction = 0, exec = 1, segment = 1,
      privilege = 0, present = 1, segment1 = 15, zero = 0, size = 1,
      granularity = 1, base1 = 0}}, {value = 58425848876826623, mapping = {
      segment0 = 65535, base0 = 0, accessed = 0, segment_r_rw = 1, direction = 0,
      exec = 0, segment = 1, privilege = 0, present = 1, segment1 = 15, zero = 0,
      size = 1, granularity = 1, base1 = 0}}, {value = 58540198086115327,
    mapping = {segment0 = 65535, base0 = 0, accessed = 0, segment_r_rw = 1,
      direction = 0, exec = 1, segment = 1, privilege = 3, present = 1,
      segment1 = 15, zero = 0, size = 1, granularity = 1, base1 = 0}}, {
    value = 58531401993093119, mapping = {segment0 = 65535, base0 = 0,
      accessed = 0, segment_r_rw = 1, direction = 0, exec = 0, segment = 1,
      privilege = 3, present = 1, segment1 = 15, zero = 0, size = 1,
      granularity = 1, base1 = 0}}}

Danke.

Gruss,
rizor

9

Softwareentwicklung / GCC veraendert den Stack nicht

« am: 27. December 2011, 19:45 »

Hallo zusammen,

ich stosse momentan auf ein komisches Problem.
Bei Aufrufen von Funktionen veraendert der Kernel den Stack nicht.
Also mal ein wenig genauer:

Eine meiner Funktionen ruft eine andere auf und setzt den Stack richtig (Parameteruebergabe korrekt).
Nachdem die Funktion durchgelaufen ist, kehrt der Code zurueck und zeigt mir im GDB die Parameter der aufrufenden Funktion an.
Dabei faellt mir auf, dass der erste Parameter (der oberste auf dem Stack) der Ruecksprungadresse der aufgerufenen Funktion entspricht.
Woran liegt das?

Ich habe keine plausible Erklaerung dafuer, da der Code auch im Assembler nicht schlecht aussieht (call, ret).
Kann es sein, dass da QEmu was falsch macht und vergisst das Register zu veraendern?
Das kann ich aber fast nicht glauben, da ich auch schon ein Linux in QEmu gestartet habe und das funktioniert.


Gruss,
rizor

Edit:
Der erste Aufruf der Funktion geht aber gut und der Code laeuft ordentlich durch.

Hier mal der betroffene C-Code:

Code: [Auswählen]

/*
 * this function sets the flags of one entry correctly
 */
static inline void __boot mmu_set_flags(vmm_space_p entry, char rw, char big) {
        entry->present = 0x1;
        entry->no_tlb_flush = 0x1;

        if (rw)
                entry->writable = 0x1;
        if (big)
                entry->big_page = 0x1;
}


/*
 * this function maps physical memory, while paging is inactive
 */
void __boot mmu_map_offline(vmm_space_p space, void* vmem,
                            void* pmem, size_t size, char rw) {
        vmm_space_p l1_tbl;
        uint32_t mapped;
        size_t alloc;
        void* frame;
        int l2, l1;

        while (size) {
                l2 = MMU_L2_INDEX(vmem);

                if (!space[l2].present &&
                    size >= MMU_PAGE_SIZE_BIG && pse_feature) {
                        space[l2].frame = (uint32_t)pmem;
                        mmu_set_flags(&space[l2], rw, 1);
                        mapped = MMU_PAGE_SIZE_BIG;
                }
                else {
                        l1 = MMU_L1_INDEX(vmem);

                        //generate a l1 table
                        if (!space[l2].present) {
                                alloc = 0x1000;
                                frame = boot_malloc(&alloc);
                                if (!alloc) {
                                        //TODO call panic
                                        while (1);
                                }
                                boot_memset(frame, 0x0, 0x1000);

                                space[l2].frame = (uint32_t)frame;
                                mmu_set_flags(&space[l2], 1, 0);
                        }
                        l1_tbl = (vmm_space_p)((uint32_t)space[l2].frame);

                        l1_tbl[l1].frame = (uint32_t)pmem;
                        mmu_set_flags(&l1_tbl[l1], rw, 0);

                        mapped = MMU_PAGE_SIZE_NORM;
                }

                vmem += mapped;
                pmem += mapped;
                size -= mapped;
        }
}

Die bearbeiteten Strukturen wurden wie folgt definiert:

Code: [Auswählen]

struct l2_entry {
        uint32_t present : 1;
        uint32_t writable : 1;
        uint32_t userspace : 1;
        uint32_t write_through : 1;
        uint32_t no_cache : 1;
        uint32_t dirty : 1;
        uint32_t dirty_page : 1;
        uint32_t big_page : 1;
        uint32_t no_tlb_flush : 1;
        uint32_t free : 3;
        uint32_t frame: 20;
} packed;

struct l1_entry {
        uint32_t present : 1;
        uint32_t writable : 1;
        uint32_t userspace : 1;
        uint32_t write_through : 1;
        uint32_t no_cache : 1;
        uint32_t dirty : 1;
        uint32_t dirty_page : 1;
        uint32_t zero : 1;
        uint32_t no_tlb_flush : 1;
        uint32_t free : 3;
        uint32_t frame: 20;
} packed;


10

Lowlevel-Coding / IDT mit einem Upper-Half-Kernel

« am: 18. December 2011, 11:14 »

Hallo zusammen,

ich habe einen Upper-Half-Kernel und versuche gerade die IDt zu initialisieren.
Ich habe haeufiger gelesen, dass in der IDTR die physischen Adresse der IDT stehen muss. Da hab ich nur das Problem, dass ich bei der Behandlung einer Exception einen PageFault bekomme, der auf die Position der IDT zeigt.
Wenn die IDT an einer virtuellen Adresse liegt, bekomme ich bei einer Exceptionen eine GPF.
Die Exception erzeuge ich mit 1 / 0. Dafuer ist auch ein Handler registiert, der aktiv ist und auf eine virtuelle Adresse zeigt.
Somit muesste die Exception behandelt werden. Kann das Problem auch an der GDT liegen?
Die wird ueber ihre physische Adresse identifiziert.

Die Handler-Adressen in der IDT muessen die virtuellen Adressen enthalten, oder?

Gruss,
Sven

EDIT:
Bochs gibt folgende Fehlermeldung:
bx_dbg_read_linear: physical memory read error (phy=0x00000000c0000dea, lin=0xc0000dea)

11

Lowlevel-Coding / Call auf 0x500 erzeugt GPF

« am: 23. October 2011, 14:45 »

Hi zusammen,

ich habe mir gerade mal Code geschrieben, der zurück in den RM springt, dort BIOS-Interrupts verwenden soll und dann zurück in den PM springen muss. Der Code wird ordentlich gebaut und als Flat-Binary gelinkt. Der Linker nutzt 0x500 als Basisadresse.
Wenn ich nun den Code mit .incbin in meinen Kernel einbinde und dann auf 0x500 kopiere, sollte ja alles soweit funktionieren.
Leider gibt es beim Call auf 0x500 einen GPF und der Error-Code ist 0x5b4.

Woran kann das liegen?
Kann es sein, dass was mit der GDT von GRUB nicht passt oder so?

Gruß,
rizor

12

Lowlevel-Coding / switch setzt EIP auf 0x0

« am: 27. September 2011, 22:53 »

Nabend zusammen,

ich bin gerade dabei die ACPI-Tabellen auszulesen und habe mir eine Switch-Anweisung geschrieben, damit ich die verschiedenen APIC-Strukturen aus der MADT auslesen kann.
Diese Anweisung setzt den EIP auf 0x0.

Hier der Code:

Code: [Auswählen]

switch (apic->type) {
case MADT_LAPIC:
lapic = (struct lapic*)apic;
offset = sizeof(struct lapic);

if(hit_if(!lapic->flags))
cpu_count++;
break;
case MADT_IO_APIC:
offset = sizeof(struct ioapic);
break;
case MADT_INT_SRC_OVERRIDE:
offset = sizeof(struct int_src_override);
break;
case MADT_NMI:
offset = sizeof(struct nmi);
break;
case MADT_LAPIC_NMI:
offset = sizeof(struct lapic_nmi);
break;
case MADT_LAPIC_ADDR_OVERRIDE:
offset = sizeof(struct lapic_address_override);
break;
case MADT_IO_SAPIC:
offset = sizeof(struct io_sapic);
break;
case MADT_LOCAL_SAPIC:
offset = sizeof(struct local_sapic);
break;
case MADT_PLATFORM_INT_SRC:
offset = sizeof(struct platform_int_src);
break;
default:
offset = sizeof(struct apic_header);
break;
}

Wenn ich diesen Code mit if-else-Anweisung verwende, funktioniert alles einwandfrei.
Woran liegt das?

Hier mal der Assembler-Code:

Code: [Auswählen]

while (i < madt->header.length) {
  100016: e9 c5 00 00 00        jmp    1000e0 <acpi_count_cpus+0xe0>
apic = (struct apic_header*)addr;
  10001b: 8b 44 24 1c          mov    0x1c(%esp),%eax
  10001f: 89 44 24 0c          mov    %eax,0xc(%esp)

switch (apic->type) {
  100023: 8b 44 24 0c          mov    0xc(%esp),%eax
  100027: 0f b6 00              movzbl (%eax),%eax
  10002a: 0f be c0              movsbl %al,%eax
  10002d: 83 f8 08              cmp    $0x8,%eax
  100030: 0f 87 8b 00 00 00    ja     1000c1 <acpi_count_cpus+0xc1>
  100036: 8b 04 85 00 10 00 c0 mov    -0x3ffff000(,%eax,4),%eax
  10003d: ff e0                jmp    *%eax
case MADT_LAPIC:
lapic = (struct lapic*)apic;
  10003f: 8b 44 24 0c          mov    0xc(%esp),%eax
  100043: 89 44 24 10          mov    %eax,0x10(%esp)
offset = sizeof(struct lapic);
  100047: c7 44 24 14 08 00 00 movl   $0x8,0x14(%esp)
  10004e: 00

if(hit_if(!lapic->flags))
  10004f: 8b 44 24 10          mov    0x10(%esp),%eax
  100053: 8b 40 04              mov    0x4(%eax),%eax
  100056: 85 c0                test   %eax,%eax
  100058: 0f 94 c0              sete   %al
  10005b: 0f b6 c0              movzbl %al,%eax
  10005e: 85 c0                test   %eax,%eax
  100060: 74 69                je     1000cb <acpi_count_cpus+0xcb>
cpu_count++;
  100062: a1 f0 05 10 00        mov    0x1005f0,%eax
  100067: 83 c0 01              add    $0x1,%eax
  10006a: a3 f0 05 10 00        mov    %eax,0x1005f0
break;
  10006f: eb 5b                jmp    1000cc <acpi_count_cpus+0xcc>

Kann mir nur vorstellen, dass jmp *%eax den Fehler verursacht.

Gruss,
rizor

13

Softwareentwicklung / Makefile Erweiterung von Variablen

« am: 17. September 2011, 19:04 »

Hallo zusammen,

ich habe ein Problem mit meinen Makefiles.
Derzeit versuche ich folgendes Makefile in den Kernel einzubauen:

Code: [Auswählen]

KERNEL:=kernel lib
SRC:=$(shell find $(KERNEL) -type f -name '*.c')
CFLAGS:=-Wall -Wextra -nostdinc -fno-zero-initialized-in-bss -fno-builtin \
-fstrength-reduce -fomit-frame-pointer -finline-functions \
-fno-stack-protector -Iinclude -lgcc -MMD -O2 -g
LDFLAGS:=-Iinclude -Map kernel.map -nostdlib -O2

build:
ifneq ($(shell find . -type f -name '.config'),)

ifeq ($(shell grep ARCH .config), CONFIG_ARCH_X86_32)
CFLAGS+="-m32 -march=i686"
LDFLAGS+="-Tarch/x86/linker.ld -melf_i386 -o"
KERNEL+="arch/x86"
endif

@echo $(CFLAGS)
@echo $(LDFLAGS)
@echo $(KERNEL)

else
@echo "You have to run 'make config' first"
exit 0
endif

Wenn ich den Code so ausfuehre, laeuft der Code ohne fehler durch, aber die Echos geben nicht die erweiterten Variablen aus. Habe es schon ueberprueft, der Code laeuft den Pfad der Erweiterungen ab.

Woran kann das liegen?

Danke.

Gruss,
rizor

14

OS-Design / Optimale Baumstrukturen fuer malloc/free

« am: 02. September 2011, 23:11 »

Nabend zusammen,

ich arbeite gerade an einem neuen kmalloc, da ich bei meinem derzeitigen Kernel festgestellt habe, dass der Kernel dabei sehr viel zeit vertreiben muss.

Nun wollte ich einen balancierenden Baum verwenden allerdings habe ich dabei das Problem, dass ich bei identischen Knoten nicht fuer einen sortierten Baum garantieren kann, wodurch mir ja die ganzen Vorteile verloren gehen.
Dann hatte ich die Idee, dass die freien Speicherbereiche mit identischer Groesse in einem einzigen Knoten abgelegt werden.

Wie habt ihr das Problem geloest?
Ausserdem ueberlege ich mir die ganze Zeit, welche Baeume am besten fuer die Speicherverwaltung am besten sind.
Habe leider nichts aufschlussreiches gefunden (AVL oder RB).
Habt ihr damit Erfahrungen?

Gruesse,
rizor

15

Lowlevel-Coding / Makefile dynamisch mit Leben füllen

« am: 23. August 2011, 18:27 »

Hi zusammen,

mir gefällt mein derzeitiges Build-System nicht mehr, da der Wartungsaufwand einfach zu groß ist.
Habe jetzt alles auf eine Makefile runtergebrochen und das soll erst beim Aufruf die nötigen Informationen bekommen.

Habe mir dafür ein Skript geschrieben, das mir die Source-Files, etc. ermittelt und dann per echo weitergibt.
Die Skripte laufen auch fehlerfrei.
Leider ignoriert mein Makefile die Ausgaben.

Der Aufruf sieht wie folgt aus:

Code: [Auswählen]

SRC=`sh script.sh -source`
Der Aufruf ermittelt die passenden Source-Files, aber die ignoriert das Makefile.
Woran liegt das?

Grüße,
rizor

16

OS-Design / Locking innerhalb des Kernels

« am: 07. August 2011, 00:03 »

Nabend zusammen,

ich bin gerade dabei eine optimale Locking-Strategie fuer meinen Kernel zu entwickeln, da er ein preemptive Kernel werden soll. Das Locking der einzelnen Elemente und Subsysteme des Kernels ist kein Problem... solange die Strukturen existieren.
Nun habe ich aber Strukturen, die auch immer wieder zerstoert werden. Falls ich nun eine CPU habe, die auf einen Lock wartet, der in dem Moment zerstoert wird. Daraus resultieren zwei Probleme... Entweder die wartende CPU bekommt irgendwann den vermuteten Lock, weil der Speicher durch eine andere CPU fuer was anderes verwendet wird... dann kommt es ja zu einem unkontrollierten verhalten, oder die wartende CPU bleibt in einem Deadlock.

Ich bin momentan dabei, dass ich mir ein Konzept ueberlege, dass auch in solchen Situationen kontrolliert arbeitet. Ich hatte die Idee mit einem Flag, das angibt ob die Struktur noch passt oder eben auch nicht. EIne andere Moeglichkeit waere eine Semaphore, die bei der Zerstoerung einer Struktur aufgeloest wird und die blockierten CPUs frei gibt und ihnen den Grund fuer den Rueckruf mitteilt. Ist unter Umstaenden auch nicht die beste Idee.
Wie habt ihr das denn geloest?

Gruss,
rizor

17

Softwareentwicklung / Multiple Definitions trotz ifndef

« am: 20. July 2011, 20:29 »

Hallo zusammen,

ich habe ein Problem mit dem Linker (ld).
Ich habe mir eine Header-Datei (1) erstellt, die inline-Funktionen definiert, die in eine andere Header-Datei inkludiert wird (2).
Die Kompilierung funktioniert einfach frei.
Sobald der Linker die Object-Files bekommt, meldet er, dass Header-Dateien, die (2) inkludieren, die Funktionen aus (1) redefinieren.
Das dürfte nicht passieren, da ich (1) mit ifndef kapsel.

Was kann der Linker noch falsch machen?

Grüße,
rizor

18

Softwareentwicklung / va_arg()

« am: 21. June 2011, 22:54 »

Nabend zusammen,

mir ist eben aufgefallen, dass ich ein Problem mit meinem va_arg habe.
Ich Verwende das builtin vom GCC.
An sich muesste die Funktion doch nach dem Aufruf den args-Parameter auf den naechsten Parameter verschieben, oder?
Leider macht sie das nicht. Woran kann das liegen?

Habe einfach ein kprintf, dass ab zwei weiteren Parametern immer nur den ersten verwendet.
z.B.: kprintf(string, val1, val2) => In kprintf wird nur val1 verarbeitet, obwohl ich zwei Steuerzeichen dafuer habe.

19

OS-Design / UEFI

« am: 10. June 2011, 21:28 »

Hallo zusammen,

ich wollte mal schauen inwieweit ich es schaffe, dass mein Kernel irgendwann mal UEFI kompatibel wird.
Habe mal ein wenig recherchiert und gesehen, dass UEFI von einem EFI-Bootloader geladen werden muss (das soll auch GRUB können).
Nun weiß ich aber nicht, wie ich dann aus meinem Kernel heraus mit EFI arbeite.
Hat einer von euch da schon Erfahrung?
Habe da nichts außer den Linux-Sources entdeckt. Die sind mir aber zu viel, da ich nicht wirklich weiß wie der Kernel genau bootet.

20

Lowlevel-Coding / ACPI GAS System Memory

« am: 09. June 2011, 21:26 »

Nabend zusammen,

ich bin gerade dabei meinem Kernel einen ACPI-Treiber zu verpassen und wollte über die ACPI-Tabellen den physischen Speicher ermitteln.
Das müsste doch über die GAS gehen, oder?
Ich stehe momentan nur auf dem Schlauch wenn es um den korrekten Eintrag geht (System Memory).
Wie muss ich den denn am besten auswerten?

Gruß,
rizor