Themen

1

OS-Design / RTC mit QEMU

« am: 20. January 2013, 10:58 »

Tag Leute,

ich bin gerade dabei eine date()-Funktion, wie man das aus PHP kennt zu implementieren. Dabei ist mir aufgefallen, dass das Datum bei QEMU total falsch ist (zB haben wir laut QEMU das Jahr 2019). Außerdem werden die Sekunden bis 100 gezählt anstatt 60.
Ansonsten funktioniert das ganze eigentlich richtig, die Sekunden steigen auch im Sekundentakt usw.
Ich habe die QEMU Version 1.1.2 Ist das ein Bug oder gibt es da Einstellungsmöglichkeiten?

Grüße,
jo

2

Lowlevel-Coding / Integer fehlerhaft?!

« am: 14. December 2012, 21:16 »

Mir ist gerade aufgefallen, dass irgendwie hin und wieder Integer kaputt sind. Kaputt bedeutet, dass man mit ihnen nicht rechnen kann (als Ergebnis kommt 0 heraus). Wenn man ich den Integer ausgebe, wird die Zahl mit einem angehängten Ç (kein C). Das ist zumindest meistens der Fall. Manchmal sind es auch andere Zeichen dessen Existenz ich nichtmal kannte^^. Interessanterweise kann man den Fehler manchmal beheben, indem man vor der Ausgabe einen anderen Integer deklariert.
Ich frage mich vorallem wie diese Zeichen in die Ausgabe kommen. Eigentlich sollte es bei %x nur 1-F geben...

Vielleicht ist das ja ein verbreiterter Fehler in der Lowlevelprogrammierung. Ich hoffe das mir da wer weiterhelfen kann.

3

OS-Design / Multiboot Information Structure

« am: 26. November 2012, 21:34 »

Irgendwie ist bei mir das Multiboot Information Structure leer. Ich kriege zwar eine Adresse übergeben, aber alles enthält nur 0x0.

So sieht meine Struktur dafür aus:

Code: [Auswählen]

struct multiboot_info {
  uint32_t flags;
  uint32_t mem_lower;
  uint32_t mem_upper;
  uint32_t bootdevice;
  uint32_t cmdline;
  uint32_t mods_count;
  uint32_t mods_addr;
 
  uint32_t syms_num;
  uint32_t syms_size;
  uint32_t syms_addr;
  uint32_t syms_shndx;
 
  uint32_t mmap_length;
  uint32_t mmap_addr;
  uint32_t drives_length;
  uint32_t drives_addr;
  uint32_t config_table;
  uint32_t boot_loader_name;
  uint32_t apm_table;
  uint32_t vbe_control_info;
  uint32_t vbe_mode_info;
  uint16_t vbe_mode;
  uint16_t vbe_interface_seg;
  uint16_t vbe_intferface_off;
  uint16_t vbe_interface_len;
}__attribute((packed));
Und so soll das zum Test ausgegeben werden:

Code: [Auswählen]

void init(struct multiboot_info * mb_info)
{
  ...
  kprintf("%x\n", mb_info->mmap_addr);
  ...
}
Nur funktioniert das eben nicht. 

Es scheint so, als würde eine Adresse von einer leeren Struktur übergeben werden.

4

OS-Design / Multitasking im Usermode

« am: 23. November 2012, 21:25 »

Ok, ich komme mal wieder nicht weiter^^

Ich habe in meinen Kernel Multitasking integriert, was nach einigen Hürden auch gut geklappt hat.
Seitdem ich aber in den Ring3 umgestiegen bin, startet QEMU einfach die ganze Zeit neu. 

Das sind die Quellcodes:

Code: [Auswählen]

#include "includes.h"

#define GDT_FLAG_DATASEGM 0x02
#define GDT_FLAG_CODESEGM 0x0a
#define GDT_FLAG_TSS 0x09

#define GDT_FLAG_SEGMENT 0x10
#define GDT_FLAG_RING0 0x00
#define GDT_FLAG_RING3 0x60
#define GDT_FLAG_PRESENT 0x80

#define GDT_FLAG_4K_GRAN 0x800
#define GDT_FLAG_32_BIT 0x400

#define GDT_ENTRIES 0x5

static uint64_t gdt[GDT_ENTRIES];

