nullfs stabilization I

[Matthew Dillon]

:    Although I didn't want do it, from a coding perspective we can make
:    this glue sticky... that is, we can disallow the destruction of 
:    a lower layer namecache record while a higher layer namecache record
:    in the same chain exists.  This would remove the requirement that
:    lower layers do callbacks to upper layers.

    Er.  This is slightly confusing.  What I mean here is that the hard
    part of coding a callback would be removed.  Lower layers would still
    have to be able to invalidate higher layers (i.e. rename performed 
    on the base filesystem), but now they would only have to follow the
    preexisting chain upwards to do so and only deal with elements that
    already exist, so no callback would need to be done.  The namecache
    code would be able to do it internally.

    Also note that the idea of a 'shared locking structure' for the
    shadow chain is very, very close to the fact that all the namecache
    records will share the same vnode.  The difference of course is 
    that the vnode might not always be resolved, hence we cannot embed
    the lock in the vnode and instead need an auxillary structure that
    the namecache records in the chain reference which contains the lock.

    Another note: 'invalidating' a namecache record in DragonFly does not
    involve destroying the structure.  It is simply a matter of setting
    the state in the structure, so we don't get into deadlock trouble
    if other entities have active references to structures at various
    points in the shadow chain.
	
						-Matt