xref: /onnv-gate/usr/src/uts/common/fs/smbsrv/smb_oplock.c (revision 6600:4e63bcd27ae9)

/*
 * 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
 * or http://www.opensolaris.org/os/licensing.
 * 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 Locking library functions.
 */

#include <smbsrv/smb_incl.h>
#include <smbsrv/smb_fsops.h>

/*
 * Oplock functionality enable/disable
 */

/*
 *	Magic		0xFF 'S' 'M' 'B'
 *	smb_com 	a byte, the "first" command
 *	Error		a 4-byte union, ignored in a request
 *	smb_flg		a one byte set of eight flags
 *	smb_flg2	a two byte set of 16 flags
 *	.		twelve reserved bytes, have a role
 *			in connectionless transports (IPX, UDP?)
 *	smb_tid		a 16-bit tree ID, a mount point sorta,
 *			0xFFFF is this command does not have
 *			or require a tree context
 *	smb_pid		a 16-bit process ID
 *	smb_uid		a 16-bit user ID, specific to this "session"
 *			and mapped to a system (bona-fide) UID
 *	smb_mid		a 16-bit multiplex ID, used to differentiate
 *			multiple simultaneous requests from the same
 *			process (pid) (ref RPC "xid")
 *
 * SMB_COM_LOCKING_ANDX allows both locking and/or unlocking of file range(s).
 *
 *  Client Request                     Description
 *  ================================== =================================
 *
 *  UCHAR WordCount;                   Count of parameter words = 8
 *  UCHAR AndXCommand;                 Secondary (X) command;  0xFF = none
 *  UCHAR AndXReserved;                Reserved (must be 0)
 *  USHORT AndXOffset;                 Offset to next command WordCount
 *  USHORT Fid;                        File handle
 *  UCHAR LockType;                    See LockType table below
 *  UCHAR OplockLevel;                 The new oplock level
 *  ULONG Timeout;                     Milliseconds to wait for unlock
 *  USHORT NumberOfUnlocks;            Num. unlock range structs following
 *  USHORT NumberOfLocks;              Num. lock range structs following
 *  USHORT ByteCount;                  Count of data bytes
 *  LOCKING_ANDX_RANGE Unlocks[];      Unlock ranges
 *  LOCKING_ANDX_RANGE Locks[];        Lock ranges
 *
 *  LockType Flag Name            Value Description
 *  ============================  ===== ================================
 *
 *  LOCKING_ANDX_SHARED_LOCK      0x01  Read-only lock
 *  LOCKING_ANDX_OPLOCK_RELEASE   0x02  Oplock break notification
 *  LOCKING_ANDX_CHANGE_LOCKTYPE  0x04  Change lock type
 *  LOCKING_ANDX_CANCEL_LOCK      0x08  Cancel outstanding request
 *  LOCKING_ANDX_LARGE_FILES      0x10  Large file locking format
 *
 *  LOCKING_ANDX_RANGE Format
 *  =====================================================================
 *
 *  USHORT Pid;                        PID of process "owning" lock
 *  ULONG Offset;                      Offset to bytes to [un]lock
 *  ULONG Length;                      Number of bytes to [un]lock
 *
 *  Large File LOCKING_ANDX_RANGE Format
 *  =====================================================================
 *
 *  USHORT Pid;                        PID of process "owning" lock
 *  USHORT Pad;                        Pad to DWORD align (mbz)
 *  ULONG OffsetHigh;                  Offset to bytes to [un]lock
 *                                      (high)
 *  ULONG OffsetLow;                   Offset to bytes to [un]lock (low)
 *  ULONG LengthHigh;                  Number of bytes to [un]lock
 *                                      (high)
 *  ULONG LengthLow;                   Number of bytes to [un]lock (low)
 *
 *  Server Response                    Description
 *  ================================== =================================
 *
 *  UCHAR WordCount;                   Count of parameter words = 2
 *  UCHAR AndXCommand;                 Secondary (X) command;  0xFF =
 *                                      none
 *  UCHAR AndXReserved;                Reserved (must be 0)
 *  USHORT AndXOffset;                 Offset to next command WordCount
 *  USHORT ByteCount;                  Count of data bytes = 0
 *
 */

