You could do worse than Mach ports

[Matthew Dillon]

:>  In the quota case,
:>you have to take a pretty heavy-weight view of what constitutes
:>memtadata, as well, since you have to deal with file extends
:>via write, which means you need to peek at the bytecount for
:>payload, and return value in case of success/failure.
:
:OK, either you or I are very confused here.
:
:Matt: could you comment on this?
:
:But these are in the message, not in the data blocks. You have
:access to the message... it was copied into the kernel with the
:Send()... you just need to take a protection barrier transition to
:access any data pointed to by the message.

    The issue comes down to how to deal with foreign address spaces.
    After all, if the address space is local one just passes a pointer.

    For system calls the foreign address space is the user process's
    address space.  User data pointers come in three forms:

    (1) They represent a file path
    (2) They represent a large block of data (e.g. the buffer in a read())
    (3) They represent a small block of data (e.g. gettimeofday()).
    (4) They represent the message itself

    In case 1 I will be rewriting the VFS cache to completely evaluate any
    user path and create the appropriate nodes in the VFS cache tree.  This
    will occur before entry into the VFS layer and, of course, any nodes
    that are not known in the cache will be given an 'UNKNOWN' designation
    and will have to be resolved by VFS (e.g. VFS_LOOKUP()).  VFS_LOOKUP()
    would no longer access userspace path elements directly.  A secondary
    advantage of integrating VFS_LOOKUP() with the VFS cache is that we
    would no longer have to leave directory vnodes locked during the
    traversal, the path would be locked through the VFS cache.

    In case 2 I intend to convert the user data pointer into an IOVEC array
    of VM Object's and offset ranges within those objects.  For example,
    (vnode->object, start_offset_of_read, extent_of_read).  The kernel
    would pass the IOVEC array around just like it passes UIO's around now
    (in fact, we are really talking about UIO's with their guts rearranged
    in this new scheme).  

    Any kernel entity that actually needs to read the data directly will
    have to map the object into its data space.  We might or might not 
    cache such mappings in the UIO just so in a multi-layered VFS system
    where multiple layers need a direct mapping, only one mapping is actually
    made. 

    In case 3 I intend for the syscall to copyin/copyout the data (just like
    it does now).

    In case 4 the kernel currently copies the syscall argments into kernel
    space already (the uap family of structures), and we would do the same
    with the message.  Just think of the message as being the syscall
    arguments themselves.  We need to do this anyway because the kernel
    version of the syscall message is going to be more involved then the
    user version.

					-Matt
					Matthew Dillon 
					<dillon at xxxxxxxxxxxxx>