Why was Intel a no-show on No Execute?

  • Thread starter Thread starter Yousuf Khan
  • Start date Start date
I'm not going to get into C compiler design issues, if C requires that the
stack and data segments be combined, then let them be combined. That's also
Click to expand...

It does not.

You can have one segment per object, if you like.

-Peter
 
Robert Wessel said:
No. It's quite common to pass a pointer to a piece of automatic (on
stack) storage to a function accepting pointers to that type of data.
Or a pointer to global, or allocated storage. Unless you pass some
additional data (in x86, a selector, for example), the called routine
has no way to tell which segment to look in. Consider:
Click to expand...

Well, as I said in another message, if stack and data need to share the same
segment, then you can share the same segment for them. You still don't have
to combine them into the same segment as the code segment.

Yousuf Khan
 
In comp.sys.ibm.pc.hardware.chips Yousuf Khan said:
True, but we're not talking about a pure segments-only arrangement. We're
talking about a segmented/paged arrangement. Each segment could could have
its own separate page entries in the page directory. Meaning that with
demand-paging only the sections of a segment required to be in memory could
be in memory while the rest remains marked virtual on disk.

Yousuf Khan
Click to expand...
No, that still doesn't get you an address space > 4GB.

"Each segment could could have its own separate page entries in the
page directory." What the heck does this mean? A segment doesn't "have"
any entries in the page directory, the linear address which results
from segmentation gets translated to a physical address using the
page directory & page table entries. A linear address is 32 bits,
that's 4GB of address space.

Jerry
 
In comp.sys.ibm.pc.hardware.chips Yousuf Khan said:
Well, I'm sure the C compiler implementation would know when it's accessing
a stack element or a data element, and use the appropriate pointers (i.e.
stack or data). When are the only times you'd be pointing to an element on
the stack? It's usually only done when accessing a passed argument. You
should know which arguments are passed into a function, and which ones are
local to the function.
Click to expand...

In a function, automatic local variables are on the stack. I can pass
the address of one of these to any function which is expecting a
pointer of that type, I could also pass an address of a global or an
address returned by malloc, all in the same function call; think
printf and friends and character string arguments. In fact, with a
literal format string and using gcc defaults, I'd also be passing a
pointer in the text area of the program since gcc defaults to putting
ro strings in the code area.

Jerry


---snip-----
 
Well, as I said in another message, if stack and data need to share the same
segment, then you can share the same segment for them. You still don't have
to combine them into the same segment as the code segment.
Click to expand...

What on Earth has that got to do with anything? You still need long
pointers -- if your compiler is heroic, it can optimize some of the
pointer operations into short pointers (i.e. 4-byte pointers).

-Peter
 
Peter said:
What on Earth has that got to do with anything? You still need long
pointers
Click to expand...

What for? If 'DS == SS' then a pointer dereferenced through either
segment will refer to the same memory location. All that's necessary is
to restrict the size of the code segment so that it doesn't include
memory used for the heap or stack.
 
You then can only have only one code segment and only one data segment,
which at the same time should be stack segment.

You then have to reserve a whole area for code only, and load all code
segments of all dynamic libraries there, and reserve the rest for data. You
won't be able to arbitrarily mix data and code areas - it would require
'far' pointers, which are a pain.
 
Jerry Peters said:
No, that still doesn't get you an address space > 4GB.

"Each segment could could have its own separate page entries in the
page directory." What the heck does this mean? A segment doesn't
"have" any entries in the page directory, the linear address which
results from segmentation gets translated to a physical address
using the page directory & page table entries. A linear address is
32 bits, that's 4GB of address space.
Click to expand...

Well, when you're using a task gate to switch between programs, you can set
each task to have its own unique page table base address (loaded into CR3).
Each task could have its own page table. You can map all programs to have
their own unique pages, including unique virtual pages.

Yousuf Khan
 
Jerry Peters said:
No, that still doesn't get you an address space > 4GB.

"Each segment could could have its own separate page entries in the
page directory." What the heck does this mean? A segment doesn't
"have" any entries in the page directory, the linear address which
results from segmentation gets translated to a physical address
using the page directory & page table entries. A linear address is
32 bits, that's 4GB of address space.
Click to expand...

Well, when you're using a task gate to switch between programs, you can set
each task to have its own unique page table base address (loaded into CR3).
Each task could have its own page table. You can map all programs to have
their own unique pages, including unique virtual pages.

