So once the kernel gets all the information from the
server, kernel gets to work. First of all, it creates
this data structure on behalf of the server, and holds
it internally for itself. So there's a data structure that
is entirely in the kernel, and nobody else has to
see it, [LAUGH] it is only for the kernel to
know all the information that is needed, in order to
make this upcall into the entry point procedure. It also
establishes a buffer, and this is what is called
the A-stack, and this A-stack sizes as A-stack was just
specified by the server as part of this grand communication
to indicate how big this A-stack is got to be.
Because the you kernel has no idea what the relationship
is, is between the, the client and the server. And
so the server is saying, telling the kernel that look,
in order for us to communicate, I need a buffer,
and the size of the buffer is this much. So,
the kernel allocates shared memory, and takes the shared memory
that is allocated, and maps it into the address space
of both the client and the server. So there's the
client's address space. There's the server's address space. So, in
some part of the client address space and the server
address space, need not be exactly matching parts of the
virtual memory space of the client and the server. But somewhere
in the address space of the client and the server,
it maps this A-stack. So essentially, what we have now.
Is shared memory for communication directly between the client and
the server, without mediation of the kernel, because once this
has been setup as shared memory and mapped through the
address space of the server and the client then the
client can write into it, the server can write into
it, client can read from it, server can read from it.
No mediation by the kernel, or in other words, what we
have accomplished is, we are getting the kernel out of the
loop in terms of copying. Client and the server can directly
communicate the arguments and the results back and forth, using this
A-Stack. And that's the reason it's called A-Stack, it stands for
argument stack. It's available for communication between the client and the
server. So now the cla, the kernel is done with all
the work that it has to do in order to set
up this remote procedure call mechanism between the
caller, the client and the callee, which is the
server. And what the kernel is going to do is,
it's going to authenticate the client that you're good to
go. You can make calls on uh,this procedure
foo that is being exported through the main server
by the server, so I let you make calls on this in the future, and what you need
to do every time you want to make a call to S.foo you have to give
me a descriptive which i'm going to call
the binding object B.O stands for the binding
object In the Western world, BO has
a different colloquial connotation. I won't go there.
But here, BO stands for, Binding Object
and it's basically a capability for the client.
To present to the kernel that I am authenticated
in order to make this call into the service
domain to this particular procedure called s.foo. So that's
the idea. So all the work that I have
described to you up until now, is the kernel
mediation that happens in terms of entry point setup,
on the first call from the client. On the
first call from the client, all of this magic
happens in order to set up the communication
buffer between the client and the server and authenticate
client that you can make future calls on
this particular entry point procedure, by providing or presenting
to the kernel this capability which is called
the BO, the binding object. And of course the
important point is that the kernel knows that
this binding object and this procedure descriptor are related.
Or in other words, if the client is
going to present a binding object, the kernel knows from
the binding object What is the proceeded descriptor
that corresponds to the binding object so that it
can find the entry point to call into
the server. So once again, what I want to stress
is the fact that this kernel mediation happens only
one time. On the first call by the client.