blob: 0cc9584f5889f051208a00bb346869d73f6ed1ba [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/transport.c
3 *
Steve Frenchad7a2922008-02-07 23:25:02 +00004 * Copyright (C) International Business Machines Corp., 2002,2008
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Author(s): Steve French (sfrench@us.ibm.com)
Steve French14a441a2006-07-16 04:32:51 +00006 * Jeremy Allison (jra@samba.org) 2006.
Steve French79a58d12007-07-06 22:44:50 +00007 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * This library is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published
10 * by the Free Software Foundation; either version 2.1 of the License, or
11 * (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
16 * the GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with this library; if not, write to the Free Software
Steve French79a58d12007-07-06 22:44:50 +000020 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070021 */
22
23#include <linux/fs.h>
24#include <linux/list.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090025#include <linux/gfp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/wait.h>
27#include <linux/net.h>
28#include <linux/delay.h>
Jeff Laytonf06ac722011-10-19 15:30:40 -040029#include <linux/freezer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <asm/uaccess.h>
31#include <asm/processor.h>
32#include <linux/mempool.h>
33#include "cifspdu.h"
34#include "cifsglob.h"
35#include "cifsproto.h"
36#include "cifs_debug.h"
Steve French50c2f752007-07-13 00:33:32 +000037
Linus Torvalds1da177e2005-04-16 15:20:36 -070038extern mempool_t *cifs_mid_poolp;
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
Jeff Layton2b84a36c2011-01-11 07:24:21 -050040static void
41wake_up_task(struct mid_q_entry *mid)
42{
43 wake_up_process(mid->callback_data);
44}
45
Jeff Laytona6827c12011-01-11 07:24:21 -050046struct mid_q_entry *
Jeff Layton24b9b062008-12-01 07:09:34 -050047AllocMidQEntry(const struct smb_hdr *smb_buffer, struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -070048{
49 struct mid_q_entry *temp;
50
Jeff Layton24b9b062008-12-01 07:09:34 -050051 if (server == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +000052 cERROR(1, "Null TCP session in AllocMidQEntry");
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 return NULL;
54 }
Steve French50c2f752007-07-13 00:33:32 +000055
Pekka Enberg232087c2008-09-15 13:22:54 +030056 temp = mempool_alloc(cifs_mid_poolp, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 if (temp == NULL)
58 return temp;
59 else {
Steve French26f57362007-08-30 22:09:15 +000060 memset(temp, 0, sizeof(struct mid_q_entry));
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 temp->mid = smb_buffer->Mid; /* always LE */
62 temp->pid = current->pid;
63 temp->command = smb_buffer->Command;
Joe Perchesb6b38f72010-04-21 03:50:45 +000064 cFYI(1, "For smb_command %d", temp->command);
Steve French1047abc2005-10-11 19:58:06 -070065 /* do_gettimeofday(&temp->when_sent);*/ /* easier to use jiffies */
66 /* when mid allocated can be before when sent */
67 temp->when_alloc = jiffies;
Jeff Layton2b84a36c2011-01-11 07:24:21 -050068
69 /*
70 * The default is for the mid to be synchronous, so the
71 * default callback just wakes up the current task.
72 */
73 temp->callback = wake_up_task;
74 temp->callback_data = current;
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 }
76
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 atomic_inc(&midCount);
78 temp->midState = MID_REQUEST_ALLOCATED;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 return temp;
80}
81
Jeff Layton766fdbb2011-01-11 07:24:21 -050082void
Linus Torvalds1da177e2005-04-16 15:20:36 -070083DeleteMidQEntry(struct mid_q_entry *midEntry)
84{
Steve French1047abc2005-10-11 19:58:06 -070085#ifdef CONFIG_CIFS_STATS2
86 unsigned long now;
87#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 midEntry->midState = MID_FREE;
Jeff Layton80975312011-01-11 07:24:02 -050089 atomic_dec(&midCount);
Steve French79a58d12007-07-06 22:44:50 +000090 if (midEntry->largeBuf)
Steve Frenchb8643e12005-04-28 22:41:07 -070091 cifs_buf_release(midEntry->resp_buf);
92 else
93 cifs_small_buf_release(midEntry->resp_buf);
Steve French1047abc2005-10-11 19:58:06 -070094#ifdef CONFIG_CIFS_STATS2
95 now = jiffies;
96 /* commands taking longer than one second are indications that
97 something is wrong, unless it is quite a slow link or server */
Steve French79a58d12007-07-06 22:44:50 +000098 if ((now - midEntry->when_alloc) > HZ) {
99 if ((cifsFYI & CIFS_TIMER) &&
Steve French1047abc2005-10-11 19:58:06 -0700100 (midEntry->command != SMB_COM_LOCKING_ANDX)) {
101 printk(KERN_DEBUG " CIFS slow rsp: cmd %d mid %d",
102 midEntry->command, midEntry->mid);
103 printk(" A: 0x%lx S: 0x%lx R: 0x%lx\n",
104 now - midEntry->when_alloc,
105 now - midEntry->when_sent,
106 now - midEntry->when_received);
107 }
108 }
109#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 mempool_free(midEntry, cifs_mid_poolp);
111}
112
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500113static void
114delete_mid(struct mid_q_entry *mid)
115{
116 spin_lock(&GlobalMid_Lock);
117 list_del(&mid->qhead);
118 spin_unlock(&GlobalMid_Lock);
119
120 DeleteMidQEntry(mid);
121}
122
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500123static int
Jeff Layton0496e022008-12-30 12:39:16 -0500124smb_sendv(struct TCP_Server_Info *server, struct kvec *iov, int n_vec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125{
126 int rc = 0;
127 int i = 0;
128 struct msghdr smb_msg;
Steve French3e844692005-10-03 13:37:24 -0700129 struct smb_hdr *smb_buffer = iov[0].iov_base;
130 unsigned int len = iov[0].iov_len;
131 unsigned int total_len;
132 int first_vec = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000133 unsigned int smb_buf_length = be32_to_cpu(smb_buffer->smb_buf_length);
Steve Frenchedf1ae42008-10-29 00:47:57 +0000134 struct socket *ssocket = server->ssocket;
Steve French50c2f752007-07-13 00:33:32 +0000135
Steve French79a58d12007-07-06 22:44:50 +0000136 if (ssocket == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 return -ENOTSOCK; /* BB eventually add reconnect code here */
Steve French3e844692005-10-03 13:37:24 -0700138
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300139 smb_msg.msg_name = (struct sockaddr *) &server->dstaddr;
Steve French26f57362007-08-30 22:09:15 +0000140 smb_msg.msg_namelen = sizeof(struct sockaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 smb_msg.msg_control = NULL;
142 smb_msg.msg_controllen = 0;
Jeff Layton0496e022008-12-30 12:39:16 -0500143 if (server->noblocksnd)
Steve Frenchedf1ae42008-10-29 00:47:57 +0000144 smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL;
145 else
146 smb_msg.msg_flags = MSG_NOSIGNAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
Steve French3e844692005-10-03 13:37:24 -0700148 total_len = 0;
149 for (i = 0; i < n_vec; i++)
150 total_len += iov[i].iov_len;
151
Joe Perchesb6b38f72010-04-21 03:50:45 +0000152 cFYI(1, "Sending smb: total_len %d", total_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 dump_smb(smb_buffer, len);
154
Shirish Pargaonkar17680352008-07-29 21:26:13 +0000155 i = 0;
Steve French3e844692005-10-03 13:37:24 -0700156 while (total_len) {
157 rc = kernel_sendmsg(ssocket, &smb_msg, &iov[first_vec],
158 n_vec - first_vec, total_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 if ((rc == -ENOSPC) || (rc == -EAGAIN)) {
160 i++;
Steve Frenchda505c32009-01-19 03:49:35 +0000161 /* if blocking send we try 3 times, since each can block
162 for 5 seconds. For nonblocking we have to try more
163 but wait increasing amounts of time allowing time for
164 socket to clear. The overall time we wait in either
165 case to send on the socket is about 15 seconds.
166 Similarly we wait for 15 seconds for
167 a response from the server in SendReceive[2]
168 for the server to send a response back for
169 most types of requests (except SMB Write
170 past end of file which can be slow, and
171 blocking lock operations). NFS waits slightly longer
172 than CIFS, but this can make it take longer for
173 nonresponsive servers to be detected and 15 seconds
174 is more than enough time for modern networks to
175 send a packet. In most cases if we fail to send
176 after the retries we will kill the socket and
177 reconnect which may clear the network problem.
178 */
179 if ((i >= 14) || (!server->noblocksnd && (i > 2))) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000180 cERROR(1, "sends on sock %p stuck for 15 seconds",
181 ssocket);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 rc = -EAGAIN;
183 break;
184 }
Steve French68058e72005-10-10 10:34:22 -0700185 msleep(1 << i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 continue;
187 }
Steve French79a58d12007-07-06 22:44:50 +0000188 if (rc < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 break;
Steve French3e844692005-10-03 13:37:24 -0700190
Steve French61de8002008-10-30 20:15:22 +0000191 if (rc == total_len) {
192 total_len = 0;
193 break;
194 } else if (rc > total_len) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000195 cERROR(1, "sent %d requested %d", rc, total_len);
Steve French3e844692005-10-03 13:37:24 -0700196 break;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500197 }
Steve French79a58d12007-07-06 22:44:50 +0000198 if (rc == 0) {
Steve French3e844692005-10-03 13:37:24 -0700199 /* should never happen, letting socket clear before
200 retrying is our only obvious option here */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000201 cERROR(1, "tcp sent no data");
Steve French3e844692005-10-03 13:37:24 -0700202 msleep(500);
203 continue;
204 }
205 total_len -= rc;
Steve French68058e72005-10-10 10:34:22 -0700206 /* the line below resets i */
Steve French3e844692005-10-03 13:37:24 -0700207 for (i = first_vec; i < n_vec; i++) {
208 if (iov[i].iov_len) {
209 if (rc > iov[i].iov_len) {
210 rc -= iov[i].iov_len;
211 iov[i].iov_len = 0;
212 } else {
213 iov[i].iov_base += rc;
214 iov[i].iov_len -= rc;
215 first_vec = i;
216 break;
217 }
218 }
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500219 }
Steve French5e1253b2005-10-10 14:06:37 -0700220 i = 0; /* in case we get ENOSPC on the next send */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 }
222
Steve Frenchedf1ae42008-10-29 00:47:57 +0000223 if ((total_len > 0) && (total_len != smb_buf_length + 4)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000224 cFYI(1, "partial send (%d remaining), terminating session",
225 total_len);
Steve Frenchedf1ae42008-10-29 00:47:57 +0000226 /* If we have only sent part of an SMB then the next SMB
227 could be taken as the remainder of this one. We need
228 to kill the socket so the server throws away the partial
229 SMB */
230 server->tcpStatus = CifsNeedReconnect;
231 }
232
Jeff Laytond804d412011-01-28 15:05:43 -0500233 if (rc < 0 && rc != -EINTR)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000234 cERROR(1, "Error %d sending data on socket to server", rc);
Jeff Laytond804d412011-01-28 15:05:43 -0500235 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000238 /* Don't want to modify the buffer as a
239 side effect of this call. */
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000240 smb_buffer->smb_buf_length = cpu_to_be32(smb_buf_length);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000241
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 return rc;
243}
244
Jeff Layton0496e022008-12-30 12:39:16 -0500245int
246smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer,
247 unsigned int smb_buf_length)
248{
249 struct kvec iov;
250
251 iov.iov_base = smb_buffer;
252 iov.iov_len = smb_buf_length + 4;
253
254 return smb_sendv(server, &iov, 1);
255}
256
Jeff Laytonc5797a92011-01-11 07:24:01 -0500257static int wait_for_free_request(struct TCP_Server_Info *server,
258 const int long_op)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000259{
Steve French133672e2007-11-13 22:41:37 +0000260 if (long_op == CIFS_ASYNC_OP) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000261 /* oplock breaks must not be held up */
Jeff Laytonc5797a92011-01-11 07:24:01 -0500262 atomic_inc(&server->inFlight);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000263 return 0;
264 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000265
Volker Lendecke27a97a62008-12-08 20:59:39 +0000266 spin_lock(&GlobalMid_Lock);
267 while (1) {
Jeff Laytonc5797a92011-01-11 07:24:01 -0500268 if (atomic_read(&server->inFlight) >= cifs_max_pending) {
Volker Lendecke27a97a62008-12-08 20:59:39 +0000269 spin_unlock(&GlobalMid_Lock);
Steve French789e6662011-08-09 18:44:44 +0000270 cifs_num_waiters_inc(server);
Jeff Laytonc5797a92011-01-11 07:24:01 -0500271 wait_event(server->request_q,
272 atomic_read(&server->inFlight)
Volker Lendecke27a97a62008-12-08 20:59:39 +0000273 < cifs_max_pending);
Steve French789e6662011-08-09 18:44:44 +0000274 cifs_num_waiters_dec(server);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000275 spin_lock(&GlobalMid_Lock);
276 } else {
Jeff Laytonc5797a92011-01-11 07:24:01 -0500277 if (server->tcpStatus == CifsExiting) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000278 spin_unlock(&GlobalMid_Lock);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000279 return -ENOENT;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000280 }
Volker Lendecke27a97a62008-12-08 20:59:39 +0000281
282 /* can not count locking commands against total
283 as they are allowed to block on server */
284
285 /* update # of requests on the wire to server */
286 if (long_op != CIFS_BLOCKING_OP)
Jeff Laytonc5797a92011-01-11 07:24:01 -0500287 atomic_inc(&server->inFlight);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000288 spin_unlock(&GlobalMid_Lock);
289 break;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000290 }
291 }
292 return 0;
293}
294
Steve French96daf2b2011-05-27 04:34:02 +0000295static int allocate_mid(struct cifs_ses *ses, struct smb_hdr *in_buf,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000296 struct mid_q_entry **ppmidQ)
297{
298 if (ses->server->tcpStatus == CifsExiting) {
299 return -ENOENT;
Volker Lendecke8fbbd362008-12-06 13:12:34 +0100300 }
301
302 if (ses->server->tcpStatus == CifsNeedReconnect) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000303 cFYI(1, "tcp session dead - return to caller to retry");
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000304 return -EAGAIN;
Volker Lendecke8fbbd362008-12-06 13:12:34 +0100305 }
306
307 if (ses->status != CifsGood) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000308 /* check if SMB session is bad because we are setting it up */
Steve French79a58d12007-07-06 22:44:50 +0000309 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
Steve Frenchad7a2922008-02-07 23:25:02 +0000310 (in_buf->Command != SMB_COM_NEGOTIATE))
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000311 return -EAGAIN;
Steve Frenchad7a2922008-02-07 23:25:02 +0000312 /* else ok - we are setting up session */
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000313 }
Jeff Layton24b9b062008-12-01 07:09:34 -0500314 *ppmidQ = AllocMidQEntry(in_buf, ses->server);
Steve French26f57362007-08-30 22:09:15 +0000315 if (*ppmidQ == NULL)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000316 return -ENOMEM;
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500317 spin_lock(&GlobalMid_Lock);
318 list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);
319 spin_unlock(&GlobalMid_Lock);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000320 return 0;
321}
322
Jeff Layton0ade6402011-01-11 07:24:02 -0500323static int
324wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000325{
Jeff Layton0ade6402011-01-11 07:24:02 -0500326 int error;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000327
Jeff Laytonf06ac722011-10-19 15:30:40 -0400328 error = wait_event_freezekillable(server->response_q,
Jeff Layton0ade6402011-01-11 07:24:02 -0500329 midQ->midState != MID_REQUEST_SUBMITTED);
330 if (error < 0)
331 return -ERESTARTSYS;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000332
Jeff Layton0ade6402011-01-11 07:24:02 -0500333 return 0;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000334}
335
Steve French133672e2007-11-13 22:41:37 +0000336
337/*
Jeff Laytona6827c12011-01-11 07:24:21 -0500338 * Send a SMB request and set the callback function in the mid to handle
339 * the result. Caller is responsible for dealing with timeouts.
340 */
341int
Jeff Laytonfcc31cb2011-05-19 16:22:53 -0400342cifs_call_async(struct TCP_Server_Info *server, struct kvec *iov,
Jeff Layton44d22d82011-10-19 15:29:49 -0400343 unsigned int nvec, mid_receive_t *receive,
344 mid_callback_t *callback, void *cbdata, bool ignore_pend)
Jeff Laytona6827c12011-01-11 07:24:21 -0500345{
346 int rc;
347 struct mid_q_entry *mid;
Jeff Laytonfcc31cb2011-05-19 16:22:53 -0400348 struct smb_hdr *hdr = (struct smb_hdr *)iov[0].iov_base;
Jeff Laytona6827c12011-01-11 07:24:21 -0500349
Jeff Layton59ffd842011-05-19 16:22:55 -0400350 rc = wait_for_free_request(server, ignore_pend ? CIFS_ASYNC_OP : 0);
Jeff Laytona6827c12011-01-11 07:24:21 -0500351 if (rc)
352 return rc;
353
Jeff Laytone3f0dad2011-02-04 07:21:26 -0500354 /* enable signing if server requires it */
Steve French96daf2b2011-05-27 04:34:02 +0000355 if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Jeff Laytonfcc31cb2011-05-19 16:22:53 -0400356 hdr->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
Jeff Laytone3f0dad2011-02-04 07:21:26 -0500357
Jeff Laytona6827c12011-01-11 07:24:21 -0500358 mutex_lock(&server->srv_mutex);
Jeff Laytonfcc31cb2011-05-19 16:22:53 -0400359 mid = AllocMidQEntry(hdr, server);
Jeff Laytona6827c12011-01-11 07:24:21 -0500360 if (mid == NULL) {
361 mutex_unlock(&server->srv_mutex);
Pavel Shilovsky0193e072011-08-03 23:12:18 +0400362 atomic_dec(&server->inFlight);
363 wake_up(&server->request_q);
Jeff Laytona6827c12011-01-11 07:24:21 -0500364 return -ENOMEM;
365 }
366
367 /* put it on the pending_mid_q */
368 spin_lock(&GlobalMid_Lock);
369 list_add_tail(&mid->qhead, &server->pending_mid_q);
370 spin_unlock(&GlobalMid_Lock);
371
Jeff Laytonfcc31cb2011-05-19 16:22:53 -0400372 rc = cifs_sign_smb2(iov, nvec, server, &mid->sequence_number);
Jeff Laytona6827c12011-01-11 07:24:21 -0500373 if (rc) {
374 mutex_unlock(&server->srv_mutex);
375 goto out_err;
376 }
377
Jeff Layton44d22d82011-10-19 15:29:49 -0400378 mid->receive = receive;
Jeff Laytona6827c12011-01-11 07:24:21 -0500379 mid->callback = callback;
380 mid->callback_data = cbdata;
381 mid->midState = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000382
383 cifs_in_send_inc(server);
Jeff Laytonfcc31cb2011-05-19 16:22:53 -0400384 rc = smb_sendv(server, iov, nvec);
Steve French789e6662011-08-09 18:44:44 +0000385 cifs_in_send_dec(server);
386 cifs_save_when_sent(mid);
Jeff Laytona6827c12011-01-11 07:24:21 -0500387 mutex_unlock(&server->srv_mutex);
Steve French789e6662011-08-09 18:44:44 +0000388
Jeff Laytona6827c12011-01-11 07:24:21 -0500389 if (rc)
390 goto out_err;
391
392 return rc;
393out_err:
394 delete_mid(mid);
395 atomic_dec(&server->inFlight);
396 wake_up(&server->request_q);
397 return rc;
398}
399
400/*
Steve French133672e2007-11-13 22:41:37 +0000401 *
402 * Send an SMB Request. No response info (other than return code)
403 * needs to be parsed.
404 *
405 * flags indicate the type of request buffer and how long to wait
406 * and whether to log NT STATUS code (error) before mapping it to POSIX error
407 *
408 */
409int
Steve French96daf2b2011-05-27 04:34:02 +0000410SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
Steve French133672e2007-11-13 22:41:37 +0000411 struct smb_hdr *in_buf, int flags)
412{
413 int rc;
414 struct kvec iov[1];
415 int resp_buf_type;
416
417 iov[0].iov_base = (char *)in_buf;
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000418 iov[0].iov_len = be32_to_cpu(in_buf->smb_buf_length) + 4;
Steve French133672e2007-11-13 22:41:37 +0000419 flags |= CIFS_NO_RESP;
420 rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000421 cFYI(DBG2, "SendRcvNoRsp flags %d rc %d", flags, rc);
Steve French90c81e02008-02-12 20:32:36 +0000422
Steve French133672e2007-11-13 22:41:37 +0000423 return rc;
424}
425
Jeff Layton053d5032011-01-11 07:24:02 -0500426static int
Jeff Layton3c1105d2011-05-22 07:09:13 -0400427cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
Jeff Layton053d5032011-01-11 07:24:02 -0500428{
429 int rc = 0;
430
Jeff Layton74dd92a2011-01-11 07:24:02 -0500431 cFYI(1, "%s: cmd=%d mid=%d state=%d", __func__, mid->command,
432 mid->mid, mid->midState);
Jeff Layton053d5032011-01-11 07:24:02 -0500433
Jeff Layton74dd92a2011-01-11 07:24:02 -0500434 spin_lock(&GlobalMid_Lock);
435 switch (mid->midState) {
436 case MID_RESPONSE_RECEIVED:
Jeff Layton053d5032011-01-11 07:24:02 -0500437 spin_unlock(&GlobalMid_Lock);
438 return rc;
Jeff Layton74dd92a2011-01-11 07:24:02 -0500439 case MID_RETRY_NEEDED:
440 rc = -EAGAIN;
441 break;
Jeff Layton71823ba2011-02-10 08:03:50 -0500442 case MID_RESPONSE_MALFORMED:
443 rc = -EIO;
444 break;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400445 case MID_SHUTDOWN:
446 rc = -EHOSTDOWN;
447 break;
Jeff Layton74dd92a2011-01-11 07:24:02 -0500448 default:
Jeff Layton3c1105d2011-05-22 07:09:13 -0400449 list_del_init(&mid->qhead);
Jeff Layton74dd92a2011-01-11 07:24:02 -0500450 cERROR(1, "%s: invalid mid state mid=%d state=%d", __func__,
451 mid->mid, mid->midState);
452 rc = -EIO;
Jeff Layton053d5032011-01-11 07:24:02 -0500453 }
454 spin_unlock(&GlobalMid_Lock);
455
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500456 DeleteMidQEntry(mid);
Jeff Layton053d5032011-01-11 07:24:02 -0500457 return rc;
458}
459
Jeff Layton76dcc262011-01-11 07:24:24 -0500460/*
461 * An NT cancel request header looks just like the original request except:
462 *
463 * The Command is SMB_COM_NT_CANCEL
464 * The WordCount is zeroed out
465 * The ByteCount is zeroed out
466 *
467 * This function mangles an existing request buffer into a
468 * SMB_COM_NT_CANCEL request and then sends it.
469 */
470static int
471send_nt_cancel(struct TCP_Server_Info *server, struct smb_hdr *in_buf,
472 struct mid_q_entry *mid)
473{
474 int rc = 0;
475
476 /* -4 for RFC1001 length and +2 for BCC field */
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000477 in_buf->smb_buf_length = cpu_to_be32(sizeof(struct smb_hdr) - 4 + 2);
Jeff Layton76dcc262011-01-11 07:24:24 -0500478 in_buf->Command = SMB_COM_NT_CANCEL;
479 in_buf->WordCount = 0;
Jeff Layton820a8032011-05-04 08:05:26 -0400480 put_bcc(0, in_buf);
Jeff Layton76dcc262011-01-11 07:24:24 -0500481
482 mutex_lock(&server->srv_mutex);
483 rc = cifs_sign_smb(in_buf, server, &mid->sequence_number);
484 if (rc) {
485 mutex_unlock(&server->srv_mutex);
486 return rc;
487 }
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000488 rc = smb_send(server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
Jeff Layton76dcc262011-01-11 07:24:24 -0500489 mutex_unlock(&server->srv_mutex);
490
491 cFYI(1, "issued NT_CANCEL for mid %u, rc = %d",
492 in_buf->Mid, rc);
493
494 return rc;
495}
496
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497int
Jeff Layton2c8f9812011-05-19 16:22:52 -0400498cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
499 bool log_error)
500{
Jeff Layton826a95e2011-10-11 06:41:32 -0400501 unsigned int len = be32_to_cpu(mid->resp_buf->smb_buf_length) + 4;
502
503 dump_smb(mid->resp_buf, min_t(u32, 92, len));
Jeff Layton2c8f9812011-05-19 16:22:52 -0400504
505 /* convert the length into a more usable form */
Steve French96daf2b2011-05-27 04:34:02 +0000506 if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
Jeff Layton826a95e2011-10-11 06:41:32 -0400507 struct kvec iov;
508
509 iov.iov_base = mid->resp_buf;
510 iov.iov_len = len;
Jeff Layton2c8f9812011-05-19 16:22:52 -0400511 /* FIXME: add code to kill session */
Jeff Layton826a95e2011-10-11 06:41:32 -0400512 if (cifs_verify_signature(&iov, 1, server,
Jeff Layton2c8f9812011-05-19 16:22:52 -0400513 mid->sequence_number + 1) != 0)
514 cERROR(1, "Unexpected SMB signature");
515 }
516
517 /* BB special case reconnect tid and uid here? */
518 return map_smb_to_linux_error(mid->resp_buf, log_error);
519}
520
521int
Steve French96daf2b2011-05-27 04:34:02 +0000522SendReceive2(const unsigned int xid, struct cifs_ses *ses,
Steve French79a58d12007-07-06 22:44:50 +0000523 struct kvec *iov, int n_vec, int *pRespBufType /* ret */,
Steve French133672e2007-11-13 22:41:37 +0000524 const int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525{
526 int rc = 0;
Steve French133672e2007-11-13 22:41:37 +0000527 int long_op;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500528 struct mid_q_entry *midQ;
Steve French3e844692005-10-03 13:37:24 -0700529 struct smb_hdr *in_buf = iov[0].iov_base;
Steve French50c2f752007-07-13 00:33:32 +0000530
Steve French133672e2007-11-13 22:41:37 +0000531 long_op = flags & CIFS_TIMEOUT_MASK;
532
Steve Frenchec637e32005-12-12 20:53:18 -0800533 *pRespBufType = CIFS_NO_BUFFER; /* no response buf yet */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
Steve French4b8f9302006-02-26 16:41:18 +0000535 if ((ses == NULL) || (ses->server == NULL)) {
536 cifs_small_buf_release(in_buf);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000537 cERROR(1, "Null session");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 return -EIO;
539 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540
Steve French79a58d12007-07-06 22:44:50 +0000541 if (ses->server->tcpStatus == CifsExiting) {
Steve French4b8f9302006-02-26 16:41:18 +0000542 cifs_small_buf_release(in_buf);
Steve French31ca3bc2005-04-28 22:41:11 -0700543 return -ENOENT;
Steve French4b8f9302006-02-26 16:41:18 +0000544 }
Steve French31ca3bc2005-04-28 22:41:11 -0700545
Steve French79a58d12007-07-06 22:44:50 +0000546 /* Ensure that we do not send more than 50 overlapping requests
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 to the same server. We may make this configurable later or
548 use ses->maxReq */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
Jeff Laytonc5797a92011-01-11 07:24:01 -0500550 rc = wait_for_free_request(ses->server, long_op);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000551 if (rc) {
552 cifs_small_buf_release(in_buf);
553 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000555
Steve French79a58d12007-07-06 22:44:50 +0000556 /* make sure that we sign in the same order that we send on this socket
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 and avoid races inside tcp sendmsg code that could cause corruption
558 of smb data */
559
Jeff Layton72ca5452008-12-01 07:09:36 -0500560 mutex_lock(&ses->server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000562 rc = allocate_mid(ses, in_buf, &midQ);
563 if (rc) {
Jeff Layton72ca5452008-12-01 07:09:36 -0500564 mutex_unlock(&ses->server->srv_mutex);
Steve French4b8f9302006-02-26 16:41:18 +0000565 cifs_small_buf_release(in_buf);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000566 /* Update # of requests on wire to server */
Steve French79a58d12007-07-06 22:44:50 +0000567 atomic_dec(&ses->server->inFlight);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000568 wake_up(&ses->server->request_q);
569 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 }
Steve French79a58d12007-07-06 22:44:50 +0000571 rc = cifs_sign_smb2(iov, n_vec, ses->server, &midQ->sequence_number);
Volker Lendecke829049c2008-12-06 16:00:53 +0100572 if (rc) {
573 mutex_unlock(&ses->server->srv_mutex);
574 cifs_small_buf_release(in_buf);
575 goto out;
576 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577
578 midQ->midState = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000579 cifs_in_send_inc(ses->server);
Jeff Layton0496e022008-12-30 12:39:16 -0500580 rc = smb_sendv(ses->server, iov, n_vec);
Steve French789e6662011-08-09 18:44:44 +0000581 cifs_in_send_dec(ses->server);
582 cifs_save_when_sent(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000583
Jeff Layton72ca5452008-12-01 07:09:36 -0500584 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000585
Jeff Layton2db7c582011-01-28 07:08:28 -0500586 if (rc < 0) {
587 cifs_small_buf_release(in_buf);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000588 goto out;
Jeff Layton2db7c582011-01-28 07:08:28 -0500589 }
Steve French4b8f9302006-02-26 16:41:18 +0000590
Jeff Layton2db7c582011-01-28 07:08:28 -0500591 if (long_op == CIFS_ASYNC_OP) {
592 cifs_small_buf_release(in_buf);
Steve French133672e2007-11-13 22:41:37 +0000593 goto out;
Jeff Layton2db7c582011-01-28 07:08:28 -0500594 }
Jeff Layton0ade6402011-01-11 07:24:02 -0500595
596 rc = wait_for_response(ses->server, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500597 if (rc != 0) {
Jeff Layton2db7c582011-01-28 07:08:28 -0500598 send_nt_cancel(ses->server, in_buf, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500599 spin_lock(&GlobalMid_Lock);
600 if (midQ->midState == MID_REQUEST_SUBMITTED) {
601 midQ->callback = DeleteMidQEntry;
602 spin_unlock(&GlobalMid_Lock);
Jeff Layton2db7c582011-01-28 07:08:28 -0500603 cifs_small_buf_release(in_buf);
Jeff Layton1be912d2011-01-28 07:08:28 -0500604 atomic_dec(&ses->server->inFlight);
605 wake_up(&ses->server->request_q);
606 return rc;
607 }
608 spin_unlock(&GlobalMid_Lock);
609 }
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500610
Jeff Layton2db7c582011-01-28 07:08:28 -0500611 cifs_small_buf_release(in_buf);
612
Jeff Layton3c1105d2011-05-22 07:09:13 -0400613 rc = cifs_sync_mid_result(midQ, ses->server);
Jeff Layton053d5032011-01-11 07:24:02 -0500614 if (rc != 0) {
Steve French79a58d12007-07-06 22:44:50 +0000615 atomic_dec(&ses->server->inFlight);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000616 wake_up(&ses->server->request_q);
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500617 return rc;
618 }
Steve French50c2f752007-07-13 00:33:32 +0000619
Jeff Layton2c8f9812011-05-19 16:22:52 -0400620 if (!midQ->resp_buf || midQ->midState != MID_RESPONSE_RECEIVED) {
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500621 rc = -EIO;
Jeff Layton2c8f9812011-05-19 16:22:52 -0400622 cFYI(1, "Bad MID state?");
Steve French2b2bdfb2008-12-11 17:26:54 +0000623 goto out;
624 }
Steve French84afc292005-12-02 13:32:45 -0800625
Jeff Layton2c8f9812011-05-19 16:22:52 -0400626 iov[0].iov_base = (char *)midQ->resp_buf;
627 iov[0].iov_len = be32_to_cpu(midQ->resp_buf->smb_buf_length) + 4;
628 if (midQ->largeBuf)
629 *pRespBufType = CIFS_LARGE_BUFFER;
630 else
631 *pRespBufType = CIFS_SMALL_BUFFER;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500632
Jeff Layton2c8f9812011-05-19 16:22:52 -0400633 rc = cifs_check_receive(midQ, ses->server, flags & CIFS_LOG_ERROR);
Steve French2b2bdfb2008-12-11 17:26:54 +0000634
Jeff Layton2c8f9812011-05-19 16:22:52 -0400635 /* mark it so buf will not be freed by delete_mid */
636 if ((flags & CIFS_NO_RESP) == 0)
637 midQ->resp_buf = NULL;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000638out:
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500639 delete_mid(midQ);
Steve French79a58d12007-07-06 22:44:50 +0000640 atomic_dec(&ses->server->inFlight);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000641 wake_up(&ses->server->request_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642
643 return rc;
644}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
646int
Steve French96daf2b2011-05-27 04:34:02 +0000647SendReceive(const unsigned int xid, struct cifs_ses *ses,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
649 int *pbytes_returned, const int long_op)
650{
651 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 struct mid_q_entry *midQ;
653
654 if (ses == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000655 cERROR(1, "Null smb session");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 return -EIO;
657 }
Steve French79a58d12007-07-06 22:44:50 +0000658 if (ses->server == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000659 cERROR(1, "Null tcp session");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 return -EIO;
661 }
662
Steve French79a58d12007-07-06 22:44:50 +0000663 if (ses->server->tcpStatus == CifsExiting)
Steve French31ca3bc2005-04-28 22:41:11 -0700664 return -ENOENT;
665
Steve French79a58d12007-07-06 22:44:50 +0000666 /* Ensure that we do not send more than 50 overlapping requests
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 to the same server. We may make this configurable later or
668 use ses->maxReq */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000670 if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
671 MAX_CIFS_HDR_SIZE - 4) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000672 cERROR(1, "Illegal length, greater than maximum frame, %d",
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000673 be32_to_cpu(in_buf->smb_buf_length));
Volker Lendecke6d9c6d52008-12-08 20:50:24 +0000674 return -EIO;
675 }
676
Jeff Laytonc5797a92011-01-11 07:24:01 -0500677 rc = wait_for_free_request(ses->server, long_op);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000678 if (rc)
679 return rc;
680
Steve French79a58d12007-07-06 22:44:50 +0000681 /* make sure that we sign in the same order that we send on this socket
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 and avoid races inside tcp sendmsg code that could cause corruption
683 of smb data */
684
Jeff Layton72ca5452008-12-01 07:09:36 -0500685 mutex_lock(&ses->server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000687 rc = allocate_mid(ses, in_buf, &midQ);
688 if (rc) {
Jeff Layton72ca5452008-12-01 07:09:36 -0500689 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000690 /* Update # of requests on wire to server */
Steve French79a58d12007-07-06 22:44:50 +0000691 atomic_dec(&ses->server->inFlight);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000692 wake_up(&ses->server->request_q);
693 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 }
695
Steve Frenchad009ac2005-04-28 22:41:05 -0700696 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
Volker Lendecke829049c2008-12-06 16:00:53 +0100697 if (rc) {
698 mutex_unlock(&ses->server->srv_mutex);
699 goto out;
700 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
702 midQ->midState = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000703
704 cifs_in_send_inc(ses->server);
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000705 rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
Steve French789e6662011-08-09 18:44:44 +0000706 cifs_in_send_dec(ses->server);
707 cifs_save_when_sent(midQ);
Jeff Layton72ca5452008-12-01 07:09:36 -0500708 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000709
Steve French79a58d12007-07-06 22:44:50 +0000710 if (rc < 0)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000711 goto out;
712
Jeff Layton0ade6402011-01-11 07:24:02 -0500713 if (long_op == CIFS_ASYNC_OP)
Steve French133672e2007-11-13 22:41:37 +0000714 goto out;
Jeff Layton0ade6402011-01-11 07:24:02 -0500715
716 rc = wait_for_response(ses->server, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500717 if (rc != 0) {
Jeff Layton2db7c582011-01-28 07:08:28 -0500718 send_nt_cancel(ses->server, in_buf, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500719 spin_lock(&GlobalMid_Lock);
720 if (midQ->midState == MID_REQUEST_SUBMITTED) {
721 /* no longer considered to be "in-flight" */
722 midQ->callback = DeleteMidQEntry;
723 spin_unlock(&GlobalMid_Lock);
724 atomic_dec(&ses->server->inFlight);
725 wake_up(&ses->server->request_q);
726 return rc;
727 }
728 spin_unlock(&GlobalMid_Lock);
729 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730
Jeff Layton3c1105d2011-05-22 07:09:13 -0400731 rc = cifs_sync_mid_result(midQ, ses->server);
Jeff Layton053d5032011-01-11 07:24:02 -0500732 if (rc != 0) {
Steve French79a58d12007-07-06 22:44:50 +0000733 atomic_dec(&ses->server->inFlight);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000734 wake_up(&ses->server->request_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 return rc;
736 }
Steve French50c2f752007-07-13 00:33:32 +0000737
Jeff Layton2c8f9812011-05-19 16:22:52 -0400738 if (!midQ->resp_buf || !out_buf ||
739 midQ->midState != MID_RESPONSE_RECEIVED) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 rc = -EIO;
Jeff Layton2c8f9812011-05-19 16:22:52 -0400741 cERROR(1, "Bad MID state?");
Steve French2b2bdfb2008-12-11 17:26:54 +0000742 goto out;
743 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
Jeff Layton2c8f9812011-05-19 16:22:52 -0400745 *pbytes_returned = be32_to_cpu(midQ->resp_buf->smb_buf_length);
746 memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
747 rc = cifs_check_receive(midQ, ses->server, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000748out:
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500749 delete_mid(midQ);
Steve French79a58d12007-07-06 22:44:50 +0000750 atomic_dec(&ses->server->inFlight);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000751 wake_up(&ses->server->request_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752
753 return rc;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000754}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000756/* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
757 blocking lock to return. */
758
759static int
Steve French96daf2b2011-05-27 04:34:02 +0000760send_lock_cancel(const unsigned int xid, struct cifs_tcon *tcon,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000761 struct smb_hdr *in_buf,
762 struct smb_hdr *out_buf)
763{
764 int bytes_returned;
Steve French96daf2b2011-05-27 04:34:02 +0000765 struct cifs_ses *ses = tcon->ses;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000766 LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
767
768 /* We just modify the current in_buf to change
769 the type of lock from LOCKING_ANDX_SHARED_LOCK
770 or LOCKING_ANDX_EXCLUSIVE_LOCK to
771 LOCKING_ANDX_CANCEL_LOCK. */
772
773 pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
774 pSMB->Timeout = 0;
775 pSMB->hdr.Mid = GetNextMid(ses->server);
776
777 return SendReceive(xid, ses, in_buf, out_buf,
Jeff Layton77499812011-01-11 07:24:23 -0500778 &bytes_returned, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000779}
780
781int
Steve French96daf2b2011-05-27 04:34:02 +0000782SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000783 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
784 int *pbytes_returned)
785{
786 int rc = 0;
787 int rstart = 0;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000788 struct mid_q_entry *midQ;
Steve French96daf2b2011-05-27 04:34:02 +0000789 struct cifs_ses *ses;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000790
791 if (tcon == NULL || tcon->ses == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000792 cERROR(1, "Null smb session");
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000793 return -EIO;
794 }
795 ses = tcon->ses;
796
Steve French79a58d12007-07-06 22:44:50 +0000797 if (ses->server == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000798 cERROR(1, "Null tcp session");
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000799 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 }
801
Steve French79a58d12007-07-06 22:44:50 +0000802 if (ses->server->tcpStatus == CifsExiting)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000803 return -ENOENT;
804
Steve French79a58d12007-07-06 22:44:50 +0000805 /* Ensure that we do not send more than 50 overlapping requests
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000806 to the same server. We may make this configurable later or
807 use ses->maxReq */
808
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000809 if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
810 MAX_CIFS_HDR_SIZE - 4) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000811 cERROR(1, "Illegal length, greater than maximum frame, %d",
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000812 be32_to_cpu(in_buf->smb_buf_length));
Volker Lendecke6d9c6d52008-12-08 20:50:24 +0000813 return -EIO;
814 }
815
Jeff Laytonc5797a92011-01-11 07:24:01 -0500816 rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000817 if (rc)
818 return rc;
819
Steve French79a58d12007-07-06 22:44:50 +0000820 /* make sure that we sign in the same order that we send on this socket
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000821 and avoid races inside tcp sendmsg code that could cause corruption
822 of smb data */
823
Jeff Layton72ca5452008-12-01 07:09:36 -0500824 mutex_lock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000825
826 rc = allocate_mid(ses, in_buf, &midQ);
827 if (rc) {
Jeff Layton72ca5452008-12-01 07:09:36 -0500828 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000829 return rc;
830 }
831
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000832 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
Volker Lendecke829049c2008-12-06 16:00:53 +0100833 if (rc) {
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500834 delete_mid(midQ);
Volker Lendecke829049c2008-12-06 16:00:53 +0100835 mutex_unlock(&ses->server->srv_mutex);
836 return rc;
837 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000838
839 midQ->midState = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000840 cifs_in_send_inc(ses->server);
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000841 rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
Steve French789e6662011-08-09 18:44:44 +0000842 cifs_in_send_dec(ses->server);
843 cifs_save_when_sent(midQ);
Jeff Layton72ca5452008-12-01 07:09:36 -0500844 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000845
Steve French79a58d12007-07-06 22:44:50 +0000846 if (rc < 0) {
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500847 delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000848 return rc;
849 }
850
851 /* Wait for a reply - allow signals to interrupt. */
852 rc = wait_event_interruptible(ses->server->response_q,
Steve French79a58d12007-07-06 22:44:50 +0000853 (!(midQ->midState == MID_REQUEST_SUBMITTED)) ||
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000854 ((ses->server->tcpStatus != CifsGood) &&
855 (ses->server->tcpStatus != CifsNew)));
856
857 /* Were we interrupted by a signal ? */
858 if ((rc == -ERESTARTSYS) &&
859 (midQ->midState == MID_REQUEST_SUBMITTED) &&
860 ((ses->server->tcpStatus == CifsGood) ||
861 (ses->server->tcpStatus == CifsNew))) {
862
863 if (in_buf->Command == SMB_COM_TRANSACTION2) {
864 /* POSIX lock. We send a NT_CANCEL SMB to cause the
865 blocking lock to return. */
Jeff Layton76dcc262011-01-11 07:24:24 -0500866 rc = send_nt_cancel(ses->server, in_buf, midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000867 if (rc) {
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500868 delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000869 return rc;
870 }
871 } else {
872 /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
873 to cause the blocking lock to return. */
874
875 rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
876
877 /* If we get -ENOLCK back the lock may have
878 already been removed. Don't exit in this case. */
879 if (rc && rc != -ENOLCK) {
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500880 delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000881 return rc;
882 }
883 }
884
Jeff Layton1be912d2011-01-28 07:08:28 -0500885 rc = wait_for_response(ses->server, midQ);
886 if (rc) {
Jeff Layton2db7c582011-01-28 07:08:28 -0500887 send_nt_cancel(ses->server, in_buf, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500888 spin_lock(&GlobalMid_Lock);
889 if (midQ->midState == MID_REQUEST_SUBMITTED) {
890 /* no longer considered to be "in-flight" */
891 midQ->callback = DeleteMidQEntry;
892 spin_unlock(&GlobalMid_Lock);
893 return rc;
894 }
895 spin_unlock(&GlobalMid_Lock);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000896 }
Jeff Layton1be912d2011-01-28 07:08:28 -0500897
898 /* We got the response - restart system call. */
899 rstart = 1;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000900 }
901
Jeff Layton3c1105d2011-05-22 07:09:13 -0400902 rc = cifs_sync_mid_result(midQ, ses->server);
Jeff Layton053d5032011-01-11 07:24:02 -0500903 if (rc != 0)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000904 return rc;
Steve French50c2f752007-07-13 00:33:32 +0000905
Volker Lendecke17c8bfe2008-12-06 16:38:19 +0100906 /* rcvd frame is ok */
Jeff Layton2c8f9812011-05-19 16:22:52 -0400907 if (out_buf == NULL || midQ->midState != MID_RESPONSE_RECEIVED) {
Volker Lendecke17c8bfe2008-12-06 16:38:19 +0100908 rc = -EIO;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000909 cERROR(1, "Bad MID state?");
Volker Lendecke698e96a2008-12-06 16:39:31 +0100910 goto out;
Volker Lendecke17c8bfe2008-12-06 16:38:19 +0100911 }
912
Jeff Layton2c8f9812011-05-19 16:22:52 -0400913 *pbytes_returned = be32_to_cpu(midQ->resp_buf->smb_buf_length);
914 memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
915 rc = cifs_check_receive(midQ, ses->server, 0);
Volker Lendecke17c8bfe2008-12-06 16:38:19 +0100916out:
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500917 delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000918 if (rstart && rc == -EACCES)
919 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 return rc;
921}