[net-next-2.6.git] / fs / cifs / transport.c

/*
 *   fs/cifs/transport.c
 *
 *   Copyright (C) International Business Machines  Corp., 2002,2005
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *
 *   This library is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU Lesser General Public License as published
 *   by the Free Software Foundation; either version 2.1 of the License, or
 *   (at your option) any later version.
 *
 *   This library is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 *   the GNU Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public License
 *   along with this library; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
 */

#include <linux/fs.h>
#include <linux/list.h>
#include <linux/wait.h>
#include <linux/net.h>
#include <linux/delay.h>
#include <asm/uaccess.h>
#include <asm/processor.h>
#include <linux/mempool.h>
#include "cifspdu.h"
#include "cifsglob.h"
#include "cifsproto.h"
#include "cifs_debug.h"
  
extern mempool_t *cifs_mid_poolp;
extern kmem_cache_t *cifs_oplock_cachep;

static struct mid_q_entry *
AllocMidQEntry(struct smb_hdr *smb_buffer, struct cifsSesInfo *ses)
{
	struct mid_q_entry *temp;

	if (ses == NULL) {
		cERROR(1, ("Null session passed in to AllocMidQEntry"));
		return NULL;
	}
	if (ses->server == NULL) {
		cERROR(1, ("Null TCP session in AllocMidQEntry"));
		return NULL;
	}
	
	temp = (struct mid_q_entry *) mempool_alloc(cifs_mid_poolp,SLAB_KERNEL | SLAB_NOFS);
	if (temp == NULL)
		return temp;
	else {
		memset(temp, 0, sizeof (struct mid_q_entry));
		temp->mid = smb_buffer->Mid;	/* always LE */
		temp->pid = current->pid;
		temp->command = smb_buffer->Command;
		cFYI(1, ("For smb_command %d", temp->command));
		do_gettimeofday(&temp->when_sent);
		temp->ses = ses;
		temp->tsk = current;
	}

	spin_lock(&GlobalMid_Lock);
	list_add_tail(&temp->qhead, &ses->server->pending_mid_q);
	atomic_inc(&midCount);
	temp->midState = MID_REQUEST_ALLOCATED;
	spin_unlock(&GlobalMid_Lock);
	return temp;
}

static void
DeleteMidQEntry(struct mid_q_entry *midEntry)
{
	spin_lock(&GlobalMid_Lock);
	midEntry->midState = MID_FREE;
	list_del(&midEntry->qhead);
	atomic_dec(&midCount);
	spin_unlock(&GlobalMid_Lock);
	if(midEntry->largeBuf)
		cifs_buf_release(midEntry->resp_buf);
	else
		cifs_small_buf_release(midEntry->resp_buf);
	mempool_free(midEntry, cifs_mid_poolp);
}

struct oplock_q_entry *
AllocOplockQEntry(struct inode * pinode, __u16 fid, struct cifsTconInfo * tcon)
{
	struct oplock_q_entry *temp;
	if ((pinode== NULL) || (tcon == NULL)) {
		cERROR(1, ("Null parms passed to AllocOplockQEntry"));
		return NULL;
	}
	temp = (struct oplock_q_entry *) kmem_cache_alloc(cifs_oplock_cachep,
						       SLAB_KERNEL);
	if (temp == NULL)
		return temp;
	else {
		temp->pinode = pinode;
		temp->tcon = tcon;
		temp->netfid = fid;
		spin_lock(&GlobalMid_Lock);
		list_add_tail(&temp->qhead, &GlobalOplock_Q);
		spin_unlock(&GlobalMid_Lock);
	}
	return temp;

}

void DeleteOplockQEntry(struct oplock_q_entry * oplockEntry)
{
	spin_lock(&GlobalMid_Lock); 
    /* should we check if list empty first? */
	list_del(&oplockEntry->qhead);
	spin_unlock(&GlobalMid_Lock);
	kmem_cache_free(cifs_oplock_cachep, oplockEntry);
}

int
smb_send(struct socket *ssocket, struct smb_hdr *smb_buffer,
	 unsigned int smb_buf_length, struct sockaddr *sin)
{
	int rc = 0;
	int i = 0;
	struct msghdr smb_msg;
	struct kvec iov;
	unsigned len = smb_buf_length + 4;

	if(ssocket == NULL)
		return -ENOTSOCK; /* BB eventually add reconnect code here */
	iov.iov_base = smb_buffer;
	iov.iov_len = len;

	smb_msg.msg_name = sin;
	smb_msg.msg_namelen = sizeof (struct sockaddr);
	smb_msg.msg_control = NULL;
	smb_msg.msg_controllen = 0;
	smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL; /* BB add more flags?*/

	/* smb header is converted in header_assemble. bcc and rest of SMB word
	   area, and byte area if necessary, is converted to littleendian in 
	   cifssmb.c and RFC1001 len is converted to bigendian in smb_send 
	   Flags2 is converted in SendReceive */

	smb_buffer->smb_buf_length = cpu_to_be32(smb_buffer->smb_buf_length);
	cFYI(1, ("Sending smb of length %d ", smb_buf_length));
	dump_smb(smb_buffer, len);

	while (len > 0) {
		rc = kernel_sendmsg(ssocket, &smb_msg, &iov, 1, len);
		if ((rc == -ENOSPC) || (rc == -EAGAIN)) {
			i++;
			if(i > 60) {
				cERROR(1,
				   ("sends on sock %p stuck for 30 seconds",
				    ssocket));
				rc = -EAGAIN;
				break;
			}
			msleep(500);
			continue;
		}
		if (rc < 0) 
			break;
		iov.iov_base += rc;
		iov.iov_len -= rc;
		len -= rc;
	}

	if (rc < 0) {
		cERROR(1,("Error %d sending data on socket to server.", rc));
	} else {
		rc = 0;
	}

	return rc;
}

