blob: 9d087f4e7d4e3de1df68ad2f2d6e57e79d767b70 [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)) {
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400102 printk(KERN_DEBUG " CIFS slow rsp: cmd %d mid %llu",
Steve French1047abc2005-10-11 19:58:06 -0700103 midEntry->command, midEntry->mid);
104 printk(" A: 0x%lx S: 0x%lx R: 0x%lx\n",
105 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
579 if (rc < 0)
580 server->sequence_number -= 2;
Jeff Laytona6827c12011-01-11 07:24:21 -0500581 mutex_unlock(&server->srv_mutex);
Steve French789e6662011-08-09 18:44:44 +0000582
Sachin Prabhuffc61cc2012-07-11 12:28:05 +0100583 if (rc == 0)
584 return 0;
Jeff Laytona6827c12011-01-11 07:24:21 -0500585
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700586 cifs_delete_mid(mid);
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +0400587 add_credits_and_wake_if(server, credits, optype);
Jeff Laytona6827c12011-01-11 07:24:21 -0500588 return rc;
589}
590
591/*
Steve French133672e2007-11-13 22:41:37 +0000592 *
593 * Send an SMB Request. No response info (other than return code)
594 * needs to be parsed.
595 *
596 * flags indicate the type of request buffer and how long to wait
597 * and whether to log NT STATUS code (error) before mapping it to POSIX error
598 *
599 */
600int
Steve French96daf2b2011-05-27 04:34:02 +0000601SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400602 char *in_buf, int flags)
Steve French133672e2007-11-13 22:41:37 +0000603{
604 int rc;
605 struct kvec iov[1];
606 int resp_buf_type;
607
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400608 iov[0].iov_base = in_buf;
609 iov[0].iov_len = get_rfc1002_length(in_buf) + 4;
Steve French133672e2007-11-13 22:41:37 +0000610 flags |= CIFS_NO_RESP;
611 rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
Joe Perchesf96637b2013-05-04 22:12:25 -0500612 cifs_dbg(NOISY, "SendRcvNoRsp flags %d rc %d\n", flags, rc);
Steve French90c81e02008-02-12 20:32:36 +0000613
Steve French133672e2007-11-13 22:41:37 +0000614 return rc;
615}
616
Jeff Layton053d5032011-01-11 07:24:02 -0500617static int
Jeff Layton3c1105d2011-05-22 07:09:13 -0400618cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
Jeff Layton053d5032011-01-11 07:24:02 -0500619{
620 int rc = 0;
621
Joe Perchesf96637b2013-05-04 22:12:25 -0500622 cifs_dbg(FYI, "%s: cmd=%d mid=%llu state=%d\n",
623 __func__, le16_to_cpu(mid->command), mid->mid, mid->mid_state);
Jeff Layton053d5032011-01-11 07:24:02 -0500624
Jeff Layton74dd92a2011-01-11 07:24:02 -0500625 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400626 switch (mid->mid_state) {
Jeff Layton74dd92a2011-01-11 07:24:02 -0500627 case MID_RESPONSE_RECEIVED:
Jeff Layton053d5032011-01-11 07:24:02 -0500628 spin_unlock(&GlobalMid_Lock);
629 return rc;
Jeff Layton74dd92a2011-01-11 07:24:02 -0500630 case MID_RETRY_NEEDED:
631 rc = -EAGAIN;
632 break;
Jeff Layton71823ba2011-02-10 08:03:50 -0500633 case MID_RESPONSE_MALFORMED:
634 rc = -EIO;
635 break;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400636 case MID_SHUTDOWN:
637 rc = -EHOSTDOWN;
638 break;
Jeff Layton74dd92a2011-01-11 07:24:02 -0500639 default:
Jeff Layton3c1105d2011-05-22 07:09:13 -0400640 list_del_init(&mid->qhead);
Joe Perchesf96637b2013-05-04 22:12:25 -0500641 cifs_dbg(VFS, "%s: invalid mid state mid=%llu state=%d\n",
642 __func__, mid->mid, mid->mid_state);
Jeff Layton74dd92a2011-01-11 07:24:02 -0500643 rc = -EIO;
Jeff Layton053d5032011-01-11 07:24:02 -0500644 }
645 spin_unlock(&GlobalMid_Lock);
646
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500647 DeleteMidQEntry(mid);
Jeff Layton053d5032011-01-11 07:24:02 -0500648 return rc;
649}
650
Jeff Layton121b0462012-05-15 12:21:10 -0400651static inline int
652send_cancel(struct TCP_Server_Info *server, void *buf, struct mid_q_entry *mid)
Jeff Layton76dcc262011-01-11 07:24:24 -0500653{
Jeff Layton121b0462012-05-15 12:21:10 -0400654 return server->ops->send_cancel ?
655 server->ops->send_cancel(server, buf, mid) : 0;
Jeff Layton76dcc262011-01-11 07:24:24 -0500656}
657
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658int
Jeff Layton2c8f9812011-05-19 16:22:52 -0400659cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
660 bool log_error)
661{
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400662 unsigned int len = get_rfc1002_length(mid->resp_buf) + 4;
Jeff Layton826a95e2011-10-11 06:41:32 -0400663
664 dump_smb(mid->resp_buf, min_t(u32, 92, len));
Jeff Layton2c8f9812011-05-19 16:22:52 -0400665
666 /* convert the length into a more usable form */
Jeff Layton38d77c52013-05-26 07:01:00 -0400667 if (server->sign) {
Jeff Layton826a95e2011-10-11 06:41:32 -0400668 struct kvec iov;
Steve French985e4ff02012-08-03 09:42:45 -0500669 int rc = 0;
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700670 struct smb_rqst rqst = { .rq_iov = &iov,
671 .rq_nvec = 1 };
Jeff Layton826a95e2011-10-11 06:41:32 -0400672
673 iov.iov_base = mid->resp_buf;
674 iov.iov_len = len;
Jeff Layton2c8f9812011-05-19 16:22:52 -0400675 /* FIXME: add code to kill session */
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700676 rc = cifs_verify_signature(&rqst, server,
Jeff Layton0124cc42013-04-03 11:55:03 -0400677 mid->sequence_number);
Steve French985e4ff02012-08-03 09:42:45 -0500678 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500679 cifs_dbg(VFS, "SMB signature verification returned error = %d\n",
680 rc);
Jeff Layton2c8f9812011-05-19 16:22:52 -0400681 }
682
683 /* BB special case reconnect tid and uid here? */
684 return map_smb_to_linux_error(mid->resp_buf, log_error);
685}
686
Jeff Laytonfec344e2012-09-18 16:20:35 -0700687struct mid_q_entry *
688cifs_setup_request(struct cifs_ses *ses, struct smb_rqst *rqst)
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400689{
690 int rc;
Jeff Laytonfec344e2012-09-18 16:20:35 -0700691 struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400692 struct mid_q_entry *mid;
693
694 rc = allocate_mid(ses, hdr, &mid);
695 if (rc)
Jeff Laytonfec344e2012-09-18 16:20:35 -0700696 return ERR_PTR(rc);
697 rc = cifs_sign_rqst(rqst, ses->server, &mid->sequence_number);
698 if (rc) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700699 cifs_delete_mid(mid);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700700 return ERR_PTR(rc);
701 }
702 return mid;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400703}
704
Jeff Layton2c8f9812011-05-19 16:22:52 -0400705int
Steve French96daf2b2011-05-27 04:34:02 +0000706SendReceive2(const unsigned int xid, struct cifs_ses *ses,
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400707 struct kvec *iov, int n_vec, int *resp_buf_type /* ret */,
Steve French133672e2007-11-13 22:41:37 +0000708 const int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709{
710 int rc = 0;
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400711 int timeout, optype;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500712 struct mid_q_entry *midQ;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400713 char *buf = iov[0].iov_base;
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400714 unsigned int credits = 1;
Jeff Laytonfec344e2012-09-18 16:20:35 -0700715 struct smb_rqst rqst = { .rq_iov = iov,
716 .rq_nvec = n_vec };
Steve French50c2f752007-07-13 00:33:32 +0000717
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400718 timeout = flags & CIFS_TIMEOUT_MASK;
719 optype = flags & CIFS_OP_MASK;
Steve French133672e2007-11-13 22:41:37 +0000720
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400721 *resp_buf_type = CIFS_NO_BUFFER; /* no response buf yet */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722
Steve French4b8f9302006-02-26 16:41:18 +0000723 if ((ses == NULL) || (ses->server == NULL)) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400724 cifs_small_buf_release(buf);
Joe Perchesf96637b2013-05-04 22:12:25 -0500725 cifs_dbg(VFS, "Null session\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 return -EIO;
727 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
Steve French79a58d12007-07-06 22:44:50 +0000729 if (ses->server->tcpStatus == CifsExiting) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400730 cifs_small_buf_release(buf);
Steve French31ca3bc2005-04-28 22:41:11 -0700731 return -ENOENT;
Steve French4b8f9302006-02-26 16:41:18 +0000732 }
Steve French31ca3bc2005-04-28 22:41:11 -0700733
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400734 /*
735 * Ensure that we do not send more than 50 overlapping requests
736 * to the same server. We may make this configurable later or
737 * use ses->maxReq.
738 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400740 rc = wait_for_free_request(ses->server, timeout, optype);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000741 if (rc) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400742 cifs_small_buf_release(buf);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000743 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000745
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400746 /*
747 * Make sure that we sign in the same order that we send on this socket
748 * and avoid races inside tcp sendmsg code that could cause corruption
749 * of smb data.
750 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751
Jeff Layton72ca5452008-12-01 07:09:36 -0500752 mutex_lock(&ses->server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753
Jeff Laytonfec344e2012-09-18 16:20:35 -0700754 midQ = ses->server->ops->setup_request(ses, &rqst);
755 if (IS_ERR(midQ)) {
Jeff Layton72ca5452008-12-01 07:09:36 -0500756 mutex_unlock(&ses->server->srv_mutex);
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400757 cifs_small_buf_release(buf);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000758 /* Update # of requests on wire to server */
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400759 add_credits(ses->server, 1, optype);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700760 return PTR_ERR(midQ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400763 midQ->mid_state = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000764 cifs_in_send_inc(ses->server);
Jeff Layton0496e022008-12-30 12:39:16 -0500765 rc = smb_sendv(ses->server, iov, n_vec);
Steve French789e6662011-08-09 18:44:44 +0000766 cifs_in_send_dec(ses->server);
767 cifs_save_when_sent(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000768
Jeff Laytonad313cb2013-04-03 10:27:36 -0400769 if (rc < 0)
770 ses->server->sequence_number -= 2;
Jeff Layton72ca5452008-12-01 07:09:36 -0500771 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000772
Jeff Layton2db7c582011-01-28 07:08:28 -0500773 if (rc < 0) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400774 cifs_small_buf_release(buf);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000775 goto out;
Jeff Layton2db7c582011-01-28 07:08:28 -0500776 }
Steve French4b8f9302006-02-26 16:41:18 +0000777
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400778 if (timeout == CIFS_ASYNC_OP) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400779 cifs_small_buf_release(buf);
Steve French133672e2007-11-13 22:41:37 +0000780 goto out;
Jeff Layton2db7c582011-01-28 07:08:28 -0500781 }
Jeff Layton0ade6402011-01-11 07:24:02 -0500782
783 rc = wait_for_response(ses->server, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500784 if (rc != 0) {
Jeff Layton121b0462012-05-15 12:21:10 -0400785 send_cancel(ses->server, buf, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500786 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400787 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
Jeff Layton1be912d2011-01-28 07:08:28 -0500788 midQ->callback = DeleteMidQEntry;
789 spin_unlock(&GlobalMid_Lock);
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400790 cifs_small_buf_release(buf);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400791 add_credits(ses->server, 1, optype);
Jeff Layton1be912d2011-01-28 07:08:28 -0500792 return rc;
793 }
794 spin_unlock(&GlobalMid_Lock);
795 }
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500796
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400797 cifs_small_buf_release(buf);
Jeff Layton2db7c582011-01-28 07:08:28 -0500798
Jeff Layton3c1105d2011-05-22 07:09:13 -0400799 rc = cifs_sync_mid_result(midQ, ses->server);
Jeff Layton053d5032011-01-11 07:24:02 -0500800 if (rc != 0) {
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400801 add_credits(ses->server, 1, optype);
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500802 return rc;
803 }
Steve French50c2f752007-07-13 00:33:32 +0000804
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400805 if (!midQ->resp_buf || midQ->mid_state != MID_RESPONSE_RECEIVED) {
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500806 rc = -EIO;
Joe Perchesf96637b2013-05-04 22:12:25 -0500807 cifs_dbg(FYI, "Bad MID state?\n");
Steve French2b2bdfb2008-12-11 17:26:54 +0000808 goto out;
809 }
Steve French84afc292005-12-02 13:32:45 -0800810
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400811 buf = (char *)midQ->resp_buf;
812 iov[0].iov_base = buf;
813 iov[0].iov_len = get_rfc1002_length(buf) + 4;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400814 if (midQ->large_buf)
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400815 *resp_buf_type = CIFS_LARGE_BUFFER;
Jeff Layton2c8f9812011-05-19 16:22:52 -0400816 else
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400817 *resp_buf_type = CIFS_SMALL_BUFFER;
818
819 credits = ses->server->ops->get_credits(midQ);
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500820
Pavel Shilovsky082d0642012-05-17 12:18:21 +0400821 rc = ses->server->ops->check_receive(midQ, ses->server,
822 flags & CIFS_LOG_ERROR);
Steve French2b2bdfb2008-12-11 17:26:54 +0000823
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700824 /* mark it so buf will not be freed by cifs_delete_mid */
Jeff Layton2c8f9812011-05-19 16:22:52 -0400825 if ((flags & CIFS_NO_RESP) == 0)
826 midQ->resp_buf = NULL;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000827out:
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700828 cifs_delete_mid(midQ);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400829 add_credits(ses->server, credits, optype);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830
831 return rc;
832}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833
834int
Steve French96daf2b2011-05-27 04:34:02 +0000835SendReceive(const unsigned int xid, struct cifs_ses *ses,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400837 int *pbytes_returned, const int timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838{
839 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 struct mid_q_entry *midQ;
841
842 if (ses == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500843 cifs_dbg(VFS, "Null smb session\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 return -EIO;
845 }
Steve French79a58d12007-07-06 22:44:50 +0000846 if (ses->server == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500847 cifs_dbg(VFS, "Null tcp session\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 return -EIO;
849 }
850
Steve French79a58d12007-07-06 22:44:50 +0000851 if (ses->server->tcpStatus == CifsExiting)
Steve French31ca3bc2005-04-28 22:41:11 -0700852 return -ENOENT;
853
Steve French79a58d12007-07-06 22:44:50 +0000854 /* Ensure that we do not send more than 50 overlapping requests
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 to the same server. We may make this configurable later or
856 use ses->maxReq */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000858 if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
859 MAX_CIFS_HDR_SIZE - 4) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500860 cifs_dbg(VFS, "Illegal length, greater than maximum frame, %d\n",
861 be32_to_cpu(in_buf->smb_buf_length));
Volker Lendecke6d9c6d52008-12-08 20:50:24 +0000862 return -EIO;
863 }
864
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400865 rc = wait_for_free_request(ses->server, timeout, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000866 if (rc)
867 return rc;
868
Steve French79a58d12007-07-06 22:44:50 +0000869 /* make sure that we sign in the same order that we send on this socket
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 and avoid races inside tcp sendmsg code that could cause corruption
871 of smb data */
872
Jeff Layton72ca5452008-12-01 07:09:36 -0500873 mutex_lock(&ses->server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000875 rc = allocate_mid(ses, in_buf, &midQ);
876 if (rc) {
Jeff Layton72ca5452008-12-01 07:09:36 -0500877 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000878 /* Update # of requests on wire to server */
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400879 add_credits(ses->server, 1, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000880 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 }
882
Steve Frenchad009ac2005-04-28 22:41:05 -0700883 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
Volker Lendecke829049c2008-12-06 16:00:53 +0100884 if (rc) {
885 mutex_unlock(&ses->server->srv_mutex);
886 goto out;
887 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400889 midQ->mid_state = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000890
891 cifs_in_send_inc(ses->server);
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000892 rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
Steve French789e6662011-08-09 18:44:44 +0000893 cifs_in_send_dec(ses->server);
894 cifs_save_when_sent(midQ);
Jeff Laytonad313cb2013-04-03 10:27:36 -0400895
896 if (rc < 0)
897 ses->server->sequence_number -= 2;
898
Jeff Layton72ca5452008-12-01 07:09:36 -0500899 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000900
Steve French79a58d12007-07-06 22:44:50 +0000901 if (rc < 0)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000902 goto out;
903
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400904 if (timeout == CIFS_ASYNC_OP)
Steve French133672e2007-11-13 22:41:37 +0000905 goto out;
Jeff Layton0ade6402011-01-11 07:24:02 -0500906
907 rc = wait_for_response(ses->server, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500908 if (rc != 0) {
Jeff Layton121b0462012-05-15 12:21:10 -0400909 send_cancel(ses->server, in_buf, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500910 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400911 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
Jeff Layton1be912d2011-01-28 07:08:28 -0500912 /* no longer considered to be "in-flight" */
913 midQ->callback = DeleteMidQEntry;
914 spin_unlock(&GlobalMid_Lock);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400915 add_credits(ses->server, 1, 0);
Jeff Layton1be912d2011-01-28 07:08:28 -0500916 return rc;
917 }
918 spin_unlock(&GlobalMid_Lock);
919 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920
Jeff Layton3c1105d2011-05-22 07:09:13 -0400921 rc = cifs_sync_mid_result(midQ, ses->server);
Jeff Layton053d5032011-01-11 07:24:02 -0500922 if (rc != 0) {
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400923 add_credits(ses->server, 1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 return rc;
925 }
Steve French50c2f752007-07-13 00:33:32 +0000926
Jeff Layton2c8f9812011-05-19 16:22:52 -0400927 if (!midQ->resp_buf || !out_buf ||
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400928 midQ->mid_state != MID_RESPONSE_RECEIVED) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 rc = -EIO;
Joe Perchesf96637b2013-05-04 22:12:25 -0500930 cifs_dbg(VFS, "Bad MID state?\n");
Steve French2b2bdfb2008-12-11 17:26:54 +0000931 goto out;
932 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400934 *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
Jeff Layton2c8f9812011-05-19 16:22:52 -0400935 memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
936 rc = cifs_check_receive(midQ, ses->server, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000937out:
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700938 cifs_delete_mid(midQ);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400939 add_credits(ses->server, 1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940
941 return rc;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000942}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000944/* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
945 blocking lock to return. */
946
947static int
Steve French96daf2b2011-05-27 04:34:02 +0000948send_lock_cancel(const unsigned int xid, struct cifs_tcon *tcon,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000949 struct smb_hdr *in_buf,
950 struct smb_hdr *out_buf)
951{
952 int bytes_returned;
Steve French96daf2b2011-05-27 04:34:02 +0000953 struct cifs_ses *ses = tcon->ses;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000954 LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
955
956 /* We just modify the current in_buf to change
957 the type of lock from LOCKING_ANDX_SHARED_LOCK
958 or LOCKING_ANDX_EXCLUSIVE_LOCK to
959 LOCKING_ANDX_CANCEL_LOCK. */
960
961 pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
962 pSMB->Timeout = 0;
Pavel Shilovsky88257362012-05-23 14:01:59 +0400963 pSMB->hdr.Mid = get_next_mid(ses->server);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000964
965 return SendReceive(xid, ses, in_buf, out_buf,
Jeff Layton77499812011-01-11 07:24:23 -0500966 &bytes_returned, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000967}
968
969int
Steve French96daf2b2011-05-27 04:34:02 +0000970SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000971 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
972 int *pbytes_returned)
973{
974 int rc = 0;
975 int rstart = 0;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000976 struct mid_q_entry *midQ;
Steve French96daf2b2011-05-27 04:34:02 +0000977 struct cifs_ses *ses;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000978
979 if (tcon == NULL || tcon->ses == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500980 cifs_dbg(VFS, "Null smb session\n");
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000981 return -EIO;
982 }
983 ses = tcon->ses;
984
Steve French79a58d12007-07-06 22:44:50 +0000985 if (ses->server == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500986 cifs_dbg(VFS, "Null tcp session\n");
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000987 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 }
989
Steve French79a58d12007-07-06 22:44:50 +0000990 if (ses->server->tcpStatus == CifsExiting)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000991 return -ENOENT;
992
Steve French79a58d12007-07-06 22:44:50 +0000993 /* Ensure that we do not send more than 50 overlapping requests
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000994 to the same server. We may make this configurable later or
995 use ses->maxReq */
996
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000997 if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
998 MAX_CIFS_HDR_SIZE - 4) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500999 cifs_dbg(VFS, "Illegal length, greater than maximum frame, %d\n",
1000 be32_to_cpu(in_buf->smb_buf_length));
Volker Lendecke6d9c6d52008-12-08 20:50:24 +00001001 return -EIO;
1002 }
1003
Pavel Shilovskya891f0f2012-05-23 16:14:34 +04001004 rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001005 if (rc)
1006 return rc;
1007
Steve French79a58d12007-07-06 22:44:50 +00001008 /* make sure that we sign in the same order that we send on this socket
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001009 and avoid races inside tcp sendmsg code that could cause corruption
1010 of smb data */
1011
Jeff Layton72ca5452008-12-01 07:09:36 -05001012 mutex_lock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001013
1014 rc = allocate_mid(ses, in_buf, &midQ);
1015 if (rc) {
Jeff Layton72ca5452008-12-01 07:09:36 -05001016 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001017 return rc;
1018 }
1019
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001020 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
Volker Lendecke829049c2008-12-06 16:00:53 +01001021 if (rc) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -07001022 cifs_delete_mid(midQ);
Volker Lendecke829049c2008-12-06 16:00:53 +01001023 mutex_unlock(&ses->server->srv_mutex);
1024 return rc;
1025 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001026
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001027 midQ->mid_state = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +00001028 cifs_in_send_inc(ses->server);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00001029 rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
Steve French789e6662011-08-09 18:44:44 +00001030 cifs_in_send_dec(ses->server);
1031 cifs_save_when_sent(midQ);
Jeff Laytonad313cb2013-04-03 10:27:36 -04001032
1033 if (rc < 0)
1034 ses->server->sequence_number -= 2;
1035
Jeff Layton72ca5452008-12-01 07:09:36 -05001036 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001037
Steve French79a58d12007-07-06 22:44:50 +00001038 if (rc < 0) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -07001039 cifs_delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001040 return rc;
1041 }
1042
1043 /* Wait for a reply - allow signals to interrupt. */
1044 rc = wait_event_interruptible(ses->server->response_q,
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001045 (!(midQ->mid_state == MID_REQUEST_SUBMITTED)) ||
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001046 ((ses->server->tcpStatus != CifsGood) &&
1047 (ses->server->tcpStatus != CifsNew)));
1048
1049 /* Were we interrupted by a signal ? */
1050 if ((rc == -ERESTARTSYS) &&
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001051 (midQ->mid_state == MID_REQUEST_SUBMITTED) &&
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001052 ((ses->server->tcpStatus == CifsGood) ||
1053 (ses->server->tcpStatus == CifsNew))) {
1054
1055 if (in_buf->Command == SMB_COM_TRANSACTION2) {
1056 /* POSIX lock. We send a NT_CANCEL SMB to cause the
1057 blocking lock to return. */
Jeff Layton121b0462012-05-15 12:21:10 -04001058 rc = send_cancel(ses->server, in_buf, midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001059 if (rc) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -07001060 cifs_delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001061 return rc;
1062 }
1063 } else {
1064 /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
1065 to cause the blocking lock to return. */
1066
1067 rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
1068
1069 /* If we get -ENOLCK back the lock may have
1070 already been removed. Don't exit in this case. */
1071 if (rc && rc != -ENOLCK) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -07001072 cifs_delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001073 return rc;
1074 }
1075 }
1076
Jeff Layton1be912d2011-01-28 07:08:28 -05001077 rc = wait_for_response(ses->server, midQ);
1078 if (rc) {
Jeff Layton121b0462012-05-15 12:21:10 -04001079 send_cancel(ses->server, in_buf, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -05001080 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001081 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
Jeff Layton1be912d2011-01-28 07:08:28 -05001082 /* no longer considered to be "in-flight" */
1083 midQ->callback = DeleteMidQEntry;
1084 spin_unlock(&GlobalMid_Lock);
1085 return rc;
1086 }
1087 spin_unlock(&GlobalMid_Lock);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001088 }
Jeff Layton1be912d2011-01-28 07:08:28 -05001089
1090 /* We got the response - restart system call. */
1091 rstart = 1;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001092 }
1093
Jeff Layton3c1105d2011-05-22 07:09:13 -04001094 rc = cifs_sync_mid_result(midQ, ses->server);
Jeff Layton053d5032011-01-11 07:24:02 -05001095 if (rc != 0)
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001096 return rc;
Steve French50c2f752007-07-13 00:33:32 +00001097
Volker Lendecke17c8bfe2008-12-06 16:38:19 +01001098 /* rcvd frame is ok */
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001099 if (out_buf == NULL || midQ->mid_state != MID_RESPONSE_RECEIVED) {
Volker Lendecke17c8bfe2008-12-06 16:38:19 +01001100 rc = -EIO;
Joe Perchesf96637b2013-05-04 22:12:25 -05001101 cifs_dbg(VFS, "Bad MID state?\n");
Volker Lendecke698e96a2008-12-06 16:39:31 +01001102 goto out;
Volker Lendecke17c8bfe2008-12-06 16:38:19 +01001103 }
1104
Pavel Shilovskyd4e48542012-03-23 14:28:02 -04001105 *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
Jeff Layton2c8f9812011-05-19 16:22:52 -04001106 memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
1107 rc = cifs_check_receive(midQ, ses->server, 0);
Volker Lendecke17c8bfe2008-12-06 16:38:19 +01001108out:
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -07001109 cifs_delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001110 if (rstart && rc == -EACCES)
1111 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 return rc;
1113}