Re: [Linuxconsole-dev] writeup

[James S. <jsi...@ac...>]

> If I suggest a concrete example, can you tell me which are heads and which
> are consoles ?  This is hypothetical example, that I think may be possible,
> if I understand correctly what is being suggested.
> 
> Let's say we have two desks back-to-back, a machine on the floor, with two
> video cards, and two monitors, two keyboards, two mice plugged in.  Two
> people use that one machine, independently, running console-programs on
> several screens (switched with Alt-Fn), and also running X-Windows and
> X-Windows apps.  Physically we have two independent `stations' (by which I'm
> meaning seat-desk-keyboard-monitor).  Are these two `heads' ?  Or are they
> two `consoles', with multiple `heads' being switched between with (Ctrl-)
> Alt-F?.

Okay. We have some confussion. A console is a device thats composed of a
keyboard type of device and some video output. This can be a real console
like a serial console. It can be a virtual terminal, meaning a fake or
emulated serial console, thats made of a pc keyboard and a video card with
monitor. To see different examples of different types of consoles look at
the console_init function in tty_io.c. 

What you described above is a system with two ACTIVE consoles and several
inactive consoles depending on how many different VTs both people
are logged into. Say person one is logged into 3 different VTs and person
2 is logged in 5. Thus we have 6 ((5+3)-2 active) inactive console.

   A head is a bit different since its just a collect of input and output
devices working together. In this example we have 2 heads. 
   Let me give you a example of another type of a head. Imagine you work
at a engineering company working on a CAD project. Now a team wants to
work on this project. Say we have a multiheaded system with 8 keyboards
and 8 fbdev devices so in essence we have 8 seperate active consoles. It
would be ideal of each video output showed the same thing but each person
at each console could modify that image on the screen. So each worker can
alter in project in real time with respect to each other. So when the app
would start you would open each /dev/fb and accept input from each
keyboard/mouse from where each employee is sitting. So this is one head a
app created that's composed of a several fbdev and input devices. Now in
this case all the fbdev drivers show the same image. Now if really want to
get fancy you could have it so each fbdev is a part of a big desktop.
Imagine a projection on a wall made from a several fbdev images pieced
together and the inputs be hooked to it. Each empolyee can look at the
wall and you would see several cursors flying around doing abunch of
things each independent of each other. Like one empolyee closing some
window and another moving one.  
   Consider a class of students with a teacher. Now their is only one
computer with a bunch of keyboards and a bunch of video outputs devices.
The teacher has one console go to his/her desk and the other consoles go
to the students. Now the teacher wants to give a presentation. So the
teacher wants what he/she has on her console displayed on all the students
consoles. Now we don't want the students fooling around with the
presentation so they are in essence locked out. The app the teacher starts
grabs all their video outputs but not their keyboards. Here we have a head
that composed of several video outputs and one keyboard. Of course you can
create more than one head by say you doing both thing above at the same
time. 

> Let's say we add a VT100 terminal on the next desk on a serial cable.  Is
> this another `console', or `head', or both ?  Or is just one of these three
> `stations' really considered to be the official `console' of the system ?

All 3 would be a active console of the system. 

> Things seem to get much more confusing if we think of someone with one
> keyboard/mouse and two monitors, with some hot-keys to switch the stream of
> input events between one monitor or the other (between the applications
> visibly running on those monitors).  But this could be seen as a kind of
> emulation of the two `stations' above - somehow an emulation of two
> keyboards/mice through just one.

Here you have one console (one keyboard/one monitor) and one floating
monitor that free for a app to grab. Userland builds the head. The app
could grab the keyboard and the two monitors. In this case this means any
input is sent to both video outputs devices.

> Or is this too inflexible a viewpoint ?  You may want your two monitors to
> work in cooperation, perhaps moving apps from one monitor to the other, or
> even having X-Windows spanning two monitors.  To me this bunch of hardware
> counts as one `station', but does it count as multiple `heads' or multiple
> `consoles' as well ?  Confusing.

See above.

"Look it's a text editor, no it's a OS, no it's Emacs"
James Simmons                                           ____/| 
fbdev/gfx developer                                     \ o.O| 
http://www.linux-fbdev.org                               =(_)= 
http://linuxgfx.sourceforge.net                            U