sr (nobody.delete@this.nowhere.com) on September 22, 2021 6:55 am wrote:
>
> Why would segments need different page tables? What would
> be point of doing so instead of different processes?

A segment (or whatever you want to call it: as mentioned, people don't like some of the historical connotations, and depending on which part of the problem you care about you might want to call it a "capability pointer") is much more interesting if it gives you access to other peoples address spaces.

If it only partitions up an existing address space - like the x86 segments did - it means that segments are no good for data sharing. You can only share data if you share the page tables, so you don't actually get any advantage from using segments.

End result: all sane operating systems ended up saying "we'll just make segments the maximum size, and you can just use a flat address space to access all memory".

IOW, The i386 segments fundamentally didn't really add any functionality, they only made it more inconvenient to access memory.

The only time segments are useful is if they give you added capabilities. And no, "limiting access" is not really an added capability from a user standpoint, despite how many computer architects want to do it. You need to give people something, and in that context you can then add permissions as a part of the parcel. Not just say "this adds no other value than limit you".

So in the original 8086, people used segments - not because they liked them, but because segments was how you could access more than 64kB of memory.

In the 80286, people used segments - again not because they liked them, but because they could (repeat after me) access more than 64kB of memory, but also because they could use them to handle fragmented memory (the 286 segments were virtual addresses, not just extra phyiscal bits) and to implement security in the OS.

In the 80386 world? Nobody sane uses segments, because you can access the full address space without them, and you can do better security without them too. Paging is just so superior. Segments don't really add anything. They only make for problems, they don't make for solutions.

(Yeah, there is one special case: people use segments to get access to some thread-local storage. So honesty in advertising - segments are still used even in the 64-bit world, but they aren't actually used "as segments" - they are used pretty much purely as a thread-local base address pointer, and the "segment" use is really just a convenient special addressing mode).

But segments could be used to add something. You could use segments as a way to reach into another process' address space, and use them for controlled cross-process communication. Or on a kernel or VMM level, you could use segments as the way to access user memory or the virtual guest memory, or things like memory-mapped IO.

IOW, you could use segments to get a bigger address space, like they did in 8086.

That's not how 80386+ segments work, but other architectures have that kind of functionality (although they tend to be called "address spaces", not segments), where instead of having segment overrides like x86 has, they have address space bits in the instructions to do special loads from other memory domains.

Segments could do things like that. Would it be a good idea? Probably not - history really hasn't been gentle to the idea of having complicated memory indirection, and segments very much are just an "added indirection and complication". But things like that could at least make segments part of the solution rather than being part of the problem, like they mostly are now.

But back when segments very much were part of the solution, people pretty much universally hated them. They hated them on 8086, they hated them even more on 80286. And they weren't good in any other architecture either, it's just that at least on x86 they were successful.

Linus