blob: e80210693ff70c964a17b636f041fb1c644749d8 [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>
25#include <linux/wait.h>
26#include <linux/net.h>
27#include <linux/delay.h>
28#include <asm/uaccess.h>
29#include <asm/processor.h>
30#include <linux/mempool.h>
31#include "cifspdu.h"
32#include "cifsglob.h"
33#include "cifsproto.h"
34#include "cifs_debug.h"
Steve French50c2f752007-07-13 00:33:32 +000035
Linus Torvalds1da177e2005-04-16 15:20:36 -070036extern mempool_t *cifs_mid_poolp;
Christoph Lametere18b8902006-12-06 20:33:20 -080037extern struct kmem_cache *cifs_oplock_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
39static struct mid_q_entry *
Jeff Layton24b9b062008-12-01 07:09:34 -050040AllocMidQEntry(const struct smb_hdr *smb_buffer, struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -070041{
42 struct mid_q_entry *temp;
43
Jeff Layton24b9b062008-12-01 07:09:34 -050044 if (server == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 cERROR(1, ("Null TCP session in AllocMidQEntry"));
46 return NULL;
47 }
Steve French50c2f752007-07-13 00:33:32 +000048
Pekka Enberg232087c2008-09-15 13:22:54 +030049 temp = mempool_alloc(cifs_mid_poolp, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -070050 if (temp == NULL)
51 return temp;
52 else {
Steve French26f57362007-08-30 22:09:15 +000053 memset(temp, 0, sizeof(struct mid_q_entry));
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 temp->mid = smb_buffer->Mid; /* always LE */
55 temp->pid = current->pid;
56 temp->command = smb_buffer->Command;
57 cFYI(1, ("For smb_command %d", temp->command));
Steve French1047abc2005-10-11 19:58:06 -070058 /* do_gettimeofday(&temp->when_sent);*/ /* easier to use jiffies */
59 /* when mid allocated can be before when sent */
60 temp->when_alloc = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 temp->tsk = current;
62 }
63
64 spin_lock(&GlobalMid_Lock);
Jeff Layton24b9b062008-12-01 07:09:34 -050065 list_add_tail(&temp->qhead, &server->pending_mid_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 atomic_inc(&midCount);
67 temp->midState = MID_REQUEST_ALLOCATED;
68 spin_unlock(&GlobalMid_Lock);
69 return temp;
70}
71
72static void
73DeleteMidQEntry(struct mid_q_entry *midEntry)
74{
Steve French1047abc2005-10-11 19:58:06 -070075#ifdef CONFIG_CIFS_STATS2
76 unsigned long now;
77#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 spin_lock(&GlobalMid_Lock);
79 midEntry->midState = MID_FREE;
80 list_del(&midEntry->qhead);
81 atomic_dec(&midCount);
82 spin_unlock(&GlobalMid_Lock);
Steve French79a58d12007-07-06 22:44:50 +000083 if (midEntry->largeBuf)
Steve Frenchb8643e12005-04-28 22:41:07 -070084 cifs_buf_release(midEntry->resp_buf);
85 else
86 cifs_small_buf_release(midEntry->resp_buf);
Steve French1047abc2005-10-11 19:58:06 -070087#ifdef CONFIG_CIFS_STATS2
88 now = jiffies;
89 /* commands taking longer than one second are indications that
90 something is wrong, unless it is quite a slow link or server */
Steve French79a58d12007-07-06 22:44:50 +000091 if ((now - midEntry->when_alloc) > HZ) {
92 if ((cifsFYI & CIFS_TIMER) &&
Steve French1047abc2005-10-11 19:58:06 -070093 (midEntry->command != SMB_COM_LOCKING_ANDX)) {
94 printk(KERN_DEBUG " CIFS slow rsp: cmd %d mid %d",
95 midEntry->command, midEntry->mid);
96 printk(" A: 0x%lx S: 0x%lx R: 0x%lx\n",
97 now - midEntry->when_alloc,
98 now - midEntry->when_sent,
99 now - midEntry->when_received);
100 }
101 }
102#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 mempool_free(midEntry, cifs_mid_poolp);
104}
105
106struct oplock_q_entry *
Steve French79a58d12007-07-06 22:44:50 +0000107AllocOplockQEntry(struct inode *pinode, __u16 fid, struct cifsTconInfo *tcon)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108{
109 struct oplock_q_entry *temp;
Steve French79a58d12007-07-06 22:44:50 +0000110 if ((pinode == NULL) || (tcon == NULL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 cERROR(1, ("Null parms passed to AllocOplockQEntry"));
112 return NULL;
113 }
114 temp = (struct oplock_q_entry *) kmem_cache_alloc(cifs_oplock_cachep,
Christoph Lametere94b1762006-12-06 20:33:17 -0800115 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 if (temp == NULL)
117 return temp;
118 else {
119 temp->pinode = pinode;
120 temp->tcon = tcon;
121 temp->netfid = fid;
122 spin_lock(&GlobalMid_Lock);
123 list_add_tail(&temp->qhead, &GlobalOplock_Q);
124 spin_unlock(&GlobalMid_Lock);
125 }
126 return temp;
127
128}
129
Steve French79a58d12007-07-06 22:44:50 +0000130void DeleteOplockQEntry(struct oplock_q_entry *oplockEntry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131{
Steve French79a58d12007-07-06 22:44:50 +0000132 spin_lock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 /* should we check if list empty first? */
134 list_del(&oplockEntry->qhead);
135 spin_unlock(&GlobalMid_Lock);
136 kmem_cache_free(cifs_oplock_cachep, oplockEntry);
137}
138
Steve French5d941ca2008-04-15 18:40:48 +0000139
140void DeleteTconOplockQEntries(struct cifsTconInfo *tcon)
141{
142 struct oplock_q_entry *temp;
143
144 if (tcon == NULL)
145 return;
146
147 spin_lock(&GlobalMid_Lock);
148 list_for_each_entry(temp, &GlobalOplock_Q, qhead) {
149 if ((temp->tcon) && (temp->tcon == tcon)) {
150 list_del(&temp->qhead);
151 kmem_cache_free(cifs_oplock_cachep, temp);
152 }
153 }
154 spin_unlock(&GlobalMid_Lock);
155}
156
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157int
158smb_send(struct socket *ssocket, struct smb_hdr *smb_buffer,
Steve Frenchedf1ae42008-10-29 00:47:57 +0000159 unsigned int smb_buf_length, struct sockaddr *sin, bool noblocksnd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160{
161 int rc = 0;
162 int i = 0;
163 struct msghdr smb_msg;
164 struct kvec iov;
165 unsigned len = smb_buf_length + 4;
166
Steve French79a58d12007-07-06 22:44:50 +0000167 if (ssocket == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 return -ENOTSOCK; /* BB eventually add reconnect code here */
169 iov.iov_base = smb_buffer;
170 iov.iov_len = len;
171
172 smb_msg.msg_name = sin;
Steve French26f57362007-08-30 22:09:15 +0000173 smb_msg.msg_namelen = sizeof(struct sockaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 smb_msg.msg_control = NULL;
175 smb_msg.msg_controllen = 0;
Steve Frenchedf1ae42008-10-29 00:47:57 +0000176 if (noblocksnd)
177 smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL;
178 else
179 smb_msg.msg_flags = MSG_NOSIGNAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180
181 /* smb header is converted in header_assemble. bcc and rest of SMB word
Steve French79a58d12007-07-06 22:44:50 +0000182 area, and byte area if necessary, is converted to littleendian in
183 cifssmb.c and RFC1001 len is converted to bigendian in smb_send
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 Flags2 is converted in SendReceive */
185
186 smb_buffer->smb_buf_length = cpu_to_be32(smb_buffer->smb_buf_length);
Steve French3e844692005-10-03 13:37:24 -0700187 cFYI(1, ("Sending smb of length %d", smb_buf_length));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 dump_smb(smb_buffer, len);
189
190 while (len > 0) {
191 rc = kernel_sendmsg(ssocket, &smb_msg, &iov, 1, len);
192 if ((rc == -ENOSPC) || (rc == -EAGAIN)) {
193 i++;
Steve French3e844692005-10-03 13:37:24 -0700194 /* smaller timeout here than send2 since smaller size */
Steve French79a58d12007-07-06 22:44:50 +0000195 /* Although it may not be required, this also is smaller
196 oplock break time */
197 if (i > 12) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 cERROR(1,
Steve French68058e72005-10-10 10:34:22 -0700199 ("sends on sock %p stuck for 7 seconds",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 ssocket));
201 rc = -EAGAIN;
202 break;
203 }
Steve French68058e72005-10-10 10:34:22 -0700204 msleep(1 << i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 continue;
206 }
Steve French79a58d12007-07-06 22:44:50 +0000207 if (rc < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 break;
Steve French5e1253b2005-10-10 14:06:37 -0700209 else
210 i = 0; /* reset i after each successful send */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 iov.iov_base += rc;
212 iov.iov_len -= rc;
213 len -= rc;
214 }
215
216 if (rc < 0) {
Steve French79a58d12007-07-06 22:44:50 +0000217 cERROR(1, ("Error %d sending data on socket to server", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 } else {
219 rc = 0;
220 }
221
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000222 /* Don't want to modify the buffer as a
223 side effect of this call. */
224 smb_buffer->smb_buf_length = smb_buf_length;
225
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 return rc;
227}
228
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500229static int
Steve Frenchedf1ae42008-10-29 00:47:57 +0000230smb_send2(struct TCP_Server_Info *server, struct kvec *iov, int n_vec,
231 struct sockaddr *sin, bool noblocksnd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232{
233 int rc = 0;
234 int i = 0;
235 struct msghdr smb_msg;
Steve French3e844692005-10-03 13:37:24 -0700236 struct smb_hdr *smb_buffer = iov[0].iov_base;
237 unsigned int len = iov[0].iov_len;
238 unsigned int total_len;
239 int first_vec = 0;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000240 unsigned int smb_buf_length = smb_buffer->smb_buf_length;
Steve Frenchedf1ae42008-10-29 00:47:57 +0000241 struct socket *ssocket = server->ssocket;
Steve French50c2f752007-07-13 00:33:32 +0000242
Steve French79a58d12007-07-06 22:44:50 +0000243 if (ssocket == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 return -ENOTSOCK; /* BB eventually add reconnect code here */
Steve French3e844692005-10-03 13:37:24 -0700245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 smb_msg.msg_name = sin;
Steve French26f57362007-08-30 22:09:15 +0000247 smb_msg.msg_namelen = sizeof(struct sockaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 smb_msg.msg_control = NULL;
249 smb_msg.msg_controllen = 0;
Steve Frenchedf1ae42008-10-29 00:47:57 +0000250 if (noblocksnd)
251 smb_msg.msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL;
252 else
253 smb_msg.msg_flags = MSG_NOSIGNAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
255 /* smb header is converted in header_assemble. bcc and rest of SMB word
Steve French79a58d12007-07-06 22:44:50 +0000256 area, and byte area if necessary, is converted to littleendian in
257 cifssmb.c and RFC1001 len is converted to bigendian in smb_send
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 Flags2 is converted in SendReceive */
259
Steve French3e844692005-10-03 13:37:24 -0700260
261 total_len = 0;
262 for (i = 0; i < n_vec; i++)
263 total_len += iov[i].iov_len;
264
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 smb_buffer->smb_buf_length = cpu_to_be32(smb_buffer->smb_buf_length);
Steve French3e844692005-10-03 13:37:24 -0700266 cFYI(1, ("Sending smb: total_len %d", total_len));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 dump_smb(smb_buffer, len);
268
Shirish Pargaonkar17680352008-07-29 21:26:13 +0000269 i = 0;
Steve French3e844692005-10-03 13:37:24 -0700270 while (total_len) {
271 rc = kernel_sendmsg(ssocket, &smb_msg, &iov[first_vec],
272 n_vec - first_vec, total_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 if ((rc == -ENOSPC) || (rc == -EAGAIN)) {
274 i++;
Steve French79a58d12007-07-06 22:44:50 +0000275 if (i >= 14) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 cERROR(1,
Steve French68058e72005-10-10 10:34:22 -0700277 ("sends on sock %p stuck for 15 seconds",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 ssocket));
279 rc = -EAGAIN;
280 break;
281 }
Steve French68058e72005-10-10 10:34:22 -0700282 msleep(1 << i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 continue;
284 }
Steve French79a58d12007-07-06 22:44:50 +0000285 if (rc < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 break;
Steve French3e844692005-10-03 13:37:24 -0700287
Steve French61de8002008-10-30 20:15:22 +0000288 if (rc == total_len) {
289 total_len = 0;
290 break;
291 } else if (rc > total_len) {
292 cERROR(1, ("sent %d requested %d", rc, total_len));
Steve French3e844692005-10-03 13:37:24 -0700293 break;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500294 }
Steve French79a58d12007-07-06 22:44:50 +0000295 if (rc == 0) {
Steve French3e844692005-10-03 13:37:24 -0700296 /* should never happen, letting socket clear before
297 retrying is our only obvious option here */
Steve French79a58d12007-07-06 22:44:50 +0000298 cERROR(1, ("tcp sent no data"));
Steve French3e844692005-10-03 13:37:24 -0700299 msleep(500);
300 continue;
301 }
302 total_len -= rc;
Steve French68058e72005-10-10 10:34:22 -0700303 /* the line below resets i */
Steve French3e844692005-10-03 13:37:24 -0700304 for (i = first_vec; i < n_vec; i++) {
305 if (iov[i].iov_len) {
306 if (rc > iov[i].iov_len) {
307 rc -= iov[i].iov_len;
308 iov[i].iov_len = 0;
309 } else {
310 iov[i].iov_base += rc;
311 iov[i].iov_len -= rc;
312 first_vec = i;
313 break;
314 }
315 }
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500316 }
Steve French5e1253b2005-10-10 14:06:37 -0700317 i = 0; /* in case we get ENOSPC on the next send */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 }
319
Steve Frenchedf1ae42008-10-29 00:47:57 +0000320 if ((total_len > 0) && (total_len != smb_buf_length + 4)) {
321 cFYI(1, ("partial send (%d remaining), terminating session",
322 total_len));
323 /* If we have only sent part of an SMB then the next SMB
324 could be taken as the remainder of this one. We need
325 to kill the socket so the server throws away the partial
326 SMB */
327 server->tcpStatus = CifsNeedReconnect;
328 }
329
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 if (rc < 0) {
Steve French79a58d12007-07-06 22:44:50 +0000331 cERROR(1, ("Error %d sending data on socket to server", rc));
Steve French3e844692005-10-03 13:37:24 -0700332 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000335 /* Don't want to modify the buffer as a
336 side effect of this call. */
337 smb_buffer->smb_buf_length = smb_buf_length;
338
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 return rc;
340}
341
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000342static int wait_for_free_request(struct cifsSesInfo *ses, const int long_op)
343{
Steve French133672e2007-11-13 22:41:37 +0000344 if (long_op == CIFS_ASYNC_OP) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000345 /* oplock breaks must not be held up */
346 atomic_inc(&ses->server->inFlight);
347 } else {
Steve French79a58d12007-07-06 22:44:50 +0000348 spin_lock(&GlobalMid_Lock);
349 while (1) {
350 if (atomic_read(&ses->server->inFlight) >=
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000351 cifs_max_pending){
352 spin_unlock(&GlobalMid_Lock);
353#ifdef CONFIG_CIFS_STATS2
354 atomic_inc(&ses->server->num_waiters);
355#endif
356 wait_event(ses->server->request_q,
357 atomic_read(&ses->server->inFlight)
358 < cifs_max_pending);
359#ifdef CONFIG_CIFS_STATS2
360 atomic_dec(&ses->server->num_waiters);
361#endif
362 spin_lock(&GlobalMid_Lock);
363 } else {
Steve French79a58d12007-07-06 22:44:50 +0000364 if (ses->server->tcpStatus == CifsExiting) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000365 spin_unlock(&GlobalMid_Lock);
366 return -ENOENT;
367 }
368
Steve French79a58d12007-07-06 22:44:50 +0000369 /* can not count locking commands against total
370 as they are allowed to block on server */
Steve French50c2f752007-07-13 00:33:32 +0000371
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000372 /* update # of requests on the wire to server */
Steve French133672e2007-11-13 22:41:37 +0000373 if (long_op != CIFS_BLOCKING_OP)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000374 atomic_inc(&ses->server->inFlight);
375 spin_unlock(&GlobalMid_Lock);
376 break;
377 }
378 }
379 }
380 return 0;
381}
382
383static int allocate_mid(struct cifsSesInfo *ses, struct smb_hdr *in_buf,
384 struct mid_q_entry **ppmidQ)
385{
386 if (ses->server->tcpStatus == CifsExiting) {
387 return -ENOENT;
388 } else if (ses->server->tcpStatus == CifsNeedReconnect) {
Steve French79a58d12007-07-06 22:44:50 +0000389 cFYI(1, ("tcp session dead - return to caller to retry"));
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000390 return -EAGAIN;
391 } else if (ses->status != CifsGood) {
392 /* check if SMB session is bad because we are setting it up */
Steve French79a58d12007-07-06 22:44:50 +0000393 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
Steve Frenchad7a2922008-02-07 23:25:02 +0000394 (in_buf->Command != SMB_COM_NEGOTIATE))
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000395 return -EAGAIN;
Steve Frenchad7a2922008-02-07 23:25:02 +0000396 /* else ok - we are setting up session */
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000397 }
Jeff Layton24b9b062008-12-01 07:09:34 -0500398 *ppmidQ = AllocMidQEntry(in_buf, ses->server);
Steve French26f57362007-08-30 22:09:15 +0000399 if (*ppmidQ == NULL)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000400 return -ENOMEM;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000401 return 0;
402}
403
Steve French79a58d12007-07-06 22:44:50 +0000404static int wait_for_response(struct cifsSesInfo *ses,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000405 struct mid_q_entry *midQ,
406 unsigned long timeout,
407 unsigned long time_to_wait)
408{
409 unsigned long curr_timeout;
410
411 for (;;) {
412 curr_timeout = timeout + jiffies;
Jeff Layton85705522008-12-05 20:41:21 -0500413 wait_event_timeout(ses->server->response_q,
414 midQ->midState != MID_REQUEST_SUBMITTED, timeout);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000415
416 if (time_after(jiffies, curr_timeout) &&
417 (midQ->midState == MID_REQUEST_SUBMITTED) &&
418 ((ses->server->tcpStatus == CifsGood) ||
419 (ses->server->tcpStatus == CifsNew))) {
420
421 unsigned long lrt;
422
423 /* We timed out. Is the server still
424 sending replies ? */
425 spin_lock(&GlobalMid_Lock);
426 lrt = ses->server->lstrp;
427 spin_unlock(&GlobalMid_Lock);
428
429 /* Calculate time_to_wait past last receive time.
Steve French79a58d12007-07-06 22:44:50 +0000430 Although we prefer not to time out if the
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000431 server is still responding - we will time
Steve French79a58d12007-07-06 22:44:50 +0000432 out if the server takes more than 15 (or 45
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000433 or 180) seconds to respond to this request
Steve French79a58d12007-07-06 22:44:50 +0000434 and has not responded to any request from
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000435 other threads on the client within 10 seconds */
436 lrt += time_to_wait;
437 if (time_after(jiffies, lrt)) {
438 /* No replies for time_to_wait. */
Steve French79a58d12007-07-06 22:44:50 +0000439 cERROR(1, ("server not responding"));
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000440 return -1;
441 }
442 } else {
443 return 0;
444 }
445 }
446}
447
Steve French133672e2007-11-13 22:41:37 +0000448
449/*
450 *
451 * Send an SMB Request. No response info (other than return code)
452 * needs to be parsed.
453 *
454 * flags indicate the type of request buffer and how long to wait
455 * and whether to log NT STATUS code (error) before mapping it to POSIX error
456 *
457 */
458int
459SendReceiveNoRsp(const unsigned int xid, struct cifsSesInfo *ses,
460 struct smb_hdr *in_buf, int flags)
461{
462 int rc;
463 struct kvec iov[1];
464 int resp_buf_type;
465
466 iov[0].iov_base = (char *)in_buf;
467 iov[0].iov_len = in_buf->smb_buf_length + 4;
468 flags |= CIFS_NO_RESP;
469 rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
Steve French90c81e02008-02-12 20:32:36 +0000470 cFYI(DBG2, ("SendRcvNoRsp flags %d rc %d", flags, rc));
471
Steve French133672e2007-11-13 22:41:37 +0000472 return rc;
473}
474
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475int
Steve French79a58d12007-07-06 22:44:50 +0000476SendReceive2(const unsigned int xid, struct cifsSesInfo *ses,
477 struct kvec *iov, int n_vec, int *pRespBufType /* ret */,
Steve French133672e2007-11-13 22:41:37 +0000478 const int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479{
480 int rc = 0;
Steve French133672e2007-11-13 22:41:37 +0000481 int long_op;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500482 unsigned int receive_len;
483 unsigned long timeout;
484 struct mid_q_entry *midQ;
Steve French3e844692005-10-03 13:37:24 -0700485 struct smb_hdr *in_buf = iov[0].iov_base;
Steve French50c2f752007-07-13 00:33:32 +0000486
Steve French133672e2007-11-13 22:41:37 +0000487 long_op = flags & CIFS_TIMEOUT_MASK;
488
Steve Frenchec637e32005-12-12 20:53:18 -0800489 *pRespBufType = CIFS_NO_BUFFER; /* no response buf yet */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490
Steve French4b8f9302006-02-26 16:41:18 +0000491 if ((ses == NULL) || (ses->server == NULL)) {
492 cifs_small_buf_release(in_buf);
Steve French79a58d12007-07-06 22:44:50 +0000493 cERROR(1, ("Null session"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 return -EIO;
495 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496
Steve French79a58d12007-07-06 22:44:50 +0000497 if (ses->server->tcpStatus == CifsExiting) {
Steve French4b8f9302006-02-26 16:41:18 +0000498 cifs_small_buf_release(in_buf);
Steve French31ca3bc2005-04-28 22:41:11 -0700499 return -ENOENT;
Steve French4b8f9302006-02-26 16:41:18 +0000500 }
Steve French31ca3bc2005-04-28 22:41:11 -0700501
Steve French79a58d12007-07-06 22:44:50 +0000502 /* Ensure that we do not send more than 50 overlapping requests
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 to the same server. We may make this configurable later or
504 use ses->maxReq */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000506 rc = wait_for_free_request(ses, long_op);
507 if (rc) {
508 cifs_small_buf_release(in_buf);
509 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000511
Steve French79a58d12007-07-06 22:44:50 +0000512 /* make sure that we sign in the same order that we send on this socket
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 and avoid races inside tcp sendmsg code that could cause corruption
514 of smb data */
515
Jeff Layton72ca5452008-12-01 07:09:36 -0500516 mutex_lock(&ses->server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000518 rc = allocate_mid(ses, in_buf, &midQ);
519 if (rc) {
Jeff Layton72ca5452008-12-01 07:09:36 -0500520 mutex_unlock(&ses->server->srv_mutex);
Steve French4b8f9302006-02-26 16:41:18 +0000521 cifs_small_buf_release(in_buf);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000522 /* Update # of requests on wire to server */
Steve French79a58d12007-07-06 22:44:50 +0000523 atomic_dec(&ses->server->inFlight);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000524 wake_up(&ses->server->request_q);
525 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 }
Steve French79a58d12007-07-06 22:44:50 +0000527 rc = cifs_sign_smb2(iov, n_vec, ses->server, &midQ->sequence_number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
529 midQ->midState = MID_REQUEST_SUBMITTED;
Steve French131afd0b2005-10-07 09:51:05 -0700530#ifdef CONFIG_CIFS_STATS2
531 atomic_inc(&ses->server->inSend);
532#endif
Steve Frenchedf1ae42008-10-29 00:47:57 +0000533 rc = smb_send2(ses->server, iov, n_vec,
534 (struct sockaddr *) &(ses->server->addr.sockAddr),
535 ses->server->noblocksnd);
Steve French131afd0b2005-10-07 09:51:05 -0700536#ifdef CONFIG_CIFS_STATS2
537 atomic_dec(&ses->server->inSend);
Steve French1047abc2005-10-11 19:58:06 -0700538 midQ->when_sent = jiffies;
Steve French131afd0b2005-10-07 09:51:05 -0700539#endif
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000540
Jeff Layton72ca5452008-12-01 07:09:36 -0500541 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000542 cifs_small_buf_release(in_buf);
543
Steve French79a58d12007-07-06 22:44:50 +0000544 if (rc < 0)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000545 goto out;
Steve French4b8f9302006-02-26 16:41:18 +0000546
Steve French133672e2007-11-13 22:41:37 +0000547 if (long_op == CIFS_STD_OP)
548 timeout = 15 * HZ;
549 else if (long_op == CIFS_VLONG_OP) /* e.g. slow writes past EOF */
Steve French37c0eb42005-10-05 14:50:29 -0700550 timeout = 180 * HZ;
Steve French133672e2007-11-13 22:41:37 +0000551 else if (long_op == CIFS_LONG_OP)
Steve French79a58d12007-07-06 22:44:50 +0000552 timeout = 45 * HZ; /* should be greater than
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500553 servers oplock break timeout (about 43 seconds) */
Steve French133672e2007-11-13 22:41:37 +0000554 else if (long_op == CIFS_ASYNC_OP)
555 goto out;
556 else if (long_op == CIFS_BLOCKING_OP)
557 timeout = 0x7FFFFFFF; /* large, but not so large as to wrap */
558 else {
559 cERROR(1, ("unknown timeout flag %d", long_op));
560 rc = -EIO;
561 goto out;
562 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000563
Steve French79a58d12007-07-06 22:44:50 +0000564 /* wait for 15 seconds or until woken up due to response arriving or
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500565 due to last connection to this server being unmounted */
566 if (signal_pending(current)) {
567 /* if signal pending do not hold up user for full smb timeout
Steve French8a236262007-03-06 00:31:00 +0000568 but we still give response a chance to complete */
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500569 timeout = 2 * HZ;
Steve French79a58d12007-07-06 22:44:50 +0000570 }
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500571
572 /* No user interrupts in wait - wreaks havoc with performance */
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000573 wait_for_response(ses, midQ, timeout, 10 * HZ);
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500574
575 spin_lock(&GlobalMid_Lock);
576 if (midQ->resp_buf) {
577 spin_unlock(&GlobalMid_Lock);
Steve French70ca7342005-09-22 16:32:06 -0700578 receive_len = midQ->resp_buf->smb_buf_length;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500579 } else {
Steve French79a58d12007-07-06 22:44:50 +0000580 cERROR(1, ("No response to cmd %d mid %d",
Steve French37c0eb42005-10-05 14:50:29 -0700581 midQ->command, midQ->mid));
Steve French79a58d12007-07-06 22:44:50 +0000582 if (midQ->midState == MID_REQUEST_SUBMITTED) {
583 if (ses->server->tcpStatus == CifsExiting)
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500584 rc = -EHOSTDOWN;
585 else {
586 ses->server->tcpStatus = CifsNeedReconnect;
587 midQ->midState = MID_RETRY_NEEDED;
588 }
589 }
590
591 if (rc != -EHOSTDOWN) {
Steve French79a58d12007-07-06 22:44:50 +0000592 if (midQ->midState == MID_RETRY_NEEDED) {
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500593 rc = -EAGAIN;
Steve French79a58d12007-07-06 22:44:50 +0000594 cFYI(1, ("marking request for retry"));
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500595 } else {
596 rc = -EIO;
597 }
598 }
599 spin_unlock(&GlobalMid_Lock);
600 DeleteMidQEntry(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000601 /* Update # of requests on wire to server */
Steve French79a58d12007-07-06 22:44:50 +0000602 atomic_dec(&ses->server->inFlight);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000603 wake_up(&ses->server->request_q);
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500604 return rc;
605 }
Steve French50c2f752007-07-13 00:33:32 +0000606
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500607 if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
608 cERROR(1, ("Frame too large received. Length: %d Xid: %d",
609 receive_len, xid));
610 rc = -EIO;
611 } else { /* rcvd frame is ok */
Steve French79a58d12007-07-06 22:44:50 +0000612 if (midQ->resp_buf &&
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500613 (midQ->midState == MID_RESPONSE_RECEIVED)) {
Steve French84afc292005-12-02 13:32:45 -0800614
Steve Frenchec637e32005-12-12 20:53:18 -0800615 iov[0].iov_base = (char *)midQ->resp_buf;
Steve French79a58d12007-07-06 22:44:50 +0000616 if (midQ->largeBuf)
Steve Frenchec637e32005-12-12 20:53:18 -0800617 *pRespBufType = CIFS_LARGE_BUFFER;
618 else
619 *pRespBufType = CIFS_SMALL_BUFFER;
620 iov[0].iov_len = receive_len + 4;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500621
Steve Frenchec637e32005-12-12 20:53:18 -0800622 dump_smb(midQ->resp_buf, 80);
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500623 /* convert the length into a more usable form */
Steve French79a58d12007-07-06 22:44:50 +0000624 if ((receive_len > 24) &&
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500625 (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
626 SECMODE_SIGN_ENABLED))) {
Steve Frenchec637e32005-12-12 20:53:18 -0800627 rc = cifs_verify_signature(midQ->resp_buf,
Steve Frenchb609f062007-07-09 07:55:14 +0000628 &ses->server->mac_signing_key,
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500629 midQ->sequence_number+1);
Steve French79a58d12007-07-06 22:44:50 +0000630 if (rc) {
631 cERROR(1, ("Unexpected SMB signature"));
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500632 /* BB FIXME add code to kill session */
633 }
634 }
635
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500636 /* BB special case reconnect tid and uid here? */
Steve French133672e2007-11-13 22:41:37 +0000637 rc = map_smb_to_linux_error(midQ->resp_buf,
638 flags & CIFS_LOG_ERROR);
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500639
640 /* convert ByteCount if necessary */
Steve French26f57362007-08-30 22:09:15 +0000641 if (receive_len >= sizeof(struct smb_hdr) - 4
642 /* do not count RFC1001 header */ +
Steve Frenchec637e32005-12-12 20:53:18 -0800643 (2 * midQ->resp_buf->WordCount) + 2 /* bcc */ )
Steve French79a58d12007-07-06 22:44:50 +0000644 BCC(midQ->resp_buf) =
Steve Frenchec637e32005-12-12 20:53:18 -0800645 le16_to_cpu(BCC_LE(midQ->resp_buf));
Steve French133672e2007-11-13 22:41:37 +0000646 if ((flags & CIFS_NO_RESP) == 0)
647 midQ->resp_buf = NULL; /* mark it so buf will
648 not be freed by
649 DeleteMidQEntry */
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500650 } else {
651 rc = -EIO;
Steve French79a58d12007-07-06 22:44:50 +0000652 cFYI(1, ("Bad MID state?"));
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500653 }
654 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000655
656out:
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500657 DeleteMidQEntry(midQ);
Steve French79a58d12007-07-06 22:44:50 +0000658 atomic_dec(&ses->server->inFlight);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000659 wake_up(&ses->server->request_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660
661 return rc;
662}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663
664int
665SendReceive(const unsigned int xid, struct cifsSesInfo *ses,
666 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
667 int *pbytes_returned, const int long_op)
668{
669 int rc = 0;
670 unsigned int receive_len;
671 unsigned long timeout;
672 struct mid_q_entry *midQ;
673
674 if (ses == NULL) {
Steve French79a58d12007-07-06 22:44:50 +0000675 cERROR(1, ("Null smb session"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 return -EIO;
677 }
Steve French79a58d12007-07-06 22:44:50 +0000678 if (ses->server == NULL) {
679 cERROR(1, ("Null tcp session"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 return -EIO;
681 }
682
Steve French79a58d12007-07-06 22:44:50 +0000683 if (ses->server->tcpStatus == CifsExiting)
Steve French31ca3bc2005-04-28 22:41:11 -0700684 return -ENOENT;
685
Steve French79a58d12007-07-06 22:44:50 +0000686 /* Ensure that we do not send more than 50 overlapping requests
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 to the same server. We may make this configurable later or
688 use ses->maxReq */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
Volker Lendecke6d9c6d52008-12-08 20:50:24 +0000690 if (in_buf->smb_buf_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
691 cERROR(1, ("Illegal length, greater than maximum frame, %d",
692 in_buf->smb_buf_length));
693 return -EIO;
694 }
695
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000696 rc = wait_for_free_request(ses, long_op);
697 if (rc)
698 return rc;
699
Steve French79a58d12007-07-06 22:44:50 +0000700 /* make sure that we sign in the same order that we send on this socket
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 and avoid races inside tcp sendmsg code that could cause corruption
702 of smb data */
703
Jeff Layton72ca5452008-12-01 07:09:36 -0500704 mutex_lock(&ses->server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000706 rc = allocate_mid(ses, in_buf, &midQ);
707 if (rc) {
Jeff Layton72ca5452008-12-01 07:09:36 -0500708 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000709 /* Update # of requests on wire to server */
Steve French79a58d12007-07-06 22:44:50 +0000710 atomic_dec(&ses->server->inFlight);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000711 wake_up(&ses->server->request_q);
712 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 }
714
Steve Frenchad009ac2005-04-28 22:41:05 -0700715 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716
717 midQ->midState = MID_REQUEST_SUBMITTED;
Steve French131afd0b2005-10-07 09:51:05 -0700718#ifdef CONFIG_CIFS_STATS2
719 atomic_inc(&ses->server->inSend);
720#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 rc = smb_send(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
Steve Frenchedf1ae42008-10-29 00:47:57 +0000722 (struct sockaddr *) &(ses->server->addr.sockAddr),
723 ses->server->noblocksnd);
Steve French131afd0b2005-10-07 09:51:05 -0700724#ifdef CONFIG_CIFS_STATS2
725 atomic_dec(&ses->server->inSend);
Steve French1047abc2005-10-11 19:58:06 -0700726 midQ->when_sent = jiffies;
Steve French131afd0b2005-10-07 09:51:05 -0700727#endif
Jeff Layton72ca5452008-12-01 07:09:36 -0500728 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000729
Steve French79a58d12007-07-06 22:44:50 +0000730 if (rc < 0)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000731 goto out;
732
Steve French133672e2007-11-13 22:41:37 +0000733 if (long_op == CIFS_STD_OP)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 timeout = 15 * HZ;
Steve French79a58d12007-07-06 22:44:50 +0000735 /* wait for 15 seconds or until woken up due to response arriving or
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 due to last connection to this server being unmounted */
Steve French133672e2007-11-13 22:41:37 +0000737 else if (long_op == CIFS_ASYNC_OP)
738 goto out;
739 else if (long_op == CIFS_VLONG_OP) /* writes past EOF can be slow */
740 timeout = 180 * HZ;
741 else if (long_op == CIFS_LONG_OP)
742 timeout = 45 * HZ; /* should be greater than
743 servers oplock break timeout (about 43 seconds) */
744 else if (long_op == CIFS_BLOCKING_OP)
745 timeout = 0x7FFFFFFF; /* large but no so large as to wrap */
746 else {
747 cERROR(1, ("unknown timeout flag %d", long_op));
748 rc = -EIO;
749 goto out;
750 }
751
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 if (signal_pending(current)) {
753 /* if signal pending do not hold up user for full smb timeout
Steve French8a236262007-03-06 00:31:00 +0000754 but we still give response a chance to complete */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 timeout = 2 * HZ;
Steve French79a58d12007-07-06 22:44:50 +0000756 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757
758 /* No user interrupts in wait - wreaks havoc with performance */
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000759 wait_for_response(ses, midQ, timeout, 10 * HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760
761 spin_lock(&GlobalMid_Lock);
762 if (midQ->resp_buf) {
763 spin_unlock(&GlobalMid_Lock);
Steve French70ca7342005-09-22 16:32:06 -0700764 receive_len = midQ->resp_buf->smb_buf_length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 } else {
Steve French79a58d12007-07-06 22:44:50 +0000766 cERROR(1, ("No response for cmd %d mid %d",
Steve French37c0eb42005-10-05 14:50:29 -0700767 midQ->command, midQ->mid));
Steve French79a58d12007-07-06 22:44:50 +0000768 if (midQ->midState == MID_REQUEST_SUBMITTED) {
769 if (ses->server->tcpStatus == CifsExiting)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 rc = -EHOSTDOWN;
771 else {
772 ses->server->tcpStatus = CifsNeedReconnect;
773 midQ->midState = MID_RETRY_NEEDED;
774 }
775 }
776
777 if (rc != -EHOSTDOWN) {
Steve French79a58d12007-07-06 22:44:50 +0000778 if (midQ->midState == MID_RETRY_NEEDED) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 rc = -EAGAIN;
Steve French79a58d12007-07-06 22:44:50 +0000780 cFYI(1, ("marking request for retry"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 } else {
782 rc = -EIO;
783 }
784 }
785 spin_unlock(&GlobalMid_Lock);
786 DeleteMidQEntry(midQ);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000787 /* Update # of requests on wire to server */
Steve French79a58d12007-07-06 22:44:50 +0000788 atomic_dec(&ses->server->inFlight);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000789 wake_up(&ses->server->request_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 return rc;
791 }
Steve French50c2f752007-07-13 00:33:32 +0000792
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
Steve Frenchad009ac2005-04-28 22:41:05 -0700794 cERROR(1, ("Frame too large received. Length: %d Xid: %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 receive_len, xid));
796 rc = -EIO;
797 } else { /* rcvd frame is ok */
798
799 if (midQ->resp_buf && out_buf
800 && (midQ->midState == MID_RESPONSE_RECEIVED)) {
801 out_buf->smb_buf_length = receive_len;
802 memcpy((char *)out_buf + 4,
803 (char *)midQ->resp_buf + 4,
804 receive_len);
805
806 dump_smb(out_buf, 92);
807 /* convert the length into a more usable form */
Steve French79a58d12007-07-06 22:44:50 +0000808 if ((receive_len > 24) &&
Steve Frenchad009ac2005-04-28 22:41:05 -0700809 (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
810 SECMODE_SIGN_ENABLED))) {
811 rc = cifs_verify_signature(out_buf,
Steve Frenchb609f062007-07-09 07:55:14 +0000812 &ses->server->mac_signing_key,
Steve Frenchad009ac2005-04-28 22:41:05 -0700813 midQ->sequence_number+1);
Steve French79a58d12007-07-06 22:44:50 +0000814 if (rc) {
815 cERROR(1, ("Unexpected SMB signature"));
Steve French275cde12005-04-28 22:41:10 -0700816 /* BB FIXME add code to kill session */
Steve Frenchad009ac2005-04-28 22:41:05 -0700817 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 }
819
820 *pbytes_returned = out_buf->smb_buf_length;
821
Steve Frenchad009ac2005-04-28 22:41:05 -0700822 /* BB special case reconnect tid and uid here? */
Steve Frencha761ac52007-10-18 21:45:27 +0000823 rc = map_smb_to_linux_error(out_buf, 0 /* no log */ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
825 /* convert ByteCount if necessary */
Steve French26f57362007-08-30 22:09:15 +0000826 if (receive_len >= sizeof(struct smb_hdr) - 4
827 /* do not count RFC1001 header */ +
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 (2 * out_buf->WordCount) + 2 /* bcc */ )
Steve French0f2b27c2005-11-16 14:25:50 -0800829 BCC(out_buf) = le16_to_cpu(BCC_LE(out_buf));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 } else {
831 rc = -EIO;
Steve French79a58d12007-07-06 22:44:50 +0000832 cERROR(1, ("Bad MID state?"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 }
834 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000836out:
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000837 DeleteMidQEntry(midQ);
Steve French79a58d12007-07-06 22:44:50 +0000838 atomic_dec(&ses->server->inFlight);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000839 wake_up(&ses->server->request_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840
841 return rc;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000842}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000844/* Send an NT_CANCEL SMB to cause the POSIX blocking lock to return. */
845
846static int
847send_nt_cancel(struct cifsTconInfo *tcon, struct smb_hdr *in_buf,
848 struct mid_q_entry *midQ)
849{
850 int rc = 0;
851 struct cifsSesInfo *ses = tcon->ses;
852 __u16 mid = in_buf->Mid;
853
854 header_assemble(in_buf, SMB_COM_NT_CANCEL, tcon, 0);
855 in_buf->Mid = mid;
Jeff Layton72ca5452008-12-01 07:09:36 -0500856 mutex_lock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000857 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
858 if (rc) {
Jeff Layton72ca5452008-12-01 07:09:36 -0500859 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000860 return rc;
861 }
862 rc = smb_send(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
Steve Frenchedf1ae42008-10-29 00:47:57 +0000863 (struct sockaddr *) &(ses->server->addr.sockAddr),
864 ses->server->noblocksnd);
Jeff Layton72ca5452008-12-01 07:09:36 -0500865 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000866 return rc;
867}
868
869/* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
870 blocking lock to return. */
871
872static int
873send_lock_cancel(const unsigned int xid, struct cifsTconInfo *tcon,
874 struct smb_hdr *in_buf,
875 struct smb_hdr *out_buf)
876{
877 int bytes_returned;
878 struct cifsSesInfo *ses = tcon->ses;
879 LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
880
881 /* We just modify the current in_buf to change
882 the type of lock from LOCKING_ANDX_SHARED_LOCK
883 or LOCKING_ANDX_EXCLUSIVE_LOCK to
884 LOCKING_ANDX_CANCEL_LOCK. */
885
886 pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
887 pSMB->Timeout = 0;
888 pSMB->hdr.Mid = GetNextMid(ses->server);
889
890 return SendReceive(xid, ses, in_buf, out_buf,
Steve French133672e2007-11-13 22:41:37 +0000891 &bytes_returned, CIFS_STD_OP);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000892}
893
894int
895SendReceiveBlockingLock(const unsigned int xid, struct cifsTconInfo *tcon,
896 struct smb_hdr *in_buf, struct smb_hdr *out_buf,
897 int *pbytes_returned)
898{
899 int rc = 0;
900 int rstart = 0;
901 unsigned int receive_len;
902 struct mid_q_entry *midQ;
903 struct cifsSesInfo *ses;
904
905 if (tcon == NULL || tcon->ses == NULL) {
Steve French79a58d12007-07-06 22:44:50 +0000906 cERROR(1, ("Null smb session"));
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000907 return -EIO;
908 }
909 ses = tcon->ses;
910
Steve French79a58d12007-07-06 22:44:50 +0000911 if (ses->server == NULL) {
912 cERROR(1, ("Null tcp session"));
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000913 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 }
915
Steve French79a58d12007-07-06 22:44:50 +0000916 if (ses->server->tcpStatus == CifsExiting)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000917 return -ENOENT;
918
Steve French79a58d12007-07-06 22:44:50 +0000919 /* Ensure that we do not send more than 50 overlapping requests
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000920 to the same server. We may make this configurable later or
921 use ses->maxReq */
922
Volker Lendecke6d9c6d52008-12-08 20:50:24 +0000923 if (in_buf->smb_buf_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
924 cERROR(1, ("Illegal length, greater than maximum frame, %d",
925 in_buf->smb_buf_length));
926 return -EIO;
927 }
928
Steve French133672e2007-11-13 22:41:37 +0000929 rc = wait_for_free_request(ses, CIFS_BLOCKING_OP);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000930 if (rc)
931 return rc;
932
Steve French79a58d12007-07-06 22:44:50 +0000933 /* make sure that we sign in the same order that we send on this socket
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000934 and avoid races inside tcp sendmsg code that could cause corruption
935 of smb data */
936
Jeff Layton72ca5452008-12-01 07:09:36 -0500937 mutex_lock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000938
939 rc = allocate_mid(ses, in_buf, &midQ);
940 if (rc) {
Jeff Layton72ca5452008-12-01 07:09:36 -0500941 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000942 return rc;
943 }
944
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000945 rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
946
947 midQ->midState = MID_REQUEST_SUBMITTED;
948#ifdef CONFIG_CIFS_STATS2
949 atomic_inc(&ses->server->inSend);
950#endif
951 rc = smb_send(ses->server->ssocket, in_buf, in_buf->smb_buf_length,
Steve Frenchedf1ae42008-10-29 00:47:57 +0000952 (struct sockaddr *) &(ses->server->addr.sockAddr),
953 ses->server->noblocksnd);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000954#ifdef CONFIG_CIFS_STATS2
955 atomic_dec(&ses->server->inSend);
956 midQ->when_sent = jiffies;
957#endif
Jeff Layton72ca5452008-12-01 07:09:36 -0500958 mutex_unlock(&ses->server->srv_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000959
Steve French79a58d12007-07-06 22:44:50 +0000960 if (rc < 0) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000961 DeleteMidQEntry(midQ);
962 return rc;
963 }
964
965 /* Wait for a reply - allow signals to interrupt. */
966 rc = wait_event_interruptible(ses->server->response_q,
Steve French79a58d12007-07-06 22:44:50 +0000967 (!(midQ->midState == MID_REQUEST_SUBMITTED)) ||
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000968 ((ses->server->tcpStatus != CifsGood) &&
969 (ses->server->tcpStatus != CifsNew)));
970
971 /* Were we interrupted by a signal ? */
972 if ((rc == -ERESTARTSYS) &&
973 (midQ->midState == MID_REQUEST_SUBMITTED) &&
974 ((ses->server->tcpStatus == CifsGood) ||
975 (ses->server->tcpStatus == CifsNew))) {
976
977 if (in_buf->Command == SMB_COM_TRANSACTION2) {
978 /* POSIX lock. We send a NT_CANCEL SMB to cause the
979 blocking lock to return. */
980
981 rc = send_nt_cancel(tcon, in_buf, midQ);
982 if (rc) {
983 DeleteMidQEntry(midQ);
984 return rc;
985 }
986 } else {
987 /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
988 to cause the blocking lock to return. */
989
990 rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
991
992 /* If we get -ENOLCK back the lock may have
993 already been removed. Don't exit in this case. */
994 if (rc && rc != -ENOLCK) {
995 DeleteMidQEntry(midQ);
996 return rc;
997 }
998 }
999
1000 /* Wait 5 seconds for the response. */
Steve French79a58d12007-07-06 22:44:50 +00001001 if (wait_for_response(ses, midQ, 5 * HZ, 5 * HZ) == 0) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001002 /* We got the response - restart system call. */
1003 rstart = 1;
1004 }
1005 }
1006
1007 spin_lock(&GlobalMid_Lock);
1008 if (midQ->resp_buf) {
1009 spin_unlock(&GlobalMid_Lock);
1010 receive_len = midQ->resp_buf->smb_buf_length;
1011 } else {
Steve French79a58d12007-07-06 22:44:50 +00001012 cERROR(1, ("No response for cmd %d mid %d",
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001013 midQ->command, midQ->mid));
Steve French79a58d12007-07-06 22:44:50 +00001014 if (midQ->midState == MID_REQUEST_SUBMITTED) {
1015 if (ses->server->tcpStatus == CifsExiting)
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001016 rc = -EHOSTDOWN;
1017 else {
1018 ses->server->tcpStatus = CifsNeedReconnect;
1019 midQ->midState = MID_RETRY_NEEDED;
1020 }
1021 }
1022
1023 if (rc != -EHOSTDOWN) {
Steve French79a58d12007-07-06 22:44:50 +00001024 if (midQ->midState == MID_RETRY_NEEDED) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001025 rc = -EAGAIN;
Steve French79a58d12007-07-06 22:44:50 +00001026 cFYI(1, ("marking request for retry"));
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001027 } else {
1028 rc = -EIO;
1029 }
1030 }
1031 spin_unlock(&GlobalMid_Lock);
1032 DeleteMidQEntry(midQ);
1033 return rc;
1034 }
Steve French50c2f752007-07-13 00:33:32 +00001035
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001036 if (receive_len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE) {
1037 cERROR(1, ("Frame too large received. Length: %d Xid: %d",
1038 receive_len, xid));
1039 rc = -EIO;
1040 } else { /* rcvd frame is ok */
1041
1042 if (midQ->resp_buf && out_buf
1043 && (midQ->midState == MID_RESPONSE_RECEIVED)) {
1044 out_buf->smb_buf_length = receive_len;
1045 memcpy((char *)out_buf + 4,
1046 (char *)midQ->resp_buf + 4,
1047 receive_len);
1048
1049 dump_smb(out_buf, 92);
1050 /* convert the length into a more usable form */
Steve French79a58d12007-07-06 22:44:50 +00001051 if ((receive_len > 24) &&
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001052 (ses->server->secMode & (SECMODE_SIGN_REQUIRED |
1053 SECMODE_SIGN_ENABLED))) {
1054 rc = cifs_verify_signature(out_buf,
Steve Frenchb609f062007-07-09 07:55:14 +00001055 &ses->server->mac_signing_key,
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001056 midQ->sequence_number+1);
Steve French79a58d12007-07-06 22:44:50 +00001057 if (rc) {
1058 cERROR(1, ("Unexpected SMB signature"));
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001059 /* BB FIXME add code to kill session */
1060 }
1061 }
1062
1063 *pbytes_returned = out_buf->smb_buf_length;
1064
1065 /* BB special case reconnect tid and uid here? */
Steve Frencha761ac52007-10-18 21:45:27 +00001066 rc = map_smb_to_linux_error(out_buf, 0 /* no log */ );
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001067
1068 /* convert ByteCount if necessary */
Steve French26f57362007-08-30 22:09:15 +00001069 if (receive_len >= sizeof(struct smb_hdr) - 4
1070 /* do not count RFC1001 header */ +
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001071 (2 * out_buf->WordCount) + 2 /* bcc */ )
1072 BCC(out_buf) = le16_to_cpu(BCC_LE(out_buf));
1073 } else {
1074 rc = -EIO;
Steve French79a58d12007-07-06 22:44:50 +00001075 cERROR(1, ("Bad MID state?"));
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001076 }
1077 }
1078 DeleteMidQEntry(midQ);
1079 if (rstart && rc == -EACCES)
1080 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 return rc;
1082}