Linus Torvalds (torvalds.delete@this.linux-foundation.org) on September 22, 2021 11:50 am wrote:
> 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

In other words, if I read your posts about segments correctly, you seem to be claiming that there is zero correlation between the overly simplistic type system of the C programming language (plus other languages from that era) and the downfall of segments.

I claim that if this correlation is non-zero then the downfall of segments was just a historical coincidence.

-atom