blob: 87abe8ed074c31962a969b178d55757e44bdc0d5 [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>
Jeff Laytonb8eed282012-09-18 16:20:35 -070030#include <linux/tcp.h>
Jeff Layton97bc00b2012-09-18 16:20:35 -070031#include <linux/highmem.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <asm/uaccess.h>
33#include <asm/processor.h>
34#include <linux/mempool.h>
35#include "cifspdu.h"
36#include "cifsglob.h"
37#include "cifsproto.h"
38#include "cifs_debug.h"
Steve French50c2f752007-07-13 00:33:32 +000039
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +040040void
41cifs_wake_up_task(struct mid_q_entry *mid)
Jeff Layton2b84a36c2011-01-11 07:24:21 -050042{
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 Perchesf96637b2013-05-04 22:12:25 -050052 cifs_dbg(VFS, "Null TCP session in AllocMidQEntry\n");
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));
Tim Gardner3d378d32013-11-02 12:50:34 -050061 temp->mid = get_mid(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 temp->pid = current->pid;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -040063 temp->command = cpu_to_le16(smb_buffer->Command);
Joe Perchesf96637b2013-05-04 22:12:25 -050064 cifs_dbg(FYI, "For smb_command %d\n", 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;
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +040068 temp->server = server;
Jeff Layton2b84a36c2011-01-11 07:24:21 -050069
70 /*
71 * The default is for the mid to be synchronous, so the
72 * default callback just wakes up the current task.
73 */
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +040074 temp->callback = cifs_wake_up_task;
Jeff Layton2b84a36c2011-01-11 07:24:21 -050075 temp->callback_data = current;
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 }
77
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 atomic_inc(&midCount);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -040079 temp->mid_state = MID_REQUEST_ALLOCATED;
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 return temp;
81}
82
Jeff Layton766fdbb2011-01-11 07:24:21 -050083void
Linus Torvalds1da177e2005-04-16 15:20:36 -070084DeleteMidQEntry(struct mid_q_entry *midEntry)
85{
Steve French1047abc2005-10-11 19:58:06 -070086#ifdef CONFIG_CIFS_STATS2
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +040087 __le16 command = midEntry->server->vals->lock_cmd;
Steve French1047abc2005-10-11 19:58:06 -070088 unsigned long now;
89#endif
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -040090 midEntry->mid_state = MID_FREE;
Jeff Layton80975312011-01-11 07:24:02 -050091 atomic_dec(&midCount);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -040092 if (midEntry->large_buf)
Steve Frenchb8643e12005-04-28 22:41:07 -070093 cifs_buf_release(midEntry->resp_buf);
94 else
95 cifs_small_buf_release(midEntry->resp_buf);
Steve French1047abc2005-10-11 19:58:06 -070096#ifdef CONFIG_CIFS_STATS2
97 now = jiffies;
98 /* commands taking longer than one second are indications that
99 something is wrong, unless it is quite a slow link or server */
Steve French79a58d12007-07-06 22:44:50 +0000100 if ((now - midEntry->when_alloc) > HZ) {
Pavel Shilovsky2dc7e1c2011-12-26 22:53:34 +0400101 if ((cifsFYI & CIFS_TIMER) && (midEntry->command != command)) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +0300102 pr_debug(" CIFS slow rsp: cmd %d mid %llu",
Steve French1047abc2005-10-11 19:58:06 -0700103 midEntry->command, midEntry->mid);
Andy Shevchenko0b456f02014-08-27 16:49:44 +0300104 pr_info(" A: 0x%lx S: 0x%lx R: 0x%lx\n",
Steve French1047abc2005-10-11 19:58:06 -0700105 now - midEntry->when_alloc,
106 now - midEntry->when_sent,
107 now - midEntry->when_received);
108 }
109 }
110#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 mempool_free(midEntry, cifs_mid_poolp);
112}
113
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700114void
115cifs_delete_mid(struct mid_q_entry *mid)
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500116{
117 spin_lock(&GlobalMid_Lock);
118 list_del(&mid->qhead);
119 spin_unlock(&GlobalMid_Lock);
120
121 DeleteMidQEntry(mid);
122}
123
Jeff Layton6f49f462012-09-18 16:20:34 -0700124/*
125 * smb_send_kvec - send an array of kvecs to the server
126 * @server: Server to send the data to
127 * @iov: Pointer to array of kvecs
128 * @n_vec: length of kvec array
129 * @sent: amount of data sent on socket is stored here
130 *
131 * Our basic "send data to server" function. Should be called with srv_mutex
132 * held. The caller is responsible for handling the results.
133 */
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500134static int
Jeff Layton6f49f462012-09-18 16:20:34 -0700135smb_send_kvec(struct TCP_Server_Info *server, struct kvec *iov, size_t n_vec,
136 size_t *sent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137{
138 int rc = 0;
139 int i = 0;
140 struct msghdr smb_msg;
Jeff Layton6f49f462012-09-18 16:20:34 -0700141 unsigned int remaining;
142 size_t first_vec = 0;
Steve Frenchedf1ae42008-10-29 00:47:57 +0000143 struct socket *ssocket = server->ssocket;
Steve French50c2f752007-07-13 00:33:32 +0000144
Jeff Layton6f49f462012-09-18 16:20:34 -0700145 *sent = 0;
146
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300147 smb_msg.msg_name = (struct sockaddr *) &server->dstaddr;
Steve French26f57362007-08-30 22:09:15 +0000148 smb_msg.msg_namelen = sizeof(struct sockaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 smb_msg.msg_control = NULL;
150 smb_msg.msg_controllen = 0;
Jeff Layton0496e022008-12-30 12:39:16 -0500151 if (server->noblocksnd)
Steve Frenchedf1ae42008-10-29 00:47:57 +0000152 smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL;
153 else
154 smb_msg.msg_flags = MSG_NOSIGNAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155
Jeff Layton6f49f462012-09-18 16:20:34 -0700156 remaining = 0;
Steve French3e844692005-10-03 13:37:24 -0700157 for (i = 0; i < n_vec; i++)
Jeff Layton6f49f462012-09-18 16:20:34 -0700158 remaining += iov[i].iov_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159
Shirish Pargaonkar17680352008-07-29 21:26:13 +0000160 i = 0;
Jeff Layton6f49f462012-09-18 16:20:34 -0700161 while (remaining) {
162 /*
163 * If blocking send, we try 3 times, since each can block
164 * for 5 seconds. For nonblocking we have to try more
165 * but wait increasing amounts of time allowing time for
166 * socket to clear. The overall time we wait in either
167 * case to send on the socket is about 15 seconds.
168 * Similarly we wait for 15 seconds for a response from
169 * the server in SendReceive[2] for the server to send
170 * a response back for most types of requests (except
171 * SMB Write past end of file which can be slow, and
172 * blocking lock operations). NFS waits slightly longer
173 * than CIFS, but this can make it take longer for
174 * nonresponsive servers to be detected and 15 seconds
175 * is more than enough time for modern networks to
176 * send a packet. In most cases if we fail to send
177 * after the retries we will kill the socket and
178 * reconnect which may clear the network problem.
179 */
Steve French3e844692005-10-03 13:37:24 -0700180 rc = kernel_sendmsg(ssocket, &smb_msg, &iov[first_vec],
Jeff Layton6f49f462012-09-18 16:20:34 -0700181 n_vec - first_vec, remaining);
Jeff Laytonce6c44e2013-03-22 08:36:45 -0400182 if (rc == -EAGAIN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 i++;
Jeff Layton6f49f462012-09-18 16:20:34 -0700184 if (i >= 14 || (!server->noblocksnd && (i > 2))) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500185 cifs_dbg(VFS, "sends on sock %p stuck for 15 seconds\n",
186 ssocket);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 rc = -EAGAIN;
188 break;
189 }
Steve French68058e72005-10-10 10:34:22 -0700190 msleep(1 << i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 continue;
192 }
Jeff Layton6f49f462012-09-18 16:20:34 -0700193
Steve French79a58d12007-07-06 22:44:50 +0000194 if (rc < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 break;
Steve French3e844692005-10-03 13:37:24 -0700196
Jeff Layton6f49f462012-09-18 16:20:34 -0700197 /* send was at least partially successful */
198 *sent += rc;
199
200 if (rc == remaining) {
201 remaining = 0;
Steve French3e844692005-10-03 13:37:24 -0700202 break;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500203 }
Jeff Layton6f49f462012-09-18 16:20:34 -0700204
205 if (rc > remaining) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500206 cifs_dbg(VFS, "sent %d requested %d\n", rc, remaining);
Jeff Layton6f49f462012-09-18 16:20:34 -0700207 break;
208 }
209
Steve French79a58d12007-07-06 22:44:50 +0000210 if (rc == 0) {
Steve French3e844692005-10-03 13:37:24 -0700211 /* should never happen, letting socket clear before
212 retrying is our only obvious option here */
Joe Perchesf96637b2013-05-04 22:12:25 -0500213 cifs_dbg(VFS, "tcp sent no data\n");
Steve French3e844692005-10-03 13:37:24 -0700214 msleep(500);
215 continue;
216 }
Jeff Layton6f49f462012-09-18 16:20:34 -0700217
218 remaining -= rc;
219
Steve French68058e72005-10-10 10:34:22 -0700220 /* the line below resets i */
Steve French3e844692005-10-03 13:37:24 -0700221 for (i = first_vec; i < n_vec; i++) {
222 if (iov[i].iov_len) {
223 if (rc > iov[i].iov_len) {
224 rc -= iov[i].iov_len;
225 iov[i].iov_len = 0;
226 } else {
227 iov[i].iov_base += rc;
228 iov[i].iov_len -= rc;
229 first_vec = i;
230 break;
231 }
232 }
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500233 }
Jeff Layton6f49f462012-09-18 16:20:34 -0700234
Steve French5e1253b2005-10-10 14:06:37 -0700235 i = 0; /* in case we get ENOSPC on the next send */
Jeff Layton6f49f462012-09-18 16:20:34 -0700236 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 }
Jeff Layton6f49f462012-09-18 16:20:34 -0700238 return rc;
239}
240
Jeff Layton97bc00b2012-09-18 16:20:35 -0700241/**
242 * rqst_page_to_kvec - Turn a slot in the smb_rqst page array into a kvec
243 * @rqst: pointer to smb_rqst
244 * @idx: index into the array of the page
245 * @iov: pointer to struct kvec that will hold the result
246 *
247 * Helper function to convert a slot in the rqst->rq_pages array into a kvec.
248 * The page will be kmapped and the address placed into iov_base. The length
249 * will then be adjusted according to the ptailoff.
250 */
Jeff Laytonfb308a62012-09-18 16:20:35 -0700251void
Jeff Layton97bc00b2012-09-18 16:20:35 -0700252cifs_rqst_page_to_kvec(struct smb_rqst *rqst, unsigned int idx,
253 struct kvec *iov)
254{
255 /*
256 * FIXME: We could avoid this kmap altogether if we used
257 * kernel_sendpage instead of kernel_sendmsg. That will only
258 * work if signing is disabled though as sendpage inlines the
259 * page directly into the fraglist. If userspace modifies the
260 * page after we calculate the signature, then the server will
261 * reject it and may break the connection. kernel_sendmsg does
262 * an extra copy of the data and avoids that issue.
263 */
264 iov->iov_base = kmap(rqst->rq_pages[idx]);
265
266 /* if last page, don't send beyond this offset into page */
267 if (idx == (rqst->rq_npages - 1))
268 iov->iov_len = rqst->rq_tailsz;
269 else
270 iov->iov_len = rqst->rq_pagesz;
271}
272
Jeff Laytona26054d2014-02-14 07:21:00 -0500273static unsigned long
274rqst_len(struct smb_rqst *rqst)
275{
276 unsigned int i;
277 struct kvec *iov = rqst->rq_iov;
278 unsigned long buflen = 0;
279
280 /* total up iov array first */
281 for (i = 0; i < rqst->rq_nvec; i++)
282 buflen += iov[i].iov_len;
283
284 /* add in the page array if there is one */
285 if (rqst->rq_npages) {
286 buflen += rqst->rq_pagesz * (rqst->rq_npages - 1);
287 buflen += rqst->rq_tailsz;
288 }
289
290 return buflen;
291}
292
Jeff Layton6f49f462012-09-18 16:20:34 -0700293static int
294smb_send_rqst(struct TCP_Server_Info *server, struct smb_rqst *rqst)
295{
296 int rc;
297 struct kvec *iov = rqst->rq_iov;
298 int n_vec = rqst->rq_nvec;
299 unsigned int smb_buf_length = get_rfc1002_length(iov[0].iov_base);
Jeff Laytona26054d2014-02-14 07:21:00 -0500300 unsigned long send_length;
Jeff Layton97bc00b2012-09-18 16:20:35 -0700301 unsigned int i;
302 size_t total_len = 0, sent;
Jeff Laytonb8eed282012-09-18 16:20:35 -0700303 struct socket *ssocket = server->ssocket;
304 int val = 1;
Jeff Layton6f49f462012-09-18 16:20:34 -0700305
Jeff Laytonea702b82012-12-27 07:28:55 -0500306 if (ssocket == NULL)
307 return -ENOTSOCK;
308
Jeff Laytona26054d2014-02-14 07:21:00 -0500309 /* sanity check send length */
310 send_length = rqst_len(rqst);
311 if (send_length != smb_buf_length + 4) {
312 WARN(1, "Send length mismatch(send_length=%lu smb_buf_length=%u)\n",
313 send_length, smb_buf_length);
314 return -EIO;
315 }
316
Joe Perchesf96637b2013-05-04 22:12:25 -0500317 cifs_dbg(FYI, "Sending smb: smb_len=%u\n", smb_buf_length);
Jeff Layton6f49f462012-09-18 16:20:34 -0700318 dump_smb(iov[0].iov_base, iov[0].iov_len);
319
Jeff Laytonb8eed282012-09-18 16:20:35 -0700320 /* cork the socket */
321 kernel_setsockopt(ssocket, SOL_TCP, TCP_CORK,
322 (char *)&val, sizeof(val));
323
Jeff Layton97bc00b2012-09-18 16:20:35 -0700324 rc = smb_send_kvec(server, iov, n_vec, &sent);
325 if (rc < 0)
326 goto uncork;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
Jeff Layton97bc00b2012-09-18 16:20:35 -0700328 total_len += sent;
329
330 /* now walk the page array and send each page in it */
331 for (i = 0; i < rqst->rq_npages; i++) {
332 struct kvec p_iov;
333
334 cifs_rqst_page_to_kvec(rqst, i, &p_iov);
335 rc = smb_send_kvec(server, &p_iov, 1, &sent);
336 kunmap(rqst->rq_pages[i]);
337 if (rc < 0)
338 break;
339
340 total_len += sent;
341 }
342
343uncork:
Jeff Laytonb8eed282012-09-18 16:20:35 -0700344 /* uncork it */
345 val = 0;
346 kernel_setsockopt(ssocket, SOL_TCP, TCP_CORK,
347 (char *)&val, sizeof(val));
348
Steve Frenchedf1ae42008-10-29 00:47:57 +0000349 if ((total_len > 0) && (total_len != smb_buf_length + 4)) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500350 cifs_dbg(FYI, "partial send (wanted=%u sent=%zu): terminating session\n",
351 smb_buf_length + 4, total_len);
Jeff Layton6f49f462012-09-18 16:20:34 -0700352 /*
353 * If we have only sent part of an SMB then the next SMB could
354 * be taken as the remainder of this one. We need to kill the
355 * socket so the server throws away the partial SMB
356 */
Steve Frenchedf1ae42008-10-29 00:47:57 +0000357 server->tcpStatus = CifsNeedReconnect;
358 }
359
Jeff Laytond804d412011-01-28 15:05:43 -0500360 if (rc < 0 && rc != -EINTR)
Joe Perchesf96637b2013-05-04 22:12:25 -0500361 cifs_dbg(VFS, "Error %d sending data on socket to server\n",
362 rc);
Jeff Laytond804d412011-01-28 15:05:43 -0500363 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365
366 return rc;
367}
368
Jeff Layton6f49f462012-09-18 16:20:34 -0700369static int
370smb_sendv(struct TCP_Server_Info *server, struct kvec *iov, int n_vec)
371{
372 struct smb_rqst rqst = { .rq_iov = iov,
373 .rq_nvec = n_vec };
374
375 return smb_send_rqst(server, &rqst);
376}
377
Jeff Layton0496e022008-12-30 12:39:16 -0500378int
379smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer,
380 unsigned int smb_buf_length)
381{
382 struct kvec iov;
383
384 iov.iov_base = smb_buffer;
385 iov.iov_len = smb_buf_length + 4;
386
387 return smb_sendv(server, &iov, 1);
388}
389
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300390static int
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400391wait_for_free_credits(struct TCP_Server_Info *server, const int timeout,
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300392 int *credits)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000393{
Pavel Shilovsky5bc59492012-02-21 19:56:08 +0300394 int rc;
395
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300396 spin_lock(&server->req_lock);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400397 if (timeout == CIFS_ASYNC_OP) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000398 /* oplock breaks must not be held up */
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300399 server->in_flight++;
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300400 *credits -= 1;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300401 spin_unlock(&server->req_lock);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000402 return 0;
403 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000404
Volker Lendecke27a97a62008-12-08 20:59:39 +0000405 while (1) {
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300406 if (*credits <= 0) {
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300407 spin_unlock(&server->req_lock);
Steve French789e6662011-08-09 18:44:44 +0000408 cifs_num_waiters_inc(server);
Pavel Shilovsky5bc59492012-02-21 19:56:08 +0300409 rc = wait_event_killable(server->request_q,
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300410 has_credits(server, credits));
Steve French789e6662011-08-09 18:44:44 +0000411 cifs_num_waiters_dec(server);
Pavel Shilovsky5bc59492012-02-21 19:56:08 +0300412 if (rc)
413 return rc;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300414 spin_lock(&server->req_lock);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000415 } else {
Jeff Laytonc5797a92011-01-11 07:24:01 -0500416 if (server->tcpStatus == CifsExiting) {
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300417 spin_unlock(&server->req_lock);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000418 return -ENOENT;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000419 }
Volker Lendecke27a97a62008-12-08 20:59:39 +0000420
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400421 /*
422 * Can not count locking commands against total
423 * as they are allowed to block on server.
424 */
Volker Lendecke27a97a62008-12-08 20:59:39 +0000425
426 /* update # of requests on the wire to server */
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400427 if (timeout != CIFS_BLOCKING_OP) {
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300428 *credits -= 1;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300429 server->in_flight++;
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400430 }
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300431 spin_unlock(&server->req_lock);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000432 break;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000433 }
434 }
435 return 0;
436}
437
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300438static int
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400439wait_for_free_request(struct TCP_Server_Info *server, const int timeout,
440 const int optype)
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300441{
Shirish Pargaonkareb4c7df2013-10-03 05:44:45 -0500442 int *val;
443
444 val = server->ops->get_credits_field(server, optype);
445 /* Since an echo is already inflight, no need to wait to send another */
446 if (*val <= 0 && optype == CIFS_ECHO_OP)
447 return -EAGAIN;
448 return wait_for_free_credits(server, timeout, val);
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300449}
450
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +0400451int
452cifs_wait_mtu_credits(struct TCP_Server_Info *server, unsigned int size,
453 unsigned int *num, unsigned int *credits)
454{
455 *num = size;
456 *credits = 0;
457 return 0;
458}
459
Steve French96daf2b2011-05-27 04:34:02 +0000460static int allocate_mid(struct cifs_ses *ses, struct smb_hdr *in_buf,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000461 struct mid_q_entry **ppmidQ)
462{
463 if (ses->server->tcpStatus == CifsExiting) {
464 return -ENOENT;
Volker Lendecke8fbbd362008-12-06 13:12:34 +0100465 }
466
467 if (ses->server->tcpStatus == CifsNeedReconnect) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500468 cifs_dbg(FYI, "tcp session dead - return to caller to retry\n");
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000469 return -EAGAIN;
Volker Lendecke8fbbd362008-12-06 13:12:34 +0100470 }
471
Shirish Pargaonkar7f485582013-10-12 10:06:03 -0500472 if (ses->status == CifsNew) {
Steve French79a58d12007-07-06 22:44:50 +0000473 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
Steve Frenchad7a2922008-02-07 23:25:02 +0000474 (in_buf->Command != SMB_COM_NEGOTIATE))
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000475 return -EAGAIN;
Steve Frenchad7a2922008-02-07 23:25:02 +0000476 /* else ok - we are setting up session */
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000477 }
Shirish Pargaonkar7f485582013-10-12 10:06:03 -0500478
479 if (ses->status == CifsExiting) {
480 /* check if SMB session is bad because we are setting it up */
481 if (in_buf->Command != SMB_COM_LOGOFF_ANDX)
482 return -EAGAIN;
483 /* else ok - we are shutting down session */
484 }
485
Jeff Layton24b9b062008-12-01 07:09:34 -0500486 *ppmidQ = AllocMidQEntry(in_buf, ses->server);
Steve French26f57362007-08-30 22:09:15 +0000487 if (*ppmidQ == NULL)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000488 return -ENOMEM;
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500489 spin_lock(&GlobalMid_Lock);
490 list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);
491 spin_unlock(&GlobalMid_Lock);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000492 return 0;
493}
494
Jeff Layton0ade6402011-01-11 07:24:02 -0500495static int
496wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000497{
Jeff Layton0ade6402011-01-11 07:24:02 -0500498 int error;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000499
Colin Cross5853cc22013-05-07 17:52:05 +0000500 error = wait_event_freezekillable_unsafe(server->response_q,
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400501 midQ->mid_state != MID_REQUEST_SUBMITTED);
Jeff Layton0ade6402011-01-11 07:24:02 -0500502 if (error < 0)
503 return -ERESTARTSYS;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000504
Jeff Layton0ade6402011-01-11 07:24:02 -0500505 return 0;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000506}
507
Jeff Laytonfec344e2012-09-18 16:20:35 -0700508struct mid_q_entry *
509cifs_setup_async_request(struct TCP_Server_Info *server, struct smb_rqst *rqst)
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400510{
511 int rc;
Jeff Laytonfec344e2012-09-18 16:20:35 -0700512 struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400513 struct mid_q_entry *mid;
514
515 /* enable signing if server requires it */
Jeff Layton38d77c52013-05-26 07:01:00 -0400516 if (server->sign)
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400517 hdr->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
518
519 mid = AllocMidQEntry(hdr, server);
520 if (mid == NULL)
Jeff Laytonfec344e2012-09-18 16:20:35 -0700521 return ERR_PTR(-ENOMEM);
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400522
Jeff Laytonfec344e2012-09-18 16:20:35 -0700523 rc = cifs_sign_rqst(rqst, server, &mid->sequence_number);
Sachin Prabhuffc61cc2012-07-11 12:28:05 +0100524 if (rc) {
525 DeleteMidQEntry(mid);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700526 return ERR_PTR(rc);
Sachin Prabhuffc61cc2012-07-11 12:28:05 +0100527 }
528
Jeff Laytonfec344e2012-09-18 16:20:35 -0700529 return mid;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400530}
Steve French133672e2007-11-13 22:41:37 +0000531
532/*
Jeff Laytona6827c12011-01-11 07:24:21 -0500533 * Send a SMB request and set the callback function in the mid to handle
534 * the result. Caller is responsible for dealing with timeouts.
535 */
536int
Jeff Laytonfec344e2012-09-18 16:20:35 -0700537cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst,
538 mid_receive_t *receive, mid_callback_t *callback,
539 void *cbdata, const int flags)
Jeff Laytona6827c12011-01-11 07:24:21 -0500540{
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400541 int rc, timeout, optype;
Jeff Laytona6827c12011-01-11 07:24:21 -0500542 struct mid_q_entry *mid;
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +0400543 unsigned int credits = 0;
Jeff Laytona6827c12011-01-11 07:24:21 -0500544
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400545 timeout = flags & CIFS_TIMEOUT_MASK;
546 optype = flags & CIFS_OP_MASK;
547
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +0400548 if ((flags & CIFS_HAS_CREDITS) == 0) {
549 rc = wait_for_free_request(server, timeout, optype);
550 if (rc)
551 return rc;
552 credits = 1;
553 }
Jeff Laytona6827c12011-01-11 07:24:21 -0500554
555 mutex_lock(&server->srv_mutex);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700556 mid = server->ops->setup_async_request(server, rqst);
557 if (IS_ERR(mid)) {
Jeff Laytona6827c12011-01-11 07:24:21 -0500558 mutex_unlock(&server->srv_mutex);
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +0400559 add_credits_and_wake_if(server, credits, optype);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700560 return PTR_ERR(mid);
Jeff Laytona6827c12011-01-11 07:24:21 -0500561 }
562
Jeff Layton44d22d82011-10-19 15:29:49 -0400563 mid->receive = receive;
Jeff Laytona6827c12011-01-11 07:24:21 -0500564 mid->callback = callback;
565 mid->callback_data = cbdata;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400566 mid->mid_state = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000567
Sachin Prabhuffc61cc2012-07-11 12:28:05 +0100568 /* put it on the pending_mid_q */
569 spin_lock(&GlobalMid_Lock);
570 list_add_tail(&mid->qhead, &server->pending_mid_q);
571 spin_unlock(&GlobalMid_Lock);
572
573
Steve French789e6662011-08-09 18:44:44 +0000574 cifs_in_send_inc(server);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700575 rc = smb_send_rqst(server, rqst);
Steve French789e6662011-08-09 18:44:44 +0000576 cifs_in_send_dec(server);
577 cifs_save_when_sent(mid);
Jeff Laytonad313cb2013-04-03 10:27:36 -0400578
Rabin Vincent820962d2015-12-23 07:32:41 +0100579 if (rc < 0) {
Jeff Laytonad313cb2013-04-03 10:27:36 -0400580 server->sequence_number -= 2;
Rabin Vincent820962d2015-12-23 07:32:41 +0100581 cifs_delete_mid(mid);
582 }
583
Jeff Laytona6827c12011-01-11 07:24:21 -0500584 mutex_unlock(&server->srv_mutex);
Steve French789e6662011-08-09 18:44:44 +0000585
Sachin Prabhuffc61cc2012-07-11 12:28:05 +0100586 if (rc == 0)
587 return 0;
Jeff Laytona6827c12011-01-11 07:24:21 -0500588
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +0400589 add_credits_and_wake_if(server, credits, optype);
Jeff Laytona6827c12011-01-11 07:24:21 -0500590 return rc;
591}
592
593/*
Steve French133672e2007-11-13 22:41:37 +0000594 *
595 * Send an SMB Request. No response info (other than return code)
596 * needs to be parsed.
597 *
598 * flags indicate the type of request buffer and how long to wait
599 * and whether to log NT STATUS code (error) before mapping it to POSIX error
600 *
601 */
602int
Steve French96daf2b2011-05-27 04:34:02 +0000603SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400604 char *in_buf, int flags)
Steve French133672e2007-11-13 22:41:37 +0000605{
606 int rc;
607 struct kvec iov[1];
608 int resp_buf_type;
609
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400610 iov[0].iov_base = in_buf;
611 iov[0].iov_len = get_rfc1002_length(in_buf) + 4;
Steve French133672e2007-11-13 22:41:37 +0000612 flags |= CIFS_NO_RESP;
613 rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
Joe Perchesf96637b2013-05-04 22:12:25 -0500614 cifs_dbg(NOISY, "SendRcvNoRsp flags %d rc %d\n", flags, rc);
Steve French90c81e02008-02-12 20:32:36 +0000615
Steve French133672e2007-11-13 22:41:37 +0000616 return rc;
617}
618
Jeff Layton053d5032011-01-11 07:24:02 -0500619static int
Jeff Layton3c1105d2011-05-22 07:09:13 -0400620cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
Jeff Layton053d5032011-01-11 07:24:02 -0500621{
622 int rc = 0;
623
Joe Perchesf96637b2013-05-04 22:12:25 -0500624 cifs_dbg(FYI, "%s: cmd=%d mid=%llu state=%d\n",
625 __func__, le16_to_cpu(mid->command), mid->mid, mid->mid_state);
Jeff Layton053d5032011-01-11 07:24:02 -0500626
Jeff Layton74dd92a2011-01-11 07:24:02 -0500627 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400628 switch (mid->mid_state) {
Jeff Layton74dd92a2011-01-11 07:24:02 -0500629 case MID_RESPONSE_RECEIVED:
Jeff Layton053d5032011-01-11 07:24:02 -0500630 spin_unlock(&GlobalMid_Lock);
631 return rc;
Jeff Layton74dd92a2011-01-11 07:24:02 -0500632 case MID_RETRY_NEEDED:
633 rc = -EAGAIN;
634 break;
Jeff Layton71823ba2011-02-10 08:03:50 -0500635 case MID_RESPONSE_MALFORMED:
636 rc = -EIO;
637 break;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400638 case MID_SHUTDOWN:
639 rc = -EHOSTDOWN;
640 break;
Jeff Layton74dd92a2011-01-11 07:24:02 -0500641 default:
Jeff Layton3c1105d2011-05-22 07:09:13 -0400642 list_del_init(&mid->qhead);
Joe Perchesf96637b2013-05-04 22:12:25 -0500643 cifs_dbg(VFS, "%s: invalid mid state mid=%llu state=%d\n",
644 __func__, mid->mid, mid->mid_state);
Jeff Layton74dd92a2011-01-11 07:24:02 -0500645 rc = -EIO;
Jeff Layton053d5032011-01-11 07:24:02 -0500646 }
647 spin_unlock(&GlobalMid_Lock);
648
Christopher Oo5fb4e282015-06-25 16:10:48 -0700649 mutex_lock(&server->srv_mutex);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500650 DeleteMidQEntry(mid);
Christopher Oo5fb4e282015-06-25 16:10:48 -0700651 mutex_unlock(&server->srv_mutex);
Jeff Layton053d5032011-01-11 07:24:02 -0500652 return rc;
653}
654
Jeff Layton121b0462012-05-15 12:21:10 -0400655static inline int
656send_cancel(struct TCP_Server_Info *server, void *buf, struct mid_q_entry *mid)
Jeff Layton76dcc262011-01-11 07:24:24 -0500657{
Jeff Layton121b0462012-05-15 12:21:10 -0400658 return server->ops->send_cancel ?
659 server->ops->send_cancel(server, buf, mid) : 0;
Jeff Layton76dcc262011-01-11 07:24:24 -0500660}
661
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662int
Jeff Layton2c8f9812011-05-19 16:22:52 -0400663cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
664 bool log_error)
665{
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400666 unsigned int len = get_rfc1002_length(mid->resp_buf) + 4;
Jeff Layton826a95e2011-10-11 06:41:32 -0400667
668 dump_smb(mid->resp_buf, min_t(u32, 92, len));
Jeff Layton2c8f9812011-05-19 16:22:52 -0400669
670 /* convert the length into a more usable form */
Jeff Layton38d77c52013-05-26 07:01:00 -0400671 if (server->sign) {
Jeff Layton826a95e2011-10-11 06:41:32 -0400672 struct kvec iov;
Steve French985e4ff02012-08-03 09:42:45 -0500673 int rc = 0;
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700674 struct smb_rqst rqst = { .rq_iov = &iov,
675 .rq_nvec = 1 };
Jeff Layton826a95e2011-10-11 06:41:32 -0400676
677 iov.iov_base = mid->resp_buf;
678 iov.iov_len = len;
Jeff Layton2c8f9812011-05-19 16:22:52 -0400679 /* FIXME: add code to kill session */
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700680 rc = cifs_verify_signature(&rqst, server,
Jeff Layton0124cc42013-04-03 11:55:03 -0400681 mid->sequence_number);
Steve French985e4ff02012-08-03 09:42:45 -0500682 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500683 cifs_dbg(VFS, "SMB signature verification returned error = %d\n",
684 rc);
Jeff Layton2c8f9812011-05-19 16:22:52 -0400685 }
686
687 /* BB special case reconnect tid and uid here? */
688 return map_smb_to_linux_error(mid->resp_buf, log_error);
689}
690
Jeff Laytonfec344e2012-09-18 16:20:35 -0700691struct mid_q_entry *
692cifs_setup_request(struct cifs_ses *ses, struct smb_rqst *rqst)
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400693{
694 int rc;
Jeff Laytonfec344e2012-09-18 16:20:35 -0700695 struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400696 struct mid_q_entry *mid;
697
698 rc = allocate_mid(ses, hdr, &mid);
699 if (rc)
Jeff Laytonfec344e2012-09-18 16:20:35 -0700700 return ERR_PTR(rc);
701 rc = cifs_sign_rqst(rqst, ses->server, &mid->sequence_number);
702 if (rc) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700703 cifs_delete_mid(mid);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700704 return ERR_PTR(rc);
705 }
706 return mid;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400707}
708
Jeff Layton2c8f9812011-05-19 16:22:52 -0400709int
Steve French96daf2b2011-05-27 04:34:02 +0000710SendReceive2(const unsigned int xid, struct cifs_ses *ses,
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400711 struct kvec *iov, int n_vec, int *resp_buf_type /* ret */,
Steve French133672e2007-11-13 22:41:37 +0000712 const int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713{
714 int rc = 0;
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400715 int timeout, optype;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500716 struct mid_q_entry *midQ;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400717 char *buf = iov[0].iov_base;
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400718 unsigned int credits = 1;
Jeff Laytonfec344e2012-09-18 16:20:35 -0700719 struct smb_rqst rqst = { .rq_iov = iov,
720 .rq_nvec = n_vec };
Steve French50c2f752007-07-13 00:33:32 +0000721
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400722 timeout = flags & CIFS_TIMEOUT_MASK;
723 optype = flags & CIFS_OP_MASK;
Steve French133672e2007-11-13 22:41:37 +0000724
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400725 *resp_buf_type = CIFS_NO_BUFFER; /* no response buf yet */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726
Steve French4b8f9302006-02-26 16:41:18 +0000727 if ((ses == NULL) || (ses->server == NULL)) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400728 cifs_small_buf_release(buf);
Joe Perchesf96637b2013-05-04 22:12:25 -0500729 cifs_dbg(VFS, "Null session\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 return -EIO;
731 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732
Steve French79a58d12007-07-06 22:44:50 +0000733 if (ses->server->tcpStatus == CifsExiting) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400734 cifs_small_buf_release(buf);
Steve French31ca3bc2005-04-28 22:41:11 -0700735 return -ENOENT;
Steve French4b8f9302006-02-26 16:41:18 +0000736 }
Steve French31ca3bc2005-04-28 22:41:11 -0700737
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400738 /*
739 * Ensure that we do not send more than 50 overlapping requests
740 * to the same server. We may make this configurable later or
741 * use ses->maxReq.
742 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400744 rc = wait_for_free_request(ses->server, timeout, optype);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000745 if (rc) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400746 cifs_small_buf_release(buf);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000747 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000749
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400750 /*
751 * Make sure that we sign in the same order that we send on this socket
752 * and avoid races inside tcp sendmsg code that could cause corruption
753 * of smb data.
754 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755
Jeff Layton72ca5452008-12-01 07:09:36 -0500756 mutex_lock(&ses->server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757
Jeff Laytonfec344e2012-09-18 16:20:35 -0700758 midQ = ses->server->ops->setup_request(ses, &rqst);
759 if (IS_ERR(midQ)) {
Jeff Layton72ca5452008-12-01 07:09:36 -0500760 mutex_unlock(&ses->server->srv_mutex);
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400761 cifs_small_buf_release(buf);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000762 /* Update # of requests on wire to server */
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400763 add_credits(ses->server, 1, optype);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700764 return PTR_ERR(midQ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400767 midQ->mid_state = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000768 cifs_in_send_inc(ses->server);
Jeff Layton0496e022008-12-30 12:39:16 -0500769 rc = smb_sendv(ses->server, iov, n_vec);
Steve French789e6662011-08-09 18:44:44 +0000770 cifs_in_send_dec(ses->server);
771 cifs_save_when_sent(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000772
Jeff Laytonad313cb2013-04-03 10:27:36 -0400773 if (rc < 0)
774 ses->server->sequence_number -= 2;
Jeff Layton72ca5452008-12-01 07:09:36 -0500775 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000776
Jeff Layton2db7c582011-01-28 07:08:28 -0500777 if (rc < 0) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400778 cifs_small_buf_release(buf);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000779 goto out;
Jeff Layton2db7c582011-01-28 07:08:28 -0500780 }
Steve French4b8f9302006-02-26 16:41:18 +0000781
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400782 if (timeout == CIFS_ASYNC_OP) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400783 cifs_small_buf_release(buf);
Steve French133672e2007-11-13 22:41:37 +0000784 goto out;
Jeff Layton2db7c582011-01-28 07:08:28 -0500785 }
Jeff Layton0ade6402011-01-11 07:24:02 -0500786
787 rc = wait_for_response(ses->server, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500788 if (rc != 0) {
Jeff Layton121b0462012-05-15 12:21:10 -0400789 send_cancel(ses->server, buf, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500790 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400791 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
Jeff Layton1be912d2011-01-28 07:08:28 -0500792 midQ->callback = DeleteMidQEntry;
793 spin_unlock(&GlobalMid_Lock);
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400794 cifs_small_buf_release(buf);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400795 add_credits(ses->server, 1, optype);
Jeff Layton1be912d2011-01-28 07:08:28 -0500796 return rc;
797 }
798 spin_unlock(&GlobalMid_Lock);
799 }
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500800
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400801 cifs_small_buf_release(buf);
Jeff Layton2db7c582011-01-28 07:08:28 -0500802
Jeff Layton3c1105d2011-05-22 07:09:13 -0400803 rc = cifs_sync_mid_result(midQ, ses->server);
Jeff Layton053d5032011-01-11 07:24:02 -0500804 if (rc != 0) {
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400805 add_credits(ses->server, 1, optype);
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500806 return rc;
807 }
Steve French50c2f752007-07-13 00:33:32 +0000808
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400809 if (!midQ->resp_buf || midQ->mid_state != MID_RESPONSE_RECEIVED) {
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500810 rc = -EIO;
Joe Perchesf96637b2013-05-04 22:12:25 -0500811 cifs_dbg(FYI, "Bad MID state?\n");
Steve French2b2bdfb2008-12-11 17:26:54 +0000812 goto out;
813 }
Steve French84afc292005-12-02 13:32:45 -0800814
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400815 buf = (char *)midQ->resp_buf;
816 iov[0].iov_base = buf;
817 iov[0].iov_len = get_rfc1002_length(buf) + 4;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400818 if (midQ->large_buf)
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400819 *resp_buf_type = CIFS_LARGE_BUFFER;
Jeff Layton2c8f9812011-05-19 16:22:52 -0400820 else
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400821 *resp_buf_type = CIFS_SMALL_BUFFER;
822
823 credits = ses->server->ops->get_credits(midQ);
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500824
Pavel Shilovsky082d0642012-05-17 12:18:21 +0400825 rc = ses->server->ops->check_receive(midQ, ses->server,
826 flags & CIFS_LOG_ERROR);
Steve French2b2bdfb2008-12-11 17:26:54 +0000827
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700828 /* mark it so buf will not be freed by cifs_delete_mid */
Jeff Layton2c8f9812011-05-19 16:22:52 -0400829 if ((flags & CIFS_NO_RESP) == 0)
830 midQ->resp_buf = NULL;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000831out:
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700832 cifs_delete_mid(midQ);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400833 add_credits(ses->server, credits, optype);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834
835 return rc;
836}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
838int
Steve French96daf2b2011-05-27 04:34:02 +0000839SendReceive(const unsigned int xid, struct cifs_ses *ses,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400841 int *pbytes_returned, const int timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842{
843 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 struct mid_q_entry *midQ;
845
846 if (ses == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500847 cifs_dbg(VFS, "Null smb session\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 return -EIO;
849 }
Steve French79a58d12007-07-06 22:44:50 +0000850 if (ses->server == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500851 cifs_dbg(VFS, "Null tcp session\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 return -EIO;
853 }
854
Steve French79a58d12007-07-06 22:44:50 +0000855 if (ses->server->tcpStatus == CifsExiting)
Steve French31ca3bc2005-04-28 22:41:11 -0700856 return -ENOENT;
857
Steve French79a58d12007-07-06 22:44:50 +0000858 /* Ensure that we do not send more than 50 overlapping requests
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 to the same server. We may make this configurable later or
860 use ses->maxReq */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000862 if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
863 MAX_CIFS_HDR_SIZE - 4) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500864 cifs_dbg(VFS, "Illegal length, greater than maximum frame, %d\n",
865 be32_to_cpu(in_buf->smb_buf_length));
Volker Lendecke6d9c6d52008-12-08 20:50:24 +0000866 return -EIO;
867 }
868
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400869 rc = wait_for_free_request(ses->server, timeout, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000870 if (rc)
871 return rc;
872
Steve French79a58d12007-07-06 22:44:50 +0000873 /* make sure that we sign in the same order that we send on this socket
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 and avoid races inside tcp sendmsg code that could cause corruption
875 of smb data */
876
Jeff Layton72ca5452008-12-01 07:09:36 -0500877 mutex_lock(&ses->server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000879 rc = allocate_mid(ses, in_buf, &midQ);
880 if (rc) {
Jeff Layton72ca5452008-12-01 07:09:36 -0500881 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000882 /* Update # of requests on wire to server */
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400883 add_credits(ses->server, 1, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000884 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 }
886
Steve Frenchad009ac2005-04-28 22:41:05 -0700887 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
Volker Lendecke829049c2008-12-06 16:00:53 +0100888 if (rc) {
889 mutex_unlock(&ses->server->srv_mutex);
890 goto out;
891 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400893 midQ->mid_state = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000894
895 cifs_in_send_inc(ses->server);
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000896 rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
Steve French789e6662011-08-09 18:44:44 +0000897 cifs_in_send_dec(ses->server);
898 cifs_save_when_sent(midQ);
Jeff Laytonad313cb2013-04-03 10:27:36 -0400899
900 if (rc < 0)
901 ses->server->sequence_number -= 2;
902
Jeff Layton72ca5452008-12-01 07:09:36 -0500903 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000904
Steve French79a58d12007-07-06 22:44:50 +0000905 if (rc < 0)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000906 goto out;
907
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400908 if (timeout == CIFS_ASYNC_OP)
Steve French133672e2007-11-13 22:41:37 +0000909 goto out;
Jeff Layton0ade6402011-01-11 07:24:02 -0500910
911 rc = wait_for_response(ses->server, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500912 if (rc != 0) {
Jeff Layton121b0462012-05-15 12:21:10 -0400913 send_cancel(ses->server, in_buf, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500914 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400915 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
Jeff Layton1be912d2011-01-28 07:08:28 -0500916 /* no longer considered to be "in-flight" */
917 midQ->callback = DeleteMidQEntry;
918 spin_unlock(&GlobalMid_Lock);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400919 add_credits(ses->server, 1, 0);
Jeff Layton1be912d2011-01-28 07:08:28 -0500920 return rc;
921 }
922 spin_unlock(&GlobalMid_Lock);
923 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924
Jeff Layton3c1105d2011-05-22 07:09:13 -0400925 rc = cifs_sync_mid_result(midQ, ses->server);
Jeff Layton053d5032011-01-11 07:24:02 -0500926 if (rc != 0) {
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400927 add_credits(ses->server, 1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 return rc;
929 }
Steve French50c2f752007-07-13 00:33:32 +0000930
Jeff Layton2c8f9812011-05-19 16:22:52 -0400931 if (!midQ->resp_buf || !out_buf ||
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400932 midQ->mid_state != MID_RESPONSE_RECEIVED) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 rc = -EIO;
Joe Perchesf96637b2013-05-04 22:12:25 -0500934 cifs_dbg(VFS, "Bad MID state?\n");
Steve French2b2bdfb2008-12-11 17:26:54 +0000935 goto out;
936 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400938 *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
Jeff Layton2c8f9812011-05-19 16:22:52 -0400939 memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
940 rc = cifs_check_receive(midQ, ses->server, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000941out:
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700942 cifs_delete_mid(midQ);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400943 add_credits(ses->server, 1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944
945 return rc;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000946}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000948/* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
949 blocking lock to return. */
950
951static int
Steve French96daf2b2011-05-27 04:34:02 +0000952send_lock_cancel(const unsigned int xid, struct cifs_tcon *tcon,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000953 struct smb_hdr *in_buf,
954 struct smb_hdr *out_buf)
955{
956 int bytes_returned;
Steve French96daf2b2011-05-27 04:34:02 +0000957 struct cifs_ses *ses = tcon->ses;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000958 LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
959
960 /* We just modify the current in_buf to change
961 the type of lock from LOCKING_ANDX_SHARED_LOCK
962 or LOCKING_ANDX_EXCLUSIVE_LOCK to
963 LOCKING_ANDX_CANCEL_LOCK. */
964
965 pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
966 pSMB->Timeout = 0;
Pavel Shilovsky88257362012-05-23 14:01:59 +0400967 pSMB->hdr.Mid = get_next_mid(ses->server);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000968
969 return SendReceive(xid, ses, in_buf, out_buf,
Jeff Layton77499812011-01-11 07:24:23 -0500970 &bytes_returned, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000971}
972
973int
Steve French96daf2b2011-05-27 04:34:02 +0000974SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000975 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
976 int *pbytes_returned)
977{
978 int rc = 0;
979 int rstart = 0;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000980 struct mid_q_entry *midQ;
Steve French96daf2b2011-05-27 04:34:02 +0000981 struct cifs_ses *ses;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000982
983 if (tcon == NULL || tcon->ses == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500984 cifs_dbg(VFS, "Null smb session\n");
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000985 return -EIO;
986 }
987 ses = tcon->ses;
988
Steve French79a58d12007-07-06 22:44:50 +0000989 if (ses->server == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500990 cifs_dbg(VFS, "Null tcp session\n");
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000991 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 }
993
Steve French79a58d12007-07-06 22:44:50 +0000994 if (ses->server->tcpStatus == CifsExiting)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000995 return -ENOENT;
996
Steve French79a58d12007-07-06 22:44:50 +0000997 /* Ensure that we do not send more than 50 overlapping requests
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000998 to the same server. We may make this configurable later or
999 use ses->maxReq */
1000
Steve Frenchbe8e3b02011-04-29 05:40:20 +00001001 if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
1002 MAX_CIFS_HDR_SIZE - 4) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001003 cifs_dbg(VFS, "Illegal length, greater than maximum frame, %d\n",
1004 be32_to_cpu(in_buf->smb_buf_length));
Volker Lendecke6d9c6d52008-12-08 20:50:24 +00001005 return -EIO;
1006 }
1007
Pavel Shilovskya891f0f2012-05-23 16:14:34 +04001008 rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001009 if (rc)
1010 return rc;
1011
Steve French79a58d12007-07-06 22:44:50 +00001012 /* make sure that we sign in the same order that we send on this socket
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001013 and avoid races inside tcp sendmsg code that could cause corruption
1014 of smb data */
1015
Jeff Layton72ca5452008-12-01 07:09:36 -05001016 mutex_lock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001017
1018 rc = allocate_mid(ses, in_buf, &midQ);
1019 if (rc) {
Jeff Layton72ca5452008-12-01 07:09:36 -05001020 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001021 return rc;
1022 }
1023
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001024 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
Volker Lendecke829049c2008-12-06 16:00:53 +01001025 if (rc) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -07001026 cifs_delete_mid(midQ);
Volker Lendecke829049c2008-12-06 16:00:53 +01001027 mutex_unlock(&ses->server->srv_mutex);
1028 return rc;
1029 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001030
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001031 midQ->mid_state = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +00001032 cifs_in_send_inc(ses->server);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00001033 rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
Steve French789e6662011-08-09 18:44:44 +00001034 cifs_in_send_dec(ses->server);
1035 cifs_save_when_sent(midQ);
Jeff Laytonad313cb2013-04-03 10:27:36 -04001036
1037 if (rc < 0)
1038 ses->server->sequence_number -= 2;
1039
Jeff Layton72ca5452008-12-01 07:09:36 -05001040 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001041
Steve French79a58d12007-07-06 22:44:50 +00001042 if (rc < 0) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -07001043 cifs_delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001044 return rc;
1045 }
1046
1047 /* Wait for a reply - allow signals to interrupt. */
1048 rc = wait_event_interruptible(ses->server->response_q,
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001049 (!(midQ->mid_state == MID_REQUEST_SUBMITTED)) ||
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001050 ((ses->server->tcpStatus != CifsGood) &&
1051 (ses->server->tcpStatus != CifsNew)));
1052
1053 /* Were we interrupted by a signal ? */
1054 if ((rc == -ERESTARTSYS) &&
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001055 (midQ->mid_state == MID_REQUEST_SUBMITTED) &&
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001056 ((ses->server->tcpStatus == CifsGood) ||
1057 (ses->server->tcpStatus == CifsNew))) {
1058
1059 if (in_buf->Command == SMB_COM_TRANSACTION2) {
1060 /* POSIX lock. We send a NT_CANCEL SMB to cause the
1061 blocking lock to return. */
Jeff Layton121b0462012-05-15 12:21:10 -04001062 rc = send_cancel(ses->server, in_buf, midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001063 if (rc) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -07001064 cifs_delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001065 return rc;
1066 }
1067 } else {
1068 /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
1069 to cause the blocking lock to return. */
1070
1071 rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
1072
1073 /* If we get -ENOLCK back the lock may have
1074 already been removed. Don't exit in this case. */
1075 if (rc && rc != -ENOLCK) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -07001076 cifs_delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001077 return rc;
1078 }
1079 }
1080
Jeff Layton1be912d2011-01-28 07:08:28 -05001081 rc = wait_for_response(ses->server, midQ);
1082 if (rc) {
Jeff Layton121b0462012-05-15 12:21:10 -04001083 send_cancel(ses->server, in_buf, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -05001084 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001085 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
Jeff Layton1be912d2011-01-28 07:08:28 -05001086 /* no longer considered to be "in-flight" */
1087 midQ->callback = DeleteMidQEntry;
1088 spin_unlock(&GlobalMid_Lock);
1089 return rc;
1090 }
1091 spin_unlock(&GlobalMid_Lock);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001092 }
Jeff Layton1be912d2011-01-28 07:08:28 -05001093
1094 /* We got the response - restart system call. */
1095 rstart = 1;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001096 }
1097
Jeff Layton3c1105d2011-05-22 07:09:13 -04001098 rc = cifs_sync_mid_result(midQ, ses->server);
Jeff Layton053d5032011-01-11 07:24:02 -05001099 if (rc != 0)
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001100 return rc;
Steve French50c2f752007-07-13 00:33:32 +00001101
Volker Lendecke17c8bfe2008-12-06 16:38:19 +01001102 /* rcvd frame is ok */
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001103 if (out_buf == NULL || midQ->mid_state != MID_RESPONSE_RECEIVED) {
Volker Lendecke17c8bfe2008-12-06 16:38:19 +01001104 rc = -EIO;
Joe Perchesf96637b2013-05-04 22:12:25 -05001105 cifs_dbg(VFS, "Bad MID state?\n");
Volker Lendecke698e96a2008-12-06 16:39:31 +01001106 goto out;
Volker Lendecke17c8bfe2008-12-06 16:38:19 +01001107 }
1108
Pavel Shilovskyd4e48542012-03-23 14:28:02 -04001109 *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
Jeff Layton2c8f9812011-05-19 16:22:52 -04001110 memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
1111 rc = cifs_check_receive(midQ, ses->server, 0);
Volker Lendecke17c8bfe2008-12-06 16:38:19 +01001112out:
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -07001113 cifs_delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001114 if (rstart && rc == -EACCES)
1115 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 return rc;
1117}