/*
 * smb_oplock_acquire
 *
 * Attempt to acquire an oplock. Note that the oplock granted may be
 * none, i.e. the oplock was not granted.
 *
 * Grant an oplock to the requestor if this session is the only one
 * that has the file open, regardless of the number of instances of
 * the file opened by this session.
 *
 * However, if there is no oplock on this file and there is already
 * at least one open, we will not grant an oplock, even if the only
 * existing opens are from the same client.  This is "server discretion."
 *
 * An oplock may need to be broken in order for one to be granted, and
 * depending on what action is taken by the other client (unlock or close),
 * an oplock may or may not be granted.  (The breaking of an oplock is
 * done earlier in the calling path.)
 *
 * XXX: Node synchronization is not yet implemented.  However, racing
 * opens are handled thus:
 *
 * A racing oplock acquire can happen in the open path between
 * smb_oplock_break() and smb_fsop_open(), but no later.  (Once
 * the file is open via smb_fsop_open()/VOP_OPEN,
 * smb_fsop_oplock_install() will not be able to install an oplock,
 * which requires an open count of 1.)
 *
 * Hence, we can safely break any oplock that came in after the
 * smb_oplock_break() done previously in the open path, knowing that
 * no other racing oplock acquisitions should be able to succeed
 * because we already have the file open (see above).
 *
 * The type of oplock being requested is passed in op->my_flags.  The result
 * is also returned in op->my_flags.
 *
 * (Note that exclusive and batch oplocks are treated interchangeably.)
 *
 * The Returns NT status codes:
 *	NT_STATUS_SUCCESS
 *	NT_STATUS_CONNECTION_DISCONNECTED
 */
DWORD
smb_oplock_acquire(
    smb_request_t	*sr,
    smb_ofile_t		*of,
    struct open_param	*op)
{
	smb_node_t		*node;
	unsigned int		level;

	ASSERT(sr);
	ASSERT(of);
	ASSERT(op);
	ASSERT(op->fqi.last_attr.sa_vattr.va_type == VREG);

	level = op->my_flags & MYF_OPLOCK_MASK;

	op->my_flags &= ~MYF_OPLOCK_MASK;

	if ((sr->sr_cfg->skc_oplock_enable == 0) ||
	    (fsd_chkcap(&of->f_tree->t_fsd, FSOLF_DISABLE_OPLOCKS) > 0))
		return (NT_STATUS_SUCCESS);

	if (!((MYF_IS_EXCLUSIVE_OPLOCK(level)) ||
	    (MYF_IS_BATCH_OPLOCK(level))))
		return (NT_STATUS_SUCCESS);

	node = of->f_node;

	smb_rwx_rwenter(&node->n_lock, RW_WRITER);

	if (EXCLUSIVE_OPLOCK_IN_FORCE(node) ||
	    BATCH_OPLOCK_IN_FORCE(node)) {

		smb_rwx_rwexit(&node->n_lock);

		if (SMB_SAME_SESSION(sr->session,
		    node->n_oplock.op_ofile->f_session)) {
			op->my_flags |= level;
			return (NT_STATUS_SUCCESS);
		} else if (SMB_ATTR_ONLY_OPEN(op)) {
			ASSERT(!(op->my_flags & MYF_OPLOCK_MASK));
			return (NT_STATUS_SUCCESS);
		}

		smb_oplock_break(node);

		smb_rwx_rwenter(&node->n_lock, RW_WRITER);
	}

	if (smb_fsop_oplock_install(node, of->f_mode) != 0) {
		smb_rwx_rwexit(&node->n_lock);
		return (NT_STATUS_SUCCESS);
	}

	node->n_oplock.op_ofile = of;
	node->n_oplock.op_ipaddr = sr->session->ipaddr;
	node->n_oplock.op_kid = sr->session->s_kid;
	node->flags &= ~NODE_OPLOCKS_IN_FORCE;

	if (MYF_IS_EXCLUSIVE_OPLOCK(level))
		node->flags |= NODE_EXCLUSIVE_OPLOCK;

	if (MYF_IS_BATCH_OPLOCK(level))
		node->flags |= NODE_BATCH_OPLOCK;

