[cap-talk] Piping capability communication, data vs. descriptor capability strengths

Bill Frantz frantz at pwpconsult.com
Tue Mar 3 18:02:13 EST 2009

capability at webstart.com (Jed Donnelley) on Friday, February 27, 2009 wrote:

>At 04:03 PM 2/27/2009, Bill Frantz wrote:
>>capability at webstart.com (Jed Donnelley) on Friday, February 27, 2009 wrote:
>> >Have there ever been such systems (e.g. E,
>> >KeyKos/EROS/Coyotos/CapROS, etc.) that can effectively "pipe"
>> >communication streams between running programs that include
>> >capabilities?  Perhaps supporting something like the Unix shell
>> >piping syntax, but including capabilities in the communication for
>> >tinker toy connections between working modules?
>>KeyKOS could link two domains together in a coroutine linkage
>><http://www.cap-lore.com/CapTheory/KK/m/180.html#coroutine>. This linkage
>>permitted both data and keys to be passed on every invocation.
>>The New Command System had pipe syntax
>><http://www.cap-lore.com/CapTheory/KK/m/166.html> (see under heading "Pipe
>>Syntax") which made it easy to set up these linkages.
>Thanks for responding Bill.  While the first is interesting, I don't see
>how it relates to my question.  Perhaps the mechanisms are more intertwined
>that I understand, but let me try to focus on:

The first is the low-level protocol for passing data and capabilities. The
second is the command system syntax for setting up these linkages.

>The second is close and perhaps by asking a few more details I can
>determine if it answers my question.  This is one of those things
>that would be easy in person but that can be difficult with email.
>I'm not sure it's wise to proceed here (perhaps better to call
>on the telephone?), but let me give it a shot:
>The crux of my question was "including capabilities" in piped
>communication.  In the first piping example that is given for KeyKOS:

The coroutine linkage described above was used to pass capabilities in the
extend jump protocol, which was in a sense piping capabilities.

To try to explain extended jump protocol (ejp):

The basic call invocation passes 4K of data, a 32 bit order code, 3
capabilities, and generates a resume capability. If you have more data or
capabilities to pass, then you can use ejp to pass them all. (There may be
issues with promptness to consider since either side can cause the other to
be permanently busy.)

Using ejp, the caller starts with an order code of KT+5 (indicating ejp),
and sends the first 4K of data and the first 3 capabilities. The receiver
stashes the data and keys away, and calls the generated resume key with an
order code of KT+5 (indicating ejp). The caller next passes the next 4K of
data and the next 3 capabilities. When the caller is passing the last of
the data and capabilities, instead of using an order code of KT+5 it uses
the method-selector order code for the method it is invoking. Ejp may be
used similarly on the return if there is more than 4K of data and or more
than 4 capabilities.

The New Command System would automatically use ejp if there were more than
3 capabilities to be passed.

The "pipe" syntax ("^") would also set up a coroutine linkage between
domains. I don't think these linkages were ever used to pass capabilities,
because the need wasn't obvious. If someone found a need for passing
capabilities between inner domains of a pipe, the basic coroutine protocol
supported it. The command system would only automatically supply data
sources/sinks for the end points.

>list(0,sok6==>) ^ filter(0;sik6,sok6==>) ^ format(0;sik6,sok6==>)
>This command line forks key "list" causing its output (on "sok6") to 
>be passed to key "filter" with a coroutine linkage to "sik6". The 
>output of "filter" is likewise linked to "sik6" of "format". Since 
>"format" is the last key and specifies a "sok6" key a terminal system 
>is built to pass the output of format to the terminal.
>can you describe which of the above are names of capabilities and
>what capabilities pass between the running programs servicing
>those capabilities?  Perhaps I shouldn't anticipate, but it sounds
>like "list", "filter", perhaps "sik6" (reserved word meaning?), and
>"format" name keys == capabilities.  Right so far?  Presumably
>these named capabilities are available in the domain of the script
>interpreter running on behalf of some person typing or otherwise
>having the above characters interpreted and actions taken?

list, filter, and format are the names of capabilities in the user's
namespace. sik6 and sok6 are placeholders for capabilities generated by the
command system, and so are reserved words. (The command system uses a Byte
Stream Creator (<http://www.cap-lore.com/CapTheory/KK/m/133.html#bscr>) to
glue the two domains together. The producer key is give in the slot marked
sik6, and the consumer key is given in the slot marked sok6.

>The above syntax then specifies how some of the capabilities are
>to be invoked and how their output is to be linked to other
>invocations I guess?  Can you describe in the above where
>a capability that is communicated as output from one of the
>invocations that is then considered input by another?  That
>would suffice to answer my question.
>The rest is mostly for my curiosity.
>The User's Guide specifies that sok6 and sik6 are reserved words.  What is
>their meaning?

Simplex Input Key and Simplex Output Key. The levels provide the kind of
functionality you see in the "cooked" interface in *nix.

sik6/sok6 <http://www.cap-lore.com/CapTheory/KK/m/95.html> are built on
sik5/so5 <http://www.cap-lore.com/CapTheory/KK/m/94.html>, which is built
on sik3/sok3. For sik3, see
<http://www.cap-lore.com/CapTheory/KK/m/83.html>. For sok3, see
<http://www.cap-lore.com/CapTheory/KK/m/84.html>. For all the pieces of the
terminal system, see <http://www.cap-lore.com/CapTheory/KK/m/81.html>.

>In the description of "Input/Output Redirection":
>If the first (or only) command of a pipe expression is followed by "< 
>KEYNAME" the data in the object KEYNAME (which must be acceptable to 
>the os simulator {(p3,ossim)} for QSAM simulation) will be converted 
>to a byte stream and passed to the first command as its "standard 
>input" (SIK6) key.
>Similary, if the last (or only) command of a pipe expression is 
>followed by "> KEYNAME" or ">> KEYNAME" then its "standard output" 
>(SOK6) will be respectivly placed in or appended to the object 
>KEYNAME (which must be acceptable to the os simulator {(p3,ossim)} 
>for QSAM simulation). If KEYNAME does not exist in the directory, a 
>fresh segment {(p2,fsc)} will be created to hold the data.
>can you give a brief explanation of what that first parenthetical 
>expression means:
>"(which must be acceptable to the os simulator {(p3,ossim)} for QSAM 

In OS/360, QSAM is the name for the I/O routines that access a sequential
file. Isn't it the standard terminology everywhere? :-)

>What is CS84?

CS84 is another name for the New Command System.

Bill Frantz        | The first thing you need when  | Periwinkle
(408)356-8506      | using a perimeter defense is a | 16345 Englewood Ave
www.pwpconsult.com | perimeter.                     | Los Gatos, CA 95032

More information about the cap-talk mailing list