21 Feb
2006
21 Feb
'06
8:44 p.m.
On 2/21/2006 at 7:35 PM vrs wrote:
I am certain that Xenix/286 doesn't page. It does
swap, much like early
PDP-11 Unix kernels. But you will need enough RAM to load the kernel plus
your largest process.
Certainly not page--there's no native paging facility in the 286. That
came with the 386. However, the 286 can run segmented code and swap
segments in and out of memory. One could, I suppose, define a 64K page
size and fill the descriptor table with entries and so, in theory, have a
virtual memory size of half a gig. But you'd have to tread selector
arithmetic something awful.
AFAIK, no OS ever did this on the 286.
Cheers,
Chuck
21 Feb
21 Feb
10:15 p.m.
It was thus said that the Great Chuck Guzis once stated:
On 2/21/2006 at 7:35 PM vrs wrote:
I belive OS/2 1x did this. IBM insisted on OS/2 supporting the 286 while
Microsoft wanted to skip it and support the 386 and above (this was one
disagreement between IBM and Microsoft that lead to the split between the
two).
-spc (Who worked at IBM during 1990 on an OS/2 1x project ... )
I am certain that Xenix/286 doesn't page. It
does swap, much like early
PDP-11 Unix kernels. But you will need enough RAM to load the kernel plus
your largest process.
Certainly not page--there's no native paging facility in the 286. That
came with the 386. However, the 286 can run segmented code and swap
segments in and out of memory. One could, I suppose, define a 64K page
size and fill the descriptor table with entries and so, in theory, have a
virtual memory size of half a gig. But you'd have to tread selector
arithmetic something awful.
AFAIK, no OS ever did this on the 286.
10:45 p.m.
On 2/22/2006 at 1:15 AM spc at conman.org wrote:
I belive OS/2 1x did this. IBM insisted on OS/2
supporting the 286
while
Microsoft wanted to skip it and support the 386 and
above (this was one
disagreement between IBM and Microsoft that lead to the split between the
two).
I can believe that OS/2 swapped segments, but it'd be pretty surprising to
me to find out that they'd defined a fixed page size. I've still got OS/2
1.1 and 1.2 kicking around somewhere, complete with the SDK stuff--all
printed, bound material. A wonder of careful technical writing. IIRC, if
the SDK docs say something works a certain way, it does.
Microsoft SDK/DDK documentation was a rude surprise after that.
Cheers,
Chuck
22 Feb
22 Feb
11:14 a.m.
It was thus said that the Great Chuck Guzis once stated:
On 2/22/2006 at 1:15 AM spc at conman.org wrote:
Well, the 286 only supported swapping (no paging) (now I see what is being
discussed).
Also, on the 8086, sequential segments were 16 bytes apart and many
programs relied upon this behavior. I know that OS/2 included support for
sequential selectors but one had to call a function to get the offset
between each selector. Not that I used such functions---just that I recall
seeing them in the documentation.
I belive OS/2 1x did this. IBM insisted on OS/2
supporting the 286
while
Microsoft wanted to skip it and support the 386
and above (this was one
disagreement between IBM and Microsoft that lead to the split between the
two).
I can believe that OS/2 swapped segments, but it'd be pretty surprising to
me to find out that they'd defined a fixed page size. I've still got OS/2
1.1 and 1.2 kicking around somewhere, complete with the SDK stuff--all
printed, bound material. A wonder of careful technical writing. IIRC, if
the SDK docs say something works a certain way, it does.
When I worked at IBM, I remember most of my desk being taken up with OS/2
1x programming documentation and it being quite complete. At the time, most
of the programmers in the department were using Charles Petzold's OS/2 GUI
programming book (mostly for handling of dialog boxes), which included
routines to handle radio buttons, check boxes, etc. I was amazed to
discover that OS/2 would handle those things automatically and subsequently,
the code I wrote to handle dialog boxes was about a tenth the size of my
fellow cow-orkers.
Microsoft SDK/DDK documentation was a rude surprise
after that.
Fortunately, never did any Windows programming.
-spc (Really liked OS/2)
25 Feb
25 Feb
1:48 p.m.
On 2/22/06, Sean 'Captain Napalm' Conner <spc at conman.org> wrote:
Also, on the 8086, sequential segments were 16 bytes
apart and many
programs relied upon this behavior. I know that OS/2 included support for
sequential selectors but one had to call a function to get the offset
between each selector. Not that I used such functions---just that I recall
seeing them in the documentation.
There was a function called DosGetHugeShift(). The segment increment
was (1<<HugeShift) But they always return the same value in a given
environment (3 in the case of OS/2). They were primarilty provided
for code portability (so you could use the same object file in dos
assuming you provide a DosGetHugeShift() function that returns 12.)
Most DOS extenders had similar calls although some returned the
increment rather than the shift.
22 Feb
22 Feb
4:17 a.m.
On 2/22/06, Sean 'Captain Napalm' Conner <spc at conman.org> wrote:
That is my understanding, too, for what little it's worth...
--
Liam Proven ? http://livejournal.com/userinfo.bml?user=lproven
AOL/AIM/iChat: liamproven at aol.com ? MSN/Messenger: lproven at hotmail.com
Yahoo: liamproven at yahoo.co.uk ? Skype: liamproven ? ICQ: 73187508
Gmail/Google Talk/Orkut: lproven at gmail.com
It was thus said that the Great Chuck Guzis once
stated:
AFAIK, no OS
ever did this on the 286.
I belive OS/2 1x did this. IBM insisted on OS/2 supporting the 286 while
Microsoft wanted to skip it and support the 386 and above (this was one
disagreement between IBM and Microsoft that lead to the split between the
two). 
12:05 p.m.
On Wed, 22 Feb 2006, Sean 'Captain Napalm' Conner wrote:
I belive OS/2 1x did this. IBM insisted on OS/2
supporting the 286 while
Microsoft wanted to skip it and support the 386 and above (this was one
disagreement between IBM and Microsoft that lead to the split between the
two).
"The 80286 is brain dead" - Bill Gates
"Changing modes on the '286 is like having to shut off your car engine on
the freeway to shift gears." - Gordon Letwin (primary OS/2 at MS)
12:18 p.m.
At 02:05 PM 2/22/2006, Fred Cisin wrote:
"Changing modes on the '286 is like having to
shut off your car engine on
the freeway to shift gears." - Gordon Letwin (primary OS/2 at MS)
Referring to the method involving the keyboard controller to
make the system change gears by almost rebooting?
- John
12:35 p.m.
It was thus said that the Great John Foust once stated:
At 02:05 PM 2/22/2006, Fred Cisin wrote:
Yup. Because once in protected mode on the 286, you can't get out unless
you reset the CPU.
-spc (I think you could get out by tripple faulting ... )
"Changing modes on the '286 is like
having to shut off your car engine on
the freeway to shift gears." - Gordon Letwin (primary OS/2 at MS)
Referring to the method involving the keyboard controller to
make the system change gears by almost rebooting? 
4:37 p.m.
Yup. Because once in protected mode on the 286, you
can't get out unless
you reset the CPU.
-spc (I think you could get out by tripple faulting ... )
Could you, in general. I think you can on the PC/AT, but I seem to recall
a circuit that detects the odd state of the bus status lines if you get a
triple fault, and then resets the CPU, or toggles a pin on the keyboard
controller, or...
-tony
5:24 p.m.
On Thu, 23 Feb 2006, Tony Duell wrote:
By lore, Gordon Letwin was responsible for coding a hack which used the
keyboard controller MPU to reset the CPU and throw it back into real mode.
I guess it worked, but was incredibly slow.
Yup.
Because once in protected mode on the 286, you can't get out unless
you reset the CPU.
-spc (I think you could get out by tripple faulting ... )
Could you, in general. I think you can on the PC/AT, but I seem to recall
a circuit that detects the odd state of the bus status lines if you get a
triple fault, and then resets the CPU, or toggles a pin on the keyboard
controller, or... 
5:26 p.m.
I realize that I'm talking about something much later
in time, but didn't Windows 95 engage in "thunking",
meaning, IIUC, to revert to 16 bit code (i.e.
non-protected mode stuph)? So therefore, at least
newer Pentium series uPs, had the ability to switch in
and out of protectd mode. M$ had us believing that
Chicago was rewritten from the ground up (I think they
said that in the beginning), and didn't rely on 16-bit
code whatsoever.
__________________________________________________
Do You Yahoo!?
Tired of spam? Yahoo! Mail has the best spam protection around
http://mail.yahoo.com
Yup.
Because once in protected mode on the 286,
you can't get out unless
you reset the CPU.
-spc (I think you could get out by tripple
faulting ... )
Could you, in general. I think you can on the PC/AT,
but I seem to recall
a circuit that detects the odd state of the bus
status lines if you get a
triple fault, and then resets the CPU, or toggles a
pin on the keyboard
controller, or...
-tony
23 Feb
23 Feb
12:08 a.m.
On 2/22/2006 at 5:26 PM Chris M wrote:
I realize that I'm talking about something much
later
in time, but didn't Windows 95 engage in "thunking",
meaning, IIUC, to revert to 16 bit code (i.e.
non-protected mode stuph)? So therefore, at least
newer Pentium series uPs, had the ability to switch in
and out of protectd mode. M$ had us believing that
Chicago was rewritten from the ground up (I think they
said that in the beginning), and didn't rely on 16-bit
code whatsoever.
Well, now wait just a second. "Thunking" usually refers to calling a
32-bit DLL from 16-bit code or vice versa. But both are usually in
protected mode. And, while it's true that Win95 used a lot of the guts of
DOS and BIOS functions, there wasn't any need in the 386 architecture to
switch to real mode. Did MS ever claim that Chicago was written from the
ground up? I didn't think they did--they did integrate the Win32S DLL into
the new platform and added support for long file names. For a quick and
dirty solution to attempt to bridge the gap between NT and Windows 3.x, it
wasn't too bad. I still keep a copy of Win98 running on a system or two
around here.
Windows 3.x had a lot of really limiting stuff in it. Such as the way VxDs
were called via the mux interrupt. If you wrote a VxD back in the Win 3.1
days, you had to apply to MS for a VxD number if you ever hoped to deploy
the thing--and you couldn't dynamically load and unload them.
Cheers,
Chuck
7:22 a.m.
On 2/23/06, Chris M <chrism3667 at yahoo.com> wrote:
I realize that I'm talking about something much
later
in time, but didn't Windows 95 engage in "thunking",
meaning, IIUC, to revert to 16 bit code (i.e.
non-protected mode stuph)?
Not quite. On an OS that runs a mixture of code designed for different
word lengths - e.g., mixed 16- & 32-bit, or mixed 64- and 32-bit -
"thunking" is making API calls from one address space to the other.
So, for example, running 32-bit Internet apps on Win9x called the
16-bit networking layer, requiring a thunk from Win32 address space
into Win16. Similarly, running 16-bit apps on NT required thunks from
16-bit address space into 32-bit, so that the 16-bit apps could call
32-but DLLs.
The same applies with running 32-bit Windows code on 64-bit versions
of XP or W2K3.
http://en.wikipedia.org/wiki/Thunking
http://foldoc.org/foldoc.cgi?query=thunk&action=Search
So therefore, at least
newer Pentium series uPs, had the ability to switch in
and out of protectd mode.
Something different.
The 80286 ran in "protect mode" or "real mode", but only provided an
opcode to switch from real to protected, not back again. This is the
problem discussed elsewhere in this thread - horrible kludges were
required to get back into real mode again, causing major problems for
OSs trying to run real-mode code in protect mode. I.e., OS/2 1.x.
http://en.wikipedia.org/wiki/Protected_mode
http://en.wikipedia.org/wiki/Real_mode
M$ had us believing that
Chicago was rewritten from the ground up (I think they
said that in the beginning), and didn't rely on 16-bit
code whatsoever.
No, not so. Chicago was "Windows 4.0" for a long time. It's NT that
was the ground-up rewrite, albeit based on the codebase of OS/2 3, the
portable version of OS/2, as made to work by Dave Cutler & his team
hired in from DEC, which explains the internal resemblances to VMS.
--
Liam Proven ? http://livejournal.com/userinfo.bml?user=lproven
AOL/AIM/iChat: liamproven at aol.com ? MSN/Messenger: lproven at hotmail.com
Yahoo: liamproven at yahoo.co.uk ? Skype: liamproven ? ICQ: 73187508
Gmail/Google Talk/Orkut: lproven at gmail.com
22 Feb
22 Feb
3:03 p.m.
>"Changing modes on the '286 is like
having to shut off your car engine on
>the freeway to shift gears." - Gordon Letwin (primary OS/2 at MS)
On Wed,
22 Feb 2006, John Foust wrote:
Referring to the method involving the keyboard
controller to
make the system change gears by almost rebooting?
I ASSUME that is what he was referring to.
I should dig out a copy of his book ("Inside OS/2"), and see whether he
mentions it there.
3:14 p.m.
On Wed, 22 Feb 2006, John Foust wrote:
> Referring to the method involving the keyboard controller to
> make the system change gears by almost rebooting?
Actually, you DO reboot--there's a flag that's set in CMOS that tells the
boot routines what's special about it.
Cheers,
Chuck
12:39 p.m.
Fred Cisin wrote:
On Wed, 22 Feb 2006, Sean 'Captain Napalm'
Conner wrote:
To be honest, they were right. If you wanted more than 640K on a 286,
it was easier and faster to work with a hardware LIM EMS board than it
was to try to do it yourself via protected mode. (I'm talking about the
period before HIMEM.SYS and the formalized XMS standard, but even then,
XMS copies RAM in and out of the 640K-space, whereas EMS would just
slide the window around which was a hell of a lot faster.)
--
Jim Leonard (trixter at oldskool.org) http://www.oldskool.org/
Help our electronic games project: http://www.mobygames.com/
Or check out some trippy MindCandy at http://www.mindcandydvd.com/
A child borne of the home computer wars: http://trixter.wordpress.com/
I belive OS/2 1x did this. IBM insisted on
OS/2 supporting the 286 while
Microsoft wanted to skip it and support the 386 and above (this was one
disagreement between IBM and Microsoft that lead to the split between the
two).
"The 80286 is brain dead" - Bill Gates
"Changing modes on the '286 is like having to shut off your car engine on
the freeway to shift gears." - Gordon Letwin (primary OS/2 at MS)
1:46 p.m.
On 2/22/2006 at 2:39 PM Jim Leonard wrote:
To be honest, they were right. If you wanted more than
640K on a 286,
it was easier and faster to work with a hardware LIM EMS board than it
was to try to do it yourself via protected mode. (I'm talking about the
period before HIMEM.SYS and the formalized XMS standard, but even then,
XMS copies RAM in and out of the 640K-space, whereas EMS would just
slide the window around which was a hell of a lot faster.)
Yes and no--if you were savvy enough to know how to use LOADALL, things got
somewhat simpler.
Cheers,
Chuck
2:40 p.m.
Chuck Guzis wrote:
On 2/22/2006 at 2:39 PM Jim Leonard wrote:
My balls weren't big enough to try it :-) Maybe today, with all of the
documentation, it might be fun to explore. But with emulators all the
rage with the kids these days, exploiting LOADALL means that your
program would only run on the real thing.
--
Jim Leonard (trixter at oldskool.org) http://www.oldskool.org/
Help our electronic games project: http://www.mobygames.com/
Or check out some trippy MindCandy at http://www.mindcandydvd.com/
A child borne of the home computer wars: http://trixter.wordpress.com/
To be honest, they were right. If you wanted
more than 640K on a 286,
it was easier and faster to work with a hardware LIM EMS board than it
was to try to do it yourself via protected mode. (I'm talking about the
period before HIMEM.SYS and the formalized XMS standard, but even then,
XMS copies RAM in and out of the 640K-space, whereas EMS would just
slide the window around which was a hell of a lot faster.)
Yes and no--if you were savvy enough to know how to use LOADALL, things got
somewhat simpler.
2:59 p.m.
On 2/22/2006 at 4:40 PM Jim Leonard wrote:
My balls weren't big enough to try it :-) Maybe today, with all of the
documentation, it might be fun to explore. But with emulators all the
rage with the kids these days, exploiting LOADALL means that your
program would only run on the real thing.
It'd be fun to see which emulators know about 286 LOADALL. Certainly most
386/486 BIOSes trapped it and emulated it.
Cheers,
Chuck
21 Feb
21 Feb
11:12 p.m.
Chuck Guzis wrote:
AFAIK, no OS ever did this on the 286.
Depends on "OS" I guess -- I distinctly remember Geoworks supporting
extremely granular code objects and virtual memory. But Geoworks wasn't
really an OS (for the same reason Win95/98/me weren't really OSes ;-)
--
Jim Leonard (trixter at oldskool.org) http://www.oldskool.org/
Help our electronic games project: http://www.mobygames.com/
Or check out some trippy MindCandy at http://www.mindcandydvd.com/
A child borne of the home computer wars: http://trixter.wordpress.com/
11:42 p.m.
On 2/22/2006 at 1:12 AM Jim Leonard wrote:
Depends on "OS" I guess -- I distinctly
remember Geoworks supporting
extremely granular code objects and virtual memory. But Geoworks wasn't
really an OS (for the same reason Win95/98/me weren't really OSes ;-)
Yes, but I don't think any 286 OS used fixed page sizes!
Cheers,
Chuck
25 Feb
25 Feb
9:34 a.m.
On 2/21/06, Chuck Guzis <cclist at sydex.com> wrote:
One could, I
suppose, define a 64K page
size and fill the descriptor table with entries and so, in theory, have a
virtual memory size of half a gig. But you'd have to tread selector
arithmetic something awful.
AFAIK, no OS ever did this on the 286.
OS/2 1.X definitely does segment swapping with support for logically
adjacent segments, as do some 286 DOS extenders. The selector math
isn't that difficult (to get the next segment you add 8).
Eric
10:50 a.m.
On 2/25/2006 at 9:34 AM Eric J Korpela wrote:
OS/2 1.X definitely does segment swapping with support
for logically
adjacent segments, as do some 286 DOS extenders. The selector math
isn't that difficult (to get the next segment you add 8).
...and Windows also allowed this for large memory allocations, though it
was held in the realm of "undocumented". I know of no 286 OS that used
sequentially-numbered selectors to divide up the whole memory space into
uniform 64K segments, a la "real" paging. IOW, you couldn't simply take
any arbitrary address and compute the selector for a new address from it
without knowing the value of the selector for some other address.
Cheers,
Chuck
6826
days inactive
6829
days old
23 comments
10 participants
participants (10)
-
ard＠p850ug1.demon.co.uk -
cclist＠sydex.com -
chrism3667＠yahoo.com -
cisin＠xenosoft.com -
jfoust＠threedee.com -
korpela＠ssl.berkeley.edu -
lproven＠gmail.com -
shirsch＠adelphia.net -
spc＠conman.org -
trixter＠oldskool.org