/*
* 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 2010 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*
* Copyright (c) 1983,1984,1985,1986,1987,1988,1989 AT&T.
* All rights reserved.
*/
/*
* Node hash implementation initially borrowed from NFS (nfs_subr.c)
* but then heavily modified. It's no longer an array of hash lists,
* but an AVL tree per mount point. More on this below.
*/
#include <sys/sysmacros.h>
#include <netsmb/smb_osdep.h>
#include <netsmb/smb_conn.h>
#include <netsmb/smb_subr.h>
#include <smbfs/smbfs_node.h>
#include <smbfs/smbfs_subr.h>
/*
* The AVL trees (now per-mount) allow finding an smbfs node by its
* full remote path name. It also allows easy traversal of all nodes
* (per mount) AVL tree is used to control access and to synchronize
* lookups, additions, and deletions from that AVL tree.
*
* Previously, this code use a global array of hash chains, each with
* its own rwlock. A few struct members, functions, and comments may
* still refer to a "hash", and those should all now be considered to
* refer to the per-mount AVL tree that replaced the old hash chains.
* (i.e. member smi_hash_lk, function sn_hashfind, etc.)
*
* The smbnode freelist is organized as a doubly linked list with
* a head pointer. Additions and deletions are synchronized via
* a single mutex.
*
* In order to add an smbnode to the free list, it must be linked into
* the mount's AVL tree and the exclusive lock for the AVL must be held.
* If an smbnode is not linked into the AVL tree, then it is destroyed
* because it represents no valuable information that can be reused
* about the file. The exclusive lock for the AVL tree must be held
* in order to prevent a lookup in the AVL tree from finding the
* smbnode and using it and assuming that the smbnode is not on the
* freelist. The lookup in the AVL tree will have the AVL tree lock
* held, either exclusive or shared.
*
* The vnode reference count for each smbnode is not allowed to drop
* below 1. This prevents external entities, such as the VM
* subsystem, from acquiring references to vnodes already on the
* freelist and then trying to place them back on the freelist
* when their reference is released. This means that the when an
* smbnode is looked up in the AVL tree, then either the smbnode
* is removed from the freelist and that reference is tranfered to
* the new reference or the vnode reference count must be incremented
* accordingly. The mutex for the freelist must be held in order to
* accurately test to see if the smbnode is on the freelist or not.
* The AVL tree lock might be held shared and it is possible that
* two different threads may race to remove the smbnode from the
* freelist. This race can be resolved by holding the mutex for the
* freelist. Please note that the mutex for the freelist does not
* need to held if the smbnode is not on the freelist. It can not be
* placed on the freelist due to the requirement that the thread
* putting the smbnode on the freelist must hold the exclusive lock
* for the AVL tree and the thread doing the lookup in the AVL tree
* is holding either a shared or exclusive lock for the AVL tree.
*
* The lock ordering is:
*
* AVL tree lock -> vnode lock
* AVL tree lock -> freelist lock
*/
long nsmbnode = 0;
/*
* Mutex to protect the following variables:
* smbfs_major
* smbfs_minor
*/
int smbfs_major;
int smbfs_minor;
/* See smbfs_node_findcreate() */
/*
* Local functions.
* SN for Smb Node
*/
static void sn_inactive(smbnode_t *);
static void sn_rmhash_locked(smbnode_t *);
static void sn_destroy_node(smbnode_t *);
void smbfs_kmem_reclaim(void *cdrarg);
static smbnode_t *
static smbnode_t *
make_smbnode(smbmntinfo_t *, const char *, int, int *);
/*
* Free the resources associated with an smbnode.
* Note: This is different from smbfs_inactive
*
* NFS: nfs_subr.c:rinactive
*/
static void
{
char *orpath;
int orplen;
/*
* Flush and invalidate all pages (todo)
* Free any held credentials and caches...
* etc. (See NFS code)
*/
}
/*
* Find and optionally create an smbnode for the passed
* mountinfo, directory, separator, and name. If the
* desired smbnode already exists, return a reference.
* If the file attributes pointer is non-null, the node
* is created if necessary and linked into the AVL tree.
*
* Callers that need a node created but don't have the
* real attributes pass smbfs_fattr0 to force creation.
*
* Note: make_smbnode() may upgrade the "hash" lock to exclusive.
*
* NFS: nfs_subr.c:makenfsnode
*/
const char *dirnm,
int dirlen,
const char *name,
int nmlen,
char sep,
{
char *p, *rpath;
int rplen;
int newnode;
/*
* Build the search string, either in tmpbuf or
* in allocated memory if larger than tmpbuf.
*/
if (sep != '\0')
rplen++;
/* use tmpbuf */
rpalloc = 0;
} else {
}
p = rpath;
p += dirlen;
if (sep != '\0')
*p++ = sep;
p += nmlen;
}
/*
* Find or create a node with this path.
*/
else
if (rpalloc)
/*
* Caller is "just looking" (no create)
* so np may or may not be NULL here.
* Either way, we're done.
*/
return (np);
}
/*
* We should have a node, possibly created.
* Do we have (real) attributes to apply?
*/
if (fap == &smbfs_fattr0)
return (np);
/*
* Apply the given attributes to this node,
* dealing with any cache impact, etc.
*/
if (!newnode) {
/*
* Found an existing node.
* Maybe purge caches...
*/
}
/*
* Note NFS sets vp->v_type here, assuming it
* can never change for the life of a node.
* We allow v_type to change, and set it in
* smbfs_attrcache(). Also: mode, uid, gid
*/
return (np);
}
/*
* NFS: nfs_subr.c:rtablehash
* We use smbfs_hash().
*/
/*
* Find or create an smbnode.
* NFS: nfs_subr.c:make_rnode
*/
static smbnode_t *
const char *rpath,
int rplen,
int *newnode)
{
*newnode = 0;
return (np);
}
/* Note: will retake this lock below. */
/*
* see if we can find something on the freelist
*/
np = smbfreelist;
/* start over */
goto start;
}
}
goto start;
}
vn_invalid(vp);
/*
* destroy old locks before bzero'ing and
* recreating the locks below.
*/
/*
* Make sure that if smbnode is recycled then
* VFS count is decremented properly before
* reuse.
*/
} else {
/*
* allocate and initialize a new smbnode
*/
}
/*
* Allocate and copy the rpath we'll need below.
*/
/* Initialize smbnode_t */
/* cv_init(&np->r_commit.c_cv, NULL, CV_DEFAULT, NULL); */
/* Leave attributes "stale." */
#if 0 /* XXX dircache */
/*
* We don't know if it's a directory yet.
* Let the caller do this? XXX
*/
#endif
/* Now fill in the vnode. */
/*
* We entered with mi->smi_hash_lk held (reader).
* Retake it now, (as the writer).
* Will return with it held.
*/
/*
* There is a race condition where someone else
* may alloc the smbnode while no locks are held,
* so check again and recover if found.
*/
/*
* Lost the race. Put the node we were building
* on the free list and return the one we found.
*/
*newnode = 0;
return (tnp);
}
/*
* Hash search identifies nodes by the remote path
* (n_rpath) so fill that in now, before linking
* this node into the node cache (AVL tree).
*/
*newnode = 1;
return (np);
}
/*
* smbfs_addfree
* Put an smbnode on the free list, or destroy it immediately
* if it offers no value were it to be reclaimed later. Also
* destroy immediately when we have too many smbnodes, etc.
*
* Normally called by smbfs_inactive, but also
* called in here during cleanup operations.
*
* NFS: nfs_subr.c:rp_addfree
*/
void
{
/*
* If there are no more references to this smbnode and:
* we have too many smbnodes allocated, or if the node
* is no longer accessible via the AVL tree (!RHASHED),
* or an i/o error occurred while writing to the file,
* or it's part of an unmounted FS, then try to destroy
* it instead of putting it on the smbnode freelist.
*/
(smbnodenew > nsmbnode))) {
/* Try to destroy this node. */
return;
/*
* Will get another call later,
* via smbfs_inactive.
*/
}
}
/*
* Recheck the vnode reference count. We need to
* make sure that another reference has not been
* acquired while we were not holding v_lock. The
* smbnode is not in the smbnode "hash" AVL tree, so
* the only way for a reference to have been acquired
* is for a VOP_PUTPAGE because the smbnode was marked
* with RDIRTY or for a modified page. This vnode
* reference may have been acquired before our call
* to sn_inactive. The i/o may have been completed,
* thus allowing sn_inactive to complete, but the
* reference to the vnode may not have been released
* yet. In any case, the smbnode can not be destroyed
* until the other references to this vnode have been
* released. The other references will take care of
* either destroying the smbnode or placing it on the
* smbnode freelist. If there are no other references,
* then the smbnode may be safely destroyed.
*/
return;
}
return;
}
/*
* Lock the AVL tree and then recheck the reference count
* to ensure that no other threads have acquired a reference
* to indicate that the smbnode should not be placed on the
* freelist. If another reference has been acquired, then
* just release this one and let the other thread complete
* the processing of adding this smbnode to the freelist.
*/
return;
}
/*
* Put this node on the free list.
*/
if (smbfreelist == NULL) {
smbfreelist = np;
} else {
}
}
/*
* Remove an smbnode from the free list.
*
* The caller must be holding smbfreelist_lock and the smbnode
* must be on the freelist.
*
* NFS: nfs_subr.c:rp_rmfree
*/
static void
{
if (np == smbfreelist) {
if (np == smbfreelist)
smbfreelist = NULL;
}
}
/*
* Put an smbnode in the "hash" AVL tree.
*
* The caller must be hold the rwlock as writer.
*
* NFS: nfs_subr.c:rp_addhash
*/
static void
{
}
/*
* Remove an smbnode from the "hash" AVL tree.
*
* The caller must hold the rwlock as writer.
*
* NFS: nfs_subr.c:rp_rmhash_locked
*/
static void
{
}
/*
* Remove an smbnode from the "hash" AVL tree.
*
* The caller must not be holding the rwlock.
*/
void
{
}
/*
* Lookup an smbnode by remote pathname
*
* The caller must be holding the AVL rwlock, either shared or exclusive.
*
* NFS: nfs_subr.c:rfind
*/
static smbnode_t *
const char *rpath,
int rplen,
{
/* See smbfs_node_cmp below. */
return (NULL);
/*
* Found it in the "hash" AVL tree.
* Remove from free list, if necessary.
*/
/*
* If the smbnode is on the freelist,
* then remove it and use that reference
* as the new reference. Otherwise,
* need to increment the reference count.
*/
} else {
}
} else
return (np);
}
static int
{
const smbfs_node_hdr_t *a = va;
const smbfs_node_hdr_t *b = vb;
/*
* Same semantics as strcmp, but does not
* assume the strings are null terminated.
*/
a->hdr_n_rplen : b->hdr_n_rplen;
if (diff < 0)
return (-1);
if (diff > 0)
return (1);
/* they match through clen */
if (b->hdr_n_rplen > clen)
return (-1);
if (a->hdr_n_rplen > clen)
return (1);
return (0);
}
/*
* Setup the "hash" AVL tree used for our node cache.
* See: smbfs_mount, smbfs_destroy_table.
*/
void
{
}
/*
* Invalidate the cached attributes for all nodes "under" the
* passed-in node. Note: the passed-in node is NOT affected by
* this call. This is used both for files under some directory
* after the directory is deleted or renamed, and for extended
* attribute files (named streams) under a plain file after that
* file is renamed or deleted.
*
* Do this by walking the AVL tree starting at the passed in node,
* and continuing while the visited nodes have a path prefix matching
* the entire path of the passed-in node, and a separator just after
* that matching path prefix. Watch out for cases where the AVL tree
* order may not exactly match the order of an FS walk, i.e.
* consider this sequence:
* "foo" (directory)
* "foo bar" (name containing a space)
* The walk needs to skip "foo bar" and keep going until it finds
* something that doesn't match the "foo" name prefix.
*/
void
{
char *rpath;
int rplen;
for (;;) {
break;
break;
break;
}
}
#ifdef SMB_VNODE_DEBUG
#else /* SMB_VNODE_DEBUG */
int smbfs_check_table_debug = 0;
#endif /* SMB_VNODE_DEBUG */
/*
* Return 1 if there is a active vnode belonging to this vfs in the
* smbnode cache.
*
* Several of these checks are done without holding the usual
* locks. This is safe because destroy_smbtable(), smbfs_addfree(),
* etc. will redo the necessary checks before actually destroying
* any smbnodes.
*
* NFS: nfs_subr.c:check_rtable
*
* Debugging changes here relative to NFS.
* Relatively harmless, so left 'em in.
*/
int
{
int busycnt = 0;
continue; /* skip the root */
/* Now the 'busy' checks: */
/* Not on the free list? */
SMBVDEBUG("!r_freef: node=0x%p, rpath=%s\n",
busycnt++;
}
/* Has dirty pages? */
if (vn_has_cached_data(vp) &&
SMBVDEBUG("is dirty: node=0x%p, rpath=%s\n",
busycnt++;
}
/* Other refs? (not reflected in v_count) */
SMBVDEBUG("+r_count: node=0x%p, rpath=%s\n",
busycnt++;
}
if (busycnt && !smbfs_check_table_debug)
break;
}
return (busycnt);
}
/*
* Destroy inactive vnodes from the AVL tree which belong to this
* vfs. It is essential that we destroy all inactive vnodes during a
* forced unmount as well as during a normal unmount.
*
* NFS: nfs_subr.c:destroy_rtable
*
* In here, we're normally destrying all or most of the AVL tree,
* so the natural choice is to use avl_destroy_nodes. However,
* there may be a few busy nodes that should remain in the AVL
* tree when we're done. The solution: use a temporary tree to
* hold the busy nodes until we're done destroying the old tree,
* then copy the temporary tree over the (now emtpy) real tree.
*/
void
{
void *v;
v = NULL;
/*
* Busy node (not on the free list).
* Will keep in the final AVL tree.
*/
} else {
/*
* It's on the free list. Remove and
* arrange for it to be destroyed.
*/
/*
* Last part of sn_rmhash_locked().
* NB: avl_destroy_nodes has already
* removed this from the "hash" AVL.
*/
/*
* Add to the list of nodes to destroy.
* Borrowing avl_child[0] for this list.
*/
}
}
/*
* Replace the (now destroyed) "hash" AVL with the
* temporary AVL, which restores the busy nodes.
*/
/*
* Now destroy the nodes on our temporary list (rlist).
* This call to smbfs_addfree will end up destroying the
* smbnode, but in a safe way with the appropriate set
* of checks done.
*/
}
}
/*
* This routine destroys all the resources associated with the smbnode
* and then the smbnode itself. Note: sn_inactive has been called.
*
* NFS: nfs_subr.c:destroy_rnode
*/
static void
{
vn_invalid(vp);
}
/*
* Flush all vnodes in this (or every) vfs.
* Used by nfs_sync and by nfs_unmount.
*/
/*ARGSUSED*/
void
{
/* Todo: mmap support. */
}
/* access cache */
/* client handles */
/*
* initialize resources that are used by smbfs_subr.c
* this is called from the _init() routine (by the way of smbfs_clntinit())
*
* NFS: nfs_subr.c:nfs_subrinit
*/
int
smbfs_subrinit(void)
{
/*
* Allocate and initialize the smbnode cache
*/
if (nsmbnode <= 0)
sizeof (struct smbnode));
"setting nsmbnode to max value of %ld", nsmbnode_max);
}
/*
*/
/*
* Assign unique major number for all smbfs mounts
*/
"smbfs: init: can't get unique device number");
smbfs_major = 0;
}
smbfs_minor = 0;
return (0);
}
/*
* free smbfs hash table, etc.
* NFS: nfs_subr.c:nfs_subrfini
*/
void
smbfs_subrfini(void)
{
/*
* Destroy the smbnode cache
*/
/*
*/
}
/* rddir_cache ? */
/*
* Support functions for smbfs_kmem_reclaim
*/
static void
smbfs_node_reclaim(void)
{
continue;
}
}
/*
* This call to smbfs_addfree will end up destroying the
* smbnode, but in a safe way with the appropriate set
* of checks done.
*/
}
}
/*
* Called by kmem_cache_alloc ask us if we could
* "Please give back some memory!"
*
* Todo: dump nodes from the free list?
*/
/*ARGSUSED*/
void
{
}
/* nfs failover stuff */
/* nfs_rw_xxx - see smbfs_rwlock.c */