blob: 1a528680ec5a29e4b59485fba5df54568a1e3787 [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 Perchesb6b38f72010-04-21 03:50:45 +000052 cERROR(1, "Null TCP session in AllocMidQEntry");
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 return NULL;
54 }
Steve French50c2f752007-07-13 00:33:32 +000055
Pekka Enberg232087c2008-09-15 13:22:54 +030056 temp = mempool_alloc(cifs_mid_poolp, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 if (temp == NULL)
58 return temp;
59 else {
Steve French26f57362007-08-30 22:09:15 +000060 memset(temp, 0, sizeof(struct mid_q_entry));
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 temp->mid = smb_buffer->Mid; /* always LE */
62 temp->pid = current->pid;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -040063 temp->command = cpu_to_le16(smb_buffer->Command);
64 cFYI(1, "For smb_command %d", smb_buffer->Command);
Steve French1047abc2005-10-11 19:58:06 -070065 /* do_gettimeofday(&temp->when_sent);*/ /* easier to use jiffies */
66 /* when mid allocated can be before when sent */
67 temp->when_alloc = jiffies;
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);
182 if (rc == -ENOSPC || rc == -EAGAIN) {
Steve Frenchb7a10622012-10-07 20:00:47 -0500183 /*
184 * Catch if a low level driver returns -ENOSPC. This
185 * WARN_ON will be removed by 3.10 if no one reports
186 * seeing this.
187 */
188 WARN_ON_ONCE(rc == -ENOSPC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 i++;
Jeff Layton6f49f462012-09-18 16:20:34 -0700190 if (i >= 14 || (!server->noblocksnd && (i > 2))) {
191 cERROR(1, "sends on sock %p stuck for 15 "
192 "seconds", ssocket);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 rc = -EAGAIN;
194 break;
195 }
Steve French68058e72005-10-10 10:34:22 -0700196 msleep(1 << i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 continue;
198 }
Jeff Layton6f49f462012-09-18 16:20:34 -0700199
Steve French79a58d12007-07-06 22:44:50 +0000200 if (rc < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 break;
Steve French3e844692005-10-03 13:37:24 -0700202
Jeff Layton6f49f462012-09-18 16:20:34 -0700203 /* send was at least partially successful */
204 *sent += rc;
205
206 if (rc == remaining) {
207 remaining = 0;
Steve French3e844692005-10-03 13:37:24 -0700208 break;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500209 }
Jeff Layton6f49f462012-09-18 16:20:34 -0700210
211 if (rc > remaining) {
212 cERROR(1, "sent %d requested %d", rc, remaining);
213 break;
214 }
215
Steve French79a58d12007-07-06 22:44:50 +0000216 if (rc == 0) {
Steve French3e844692005-10-03 13:37:24 -0700217 /* should never happen, letting socket clear before
218 retrying is our only obvious option here */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000219 cERROR(1, "tcp sent no data");
Steve French3e844692005-10-03 13:37:24 -0700220 msleep(500);
221 continue;
222 }
Jeff Layton6f49f462012-09-18 16:20:34 -0700223
224 remaining -= rc;
225
Steve French68058e72005-10-10 10:34:22 -0700226 /* the line below resets i */
Steve French3e844692005-10-03 13:37:24 -0700227 for (i = first_vec; i < n_vec; i++) {
228 if (iov[i].iov_len) {
229 if (rc > iov[i].iov_len) {
230 rc -= iov[i].iov_len;
231 iov[i].iov_len = 0;
232 } else {
233 iov[i].iov_base += rc;
234 iov[i].iov_len -= rc;
235 first_vec = i;
236 break;
237 }
238 }
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500239 }
Jeff Layton6f49f462012-09-18 16:20:34 -0700240
Steve French5e1253b2005-10-10 14:06:37 -0700241 i = 0; /* in case we get ENOSPC on the next send */
Jeff Layton6f49f462012-09-18 16:20:34 -0700242 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 }
Jeff Layton6f49f462012-09-18 16:20:34 -0700244 return rc;
245}
246
Jeff Layton97bc00b2012-09-18 16:20:35 -0700247/**
248 * rqst_page_to_kvec - Turn a slot in the smb_rqst page array into a kvec
249 * @rqst: pointer to smb_rqst
250 * @idx: index into the array of the page
251 * @iov: pointer to struct kvec that will hold the result
252 *
253 * Helper function to convert a slot in the rqst->rq_pages array into a kvec.
254 * The page will be kmapped and the address placed into iov_base. The length
255 * will then be adjusted according to the ptailoff.
256 */
Jeff Laytonfb308a62012-09-18 16:20:35 -0700257void
Jeff Layton97bc00b2012-09-18 16:20:35 -0700258cifs_rqst_page_to_kvec(struct smb_rqst *rqst, unsigned int idx,
259 struct kvec *iov)
260{
261 /*
262 * FIXME: We could avoid this kmap altogether if we used
263 * kernel_sendpage instead of kernel_sendmsg. That will only
264 * work if signing is disabled though as sendpage inlines the
265 * page directly into the fraglist. If userspace modifies the
266 * page after we calculate the signature, then the server will
267 * reject it and may break the connection. kernel_sendmsg does
268 * an extra copy of the data and avoids that issue.
269 */
270 iov->iov_base = kmap(rqst->rq_pages[idx]);
271
272 /* if last page, don't send beyond this offset into page */
273 if (idx == (rqst->rq_npages - 1))
274 iov->iov_len = rqst->rq_tailsz;
275 else
276 iov->iov_len = rqst->rq_pagesz;
277}
278
Jeff Layton6f49f462012-09-18 16:20:34 -0700279static int
280smb_send_rqst(struct TCP_Server_Info *server, struct smb_rqst *rqst)
281{
282 int rc;
283 struct kvec *iov = rqst->rq_iov;
284 int n_vec = rqst->rq_nvec;
285 unsigned int smb_buf_length = get_rfc1002_length(iov[0].iov_base);
Jeff Layton97bc00b2012-09-18 16:20:35 -0700286 unsigned int i;
287 size_t total_len = 0, sent;
Jeff Laytonb8eed282012-09-18 16:20:35 -0700288 struct socket *ssocket = server->ssocket;
289 int val = 1;
Jeff Layton6f49f462012-09-18 16:20:34 -0700290
Jeff Laytonea702b82012-12-27 07:28:55 -0500291 if (ssocket == NULL)
292 return -ENOTSOCK;
293
Jeff Layton6f49f462012-09-18 16:20:34 -0700294 cFYI(1, "Sending smb: smb_len=%u", smb_buf_length);
295 dump_smb(iov[0].iov_base, iov[0].iov_len);
296
Jeff Laytonb8eed282012-09-18 16:20:35 -0700297 /* cork the socket */
298 kernel_setsockopt(ssocket, SOL_TCP, TCP_CORK,
299 (char *)&val, sizeof(val));
300
Jeff Layton97bc00b2012-09-18 16:20:35 -0700301 rc = smb_send_kvec(server, iov, n_vec, &sent);
302 if (rc < 0)
303 goto uncork;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304
Jeff Layton97bc00b2012-09-18 16:20:35 -0700305 total_len += sent;
306
307 /* now walk the page array and send each page in it */
308 for (i = 0; i < rqst->rq_npages; i++) {
309 struct kvec p_iov;
310
311 cifs_rqst_page_to_kvec(rqst, i, &p_iov);
312 rc = smb_send_kvec(server, &p_iov, 1, &sent);
313 kunmap(rqst->rq_pages[i]);
314 if (rc < 0)
315 break;
316
317 total_len += sent;
318 }
319
320uncork:
Jeff Laytonb8eed282012-09-18 16:20:35 -0700321 /* uncork it */
322 val = 0;
323 kernel_setsockopt(ssocket, SOL_TCP, TCP_CORK,
324 (char *)&val, sizeof(val));
325
Steve Frenchedf1ae42008-10-29 00:47:57 +0000326 if ((total_len > 0) && (total_len != smb_buf_length + 4)) {
Jeff Layton6f49f462012-09-18 16:20:34 -0700327 cFYI(1, "partial send (wanted=%u sent=%zu): terminating "
328 "session", smb_buf_length + 4, total_len);
329 /*
330 * If we have only sent part of an SMB then the next SMB could
331 * be taken as the remainder of this one. We need to kill the
332 * socket so the server throws away the partial SMB
333 */
Steve Frenchedf1ae42008-10-29 00:47:57 +0000334 server->tcpStatus = CifsNeedReconnect;
335 }
336
Jeff Laytond804d412011-01-28 15:05:43 -0500337 if (rc < 0 && rc != -EINTR)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000338 cERROR(1, "Error %d sending data on socket to server", rc);
Jeff Laytond804d412011-01-28 15:05:43 -0500339 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341
342 return rc;
343}
344
Jeff Layton6f49f462012-09-18 16:20:34 -0700345static int
346smb_sendv(struct TCP_Server_Info *server, struct kvec *iov, int n_vec)
347{
348 struct smb_rqst rqst = { .rq_iov = iov,
349 .rq_nvec = n_vec };
350
351 return smb_send_rqst(server, &rqst);
352}
353
Jeff Layton0496e022008-12-30 12:39:16 -0500354int
355smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer,
356 unsigned int smb_buf_length)
357{
358 struct kvec iov;
359
360 iov.iov_base = smb_buffer;
361 iov.iov_len = smb_buf_length + 4;
362
363 return smb_sendv(server, &iov, 1);
364}
365
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300366static int
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400367wait_for_free_credits(struct TCP_Server_Info *server, const int timeout,
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300368 int *credits)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000369{
Pavel Shilovsky5bc59492012-02-21 19:56:08 +0300370 int rc;
371
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300372 spin_lock(&server->req_lock);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400373 if (timeout == CIFS_ASYNC_OP) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000374 /* oplock breaks must not be held up */
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300375 server->in_flight++;
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300376 *credits -= 1;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300377 spin_unlock(&server->req_lock);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000378 return 0;
379 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000380
Volker Lendecke27a97a62008-12-08 20:59:39 +0000381 while (1) {
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300382 if (*credits <= 0) {
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300383 spin_unlock(&server->req_lock);
Steve French789e6662011-08-09 18:44:44 +0000384 cifs_num_waiters_inc(server);
Pavel Shilovsky5bc59492012-02-21 19:56:08 +0300385 rc = wait_event_killable(server->request_q,
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300386 has_credits(server, credits));
Steve French789e6662011-08-09 18:44:44 +0000387 cifs_num_waiters_dec(server);
Pavel Shilovsky5bc59492012-02-21 19:56:08 +0300388 if (rc)
389 return rc;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300390 spin_lock(&server->req_lock);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000391 } else {
Jeff Laytonc5797a92011-01-11 07:24:01 -0500392 if (server->tcpStatus == CifsExiting) {
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300393 spin_unlock(&server->req_lock);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000394 return -ENOENT;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000395 }
Volker Lendecke27a97a62008-12-08 20:59:39 +0000396
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400397 /*
398 * Can not count locking commands against total
399 * as they are allowed to block on server.
400 */
Volker Lendecke27a97a62008-12-08 20:59:39 +0000401
402 /* update # of requests on the wire to server */
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400403 if (timeout != CIFS_BLOCKING_OP) {
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300404 *credits -= 1;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300405 server->in_flight++;
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400406 }
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300407 spin_unlock(&server->req_lock);
Volker Lendecke27a97a62008-12-08 20:59:39 +0000408 break;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000409 }
410 }
411 return 0;
412}
413
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300414static int
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400415wait_for_free_request(struct TCP_Server_Info *server, const int timeout,
416 const int optype)
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300417{
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400418 return wait_for_free_credits(server, timeout,
419 server->ops->get_credits_field(server, optype));
Pavel Shilovskybc205ed2012-03-15 13:22:27 +0300420}
421
Steve French96daf2b2011-05-27 04:34:02 +0000422static int allocate_mid(struct cifs_ses *ses, struct smb_hdr *in_buf,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000423 struct mid_q_entry **ppmidQ)
424{
425 if (ses->server->tcpStatus == CifsExiting) {
426 return -ENOENT;
Volker Lendecke8fbbd362008-12-06 13:12:34 +0100427 }
428
429 if (ses->server->tcpStatus == CifsNeedReconnect) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000430 cFYI(1, "tcp session dead - return to caller to retry");
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000431 return -EAGAIN;
Volker Lendecke8fbbd362008-12-06 13:12:34 +0100432 }
433
434 if (ses->status != CifsGood) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000435 /* check if SMB session is bad because we are setting it up */
Steve French79a58d12007-07-06 22:44:50 +0000436 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
Steve Frenchad7a2922008-02-07 23:25:02 +0000437 (in_buf->Command != SMB_COM_NEGOTIATE))
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000438 return -EAGAIN;
Steve Frenchad7a2922008-02-07 23:25:02 +0000439 /* else ok - we are setting up session */
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000440 }
Jeff Layton24b9b062008-12-01 07:09:34 -0500441 *ppmidQ = AllocMidQEntry(in_buf, ses->server);
Steve French26f57362007-08-30 22:09:15 +0000442 if (*ppmidQ == NULL)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000443 return -ENOMEM;
Jeff Laytonddc8cf82011-01-11 07:24:02 -0500444 spin_lock(&GlobalMid_Lock);
445 list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);
446 spin_unlock(&GlobalMid_Lock);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000447 return 0;
448}
449
Jeff Layton0ade6402011-01-11 07:24:02 -0500450static int
451wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000452{
Jeff Layton0ade6402011-01-11 07:24:02 -0500453 int error;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000454
Jeff Laytonf06ac722011-10-19 15:30:40 -0400455 error = wait_event_freezekillable(server->response_q,
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400456 midQ->mid_state != MID_REQUEST_SUBMITTED);
Jeff Layton0ade6402011-01-11 07:24:02 -0500457 if (error < 0)
458 return -ERESTARTSYS;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000459
Jeff Layton0ade6402011-01-11 07:24:02 -0500460 return 0;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000461}
462
Jeff Laytonfec344e2012-09-18 16:20:35 -0700463struct mid_q_entry *
464cifs_setup_async_request(struct TCP_Server_Info *server, struct smb_rqst *rqst)
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400465{
466 int rc;
Jeff Laytonfec344e2012-09-18 16:20:35 -0700467 struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400468 struct mid_q_entry *mid;
469
470 /* enable signing if server requires it */
471 if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
472 hdr->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
473
474 mid = AllocMidQEntry(hdr, server);
475 if (mid == NULL)
Jeff Laytonfec344e2012-09-18 16:20:35 -0700476 return ERR_PTR(-ENOMEM);
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400477
Jeff Laytonfec344e2012-09-18 16:20:35 -0700478 rc = cifs_sign_rqst(rqst, server, &mid->sequence_number);
Sachin Prabhuffc61cc2012-07-11 12:28:05 +0100479 if (rc) {
480 DeleteMidQEntry(mid);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700481 return ERR_PTR(rc);
Sachin Prabhuffc61cc2012-07-11 12:28:05 +0100482 }
483
Jeff Laytonfec344e2012-09-18 16:20:35 -0700484 return mid;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400485}
Steve French133672e2007-11-13 22:41:37 +0000486
487/*
Jeff Laytona6827c12011-01-11 07:24:21 -0500488 * Send a SMB request and set the callback function in the mid to handle
489 * the result. Caller is responsible for dealing with timeouts.
490 */
491int
Jeff Laytonfec344e2012-09-18 16:20:35 -0700492cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst,
493 mid_receive_t *receive, mid_callback_t *callback,
494 void *cbdata, const int flags)
Jeff Laytona6827c12011-01-11 07:24:21 -0500495{
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400496 int rc, timeout, optype;
Jeff Laytona6827c12011-01-11 07:24:21 -0500497 struct mid_q_entry *mid;
498
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400499 timeout = flags & CIFS_TIMEOUT_MASK;
500 optype = flags & CIFS_OP_MASK;
501
502 rc = wait_for_free_request(server, timeout, optype);
Jeff Laytona6827c12011-01-11 07:24:21 -0500503 if (rc)
504 return rc;
505
506 mutex_lock(&server->srv_mutex);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700507 mid = server->ops->setup_async_request(server, rqst);
508 if (IS_ERR(mid)) {
Jeff Laytona6827c12011-01-11 07:24:21 -0500509 mutex_unlock(&server->srv_mutex);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400510 add_credits(server, 1, optype);
Pavel Shilovsky0193e072011-08-03 23:12:18 +0400511 wake_up(&server->request_q);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700512 return PTR_ERR(mid);
Jeff Laytona6827c12011-01-11 07:24:21 -0500513 }
514
Jeff Layton44d22d82011-10-19 15:29:49 -0400515 mid->receive = receive;
Jeff Laytona6827c12011-01-11 07:24:21 -0500516 mid->callback = callback;
517 mid->callback_data = cbdata;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400518 mid->mid_state = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000519
Sachin Prabhuffc61cc2012-07-11 12:28:05 +0100520 /* put it on the pending_mid_q */
521 spin_lock(&GlobalMid_Lock);
522 list_add_tail(&mid->qhead, &server->pending_mid_q);
523 spin_unlock(&GlobalMid_Lock);
524
525
Steve French789e6662011-08-09 18:44:44 +0000526 cifs_in_send_inc(server);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700527 rc = smb_send_rqst(server, rqst);
Steve French789e6662011-08-09 18:44:44 +0000528 cifs_in_send_dec(server);
529 cifs_save_when_sent(mid);
Jeff Laytona6827c12011-01-11 07:24:21 -0500530 mutex_unlock(&server->srv_mutex);
Steve French789e6662011-08-09 18:44:44 +0000531
Sachin Prabhuffc61cc2012-07-11 12:28:05 +0100532 if (rc == 0)
533 return 0;
Jeff Laytona6827c12011-01-11 07:24:21 -0500534
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700535 cifs_delete_mid(mid);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400536 add_credits(server, 1, optype);
Jeff Laytona6827c12011-01-11 07:24:21 -0500537 wake_up(&server->request_q);
538 return rc;
539}
540
541/*
Steve French133672e2007-11-13 22:41:37 +0000542 *
543 * Send an SMB Request. No response info (other than return code)
544 * needs to be parsed.
545 *
546 * flags indicate the type of request buffer and how long to wait
547 * and whether to log NT STATUS code (error) before mapping it to POSIX error
548 *
549 */
550int
Steve French96daf2b2011-05-27 04:34:02 +0000551SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400552 char *in_buf, int flags)
Steve French133672e2007-11-13 22:41:37 +0000553{
554 int rc;
555 struct kvec iov[1];
556 int resp_buf_type;
557
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400558 iov[0].iov_base = in_buf;
559 iov[0].iov_len = get_rfc1002_length(in_buf) + 4;
Steve French133672e2007-11-13 22:41:37 +0000560 flags |= CIFS_NO_RESP;
561 rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000562 cFYI(DBG2, "SendRcvNoRsp flags %d rc %d", flags, rc);
Steve French90c81e02008-02-12 20:32:36 +0000563
Steve French133672e2007-11-13 22:41:37 +0000564 return rc;
565}
566
Jeff Layton053d5032011-01-11 07:24:02 -0500567static int
Jeff Layton3c1105d2011-05-22 07:09:13 -0400568cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
Jeff Layton053d5032011-01-11 07:24:02 -0500569{
570 int rc = 0;
571
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400572 cFYI(1, "%s: cmd=%d mid=%llu state=%d", __func__,
573 le16_to_cpu(mid->command), mid->mid, mid->mid_state);
Jeff Layton053d5032011-01-11 07:24:02 -0500574
Jeff Layton74dd92a2011-01-11 07:24:02 -0500575 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400576 switch (mid->mid_state) {
Jeff Layton74dd92a2011-01-11 07:24:02 -0500577 case MID_RESPONSE_RECEIVED:
Jeff Layton053d5032011-01-11 07:24:02 -0500578 spin_unlock(&GlobalMid_Lock);
579 return rc;
Jeff Layton74dd92a2011-01-11 07:24:02 -0500580 case MID_RETRY_NEEDED:
581 rc = -EAGAIN;
582 break;
Jeff Layton71823ba2011-02-10 08:03:50 -0500583 case MID_RESPONSE_MALFORMED:
584 rc = -EIO;
585 break;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400586 case MID_SHUTDOWN:
587 rc = -EHOSTDOWN;
588 break;
Jeff Layton74dd92a2011-01-11 07:24:02 -0500589 default:
Jeff Layton3c1105d2011-05-22 07:09:13 -0400590 list_del_init(&mid->qhead);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400591 cERROR(1, "%s: invalid mid state mid=%llu state=%d", __func__,
592 mid->mid, mid->mid_state);
Jeff Layton74dd92a2011-01-11 07:24:02 -0500593 rc = -EIO;
Jeff Layton053d5032011-01-11 07:24:02 -0500594 }
595 spin_unlock(&GlobalMid_Lock);
596
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500597 DeleteMidQEntry(mid);
Jeff Layton053d5032011-01-11 07:24:02 -0500598 return rc;
599}
600
Jeff Layton121b0462012-05-15 12:21:10 -0400601static inline int
602send_cancel(struct TCP_Server_Info *server, void *buf, struct mid_q_entry *mid)
Jeff Layton76dcc262011-01-11 07:24:24 -0500603{
Jeff Layton121b0462012-05-15 12:21:10 -0400604 return server->ops->send_cancel ?
605 server->ops->send_cancel(server, buf, mid) : 0;
Jeff Layton76dcc262011-01-11 07:24:24 -0500606}
607
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608int
Jeff Layton2c8f9812011-05-19 16:22:52 -0400609cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
610 bool log_error)
611{
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400612 unsigned int len = get_rfc1002_length(mid->resp_buf) + 4;
Jeff Layton826a95e2011-10-11 06:41:32 -0400613
614 dump_smb(mid->resp_buf, min_t(u32, 92, len));
Jeff Layton2c8f9812011-05-19 16:22:52 -0400615
616 /* convert the length into a more usable form */
Steve French96daf2b2011-05-27 04:34:02 +0000617 if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
Jeff Layton826a95e2011-10-11 06:41:32 -0400618 struct kvec iov;
Steve French985e4ff02012-08-03 09:42:45 -0500619 int rc = 0;
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700620 struct smb_rqst rqst = { .rq_iov = &iov,
621 .rq_nvec = 1 };
Jeff Layton826a95e2011-10-11 06:41:32 -0400622
623 iov.iov_base = mid->resp_buf;
624 iov.iov_len = len;
Jeff Layton2c8f9812011-05-19 16:22:52 -0400625 /* FIXME: add code to kill session */
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -0700626 rc = cifs_verify_signature(&rqst, server,
Steve French985e4ff02012-08-03 09:42:45 -0500627 mid->sequence_number + 1);
628 if (rc)
629 cERROR(1, "SMB signature verification returned error = "
630 "%d", rc);
Jeff Layton2c8f9812011-05-19 16:22:52 -0400631 }
632
633 /* BB special case reconnect tid and uid here? */
634 return map_smb_to_linux_error(mid->resp_buf, log_error);
635}
636
Jeff Laytonfec344e2012-09-18 16:20:35 -0700637struct mid_q_entry *
638cifs_setup_request(struct cifs_ses *ses, struct smb_rqst *rqst)
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400639{
640 int rc;
Jeff Laytonfec344e2012-09-18 16:20:35 -0700641 struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400642 struct mid_q_entry *mid;
643
644 rc = allocate_mid(ses, hdr, &mid);
645 if (rc)
Jeff Laytonfec344e2012-09-18 16:20:35 -0700646 return ERR_PTR(rc);
647 rc = cifs_sign_rqst(rqst, ses->server, &mid->sequence_number);
648 if (rc) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700649 cifs_delete_mid(mid);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700650 return ERR_PTR(rc);
651 }
652 return mid;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400653}
654
Jeff Layton2c8f9812011-05-19 16:22:52 -0400655int
Steve French96daf2b2011-05-27 04:34:02 +0000656SendReceive2(const unsigned int xid, struct cifs_ses *ses,
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400657 struct kvec *iov, int n_vec, int *resp_buf_type /* ret */,
Steve French133672e2007-11-13 22:41:37 +0000658 const int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659{
660 int rc = 0;
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400661 int timeout, optype;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500662 struct mid_q_entry *midQ;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400663 char *buf = iov[0].iov_base;
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400664 unsigned int credits = 1;
Jeff Laytonfec344e2012-09-18 16:20:35 -0700665 struct smb_rqst rqst = { .rq_iov = iov,
666 .rq_nvec = n_vec };
Steve French50c2f752007-07-13 00:33:32 +0000667
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400668 timeout = flags & CIFS_TIMEOUT_MASK;
669 optype = flags & CIFS_OP_MASK;
Steve French133672e2007-11-13 22:41:37 +0000670
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400671 *resp_buf_type = CIFS_NO_BUFFER; /* no response buf yet */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672
Steve French4b8f9302006-02-26 16:41:18 +0000673 if ((ses == NULL) || (ses->server == NULL)) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400674 cifs_small_buf_release(buf);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000675 cERROR(1, "Null session");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 return -EIO;
677 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678
Steve French79a58d12007-07-06 22:44:50 +0000679 if (ses->server->tcpStatus == CifsExiting) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400680 cifs_small_buf_release(buf);
Steve French31ca3bc2005-04-28 22:41:11 -0700681 return -ENOENT;
Steve French4b8f9302006-02-26 16:41:18 +0000682 }
Steve French31ca3bc2005-04-28 22:41:11 -0700683
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400684 /*
685 * Ensure that we do not send more than 50 overlapping requests
686 * to the same server. We may make this configurable later or
687 * use ses->maxReq.
688 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400690 rc = wait_for_free_request(ses->server, timeout, optype);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000691 if (rc) {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400692 cifs_small_buf_release(buf);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000693 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000695
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400696 /*
697 * Make sure that we sign in the same order that we send on this socket
698 * and avoid races inside tcp sendmsg code that could cause corruption
699 * of smb data.
700 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
Jeff Layton72ca5452008-12-01 07:09:36 -0500702 mutex_lock(&ses->server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703
Jeff Laytonfec344e2012-09-18 16:20:35 -0700704 midQ = ses->server->ops->setup_request(ses, &rqst);
705 if (IS_ERR(midQ)) {
Jeff Layton72ca5452008-12-01 07:09:36 -0500706 mutex_unlock(&ses->server->srv_mutex);
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400707 cifs_small_buf_release(buf);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000708 /* Update # of requests on wire to server */
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400709 add_credits(ses->server, 1, optype);
Jeff Laytonfec344e2012-09-18 16:20:35 -0700710 return PTR_ERR(midQ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400713 midQ->mid_state = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000714 cifs_in_send_inc(ses->server);
Jeff Layton0496e022008-12-30 12:39:16 -0500715 rc = smb_sendv(ses->server, iov, n_vec);
Steve French789e6662011-08-09 18:44:44 +0000716 cifs_in_send_dec(ses->server);
717 cifs_save_when_sent(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000718
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;
Jeff Layton2c8f9812011-05-19 16:22:52 -0400755 cFYI(1, "Bad MID state?");
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 Perchesb6b38f72010-04-21 03:50:45 +0000791 cERROR(1, "Null smb session");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 return -EIO;
793 }
Steve French79a58d12007-07-06 22:44:50 +0000794 if (ses->server == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000795 cERROR(1, "Null tcp session");
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 Perchesb6b38f72010-04-21 03:50:45 +0000808 cERROR(1, "Illegal length, greater than maximum frame, %d",
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000809 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 Layton72ca5452008-12-01 07:09:36 -0500843 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000844
Steve French79a58d12007-07-06 22:44:50 +0000845 if (rc < 0)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000846 goto out;
847
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400848 if (timeout == CIFS_ASYNC_OP)
Steve French133672e2007-11-13 22:41:37 +0000849 goto out;
Jeff Layton0ade6402011-01-11 07:24:02 -0500850
851 rc = wait_for_response(ses->server, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500852 if (rc != 0) {
Jeff Layton121b0462012-05-15 12:21:10 -0400853 send_cancel(ses->server, in_buf, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -0500854 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400855 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
Jeff Layton1be912d2011-01-28 07:08:28 -0500856 /* no longer considered to be "in-flight" */
857 midQ->callback = DeleteMidQEntry;
858 spin_unlock(&GlobalMid_Lock);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400859 add_credits(ses->server, 1, 0);
Jeff Layton1be912d2011-01-28 07:08:28 -0500860 return rc;
861 }
862 spin_unlock(&GlobalMid_Lock);
863 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864
Jeff Layton3c1105d2011-05-22 07:09:13 -0400865 rc = cifs_sync_mid_result(midQ, ses->server);
Jeff Layton053d5032011-01-11 07:24:02 -0500866 if (rc != 0) {
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400867 add_credits(ses->server, 1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 return rc;
869 }
Steve French50c2f752007-07-13 00:33:32 +0000870
Jeff Layton2c8f9812011-05-19 16:22:52 -0400871 if (!midQ->resp_buf || !out_buf ||
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400872 midQ->mid_state != MID_RESPONSE_RECEIVED) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 rc = -EIO;
Jeff Layton2c8f9812011-05-19 16:22:52 -0400874 cERROR(1, "Bad MID state?");
Steve French2b2bdfb2008-12-11 17:26:54 +0000875 goto out;
876 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400878 *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
Jeff Layton2c8f9812011-05-19 16:22:52 -0400879 memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
880 rc = cifs_check_receive(midQ, ses->server, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000881out:
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700882 cifs_delete_mid(midQ);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400883 add_credits(ses->server, 1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884
885 return rc;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000886}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000888/* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
889 blocking lock to return. */
890
891static int
Steve French96daf2b2011-05-27 04:34:02 +0000892send_lock_cancel(const unsigned int xid, struct cifs_tcon *tcon,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000893 struct smb_hdr *in_buf,
894 struct smb_hdr *out_buf)
895{
896 int bytes_returned;
Steve French96daf2b2011-05-27 04:34:02 +0000897 struct cifs_ses *ses = tcon->ses;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000898 LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
899
900 /* We just modify the current in_buf to change
901 the type of lock from LOCKING_ANDX_SHARED_LOCK
902 or LOCKING_ANDX_EXCLUSIVE_LOCK to
903 LOCKING_ANDX_CANCEL_LOCK. */
904
905 pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
906 pSMB->Timeout = 0;
Pavel Shilovsky88257362012-05-23 14:01:59 +0400907 pSMB->hdr.Mid = get_next_mid(ses->server);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000908
909 return SendReceive(xid, ses, in_buf, out_buf,
Jeff Layton77499812011-01-11 07:24:23 -0500910 &bytes_returned, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000911}
912
913int
Steve French96daf2b2011-05-27 04:34:02 +0000914SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000915 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
916 int *pbytes_returned)
917{
918 int rc = 0;
919 int rstart = 0;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000920 struct mid_q_entry *midQ;
Steve French96daf2b2011-05-27 04:34:02 +0000921 struct cifs_ses *ses;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000922
923 if (tcon == NULL || tcon->ses == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000924 cERROR(1, "Null smb session");
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000925 return -EIO;
926 }
927 ses = tcon->ses;
928
Steve French79a58d12007-07-06 22:44:50 +0000929 if (ses->server == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000930 cERROR(1, "Null tcp session");
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000931 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 }
933
Steve French79a58d12007-07-06 22:44:50 +0000934 if (ses->server->tcpStatus == CifsExiting)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000935 return -ENOENT;
936
Steve French79a58d12007-07-06 22:44:50 +0000937 /* Ensure that we do not send more than 50 overlapping requests
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000938 to the same server. We may make this configurable later or
939 use ses->maxReq */
940
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000941 if (be32_to_cpu(in_buf->smb_buf_length) > CIFSMaxBufSize +
942 MAX_CIFS_HDR_SIZE - 4) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000943 cERROR(1, "Illegal length, greater than maximum frame, %d",
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000944 be32_to_cpu(in_buf->smb_buf_length));
Volker Lendecke6d9c6d52008-12-08 20:50:24 +0000945 return -EIO;
946 }
947
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400948 rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP, 0);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000949 if (rc)
950 return rc;
951
Steve French79a58d12007-07-06 22:44:50 +0000952 /* make sure that we sign in the same order that we send on this socket
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000953 and avoid races inside tcp sendmsg code that could cause corruption
954 of smb data */
955
Jeff Layton72ca5452008-12-01 07:09:36 -0500956 mutex_lock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000957
958 rc = allocate_mid(ses, in_buf, &midQ);
959 if (rc) {
Jeff Layton72ca5452008-12-01 07:09:36 -0500960 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000961 return rc;
962 }
963
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000964 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
Volker Lendecke829049c2008-12-06 16:00:53 +0100965 if (rc) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700966 cifs_delete_mid(midQ);
Volker Lendecke829049c2008-12-06 16:00:53 +0100967 mutex_unlock(&ses->server->srv_mutex);
968 return rc;
969 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000970
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400971 midQ->mid_state = MID_REQUEST_SUBMITTED;
Steve French789e6662011-08-09 18:44:44 +0000972 cifs_in_send_inc(ses->server);
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000973 rc = smb_send(ses->server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
Steve French789e6662011-08-09 18:44:44 +0000974 cifs_in_send_dec(ses->server);
975 cifs_save_when_sent(midQ);
Jeff Layton72ca5452008-12-01 07:09:36 -0500976 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000977
Steve French79a58d12007-07-06 22:44:50 +0000978 if (rc < 0) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -0700979 cifs_delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000980 return rc;
981 }
982
983 /* Wait for a reply - allow signals to interrupt. */
984 rc = wait_event_interruptible(ses->server->response_q,
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400985 (!(midQ->mid_state == MID_REQUEST_SUBMITTED)) ||
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000986 ((ses->server->tcpStatus != CifsGood) &&
987 (ses->server->tcpStatus != CifsNew)));
988
989 /* Were we interrupted by a signal ? */
990 if ((rc == -ERESTARTSYS) &&
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400991 (midQ->mid_state == MID_REQUEST_SUBMITTED) &&
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000992 ((ses->server->tcpStatus == CifsGood) ||
993 (ses->server->tcpStatus == CifsNew))) {
994
995 if (in_buf->Command == SMB_COM_TRANSACTION2) {
996 /* POSIX lock. We send a NT_CANCEL SMB to cause the
997 blocking lock to return. */
Jeff Layton121b0462012-05-15 12:21:10 -0400998 rc = send_cancel(ses->server, in_buf, midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000999 if (rc) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -07001000 cifs_delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001001 return rc;
1002 }
1003 } else {
1004 /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
1005 to cause the blocking lock to return. */
1006
1007 rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
1008
1009 /* If we get -ENOLCK back the lock may have
1010 already been removed. Don't exit in this case. */
1011 if (rc && rc != -ENOLCK) {
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -07001012 cifs_delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001013 return rc;
1014 }
1015 }
1016
Jeff Layton1be912d2011-01-28 07:08:28 -05001017 rc = wait_for_response(ses->server, midQ);
1018 if (rc) {
Jeff Layton121b0462012-05-15 12:21:10 -04001019 send_cancel(ses->server, in_buf, midQ);
Jeff Layton1be912d2011-01-28 07:08:28 -05001020 spin_lock(&GlobalMid_Lock);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001021 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
Jeff Layton1be912d2011-01-28 07:08:28 -05001022 /* no longer considered to be "in-flight" */
1023 midQ->callback = DeleteMidQEntry;
1024 spin_unlock(&GlobalMid_Lock);
1025 return rc;
1026 }
1027 spin_unlock(&GlobalMid_Lock);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001028 }
Jeff Layton1be912d2011-01-28 07:08:28 -05001029
1030 /* We got the response - restart system call. */
1031 rstart = 1;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001032 }
1033
Jeff Layton3c1105d2011-05-22 07:09:13 -04001034 rc = cifs_sync_mid_result(midQ, ses->server);
Jeff Layton053d5032011-01-11 07:24:02 -05001035 if (rc != 0)
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001036 return rc;
Steve French50c2f752007-07-13 00:33:32 +00001037
Volker Lendecke17c8bfe2008-12-06 16:38:19 +01001038 /* rcvd frame is ok */
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001039 if (out_buf == NULL || midQ->mid_state != MID_RESPONSE_RECEIVED) {
Volker Lendecke17c8bfe2008-12-06 16:38:19 +01001040 rc = -EIO;
Joe Perchesb6b38f72010-04-21 03:50:45 +00001041 cERROR(1, "Bad MID state?");
Volker Lendecke698e96a2008-12-06 16:39:31 +01001042 goto out;
Volker Lendecke17c8bfe2008-12-06 16:38:19 +01001043 }
1044
Pavel Shilovskyd4e48542012-03-23 14:28:02 -04001045 *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
Jeff Layton2c8f9812011-05-19 16:22:52 -04001046 memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
1047 rc = cifs_check_receive(midQ, ses->server, 0);
Volker Lendecke17c8bfe2008-12-06 16:38:19 +01001048out:
Pavel Shilovsky3c1bf7e2012-09-18 16:20:30 -07001049 cifs_delete_mid(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001050 if (rstart && rc == -EACCES)
1051 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 return rc;
1053}