#ifdef CIFS_EXPERIMENTAL
/* BB finish off this function, adding support for writing set of pages as iovec */
/* and also adding support for operations that need to parse the response smb    */

int
smb_sendv(struct socket *ssocket, struct smb_hdr *smb_buffer,
	 unsigned int smb_buf_length, struct kvec * write_vector 
	  /* page list */, struct sockaddr *sin)
{
	int rc = 0;
	int i = 0;
	struct msghdr smb_msg;
	number_of_pages += 1; /* account for SMB header */
	struct kvec * piov  = kmalloc(number_of_pages * sizeof(struct kvec));
	unsigned len = smb_buf_length + 4;

	if(ssocket == NULL)
		return -ENOTSOCK; /* BB eventually add reconnect code here */
	iov.iov_base = smb_buffer;
	iov.iov_len = len;

	smb_msg.msg_name = sin;
	smb_msg.msg_namelen = sizeof (struct sockaddr);
	smb_msg.msg_control = NULL;
	smb_msg.msg_controllen = 0;
	smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL; /* BB add more flags?*/

	/* smb header is converted in header_assemble. bcc and rest of SMB word
	   area, and byte area if necessary, is converted to littleendian in 
	   cifssmb.c and RFC1001 len is converted to bigendian in smb_send 
	   Flags2 is converted in SendReceive */

	smb_buffer->smb_buf_length = cpu_to_be32(smb_buffer->smb_buf_length);
	cFYI(1, ("Sending smb of length %d ", smb_buf_length));
	dump_smb(smb_buffer, len);

	while (len > 0) {
		rc = kernel_sendmsg(ssocket, &smb_msg, &iov, number_of_pages, 
				    len);
		if ((rc == -ENOSPC) || (rc == -EAGAIN)) {
			i++;
			if(i > 60) {
				cERROR(1,
				   ("sends on sock %p stuck for 30 seconds",
				    ssocket));
				rc = -EAGAIN;
				break;
			}
			msleep(500);
			continue;
		}
		if (rc < 0) 
			break;
		iov.iov_base += rc;
		iov.iov_len -= rc;
		len -= rc;
	}

	if (rc < 0) {
		cERROR(1,("Error %d sending data on socket to server.", rc));
	} else {
		rc = 0;
	}

	return rc;
}


int
CIFSSendRcv(const unsigned int xid, struct cifsSesInfo *ses,
	    struct smb_hdr *in_buf, struct kvec * write_vector /* page list */, int *pbytes_returned, const int long_op)
{
	int rc = 0;
	unsigned long timeout = 15 * HZ;
	struct mid_q_entry *midQ = NULL;

	if (ses == NULL) {
		cERROR(1,("Null smb session"));
		return -EIO;
	}
	if(ses->server == NULL) {
		cERROR(1,("Null tcp session"));
		return -EIO;
	}
	if(pbytes_returned == NULL)
		return -EIO;
	else
		*pbytes_returned = 0;

  
	/* Ensure that we do not send more than 50 overlapping requests 
	   to the same server. We may make this configurable later or
	   use ses->maxReq */
	if(long_op == -1) {
		/* oplock breaks must not be held up */
		atomic_inc(&ses->server->inFlight);
	} else {
		spin_lock(&GlobalMid_Lock); 
		while(1) {        
			if(atomic_read(&ses->server->inFlight) >= cifs_max_pending){
				spin_unlock(&GlobalMid_Lock);
				wait_event(ses->server->request_q,
					atomic_read(&ses->server->inFlight)
					 < cifs_max_pending);
				spin_lock(&GlobalMid_Lock);
			} else {
				if(ses->server->tcpStatus == CifsExiting) {
					spin_unlock(&GlobalMid_Lock);
					return -ENOENT;
				}

			/* can not count locking commands against total since
			   they are allowed to block on server */
					
				if(long_op < 3) {
				/* update # of requests on the wire to server */
					atomic_inc(&ses->server->inFlight);
				}
				spin_unlock(&GlobalMid_Lock);
				break;
			}
		}
	}
	/* make sure that we sign in the same order that we send on this socket 
	   and avoid races inside tcp sendmsg code that could cause corruption
	   of smb data */

	down(&ses->server->tcpSem); 

	if (ses->server->tcpStatus == CifsExiting) {
		rc = -ENOENT;
		goto cifs_out_label;
	} else if (ses->server->tcpStatus == CifsNeedReconnect) {
		cFYI(1,("tcp session dead - return to caller to retry"));
		rc = -EAGAIN;
		goto cifs_out_label;
	} else if (ses->status != CifsGood) {
		/* check if SMB session is bad because we are setting it up */
		if((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) && 
			(in_buf->Command != SMB_COM_NEGOTIATE)) {
			rc = -EAGAIN;
			goto cifs_out_label;
		} /* else ok - we are setting up session */
	}
	midQ = AllocMidQEntry(in_buf, ses);
	if (midQ == NULL) {
		up(&ses->server->tcpSem);
		/* If not lock req, update # of requests on wire to server */
		if(long_op < 3) {
			atomic_dec(&ses->server->inFlight); 
			wake_up(&ses->server->request_q);
		}
		return -ENOMEM;
	}

