Merge branch 'work.afs' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs
[muen/linux.git] / fs / cifs / transport.c
1 /*
2  *   fs/cifs/transport.c
3  *
4  *   Copyright (C) International Business Machines  Corp., 2002,2008
5  *   Author(s): Steve French (sfrench@us.ibm.com)
6  *   Jeremy Allison (jra@samba.org) 2006.
7  *
8  *   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
20  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21  */
22
23 #include <linux/fs.h>
24 #include <linux/list.h>
25 #include <linux/gfp.h>
26 #include <linux/wait.h>
27 #include <linux/net.h>
28 #include <linux/delay.h>
29 #include <linux/freezer.h>
30 #include <linux/tcp.h>
31 #include <linux/bvec.h>
32 #include <linux/highmem.h>
33 #include <linux/uaccess.h>
34 #include <asm/processor.h>
35 #include <linux/mempool.h>
36 #include "cifspdu.h"
37 #include "cifsglob.h"
38 #include "cifsproto.h"
39 #include "cifs_debug.h"
40 #include "smb2proto.h"
41 #include "smbdirect.h"
42
43 /* Max number of iovectors we can use off the stack when sending requests. */
44 #define CIFS_MAX_IOV_SIZE 8
45
46 void
47 cifs_wake_up_task(struct mid_q_entry *mid)
48 {
49         wake_up_process(mid->callback_data);
50 }
51
52 struct mid_q_entry *
53 AllocMidQEntry(const struct smb_hdr *smb_buffer, struct TCP_Server_Info *server)
54 {
55         struct mid_q_entry *temp;
56
57         if (server == NULL) {
58                 cifs_dbg(VFS, "Null TCP session in AllocMidQEntry\n");
59                 return NULL;
60         }
61
62         temp = mempool_alloc(cifs_mid_poolp, GFP_NOFS);
63         memset(temp, 0, sizeof(struct mid_q_entry));
64         kref_init(&temp->refcount);
65         temp->mid = get_mid(smb_buffer);
66         temp->pid = current->pid;
67         temp->command = cpu_to_le16(smb_buffer->Command);
68         cifs_dbg(FYI, "For smb_command %d\n", smb_buffer->Command);
69         /*      do_gettimeofday(&temp->when_sent);*/ /* easier to use jiffies */
70         /* when mid allocated can be before when sent */
71         temp->when_alloc = jiffies;
72         temp->server = server;
73
74         /*
75          * The default is for the mid to be synchronous, so the
76          * default callback just wakes up the current task.
77          */
78         temp->callback = cifs_wake_up_task;
79         temp->callback_data = current;
80
81         atomic_inc(&midCount);
82         temp->mid_state = MID_REQUEST_ALLOCATED;
83         return temp;
84 }
85
86 static void _cifs_mid_q_entry_release(struct kref *refcount)
87 {
88         struct mid_q_entry *mid = container_of(refcount, struct mid_q_entry,
89                                                refcount);
90
91         mempool_free(mid, cifs_mid_poolp);
92 }
93
94 void cifs_mid_q_entry_release(struct mid_q_entry *midEntry)
95 {
96         spin_lock(&GlobalMid_Lock);
97         kref_put(&midEntry->refcount, _cifs_mid_q_entry_release);
98         spin_unlock(&GlobalMid_Lock);
99 }
100
101 void
102 DeleteMidQEntry(struct mid_q_entry *midEntry)
103 {
104 #ifdef CONFIG_CIFS_STATS2
105         __le16 command = midEntry->server->vals->lock_cmd;
106         unsigned long now;
107 #endif
108         midEntry->mid_state = MID_FREE;
109         atomic_dec(&midCount);
110         if (midEntry->large_buf)
111                 cifs_buf_release(midEntry->resp_buf);
112         else
113                 cifs_small_buf_release(midEntry->resp_buf);
114 #ifdef CONFIG_CIFS_STATS2
115         now = jiffies;
116         /*
117          * commands taking longer than one second (default) can be indications
118          * that something is wrong, unless it is quite a slow link or a very
119          * busy server. Note that this calc is unlikely or impossible to wrap
120          * as long as slow_rsp_threshold is not set way above recommended max
121          * value (32767 ie 9 hours) and is generally harmless even if wrong
122          * since only affects debug counters - so leaving the calc as simple
123          * comparison rather than doing multiple conversions and overflow
124          * checks
125          */
126         if ((slow_rsp_threshold != 0) &&
127             time_after(now, midEntry->when_alloc + (slow_rsp_threshold * HZ)) &&
128             (midEntry->command != command)) {
129                 /* smb2slowcmd[NUMBER_OF_SMB2_COMMANDS] counts by command */
130                 if ((le16_to_cpu(midEntry->command) < NUMBER_OF_SMB2_COMMANDS) &&
131                     (le16_to_cpu(midEntry->command) >= 0))
132                         cifs_stats_inc(&midEntry->server->smb2slowcmd[le16_to_cpu(midEntry->command)]);
133
134                 trace_smb3_slow_rsp(le16_to_cpu(midEntry->command),
135                                midEntry->mid, midEntry->pid,
136                                midEntry->when_sent, midEntry->when_received);
137                 if (cifsFYI & CIFS_TIMER) {
138                         pr_debug(" CIFS slow rsp: cmd %d mid %llu",
139                                midEntry->command, midEntry->mid);
140                         cifs_info(" A: 0x%lx S: 0x%lx R: 0x%lx\n",
141                                now - midEntry->when_alloc,
142                                now - midEntry->when_sent,
143                                now - midEntry->when_received);
144                 }
145         }
146 #endif
147         cifs_mid_q_entry_release(midEntry);
148 }
149
150 void
151 cifs_delete_mid(struct mid_q_entry *mid)
152 {
153         spin_lock(&GlobalMid_Lock);
154         list_del_init(&mid->qhead);
155         mid->mid_flags |= MID_DELETED;
156         spin_unlock(&GlobalMid_Lock);
157
158         DeleteMidQEntry(mid);
159 }
160
161 /*
162  * smb_send_kvec - send an array of kvecs to the server
163  * @server:     Server to send the data to
164  * @smb_msg:    Message to send
165  * @sent:       amount of data sent on socket is stored here
166  *
167  * Our basic "send data to server" function. Should be called with srv_mutex
168  * held. The caller is responsible for handling the results.
169  */
170 static int
171 smb_send_kvec(struct TCP_Server_Info *server, struct msghdr *smb_msg,
172               size_t *sent)
173 {
174         int rc = 0;
175         int retries = 0;
176         struct socket *ssocket = server->ssocket;
177
178         *sent = 0;
179
180         smb_msg->msg_name = (struct sockaddr *) &server->dstaddr;
181         smb_msg->msg_namelen = sizeof(struct sockaddr);
182         smb_msg->msg_control = NULL;
183         smb_msg->msg_controllen = 0;
184         if (server->noblocksnd)
185                 smb_msg->msg_flags = MSG_DONTWAIT + MSG_NOSIGNAL;
186         else
187                 smb_msg->msg_flags = MSG_NOSIGNAL;
188
189         while (msg_data_left(smb_msg)) {
190                 /*
191                  * If blocking send, we try 3 times, since each can block
192                  * for 5 seconds. For nonblocking  we have to try more
193                  * but wait increasing amounts of time allowing time for
194                  * socket to clear.  The overall time we wait in either
195                  * case to send on the socket is about 15 seconds.
196                  * Similarly we wait for 15 seconds for a response from
197                  * the server in SendReceive[2] for the server to send
198                  * a response back for most types of requests (except
199                  * SMB Write past end of file which can be slow, and
200                  * blocking lock operations). NFS waits slightly longer
201                  * than CIFS, but this can make it take longer for
202                  * nonresponsive servers to be detected and 15 seconds
203                  * is more than enough time for modern networks to
204                  * send a packet.  In most cases if we fail to send
205                  * after the retries we will kill the socket and
206                  * reconnect which may clear the network problem.
207                  */
208                 rc = sock_sendmsg(ssocket, smb_msg);
209                 if (rc == -EAGAIN) {
210                         retries++;
211                         if (retries >= 14 ||
212                             (!server->noblocksnd && (retries > 2))) {
213                                 cifs_dbg(VFS, "sends on sock %p stuck for 15 seconds\n",
214                                          ssocket);
215                                 return -EAGAIN;
216                         }
217                         msleep(1 << retries);
218                         continue;
219                 }
220
221                 if (rc < 0)
222                         return rc;
223
224                 if (rc == 0) {
225                         /* should never happen, letting socket clear before
226                            retrying is our only obvious option here */
227                         cifs_dbg(VFS, "tcp sent no data\n");
228                         msleep(500);
229                         continue;
230                 }
231
232                 /* send was at least partially successful */
233                 *sent += rc;
234                 retries = 0; /* in case we get ENOSPC on the next send */
235         }
236         return 0;
237 }
238
239 unsigned long
240 smb_rqst_len(struct TCP_Server_Info *server, struct smb_rqst *rqst)
241 {
242         unsigned int i;
243         struct kvec *iov;
244         int nvec;
245         unsigned long buflen = 0;
246
247         if (server->vals->header_preamble_size == 0 &&
248             rqst->rq_nvec >= 2 && rqst->rq_iov[0].iov_len == 4) {
249                 iov = &rqst->rq_iov[1];
250                 nvec = rqst->rq_nvec - 1;
251         } else {
252                 iov = rqst->rq_iov;
253                 nvec = rqst->rq_nvec;
254         }
255
256         /* total up iov array first */
257         for (i = 0; i < nvec; i++)
258                 buflen += iov[i].iov_len;
259
260         /*
261          * Add in the page array if there is one. The caller needs to make
262          * sure rq_offset and rq_tailsz are set correctly. If a buffer of
263          * multiple pages ends at page boundary, rq_tailsz needs to be set to
264          * PAGE_SIZE.
265          */
266         if (rqst->rq_npages) {
267                 if (rqst->rq_npages == 1)
268                         buflen += rqst->rq_tailsz;
269                 else {
270                         /*
271                          * If there is more than one page, calculate the
272                          * buffer length based on rq_offset and rq_tailsz
273                          */
274                         buflen += rqst->rq_pagesz * (rqst->rq_npages - 1) -
275                                         rqst->rq_offset;
276                         buflen += rqst->rq_tailsz;
277                 }
278         }
279
280         return buflen;
281 }
282
283 static int
284 __smb_send_rqst(struct TCP_Server_Info *server, int num_rqst,
285                 struct smb_rqst *rqst)
286 {
287         int rc = 0;
288         struct kvec *iov;
289         int n_vec;
290         unsigned int send_length = 0;
291         unsigned int i, j;
292         size_t total_len = 0, sent, size;
293         struct socket *ssocket = server->ssocket;
294         struct msghdr smb_msg;
295         int val = 1;
296         __be32 rfc1002_marker;
297
298         if (cifs_rdma_enabled(server) && server->smbd_conn) {
299                 rc = smbd_send(server, rqst);
300                 goto smbd_done;
301         }
302         if (ssocket == NULL)
303                 return -ENOTSOCK;
304
305         /* cork the socket */
306         kernel_setsockopt(ssocket, SOL_TCP, TCP_CORK,
307                                 (char *)&val, sizeof(val));
308
309         for (j = 0; j < num_rqst; j++)
310                 send_length += smb_rqst_len(server, &rqst[j]);
311         rfc1002_marker = cpu_to_be32(send_length);
312
313         /* Generate a rfc1002 marker for SMB2+ */
314         if (server->vals->header_preamble_size == 0) {
315                 struct kvec hiov = {
316                         .iov_base = &rfc1002_marker,
317                         .iov_len  = 4
318                 };
319                 iov_iter_kvec(&smb_msg.msg_iter, WRITE, &hiov, 1, 4);
320                 rc = smb_send_kvec(server, &smb_msg, &sent);
321                 if (rc < 0)
322                         goto uncork;
323
324                 total_len += sent;
325                 send_length += 4;
326         }
327
328         cifs_dbg(FYI, "Sending smb: smb_len=%u\n", send_length);
329
330         for (j = 0; j < num_rqst; j++) {
331                 iov = rqst[j].rq_iov;
332                 n_vec = rqst[j].rq_nvec;
333
334                 size = 0;
335                 for (i = 0; i < n_vec; i++) {
336                         dump_smb(iov[i].iov_base, iov[i].iov_len);
337                         size += iov[i].iov_len;
338                 }
339
340                 iov_iter_kvec(&smb_msg.msg_iter, WRITE, iov, n_vec, size);
341
342                 rc = smb_send_kvec(server, &smb_msg, &sent);
343                 if (rc < 0)
344                         goto uncork;
345
346                 total_len += sent;
347
348                 /* now walk the page array and send each page in it */
349                 for (i = 0; i < rqst[j].rq_npages; i++) {
350                         struct bio_vec bvec;
351
352                         bvec.bv_page = rqst[j].rq_pages[i];
353                         rqst_page_get_length(&rqst[j], i, &bvec.bv_len,
354                                              &bvec.bv_offset);
355
356                         iov_iter_bvec(&smb_msg.msg_iter, WRITE,
357                                       &bvec, 1, bvec.bv_len);
358                         rc = smb_send_kvec(server, &smb_msg, &sent);
359                         if (rc < 0)
360                                 break;
361
362                         total_len += sent;
363                 }
364         }
365
366 uncork:
367         /* uncork it */
368         val = 0;
369         kernel_setsockopt(ssocket, SOL_TCP, TCP_CORK,
370                                 (char *)&val, sizeof(val));
371
372         if ((total_len > 0) && (total_len != send_length)) {
373                 cifs_dbg(FYI, "partial send (wanted=%u sent=%zu): terminating session\n",
374                          send_length, total_len);
375                 /*
376                  * If we have only sent part of an SMB then the next SMB could
377                  * be taken as the remainder of this one. We need to kill the
378                  * socket so the server throws away the partial SMB
379                  */
380                 server->tcpStatus = CifsNeedReconnect;
381                 trace_smb3_partial_send_reconnect(server->CurrentMid,
382                                                   server->hostname);
383         }
384 smbd_done:
385         if (rc < 0 && rc != -EINTR)
386                 cifs_dbg(VFS, "Error %d sending data on socket to server\n",
387                          rc);
388         else
389                 rc = 0;
390
391         return rc;
392 }
393
394 static int
395 smb_send_rqst(struct TCP_Server_Info *server, int num_rqst,
396               struct smb_rqst *rqst, int flags)
397 {
398         struct kvec iov;
399         struct smb2_transform_hdr tr_hdr;
400         struct smb_rqst cur_rqst[MAX_COMPOUND];
401         int rc;
402
403         if (!(flags & CIFS_TRANSFORM_REQ))
404                 return __smb_send_rqst(server, num_rqst, rqst);
405
406         if (num_rqst > MAX_COMPOUND - 1)
407                 return -ENOMEM;
408
409         memset(&cur_rqst[0], 0, sizeof(cur_rqst));
410         memset(&iov, 0, sizeof(iov));
411         memset(&tr_hdr, 0, sizeof(tr_hdr));
412
413         iov.iov_base = &tr_hdr;
414         iov.iov_len = sizeof(tr_hdr);
415         cur_rqst[0].rq_iov = &iov;
416         cur_rqst[0].rq_nvec = 1;
417
418         if (!server->ops->init_transform_rq) {
419                 cifs_dbg(VFS, "Encryption requested but transform callback "
420                          "is missing\n");
421                 return -EIO;
422         }
423
424         rc = server->ops->init_transform_rq(server, num_rqst + 1,
425                                             &cur_rqst[0], rqst);
426         if (rc)
427                 return rc;
428
429         rc = __smb_send_rqst(server, num_rqst + 1, &cur_rqst[0]);
430         smb3_free_compound_rqst(num_rqst, &cur_rqst[1]);
431         return rc;
432 }
433
434 int
435 smb_send(struct TCP_Server_Info *server, struct smb_hdr *smb_buffer,
436          unsigned int smb_buf_length)
437 {
438         struct kvec iov[2];
439         struct smb_rqst rqst = { .rq_iov = iov,
440                                  .rq_nvec = 2 };
441
442         iov[0].iov_base = smb_buffer;
443         iov[0].iov_len = 4;
444         iov[1].iov_base = (char *)smb_buffer + 4;
445         iov[1].iov_len = smb_buf_length;
446
447         return __smb_send_rqst(server, 1, &rqst);
448 }
449
450 static int
451 wait_for_free_credits(struct TCP_Server_Info *server, const int timeout,
452                       int *credits)
453 {
454         int rc;
455
456         spin_lock(&server->req_lock);
457         if (timeout == CIFS_ASYNC_OP) {
458                 /* oplock breaks must not be held up */
459                 server->in_flight++;
460                 *credits -= 1;
461                 spin_unlock(&server->req_lock);
462                 return 0;
463         }
464
465         while (1) {
466                 if (*credits <= 0) {
467                         spin_unlock(&server->req_lock);
468                         cifs_num_waiters_inc(server);
469                         rc = wait_event_killable(server->request_q,
470                                                  has_credits(server, credits));
471                         cifs_num_waiters_dec(server);
472                         if (rc)
473                                 return rc;
474                         spin_lock(&server->req_lock);
475                 } else {
476                         if (server->tcpStatus == CifsExiting) {
477                                 spin_unlock(&server->req_lock);
478                                 return -ENOENT;
479                         }
480
481                         /*
482                          * Can not count locking commands against total
483                          * as they are allowed to block on server.
484                          */
485
486                         /* update # of requests on the wire to server */
487                         if (timeout != CIFS_BLOCKING_OP) {
488                                 *credits -= 1;
489                                 server->in_flight++;
490                         }
491                         spin_unlock(&server->req_lock);
492                         break;
493                 }
494         }
495         return 0;
496 }
497
498 static int
499 wait_for_free_request(struct TCP_Server_Info *server, const int timeout,
500                       const int optype)
501 {
502         int *val;
503
504         val = server->ops->get_credits_field(server, optype);
505         /* Since an echo is already inflight, no need to wait to send another */
506         if (*val <= 0 && optype == CIFS_ECHO_OP)
507                 return -EAGAIN;
508         return wait_for_free_credits(server, timeout, val);
509 }
510
511 int
512 cifs_wait_mtu_credits(struct TCP_Server_Info *server, unsigned int size,
513                       unsigned int *num, unsigned int *credits)
514 {
515         *num = size;
516         *credits = 0;
517         return 0;
518 }
519
520 static int allocate_mid(struct cifs_ses *ses, struct smb_hdr *in_buf,
521                         struct mid_q_entry **ppmidQ)
522 {
523         if (ses->server->tcpStatus == CifsExiting) {
524                 return -ENOENT;
525         }
526
527         if (ses->server->tcpStatus == CifsNeedReconnect) {
528                 cifs_dbg(FYI, "tcp session dead - return to caller to retry\n");
529                 return -EAGAIN;
530         }
531
532         if (ses->status == CifsNew) {
533                 if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
534                         (in_buf->Command != SMB_COM_NEGOTIATE))
535                         return -EAGAIN;
536                 /* else ok - we are setting up session */
537         }
538
539         if (ses->status == CifsExiting) {
540                 /* check if SMB session is bad because we are setting it up */
541                 if (in_buf->Command != SMB_COM_LOGOFF_ANDX)
542                         return -EAGAIN;
543                 /* else ok - we are shutting down session */
544         }
545
546         *ppmidQ = AllocMidQEntry(in_buf, ses->server);
547         if (*ppmidQ == NULL)
548                 return -ENOMEM;
549         spin_lock(&GlobalMid_Lock);
550         list_add_tail(&(*ppmidQ)->qhead, &ses->server->pending_mid_q);
551         spin_unlock(&GlobalMid_Lock);
552         return 0;
553 }
554
555 static int
556 wait_for_response(struct TCP_Server_Info *server, struct mid_q_entry *midQ)
557 {
558         int error;
559
560         error = wait_event_freezekillable_unsafe(server->response_q,
561                                     midQ->mid_state != MID_REQUEST_SUBMITTED);
562         if (error < 0)
563                 return -ERESTARTSYS;
564
565         return 0;
566 }
567
568 struct mid_q_entry *
569 cifs_setup_async_request(struct TCP_Server_Info *server, struct smb_rqst *rqst)
570 {
571         int rc;
572         struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
573         struct mid_q_entry *mid;
574
575         if (rqst->rq_iov[0].iov_len != 4 ||
576             rqst->rq_iov[0].iov_base + 4 != rqst->rq_iov[1].iov_base)
577                 return ERR_PTR(-EIO);
578
579         /* enable signing if server requires it */
580         if (server->sign)
581                 hdr->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
582
583         mid = AllocMidQEntry(hdr, server);
584         if (mid == NULL)
585                 return ERR_PTR(-ENOMEM);
586
587         rc = cifs_sign_rqst(rqst, server, &mid->sequence_number);
588         if (rc) {
589                 DeleteMidQEntry(mid);
590                 return ERR_PTR(rc);
591         }
592
593         return mid;
594 }
595
596 /*
597  * Send a SMB request and set the callback function in the mid to handle
598  * the result. Caller is responsible for dealing with timeouts.
599  */
600 int
601 cifs_call_async(struct TCP_Server_Info *server, struct smb_rqst *rqst,
602                 mid_receive_t *receive, mid_callback_t *callback,
603                 mid_handle_t *handle, void *cbdata, const int flags)
604 {
605         int rc, timeout, optype;
606         struct mid_q_entry *mid;
607         unsigned int credits = 0;
608
609         timeout = flags & CIFS_TIMEOUT_MASK;
610         optype = flags & CIFS_OP_MASK;
611
612         if ((flags & CIFS_HAS_CREDITS) == 0) {
613                 rc = wait_for_free_request(server, timeout, optype);
614                 if (rc)
615                         return rc;
616                 credits = 1;
617         }
618
619         mutex_lock(&server->srv_mutex);
620         mid = server->ops->setup_async_request(server, rqst);
621         if (IS_ERR(mid)) {
622                 mutex_unlock(&server->srv_mutex);
623                 add_credits_and_wake_if(server, credits, optype);
624                 return PTR_ERR(mid);
625         }
626
627         mid->receive = receive;
628         mid->callback = callback;
629         mid->callback_data = cbdata;
630         mid->handle = handle;
631         mid->mid_state = MID_REQUEST_SUBMITTED;
632
633         /* put it on the pending_mid_q */
634         spin_lock(&GlobalMid_Lock);
635         list_add_tail(&mid->qhead, &server->pending_mid_q);
636         spin_unlock(&GlobalMid_Lock);
637
638         /*
639          * Need to store the time in mid before calling I/O. For call_async,
640          * I/O response may come back and free the mid entry on another thread.
641          */
642         cifs_save_when_sent(mid);
643         cifs_in_send_inc(server);
644         rc = smb_send_rqst(server, 1, rqst, flags);
645         cifs_in_send_dec(server);
646
647         if (rc < 0) {
648                 server->sequence_number -= 2;
649                 cifs_delete_mid(mid);
650         }
651
652         mutex_unlock(&server->srv_mutex);
653
654         if (rc == 0)
655                 return 0;
656
657         add_credits_and_wake_if(server, credits, optype);
658         return rc;
659 }
660
661 /*
662  *
663  * Send an SMB Request.  No response info (other than return code)
664  * needs to be parsed.
665  *
666  * flags indicate the type of request buffer and how long to wait
667  * and whether to log NT STATUS code (error) before mapping it to POSIX error
668  *
669  */
670 int
671 SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
672                  char *in_buf, int flags)
673 {
674         int rc;
675         struct kvec iov[1];
676         struct kvec rsp_iov;
677         int resp_buf_type;
678
679         iov[0].iov_base = in_buf;
680         iov[0].iov_len = get_rfc1002_length(in_buf) + 4;
681         flags |= CIFS_NO_RESP;
682         rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags, &rsp_iov);
683         cifs_dbg(NOISY, "SendRcvNoRsp flags %d rc %d\n", flags, rc);
684
685         return rc;
686 }
687
688 static int
689 cifs_sync_mid_result(struct mid_q_entry *mid, struct TCP_Server_Info *server)
690 {
691         int rc = 0;
692
693         cifs_dbg(FYI, "%s: cmd=%d mid=%llu state=%d\n",
694                  __func__, le16_to_cpu(mid->command), mid->mid, mid->mid_state);
695
696         spin_lock(&GlobalMid_Lock);
697         switch (mid->mid_state) {
698         case MID_RESPONSE_RECEIVED:
699                 spin_unlock(&GlobalMid_Lock);
700                 return rc;
701         case MID_RETRY_NEEDED:
702                 rc = -EAGAIN;
703                 break;
704         case MID_RESPONSE_MALFORMED:
705                 rc = -EIO;
706                 break;
707         case MID_SHUTDOWN:
708                 rc = -EHOSTDOWN;
709                 break;
710         default:
711                 list_del_init(&mid->qhead);
712                 cifs_dbg(VFS, "%s: invalid mid state mid=%llu state=%d\n",
713                          __func__, mid->mid, mid->mid_state);
714                 rc = -EIO;
715         }
716         spin_unlock(&GlobalMid_Lock);
717
718         DeleteMidQEntry(mid);
719         return rc;
720 }
721
722 static inline int
723 send_cancel(struct TCP_Server_Info *server, struct smb_rqst *rqst,
724             struct mid_q_entry *mid)
725 {
726         return server->ops->send_cancel ?
727                                 server->ops->send_cancel(server, rqst, mid) : 0;
728 }
729
730 int
731 cifs_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
732                    bool log_error)
733 {
734         unsigned int len = get_rfc1002_length(mid->resp_buf) + 4;
735
736         dump_smb(mid->resp_buf, min_t(u32, 92, len));
737
738         /* convert the length into a more usable form */
739         if (server->sign) {
740                 struct kvec iov[2];
741                 int rc = 0;
742                 struct smb_rqst rqst = { .rq_iov = iov,
743                                          .rq_nvec = 2 };
744
745                 iov[0].iov_base = mid->resp_buf;
746                 iov[0].iov_len = 4;
747                 iov[1].iov_base = (char *)mid->resp_buf + 4;
748                 iov[1].iov_len = len - 4;
749                 /* FIXME: add code to kill session */
750                 rc = cifs_verify_signature(&rqst, server,
751                                            mid->sequence_number);
752                 if (rc)
753                         cifs_dbg(VFS, "SMB signature verification returned error = %d\n",
754                                  rc);
755         }
756
757         /* BB special case reconnect tid and uid here? */
758         return map_smb_to_linux_error(mid->resp_buf, log_error);
759 }
760
761 struct mid_q_entry *
762 cifs_setup_request(struct cifs_ses *ses, struct smb_rqst *rqst)
763 {
764         int rc;
765         struct smb_hdr *hdr = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
766         struct mid_q_entry *mid;
767
768         if (rqst->rq_iov[0].iov_len != 4 ||
769             rqst->rq_iov[0].iov_base + 4 != rqst->rq_iov[1].iov_base)
770                 return ERR_PTR(-EIO);
771
772         rc = allocate_mid(ses, hdr, &mid);
773         if (rc)
774                 return ERR_PTR(rc);
775         rc = cifs_sign_rqst(rqst, ses->server, &mid->sequence_number);
776         if (rc) {
777                 cifs_delete_mid(mid);
778                 return ERR_PTR(rc);
779         }
780         return mid;
781 }
782
783 static void
784 cifs_noop_callback(struct mid_q_entry *mid)
785 {
786 }
787
788 int
789 compound_send_recv(const unsigned int xid, struct cifs_ses *ses,
790                    const int flags, const int num_rqst, struct smb_rqst *rqst,
791                    int *resp_buf_type, struct kvec *resp_iov)
792 {
793         int i, j, rc = 0;
794         int timeout, optype;
795         struct mid_q_entry *midQ[MAX_COMPOUND];
796         unsigned int credits = 0;
797         char *buf;
798
799         timeout = flags & CIFS_TIMEOUT_MASK;
800         optype = flags & CIFS_OP_MASK;
801
802         for (i = 0; i < num_rqst; i++)
803                 resp_buf_type[i] = CIFS_NO_BUFFER;  /* no response buf yet */
804
805         if ((ses == NULL) || (ses->server == NULL)) {
806                 cifs_dbg(VFS, "Null session\n");
807                 return -EIO;
808         }
809
810         if (ses->server->tcpStatus == CifsExiting)
811                 return -ENOENT;
812
813         /*
814          * Ensure that we do not send more than 50 overlapping requests
815          * to the same server. We may make this configurable later or
816          * use ses->maxReq.
817          */
818         rc = wait_for_free_request(ses->server, timeout, optype);
819         if (rc)
820                 return rc;
821
822         /*
823          * Make sure that we sign in the same order that we send on this socket
824          * and avoid races inside tcp sendmsg code that could cause corruption
825          * of smb data.
826          */
827
828         mutex_lock(&ses->server->srv_mutex);
829
830         for (i = 0; i < num_rqst; i++) {
831                 midQ[i] = ses->server->ops->setup_request(ses, &rqst[i]);
832                 if (IS_ERR(midQ[i])) {
833                         for (j = 0; j < i; j++)
834                                 cifs_delete_mid(midQ[j]);
835                         mutex_unlock(&ses->server->srv_mutex);
836                         /* Update # of requests on wire to server */
837                         add_credits(ses->server, 1, optype);
838                         return PTR_ERR(midQ[i]);
839                 }
840
841                 midQ[i]->mid_state = MID_REQUEST_SUBMITTED;
842                 /*
843                  * We don't invoke the callback compounds unless it is the last
844                  * request.
845                  */
846                 if (i < num_rqst - 1)
847                         midQ[i]->callback = cifs_noop_callback;
848         }
849         cifs_in_send_inc(ses->server);
850         rc = smb_send_rqst(ses->server, num_rqst, rqst, flags);
851         cifs_in_send_dec(ses->server);
852
853         for (i = 0; i < num_rqst; i++)
854                 cifs_save_when_sent(midQ[i]);
855
856         if (rc < 0)
857                 ses->server->sequence_number -= 2;
858
859         mutex_unlock(&ses->server->srv_mutex);
860
861         if (rc < 0)
862                 goto out;
863
864         /*
865          * Compounding is never used during session establish.
866          */
867         if ((ses->status == CifsNew) || (optype & CIFS_NEG_OP))
868                 smb311_update_preauth_hash(ses, rqst[0].rq_iov,
869                                            rqst[0].rq_nvec);
870
871         if (timeout == CIFS_ASYNC_OP)
872                 goto out;
873
874         for (i = 0; i < num_rqst; i++) {
875                 rc = wait_for_response(ses->server, midQ[i]);
876                 if (rc != 0) {
877                         cifs_dbg(VFS, "Cancelling wait for mid %llu cmd: %d\n",
878                                  midQ[i]->mid, le16_to_cpu(midQ[i]->command));
879                         send_cancel(ses->server, &rqst[i], midQ[i]);
880                         spin_lock(&GlobalMid_Lock);
881                         if (midQ[i]->mid_state == MID_REQUEST_SUBMITTED) {
882                                 midQ[i]->mid_flags |= MID_WAIT_CANCELLED;
883                                 midQ[i]->callback = DeleteMidQEntry;
884                                 spin_unlock(&GlobalMid_Lock);
885                                 add_credits(ses->server, 1, optype);
886                                 return rc;
887                         }
888                         spin_unlock(&GlobalMid_Lock);
889                 }
890         }
891
892         for (i = 0; i < num_rqst; i++)
893                 if (midQ[i]->resp_buf)
894                         credits += ses->server->ops->get_credits(midQ[i]);
895         if (!credits)
896                 credits = 1;
897
898         for (i = 0; i < num_rqst; i++) {
899                 if (rc < 0)
900                         goto out;
901
902                 rc = cifs_sync_mid_result(midQ[i], ses->server);
903                 if (rc != 0) {
904                         add_credits(ses->server, credits, optype);
905                         return rc;
906                 }
907
908                 if (!midQ[i]->resp_buf ||
909                     midQ[i]->mid_state != MID_RESPONSE_RECEIVED) {
910                         rc = -EIO;
911                         cifs_dbg(FYI, "Bad MID state?\n");
912                         goto out;
913                 }
914
915                 buf = (char *)midQ[i]->resp_buf;
916                 resp_iov[i].iov_base = buf;
917                 resp_iov[i].iov_len = midQ[i]->resp_buf_size +
918                         ses->server->vals->header_preamble_size;
919
920                 if (midQ[i]->large_buf)
921                         resp_buf_type[i] = CIFS_LARGE_BUFFER;
922                 else
923                         resp_buf_type[i] = CIFS_SMALL_BUFFER;
924
925                 rc = ses->server->ops->check_receive(midQ[i], ses->server,
926                                                      flags & CIFS_LOG_ERROR);
927
928                 /* mark it so buf will not be freed by cifs_delete_mid */
929                 if ((flags & CIFS_NO_RESP) == 0)
930                         midQ[i]->resp_buf = NULL;
931
932         }
933
934         /*
935          * Compounding is never used during session establish.
936          */
937         if ((ses->status == CifsNew) || (optype & CIFS_NEG_OP)) {
938                 struct kvec iov = {
939                         .iov_base = resp_iov[0].iov_base,
940                         .iov_len = resp_iov[0].iov_len
941                 };
942                 smb311_update_preauth_hash(ses, &iov, 1);
943         }
944
945 out:
946         /*
947          * This will dequeue all mids. After this it is important that the
948          * demultiplex_thread will not process any of these mids any futher.
949          * This is prevented above by using a noop callback that will not
950          * wake this thread except for the very last PDU.
951          */
952         for (i = 0; i < num_rqst; i++)
953                 cifs_delete_mid(midQ[i]);
954         add_credits(ses->server, credits, optype);
955
956         return rc;
957 }
958
959 int
960 cifs_send_recv(const unsigned int xid, struct cifs_ses *ses,
961                struct smb_rqst *rqst, int *resp_buf_type, const int flags,
962                struct kvec *resp_iov)
963 {
964         return compound_send_recv(xid, ses, flags, 1, rqst, resp_buf_type,
965                                   resp_iov);
966 }
967
968 int
969 SendReceive2(const unsigned int xid, struct cifs_ses *ses,
970              struct kvec *iov, int n_vec, int *resp_buf_type /* ret */,
971              const int flags, struct kvec *resp_iov)
972 {
973         struct smb_rqst rqst;
974         struct kvec s_iov[CIFS_MAX_IOV_SIZE], *new_iov;
975         int rc;
976
977         if (n_vec + 1 > CIFS_MAX_IOV_SIZE) {
978                 new_iov = kmalloc_array(n_vec + 1, sizeof(struct kvec),
979                                         GFP_KERNEL);
980                 if (!new_iov) {
981                         /* otherwise cifs_send_recv below sets resp_buf_type */
982                         *resp_buf_type = CIFS_NO_BUFFER;
983                         return -ENOMEM;
984                 }
985         } else
986                 new_iov = s_iov;
987
988         /* 1st iov is a RFC1001 length followed by the rest of the packet */
989         memcpy(new_iov + 1, iov, (sizeof(struct kvec) * n_vec));
990
991         new_iov[0].iov_base = new_iov[1].iov_base;
992         new_iov[0].iov_len = 4;
993         new_iov[1].iov_base += 4;
994         new_iov[1].iov_len -= 4;
995
996         memset(&rqst, 0, sizeof(struct smb_rqst));
997         rqst.rq_iov = new_iov;
998         rqst.rq_nvec = n_vec + 1;
999
1000         rc = cifs_send_recv(xid, ses, &rqst, resp_buf_type, flags, resp_iov);
1001         if (n_vec + 1 > CIFS_MAX_IOV_SIZE)
1002                 kfree(new_iov);
1003         return rc;
1004 }
1005
1006 int
1007 SendReceive(const unsigned int xid, struct cifs_ses *ses,
1008             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
1009             int *pbytes_returned, const int timeout)
1010 {
1011         int rc = 0;
1012         struct mid_q_entry *midQ;
1013         unsigned int len = be32_to_cpu(in_buf->smb_buf_length);
1014         struct kvec iov = { .iov_base = in_buf, .iov_len = len };
1015         struct smb_rqst rqst = { .rq_iov = &iov, .rq_nvec = 1 };
1016
1017         if (ses == NULL) {
1018                 cifs_dbg(VFS, "Null smb session\n");
1019                 return -EIO;
1020         }
1021         if (ses->server == NULL) {
1022                 cifs_dbg(VFS, "Null tcp session\n");
1023                 return -EIO;
1024         }
1025
1026         if (ses->server->tcpStatus == CifsExiting)
1027                 return -ENOENT;
1028
1029         /* Ensure that we do not send more than 50 overlapping requests
1030            to the same server. We may make this configurable later or
1031            use ses->maxReq */
1032
1033         if (len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
1034                 cifs_dbg(VFS, "Illegal length, greater than maximum frame, %d\n",
1035                          len);
1036                 return -EIO;
1037         }
1038
1039         rc = wait_for_free_request(ses->server, timeout, 0);
1040         if (rc)
1041                 return rc;
1042
1043         /* make sure that we sign in the same order that we send on this socket
1044            and avoid races inside tcp sendmsg code that could cause corruption
1045            of smb data */
1046
1047         mutex_lock(&ses->server->srv_mutex);
1048
1049         rc = allocate_mid(ses, in_buf, &midQ);
1050         if (rc) {
1051                 mutex_unlock(&ses->server->srv_mutex);
1052                 /* Update # of requests on wire to server */
1053                 add_credits(ses->server, 1, 0);
1054                 return rc;
1055         }
1056
1057         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
1058         if (rc) {
1059                 mutex_unlock(&ses->server->srv_mutex);
1060                 goto out;
1061         }
1062
1063         midQ->mid_state = MID_REQUEST_SUBMITTED;
1064
1065         cifs_in_send_inc(ses->server);
1066         rc = smb_send(ses->server, in_buf, len);
1067         cifs_in_send_dec(ses->server);
1068         cifs_save_when_sent(midQ);
1069
1070         if (rc < 0)
1071                 ses->server->sequence_number -= 2;
1072
1073         mutex_unlock(&ses->server->srv_mutex);
1074
1075         if (rc < 0)
1076                 goto out;
1077
1078         if (timeout == CIFS_ASYNC_OP)
1079                 goto out;
1080
1081         rc = wait_for_response(ses->server, midQ);
1082         if (rc != 0) {
1083                 send_cancel(ses->server, &rqst, midQ);
1084                 spin_lock(&GlobalMid_Lock);
1085                 if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
1086                         /* no longer considered to be "in-flight" */
1087                         midQ->callback = DeleteMidQEntry;
1088                         spin_unlock(&GlobalMid_Lock);
1089                         add_credits(ses->server, 1, 0);
1090                         return rc;
1091                 }
1092                 spin_unlock(&GlobalMid_Lock);
1093         }
1094
1095         rc = cifs_sync_mid_result(midQ, ses->server);
1096         if (rc != 0) {
1097                 add_credits(ses->server, 1, 0);
1098                 return rc;
1099         }
1100
1101         if (!midQ->resp_buf || !out_buf ||
1102             midQ->mid_state != MID_RESPONSE_RECEIVED) {
1103                 rc = -EIO;
1104                 cifs_dbg(VFS, "Bad MID state?\n");
1105                 goto out;
1106         }
1107
1108         *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
1109         memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
1110         rc = cifs_check_receive(midQ, ses->server, 0);
1111 out:
1112         cifs_delete_mid(midQ);
1113         add_credits(ses->server, 1, 0);
1114
1115         return rc;
1116 }
1117
1118 /* We send a LOCKINGX_CANCEL_LOCK to cause the Windows
1119    blocking lock to return. */
1120
1121 static int
1122 send_lock_cancel(const unsigned int xid, struct cifs_tcon *tcon,
1123                         struct smb_hdr *in_buf,
1124                         struct smb_hdr *out_buf)
1125 {
1126         int bytes_returned;
1127         struct cifs_ses *ses = tcon->ses;
1128         LOCK_REQ *pSMB = (LOCK_REQ *)in_buf;
1129
1130         /* We just modify the current in_buf to change
1131            the type of lock from LOCKING_ANDX_SHARED_LOCK
1132            or LOCKING_ANDX_EXCLUSIVE_LOCK to
1133            LOCKING_ANDX_CANCEL_LOCK. */
1134
1135         pSMB->LockType = LOCKING_ANDX_CANCEL_LOCK|LOCKING_ANDX_LARGE_FILES;
1136         pSMB->Timeout = 0;
1137         pSMB->hdr.Mid = get_next_mid(ses->server);
1138
1139         return SendReceive(xid, ses, in_buf, out_buf,
1140                         &bytes_returned, 0);
1141 }
1142
1143 int
1144 SendReceiveBlockingLock(const unsigned int xid, struct cifs_tcon *tcon,
1145             struct smb_hdr *in_buf, struct smb_hdr *out_buf,
1146             int *pbytes_returned)
1147 {
1148         int rc = 0;
1149         int rstart = 0;
1150         struct mid_q_entry *midQ;
1151         struct cifs_ses *ses;
1152         unsigned int len = be32_to_cpu(in_buf->smb_buf_length);
1153         struct kvec iov = { .iov_base = in_buf, .iov_len = len };
1154         struct smb_rqst rqst = { .rq_iov = &iov, .rq_nvec = 1 };
1155
1156         if (tcon == NULL || tcon->ses == NULL) {
1157                 cifs_dbg(VFS, "Null smb session\n");
1158                 return -EIO;
1159         }
1160         ses = tcon->ses;
1161
1162         if (ses->server == NULL) {
1163                 cifs_dbg(VFS, "Null tcp session\n");
1164                 return -EIO;
1165         }
1166
1167         if (ses->server->tcpStatus == CifsExiting)
1168                 return -ENOENT;
1169
1170         /* Ensure that we do not send more than 50 overlapping requests
1171            to the same server. We may make this configurable later or
1172            use ses->maxReq */
1173
1174         if (len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
1175                 cifs_dbg(VFS, "Illegal length, greater than maximum frame, %d\n",
1176                          len);
1177                 return -EIO;
1178         }
1179
1180         rc = wait_for_free_request(ses->server, CIFS_BLOCKING_OP, 0);
1181         if (rc)
1182                 return rc;
1183
1184         /* make sure that we sign in the same order that we send on this socket
1185            and avoid races inside tcp sendmsg code that could cause corruption
1186            of smb data */
1187
1188         mutex_lock(&ses->server->srv_mutex);
1189
1190         rc = allocate_mid(ses, in_buf, &midQ);
1191         if (rc) {
1192                 mutex_unlock(&ses->server->srv_mutex);
1193                 return rc;
1194         }
1195
1196         rc = cifs_sign_smb(in_buf, ses->server, &midQ->sequence_number);
1197         if (rc) {
1198                 cifs_delete_mid(midQ);
1199                 mutex_unlock(&ses->server->srv_mutex);
1200                 return rc;
1201         }
1202
1203         midQ->mid_state = MID_REQUEST_SUBMITTED;
1204         cifs_in_send_inc(ses->server);
1205         rc = smb_send(ses->server, in_buf, len);
1206         cifs_in_send_dec(ses->server);
1207         cifs_save_when_sent(midQ);
1208
1209         if (rc < 0)
1210                 ses->server->sequence_number -= 2;
1211
1212         mutex_unlock(&ses->server->srv_mutex);
1213
1214         if (rc < 0) {
1215                 cifs_delete_mid(midQ);
1216                 return rc;
1217         }
1218
1219         /* Wait for a reply - allow signals to interrupt. */
1220         rc = wait_event_interruptible(ses->server->response_q,
1221                 (!(midQ->mid_state == MID_REQUEST_SUBMITTED)) ||
1222                 ((ses->server->tcpStatus != CifsGood) &&
1223                  (ses->server->tcpStatus != CifsNew)));
1224
1225         /* Were we interrupted by a signal ? */
1226         if ((rc == -ERESTARTSYS) &&
1227                 (midQ->mid_state == MID_REQUEST_SUBMITTED) &&
1228                 ((ses->server->tcpStatus == CifsGood) ||
1229                  (ses->server->tcpStatus == CifsNew))) {
1230
1231                 if (in_buf->Command == SMB_COM_TRANSACTION2) {
1232                         /* POSIX lock. We send a NT_CANCEL SMB to cause the
1233                            blocking lock to return. */
1234                         rc = send_cancel(ses->server, &rqst, midQ);
1235                         if (rc) {
1236                                 cifs_delete_mid(midQ);
1237                                 return rc;
1238                         }
1239                 } else {
1240                         /* Windows lock. We send a LOCKINGX_CANCEL_LOCK
1241                            to cause the blocking lock to return. */
1242
1243                         rc = send_lock_cancel(xid, tcon, in_buf, out_buf);
1244
1245                         /* If we get -ENOLCK back the lock may have
1246                            already been removed. Don't exit in this case. */
1247                         if (rc && rc != -ENOLCK) {
1248                                 cifs_delete_mid(midQ);
1249                                 return rc;
1250                         }
1251                 }
1252
1253                 rc = wait_for_response(ses->server, midQ);
1254                 if (rc) {
1255                         send_cancel(ses->server, &rqst, midQ);
1256                         spin_lock(&GlobalMid_Lock);
1257                         if (midQ->mid_state == MID_REQUEST_SUBMITTED) {
1258                                 /* no longer considered to be "in-flight" */
1259                                 midQ->callback = DeleteMidQEntry;
1260                                 spin_unlock(&GlobalMid_Lock);
1261                                 return rc;
1262                         }
1263                         spin_unlock(&GlobalMid_Lock);
1264                 }
1265
1266                 /* We got the response - restart system call. */
1267                 rstart = 1;
1268         }
1269
1270         rc = cifs_sync_mid_result(midQ, ses->server);
1271         if (rc != 0)
1272                 return rc;
1273
1274         /* rcvd frame is ok */
1275         if (out_buf == NULL || midQ->mid_state != MID_RESPONSE_RECEIVED) {
1276                 rc = -EIO;
1277                 cifs_dbg(VFS, "Bad MID state?\n");
1278                 goto out;
1279         }
1280
1281         *pbytes_returned = get_rfc1002_length(midQ->resp_buf);
1282         memcpy(out_buf, midQ->resp_buf, *pbytes_returned + 4);
1283         rc = cifs_check_receive(midQ, ses->server, 0);
1284 out:
1285         cifs_delete_mid(midQ);
1286         if (rstart && rc == -EACCES)
1287                 return -ERESTARTSYS;
1288         return rc;
1289 }