Yousuf Khan
 
Jerry Peters said:
No, that still doesn't get you an address space > 4GB.

"Each segment could could have its own separate page entries in the
page directory." What the heck does this mean? A segment doesn't
"have" any entries in the page directory, the linear address which
results from segmentation gets translated to a physical address
using the page directory & page table entries. A linear address is
32 bits, that's 4GB of address space.
Click to expand...

Well, when you're using a task gate to switch between programs, you can set
each task to have its own unique page table base address (loaded into CR3).
Each task could have its own page table. You can map all programs to have
their own unique pages, including unique virtual pages.

Yousuf Khan
 
Alexander Grigoriev said:
You then can only have only one code segment and only one data
segment, which at the same time should be stack segment.

You then have to reserve a whole area for code only, and load all code
segments of all dynamic libraries there, and reserve the rest for
data. You won't be able to arbitrarily mix data and code areas - it
would require 'far' pointers, which are a pain.
Click to expand...

You can use the page tables to map the data pages totally separately from
the code pages. In a case like that you can start your data access right
from address 0 and finish right at the 4GB address mark. There will be no
danger of it overwriting the code, because the code will have totally
different pages. The code itself could go from 0 to 4GB without ever
trampling over the data segments either. This where the paging magic comes
in.

Yousuf Khan
 
Yousuf Khan said:
You can use the page tables to map the data pages totally separately from
the code pages. In a case like that you can start your data access right
from address 0 and finish right at the 4GB address mark. There will be no
danger of it overwriting the code, because the code will have totally
different pages. The code itself could go from 0 to 4GB without ever
trampling over the data segments either. This where the paging magic comes
in.
Click to expand...

While the physical address space can be 36-bit, isn't the linear address
space still limited to 32-bit? If that's correct, all segments must have
the same base (zero) if they're to have a 4GB limit.

S
 
What for? If 'DS == SS' then a pointer dereferenced through either
segment will refer to the same memory location. All that's necessary is
to restrict the size of the code segment so that it doesn't include
memory used for the heap or stack.
Click to expand...

I think you misunderstood Yousuf.

-Peter
 
Stephen Sprunk said:
While the physical address space can be 36-bit, isn't the linear
address space still limited to 32-bit? If that's correct, all
segments must have the same base (zero) if they're to have a 4GB
limit.
Click to expand...

Yes, but they can be different 4GB regions because they will have different
page mappings.

Yousuf Khan
 
Yousuf Khan said:
Yes, but they can be different 4GB regions because they will have different
page mappings.
Click to expand...

How? LDT/GDT are used to map virtual addresses to linear addresses, and
page tables are used to map linear addresses to physical addresses. If the
linear address space is 32-bit, how can a single process address more than
4GB in unique virtual address space? My understanding is that systems over
4GB use different page directories for each process so that the linear
address space can be reused, but I don't see a similar scheme using
selectors within a single process.

S
 
How? LDT/GDT are used to map virtual addresses to linear addresses, and
page tables are used to map linear addresses to physical addresses. If the
linear address space is 32-bit, how can a single process address more than
4GB in unique virtual address space? My understanding is that systems over
Click to expand...

It can't, really. But...
4GB use different page directories for each process so that the linear
address space can be reused, but I don't see a similar scheme using
selectors within a single process.
Click to expand...

....if you have long pointers (with selectors), several of them, in fact,
then you can mark some of the corresponding segments as not present.
When the program tries to access it, the operating system can kick and
change the page tables (and mark the faulting segment present). You have
in effect taken the bank switching schemes from the late eighties' home
computers into the brave new modern world. Or something.

It's called pointer swizzling.

-Peter
 
In comp.sys.ibm.pc.hardware.chips Yousuf Khan said:
Well, when you're using a task gate to switch between programs, you can set
each task to have its own unique page table base address (loaded into CR3).
Each task could have its own page table. You can map all programs to have
their own unique pages, including unique virtual pages.

Yousuf Khan
Click to expand...
??? You're confused. That's how Linux works now, each process has its
own page tables and hence address space. Oh, except Linux doesn't use
a task gate, since 1) it's slow, & 2) limits you to something like
4000 total processes. This still doesn't get you a _single_ AS that's
greater then 4GB. AFAIK x86 has no facilities like IBM's S3X0 has to
have access to multiple address spaces at once.

You _really_ do need to do some research on OS design and
implementation issues.

Jerry
 
Back
Top