OSDev.org

hello,
i have a program loaded to 080000h in realmode
it switches then to pmode. That works fine.
at least i call the _main function, which is written in c (djgpp)

it looks like this:

char * message = "H A L L O ";
int main()
{
....
      movedata(datasel, message, screensel, 0, 10);
}

THE PROBLEM is: movedata works. But the pointer may hold the wrong adress. Cause 5 stupid signs are written to the screen.

When i take
char * message = "H A L L O ";

into the main() function it works!!!!
I know that local variables are on the stack. BUT:

a for(i=0....
causes the pc to hang! (i is declared local!!)
where can the problem be?

Could you maybe give some more info on this?

K.J.

sure....what kind of info?

Well, the source to your movedata function might help and all the values that you feed into the movedata function in your code:

movedata(datasel, message, screensel, 0, 10);
what's datasel equal, what's screensel equal, what's the 0 and 10 for?

Also, the commands you use to link your kernel might also help.

K.J.

Now that I think about it you're probably using the movedata from string.h(right?). If this is so try:


#include <string.h> // movedata()

#define      LINEAR_SEL      0x08
#define      SYS_DATA_SEL      0x18

int main(void)
{
     const char Msg[] = "h e l l o ";

     movedata(SYS_DATA_SEL, (unsigned)Msg,
           LINEAR_SEL, 0xB8000,
           sizeof(Msg));
     return 0;
};

Please note that I haven't tested the above code but found floating around on the 'net.

Still, please post the commands used to link your kernel, and the rest of your for(i=0.... loop.

K.J.

1st: movedata works (copied from an older version of this project)

2nd: i dont link against the libc:
ld -o loader.oos -e start --oformat binary -Ttext 0x0 $(OFILES)

where ofiles are the objectcodefiles produced by gcc -c ...

the problem is:
this works:


this dont:



movedata looks like this (altough it cant be the problem):


gdt looks like this (descriptor is a makro, that copies all the values into the gdt
1st one: nil
2nd one: kernel codeseg (yet not used)
3rd: kernel data (not used)
then stack, codeseg (for this program), dataseg(for this program (the loader)) and then the screensegment

       descriptor      0,0,0,0,0,0,0
       ;codeseg base 0 limit FFFFF, gran
       descriptor 8, 0FFFFh, 0, 0, 9Ah, 0CFh, 0
       ;dataseg base 0 limit FFFFF, gran
       descriptor 16, 0FFFFh, 0, 0, 092h, 0CFh, 0
       ;stackseg, base 70800h
       descriptor 24, 0F800h, 0800h, 07h, 092h, 040h, 0
       ;codeseg base 0x80000 limit FFFFF, gran
       descriptor 32, 0FFFFh, 0, 08h, 09Ah, 0CFh, 0
       ;dataseg base 0x80000 limit FFFFF, gran
       descriptor 40, 0FFFFh, 0, 08h, 092h, 0CFh, 0
       ;videoseg base 0xB8000 limit 4000
       descriptor 48, 0FA0h, 08000h, 0Bh, 092h, 040h, 0

you see the problem is: why doesnt it work when message is declared globally?

have you tried:

char message[] = "HALLO";

??

- Nick

Yeah, I think that you ought to try what Nick suggests, just change it to:

char message[] = "H A L L O ";

And if that doesn't work then I don't have a clue why it won't work when declared globaly . One thing I do suggest though is that if you are wanting to make a printf function then I suggest using something different than movedata.

K.J.

what else should i use to move datas?
when i change char *messge into message[] ... the pc reboots
also it does not make sense to me:

this c-code:


assembles to:



it seems that the only difference is that message[] will keep the real name (_message) in asm code.

So i took a look with the hexeditor and found that
H A L L O is contained in the file. I manually changed the sourceoffset in movedata to the offset read in the hexeditor.
And it worked. It also cant be a problem with the dataseg cause local  strings are also in it.

The only reason why I suggested it was that GCC normally sets constant strings as read only.  Presumably to save memory because you can lump similar strings together. I don't know a lot about compilers or linkers so I don't know which stage it actually does this.  Anyway.. if you set it as an array instead of a pointer, it won't set it as readonly.

I noticed you're using GCC v3.0.3.. have you tried the v2.9xx range?  v3 is pretty recent and some people have had problems with it still.

- Nick

What else should you use to move data? Do you mean "what else can I do for a printf type function?" if so then this is what I use, with a little bit of editing you should be able to easily make a printf type function:


main()
{
     char *vidmem = (char *) 0xb8000;
     char message[]="Hello";

     vidmem[0]=message[0];
     vidmem[1]=0x7; // for white on black text
     vidmem[2]=message[1];
     vidmem[3]=0x7;
     vidmem[4]=message[2];
     vidmem[5]=0x7;
     vidmem[6]=message[3];
     vidmem[7]=0x7;
     vidmem[8]=message[4];
     vidmem[9]=0x7;
};


K.J.

and wheres the difference?...if i move a block of data or every sign for itself?....also movedata is much faster and you can also use uit for other datatransfers.

BUT that is not the PROBLEM.
I tried gcc 2.952 & 2.953 ...it still doesnt work.

Does your bootloader set up your DS(data segment) and cs(code segment) properly(or at all)?

K.J.

the bootsector loads loader.oos (FAT FS) to 08000h:0
loader.oos then starts with

push cs
pop  ds

after switching to pmode:
       mov     ax, datasel
       mov     ds, ax
       mov     es, ax
       mov     fs, ax
       mov     ax, screensel
       mov     gs, ax
       mov     ax, stacksel
       mov     ss, ax
       mov     esp, stacksize
then calls main()

i can send you the code if want to have a look at it.