Need complete picture of virtual address space

This image gives a good picture about Virtual Address space. But it only says half of the story. It on开发者_JAVA技巧ly gives complete picture of User Address space ie.. lower 50% (or 75% in some cases).

What about the rest 50% (or 25%) which is occupied by the kernel. I know kernel also has so many different things like kernel modules , device drivers, core kernel itself. There must be some kind of layout right?

What is its layout? If you say its Operating System dependent. I would say, there are two major operating systems Windows & Linux. Please give answer for any one these.

alt text http://img690.imageshack.us/img690/2543/virtualadressspace.gif

I've got even worse news for you, there's also a feature to explicitly randomize kernel address layouts by the OS as a security feature. This is on by default in most recent Windows, OpenBSD as well as being an option for Linux.

Like users said here, your picture is incomplete. It tends to look something specific to single-threaded OS. In particular there may be hundreds of threads within the process (hence - sharing the same address space), everyone with its own stack.

Also, I believe the actual picture of the address space may vary strongly depending on OS version and some subtle changes.

It's not completely clear from your question or the image, but with the 'System Address Space' you probably mean the area between 2GB-4GB. This indeed takes up half of the theoretical 4GB space, but there is a valid reason for it.

Normally with 32-bits you can address 4 GB of memory (2^32=4294967296) so it would seem logical to have 4 GB of address space, not 2 GB. The reason for this is the following: Suppose you have 2 pointers, like this in C/C++:

char *ptr1;
char *ptr2;

I now want to know what the difference is between the two pointers, like this:

offset = ptr2 - ptr1;

What should be the data type of 'offset'? If we don't know whether ptr1 comes before ptr2 or vice versa, the offset can be positive or negative. Now if both ptr1 or ptr2 are between the range 0 - 2GB, then the offset is always between -2147483648 and +2147483647, which fits exactly in a 4 byte signed integer.

However, if ptr1 and ptr2 would be able to access the full 4 GB address space, offset would be between -4294967296 and +4294967295 which doesn't fit in a 4 byte signed integer anymore.

If you are sure that you are never doing this kind of calculations in your application, or you are sure that if you subtract 2 pointers that they will be never more apart than 2 GB (or your vectors are always smaller than 2 GB), you can tell the linker (Windows, Visual Studio) that your application is LARGEADDRESSAWARE. This linker flag sets a bit in the executable, and if a 32-bit Windows is booted correctly (on XP you had to boot with the /3GB) flag, Windows gave you 3GB instead of 2GB (only for the LARGEADDRESSAWARE executables). The remaining 1GB is still used for operating system data structures (but I have no details about them).

If you are running a 64-bit Windows, then things get even more interesting, because LARGEADDRESSAWARE executables will then get 4GB of memory. Apparently, the operating system data structures are now stored somewhere in the 64-bit address space, outside the 4GB used by the application.

Hope this clarifies a bit.

Memory Layout of Windows Kernel. Picture taken from Reversing: Secrets of Reverse Engineering

alt text http://img821.imageshack.us/img821/1525/windowskernelmemorylayo.jpg