	op->my_flags |= level;

	smb_rwx_rwexit(&node->n_lock);

	return (NT_STATUS_SUCCESS);
}

/*
 * smb_oplock_break
 *
 * The oplock break may succeed for multiple reasons: file close, oplock
 * release, holder connection dropped, requesting client disconnect etc.
 * Whatever the reason, the oplock should be broken when this function
 * returns. The exceptions are when the client making this request gets
 * disconnected or when another client is handling the break and it gets
 * disconnected.
 *
 * Returns NT status codes:
 *	NT_STATUS_SUCCESS                  No oplock in force, i.e. the
 *						oplock has been broken.
 *	NT_STATUS_CONNECTION_DISCONNECTED  Requesting client disconnected.
 *	NT_STATUS_INTERNAL_ERROR
 */

void
smb_oplock_break(smb_node_t *node)
{
	smb_session_t		*oplock_session;
	smb_ofile_t		*oplock_ofile;
	struct mbuf_chain	mbc;
	int			retries = 0;
	clock_t			elapsed_time;
	clock_t			max_time;
	boolean_t		flag;

	smb_rwx_rwenter(&node->n_lock, RW_WRITER);

	if (!OPLOCKS_IN_FORCE(node)) {
		smb_rwx_rwexit(&node->n_lock);
		return;
	}

	if (node->n_oplock.op_flags & OPLOCK_FLAG_BREAKING) {
		elapsed_time = 0;
		max_time = MSEC_TO_TICK(smb_oplock_timeout * OPLOCK_RETRIES);
		/*
		 * Another client is already attempting to break the oplock.
		 * We wait for it to finish. If the caller was trying to
		 * acquire an oplock, he should retry in case the client's
		 * connection was dropped while trying to break the oplock.
		 *
		 * If the holder's connection has been dropped, we yield to
		 * allow the thread handling the break to detect it and set
		 * the flags.
		 */
		while ((node->n_oplock.op_flags & OPLOCK_FLAG_BREAKING) &&
		    (elapsed_time < max_time)) {
			clock_t	timeleft;

			timeleft = smb_rwx_rwwait(&node->n_lock, max_time);
			if (timeleft == -1) {
				elapsed_time = max_time;
			} else {
				elapsed_time += max_time - timeleft;
			}
		}
		/*
		 * If there are no oplocks in force we're done.
		 */
		if (!OPLOCKS_IN_FORCE(node)) {
			smb_rwx_rwexit(&node->n_lock);
			return;
		} else {
			/*
			 * This is an anomalous condition.
			 * Cancel/release the oplock.
			 */
			smb_oplock_release(node, B_TRUE);
			smb_rwx_rwexit(&node->n_lock);
			return;
		}
	}

	oplock_ofile = node->n_oplock.op_ofile;
	ASSERT(oplock_ofile);

	oplock_session = oplock_ofile->f_session;
	ASSERT(oplock_session);

	/*
	 * Start oplock break.
	 */

	node->n_oplock.op_flags |= OPLOCK_FLAG_BREAKING;

	smb_rwx_rwexit(&node->n_lock);

	max_time = MSEC_TO_TICK(smb_oplock_timeout);
	do {
		MBC_INIT(&mbc, MLEN);
		(void) smb_encode_mbc(&mbc, "Mb19.wwwwbb3.ww10.",
		    SMB_COM_LOCKING_ANDX, oplock_ofile->f_tree->t_tid,
		    0xffff, 0, 0xffff, 8, 0xff, oplock_ofile->f_fid,
		    LOCKING_ANDX_OPLOCK_RELEASE);

		flag = B_TRUE;
		smb_rwx_rwenter(&oplock_session->s_lock, RW_WRITER);
		while (flag) {
			switch (oplock_session->s_state) {
			case SMB_SESSION_STATE_DISCONNECTED:
			case SMB_SESSION_STATE_TERMINATED:
				smb_rwx_rwexit(&oplock_session->s_lock);
				smb_rwx_rwenter(&node->n_lock, RW_WRITER);

				node->flags &= ~NODE_OPLOCKS_IN_FORCE;
				node->n_oplock.op_flags &=
				    ~OPLOCK_FLAG_BREAKING;
				node->n_oplock.op_ofile = NULL;
				node->n_oplock.op_ipaddr = 0;
				node->n_oplock.op_kid = 0;

				smb_rwx_rwexit(&node->n_lock);

				return;

			case SMB_SESSION_STATE_OPLOCK_BREAKING:
				flag = B_FALSE;
				break;

			case SMB_SESSION_STATE_NEGOTIATED:
				oplock_session->s_state =
				    SMB_SESSION_STATE_OPLOCK_BREAKING;
				flag = B_FALSE;
				break;

			default:
				(void) smb_rwx_rwwait(&oplock_session->s_lock,
				    -1);
				break;
			}
		}
		smb_rwx_rwexit(&oplock_session->s_lock);

		(void) smb_session_send(oplock_session, 0, &mbc);

		elapsed_time = 0;

		smb_rwx_rwenter(&node->n_lock, RW_WRITER);
		while ((node->n_oplock.op_flags & OPLOCK_FLAG_BREAKING) &&
		    (elapsed_time < max_time)) {
			clock_t	timeleft;

			timeleft = smb_rwx_rwwait(&node->n_lock, max_time);
			if (timeleft == -1) {
				elapsed_time = max_time;
			} else {
				elapsed_time += max_time - timeleft;
			}
		}

		if (!OPLOCKS_IN_FORCE(node)) {
			/*
			 * smb_oplock_release() was called
			 */
			smb_rwx_rwexit(&node->n_lock);
			return;
		}
	} while (++retries < OPLOCK_RETRIES);

	/*
	 * Retries exhausted and timed out.
	 * Cancel the oplock and continue.
	 */

	smb_oplock_release(node, B_TRUE);

	smb_rwx_rwexit(&node->n_lock);
}