void init_gdt() 
{
  gdt_set_entry(0, 0, 0, 0);
  gdt_set_entry(1, 0, 0xfffff, GDT_FLAG_SEGMENT | GDT_FLAG_32_BIT | GDT_FLAG_CODESEGM | GDT_FLAG_4K_GRAN | GDT_FLAG_PRESENT);
  gdt_set_entry(2, 0, 0xfffff, GDT_FLAG_SEGMENT | GDT_FLAG_32_BIT | GDT_FLAG_DATASEGM | GDT_FLAG_4K_GRAN | GDT_FLAG_PRESENT);
  gdt_set_entry(3, 0, 0xfffff, GDT_FLAG_SEGMENT | GDT_FLAG_32_BIT | GDT_FLAG_CODESEGM | GDT_FLAG_4K_GRAN | GDT_FLAG_PRESENT | GDT_FLAG_RING3);
  gdt_set_entry(4, 0, 0xfffff, GDT_FLAG_SEGMENT | GDT_FLAG_32_BIT | GDT_FLAG_DATASEGM | GDT_FLAG_4K_GRAN | GDT_FLAG_PRESENT | GDT_FLAG_RING3);
  gdt_set_entry(5, (uint32_t)tss, sizeof(tss), GDT_FLAG_TSS | GDT_FLAG_PRESENT | GDT_FLAG_RING3);
 
  load_gdt();
  kprintf(P_GDT_LOADED);
}
 
void gdt_set_entry(int i, unsigned int base, unsigned int limit, int flags)
{
  gdt[i] = limit & 0xffffLL;
  gdt[i] |= (base & 0xffffffLL) << 16;
  gdt[i] |= (flags & 0xffLL) << 40;
  gdt[i] |= ((limit >> 16) & 0xfLL) << 48;
  gdt[i] |= ((flags >> 8) & 0xffLL) << 52;
  gdt[i] |= ((base >> 24) &  0xffLL) << 56;
}


void load_gdt()
{
  struct {
    uint16_t limit;
    void * pointer;
  } __attribute__((packed)) gdtp = {
    .limit = GDT_ENTRIES * 8 - 1,
    .pointer = gdt,
  };
  asm volatile("lgdt %0" : : "m" (gdtp));
  asm volatile("ltr %%ax" : : "a" (5 << 3));
 
  asm volatile("mov $0x10, %ax;"
"mov %ax, %ds;"
"mov %ax, %es;"
     "mov %ax, %ss;"
     "ljmp $0x8, $.1;"
     ".1:");
}



Code: [Auswählen]

static uint8_t stack_a[4096];
static uint8_t stack_b[4096];
static uint8_t user_stack_a[4096];
static uint8_t user_stack_b[4096];

static int current_task = -1;
static int num_tasks = 2;
static struct cpu_state* task_states[2];


void init_taskmanager()
{
  task_states[0] = init_task(stack_a, user_stack_a, task_a);
  task_states[1] = init_task(stack_b, user_stack_b, task_b);
  kprintf("Der Taskmanager wurde initialisiert\n");
}

struct cpu_state * init_task(uint8_t* stack, uint8_t* userstack, void* entry)
{
  struct cpu_state task_cpu_state = {
    .eax = 0,
    .ebx = 0,
    .ecx = 0,
    .edx = 0,
    .esi = 0,
    .edi = 0,
    .ebp = 0,
    .esp = (uint32_t)userstack + 4096,
    .eip = (uint32_t)entry,
    .cs = 0x18 | 0x03,
    .ss = 0x20 | 0x03,
    .eflags = 0x202,
  };
   
  struct cpu_state* state = (void*) (stack + 4096 - sizeof(task_cpu_state));
  *state = task_cpu_state;
  kprintf("%x\n", state->eip);
  return state;
}

