blob: 0961336513d5334d99084eee82addeb1b582ffbf [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 French14a441a2b2006-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;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -040063 temp->command = cpu_to_le16(smb_buffer->Command);
64 cFYI(1, "For smb_command %d", smb_buffer->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);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -040078 temp->mid_state = 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
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -040088 midEntry->mid_state = MID_FREE;
Jeff Layton80975312011-01-11 07:24:02 -050089 atomic_dec(&midCount);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -040090 if (midEntry->large_buf)
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) &&
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400100 (midEntry->command != cpu_to_le16(SMB_COM_LOCKING_ANDX))) {
101 printk(KERN_DEBUG " CIFS slow rsp: cmd %d mid %llu",
Steve French1047abc2005-10-11 19:58:06 -0700102 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;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400129 __be32 *buf_len = (__be32 *)(iov[0].iov_base);
Steve French3e844692005-10-03 13:37:24 -0700130 unsigned int len = iov[0].iov_len;
131 unsigned int total_len;
132 int first_vec = 0;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400133 unsigned int smb_buf_length = get_rfc1002_length(iov[0].iov_base);
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);
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400153 dump_smb(iov[0].iov_base, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
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++;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400161 /*
162 * If blocking send we try 3 times, since each can block
163 * for 5 seconds. For nonblocking we have to try more
164 * but wait increasing amounts of time allowing time for
165 * socket to clear. The overall time we wait in either
166 * case to send on the socket is about 15 seconds.
167 * Similarly we wait for 15 seconds for a response from
168 * the server in SendReceive[2] for the server to send
169 * a response back for most types of requests (except
170 * SMB Write 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 */
Steve Frenchda505c32009-01-19 03:49:35 +0000179 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
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400238 /* Don't want to modify the buffer as a side effect of this call. */
239 *buf_len = cpu_to_be32(smb_buf_length);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000240
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 return rc;
242}
243
Jeff Layton0496e022008-12-30 12:39:16 -0500244int
245smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer,
246 unsigned int smb_buf_length)
247{
248 struct kvec iov;
249
250 iov.iov_base = smb_buffer;
251 iov.iov_len = smb_buf_length + 4;
252
253 return smb_sendv(server, &iov, 1);
254}
255
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300256static int
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300257wait_for_free_credits(struct TCP_Server_Info *server, const int optype,
258 int *credits)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000259{
Pavel Shilovsky5bc59492012-02-21 19:56:08 +0300260 int rc;
261
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300262 spin_lock(&server->req_lock);
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300263 if (optype == CIFS_ASYNC_OP) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000264 /* oplock breaks must not be held up */
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300265 server->in_flight++;
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300266 *credits -= 1;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300267 spin_unlock(&server->req_lock);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000268 return 0;
269 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000270
Volker Lendecke27a97a62008-12-08 20:59:39 +0000271 while (1) {
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300272 if (*credits <= 0) {
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300273 spin_unlock(&server->req_lock);
Steve French789e6662011-08-09 18:44:44 +0000274 cifs_num_waiters_inc(server);
Pavel Shilovsky5bc59492012-02-21 19:56:08 +0300275 rc = wait_event_killable(server->request_q,
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300276 has_credits(server, credits));
Steve French789e6662011-08-09 18:44:44 +0000277 cifs_num_waiters_dec(server);
Pavel Shilovsky5bc59492012-02-21 19:56:08 +0300278 if (rc)
279 return rc;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300280 spin_lock(&server->req_lock);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000281 } else {
Jeff Laytonc5797a92011-01-11 07:24:01 -0500282 if (server->tcpStatus == CifsExiting) {
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300283 spin_unlock(&server->req_lock);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000284 return -ENOENT;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000285 }
Volker Lendecke27a97a62008-12-08 20:59:39 +0000286
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400287 /*
288 * Can not count locking commands against total
289 * as they are allowed to block on server.
290 */
Volker Lendecke27a97a62008-12-08 20:59:39 +0000291
292 /* update # of requests on the wire to server */
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300293 if (optype != CIFS_BLOCKING_OP) {
294 *credits -= 1;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300295 server->in_flight++;
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400296 }
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300297 spin_unlock(&server->req_lock);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000298 break;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000299 }
300 }
301 return 0;
302}
303
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300304static int
305wait_for_free_request(struct TCP_Server_Info *server, const int optype)
306{
307 return wait_for_free_credits(server, optype, get_credits_field(server));
308}
309
Steve French96daf2b2011-05-27 04:34:02 +0000310static int allocate_mid(struct cifs_ses *ses, struct smb_hdr *in_buf,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000311 struct mid_q_entry **ppmidQ)
312{
313 if (ses->server->tcpStatus == CifsExiting) {
314 return -ENOENT;
Volker Lendecke8fbbd362008-12-06 13:12:34 +0100315 }
316
317 if (ses->server->tcpStatus == CifsNeedReconnect) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000318 cFYI(1, "tcp session dead - return to caller to retry");
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000319 return -EAGAIN;
Volker Lendecke8fbbd362008-12-06 13:12:34 +0100320 }
321
322 if (ses->status != CifsGood) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000323 /* check if SMB session is bad because we are setting it up */
Steve French79a58d12007-07-06 22:44:50 +0000324 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
Steve Frenchad7a2922008-02-07 23:25:02 +0000325 (in_buf->Command != SMB_COM_NEGOTIATE))
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000326 return -EAGAIN;
Steve Frenchad7a2922008-02-07 23:25:02 +0000327 /* else ok - we are setting up session */
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000328 }
Jeff Layton24b9b062008-12-01 07:09:34 -0500329 *ppmidQ = AllocMidQEntry(in_buf, ses->server);
Steve French26f57362007-08-30 22:09:15 +0000330 if (*ppmidQ == NULL)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000331 return -ENOMEM;
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500332 spin_lock(&GlobalMid_Lock);
333 list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);
334 spin_unlock(&GlobalMid_Lock);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000335 return 0;
336}
337
Jeff Layton0ade6402011-01-11 07:24:02 -0500338static int
339wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000340{
Jeff Layton0ade6402011-01-11 07:24:02 -0500341 int error;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000342
Jeff Laytonf06ac722011-10-19 15:30:40 -0400343 error = wait_event_freezekillable(server->response_q,
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400344 midQ->mid_state != MID_REQUEST_SUBMITTED);
Jeff Layton0ade6402011-01-11 07:24:02 -0500345 if (error < 0)
346 return -ERESTARTSYS;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000347
Jeff Layton0ade6402011-01-11 07:24:02 -0500348 return 0;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000349}
350
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400351static int
352cifs_setup_async_request(struct TCP_Server_Info *server, struct kvec *iov,
353 unsigned int nvec, struct mid_q_entry **ret_mid)
354{
355 int rc;
356 struct smb_hdr *hdr = (struct smb_hdr *)iov[0].iov_base;
357 struct mid_q_entry *mid;
358
359 /* enable signing if server requires it */
360 if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
361 hdr->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
362
363 mid = AllocMidQEntry(hdr, server);
364 if (mid == NULL)
365 return -ENOMEM;
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
372 rc = cifs_sign_smb2(iov, nvec, server, &mid->sequence_number);
373 if (rc)
374 delete_mid(mid);
375 *ret_mid = mid;
376 return rc;
377}
Steve French133672e2007-11-13 22:41:37 +0000378
379/*
Jeff Laytona6827c12011-01-11 07:24:21 -0500380 * Send a SMB request and set the callback function in the mid to handle
381 * the result. Caller is responsible for dealing with timeouts.
382 */
383int
Jeff Laytonfcc31cb2011-05-19 16:22:53 -0400384cifs_call_async(struct TCP_Server_Info *server, struct kvec *iov,
Jeff Layton44d22d82011-10-19 15:29:49 -0400385 unsigned int nvec, mid_receive_t *receive,
386 mid_callback_t *callback, void *cbdata, bool ignore_pend)
Jeff Laytona6827c12011-01-11 07:24:21 -0500387{
388 int rc;
389 struct mid_q_entry *mid;
390
Jeff Layton59ffd842011-05-19 16:22:55 -0400391 rc = wait_for_free_request(server, ignore_pend ? CIFS_ASYNC_OP : 0);
Jeff Laytona6827c12011-01-11 07:24:21 -0500392 if (rc)
393 return rc;
394
395 mutex_lock(&server->srv_mutex);
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400396 rc = cifs_setup_async_request(server, iov, nvec, &mid);
397 if (rc) {
Jeff Laytona6827c12011-01-11 07:24:21 -0500398 mutex_unlock(&server->srv_mutex);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400399 cifs_add_credits(server, 1);
Pavel Shilovsky0193e072011-08-03 23:12:18 +0400400 wake_up(&server->request_q);
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400401 return rc;
Jeff Laytona6827c12011-01-11 07:24:21 -0500402 }
403
Jeff Layton44d22d82011-10-19 15:29:49 -0400404 mid->receive = receive;
Jeff Laytona6827c12011-01-11 07:24:21 -0500405 mid->callback = callback;
406 mid->callback_data = cbdata;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400407 mid->mid_state = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000408
409 cifs_in_send_inc(server);
Jeff Laytonfcc31cb2011-05-19 16:22:53 -0400410 rc = smb_sendv(server, iov, nvec);
Steve French789e6662011-08-09 18:44:44 +0000411 cifs_in_send_dec(server);
412 cifs_save_when_sent(mid);
Jeff Laytona6827c12011-01-11 07:24:21 -0500413 mutex_unlock(&server->srv_mutex);
Steve French789e6662011-08-09 18:44:44 +0000414
Jeff Laytona6827c12011-01-11 07:24:21 -0500415 if (rc)
416 goto out_err;
417
418 return rc;
419out_err:
420 delete_mid(mid);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400421 cifs_add_credits(server, 1);
Jeff Laytona6827c12011-01-11 07:24:21 -0500422 wake_up(&server->request_q);
423 return rc;
424}
425
426/*
Steve French133672e2007-11-13 22:41:37 +0000427 *
428 * Send an SMB Request. No response info (other than return code)
429 * needs to be parsed.
430 *
431 * flags indicate the type of request buffer and how long to wait
432 * and whether to log NT STATUS code (error) before mapping it to POSIX error
433 *
434 */
435int
Steve French96daf2b2011-05-27 04:34:02 +0000436SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400437 char *in_buf, int flags)
Steve French133672e2007-11-13 22:41:37 +0000438{
439 int rc;
440 struct kvec iov[1];
441 int resp_buf_type;
442
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400443 iov[0].iov_base = in_buf;
444 iov[0].iov_len = get_rfc1002_length(in_buf) + 4;
Steve French133672e2007-11-13 22:41:37 +0000445 flags |= CIFS_NO_RESP;
446 rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000447 cFYI(DBG2, "SendRcvNoRsp flags %d rc %d", flags, rc);
Steve French90c81e02008-02-12 20:32:36 +0000448
Steve French133672e2007-11-13 22:41:37 +0000449 return rc;
450}
451
Jeff Layton053d5032011-01-11 07:24:02 -0500452static int
Jeff Layton3c1105d2011-05-22 07:09:13 -0400453cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
Jeff Layton053d5032011-01-11 07:24:02 -0500454{
455 int rc = 0;
456
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400457 cFYI(1, "%s: cmd=%d mid=%llu state=%d", __func__,
458 le16_to_cpu(mid->command), mid->mid, mid->mid_state);
Jeff Layton053d5032011-01-11 07:24:02 -0500459
Jeff Layton74dd92a2011-01-11 07:24:02 -0500460 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400461 switch (mid->mid_state) {
Jeff Layton74dd92a2011-01-11 07:24:02 -0500462 case MID_RESPONSE_RECEIVED:
Jeff Layton053d5032011-01-11 07:24:02 -0500463 spin_unlock(&GlobalMid_Lock);
464 return rc;
Jeff Layton74dd92a2011-01-11 07:24:02 -0500465 case MID_RETRY_NEEDED:
466 rc = -EAGAIN;
467 break;
Jeff Layton71823ba2011-02-10 08:03:50 -0500468 case MID_RESPONSE_MALFORMED:
469 rc = -EIO;
470 break;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400471 case MID_SHUTDOWN:
472 rc = -EHOSTDOWN;
473 break;
Jeff Layton74dd92a2011-01-11 07:24:02 -0500474 default:
Jeff Layton3c1105d2011-05-22 07:09:13 -0400475 list_del_init(&mid->qhead);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400476 cERROR(1, "%s: invalid mid state mid=%llu state=%d", __func__,
477 mid->mid, mid->mid_state);
Jeff Layton74dd92a2011-01-11 07:24:02 -0500478 rc = -EIO;
Jeff Layton053d5032011-01-11 07:24:02 -0500479 }
480 spin_unlock(&GlobalMid_Lock);
481
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500482 DeleteMidQEntry(mid);
Jeff Layton053d5032011-01-11 07:24:02 -0500483 return rc;
484}
485
Jeff Layton76dcc262011-01-11 07:24:24 -0500486/*
487 * An NT cancel request header looks just like the original request except:
488 *
489 * The Command is SMB_COM_NT_CANCEL
490 * The WordCount is zeroed out
491 * The ByteCount is zeroed out
492 *
493 * This function mangles an existing request buffer into a
494 * SMB_COM_NT_CANCEL request and then sends it.
495 */
496static int
497send_nt_cancel(struct TCP_Server_Info *server, struct smb_hdr *in_buf,
498 struct mid_q_entry *mid)
499{
500 int rc = 0;
501
502 /* -4 for RFC1001 length and +2 for BCC field */
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000503 in_buf->smb_buf_length = cpu_to_be32(sizeof(struct smb_hdr) - 4 + 2);
Jeff Layton76dcc262011-01-11 07:24:24 -0500504 in_buf->Command = SMB_COM_NT_CANCEL;
505 in_buf->WordCount = 0;
Jeff Layton820a8032011-05-04 08:05:26 -0400506 put_bcc(0, in_buf);
Jeff Layton76dcc262011-01-11 07:24:24 -0500507
508 mutex_lock(&server->srv_mutex);
509 rc = cifs_sign_smb(in_buf, server, &mid->sequence_number);
510 if (rc) {
511 mutex_unlock(&server->srv_mutex);
512 return rc;
513 }
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000514 rc = smb_send(server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
Jeff Layton76dcc262011-01-11 07:24:24 -0500515 mutex_unlock(&server->srv_mutex);
516
517 cFYI(1, "issued NT_CANCEL for mid %u, rc = %d",
518 in_buf->Mid, rc);
519
520 return rc;
521}
522
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523int
Jeff Layton2c8f9812011-05-19 16:22:52 -0400524cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
525 bool log_error)
526{
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400527 unsigned int len = get_rfc1002_length(mid->resp_buf) + 4;
Jeff Layton826a95e2011-10-11 06:41:32 -0400528
529 dump_smb(mid->resp_buf, min_t(u32, 92, len));
Jeff Layton2c8f9812011-05-19 16:22:52 -0400530
531 /* convert the length into a more usable form */
Steve French96daf2b2011-05-27 04:34:02 +0000532 if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
Jeff Layton826a95e2011-10-11 06:41:32 -0400533 struct kvec iov;
534
535 iov.iov_base = mid->resp_buf;
536 iov.iov_len = len;
Jeff Layton2c8f9812011-05-19 16:22:52 -0400537 /* FIXME: add code to kill session */
Jeff Layton826a95e2011-10-11 06:41:32 -0400538 if (cifs_verify_signature(&iov, 1, server,
Jeff Layton2c8f9812011-05-19 16:22:52 -0400539 mid->sequence_number + 1) != 0)
540 cERROR(1, "Unexpected SMB signature");
541 }
542
543 /* BB special case reconnect tid and uid here? */
544 return map_smb_to_linux_error(mid->resp_buf, log_error);
545}
546
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400547static int
548cifs_setup_request(struct cifs_ses *ses, struct kvec *iov,
549 unsigned int nvec, struct mid_q_entry **ret_mid)
550{
551 int rc;
552 struct smb_hdr *hdr = (struct smb_hdr *)iov[0].iov_base;
553 struct mid_q_entry *mid;
554
555 rc = allocate_mid(ses, hdr, &mid);
556 if (rc)
557 return rc;
558 rc = cifs_sign_smb2(iov, nvec, ses->server, &mid->sequence_number);
559 if (rc)
560 delete_mid(mid);
561 *ret_mid = mid;
562 return rc;
563}
564
Jeff Layton2c8f9812011-05-19 16:22:52 -0400565int
Steve French96daf2b2011-05-27 04:34:02 +0000566SendReceive2(const unsigned int xid, struct cifs_ses *ses,
Steve French79a58d12007-07-06 22:44:50 +0000567 struct kvec *iov, int n_vec, int *pRespBufType /* ret */,
Steve French133672e2007-11-13 22:41:37 +0000568 const int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569{
570 int rc = 0;
Steve French133672e2007-11-13 22:41:37 +0000571 int long_op;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500572 struct mid_q_entry *midQ;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400573 char *buf = iov[0].iov_base;
Steve French50c2f752007-07-13 00:33:32 +0000574
Steve French133672e2007-11-13 22:41:37 +0000575 long_op = flags & CIFS_TIMEOUT_MASK;
576
Steve Frenchec637e32005-12-12 20:53:18 -0800577 *pRespBufType = CIFS_NO_BUFFER; /* no response buf yet */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578
Steve French4b8f9302006-02-26 16:41:18 +0000579 if ((ses == NULL) || (ses->server == NULL)) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400580 cifs_small_buf_release(buf);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000581 cERROR(1, "Null session");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 return -EIO;
583 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584
Steve French79a58d12007-07-06 22:44:50 +0000585 if (ses->server->tcpStatus == CifsExiting) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400586 cifs_small_buf_release(buf);
Steve French31ca3bc2005-04-28 22:41:11 -0700587 return -ENOENT;
Steve French4b8f9302006-02-26 16:41:18 +0000588 }
Steve French31ca3bc2005-04-28 22:41:11 -0700589
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400590 /*
591 * Ensure that we do not send more than 50 overlapping requests
592 * to the same server. We may make this configurable later or
593 * use ses->maxReq.
594 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
Jeff Laytonc5797a92011-01-11 07:24:01 -0500596 rc = wait_for_free_request(ses->server, long_op);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000597 if (rc) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400598 cifs_small_buf_release(buf);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000599 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000601
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400602 /*
603 * Make sure that we sign in the same order that we send on this socket
604 * and avoid races inside tcp sendmsg code that could cause corruption
605 * of smb data.
606 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607
Jeff Layton72ca5452008-12-01 07:09:36 -0500608 mutex_lock(&ses->server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400610 rc = cifs_setup_request(ses, iov, n_vec, &midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000611 if (rc) {
Jeff Layton72ca5452008-12-01 07:09:36 -0500612 mutex_unlock(&ses->server->srv_mutex);
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400613 cifs_small_buf_release(buf);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000614 /* Update # of requests on wire to server */
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400615 cifs_add_credits(ses->server, 1);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000616 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400619 midQ->mid_state = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000620 cifs_in_send_inc(ses->server);
Jeff Layton0496e022008-12-30 12:39:16 -0500621 rc = smb_sendv(ses->server, iov, n_vec);
Steve French789e6662011-08-09 18:44:44 +0000622 cifs_in_send_dec(ses->server);
623 cifs_save_when_sent(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000624
Jeff Layton72ca5452008-12-01 07:09:36 -0500625 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000626
Jeff Layton2db7c582011-01-28 07:08:28 -0500627 if (rc < 0) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400628 cifs_small_buf_release(buf);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000629 goto out;
Jeff Layton2db7c582011-01-28 07:08:28 -0500630 }
Steve French4b8f9302006-02-26 16:41:18 +0000631
Jeff Layton2db7c582011-01-28 07:08:28 -0500632 if (long_op == CIFS_ASYNC_OP) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400633 cifs_small_buf_release(buf);
Steve French133672e2007-11-13 22:41:37 +0000634 goto out;
Jeff Layton2db7c582011-01-28 07:08:28 -0500635 }
Jeff Layton0ade6402011-01-11 07:24:02 -0500636
637 rc = wait_for_response(ses->server, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500638 if (rc != 0) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400639 send_nt_cancel(ses->server, (struct smb_hdr *)buf, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500640 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400641 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
Jeff Layton1be912d2011-01-28 07:08:28 -0500642 midQ->callback = DeleteMidQEntry;
643 spin_unlock(&GlobalMid_Lock);
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400644 cifs_small_buf_release(buf);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400645 cifs_add_credits(ses->server, 1);
Jeff Layton1be912d2011-01-28 07:08:28 -0500646 return rc;
647 }
648 spin_unlock(&GlobalMid_Lock);
649 }
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500650
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400651 cifs_small_buf_release(buf);
Jeff Layton2db7c582011-01-28 07:08:28 -0500652
Jeff Layton3c1105d2011-05-22 07:09:13 -0400653 rc = cifs_sync_mid_result(midQ, ses->server);
Jeff Layton053d5032011-01-11 07:24:02 -0500654 if (rc != 0) {
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400655 cifs_add_credits(ses->server, 1);
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500656 return rc;
657 }
Steve French50c2f752007-07-13 00:33:32 +0000658
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400659 if (!midQ->resp_buf || midQ->mid_state != MID_RESPONSE_RECEIVED) {
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500660 rc = -EIO;
Jeff Layton2c8f9812011-05-19 16:22:52 -0400661 cFYI(1, "Bad MID state?");
Steve French2b2bdfb2008-12-11 17:26:54 +0000662 goto out;
663 }
Steve French84afc292005-12-02 13:32:45 -0800664
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400665 buf = (char *)midQ->resp_buf;
666 iov[0].iov_base = buf;
667 iov[0].iov_len = get_rfc1002_length(buf) + 4;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400668 if (midQ->large_buf)
Jeff Layton2c8f9812011-05-19 16:22:52 -0400669 *pRespBufType = CIFS_LARGE_BUFFER;
670 else
671 *pRespBufType = CIFS_SMALL_BUFFER;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500672
Jeff Layton2c8f9812011-05-19 16:22:52 -0400673 rc = cifs_check_receive(midQ, ses->server, flags & CIFS_LOG_ERROR);
Steve French2b2bdfb2008-12-11 17:26:54 +0000674
Jeff Layton2c8f9812011-05-19 16:22:52 -0400675 /* mark it so buf will not be freed by delete_mid */
676 if ((flags & CIFS_NO_RESP) == 0)
677 midQ->resp_buf = NULL;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000678out:
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500679 delete_mid(midQ);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400680 cifs_add_credits(ses->server, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681
682 return rc;
683}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684
685int
Steve French96daf2b2011-05-27 04:34:02 +0000686SendReceive(const unsigned int xid, struct cifs_ses *ses,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
688 int *pbytes_returned, const int long_op)
689{
690 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 struct mid_q_entry *midQ;
692
693 if (ses == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000694 cERROR(1, "Null smb session");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 return -EIO;
696 }
Steve French79a58d12007-07-06 22:44:50 +0000697 if (ses->server == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000698 cERROR(1, "Null tcp session");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 return -EIO;
700 }
701
Steve French79a58d12007-07-06 22:44:50 +0000702 if (ses->server->tcpStatus == CifsExiting)
Steve French31ca3bc2005-04-28 22:41:11 -0700703 return -ENOENT;
704
Steve French79a58d12007-07-06 22:44:50 +0000705 /* Ensure that we do not send more than 50 overlapping requests
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 to the same server. We may make this configurable later or
707 use ses->maxReq */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000709 if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
710 MAX_CIFS_HDR_SIZE - 4) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000711 cERROR(1, "Illegal length, greater than maximum frame, %d",
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000712 be32_to_cpu(in_buf->smb_buf_length));
Volker Lendecke6d9c6d52008-12-08 20:50:24 +0000713 return -EIO;
714 }
715
Jeff Laytonc5797a92011-01-11 07:24:01 -0500716 rc = wait_for_free_request(ses->server, long_op);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000717 if (rc)
718 return rc;
719
Steve French79a58d12007-07-06 22:44:50 +0000720 /* make sure that we sign in the same order that we send on this socket
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 and avoid races inside tcp sendmsg code that could cause corruption
722 of smb data */
723
Jeff Layton72ca5452008-12-01 07:09:36 -0500724 mutex_lock(&ses->server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000726 rc = allocate_mid(ses, in_buf, &midQ);
727 if (rc) {
Jeff Layton72ca5452008-12-01 07:09:36 -0500728 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000729 /* Update # of requests on wire to server */
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400730 cifs_add_credits(ses->server, 1);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000731 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 }
733
Steve Frenchad009ac2005-04-28 22:41:05 -0700734 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
Volker Lendecke829049c2008-12-06 16:00:53 +0100735 if (rc) {
736 mutex_unlock(&ses->server->srv_mutex);
737 goto out;
738 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400740 midQ->mid_state = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000741
742 cifs_in_send_inc(ses->server);
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000743 rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
Steve French789e6662011-08-09 18:44:44 +0000744 cifs_in_send_dec(ses->server);
745 cifs_save_when_sent(midQ);
Jeff Layton72ca5452008-12-01 07:09:36 -0500746 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000747
Steve French79a58d12007-07-06 22:44:50 +0000748 if (rc < 0)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000749 goto out;
750
Jeff Layton0ade6402011-01-11 07:24:02 -0500751 if (long_op == CIFS_ASYNC_OP)
Steve French133672e2007-11-13 22:41:37 +0000752 goto out;
Jeff Layton0ade6402011-01-11 07:24:02 -0500753
754 rc = wait_for_response(ses->server, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500755 if (rc != 0) {
Jeff Layton2db7c582011-01-28 07:08:28 -0500756 send_nt_cancel(ses->server, in_buf, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500757 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400758 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
Jeff Layton1be912d2011-01-28 07:08:28 -0500759 /* no longer considered to be "in-flight" */
760 midQ->callback = DeleteMidQEntry;
761 spin_unlock(&GlobalMid_Lock);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400762 cifs_add_credits(ses->server, 1);
Jeff Layton1be912d2011-01-28 07:08:28 -0500763 return rc;
764 }
765 spin_unlock(&GlobalMid_Lock);
766 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767
Jeff Layton3c1105d2011-05-22 07:09:13 -0400768 rc = cifs_sync_mid_result(midQ, ses->server);
Jeff Layton053d5032011-01-11 07:24:02 -0500769 if (rc != 0) {
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400770 cifs_add_credits(ses->server, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 return rc;
772 }
Steve French50c2f752007-07-13 00:33:32 +0000773
Jeff Layton2c8f9812011-05-19 16:22:52 -0400774 if (!midQ->resp_buf || !out_buf ||
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400775 midQ->mid_state != MID_RESPONSE_RECEIVED) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 rc = -EIO;
Jeff Layton2c8f9812011-05-19 16:22:52 -0400777 cERROR(1, "Bad MID state?");
Steve French2b2bdfb2008-12-11 17:26:54 +0000778 goto out;
779 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400781 *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
Jeff Layton2c8f9812011-05-19 16:22:52 -0400782 memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
783 rc = cifs_check_receive(midQ, ses->server, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000784out:
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500785 delete_mid(midQ);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400786 cifs_add_credits(ses->server, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787
788 return rc;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000789}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000791/* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
792 blocking lock to return. */
793
794static int
Steve French96daf2b2011-05-27 04:34:02 +0000795send_lock_cancel(const unsigned int xid, struct cifs_tcon *tcon,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000796 struct smb_hdr *in_buf,
797 struct smb_hdr *out_buf)
798{
799 int bytes_returned;
Steve French96daf2b2011-05-27 04:34:02 +0000800 struct cifs_ses *ses = tcon->ses;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000801 LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
802
803 /* We just modify the current in_buf to change
804 the type of lock from LOCKING_ANDX_SHARED_LOCK
805 or LOCKING_ANDX_EXCLUSIVE_LOCK to
806 LOCKING_ANDX_CANCEL_LOCK. */
807
808 pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
809 pSMB->Timeout = 0;
810 pSMB->hdr.Mid = GetNextMid(ses->server);
811
812 return SendReceive(xid, ses, in_buf, out_buf,
Jeff Layton77499812011-01-11 07:24:23 -0500813 &bytes_returned, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000814}
815
816int
Steve French96daf2b2011-05-27 04:34:02 +0000817SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000818 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
819 int *pbytes_returned)
820{
821 int rc = 0;
822 int rstart = 0;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000823 struct mid_q_entry *midQ;
Steve French96daf2b2011-05-27 04:34:02 +0000824 struct cifs_ses *ses;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000825
826 if (tcon == NULL || tcon->ses == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000827 cERROR(1, "Null smb session");
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000828 return -EIO;
829 }
830 ses = tcon->ses;
831
Steve French79a58d12007-07-06 22:44:50 +0000832 if (ses->server == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000833 cERROR(1, "Null tcp session");
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000834 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 }
836
Steve French79a58d12007-07-06 22:44:50 +0000837 if (ses->server->tcpStatus == CifsExiting)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000838 return -ENOENT;
839
Steve French79a58d12007-07-06 22:44:50 +0000840 /* Ensure that we do not send more than 50 overlapping requests
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000841 to the same server. We may make this configurable later or
842 use ses->maxReq */
843
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000844 if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
845 MAX_CIFS_HDR_SIZE - 4) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000846 cERROR(1, "Illegal length, greater than maximum frame, %d",
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000847 be32_to_cpu(in_buf->smb_buf_length));
Volker Lendecke6d9c6d52008-12-08 20:50:24 +0000848 return -EIO;
849 }
850
Jeff Laytonc5797a92011-01-11 07:24:01 -0500851 rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000852 if (rc)
853 return rc;
854
Steve French79a58d12007-07-06 22:44:50 +0000855 /* make sure that we sign in the same order that we send on this socket
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000856 and avoid races inside tcp sendmsg code that could cause corruption
857 of smb data */
858
Jeff Layton72ca5452008-12-01 07:09:36 -0500859 mutex_lock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000860
861 rc = allocate_mid(ses, in_buf, &midQ);
862 if (rc) {
Jeff Layton72ca5452008-12-01 07:09:36 -0500863 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000864 return rc;
865 }
866
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000867 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
Volker Lendecke829049c2008-12-06 16:00:53 +0100868 if (rc) {
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500869 delete_mid(midQ);
Volker Lendecke829049c2008-12-06 16:00:53 +0100870 mutex_unlock(&ses->server->srv_mutex);
871 return rc;
872 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000873
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400874 midQ->mid_state = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000875 cifs_in_send_inc(ses->server);
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000876 rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
Steve French789e6662011-08-09 18:44:44 +0000877 cifs_in_send_dec(ses->server);
878 cifs_save_when_sent(midQ);
Jeff Layton72ca5452008-12-01 07:09:36 -0500879 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000880
Steve French79a58d12007-07-06 22:44:50 +0000881 if (rc < 0) {
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500882 delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000883 return rc;
884 }
885
886 /* Wait for a reply - allow signals to interrupt. */
887 rc = wait_event_interruptible(ses->server->response_q,
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400888 (!(midQ->mid_state == MID_REQUEST_SUBMITTED)) ||
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000889 ((ses->server->tcpStatus != CifsGood) &&
890 (ses->server->tcpStatus != CifsNew)));
891
892 /* Were we interrupted by a signal ? */
893 if ((rc == -ERESTARTSYS) &&
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400894 (midQ->mid_state == MID_REQUEST_SUBMITTED) &&
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000895 ((ses->server->tcpStatus == CifsGood) ||
896 (ses->server->tcpStatus == CifsNew))) {
897
898 if (in_buf->Command == SMB_COM_TRANSACTION2) {
899 /* POSIX lock. We send a NT_CANCEL SMB to cause the
900 blocking lock to return. */
Jeff Layton76dcc262011-01-11 07:24:24 -0500901 rc = send_nt_cancel(ses->server, in_buf, midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000902 if (rc) {
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500903 delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000904 return rc;
905 }
906 } else {
907 /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
908 to cause the blocking lock to return. */
909
910 rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
911
912 /* If we get -ENOLCK back the lock may have
913 already been removed. Don't exit in this case. */
914 if (rc && rc != -ENOLCK) {
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500915 delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000916 return rc;
917 }
918 }
919
Jeff Layton1be912d2011-01-28 07:08:28 -0500920 rc = wait_for_response(ses->server, midQ);
921 if (rc) {
Jeff Layton2db7c582011-01-28 07:08:28 -0500922 send_nt_cancel(ses->server, in_buf, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500923 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400924 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
Jeff Layton1be912d2011-01-28 07:08:28 -0500925 /* no longer considered to be "in-flight" */
926 midQ->callback = DeleteMidQEntry;
927 spin_unlock(&GlobalMid_Lock);
928 return rc;
929 }
930 spin_unlock(&GlobalMid_Lock);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000931 }
Jeff Layton1be912d2011-01-28 07:08:28 -0500932
933 /* We got the response - restart system call. */
934 rstart = 1;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000935 }
936
Jeff Layton3c1105d2011-05-22 07:09:13 -0400937 rc = cifs_sync_mid_result(midQ, ses->server);
Jeff Layton053d5032011-01-11 07:24:02 -0500938 if (rc != 0)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000939 return rc;
Steve French50c2f752007-07-13 00:33:32 +0000940
Volker Lendecke17c8bfe2008-12-06 16:38:19 +0100941 /* rcvd frame is ok */
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400942 if (out_buf == NULL || midQ->mid_state != MID_RESPONSE_RECEIVED) {
Volker Lendecke17c8bfe2008-12-06 16:38:19 +0100943 rc = -EIO;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000944 cERROR(1, "Bad MID state?");
Volker Lendecke698e96a2008-12-06 16:39:31 +0100945 goto out;
Volker Lendecke17c8bfe2008-12-06 16:38:19 +0100946 }
947
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400948 *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
Jeff Layton2c8f9812011-05-19 16:22:52 -0400949 memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
950 rc = cifs_check_receive(midQ, ses->server, 0);
Volker Lendecke17c8bfe2008-12-06 16:38:19 +0100951out:
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500952 delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000953 if (rstart && rc == -EACCES)
954 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 return rc;
956}