/*
 * smb_oplock_release
 *
 * This function uninstalls the FEM oplock monitors and
 * clears all flags in relation to an oplock on the
 * given node.
 *
 * The function can be called with the node->n_lock held
 * or not held.
 */

void /*ARGSUSED*/
smb_oplock_release(smb_node_t *node, boolean_t have_rwx)
{
	if (!have_rwx)
		smb_rwx_rwenter(&node->n_lock, RW_WRITER);

	if (!OPLOCKS_IN_FORCE(node)) {
		if (!have_rwx)
			smb_rwx_rwexit(&node->n_lock);
		return;
	}

	smb_fsop_oplock_uninstall(node);

	node->flags &= ~NODE_OPLOCKS_IN_FORCE;
	node->n_oplock.op_flags &= ~OPLOCK_FLAG_BREAKING;
	node->n_oplock.op_ofile = NULL;
	node->n_oplock.op_ipaddr = 0;
	node->n_oplock.op_kid = 0;

	if (!have_rwx)
		smb_rwx_rwexit(&node->n_lock);
}

/*
 * smb_oplock_conflict
 *
 * The two checks on "session" and "op" are primarily for the open path.
 * Other CIFS functions may call smb_oplock_conflict() with a session
 * pointer so as to do the session check.
 */

boolean_t
smb_oplock_conflict(smb_node_t *node, smb_session_t *session,
    struct open_param *op)
{
	smb_session_t		*oplock_session;
	smb_ofile_t		*oplock_ofile;

	smb_rwx_rwenter(&node->n_lock, RW_READER);

	if (!OPLOCKS_IN_FORCE(node)) {
		smb_rwx_rwexit(&node->n_lock);
		return (B_FALSE);
	}

	oplock_ofile = node->n_oplock.op_ofile;
	ASSERT(oplock_ofile);

	oplock_session = oplock_ofile->f_session;
	ASSERT(oplock_session);

	if (SMB_SAME_SESSION(session, oplock_session)) {
		smb_rwx_rwexit(&node->n_lock);
		return (B_FALSE);
	}

	if (SMB_ATTR_ONLY_OPEN(op)) {
		smb_rwx_rwexit(&node->n_lock);
		return (B_FALSE);
	}

	smb_rwx_rwexit(&node->n_lock);
	return (B_TRUE);
}