	if (in_buf->smb_buf_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
		up(&ses->server->tcpSem);
		cERROR(1,
		       ("Illegal length, greater than maximum frame, %d ",
			in_buf->smb_buf_length));
		DeleteMidQEntry(midQ);
		/* If not lock req, update # of requests on wire to server */
		if(long_op < 3) {
			atomic_dec(&ses->server->inFlight); 
			wake_up(&ses->server->request_q);
		}
		return -EIO;
	}

	/* BB can we sign efficiently in this path? */
	rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);

	midQ->midState = MID_REQUEST_SUBMITTED;
/*	rc = smb_sendv(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
		       piovec, 
		       (struct sockaddr *) &(ses->server->addr.sockAddr));*/
	if(rc < 0) {
		DeleteMidQEntry(midQ);
		up(&ses->server->tcpSem);
		/* If not lock req, update # of requests on wire to server */
		if(long_op < 3) {
			atomic_dec(&ses->server->inFlight); 
			wake_up(&ses->server->request_q);
		}
		return rc;
	} else
		up(&ses->server->tcpSem);
cifs_out_label:
	if(midQ)
	        DeleteMidQEntry(midQ);
                                                                                                                           
	if(long_op < 3) {
		atomic_dec(&ses->server->inFlight);
		wake_up(&ses->server->request_q);
	}

	return rc;
}


#endif /* CIFS_EXPERIMENTAL */

int
SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
	    struct smb_hdr *in_buf, struct smb_hdr *out_buf,
	    int *pbytes_returned, const int long_op)
{
	int rc = 0;
	unsigned int receive_len;
	unsigned long timeout;
	struct mid_q_entry *midQ;

	if (ses == NULL) {
		cERROR(1,("Null smb session"));
		return -EIO;
	}
	if(ses->server == NULL) {
		cERROR(1,("Null tcp session"));
		return -EIO;
	}

	/* Ensure that we do not send more than 50 overlapping requests 
	   to the same server. We may make this configurable later or
	   use ses->maxReq */
	if(long_op == -1) {
		/* oplock breaks must not be held up */
		atomic_inc(&ses->server->inFlight);
	} else {
		spin_lock(&GlobalMid_Lock); 
		while(1) {        
			if(atomic_read(&ses->server->inFlight) >= 
					cifs_max_pending){
				spin_unlock(&GlobalMid_Lock);
				wait_event(ses->server->request_q,
					atomic_read(&ses->server->inFlight)
					 < cifs_max_pending);
				spin_lock(&GlobalMid_Lock);
			} else {
				if(ses->server->tcpStatus == CifsExiting) {
					spin_unlock(&GlobalMid_Lock);
					return -ENOENT;
				}

			/* can not count locking commands against total since
			   they are allowed to block on server */
					
				if(long_op < 3) {
				/* update # of requests on the wire to server */
					atomic_inc(&ses->server->inFlight);
				}
				spin_unlock(&GlobalMid_Lock);
				break;
			}
		}
	}
	/* make sure that we sign in the same order that we send on this socket 
	   and avoid races inside tcp sendmsg code that could cause corruption
	   of smb data */

	down(&ses->server->tcpSem); 

	if (ses->server->tcpStatus == CifsExiting) {
		rc = -ENOENT;
		goto out_unlock;
	} else if (ses->server->tcpStatus == CifsNeedReconnect) {
		cFYI(1,("tcp session dead - return to caller to retry"));
		rc = -EAGAIN;
		goto out_unlock;
	} else if (ses->status != CifsGood) {
		/* check if SMB session is bad because we are setting it up */
		if((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) && 
			(in_buf->Command != SMB_COM_NEGOTIATE)) {
			rc = -EAGAIN;
			goto out_unlock;
		} /* else ok - we are setting up session */
	}
	midQ = AllocMidQEntry(in_buf, ses);
	if (midQ == NULL) {
		up(&ses->server->tcpSem);
		/* If not lock req, update # of requests on wire to server */
		if(long_op < 3) {
			atomic_dec(&ses->server->inFlight); 
			wake_up(&ses->server->request_q);
		}
		return -ENOMEM;
	}

	if (in_buf->smb_buf_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
		up(&ses->server->tcpSem);
		cERROR(1,
		       ("Illegal length, greater than maximum frame, %d ",
			in_buf->smb_buf_length));
		DeleteMidQEntry(midQ);
		/* If not lock req, update # of requests on wire to server */
		if(long_op < 3) {
			atomic_dec(&ses->server->inFlight); 
			wake_up(&ses->server->request_q);
		}
		return -EIO;
	}

	rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);

	midQ->midState = MID_REQUEST_SUBMITTED;
	rc = smb_send(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
		      (struct sockaddr *) &(ses->server->addr.sockAddr));
	if(rc < 0) {
		DeleteMidQEntry(midQ);
		up(&ses->server->tcpSem);
		/* If not lock req, update # of requests on wire to server */
		if(long_op < 3) {
			atomic_dec(&ses->server->inFlight); 
			wake_up(&ses->server->request_q);
		}
		return rc;
	} else
		up(&ses->server->tcpSem);
	if (long_op == -1)
		goto cifs_no_response_exit;
	else if (long_op == 2) /* writes past end of file can take loong time */
		timeout = 300 * HZ;
	else if (long_op == 1)
		timeout = 45 * HZ; /* should be greater than 
			servers oplock break timeout (about 43 seconds) */
	else if (long_op > 2) {
		timeout = MAX_SCHEDULE_TIMEOUT;
	} else
		timeout = 15 * HZ;
	/* wait for 15 seconds or until woken up due to response arriving or 
	   due to last connection to this server being unmounted */
	if (signal_pending(current)) {
		/* if signal pending do not hold up user for full smb timeout
		but we still give response a change to complete */
		timeout = 2 * HZ;
	}   

	/* No user interrupts in wait - wreaks havoc with performance */
	if(timeout != MAX_SCHEDULE_TIMEOUT) {
		timeout += jiffies;
		wait_event(ses->server->response_q,
			(!(midQ->midState & MID_REQUEST_SUBMITTED)) || 
			time_after(jiffies, timeout) || 
			((ses->server->tcpStatus != CifsGood) &&
			 (ses->server->tcpStatus != CifsNew)));
	} else {
		wait_event(ses->server->response_q,
			(!(midQ->midState & MID_REQUEST_SUBMITTED)) || 
			((ses->server->tcpStatus != CifsGood) &&
			 (ses->server->tcpStatus != CifsNew)));
	}

	spin_lock(&GlobalMid_Lock);
	if (midQ->resp_buf) {
		spin_unlock(&GlobalMid_Lock);
		receive_len = be32_to_cpu(*(__be32 *)midQ->resp_buf);
	} else {
		cERROR(1,("No response buffer"));
		if(midQ->midState == MID_REQUEST_SUBMITTED) {
			if(ses->server->tcpStatus == CifsExiting)
				rc = -EHOSTDOWN;
			else {
				ses->server->tcpStatus = CifsNeedReconnect;
				midQ->midState = MID_RETRY_NEEDED;
			}
		}

		if (rc != -EHOSTDOWN) {
			if(midQ->midState == MID_RETRY_NEEDED) {
				rc = -EAGAIN;
				cFYI(1,("marking request for retry"));
			} else {
				rc = -EIO;
			}
		}
		spin_unlock(&GlobalMid_Lock);
		DeleteMidQEntry(midQ);
		/* If not lock req, update # of requests on wire to server */
		if(long_op < 3) {
			atomic_dec(&ses->server->inFlight); 
			wake_up(&ses->server->request_q);
		}
		return rc;
	}
  
	if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
		cERROR(1, ("Frame too large received.  Length: %d  Xid: %d",
			receive_len, xid));
		rc = -EIO;
	} else {		/* rcvd frame is ok */

		if (midQ->resp_buf && out_buf
		    && (midQ->midState == MID_RESPONSE_RECEIVED)) {
			out_buf->smb_buf_length = receive_len;
			memcpy((char *)out_buf + 4,
			       (char *)midQ->resp_buf + 4,
			       receive_len);

			dump_smb(out_buf, 92);
			/* convert the length into a more usable form */
			if((receive_len > 24) &&
			   (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
					SECMODE_SIGN_ENABLED))) {
				rc = cifs_verify_signature(out_buf,
						ses->server->mac_signing_key,
						midQ->sequence_number+1);
				if(rc) {
					cERROR(1,("Unexpected SMB signature"));
					/* BB FIXME add code to kill session */
				}
			}

			*pbytes_returned = out_buf->smb_buf_length;

			/* BB special case reconnect tid and uid here? */
			rc = map_smb_to_linux_error(out_buf);

			/* convert ByteCount if necessary */
			if (receive_len >=
			    sizeof (struct smb_hdr) -
			    4 /* do not count RFC1001 header */  +
			    (2 * out_buf->WordCount) + 2 /* bcc */ )
				BCC(out_buf) = le16_to_cpu(BCC(out_buf));
		} else {
			rc = -EIO;
			cFYI(1,("Bad MID state? "));
		}
	}
