blob: 6fdcb1b4a106747779ae77ed365116256e79edec [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));
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 temp->mid = smb_buffer->Mid; /* always LE */
62 temp->pid = current->pid;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -040063 temp->command = cpu_to_le16(smb_buffer->Command);
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 Layton6f49f462012-09-18 16:20:34 -0700273static int
274smb_send_rqst(struct TCP_Server_Info *server, struct smb_rqst *rqst)
275{
276 int rc;
277 struct kvec *iov = rqst->rq_iov;
278 int n_vec = rqst->rq_nvec;
279 unsigned int smb_buf_length = get_rfc1002_length(iov[0].iov_base);
Jeff Layton97bc00b2012-09-18 16:20:35 -0700280 unsigned int i;
281 size_t total_len = 0, sent;
Jeff Laytonb8eed282012-09-18 16:20:35 -0700282 struct socket *ssocket = server->ssocket;
283 int val = 1;
Jeff Layton6f49f462012-09-18 16:20:34 -0700284
Jeff Laytonea702b82012-12-27 07:28:55 -0500285 if (ssocket == NULL)
286 return -ENOTSOCK;
287
Joe Perchesf96637b2013-05-04 22:12:25 -0500288 cifs_dbg(FYI, "Sending smb: smb_len=%u\n", smb_buf_length);
Jeff Layton6f49f462012-09-18 16:20:34 -0700289 dump_smb(iov[0].iov_base, iov[0].iov_len);
290
Jeff Laytonb8eed282012-09-18 16:20:35 -0700291 /* cork the socket */
292 kernel_setsockopt(ssocket, SOL_TCP, TCP_CORK,
293 (char *)&val, sizeof(val));
294
Jeff Layton97bc00b2012-09-18 16:20:35 -0700295 rc = smb_send_kvec(server, iov, n_vec, &sent);
296 if (rc < 0)
297 goto uncork;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
Jeff Layton97bc00b2012-09-18 16:20:35 -0700299 total_len += sent;
300
301 /* now walk the page array and send each page in it */
302 for (i = 0; i < rqst->rq_npages; i++) {
303 struct kvec p_iov;
304
305 cifs_rqst_page_to_kvec(rqst, i, &p_iov);
306 rc = smb_send_kvec(server, &p_iov, 1, &sent);
307 kunmap(rqst->rq_pages[i]);
308 if (rc < 0)
309 break;
310
311 total_len += sent;
312 }
313
314uncork:
Jeff Laytonb8eed282012-09-18 16:20:35 -0700315 /* uncork it */
316 val = 0;
317 kernel_setsockopt(ssocket, SOL_TCP, TCP_CORK,
318 (char *)&val, sizeof(val));
319
Steve Frenchedf1ae42008-10-29 00:47:57 +0000320 if ((total_len > 0) && (total_len != smb_buf_length + 4)) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500321 cifs_dbg(FYI, "partial send (wanted=%u sent=%zu): terminating session\n",
322 smb_buf_length + 4, total_len);
Jeff Layton6f49f462012-09-18 16:20:34 -0700323 /*
324 * If we have only sent part of an SMB then the next SMB could
325 * be taken as the remainder of this one. We need to kill the
326 * socket so the server throws away the partial SMB
327 */
Steve Frenchedf1ae42008-10-29 00:47:57 +0000328 server->tcpStatus = CifsNeedReconnect;
329 }
330
Jeff Laytond804d412011-01-28 15:05:43 -0500331 if (rc < 0 && rc != -EINTR)
Joe Perchesf96637b2013-05-04 22:12:25 -0500332 cifs_dbg(VFS, "Error %d sending data on socket to server\n",
333 rc);
Jeff Laytond804d412011-01-28 15:05:43 -0500334 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
337 return rc;
338}
339
Jeff Layton6f49f462012-09-18 16:20:34 -0700340static int
341smb_sendv(struct TCP_Server_Info *server, struct kvec *iov, int n_vec)
342{
343 struct smb_rqst rqst = { .rq_iov = iov,
344 .rq_nvec = n_vec };
345
346 return smb_send_rqst(server, &rqst);
347}
348
Jeff Layton0496e022008-12-30 12:39:16 -0500349int
350smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer,
351 unsigned int smb_buf_length)
352{
353 struct kvec iov;
354
355 iov.iov_base = smb_buffer;
356 iov.iov_len = smb_buf_length + 4;
357
358 return smb_sendv(server, &iov, 1);
359}
360
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300361static int
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400362wait_for_free_credits(struct TCP_Server_Info *server, const int timeout,
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300363 int *credits)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000364{
Pavel Shilovsky5bc59492012-02-21 19:56:08 +0300365 int rc;
366
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300367 spin_lock(&server->req_lock);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400368 if (timeout == CIFS_ASYNC_OP) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000369 /* oplock breaks must not be held up */
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300370 server->in_flight++;
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300371 *credits -= 1;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300372 spin_unlock(&server->req_lock);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000373 return 0;
374 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000375
Volker Lendecke27a97a62008-12-08 20:59:39 +0000376 while (1) {
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300377 if (*credits <= 0) {
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300378 spin_unlock(&server->req_lock);
Steve French789e6662011-08-09 18:44:44 +0000379 cifs_num_waiters_inc(server);
Pavel Shilovsky5bc59492012-02-21 19:56:08 +0300380 rc = wait_event_killable(server->request_q,
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300381 has_credits(server, credits));
Steve French789e6662011-08-09 18:44:44 +0000382 cifs_num_waiters_dec(server);
Pavel Shilovsky5bc59492012-02-21 19:56:08 +0300383 if (rc)
384 return rc;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300385 spin_lock(&server->req_lock);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000386 } else {
Jeff Laytonc5797a92011-01-11 07:24:01 -0500387 if (server->tcpStatus == CifsExiting) {
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300388 spin_unlock(&server->req_lock);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000389 return -ENOENT;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000390 }
Volker Lendecke27a97a62008-12-08 20:59:39 +0000391
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400392 /*
393 * Can not count locking commands against total
394 * as they are allowed to block on server.
395 */
Volker Lendecke27a97a62008-12-08 20:59:39 +0000396
397 /* update # of requests on the wire to server */
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400398 if (timeout != CIFS_BLOCKING_OP) {
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300399 *credits -= 1;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300400 server->in_flight++;
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400401 }
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300402 spin_unlock(&server->req_lock);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000403 break;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000404 }
405 }
406 return 0;
407}
408
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300409static int
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400410wait_for_free_request(struct TCP_Server_Info *server, const int timeout,
411 const int optype)
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300412{
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400413 return wait_for_free_credits(server, timeout,
414 server->ops->get_credits_field(server, optype));
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300415}
416
Steve French96daf2b2011-05-27 04:34:02 +0000417static int allocate_mid(struct cifs_ses *ses, struct smb_hdr *in_buf,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000418 struct mid_q_entry **ppmidQ)
419{
420 if (ses->server->tcpStatus == CifsExiting) {
421 return -ENOENT;
Volker Lendecke8fbbd362008-12-06 13:12:34 +0100422 }
423
424 if (ses->server->tcpStatus == CifsNeedReconnect) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500425 cifs_dbg(FYI, "tcp session dead - return to caller to retry\n");
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000426 return -EAGAIN;
Volker Lendecke8fbbd362008-12-06 13:12:34 +0100427 }
428
429 if (ses->status != CifsGood) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000430 /* check if SMB session is bad because we are setting it up */
Steve French79a58d12007-07-06 22:44:50 +0000431 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
Steve Frenchad7a2922008-02-07 23:25:02 +0000432 (in_buf->Command != SMB_COM_NEGOTIATE))
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000433 return -EAGAIN;
Steve Frenchad7a2922008-02-07 23:25:02 +0000434 /* else ok - we are setting up session */
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000435 }
Jeff Layton24b9b062008-12-01 07:09:34 -0500436 *ppmidQ = AllocMidQEntry(in_buf, ses->server);
Steve French26f57362007-08-30 22:09:15 +0000437 if (*ppmidQ == NULL)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000438 return -ENOMEM;
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500439 spin_lock(&GlobalMid_Lock);
440 list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);
441 spin_unlock(&GlobalMid_Lock);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000442 return 0;
443}
444
Jeff Layton0ade6402011-01-11 07:24:02 -0500445static int
446wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000447{
Jeff Layton0ade6402011-01-11 07:24:02 -0500448 int error;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000449
Colin Cross5853cc22013-05-07 17:52:05 +0000450 error = wait_event_freezekillable_unsafe(server->response_q,
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400451 midQ->mid_state != MID_REQUEST_SUBMITTED);
Jeff Layton0ade6402011-01-11 07:24:02 -0500452 if (error < 0)
453 return -ERESTARTSYS;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000454
Jeff Layton0ade6402011-01-11 07:24:02 -0500455 return 0;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000456}
457
Jeff Laytonfec344e2012-09-18 16:20:35 -0700458struct mid_q_entry *
459cifs_setup_async_request(struct TCP_Server_Info *server, struct smb_rqst *rqst)
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400460{
461 int rc;
Jeff Laytonfec344e2012-09-18 16:20:35 -0700462 struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400463 struct mid_q_entry *mid;
464
465 /* enable signing if server requires it */
Jeff Layton38d77c52013-05-26 07:01:00 -0400466 if (server->sign)
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400467 hdr->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
468
469 mid = AllocMidQEntry(hdr, server);
470 if (mid == NULL)
Jeff Laytonfec344e2012-09-18 16:20:35 -0700471 return ERR_PTR(-ENOMEM);
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400472
Jeff Laytonfec344e2012-09-18 16:20:35 -0700473 rc = cifs_sign_rqst(rqst, server, &mid->sequence_number);
Sachin Prabhuffc61cc2012-07-11 12:28:05 +0100474 if (rc) {
475 DeleteMidQEntry(mid);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700476 return ERR_PTR(rc);
Sachin Prabhuffc61cc2012-07-11 12:28:05 +0100477 }
478
Jeff Laytonfec344e2012-09-18 16:20:35 -0700479 return mid;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400480}
Steve French133672e2007-11-13 22:41:37 +0000481
482/*
Jeff Laytona6827c12011-01-11 07:24:21 -0500483 * Send a SMB request and set the callback function in the mid to handle
484 * the result. Caller is responsible for dealing with timeouts.
485 */
486int
Jeff Laytonfec344e2012-09-18 16:20:35 -0700487cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst,
488 mid_receive_t *receive, mid_callback_t *callback,
489 void *cbdata, const int flags)
Jeff Laytona6827c12011-01-11 07:24:21 -0500490{
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400491 int rc, timeout, optype;
Jeff Laytona6827c12011-01-11 07:24:21 -0500492 struct mid_q_entry *mid;
493
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400494 timeout = flags & CIFS_TIMEOUT_MASK;
495 optype = flags & CIFS_OP_MASK;
496
497 rc = wait_for_free_request(server, timeout, optype);
Jeff Laytona6827c12011-01-11 07:24:21 -0500498 if (rc)
499 return rc;
500
501 mutex_lock(&server->srv_mutex);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700502 mid = server->ops->setup_async_request(server, rqst);
503 if (IS_ERR(mid)) {
Jeff Laytona6827c12011-01-11 07:24:21 -0500504 mutex_unlock(&server->srv_mutex);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400505 add_credits(server, 1, optype);
Pavel Shilovsky0193e072011-08-03 23:12:18 +0400506 wake_up(&server->request_q);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700507 return PTR_ERR(mid);
Jeff Laytona6827c12011-01-11 07:24:21 -0500508 }
509
Jeff Layton44d22d82011-10-19 15:29:49 -0400510 mid->receive = receive;
Jeff Laytona6827c12011-01-11 07:24:21 -0500511 mid->callback = callback;
512 mid->callback_data = cbdata;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400513 mid->mid_state = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000514
Sachin Prabhuffc61cc2012-07-11 12:28:05 +0100515 /* put it on the pending_mid_q */
516 spin_lock(&GlobalMid_Lock);
517 list_add_tail(&mid->qhead, &server->pending_mid_q);
518 spin_unlock(&GlobalMid_Lock);
519
520
Steve French789e6662011-08-09 18:44:44 +0000521 cifs_in_send_inc(server);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700522 rc = smb_send_rqst(server, rqst);
Steve French789e6662011-08-09 18:44:44 +0000523 cifs_in_send_dec(server);
524 cifs_save_when_sent(mid);
Jeff Laytonad313cb2013-04-03 10:27:36 -0400525
526 if (rc < 0)
527 server->sequence_number -= 2;
Jeff Laytona6827c12011-01-11 07:24:21 -0500528 mutex_unlock(&server->srv_mutex);
Steve French789e6662011-08-09 18:44:44 +0000529
Sachin Prabhuffc61cc2012-07-11 12:28:05 +0100530 if (rc == 0)
531 return 0;
Jeff Laytona6827c12011-01-11 07:24:21 -0500532
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700533 cifs_delete_mid(mid);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400534 add_credits(server, 1, optype);
Jeff Laytona6827c12011-01-11 07:24:21 -0500535 wake_up(&server->request_q);
536 return rc;
537}
538
539/*
Steve French133672e2007-11-13 22:41:37 +0000540 *
541 * Send an SMB Request. No response info (other than return code)
542 * needs to be parsed.
543 *
544 * flags indicate the type of request buffer and how long to wait
545 * and whether to log NT STATUS code (error) before mapping it to POSIX error
546 *
547 */
548int
Steve French96daf2b2011-05-27 04:34:02 +0000549SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400550 char *in_buf, int flags)
Steve French133672e2007-11-13 22:41:37 +0000551{
552 int rc;
553 struct kvec iov[1];
554 int resp_buf_type;
555
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400556 iov[0].iov_base = in_buf;
557 iov[0].iov_len = get_rfc1002_length(in_buf) + 4;
Steve French133672e2007-11-13 22:41:37 +0000558 flags |= CIFS_NO_RESP;
559 rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
Joe Perchesf96637b2013-05-04 22:12:25 -0500560 cifs_dbg(NOISY, "SendRcvNoRsp flags %d rc %d\n", flags, rc);
Steve French90c81e02008-02-12 20:32:36 +0000561
Steve French133672e2007-11-13 22:41:37 +0000562 return rc;
563}
564
Jeff Layton053d5032011-01-11 07:24:02 -0500565static int
Jeff Layton3c1105d2011-05-22 07:09:13 -0400566cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
Jeff Layton053d5032011-01-11 07:24:02 -0500567{
568 int rc = 0;
569
Joe Perchesf96637b2013-05-04 22:12:25 -0500570 cifs_dbg(FYI, "%s: cmd=%d mid=%llu state=%d\n",
571 __func__, le16_to_cpu(mid->command), mid->mid, mid->mid_state);
Jeff Layton053d5032011-01-11 07:24:02 -0500572
Jeff Layton74dd92a2011-01-11 07:24:02 -0500573 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400574 switch (mid->mid_state) {
Jeff Layton74dd92a2011-01-11 07:24:02 -0500575 case MID_RESPONSE_RECEIVED:
Jeff Layton053d5032011-01-11 07:24:02 -0500576 spin_unlock(&GlobalMid_Lock);
577 return rc;
Jeff Layton74dd92a2011-01-11 07:24:02 -0500578 case MID_RETRY_NEEDED:
579 rc = -EAGAIN;
580 break;
Jeff Layton71823ba2011-02-10 08:03:50 -0500581 case MID_RESPONSE_MALFORMED:
582 rc = -EIO;
583 break;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400584 case MID_SHUTDOWN:
585 rc = -EHOSTDOWN;
586 break;
Jeff Layton74dd92a2011-01-11 07:24:02 -0500587 default:
Jeff Layton3c1105d2011-05-22 07:09:13 -0400588 list_del_init(&mid->qhead);
Joe Perchesf96637b2013-05-04 22:12:25 -0500589 cifs_dbg(VFS, "%s: invalid mid state mid=%llu state=%d\n",
590 __func__, mid->mid, mid->mid_state);
Jeff Layton74dd92a2011-01-11 07:24:02 -0500591 rc = -EIO;
Jeff Layton053d5032011-01-11 07:24:02 -0500592 }
593 spin_unlock(&GlobalMid_Lock);
594
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500595 DeleteMidQEntry(mid);
Jeff Layton053d5032011-01-11 07:24:02 -0500596 return rc;
597}
598
Jeff Layton121b0462012-05-15 12:21:10 -0400599static inline int
600send_cancel(struct TCP_Server_Info *server, void *buf, struct mid_q_entry *mid)
Jeff Layton76dcc262011-01-11 07:24:24 -0500601{
Jeff Layton121b0462012-05-15 12:21:10 -0400602 return server->ops->send_cancel ?
603 server->ops->send_cancel(server, buf, mid) : 0;
Jeff Layton76dcc262011-01-11 07:24:24 -0500604}
605
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606int
Jeff Layton2c8f9812011-05-19 16:22:52 -0400607cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
608 bool log_error)
609{
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400610 unsigned int len = get_rfc1002_length(mid->resp_buf) + 4;
Jeff Layton826a95e2011-10-11 06:41:32 -0400611
612 dump_smb(mid->resp_buf, min_t(u32, 92, len));
Jeff Layton2c8f9812011-05-19 16:22:52 -0400613
614 /* convert the length into a more usable form */
Jeff Layton38d77c52013-05-26 07:01:00 -0400615 if (server->sign) {
Jeff Layton826a95e2011-10-11 06:41:32 -0400616 struct kvec iov;
Steve French985e4ff02012-08-03 09:42:45 -0500617 int rc = 0;
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700618 struct smb_rqst rqst = { .rq_iov = &iov,
619 .rq_nvec = 1 };
Jeff Layton826a95e2011-10-11 06:41:32 -0400620
621 iov.iov_base = mid->resp_buf;
622 iov.iov_len = len;
Jeff Layton2c8f9812011-05-19 16:22:52 -0400623 /* FIXME: add code to kill session */
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700624 rc = cifs_verify_signature(&rqst, server,
Jeff Layton0124cc42013-04-03 11:55:03 -0400625 mid->sequence_number);
Steve French985e4ff02012-08-03 09:42:45 -0500626 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500627 cifs_dbg(VFS, "SMB signature verification returned error = %d\n",
628 rc);
Jeff Layton2c8f9812011-05-19 16:22:52 -0400629 }
630
631 /* BB special case reconnect tid and uid here? */
632 return map_smb_to_linux_error(mid->resp_buf, log_error);
633}
634
Jeff Laytonfec344e2012-09-18 16:20:35 -0700635struct mid_q_entry *
636cifs_setup_request(struct cifs_ses *ses, struct smb_rqst *rqst)
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400637{
638 int rc;
Jeff Laytonfec344e2012-09-18 16:20:35 -0700639 struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400640 struct mid_q_entry *mid;
641
642 rc = allocate_mid(ses, hdr, &mid);
643 if (rc)
Jeff Laytonfec344e2012-09-18 16:20:35 -0700644 return ERR_PTR(rc);
645 rc = cifs_sign_rqst(rqst, ses->server, &mid->sequence_number);
646 if (rc) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700647 cifs_delete_mid(mid);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700648 return ERR_PTR(rc);
649 }
650 return mid;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400651}
652
Jeff Layton2c8f9812011-05-19 16:22:52 -0400653int
Steve French96daf2b2011-05-27 04:34:02 +0000654SendReceive2(const unsigned int xid, struct cifs_ses *ses,
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400655 struct kvec *iov, int n_vec, int *resp_buf_type /* ret */,
Steve French133672e2007-11-13 22:41:37 +0000656 const int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657{
658 int rc = 0;
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400659 int timeout, optype;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500660 struct mid_q_entry *midQ;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400661 char *buf = iov[0].iov_base;
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400662 unsigned int credits = 1;
Jeff Laytonfec344e2012-09-18 16:20:35 -0700663 struct smb_rqst rqst = { .rq_iov = iov,
664 .rq_nvec = n_vec };
Steve French50c2f752007-07-13 00:33:32 +0000665
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400666 timeout = flags & CIFS_TIMEOUT_MASK;
667 optype = flags & CIFS_OP_MASK;
Steve French133672e2007-11-13 22:41:37 +0000668
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400669 *resp_buf_type = CIFS_NO_BUFFER; /* no response buf yet */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670
Steve French4b8f9302006-02-26 16:41:18 +0000671 if ((ses == NULL) || (ses->server == NULL)) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400672 cifs_small_buf_release(buf);
Joe Perchesf96637b2013-05-04 22:12:25 -0500673 cifs_dbg(VFS, "Null session\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 return -EIO;
675 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676
Steve French79a58d12007-07-06 22:44:50 +0000677 if (ses->server->tcpStatus == CifsExiting) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400678 cifs_small_buf_release(buf);
Steve French31ca3bc2005-04-28 22:41:11 -0700679 return -ENOENT;
Steve French4b8f9302006-02-26 16:41:18 +0000680 }
Steve French31ca3bc2005-04-28 22:41:11 -0700681
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400682 /*
683 * Ensure that we do not send more than 50 overlapping requests
684 * to the same server. We may make this configurable later or
685 * use ses->maxReq.
686 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400688 rc = wait_for_free_request(ses->server, timeout, optype);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000689 if (rc) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400690 cifs_small_buf_release(buf);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000691 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000693
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400694 /*
695 * Make sure that we sign in the same order that we send on this socket
696 * and avoid races inside tcp sendmsg code that could cause corruption
697 * of smb data.
698 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699
Jeff Layton72ca5452008-12-01 07:09:36 -0500700 mutex_lock(&ses->server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
Jeff Laytonfec344e2012-09-18 16:20:35 -0700702 midQ = ses->server->ops->setup_request(ses, &rqst);
703 if (IS_ERR(midQ)) {
Jeff Layton72ca5452008-12-01 07:09:36 -0500704 mutex_unlock(&ses->server->srv_mutex);
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400705 cifs_small_buf_release(buf);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000706 /* Update # of requests on wire to server */
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400707 add_credits(ses->server, 1, optype);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700708 return PTR_ERR(midQ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400711 midQ->mid_state = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000712 cifs_in_send_inc(ses->server);
Jeff Layton0496e022008-12-30 12:39:16 -0500713 rc = smb_sendv(ses->server, iov, n_vec);
Steve French789e6662011-08-09 18:44:44 +0000714 cifs_in_send_dec(ses->server);
715 cifs_save_when_sent(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000716
Jeff Laytonad313cb2013-04-03 10:27:36 -0400717 if (rc < 0)
718 ses->server->sequence_number -= 2;
Jeff Layton72ca5452008-12-01 07:09:36 -0500719 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000720
Jeff Layton2db7c582011-01-28 07:08:28 -0500721 if (rc < 0) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400722 cifs_small_buf_release(buf);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000723 goto out;
Jeff Layton2db7c582011-01-28 07:08:28 -0500724 }
Steve French4b8f9302006-02-26 16:41:18 +0000725
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400726 if (timeout == CIFS_ASYNC_OP) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400727 cifs_small_buf_release(buf);
Steve French133672e2007-11-13 22:41:37 +0000728 goto out;
Jeff Layton2db7c582011-01-28 07:08:28 -0500729 }
Jeff Layton0ade6402011-01-11 07:24:02 -0500730
731 rc = wait_for_response(ses->server, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500732 if (rc != 0) {
Jeff Layton121b0462012-05-15 12:21:10 -0400733 send_cancel(ses->server, buf, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500734 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400735 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
Jeff Layton1be912d2011-01-28 07:08:28 -0500736 midQ->callback = DeleteMidQEntry;
737 spin_unlock(&GlobalMid_Lock);
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400738 cifs_small_buf_release(buf);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400739 add_credits(ses->server, 1, optype);
Jeff Layton1be912d2011-01-28 07:08:28 -0500740 return rc;
741 }
742 spin_unlock(&GlobalMid_Lock);
743 }
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500744
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400745 cifs_small_buf_release(buf);
Jeff Layton2db7c582011-01-28 07:08:28 -0500746
Jeff Layton3c1105d2011-05-22 07:09:13 -0400747 rc = cifs_sync_mid_result(midQ, ses->server);
Jeff Layton053d5032011-01-11 07:24:02 -0500748 if (rc != 0) {
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400749 add_credits(ses->server, 1, optype);
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500750 return rc;
751 }
Steve French50c2f752007-07-13 00:33:32 +0000752
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400753 if (!midQ->resp_buf || midQ->mid_state != MID_RESPONSE_RECEIVED) {
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500754 rc = -EIO;
Joe Perchesf96637b2013-05-04 22:12:25 -0500755 cifs_dbg(FYI, "Bad MID state?\n");
Steve French2b2bdfb2008-12-11 17:26:54 +0000756 goto out;
757 }
Steve French84afc292005-12-02 13:32:45 -0800758
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400759 buf = (char *)midQ->resp_buf;
760 iov[0].iov_base = buf;
761 iov[0].iov_len = get_rfc1002_length(buf) + 4;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400762 if (midQ->large_buf)
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400763 *resp_buf_type = CIFS_LARGE_BUFFER;
Jeff Layton2c8f9812011-05-19 16:22:52 -0400764 else
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400765 *resp_buf_type = CIFS_SMALL_BUFFER;
766
767 credits = ses->server->ops->get_credits(midQ);
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500768
Pavel Shilovsky082d0642012-05-17 12:18:21 +0400769 rc = ses->server->ops->check_receive(midQ, ses->server,
770 flags & CIFS_LOG_ERROR);
Steve French2b2bdfb2008-12-11 17:26:54 +0000771
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700772 /* mark it so buf will not be freed by cifs_delete_mid */
Jeff Layton2c8f9812011-05-19 16:22:52 -0400773 if ((flags & CIFS_NO_RESP) == 0)
774 midQ->resp_buf = NULL;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000775out:
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700776 cifs_delete_mid(midQ);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400777 add_credits(ses->server, credits, optype);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778
779 return rc;
780}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781
782int
Steve French96daf2b2011-05-27 04:34:02 +0000783SendReceive(const unsigned int xid, struct cifs_ses *ses,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400785 int *pbytes_returned, const int timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786{
787 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 struct mid_q_entry *midQ;
789
790 if (ses == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500791 cifs_dbg(VFS, "Null smb session\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 return -EIO;
793 }
Steve French79a58d12007-07-06 22:44:50 +0000794 if (ses->server == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500795 cifs_dbg(VFS, "Null tcp session\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 return -EIO;
797 }
798
Steve French79a58d12007-07-06 22:44:50 +0000799 if (ses->server->tcpStatus == CifsExiting)
Steve French31ca3bc2005-04-28 22:41:11 -0700800 return -ENOENT;
801
Steve French79a58d12007-07-06 22:44:50 +0000802 /* Ensure that we do not send more than 50 overlapping requests
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 to the same server. We may make this configurable later or
804 use ses->maxReq */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000806 if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
807 MAX_CIFS_HDR_SIZE - 4) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500808 cifs_dbg(VFS, "Illegal length, greater than maximum frame, %d\n",
809 be32_to_cpu(in_buf->smb_buf_length));
Volker Lendecke6d9c6d52008-12-08 20:50:24 +0000810 return -EIO;
811 }
812
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400813 rc = wait_for_free_request(ses->server, timeout, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000814 if (rc)
815 return rc;
816
Steve French79a58d12007-07-06 22:44:50 +0000817 /* make sure that we sign in the same order that we send on this socket
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 and avoid races inside tcp sendmsg code that could cause corruption
819 of smb data */
820
Jeff Layton72ca5452008-12-01 07:09:36 -0500821 mutex_lock(&ses->server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000823 rc = allocate_mid(ses, in_buf, &midQ);
824 if (rc) {
Jeff Layton72ca5452008-12-01 07:09:36 -0500825 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000826 /* Update # of requests on wire to server */
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400827 add_credits(ses->server, 1, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000828 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 }
830
Steve Frenchad009ac2005-04-28 22:41:05 -0700831 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
Volker Lendecke829049c2008-12-06 16:00:53 +0100832 if (rc) {
833 mutex_unlock(&ses->server->srv_mutex);
834 goto out;
835 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400837 midQ->mid_state = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000838
839 cifs_in_send_inc(ses->server);
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000840 rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
Steve French789e6662011-08-09 18:44:44 +0000841 cifs_in_send_dec(ses->server);
842 cifs_save_when_sent(midQ);
Jeff Laytonad313cb2013-04-03 10:27:36 -0400843
844 if (rc < 0)
845 ses->server->sequence_number -= 2;
846
Jeff Layton72ca5452008-12-01 07:09:36 -0500847 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000848
Steve French79a58d12007-07-06 22:44:50 +0000849 if (rc < 0)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000850 goto out;
851
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400852 if (timeout == CIFS_ASYNC_OP)
Steve French133672e2007-11-13 22:41:37 +0000853 goto out;
Jeff Layton0ade6402011-01-11 07:24:02 -0500854
855 rc = wait_for_response(ses->server, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500856 if (rc != 0) {
Jeff Layton121b0462012-05-15 12:21:10 -0400857 send_cancel(ses->server, in_buf, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500858 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400859 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
Jeff Layton1be912d2011-01-28 07:08:28 -0500860 /* no longer considered to be "in-flight" */
861 midQ->callback = DeleteMidQEntry;
862 spin_unlock(&GlobalMid_Lock);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400863 add_credits(ses->server, 1, 0);
Jeff Layton1be912d2011-01-28 07:08:28 -0500864 return rc;
865 }
866 spin_unlock(&GlobalMid_Lock);
867 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868
Jeff Layton3c1105d2011-05-22 07:09:13 -0400869 rc = cifs_sync_mid_result(midQ, ses->server);
Jeff Layton053d5032011-01-11 07:24:02 -0500870 if (rc != 0) {
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400871 add_credits(ses->server, 1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 return rc;
873 }
Steve French50c2f752007-07-13 00:33:32 +0000874
Jeff Layton2c8f9812011-05-19 16:22:52 -0400875 if (!midQ->resp_buf || !out_buf ||
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400876 midQ->mid_state != MID_RESPONSE_RECEIVED) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 rc = -EIO;
Joe Perchesf96637b2013-05-04 22:12:25 -0500878 cifs_dbg(VFS, "Bad MID state?\n");
Steve French2b2bdfb2008-12-11 17:26:54 +0000879 goto out;
880 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400882 *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
Jeff Layton2c8f9812011-05-19 16:22:52 -0400883 memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
884 rc = cifs_check_receive(midQ, ses->server, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000885out:
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700886 cifs_delete_mid(midQ);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400887 add_credits(ses->server, 1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888
889 return rc;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000890}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000892/* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
893 blocking lock to return. */
894
895static int
Steve French96daf2b2011-05-27 04:34:02 +0000896send_lock_cancel(const unsigned int xid, struct cifs_tcon *tcon,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000897 struct smb_hdr *in_buf,
898 struct smb_hdr *out_buf)
899{
900 int bytes_returned;
Steve French96daf2b2011-05-27 04:34:02 +0000901 struct cifs_ses *ses = tcon->ses;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000902 LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
903
904 /* We just modify the current in_buf to change
905 the type of lock from LOCKING_ANDX_SHARED_LOCK
906 or LOCKING_ANDX_EXCLUSIVE_LOCK to
907 LOCKING_ANDX_CANCEL_LOCK. */
908
909 pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
910 pSMB->Timeout = 0;
Pavel Shilovsky88257362012-05-23 14:01:59 +0400911 pSMB->hdr.Mid = get_next_mid(ses->server);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000912
913 return SendReceive(xid, ses, in_buf, out_buf,
Jeff Layton77499812011-01-11 07:24:23 -0500914 &bytes_returned, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000915}
916
917int
Steve French96daf2b2011-05-27 04:34:02 +0000918SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000919 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
920 int *pbytes_returned)
921{
922 int rc = 0;
923 int rstart = 0;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000924 struct mid_q_entry *midQ;
Steve French96daf2b2011-05-27 04:34:02 +0000925 struct cifs_ses *ses;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000926
927 if (tcon == NULL || tcon->ses == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500928 cifs_dbg(VFS, "Null smb session\n");
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000929 return -EIO;
930 }
931 ses = tcon->ses;
932
Steve French79a58d12007-07-06 22:44:50 +0000933 if (ses->server == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500934 cifs_dbg(VFS, "Null tcp session\n");
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000935 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 }
937
Steve French79a58d12007-07-06 22:44:50 +0000938 if (ses->server->tcpStatus == CifsExiting)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000939 return -ENOENT;
940
Steve French79a58d12007-07-06 22:44:50 +0000941 /* Ensure that we do not send more than 50 overlapping requests
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000942 to the same server. We may make this configurable later or
943 use ses->maxReq */
944
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000945 if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
946 MAX_CIFS_HDR_SIZE - 4) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500947 cifs_dbg(VFS, "Illegal length, greater than maximum frame, %d\n",
948 be32_to_cpu(in_buf->smb_buf_length));
Volker Lendecke6d9c6d52008-12-08 20:50:24 +0000949 return -EIO;
950 }
951
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400952 rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000953 if (rc)
954 return rc;
955
Steve French79a58d12007-07-06 22:44:50 +0000956 /* make sure that we sign in the same order that we send on this socket
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000957 and avoid races inside tcp sendmsg code that could cause corruption
958 of smb data */
959
Jeff Layton72ca5452008-12-01 07:09:36 -0500960 mutex_lock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000961
962 rc = allocate_mid(ses, in_buf, &midQ);
963 if (rc) {
Jeff Layton72ca5452008-12-01 07:09:36 -0500964 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000965 return rc;
966 }
967
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000968 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
Volker Lendecke829049c2008-12-06 16:00:53 +0100969 if (rc) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700970 cifs_delete_mid(midQ);
Volker Lendecke829049c2008-12-06 16:00:53 +0100971 mutex_unlock(&ses->server->srv_mutex);
972 return rc;
973 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000974
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400975 midQ->mid_state = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000976 cifs_in_send_inc(ses->server);
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000977 rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
Steve French789e6662011-08-09 18:44:44 +0000978 cifs_in_send_dec(ses->server);
979 cifs_save_when_sent(midQ);
Jeff Laytonad313cb2013-04-03 10:27:36 -0400980
981 if (rc < 0)
982 ses->server->sequence_number -= 2;
983
Jeff Layton72ca5452008-12-01 07:09:36 -0500984 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000985
Steve French79a58d12007-07-06 22:44:50 +0000986 if (rc < 0) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700987 cifs_delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000988 return rc;
989 }
990
991 /* Wait for a reply - allow signals to interrupt. */
992 rc = wait_event_interruptible(ses->server->response_q,
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400993 (!(midQ->mid_state == MID_REQUEST_SUBMITTED)) ||
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000994 ((ses->server->tcpStatus != CifsGood) &&
995 (ses->server->tcpStatus != CifsNew)));
996
997 /* Were we interrupted by a signal ? */
998 if ((rc == -ERESTARTSYS) &&
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400999 (midQ->mid_state == MID_REQUEST_SUBMITTED) &&
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001000 ((ses->server->tcpStatus == CifsGood) ||
1001 (ses->server->tcpStatus == CifsNew))) {
1002
1003 if (in_buf->Command == SMB_COM_TRANSACTION2) {
1004 /* POSIX lock. We send a NT_CANCEL SMB to cause the
1005 blocking lock to return. */
Jeff Layton121b0462012-05-15 12:21:10 -04001006 rc = send_cancel(ses->server, in_buf, midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001007 if (rc) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -07001008 cifs_delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001009 return rc;
1010 }
1011 } else {
1012 /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
1013 to cause the blocking lock to return. */
1014
1015 rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
1016
1017 /* If we get -ENOLCK back the lock may have
1018 already been removed. Don't exit in this case. */
1019 if (rc && rc != -ENOLCK) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -07001020 cifs_delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001021 return rc;
1022 }
1023 }
1024
Jeff Layton1be912d2011-01-28 07:08:28 -05001025 rc = wait_for_response(ses->server, midQ);
1026 if (rc) {
Jeff Layton121b0462012-05-15 12:21:10 -04001027 send_cancel(ses->server, in_buf, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -05001028 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001029 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
Jeff Layton1be912d2011-01-28 07:08:28 -05001030 /* no longer considered to be "in-flight" */
1031 midQ->callback = DeleteMidQEntry;
1032 spin_unlock(&GlobalMid_Lock);
1033 return rc;
1034 }
1035 spin_unlock(&GlobalMid_Lock);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001036 }
Jeff Layton1be912d2011-01-28 07:08:28 -05001037
1038 /* We got the response - restart system call. */
1039 rstart = 1;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001040 }
1041
Jeff Layton3c1105d2011-05-22 07:09:13 -04001042 rc = cifs_sync_mid_result(midQ, ses->server);
Jeff Layton053d5032011-01-11 07:24:02 -05001043 if (rc != 0)
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001044 return rc;
Steve French50c2f752007-07-13 00:33:32 +00001045
Volker Lendecke17c8bfe2008-12-06 16:38:19 +01001046 /* rcvd frame is ok */
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001047 if (out_buf == NULL || midQ->mid_state != MID_RESPONSE_RECEIVED) {
Volker Lendecke17c8bfe2008-12-06 16:38:19 +01001048 rc = -EIO;
Joe Perchesf96637b2013-05-04 22:12:25 -05001049 cifs_dbg(VFS, "Bad MID state?\n");
Volker Lendecke698e96a2008-12-06 16:39:31 +01001050 goto out;
Volker Lendecke17c8bfe2008-12-06 16:38:19 +01001051 }
1052
Pavel Shilovskyd4e48542012-03-23 14:28:02 -04001053 *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
Jeff Layton2c8f9812011-05-19 16:22:52 -04001054 memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
1055 rc = cifs_check_receive(midQ, ses->server, 0);
Volker Lendecke17c8bfe2008-12-06 16:38:19 +01001056out:
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -07001057 cifs_delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001058 if (rstart && rc == -EACCES)
1059 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 return rc;
1061}