struct cpu_state * schedule(struct cpu_state * cpu)
{
  if(current_task >= 0) {
    task_states[current_task] = cpu;

Code: [Auswählen]

intr_common_handler:
    //CPU-Stand sichern 
    push %ebp
    push %edi
    push %esi
    push %edx
    push %ecx
    push %ebx
    push %eax

    mov $0x10, %ax
    mov %ax, %ds
    mov %ax, %es

    push %esp
    call handle_interrupts
    mov %eax, %esp

    mov $0x23, %ax
    mov %ax, %ds
    mov %ax, %es

    pop %eax
    pop %ebx
    pop %ecx
    pop %edx
    pop %esi
    pop %edi
    pop %ebp

    add $8, %esp
    iret

Code: [Auswählen]

#include "includes.h" 

struct cpu_state * handle_interrupts(struct cpu_state * cpu)
{
  struct cpu_state * new_cpu = cpu;
 
  if(cpu->intr <= 0x1f) {
    clear();
    changeColor(0x1f);
    kprintf("\n Das Betriebssystem hat ein Problem festgestellt und muss beendet werden.\n\n");
   
    kprintf(" Interrupt:%v %d (Exception)\n", 15, (int)cpu->intr);
    kprintf(" Fehlercode:%v %x\n\n", 15, cpu->error);
       
    kprintf(" CPU zum Zeitpunkt des Interrupts:\n\n");
   
    kprintf("\teax:%v %x%vebx:%v%x\n", 10, cpu->eax, 25, 32, cpu->ebx);
    kprintf("\tecx:%v %x%vedx:%v%x\n", 10, cpu->ecx, 25, 32, cpu->edx);
    kprintf("\tesi:%v %x%vedi:%v%x\n", 10, cpu->esi, 25, 32, cpu->edi);
    kprintf("\tebp:%v %x%veip:%v%x\n", 10, cpu->ebp, 25, 32, cpu->eip);
    kprintf("\tesp:%v %x\n", 10, cpu->esp);
    kprintf("\tcs:%v %x%vss:%v%x\n", 10, cpu->cs, 25, 32, cpu->ss);
    kprintf("\tFlags:%v %x\n", 10, cpu->eflags);

    kprintf("\n Taste druecken um einen CPU-Reset auszufuehren...\n Mach dir keine Hoffnungen, ich komme wieder. :madcat:");
    outb(0x64, 0xFE);
   
    while(1) asm volatile("cli; hlt");
   
  } else {
    if(cpu->intr >= 0x20 && cpu->intr <= 0x2f) {
if(cpu->intr >= 0x28) {
   outb(0xa0, 0x20);
} else {
   outb(0x20, 0x20);
}
if(cpu->intr == 0x20) {
   new_cpu = schedule(cpu);
   tss[1] = (uint32_t)(new_cpu+1);
}
if(cpu->intr == 0x21) kb_irq_handler(cpu->intr);
    }
  }
 
  return new_cpu;
}
Falls ihr noch irgendwelche QEMU Logs braucht, lasst es mich hören. 

5

OS-Design / QEMU + Tastaturtreiber

« am: 15. November 2012, 22:17 »

Ich bins mal wieder 

Ich habe damit eingefangen einen kleinen Keyboard-Treiber zu programmieren. Wenn ich aber mein makefile ausführe kriege ich die Meldung "qemu: unsupported keyboard cmd=0xf4". (Ich starte dabei qemu mit qemu -kernel kernel)
Wahrscheinlich klappt das nicht, weil ich eine USB-Tastatur habe. Allerdings wird das ja normalerweise vom BIOS emuliert. Gibt es irgendeine Möglichkeit, dass ich das auch mit qemu hinkriege? Ich fände es blöd, wenn ich nach jedem Build er das GRUB-Image machen müsste.^^

6

Offtopic / Windows 7 kaputt?

« am: 13. November 2012, 15:30 »

Hi Leute,

ich habe meine Festplatte vor einigen Tagen erst formatiert, und Windows 7 draufgeladen. Später habe ich dann auch noch Debian installiert. Ich konnte dann in einem GRUB Menü zwischen Windows und Debian auswählen, was auch einwandfrei geklappt hat. Seit gerade eben funktioniert aber nur noch Debian. Wenn ich Windows 7 booten will, dann komme ich nur zum Lade-Bildschirm mit dem funkelnden Win Zeichen, dann flackert ein Bluescreen auf und der PC startet direkt neu.
Die Windows Startup Repair hat auch nicht geholfen.

Ist das Problem schon bekannt und kann man das vielleicht sogar lösen?

7

Softwareentwicklung / kprintf %d usw ersetzen

« am: 11. November 2012, 12:08 »

Hi Leute.

Ich bin gerade dabei, meine kprintf-Funktion so zu erweitern, dass man wie im Tutorial gefordert soetwas machen kann: kprintf("Die Zahl ist %d", 5);
Ich bin mir jetzt nicht so sicher wie man 1. Integer in chars umwandeln kann, sodass auch wirklich die Zahl später angezeigt wird, nicht das zugehörige Zeichen, und 2. wie man das %d durch die Zahl ersetzt.

Meine aktuelle for-Schleife sieht so aus:

Code: [Auswählen]

  for(i=0; string[i] != '\0'; i++, iOff++) {
    if(string[i] == '\n') {
iCursor += 1;
iOff = -1;
    } else if(string[i] == '%') {
if(string[i+1] == 'd') {
   int iArg = va_arg(ap, int);
} else {
   video[(iCursor*160)+iOff*2] = string[i];
   video[(iCursor*160)+iOff*2+1] = 0x07;    
}
    } else {
video[(iCursor*160)+iOff*2] = string[i];
video[(iCursor*160)+iOff*2+1] = 0x07;
    }
  }
Ich hoffe ihr könnt mir da ein paar Tipps geben.