cifs_no_response_exit:
	DeleteMidQEntry(midQ);

	if(long_op < 3) {
		atomic_dec(&ses->server->inFlight); 
		wake_up(&ses->server->request_q);
	}

	return rc;

out_unlock:
	up(&ses->server->tcpSem);
	/* If not lock req, update # of requests on wire to server */
	if(long_op < 3) {
		atomic_dec(&ses->server->inFlight); 
		wake_up(&ses->server->request_q);
	}

	return rc;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* fs/cifs/transport.c
	3	*
b8643e1b	4	* Copyright (C) International Business Machines Corp., 2002,2005
1da177e4 LT	5	* Author(s): Steve French (sfrench@us.ibm.com)
	6	*
	7	* This library is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU Lesser General Public License as published
	9	* by the Free Software Foundation; either version 2.1 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This library is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
	15	* the GNU Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public License
	18	* along with this library; if not, write to the Free Software
	19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	20	*/
	21
	22	#include <linux/fs.h>
	23	#include <linux/list.h>
	24	#include <linux/wait.h>
	25	#include <linux/net.h>
	26	#include <linux/delay.h>
	27	#include <asm/uaccess.h>
	28	#include <asm/processor.h>
	29	#include <linux/mempool.h>
	30	#include "cifspdu.h"
	31	#include "cifsglob.h"
	32	#include "cifsproto.h"
	33	#include "cifs_debug.h"
	34
	35	extern mempool_t *cifs_mid_poolp;
	36	extern kmem_cache_t *cifs_oplock_cachep;
	37
	38	static struct mid_q_entry *
	39	AllocMidQEntry(struct smb_hdr smb_buffer, struct cifsSesInfo ses)
	40	{
	41	struct mid_q_entry *temp;
	42
	43	if (ses == NULL) {
275cde1a	44	cERROR(1, ("Null session passed in to AllocMidQEntry"));
1da177e4 LT	45	return NULL;
	46	}
	47	if (ses->server == NULL) {
	48	cERROR(1, ("Null TCP session in AllocMidQEntry"));
	49	return NULL;
	50	}
	51
	52	temp = (struct mid_q_entry *) mempool_alloc(cifs_mid_poolp,SLAB_KERNEL \| SLAB_NOFS);
	53	if (temp == NULL)
	54	return temp;
	55	else {
	56	memset(temp, 0, sizeof (struct mid_q_entry));
	57	temp->mid = smb_buffer->Mid; /* always LE */
	58	temp->pid = current->pid;
	59	temp->command = smb_buffer->Command;
	60	cFYI(1, ("For smb_command %d", temp->command));
	61	do_gettimeofday(&temp->when_sent);
	62	temp->ses = ses;
	63	temp->tsk = current;
	64	}
	65
	66	spin_lock(&GlobalMid_Lock);
	67	list_add_tail(&temp->qhead, &ses->server->pending_mid_q);
	68	atomic_inc(&midCount);
	69	temp->midState = MID_REQUEST_ALLOCATED;
	70	spin_unlock(&GlobalMid_Lock);
	71	return temp;
	72	}
	73
	74	static void
	75	DeleteMidQEntry(struct mid_q_entry *midEntry)
	76	{
	77	spin_lock(&GlobalMid_Lock);
	78	midEntry->midState = MID_FREE;
	79	list_del(&midEntry->qhead);
	80	atomic_dec(&midCount);
	81	spin_unlock(&GlobalMid_Lock);
b8643e1b SF	82	if(midEntry->largeBuf)
	83	cifs_buf_release(midEntry->resp_buf);
	84	else
	85	cifs_small_buf_release(midEntry->resp_buf);
1da177e4 LT	86	mempool_free(midEntry, cifs_mid_poolp);
	87	}
	88
	89	struct oplock_q_entry *
	90	AllocOplockQEntry(struct inode * pinode, __u16 fid, struct cifsTconInfo * tcon)
	91	{
	92	struct oplock_q_entry *temp;
	93	if ((pinode== NULL) \|\| (tcon == NULL)) {
	94	cERROR(1, ("Null parms passed to AllocOplockQEntry"));
	95	return NULL;
	96	}
	97	temp = (struct oplock_q_entry *) kmem_cache_alloc(cifs_oplock_cachep,
	98	SLAB_KERNEL);
	99	if (temp == NULL)
	100	return temp;
	101	else {
	102	temp->pinode = pinode;
	103	temp->tcon = tcon;
	104	temp->netfid = fid;
	105	spin_lock(&GlobalMid_Lock);
	106	list_add_tail(&temp->qhead, &GlobalOplock_Q);
	107	spin_unlock(&GlobalMid_Lock);
	108	}
	109	return temp;
	110
	111	}
	112
	113	void DeleteOplockQEntry(struct oplock_q_entry * oplockEntry)
	114	{
	115	spin_lock(&GlobalMid_Lock);
	116	/* should we check if list empty first? */
	117	list_del(&oplockEntry->qhead);
	118	spin_unlock(&GlobalMid_Lock);
	119	kmem_cache_free(cifs_oplock_cachep, oplockEntry);
	120	}
	121
	122	int
	123	smb_send(struct socket ssocket, struct smb_hdr smb_buffer,
	124	unsigned int smb_buf_length, struct sockaddr *sin)
	125	{
	126	int rc = 0;
	127	int i = 0;
	128	struct msghdr smb_msg;
	129	struct kvec iov;
	130	unsigned len = smb_buf_length + 4;
	131
	132	if(ssocket == NULL)
	133	return -ENOTSOCK; /* BB eventually add reconnect code here */
	134	iov.iov_base = smb_buffer;
	135	iov.iov_len = len;
	136
	137	smb_msg.msg_name = sin;
	138	smb_msg.msg_namelen = sizeof (struct sockaddr);
	139	smb_msg.msg_control = NULL;
	140	smb_msg.msg_controllen = 0;
	141	smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL; /* BB add more flags?*/
	142
	143	/* smb header is converted in header_assemble. bcc and rest of SMB word
	144	area, and byte area if necessary, is converted to littleendian in
	145	cifssmb.c and RFC1001 len is converted to bigendian in smb_send
	146	Flags2 is converted in SendReceive */
	147
	148	smb_buffer->smb_buf_length = cpu_to_be32(smb_buffer->smb_buf_length);
	149	cFYI(1, ("Sending smb of length %d ", smb_buf_length));
150	dump_smb(smb_buffer, len);
151
152	while (len > 0) {
153	rc = kernel_sendmsg(ssocket, &smb_msg, &iov, 1, len);
154	if ((rc == -ENOSPC) \|\| (rc == -EAGAIN)) {
155	i++;
156	if(i > 60) {
157	cERROR(1,
158	("sends on sock %p stuck for 30 seconds",
159	ssocket));
160	rc = -EAGAIN;
161	break;
162	}
163	msleep(500);
164	continue;
165	}
166	if (rc < 0)
167	break;
168	iov.iov_base += rc;
169	iov.iov_len -= rc;
170	len -= rc;
171	}
172
173	if (rc < 0) {
174	cERROR(1,("Error %d sending data on socket to server.", rc));
175	} else {
176	rc = 0;
177	}
178
179	return rc;
180	}
181
182	#ifdef CIFS_EXPERIMENTAL
183	/* BB finish off this function, adding support for writing set of pages as iovec */
184	/* and also adding support for operations that need to parse the response smb */
185
186	int
187	smb_sendv(struct socket ssocket, struct smb_hdr smb_buffer,
275cde1a SF	188	unsigned int smb_buf_length, struct kvec * write_vector
275cde1a SF	189	/* page list /, struct sockaddr sin)
1da177e4 LT	190	{
	191	int rc = 0;
	192	int i = 0;
	193	struct msghdr smb_msg;
	194	number_of_pages += 1; /* account for SMB header */
	195	struct kvec * piov = kmalloc(number_of_pages * sizeof(struct kvec));
1da177e4 LT	196	unsigned len = smb_buf_length + 4;
	197
	198	if(ssocket == NULL)
	199	return -ENOTSOCK; /* BB eventually add reconnect code here */
	200	iov.iov_base = smb_buffer;
	201	iov.iov_len = len;
	202
	203	smb_msg.msg_name = sin;
	204	smb_msg.msg_namelen = sizeof (struct sockaddr);
	205	smb_msg.msg_control = NULL;
	206	smb_msg.msg_controllen = 0;
	207	smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL; /* BB add more flags?*/
	208
	209	/* smb header is converted in header_assemble. bcc and rest of SMB word
	210	area, and byte area if necessary, is converted to littleendian in
	211	cifssmb.c and RFC1001 len is converted to bigendian in smb_send
	212	Flags2 is converted in SendReceive */
	213
	214	smb_buffer->smb_buf_length = cpu_to_be32(smb_buffer->smb_buf_length);
	215	cFYI(1, ("Sending smb of length %d ", smb_buf_length));
	216	dump_smb(smb_buffer, len);
	217
	218	while (len > 0) {
275cde1a SF	219	rc = kernel_sendmsg(ssocket, &smb_msg, &iov, number_of_pages,
275cde1a SF	220	len);
1da177e4 LT	221	if ((rc == -ENOSPC) \|\| (rc == -EAGAIN)) {
	222	i++;
	223	if(i > 60) {
	224	cERROR(1,
	225	("sends on sock %p stuck for 30 seconds",
	226	ssocket));
	227	rc = -EAGAIN;
	228	break;
	229	}
	230	msleep(500);
	231	continue;
	232	}
	233	if (rc < 0)
	234	break;
	235	iov.iov_base += rc;
	236	iov.iov_len -= rc;
	237	len -= rc;
	238	}
	239
	240	if (rc < 0) {
	241	cERROR(1,("Error %d sending data on socket to server.", rc));
	242	} else {
	243	rc = 0;
	244	}
	245
	246	return rc;
	247	}
	248
	249
	250	int
	251	CIFSSendRcv(const unsigned int xid, struct cifsSesInfo *ses,
	252	struct smb_hdr in_buf, struct kvec write_vector /* page list /, int pbytes_returned, const int long_op)
	253	{
	254	int rc = 0;
	255	unsigned long timeout = 15 * HZ;
	256	struct mid_q_entry *midQ = NULL;
	257
	258	if (ses == NULL) {
	259	cERROR(1,("Null smb session"));
	260	return -EIO;
	261	}
	262	if(ses->server == NULL) {
	263	cERROR(1,("Null tcp session"));
	264	return -EIO;
	265	}
	266	if(pbytes_returned == NULL)
	267	return -EIO;
	268	else
	269	*pbytes_returned = 0;
	270
	271
	272
	273	/* Ensure that we do not send more than 50 overlapping requests
	274	to the same server. We may make this configurable later or
	275	use ses->maxReq */
	276	if(long_op == -1) {
	277	/* oplock breaks must not be held up */
	278	atomic_inc(&ses->server->inFlight);
	279	} else {
	280	spin_lock(&GlobalMid_Lock);
	281	while(1) {
	282	if(atomic_read(&ses->server->inFlight) >= cifs_max_pending){
	283	spin_unlock(&GlobalMid_Lock);
	284	wait_event(ses->server->request_q,
285	atomic_read(&ses->server->inFlight)
286	< cifs_max_pending);
287	spin_lock(&GlobalMid_Lock);
288	} else {
289	if(ses->server->tcpStatus == CifsExiting) {
290	spin_unlock(&GlobalMid_Lock);
291	return -ENOENT;
292	}
293
294	/* can not count locking commands against total since
295	they are allowed to block on server */
296
297	if(long_op < 3) {
298	/* update # of requests on the wire to server */
299	atomic_inc(&ses->server->inFlight);
300	}
301	spin_unlock(&GlobalMid_Lock);
302	break;
303	}
304	}
305	}
306	/* make sure that we sign in the same order that we send on this socket
307	and avoid races inside tcp sendmsg code that could cause corruption
308	of smb data */
309
310	down(&ses->server->tcpSem);
311
312	if (ses->server->tcpStatus == CifsExiting) {
313	rc = -ENOENT;
314	goto cifs_out_label;
315	} else if (ses->server->tcpStatus == CifsNeedReconnect) {
316	cFYI(1,("tcp session dead - return to caller to retry"));
317	rc = -EAGAIN;
318	goto cifs_out_label;
319	} else if (ses->status != CifsGood) {
320	/* check if SMB session is bad because we are setting it up */
321	if((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
322	(in_buf->Command != SMB_COM_NEGOTIATE)) {
323	rc = -EAGAIN;
324	goto cifs_out_label;
325	} /* else ok - we are setting up session */
326	}
327	midQ = AllocMidQEntry(in_buf, ses);
328	if (midQ == NULL) {
329	up(&ses->server->tcpSem);
330	/* If not lock req, update # of requests on wire to server */
331	if(long_op < 3) {
332	atomic_dec(&ses->server->inFlight);
333	wake_up(&ses->server->request_q);
334	}
335	return -ENOMEM;
336	}
337
338	if (in_buf->smb_buf_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
339	up(&ses->server->tcpSem);
340	cERROR(1,
341	("Illegal length, greater than maximum frame, %d ",
342	in_buf->smb_buf_length));
343	DeleteMidQEntry(midQ);
344	/* If not lock req, update # of requests on wire to server */
345	if(long_op < 3) {
346	atomic_dec(&ses->server->inFlight);
347	wake_up(&ses->server->request_q);
348	}
349	return -EIO;
350	}
351
352	/* BB can we sign efficiently in this path? */
ad009ac9	353	rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
1da177e4 LT	354
1da177e4 LT	355	midQ->midState = MID_REQUEST_SUBMITTED;
275cde1a SF	356	/* rc = smb_sendv(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
	357	piovec,
	358	(struct sockaddr ) &(ses->server->addr.sockAddr));/
1da177e4 LT	359	if(rc < 0) {
	360	DeleteMidQEntry(midQ);
	361	up(&ses->server->tcpSem);
	362	/* If not lock req, update # of requests on wire to server */
	363	if(long_op < 3) {
	364	atomic_dec(&ses->server->inFlight);
	365	wake_up(&ses->server->request_q);
	366	}
	367	return rc;
	368	} else
	369	up(&ses->server->tcpSem);
	370	cifs_out_label:
	371	if(midQ)
	372	DeleteMidQEntry(midQ);
	373
	374	if(long_op < 3) {
	375	atomic_dec(&ses->server->inFlight);
	376	wake_up(&ses->server->request_q);
	377	}
	378
	379	return rc;
	380	}
	381
	382
	383	#endif /* CIFS_EXPERIMENTAL */
	384
	385	int
	386	SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
	387	struct smb_hdr in_buf, struct smb_hdr out_buf,
	388	int *pbytes_returned, const int long_op)
	389	{
	390	int rc = 0;
	391	unsigned int receive_len;
	392	unsigned long timeout;
	393	struct mid_q_entry *midQ;
	394
	395	if (ses == NULL) {
	396	cERROR(1,("Null smb session"));
	397	return -EIO;
	398	}
	399	if(ses->server == NULL) {
	400	cERROR(1,("Null tcp session"));
	401	return -EIO;
	402	}
	403
	404	/* Ensure that we do not send more than 50 overlapping requests
	405	to the same server. We may make this configurable later or
	406	use ses->maxReq */
	407	if(long_op == -1) {
	408	/* oplock breaks must not be held up */
	409	atomic_inc(&ses->server->inFlight);
	410	} else {
	411	spin_lock(&GlobalMid_Lock);
	412	while(1) {
275cde1a SF	413	if(atomic_read(&ses->server->inFlight) >=
275cde1a SF	414	cifs_max_pending){
1da177e4 LT	415	spin_unlock(&GlobalMid_Lock);
	416	wait_event(ses->server->request_q,
	417	atomic_read(&ses->server->inFlight)
	418	< cifs_max_pending);
	419	spin_lock(&GlobalMid_Lock);
	420	} else {
	421	if(ses->server->tcpStatus == CifsExiting) {
	422	spin_unlock(&GlobalMid_Lock);
	423	return -ENOENT;
	424	}
	425
	426	/* can not count locking commands against total since
	427	they are allowed to block on server */
	428
	429	if(long_op < 3) {
	430	/* update # of requests on the wire to server */
	431	atomic_inc(&ses->server->inFlight);
	432	}
	433	spin_unlock(&GlobalMid_Lock);
	434	break;
	435	}
	436	}
	437	}
	438	/* make sure that we sign in the same order that we send on this socket
	439	and avoid races inside tcp sendmsg code that could cause corruption
	440	of smb data */
	441
	442	down(&ses->server->tcpSem);
	443
	444	if (ses->server->tcpStatus == CifsExiting) {
	445	rc = -ENOENT;
	446	goto out_unlock;
	447	} else if (ses->server->tcpStatus == CifsNeedReconnect) {
	448	cFYI(1,("tcp session dead - return to caller to retry"));
	449	rc = -EAGAIN;
	450	goto out_unlock;
	451	} else if (ses->status != CifsGood) {
	452	/* check if SMB session is bad because we are setting it up */
	453	if((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
	454	(in_buf->Command != SMB_COM_NEGOTIATE)) {
	455	rc = -EAGAIN;
	456	goto out_unlock;
	457	} /* else ok - we are setting up session */
	458	}
	459	midQ = AllocMidQEntry(in_buf, ses);
	460	if (midQ == NULL) {
	461	up(&ses->server->tcpSem);
	462	/* If not lock req, update # of requests on wire to server */
	463	if(long_op < 3) {
	464	atomic_dec(&ses->server->inFlight);
	465	wake_up(&ses->server->request_q);
	466	}
	467	return -ENOMEM;
	468	}
	469
	470	if (in_buf->smb_buf_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
	471	up(&ses->server->tcpSem);
	472	cERROR(1,
	473	("Illegal length, greater than maximum frame, %d ",
	474	in_buf->smb_buf_length));
	475	DeleteMidQEntry(midQ);
	476	/* If not lock req, update # of requests on wire to server */
	477	if(long_op < 3) {
	478	atomic_dec(&ses->server->inFlight);
479	wake_up(&ses->server->request_q);
480	}
481	return -EIO;
482	}
483
ad009ac9	484	rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
1da177e4 LT	485
	486	midQ->midState = MID_REQUEST_SUBMITTED;
	487	rc = smb_send(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
	488	(struct sockaddr *) &(ses->server->addr.sockAddr));
	489	if(rc < 0) {
	490	DeleteMidQEntry(midQ);
	491	up(&ses->server->tcpSem);
	492	/* If not lock req, update # of requests on wire to server */
	493	if(long_op < 3) {
	494	atomic_dec(&ses->server->inFlight);
	495	wake_up(&ses->server->request_q);
	496	}
	497	return rc;
	498	} else
	499	up(&ses->server->tcpSem);
	500	if (long_op == -1)
	501	goto cifs_no_response_exit;
275cde1a	502	else if (long_op == 2) /* writes past end of file can take loong time */
1da177e4 LT	503	timeout = 300 * HZ;
	504	else if (long_op == 1)
	505	timeout = 45 * HZ; /* should be greater than
	506	servers oplock break timeout (about 43 seconds) */
	507	else if (long_op > 2) {
	508	timeout = MAX_SCHEDULE_TIMEOUT;
	509	} else
	510	timeout = 15 * HZ;
	511	/* wait for 15 seconds or until woken up due to response arriving or
	512	due to last connection to this server being unmounted */
	513	if (signal_pending(current)) {
	514	/* if signal pending do not hold up user for full smb timeout
	515	but we still give response a change to complete */
	516	timeout = 2 * HZ;
	517	}
	518
	519	/* No user interrupts in wait - wreaks havoc with performance */
	520	if(timeout != MAX_SCHEDULE_TIMEOUT) {
	521	timeout += jiffies;
	522	wait_event(ses->server->response_q,
	523	(!(midQ->midState & MID_REQUEST_SUBMITTED)) \|\|
	524	time_after(jiffies, timeout) \|\|
	525	((ses->server->tcpStatus != CifsGood) &&
	526	(ses->server->tcpStatus != CifsNew)));
	527	} else {
	528	wait_event(ses->server->response_q,
	529	(!(midQ->midState & MID_REQUEST_SUBMITTED)) \|\|
	530	((ses->server->tcpStatus != CifsGood) &&
	531	(ses->server->tcpStatus != CifsNew)));
	532	}
	533
	534	spin_lock(&GlobalMid_Lock);
	535	if (midQ->resp_buf) {
	536	spin_unlock(&GlobalMid_Lock);
	537	receive_len = be32_to_cpu((__be32 )midQ->resp_buf);
	538	} else {
	539	cERROR(1,("No response buffer"));
	540	if(midQ->midState == MID_REQUEST_SUBMITTED) {
	541	if(ses->server->tcpStatus == CifsExiting)
	542	rc = -EHOSTDOWN;
	543	else {
	544	ses->server->tcpStatus = CifsNeedReconnect;
	545	midQ->midState = MID_RETRY_NEEDED;
	546	}
	547	}
	548
	549	if (rc != -EHOSTDOWN) {
	550	if(midQ->midState == MID_RETRY_NEEDED) {
	551	rc = -EAGAIN;
	552	cFYI(1,("marking request for retry"));
	553	} else {
	554	rc = -EIO;
	555	}
	556	}
	557	spin_unlock(&GlobalMid_Lock);
	558	DeleteMidQEntry(midQ);
	559	/* If not lock req, update # of requests on wire to server */
	560	if(long_op < 3) {
	561	atomic_dec(&ses->server->inFlight);
	562	wake_up(&ses->server->request_q);
	563	}
	564	return rc;
	565	}
	566
567	if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
ad009ac9	568	cERROR(1, ("Frame too large received. Length: %d Xid: %d",
1da177e4 LT	569	receive_len, xid));
	570	rc = -EIO;
	571	} else { /* rcvd frame is ok */
	572
	573	if (midQ->resp_buf && out_buf
	574	&& (midQ->midState == MID_RESPONSE_RECEIVED)) {
	575	out_buf->smb_buf_length = receive_len;
	576	memcpy((char *)out_buf + 4,
	577	(char *)midQ->resp_buf + 4,
	578	receive_len);
	579
	580	dump_smb(out_buf, 92);
	581	/* convert the length into a more usable form */
	582	if((receive_len > 24) &&
ad009ac9 SF	583	(ses->server->secMode & (SECMODE_SIGN_REQUIRED \|
	584	SECMODE_SIGN_ENABLED))) {
	585	rc = cifs_verify_signature(out_buf,
	586	ses->server->mac_signing_key,
	587	midQ->sequence_number+1);
	588	if(rc) {
275cde1a SF	589	cERROR(1,("Unexpected SMB signature"));
275cde1a SF	590	/* BB FIXME add code to kill session */
ad009ac9	591	}
1da177e4 LT	592	}
	593
	594	*pbytes_returned = out_buf->smb_buf_length;
	595
ad009ac9	596	/* BB special case reconnect tid and uid here? */
1da177e4 LT	597	rc = map_smb_to_linux_error(out_buf);
	598
	599	/* convert ByteCount if necessary */
	600	if (receive_len >=
	601	sizeof (struct smb_hdr) -
	602	4 /* do not count RFC1001 header */ +
	603	(2 * out_buf->WordCount) + 2 /* bcc */ )
	604	BCC(out_buf) = le16_to_cpu(BCC(out_buf));
	605	} else {
	606	rc = -EIO;
	607	cFYI(1,("Bad MID state? "));
	608	}
	609	}
	610	cifs_no_response_exit:
	611	DeleteMidQEntry(midQ);
	612
	613	if(long_op < 3) {
	614	atomic_dec(&ses->server->inFlight);
	615	wake_up(&ses->server->request_q);
	616	}
	617
	618	return rc;
	619
	620	out_unlock:
	621	up(&ses->server->tcpSem);
	622	/* If not lock req, update # of requests on wire to server */
	623	if(long_op < 3) {
	624	atomic_dec(&ses->server->inFlight);
	625	wake_up(&ses->server->request_q);
	626	}
	627
	628	return rc;
	629	}