nfs4_srv_ns.c revision 27242a7c712b654e22134a70356231efc69c8202
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* A version of VOP_FID that deals with a remote VOP_FID for nfs.
* If vp is an nfs node, nfs4_fid() returns EREMOTE, nfs3_fid() and nfs_fid()
* returns the filehandle of vp as its fid. When nfs uses fid to set the
* exportinfo filehandle template, a remote nfs filehandle would be too big for
* the fid of the exported directory. This routine remaps the value of the
* attribute va_nodeid of vp to be the fid of vp, so that the fid can fit.
*
* We need this fid mainly for setting up NFSv4 server namespace where an
* nfs filesystem is also part of it. Thus, need to be able to setup a pseudo
* exportinfo for an nfs node.
*
* e.g. mount an ufs filesystem on an nfs filesystem, then share the ufs
* filesystem. (like exporting a local disk from a "diskless" client)
*/
int
{
int error;
/*
* XXX nfs4_fid() does nothing and returns EREMOTE.
* XXX nfs3_fid()/nfs_fid() returns nfs filehandle as its fid
* which has a bigger length than local fid.
* NFS_FH4MAXDATA is the size of
* fhandle4_t.fh_xdata[NFS_FH4MAXDATA].
*
* Note: nfs[2,3,4]_fid() only gets called for diskless clients.
*/
if (error)
return (error);
return (0);
}
return (error);
}
/*
* Get an nfsv4 vnode of the given fid from the visible list of an
* nfs filesystem or get the exi_vp if it is the root node.
*/
int
{
struct exp_visible *visp;
int error;
/* check if the given fid is in the visible list */
return (0);
}
}
/* check if the given fid is the same as the exported node */
if (error)
return (error);
return (0);
}
return (ENOENT);
}
/*
* Create a pseudo export entry
*
* This is an export entry that's created as the
* side-effect of a "real" export. As a part of
* a real export, the pathname to the export is
* checked to see if all the directory components
* are accessible via an NFSv4 client, i.e. are
* exported. If tree_climb() finds an unexported
* mountpoint along the path, then it calls this
* function to export it.
*
* This pseudo export differs from a real export
* in restriction on simple. read-only access,
* and the addition of a "visible" list of directories.
* A real export may have a visible list if it is a root of
* a file system and at least one of its subtree resides in
* a different file system is shared.
*
* A visible list is per file system. It resides in the exportinfo
* for the pseudo node (VROOT) and it could reside in a real export
* of a VROOT node.
*/
int
struct exportdata *exdata)
{
struct exportinfo *exi;
struct exportdata *kex;
int error;
char *pseudo;
/*
* Get the vfs id
*/
if (error) {
/*
* If VOP_FID returns ENOSPC then the fid supplied
* is too small. For now we simply return EREMOTE.
*/
return (error);
}
VSW_VOLATILEDEV) ? 1 : 0;
/*
* Build up the template fhandle
*/
/* Set up a generic pathname */
pseudo = "(pseudo)";
/* Transfer the secinfo data from exdata to this new pseudo node */
if (exdata)
/*
* Initialize auth cache lock
*/
/*
* Insert the new entry at the front of the export list
*/
return (0);
}
/*
* Free a list of visible directories
*/
void
{
}
}
/*
* Add a list of visible directories to a pseudo exportfs.
*
* When we export a new directory we need to add a new
* path segment through the pseudofs to reach the new
* directory. This new path is reflected in a list of
* directories added to the "visible" list.
*
* Here there are two lists of visible fids: one hanging off the
* pseudo exportinfo, and the one we want to add. It's possible
* that the two lists share a common path segment
* and have some common directories. We need to combine
* the lists so there's no duplicate entries. Where a common
* path component is found, the vis_count field is bumped.
*
* When the addition is complete, the supplied list is freed.
*/
static void
{
int found;
/*
* If exportinfo doesn't already have a visible
* list just assign the entire supplied list.
*/
return;
}
/*
* The outer loop traverses the supplied list.
*/
/*
* Given an element from the list to be added,
* search the exportinfo visible list looking for a match.
* If a match is found, increment the reference count.
*/
found = 0;
found = 1;
/*
* If the visible struct we want to add
* (vp1) has vis_exported set to 1, then
* the matching visible struct we just found
* must also have it's vis_exported field
* set to 1.
*
* (and a UFS mountpoint), then "export" and
* "home" would each have visible structs in
* the root pseudo exportinfo. The vis_exported
* for home would be 1, and vis_exported for
* export would be 0. Now, if /export was
* also shared, more_visible would find the
* existing visible struct for export, and
* see that vis_exported was 0. The code
* below will set it to 1.
*
* vp1 is from vis list passed in (vis_head)
* vp2 is from vis list on pseudo exportinfo
*/
break;
}
}
/* If not found - add to the end of the list */
if (! found) {
}
}
/*
* Throw away the path list. vis_vp pointers in vis_head list
* are either VN_RELEed or reassigned, and are set to NULL.
* There is no need to VN_RELE in free_visible for this vis_head.
*/
}
/*
* Remove a list of visible directories from the pseudo exportfs.
*
* When we unexport a directory, we have to remove path
* components from the visible list in the pseudo exportfs
* entry. The supplied visible list contains the fids of the path
* to the unexported directory. The visible list of the export
* is checked against this list any matching fids have their
* reference count decremented. If a reference count drops to
* zero, then it means no paths now use this directory, so its
* fid can be removed from the visible list.
*
* When the last path is removed, the visible list will be null.
*/
static void
{
/*
* The outer loop traverses the supplied list.
*/
/*
* Given an element from the list to be removed,
* search the exportinfo list looking for a match.
* If a match is found, decrement the reference
* count and drop the element if the count drops
* to zero.
*/
/*
* Decrement the ref count.
* Remove the entry if it's zero.
*/
else
} else {
/*
* If we're here, then the vp2 will
* remain in the vis list. If the
* vis entry corresponds to the object
* being unshared, then vis_exported
* needs to be set to 0.
*
* vp1 is a node from caller's list
* vp2 is node from exportinfo's list
*
* Only 1 node in the caller's list
* will have vis_exported set to 1,
* and it corresponds to the obj being
* unshared. It should always be the
* last element of the caller's list.
*/
if (vp1->vis_exported &&
vp2->vis_exported) {
vp2->vis_exported = 0;
}
}
break;
}
}
}
}
/*
* This function checks the path to a new export to
* check whether all the pathname components are
* exported. It works by climbing the file tree one
* component at a time via "..", crossing mountpoints
* if necessary until an export entry is found, or the
* system root is reached.
*
* If an unexported mountpoint is found, then
* a new pseudo export is added and the pathname from
* the mountpoint down to the export is added to the
* visible list for the new pseudo export. If an existing
* pseudo export is found, then the pathname is added
* to its visible list.
*
* Note that there's some tests for exportdir.
* The exportinfo entry that's passed as a parameter
* is that of the real export and exportdir is set
* for this case.
*
* Here is an example of a possible setup:
*
* () - a new fs; fs mount point
* EXPORT - a real exported node
* PSEUDO - a pseudo node
* vis - visible list
* f# - security flavor#
* (f#) - security flavor# propagated from its decendents
* "" - covered vnode
*
*
* /
* |
* (a) PSEUDO (f1,f2)
* | vis: b,b,"c","n"
* |
* b
* ---------|------------------
* | |
* (c) EXPORT,f1(f2) (n) PSEUDO (f1,f2)
* | vis: "e","d" | vis: m,m,,p,q,"o"
* | |
* ------------------ -------------------
* | | | | |
* (d) (e) f m EXPORT,f1(f2) p
* EXPORT EXPORT | |
* f1 f2 | |
* | | |
* j (o) EXPORT,f2 q EXPORT f2
*
*/
int
{
int error;
int exportdir;
struct exp_visible *visp;
exportdir = 1;
for (;;) {
if (error)
break;
if (! exportdir) {
/*
* Check if this exportroot is a VROOT dir. If so,
* then attach the pseudonodes. If not, then
* continue .. traversal until we hit a VROOT
* export (pseudo or real).
*/
/*
* Found an export info
*
* Extend the list of visible
* directories whether it's a pseudo
* or a real export.
*/
break; /* and climb no further */
}
}
/*
* If at the root of the filesystem, need
* to traverse across the mountpoint
* and continue the climb on the mounted-on
* filesystem.
*/
if (! exportdir) {
/*
* Found the root directory of a filesystem
* that isn't exported. Need to export
* this as a pseudo export so that an NFS v4
* client can do lookups in it.
*/
if (error)
break;
}
/* at system root */
break;
}
exportdir = 0;
continue;
}
/*
* Do a getattr to obtain the nodeid (inode num)
* for this vnode.
*/
if (error)
break;
/*
* Add this directory fid to visible list
*/
/*
* Now, do a ".." to find parent dir of vp.
*/
error = 0;
}
if (error)
break;
exportdir = 0;
}
return (error);
}
/*
* Walk up the tree looking for pseudo export entries.
*
* If a pseudo export is found, remove the path we've
* climbed from its visible list. If the visible list
* still has entries after the removal, then we can stop.
* If it becomes null, then remove the pseudo export entry
* and carry on up the tree to see if there's any more.
*/
int
{
int error = 0;
int exportdir;
exportdir = 1;
for (;;) {
if (error)
break;
if (! exportdir) {
/*
* We need to use checkexport4() here because it
* doesn't acquire exported_lock and it doesn't
* manipulate exi_count.
*
* Remove directories from the visible
* list that are unique to the path
* for this export. (Only VROOT exportinfos
* have can have visible entries).
*/
/*
* If the visible list has entries
* or if it's a real export, then
* there's no need to keep climbing.
*/
break;
/*
* Otherwise, we have a pseudo export
* with an empty list (no exports below
* it) so we must remove and continue
* the climb to remove its name from
* the parent export.
*/
if (error)
break;
}
}
/*
* If at the root of the filesystem, need
* to traverse across the mountpoint
* and continue the climb on the mounted-on
* filesystem.
*/
/* at system root */
break;
}
exportdir = 0;
continue;
}
/*
* Add this directory fid to path list
*/
/*
* Do a ".." to find parent dir of vp.
*/
error = 0;
}
if (error)
break;
exportdir = 0;
}
return (error);
}
/*
* Traverse backward across mountpoint from the
* root vnode of a filesystem to its mounted-on
* vnode.
*/
vnode_t *
{
for (;;) {
break;
/* lock vfs to prevent unmount of this vfs */
break;
}
/*
* Hold nextvp to prevent unmount. After unlock vfs and
* rele tvp, any number of overlays could be unmounted.
* Putting a hold on vfs_vnodecovered will only allow
* tvp's vfs to be unmounted. Of course if caller placed
* extra hold on vp before calling untraverse, the following
* hold would not be needed. Since prev actions of caller
* are unknown, we need to hold here just to be safe.
*/
}
return (tvp);
}
/*
* Given an exportinfo, climb up to find the exportinfo for the VROOT
* of the filesystem.
*
* e.g. /
* |
* a (VROOT) pseudo-exportinfo
* |
* b
* |
* c #share /a/b/c
* |
* d
*
* where c is in the same filesystem as a.
* So, get_root_export(*exportinfo_for_c) returns exportinfo_for_a
*
* If d is shared, then c will be put into a's visible list.
* Note: visible list is per filesystem and is attached to the
* VROOT exportinfo.
*/
struct exportinfo *
{
int error;
for (;;) {
break;
}
/*
* Now, do a ".." to find parent dir of vp.
*/
if (error) {
break;
}
if (error) {
break;
}
}
return (exi);
}
/*
* Return true if the supplied vnode has a sub-directory exported.
*/
int
{
struct exp_visible *visp;
/*
* An exported root vnode has a sub-dir shared if it has a visible list.
* i.e. if it does not have a visible list, then there is no node in
* this filesystem leads to any other shared node.
*/
/*
* Only the exportinfo of a fs root node may have a visible list.
* Either it is a pseudo root node, or a real exported root node.
*/
return (0);
}
if (!exi->exi_visible)
return (0);
/* Get the fid of the vnode */
return (0);
}
/*
* See if vp is in the visible list of the root node exportinfo.
*/
/*
* If vp is an exported non-root node with only 1 path
* count (for itself), it indicates no sub-dir shared
* using this vp as a path.
*/
break;
return (1);
}
}
return (0);
}
/*
* Returns true if the supplied vnode is visible
* in this export. If vnode is visible, return
* vis_exported in expseudo.
*/
int
{
struct exp_visible *visp;
/*
* First check to see if vp is export root.
*
* A pseudo export root can never be exported
* (it would be a real export then); however,
* it is always visible. If a pseudo root object
* was exported by server admin, then the entire
* pseudo exportinfo (and all visible entries) would
* be destroyed. A pseudo exportinfo only exists
* to provide access to real (descendant) export(s).
*
* Previously, rootdir was special cased here; however,
* the export root special case handles the rootdir
* case also.
*/
*expseudo = 0;
return (1);
}
/*
* Only a PSEUDO node has a visible list or an exported VROOT
* node may have a visible list.
*/
*expseudo = 0;
return (0);
}
/* Get the fid of the vnode */
*expseudo = 0;
return (0);
}
/*
* We can't trust VN_CMP() above because of LOFS.
* Even though VOP_CMP will do the right thing for LOFS
* objects, VN_CMP will short circuit out early when the
* vnode ops ptrs are different. Just in case we're dealing
*
* expseudo is not set because this is not an export
*/
*expseudo = 0;
return (1);
}
/* See if it matches any fid in the visible list */
return (1);
}
}
*expseudo = 0;
return (0);
}
/*
* Returns true if the supplied vnode is the
* directory of an export point.
*/
int
{
struct exp_visible *visp;
/*
* First check to see if vp is the export root
* This check required for the case of lookup ..
* where .. is a V_ROOT vnode and a pseudo exportroot.
* Pseudo export root objects do not have an entry
* in the visible list even though every V_ROOT
* pseudonode is visible. It is safe to compare
* vp here because pseudo_exportfs put a hold on
* it when exi_vp was initialized.
*
* Note: VN_CMP() won't match for LOFS shares, but they're
*/
return (1);
/* Get the fid of the vnode */
return (0);
return (1);
}
/* See if it matches any fid in the visible list */
return (visp->vis_exported);
}
return (0);
}
/*
* Returns true if the supplied inode is visible
* in this export. This function is used by
* readdir which uses inode numbers from the
* directory.
*
* NOTE: this code does not match inode number for ".",
* but it isn't required because NFS4 server rddir
* skips . and .. entries.
*/
int
{
struct exp_visible *visp;
/*
* Only a PSEUDO node has a visible list or an exported VROOT
* node may have a visible list.
*/
*expseudo = 0;
return (0);
}
return (1);
}
*expseudo = 0;
return (0);
}