smb_node.c revision 3db3f65c6274eb042354801a308c8e9bc4994553
/*
* 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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* SMB Node State Machine
* ----------------------
*
* +----------------------------+ T0
* | SMB_NODE_STATE_AVAILABLE |<----------- Creation/Allocation
* +----------------------------+
* |
* | T1
* |
* v
* +-----------------------------+ T2
* +-----------------------------+
*
* Transition T0
*
* This transition occurs in smb_node_lookup(). If the node looked for is
* not found in the has table a new node is created. The reference count is
* initialized to 1 and the state initialized to SMB_NODE_STATE_AVAILABLE.
*
* Transition T1
*
* This transition occurs in smb_node_release(). If the reference count
* drops to zero the state is moved to SMB_NODE_STATE_DESTROYING and no more
* reference count will be given out for that node.
*
* Transition T2
*
* This transition occurs in smb_node_release(). The structure is deleted.
*
* Comments
* --------
*
* The reason the smb node has 2 states is the following synchronization
* rule:
*
* There's a mutex embedded in the node used to protect its fields and
* there's a lock embedded in the bucket of the hash table the node belongs
* to. To increment or to decrement the reference count the mutex must be
* entered. To insert the node into the bucket and to remove it from the
* bucket the lock must be entered in RW_WRITER mode. When both (mutex and
* lock) have to be entered, the lock has always to be entered first then
* the mutex. This prevents a deadlock between smb_node_lookup() and
* smb_node_release() from occurring. However, in smb_node_release() when the
* reference count drops to zero and triggers the deletion of the node, the
* mutex has to be released before entering the lock of the bucket (to
* remove the node). This creates a window during which the node that is
* about to be freed could be given out by smb_node_lookup(). To close that
* window the node is moved to the state SMB_NODE_STATE_DESTROYING before
* releasing the mutex. That way, even if smb_node_lookup() finds it, the
* state will indicate that the node should be treated as non existent (of
* protection of the mutex).
*/
#include <smbsrv/smb_incl.h>
#include <smbsrv/smb_fsops.h>
#include <sys/pathname.h>
/*
* smb_node_init
*
* Initialization of the SMB node layer.
*
* This function is not multi-thread safe. The caller must make sure only one
* thread makes the call.
*/
int
smb_node_init(void)
{
int i;
if (smb_node_initialized)
return (0);
for (i = 0; i <= SMBND_HASH_MASK; i++) {
}
return (0);
}
/*
* smb_node_fini
*
* This function is not multi-thread safe. The caller must make sure only one
* thread makes the call.
*/
void
smb_node_fini(void)
{
int i;
if (!smb_node_initialized)
return;
#ifdef DEBUG
for (i = 0; i <= SMBND_HASH_MASK; i++) {
/*
* The following sequence is just intended for sanity check.
* This will have to be modified when the code goes into
* production.
*
* The SMB node hash table should be emtpy at this point. If the
* hash table is not empty a panic will be triggered.
*
* The reason why SMB nodes are still remaining in the hash
* table is problably due to a mismatch between calls to
* smb_node_lookup() and smb_node_release(). You must track that
* down.
*/
}
#endif
for (i = 0; i <= SMBND_HASH_MASK; i++) {
}
}
/*
* smb_node_lookup()
*
* NOTE: This routine should only be called by the file system interface layer,
* and not by SMB.
*
* smb_node_lookup() is called upon successful lookup, mkdir, and create
* (for both non-streams and streams). In each of these cases, a held vnode is
* passed into this routine. If an smb_node already exists for this vnode,
* the vp is released. Otherwise, a new smb_node will be created and the
* reference will be held until the refcnt on the node goes to 0 (see
* smb_node_release()).
*
* A reference is taken on the smb_node whether found in the hash table
* or newly created.
*
* If an smb_node needs to be created, a reference is also taken on the
* dir_snode (if passed in).
*
* See smb_node_release() for details on the release of these references.
*/
/*ARGSUSED*/
struct smb_request *sr,
struct open_param *op,
char *od_name,
{
int error;
/*
* smb_vop_getattr() is called here instead of smb_fsop_getattr(),
* because the node may not yet exist. We also do not want to call
* it with the list lock held.
*/
if (unnamed_node)
/*
* This getattr is performed on behalf of the server
* that's why kcred is used not the user's cred
*/
if (error)
return (NULL);
if (sr) {
/*
* The fsd for a file is that of the tree, even
* if the file resides in a different mountpoint
* under the share.
*/
} else {
/*
* This should be getting executed only for the
* tree's root smb_node.
*/
}
} else {
}
for (;;) {
while (node) {
smb_node_t *, node);
case SMB_NODE_STATE_AVAILABLE:
/* The node was found. */
node);
}
return (node);
/*
* Although the node exists it is about
* to be destroyed. We act as it hasn't
* been found.
*/
break;
default:
/*
* Although the node exists it is in an
* unknown state. We act as it hasn't
* been found.
*/
ASSERT(0);
break;
}
}
}
continue;
}
break;
}
if (op)
if (dir_snode) {
}
if (unnamed_node) {
}
return (node);
}
/*
* smb_stream_node_lookup()
*
* Note: stream_name (the name that will be stored in the "od_name" field
* of a stream's smb_node) is the same as the on-disk name for the stream
* except that it does not have SMB_STREAM_PREFIX prepended.
*/
{
if (xattrdir_node == NULL)
return (NULL);
/*
* The following VN_HOLD is necessary because the caller will VN_RELE
* xattrdirvp in the case of an error. (xattrdir_node has the original
* hold on the vnode, which the smb_node_release() call below will
* release.)
*/
}
(void) smb_node_release(xattrdir_node);
return (snode);
}
/*
* This function should be called whenever a reference is needed on an
* smb_node pointer. The copy of an smb_node pointer from one non-local
* data structure to another requires a reference to be taken on the smb_node
* (unless the usage is localized). Each data structure deallocation routine
* will call smb_node_release() on its smb_node pointers.
*
* In general, an smb_node pointer residing in a structure should never be
* stale. A node pointer may be NULL, however, and care should be taken
* prior to calling smb_node_ref(), which ASSERTs that the pointer is valid.
* Care also needs to be taken with respect to racing deallocations of a
* structure.
*/
void
{
}
/*
* smb_node_lookup() takes a hold on an smb_node, whether found in the
* hash table or newly created. This hold is expected to be released
* in the following manner.
*
* smb_node_lookup() takes an address of an smb_node pointer. This should
* be getting passed down via a lookup (whether path name or component), mkdir,
* create. If the original smb_node pointer resides in a data structure, then
* the deallocation routine for the data structure is responsible for calling
* smb_node_release() on the smb_node pointer. Alternatively,
* smb_node_release() can be called as soon as the smb_node pointer is no longer
* needed. In this case, callers are responsible for setting an embedded
* pointer to NULL if it is known that the last reference is being released.
*
* If the passed-in address of the smb_node pointer belongs to a local variable,
* then the caller with the local variable should call smb_node_release()
* directly.
*
* smb_node_release() itself will call smb_node_release() on a node's dir_snode,
* as smb_node_lookup() takes a hold on dir_snode.
*/
void
{
case SMB_NODE_STATE_AVAILABLE:
/*
* Check if the file was deleted
*/
/* These lists should be empty. */
}
if (node->unnamed_stream_node) {
}
return;
default:
ASSERT(0);
break;
}
}
}
static void
{
int rc = 0;
else
}
if (rc != 0)
}
/*
* smb_node_rename()
*
*/
int
char *to_name)
{
/*
* XXX Need to update attributes?
*/
return (0);
}
int
{
int error;
/*
* Take an explicit hold on rootdir. This goes with the
* corresponding release in smb_node_root_fini()/smb_node_release().
*/
if (error) {
return (error);
}
return (0);
}
/*
* smb_node_get_size
*/
{
return (0);
else
return (size);
}
static int
{
return (-1);
return (1);
/* Seconds are equal compare tv_nsec */
return (-1);
}
/*
* smb_node_set_time
*
* This function will update the time stored in the node and
* set the appropriate flags. If there is nothing to update
* or the node is readonly, the function would return without
* any updates. The update is only in the node level and the
* attribute in the file system will be updated when client
* close the file.
*/
void
{
return;
}
return;
}
if ((what & SMB_AT_CRTIME) &&
crtime) != 0) {
}
if ((what & SMB_AT_MTIME) &&
mtime) != 0) {
}
if ((what & SMB_AT_ATIME) &&
atime) != 0) {
}
/*
* The ctime handling is trickier. It has three scenarios.
* 1. Only ctime need to be set and it is the same as the ctime
* stored in the node. (update not necessary)
* 2. The ctime is the same as the ctime stored in the node but
* is not the only time need to be set. (update required)
* 3. The ctime need to be set and is not the same as the ctime
* stored in the node. (update required)
* Unlike other time setting, the ctime needs to be set even when
* it is the same as the ctime in the node if there are other time
* needs to be set (#2). This will ensure the ctime not being
* updated when other times are being updated in the file system.
*
* Retained file rules:
*
* 1. Don't add SMB_AT_CTIME to node->what by default because the
* request will be rejected by filesystem
* 2. 'what' SMB_AT_CTIME shouldn't be set for retained files, i.e.
* any request for changing ctime on these files should have
* been already rejected
*/
if (what & SMB_AT_CTIME) {
if ((what == SMB_AT_CTIME) &&
ctime) == 0) {
} else {
}
} else {
}
}
{
}
{
}
{
}
{
}
/*
* smb_node_set_dosattr
*
* Parse the specified DOS attributes and, if they have been modified,
* update the node cache. This call should be followed by a
* smb_sync_fsattr() call to write the attribute changes to filesystem.
*/
void
{
}
}
/*
* smb_node_get_dosattr
*
* This function will get dos attribute using the node.
*/
{
}
int
{
int rc = -1;
rc = 0;
}
return (rc);
}
void
{
}
}
/*
* smb_node_open_check
*
* check file sharing rules for current open request
* against all existing opens for a file.
*
* Returns NT_STATUS_SHARING_VIOLATION if there is any
* sharing conflict, otherwise returns NT_STATUS_SUCCESS.
*/
{
while (of) {
switch (status) {
case NT_STATUS_INVALID_HANDLE:
case NT_STATUS_SUCCESS:
break;
default:
return (status);
}
}
return (NT_STATUS_SUCCESS);
}
{
/*
* Intra-CIFS check
*/
while (of) {
switch (status) {
case NT_STATUS_INVALID_HANDLE:
case NT_STATUS_SUCCESS:
break;
default:
return (status);
}
}
/*
* system-wide share check
*/
return (NT_STATUS_SHARING_VIOLATION);
else
return (NT_STATUS_SUCCESS);
}
{
return (NT_STATUS_SUCCESS);
/*
* intra-CIFS check
*/
while (of) {
switch (status) {
case NT_STATUS_INVALID_HANDLE:
case NT_STATUS_SUCCESS:
break;
default:
return (status);
}
}
/*
* system-wide share check
*/
return (NT_STATUS_SHARING_VIOLATION);
else
return (NT_STATUS_SUCCESS);
}
/*
* smb_node_start_crit()
*
* Enter critical region for share reservations.
* See comments above smb_fsop_shrlock().
*/
void
{
}
/*
* smb_node_end_crit()
*
* Exit critical region for share reservations.
*/
void
{
}
int
{
}