treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[sfrench/cifs-2.6.git] / drivers / scsi / libiscsi_tcp.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * iSCSI over TCP/IP Data-Path lib
4  *
5  * Copyright (C) 2004 Dmitry Yusupov
6  * Copyright (C) 2004 Alex Aizman
7  * Copyright (C) 2005 - 2006 Mike Christie
8  * Copyright (C) 2006 Red Hat, Inc.  All rights reserved.
9  * maintained by open-iscsi@googlegroups.com
10  *
11  * See the file COPYING included with this distribution for more details.
12  *
13  * Credits:
14  *      Christoph Hellwig
15  *      FUJITA Tomonori
16  *      Arne Redlich
17  *      Zhenyu Wang
18  */
19
20 #include <crypto/hash.h>
21 #include <linux/types.h>
22 #include <linux/list.h>
23 #include <linux/inet.h>
24 #include <linux/slab.h>
25 #include <linux/file.h>
26 #include <linux/blkdev.h>
27 #include <linux/delay.h>
28 #include <linux/kfifo.h>
29 #include <linux/scatterlist.h>
30 #include <linux/module.h>
31 #include <net/tcp.h>
32 #include <scsi/scsi_cmnd.h>
33 #include <scsi/scsi_device.h>
34 #include <scsi/scsi_host.h>
35 #include <scsi/scsi.h>
36 #include <scsi/scsi_transport_iscsi.h>
37 #include <trace/events/iscsi.h>
38
39 #include "iscsi_tcp.h"
40
41 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, "
42               "Dmitry Yusupov <dmitry_yus@yahoo.com>, "
43               "Alex Aizman <itn780@yahoo.com>");
44 MODULE_DESCRIPTION("iSCSI/TCP data-path");
45 MODULE_LICENSE("GPL");
46
47 static int iscsi_dbg_libtcp;
48 module_param_named(debug_libiscsi_tcp, iscsi_dbg_libtcp, int,
49                    S_IRUGO | S_IWUSR);
50 MODULE_PARM_DESC(debug_libiscsi_tcp, "Turn on debugging for libiscsi_tcp "
51                  "module. Set to 1 to turn on, and zero to turn off. Default "
52                  "is off.");
53
54 #define ISCSI_DBG_TCP(_conn, dbg_fmt, arg...)                   \
55         do {                                                    \
56                 if (iscsi_dbg_libtcp)                           \
57                         iscsi_conn_printk(KERN_INFO, _conn,     \
58                                              "%s " dbg_fmt,     \
59                                              __func__, ##arg);  \
60                 iscsi_dbg_trace(trace_iscsi_dbg_tcp,            \
61                                 &(_conn)->cls_conn->dev,        \
62                                 "%s " dbg_fmt, __func__, ##arg);\
63         } while (0);
64
65 static int iscsi_tcp_hdr_recv_done(struct iscsi_tcp_conn *tcp_conn,
66                                    struct iscsi_segment *segment);
67
68 /*
69  * Scatterlist handling: inside the iscsi_segment, we
70  * remember an index into the scatterlist, and set data/size
71  * to the current scatterlist entry. For highmem pages, we
72  * kmap as needed.
73  *
74  * Note that the page is unmapped when we return from
75  * TCP's data_ready handler, so we may end up mapping and
76  * unmapping the same page repeatedly. The whole reason
77  * for this is that we shouldn't keep the page mapped
78  * outside the softirq.
79  */
80
81 /**
82  * iscsi_tcp_segment_init_sg - init indicated scatterlist entry
83  * @segment: the buffer object
84  * @sg: scatterlist
85  * @offset: byte offset into that sg entry
86  *
87  * This function sets up the segment so that subsequent
88  * data is copied to the indicated sg entry, at the given
89  * offset.
90  */
91 static inline void
92 iscsi_tcp_segment_init_sg(struct iscsi_segment *segment,
93                           struct scatterlist *sg, unsigned int offset)
94 {
95         segment->sg = sg;
96         segment->sg_offset = offset;
97         segment->size = min(sg->length - offset,
98                             segment->total_size - segment->total_copied);
99         segment->data = NULL;
100 }
101
102 /**
103  * iscsi_tcp_segment_map - map the current S/G page
104  * @segment: iscsi_segment
105  * @recv: 1 if called from recv path
106  *
107  * We only need to possibly kmap data if scatter lists are being used,
108  * because the iscsi passthrough and internal IO paths will never use high
109  * mem pages.
110  */
111 static void iscsi_tcp_segment_map(struct iscsi_segment *segment, int recv)
112 {
113         struct scatterlist *sg;
114
115         if (segment->data != NULL || !segment->sg)
116                 return;
117
118         sg = segment->sg;
119         BUG_ON(segment->sg_mapped);
120         BUG_ON(sg->length == 0);
121
122         /*
123          * We always map for the recv path.
124          *
125          * If the page count is greater than one it is ok to send
126          * to the network layer's zero copy send path. If not we
127          * have to go the slow sendmsg path.
128          *
129          * Same goes for slab pages: skb_can_coalesce() allows
130          * coalescing neighboring slab objects into a single frag which
131          * triggers one of hardened usercopy checks.
132          */
133         if (!recv && page_count(sg_page(sg)) >= 1 && !PageSlab(sg_page(sg)))
134                 return;
135
136         if (recv) {
137                 segment->atomic_mapped = true;
138                 segment->sg_mapped = kmap_atomic(sg_page(sg));
139         } else {
140                 segment->atomic_mapped = false;
141                 /* the xmit path can sleep with the page mapped so use kmap */
142                 segment->sg_mapped = kmap(sg_page(sg));
143         }
144
145         segment->data = segment->sg_mapped + sg->offset + segment->sg_offset;
146 }
147
148 void iscsi_tcp_segment_unmap(struct iscsi_segment *segment)
149 {
150         if (segment->sg_mapped) {
151                 if (segment->atomic_mapped)
152                         kunmap_atomic(segment->sg_mapped);
153                 else
154                         kunmap(sg_page(segment->sg));
155                 segment->sg_mapped = NULL;
156                 segment->data = NULL;
157         }
158 }
159 EXPORT_SYMBOL_GPL(iscsi_tcp_segment_unmap);
160
161 /*
162  * Splice the digest buffer into the buffer
163  */
164 static inline void
165 iscsi_tcp_segment_splice_digest(struct iscsi_segment *segment, void *digest)
166 {
167         segment->data = digest;
168         segment->digest_len = ISCSI_DIGEST_SIZE;
169         segment->total_size += ISCSI_DIGEST_SIZE;
170         segment->size = ISCSI_DIGEST_SIZE;
171         segment->copied = 0;
172         segment->sg = NULL;
173         segment->hash = NULL;
174 }
175
176 /**
177  * iscsi_tcp_segment_done - check whether the segment is complete
178  * @tcp_conn: iscsi tcp connection
179  * @segment: iscsi segment to check
180  * @recv: set to one of this is called from the recv path
181  * @copied: number of bytes copied
182  *
183  * Check if we're done receiving this segment. If the receive
184  * buffer is full but we expect more data, move on to the
185  * next entry in the scatterlist.
186  *
187  * If the amount of data we received isn't a multiple of 4,
188  * we will transparently receive the pad bytes, too.
189  *
190  * This function must be re-entrant.
191  */
192 int iscsi_tcp_segment_done(struct iscsi_tcp_conn *tcp_conn,
193                            struct iscsi_segment *segment, int recv,
194                            unsigned copied)
195 {
196         struct scatterlist sg;
197         unsigned int pad;
198
199         ISCSI_DBG_TCP(tcp_conn->iscsi_conn, "copied %u %u size %u %s\n",
200                       segment->copied, copied, segment->size,
201                       recv ? "recv" : "xmit");
202         if (segment->hash && copied) {
203                 /*
204                  * If a segment is kmapd we must unmap it before sending
205                  * to the crypto layer since that will try to kmap it again.
206                  */
207                 iscsi_tcp_segment_unmap(segment);
208
209                 if (!segment->data) {
210                         sg_init_table(&sg, 1);
211                         sg_set_page(&sg, sg_page(segment->sg), copied,
212                                     segment->copied + segment->sg_offset +
213                                                         segment->sg->offset);
214                 } else
215                         sg_init_one(&sg, segment->data + segment->copied,
216                                     copied);
217                 ahash_request_set_crypt(segment->hash, &sg, NULL, copied);
218                 crypto_ahash_update(segment->hash);
219         }
220
221         segment->copied += copied;
222         if (segment->copied < segment->size) {
223                 iscsi_tcp_segment_map(segment, recv);
224                 return 0;
225         }
226
227         segment->total_copied += segment->copied;
228         segment->copied = 0;
229         segment->size = 0;
230
231         /* Unmap the current scatterlist page, if there is one. */
232         iscsi_tcp_segment_unmap(segment);
233
234         /* Do we have more scatterlist entries? */
235         ISCSI_DBG_TCP(tcp_conn->iscsi_conn, "total copied %u total size %u\n",
236                       segment->total_copied, segment->total_size);
237         if (segment->total_copied < segment->total_size) {
238                 /* Proceed to the next entry in the scatterlist. */
239                 iscsi_tcp_segment_init_sg(segment, sg_next(segment->sg),
240                                           0);
241                 iscsi_tcp_segment_map(segment, recv);
242                 BUG_ON(segment->size == 0);
243                 return 0;
244         }
245
246         /* Do we need to handle padding? */
247         if (!(tcp_conn->iscsi_conn->session->tt->caps & CAP_PADDING_OFFLOAD)) {
248                 pad = iscsi_padding(segment->total_copied);
249                 if (pad != 0) {
250                         ISCSI_DBG_TCP(tcp_conn->iscsi_conn,
251                                       "consume %d pad bytes\n", pad);
252                         segment->total_size += pad;
253                         segment->size = pad;
254                         segment->data = segment->padbuf;
255                         return 0;
256                 }
257         }
258
259         /*
260          * Set us up for transferring the data digest. hdr digest
261          * is completely handled in hdr done function.
262          */
263         if (segment->hash) {
264                 ahash_request_set_crypt(segment->hash, NULL,
265                                         segment->digest, 0);
266                 crypto_ahash_final(segment->hash);
267                 iscsi_tcp_segment_splice_digest(segment,
268                                  recv ? segment->recv_digest : segment->digest);
269                 return 0;
270         }
271
272         return 1;
273 }
274 EXPORT_SYMBOL_GPL(iscsi_tcp_segment_done);
275
276 /**
277  * iscsi_tcp_segment_recv - copy data to segment
278  * @tcp_conn: the iSCSI TCP connection
279  * @segment: the buffer to copy to
280  * @ptr: data pointer
281  * @len: amount of data available
282  *
283  * This function copies up to @len bytes to the
284  * given buffer, and returns the number of bytes
285  * consumed, which can actually be less than @len.
286  *
287  * If hash digest is enabled, the function will update the
288  * hash while copying.
289  * Combining these two operations doesn't buy us a lot (yet),
290  * but in the future we could implement combined copy+crc,
291  * just way we do for network layer checksums.
292  */
293 static int
294 iscsi_tcp_segment_recv(struct iscsi_tcp_conn *tcp_conn,
295                        struct iscsi_segment *segment, const void *ptr,
296                        unsigned int len)
297 {
298         unsigned int copy = 0, copied = 0;
299
300         while (!iscsi_tcp_segment_done(tcp_conn, segment, 1, copy)) {
301                 if (copied == len) {
302                         ISCSI_DBG_TCP(tcp_conn->iscsi_conn,
303                                       "copied %d bytes\n", len);
304                         break;
305                 }
306
307                 copy = min(len - copied, segment->size - segment->copied);
308                 ISCSI_DBG_TCP(tcp_conn->iscsi_conn, "copying %d\n", copy);
309                 memcpy(segment->data + segment->copied, ptr + copied, copy);
310                 copied += copy;
311         }
312         return copied;
313 }
314
315 inline void
316 iscsi_tcp_dgst_header(struct ahash_request *hash, const void *hdr,
317                       size_t hdrlen, unsigned char digest[ISCSI_DIGEST_SIZE])
318 {
319         struct scatterlist sg;
320
321         sg_init_one(&sg, hdr, hdrlen);
322         ahash_request_set_crypt(hash, &sg, digest, hdrlen);
323         crypto_ahash_digest(hash);
324 }
325 EXPORT_SYMBOL_GPL(iscsi_tcp_dgst_header);
326
327 static inline int
328 iscsi_tcp_dgst_verify(struct iscsi_tcp_conn *tcp_conn,
329                       struct iscsi_segment *segment)
330 {
331         if (!segment->digest_len)
332                 return 1;
333
334         if (memcmp(segment->recv_digest, segment->digest,
335                    segment->digest_len)) {
336                 ISCSI_DBG_TCP(tcp_conn->iscsi_conn, "digest mismatch\n");
337                 return 0;
338         }
339
340         return 1;
341 }
342
343 /*
344  * Helper function to set up segment buffer
345  */
346 static inline void
347 __iscsi_segment_init(struct iscsi_segment *segment, size_t size,
348                      iscsi_segment_done_fn_t *done, struct ahash_request *hash)
349 {
350         memset(segment, 0, sizeof(*segment));
351         segment->total_size = size;
352         segment->done = done;
353
354         if (hash) {
355                 segment->hash = hash;
356                 crypto_ahash_init(hash);
357         }
358 }
359
360 inline void
361 iscsi_segment_init_linear(struct iscsi_segment *segment, void *data,
362                           size_t size, iscsi_segment_done_fn_t *done,
363                           struct ahash_request *hash)
364 {
365         __iscsi_segment_init(segment, size, done, hash);
366         segment->data = data;
367         segment->size = size;
368 }
369 EXPORT_SYMBOL_GPL(iscsi_segment_init_linear);
370
371 inline int
372 iscsi_segment_seek_sg(struct iscsi_segment *segment,
373                       struct scatterlist *sg_list, unsigned int sg_count,
374                       unsigned int offset, size_t size,
375                       iscsi_segment_done_fn_t *done,
376                       struct ahash_request *hash)
377 {
378         struct scatterlist *sg;
379         unsigned int i;
380
381         __iscsi_segment_init(segment, size, done, hash);
382         for_each_sg(sg_list, sg, sg_count, i) {
383                 if (offset < sg->length) {
384                         iscsi_tcp_segment_init_sg(segment, sg, offset);
385                         return 0;
386                 }
387                 offset -= sg->length;
388         }
389
390         return ISCSI_ERR_DATA_OFFSET;
391 }
392 EXPORT_SYMBOL_GPL(iscsi_segment_seek_sg);
393
394 /**
395  * iscsi_tcp_hdr_recv_prep - prep segment for hdr reception
396  * @tcp_conn: iscsi connection to prep for
397  *
398  * This function always passes NULL for the hash argument, because when this
399  * function is called we do not yet know the final size of the header and want
400  * to delay the digest processing until we know that.
401  */
402 void iscsi_tcp_hdr_recv_prep(struct iscsi_tcp_conn *tcp_conn)
403 {
404         ISCSI_DBG_TCP(tcp_conn->iscsi_conn,
405                       "(%s)\n", tcp_conn->iscsi_conn->hdrdgst_en ?
406                       "digest enabled" : "digest disabled");
407         iscsi_segment_init_linear(&tcp_conn->in.segment,
408                                 tcp_conn->in.hdr_buf, sizeof(struct iscsi_hdr),
409                                 iscsi_tcp_hdr_recv_done, NULL);
410 }
411 EXPORT_SYMBOL_GPL(iscsi_tcp_hdr_recv_prep);
412
413 /*
414  * Handle incoming reply to any other type of command
415  */
416 static int
417 iscsi_tcp_data_recv_done(struct iscsi_tcp_conn *tcp_conn,
418                          struct iscsi_segment *segment)
419 {
420         struct iscsi_conn *conn = tcp_conn->iscsi_conn;
421         int rc = 0;
422
423         if (!iscsi_tcp_dgst_verify(tcp_conn, segment))
424                 return ISCSI_ERR_DATA_DGST;
425
426         rc = iscsi_complete_pdu(conn, tcp_conn->in.hdr,
427                         conn->data, tcp_conn->in.datalen);
428         if (rc)
429                 return rc;
430
431         iscsi_tcp_hdr_recv_prep(tcp_conn);
432         return 0;
433 }
434
435 static void
436 iscsi_tcp_data_recv_prep(struct iscsi_tcp_conn *tcp_conn)
437 {
438         struct iscsi_conn *conn = tcp_conn->iscsi_conn;
439         struct ahash_request *rx_hash = NULL;
440
441         if (conn->datadgst_en &&
442             !(conn->session->tt->caps & CAP_DIGEST_OFFLOAD))
443                 rx_hash = tcp_conn->rx_hash;
444
445         iscsi_segment_init_linear(&tcp_conn->in.segment,
446                                 conn->data, tcp_conn->in.datalen,
447                                 iscsi_tcp_data_recv_done, rx_hash);
448 }
449
450 /**
451  * iscsi_tcp_cleanup_task - free tcp_task resources
452  * @task: iscsi task
453  *
454  * must be called with session back_lock
455  */
456 void iscsi_tcp_cleanup_task(struct iscsi_task *task)
457 {
458         struct iscsi_tcp_task *tcp_task = task->dd_data;
459         struct iscsi_r2t_info *r2t;
460
461         /* nothing to do for mgmt */
462         if (!task->sc)
463                 return;
464
465         spin_lock_bh(&tcp_task->queue2pool);
466         /* flush task's r2t queues */
467         while (kfifo_out(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*))) {
468                 kfifo_in(&tcp_task->r2tpool.queue, (void*)&r2t,
469                             sizeof(void*));
470                 ISCSI_DBG_TCP(task->conn, "pending r2t dropped\n");
471         }
472
473         r2t = tcp_task->r2t;
474         if (r2t != NULL) {
475                 kfifo_in(&tcp_task->r2tpool.queue, (void*)&r2t,
476                             sizeof(void*));
477                 tcp_task->r2t = NULL;
478         }
479         spin_unlock_bh(&tcp_task->queue2pool);
480 }
481 EXPORT_SYMBOL_GPL(iscsi_tcp_cleanup_task);
482
483 /**
484  * iscsi_tcp_data_in - SCSI Data-In Response processing
485  * @conn: iscsi connection
486  * @task: scsi command task
487  */
488 static int iscsi_tcp_data_in(struct iscsi_conn *conn, struct iscsi_task *task)
489 {
490         struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
491         struct iscsi_tcp_task *tcp_task = task->dd_data;
492         struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)tcp_conn->in.hdr;
493         int datasn = be32_to_cpu(rhdr->datasn);
494         unsigned total_in_length = task->sc->sdb.length;
495
496         /*
497          * lib iscsi will update this in the completion handling if there
498          * is status.
499          */
500         if (!(rhdr->flags & ISCSI_FLAG_DATA_STATUS))
501                 iscsi_update_cmdsn(conn->session, (struct iscsi_nopin*)rhdr);
502
503         if (tcp_conn->in.datalen == 0)
504                 return 0;
505
506         if (tcp_task->exp_datasn != datasn) {
507                 ISCSI_DBG_TCP(conn, "task->exp_datasn(%d) != rhdr->datasn(%d)"
508                               "\n", tcp_task->exp_datasn, datasn);
509                 return ISCSI_ERR_DATASN;
510         }
511
512         tcp_task->exp_datasn++;
513
514         tcp_task->data_offset = be32_to_cpu(rhdr->offset);
515         if (tcp_task->data_offset + tcp_conn->in.datalen > total_in_length) {
516                 ISCSI_DBG_TCP(conn, "data_offset(%d) + data_len(%d) > "
517                               "total_length_in(%d)\n", tcp_task->data_offset,
518                               tcp_conn->in.datalen, total_in_length);
519                 return ISCSI_ERR_DATA_OFFSET;
520         }
521
522         conn->datain_pdus_cnt++;
523         return 0;
524 }
525
526 /**
527  * iscsi_tcp_r2t_rsp - iSCSI R2T Response processing
528  * @conn: iscsi connection
529  * @task: scsi command task
530  */
531 static int iscsi_tcp_r2t_rsp(struct iscsi_conn *conn, struct iscsi_task *task)
532 {
533         struct iscsi_session *session = conn->session;
534         struct iscsi_tcp_task *tcp_task = task->dd_data;
535         struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
536         struct iscsi_r2t_rsp *rhdr = (struct iscsi_r2t_rsp *)tcp_conn->in.hdr;
537         struct iscsi_r2t_info *r2t;
538         int r2tsn = be32_to_cpu(rhdr->r2tsn);
539         u32 data_length;
540         u32 data_offset;
541         int rc;
542
543         if (tcp_conn->in.datalen) {
544                 iscsi_conn_printk(KERN_ERR, conn,
545                                   "invalid R2t with datalen %d\n",
546                                   tcp_conn->in.datalen);
547                 return ISCSI_ERR_DATALEN;
548         }
549
550         if (tcp_task->exp_datasn != r2tsn){
551                 ISCSI_DBG_TCP(conn, "task->exp_datasn(%d) != rhdr->r2tsn(%d)\n",
552                               tcp_task->exp_datasn, r2tsn);
553                 return ISCSI_ERR_R2TSN;
554         }
555
556         /* fill-in new R2T associated with the task */
557         iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr);
558
559         if (!task->sc || session->state != ISCSI_STATE_LOGGED_IN) {
560                 iscsi_conn_printk(KERN_INFO, conn,
561                                   "dropping R2T itt %d in recovery.\n",
562                                   task->itt);
563                 return 0;
564         }
565
566         data_length = be32_to_cpu(rhdr->data_length);
567         if (data_length == 0) {
568                 iscsi_conn_printk(KERN_ERR, conn,
569                                   "invalid R2T with zero data len\n");
570                 return ISCSI_ERR_DATALEN;
571         }
572
573         if (data_length > session->max_burst)
574                 ISCSI_DBG_TCP(conn, "invalid R2T with data len %u and max "
575                               "burst %u. Attempting to execute request.\n",
576                               data_length, session->max_burst);
577
578         data_offset = be32_to_cpu(rhdr->data_offset);
579         if (data_offset + data_length > task->sc->sdb.length) {
580                 iscsi_conn_printk(KERN_ERR, conn,
581                                   "invalid R2T with data len %u at offset %u "
582                                   "and total length %d\n", data_length,
583                                   data_offset, task->sc->sdb.length);
584                 return ISCSI_ERR_DATALEN;
585         }
586
587         spin_lock(&tcp_task->pool2queue);
588         rc = kfifo_out(&tcp_task->r2tpool.queue, (void *)&r2t, sizeof(void *));
589         if (!rc) {
590                 iscsi_conn_printk(KERN_ERR, conn, "Could not allocate R2T. "
591                                   "Target has sent more R2Ts than it "
592                                   "negotiated for or driver has leaked.\n");
593                 spin_unlock(&tcp_task->pool2queue);
594                 return ISCSI_ERR_PROTO;
595         }
596
597         r2t->exp_statsn = rhdr->statsn;
598         r2t->data_length = data_length;
599         r2t->data_offset = data_offset;
600
601         r2t->ttt = rhdr->ttt; /* no flip */
602         r2t->datasn = 0;
603         r2t->sent = 0;
604
605         tcp_task->exp_datasn = r2tsn + 1;
606         kfifo_in(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*));
607         conn->r2t_pdus_cnt++;
608         spin_unlock(&tcp_task->pool2queue);
609
610         iscsi_requeue_task(task);
611         return 0;
612 }
613
614 /*
615  * Handle incoming reply to DataIn command
616  */
617 static int
618 iscsi_tcp_process_data_in(struct iscsi_tcp_conn *tcp_conn,
619                           struct iscsi_segment *segment)
620 {
621         struct iscsi_conn *conn = tcp_conn->iscsi_conn;
622         struct iscsi_hdr *hdr = tcp_conn->in.hdr;
623         int rc;
624
625         if (!iscsi_tcp_dgst_verify(tcp_conn, segment))
626                 return ISCSI_ERR_DATA_DGST;
627
628         /* check for non-exceptional status */
629         if (hdr->flags & ISCSI_FLAG_DATA_STATUS) {
630                 rc = iscsi_complete_pdu(conn, tcp_conn->in.hdr, NULL, 0);
631                 if (rc)
632                         return rc;
633         }
634
635         iscsi_tcp_hdr_recv_prep(tcp_conn);
636         return 0;
637 }
638
639 /**
640  * iscsi_tcp_hdr_dissect - process PDU header
641  * @conn: iSCSI connection
642  * @hdr: PDU header
643  *
644  * This function analyzes the header of the PDU received,
645  * and performs several sanity checks. If the PDU is accompanied
646  * by data, the receive buffer is set up to copy the incoming data
647  * to the correct location.
648  */
649 static int
650 iscsi_tcp_hdr_dissect(struct iscsi_conn *conn, struct iscsi_hdr *hdr)
651 {
652         int rc = 0, opcode, ahslen;
653         struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
654         struct iscsi_task *task;
655
656         /* verify PDU length */
657         tcp_conn->in.datalen = ntoh24(hdr->dlength);
658         if (tcp_conn->in.datalen > conn->max_recv_dlength) {
659                 iscsi_conn_printk(KERN_ERR, conn,
660                                   "iscsi_tcp: datalen %d > %d\n",
661                                   tcp_conn->in.datalen, conn->max_recv_dlength);
662                 return ISCSI_ERR_DATALEN;
663         }
664
665         /* Additional header segments. So far, we don't
666          * process additional headers.
667          */
668         ahslen = hdr->hlength << 2;
669
670         opcode = hdr->opcode & ISCSI_OPCODE_MASK;
671         /* verify itt (itt encoding: age+cid+itt) */
672         rc = iscsi_verify_itt(conn, hdr->itt);
673         if (rc)
674                 return rc;
675
676         ISCSI_DBG_TCP(conn, "opcode 0x%x ahslen %d datalen %d\n",
677                       opcode, ahslen, tcp_conn->in.datalen);
678
679         switch(opcode) {
680         case ISCSI_OP_SCSI_DATA_IN:
681                 spin_lock(&conn->session->back_lock);
682                 task = iscsi_itt_to_ctask(conn, hdr->itt);
683                 if (!task)
684                         rc = ISCSI_ERR_BAD_ITT;
685                 else
686                         rc = iscsi_tcp_data_in(conn, task);
687                 if (rc) {
688                         spin_unlock(&conn->session->back_lock);
689                         break;
690                 }
691
692                 if (tcp_conn->in.datalen) {
693                         struct iscsi_tcp_task *tcp_task = task->dd_data;
694                         struct ahash_request *rx_hash = NULL;
695                         struct scsi_data_buffer *sdb = &task->sc->sdb;
696
697                         /*
698                          * Setup copy of Data-In into the struct scsi_cmnd
699                          * Scatterlist case:
700                          * We set up the iscsi_segment to point to the next
701                          * scatterlist entry to copy to. As we go along,
702                          * we move on to the next scatterlist entry and
703                          * update the digest per-entry.
704                          */
705                         if (conn->datadgst_en &&
706                             !(conn->session->tt->caps & CAP_DIGEST_OFFLOAD))
707                                 rx_hash = tcp_conn->rx_hash;
708
709                         ISCSI_DBG_TCP(conn, "iscsi_tcp_begin_data_in( "
710                                      "offset=%d, datalen=%d)\n",
711                                       tcp_task->data_offset,
712                                       tcp_conn->in.datalen);
713                         task->last_xfer = jiffies;
714                         rc = iscsi_segment_seek_sg(&tcp_conn->in.segment,
715                                                    sdb->table.sgl,
716                                                    sdb->table.nents,
717                                                    tcp_task->data_offset,
718                                                    tcp_conn->in.datalen,
719                                                    iscsi_tcp_process_data_in,
720                                                    rx_hash);
721                         spin_unlock(&conn->session->back_lock);
722                         return rc;
723                 }
724                 rc = __iscsi_complete_pdu(conn, hdr, NULL, 0);
725                 spin_unlock(&conn->session->back_lock);
726                 break;
727         case ISCSI_OP_SCSI_CMD_RSP:
728                 if (tcp_conn->in.datalen) {
729                         iscsi_tcp_data_recv_prep(tcp_conn);
730                         return 0;
731                 }
732                 rc = iscsi_complete_pdu(conn, hdr, NULL, 0);
733                 break;
734         case ISCSI_OP_R2T:
735                 spin_lock(&conn->session->back_lock);
736                 task = iscsi_itt_to_ctask(conn, hdr->itt);
737                 spin_unlock(&conn->session->back_lock);
738                 if (!task)
739                         rc = ISCSI_ERR_BAD_ITT;
740                 else if (ahslen)
741                         rc = ISCSI_ERR_AHSLEN;
742                 else if (task->sc->sc_data_direction == DMA_TO_DEVICE) {
743                         task->last_xfer = jiffies;
744                         spin_lock(&conn->session->frwd_lock);
745                         rc = iscsi_tcp_r2t_rsp(conn, task);
746                         spin_unlock(&conn->session->frwd_lock);
747                 } else
748                         rc = ISCSI_ERR_PROTO;
749                 break;
750         case ISCSI_OP_LOGIN_RSP:
751         case ISCSI_OP_TEXT_RSP:
752         case ISCSI_OP_REJECT:
753         case ISCSI_OP_ASYNC_EVENT:
754                 /*
755                  * It is possible that we could get a PDU with a buffer larger
756                  * than 8K, but there are no targets that currently do this.
757                  * For now we fail until we find a vendor that needs it
758                  */
759                 if (ISCSI_DEF_MAX_RECV_SEG_LEN < tcp_conn->in.datalen) {
760                         iscsi_conn_printk(KERN_ERR, conn,
761                                           "iscsi_tcp: received buffer of "
762                                           "len %u but conn buffer is only %u "
763                                           "(opcode %0x)\n",
764                                           tcp_conn->in.datalen,
765                                           ISCSI_DEF_MAX_RECV_SEG_LEN, opcode);
766                         rc = ISCSI_ERR_PROTO;
767                         break;
768                 }
769
770                 /* If there's data coming in with the response,
771                  * receive it to the connection's buffer.
772                  */
773                 if (tcp_conn->in.datalen) {
774                         iscsi_tcp_data_recv_prep(tcp_conn);
775                         return 0;
776                 }
777         /* fall through */
778         case ISCSI_OP_LOGOUT_RSP:
779         case ISCSI_OP_NOOP_IN:
780         case ISCSI_OP_SCSI_TMFUNC_RSP:
781                 rc = iscsi_complete_pdu(conn, hdr, NULL, 0);
782                 break;
783         default:
784                 rc = ISCSI_ERR_BAD_OPCODE;
785                 break;
786         }
787
788         if (rc == 0) {
789                 /* Anything that comes with data should have
790                  * been handled above. */
791                 if (tcp_conn->in.datalen)
792                         return ISCSI_ERR_PROTO;
793                 iscsi_tcp_hdr_recv_prep(tcp_conn);
794         }
795
796         return rc;
797 }
798
799 /**
800  * iscsi_tcp_hdr_recv_done - process PDU header
801  * @tcp_conn: iSCSI TCP connection
802  * @segment: the buffer segment being processed
803  *
804  * This is the callback invoked when the PDU header has
805  * been received. If the header is followed by additional
806  * header segments, we go back for more data.
807  */
808 static int
809 iscsi_tcp_hdr_recv_done(struct iscsi_tcp_conn *tcp_conn,
810                         struct iscsi_segment *segment)
811 {
812         struct iscsi_conn *conn = tcp_conn->iscsi_conn;
813         struct iscsi_hdr *hdr;
814
815         /* Check if there are additional header segments
816          * *prior* to computing the digest, because we
817          * may need to go back to the caller for more.
818          */
819         hdr = (struct iscsi_hdr *) tcp_conn->in.hdr_buf;
820         if (segment->copied == sizeof(struct iscsi_hdr) && hdr->hlength) {
821                 /* Bump the header length - the caller will
822                  * just loop around and get the AHS for us, and
823                  * call again. */
824                 unsigned int ahslen = hdr->hlength << 2;
825
826                 /* Make sure we don't overflow */
827                 if (sizeof(*hdr) + ahslen > sizeof(tcp_conn->in.hdr_buf))
828                         return ISCSI_ERR_AHSLEN;
829
830                 segment->total_size += ahslen;
831                 segment->size += ahslen;
832                 return 0;
833         }
834
835         /* We're done processing the header. See if we're doing
836          * header digests; if so, set up the recv_digest buffer
837          * and go back for more. */
838         if (conn->hdrdgst_en &&
839             !(conn->session->tt->caps & CAP_DIGEST_OFFLOAD)) {
840                 if (segment->digest_len == 0) {
841                         /*
842                          * Even if we offload the digest processing we
843                          * splice it in so we can increment the skb/segment
844                          * counters in preparation for the data segment.
845                          */
846                         iscsi_tcp_segment_splice_digest(segment,
847                                                         segment->recv_digest);
848                         return 0;
849                 }
850
851                 iscsi_tcp_dgst_header(tcp_conn->rx_hash, hdr,
852                                       segment->total_copied - ISCSI_DIGEST_SIZE,
853                                       segment->digest);
854
855                 if (!iscsi_tcp_dgst_verify(tcp_conn, segment))
856                         return ISCSI_ERR_HDR_DGST;
857         }
858
859         tcp_conn->in.hdr = hdr;
860         return iscsi_tcp_hdr_dissect(conn, hdr);
861 }
862
863 /**
864  * iscsi_tcp_recv_segment_is_hdr - tests if we are reading in a header
865  * @tcp_conn: iscsi tcp conn
866  *
867  * returns non zero if we are currently processing or setup to process
868  * a header.
869  */
870 inline int iscsi_tcp_recv_segment_is_hdr(struct iscsi_tcp_conn *tcp_conn)
871 {
872         return tcp_conn->in.segment.done == iscsi_tcp_hdr_recv_done;
873 }
874 EXPORT_SYMBOL_GPL(iscsi_tcp_recv_segment_is_hdr);
875
876 /**
877  * iscsi_tcp_recv_skb - Process skb
878  * @conn: iscsi connection
879  * @skb: network buffer with header and/or data segment
880  * @offset: offset in skb
881  * @offloaded: bool indicating if transfer was offloaded
882  * @status: iscsi TCP status result
883  *
884  * Will return status of transfer in @status. And will return
885  * number of bytes copied.
886  */
887 int iscsi_tcp_recv_skb(struct iscsi_conn *conn, struct sk_buff *skb,
888                        unsigned int offset, bool offloaded, int *status)
889 {
890         struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
891         struct iscsi_segment *segment = &tcp_conn->in.segment;
892         struct skb_seq_state seq;
893         unsigned int consumed = 0;
894         int rc = 0;
895
896         ISCSI_DBG_TCP(conn, "in %d bytes\n", skb->len - offset);
897         /*
898          * Update for each skb instead of pdu, because over slow networks a
899          * data_in's data could take a while to read in. We also want to
900          * account for r2ts.
901          */
902         conn->last_recv = jiffies;
903
904         if (unlikely(conn->suspend_rx)) {
905                 ISCSI_DBG_TCP(conn, "Rx suspended!\n");
906                 *status = ISCSI_TCP_SUSPENDED;
907                 return 0;
908         }
909
910         if (offloaded) {
911                 segment->total_copied = segment->total_size;
912                 goto segment_done;
913         }
914
915         skb_prepare_seq_read(skb, offset, skb->len, &seq);
916         while (1) {
917                 unsigned int avail;
918                 const u8 *ptr;
919
920                 avail = skb_seq_read(consumed, &ptr, &seq);
921                 if (avail == 0) {
922                         ISCSI_DBG_TCP(conn, "no more data avail. Consumed %d\n",
923                                       consumed);
924                         *status = ISCSI_TCP_SKB_DONE;
925                         goto skb_done;
926                 }
927                 BUG_ON(segment->copied >= segment->size);
928
929                 ISCSI_DBG_TCP(conn, "skb %p ptr=%p avail=%u\n", skb, ptr,
930                               avail);
931                 rc = iscsi_tcp_segment_recv(tcp_conn, segment, ptr, avail);
932                 BUG_ON(rc == 0);
933                 consumed += rc;
934
935                 if (segment->total_copied >= segment->total_size) {
936                         skb_abort_seq_read(&seq);
937                         goto segment_done;
938                 }
939         }
940
941 segment_done:
942         *status = ISCSI_TCP_SEGMENT_DONE;
943         ISCSI_DBG_TCP(conn, "segment done\n");
944         rc = segment->done(tcp_conn, segment);
945         if (rc != 0) {
946                 *status = ISCSI_TCP_CONN_ERR;
947                 ISCSI_DBG_TCP(conn, "Error receiving PDU, errno=%d\n", rc);
948                 iscsi_conn_failure(conn, rc);
949                 return 0;
950         }
951         /* The done() functions sets up the next segment. */
952
953 skb_done:
954         conn->rxdata_octets += consumed;
955         return consumed;
956 }
957 EXPORT_SYMBOL_GPL(iscsi_tcp_recv_skb);
958
959 /**
960  * iscsi_tcp_task_init - Initialize iSCSI SCSI_READ or SCSI_WRITE commands
961  * @task: scsi command task
962  */
963 int iscsi_tcp_task_init(struct iscsi_task *task)
964 {
965         struct iscsi_tcp_task *tcp_task = task->dd_data;
966         struct iscsi_conn *conn = task->conn;
967         struct scsi_cmnd *sc = task->sc;
968         int err;
969
970         if (!sc) {
971                 /*
972                  * mgmt tasks do not have a scatterlist since they come
973                  * in from the iscsi interface.
974                  */
975                 ISCSI_DBG_TCP(conn, "mtask deq [itt 0x%x]\n", task->itt);
976
977                 return conn->session->tt->init_pdu(task, 0, task->data_count);
978         }
979
980         BUG_ON(kfifo_len(&tcp_task->r2tqueue));
981         tcp_task->exp_datasn = 0;
982
983         /* Prepare PDU, optionally w/ immediate data */
984         ISCSI_DBG_TCP(conn, "task deq [itt 0x%x imm %d unsol %d]\n",
985                       task->itt, task->imm_count, task->unsol_r2t.data_length);
986
987         err = conn->session->tt->init_pdu(task, 0, task->imm_count);
988         if (err)
989                 return err;
990         task->imm_count = 0;
991         return 0;
992 }
993 EXPORT_SYMBOL_GPL(iscsi_tcp_task_init);
994
995 static struct iscsi_r2t_info *iscsi_tcp_get_curr_r2t(struct iscsi_task *task)
996 {
997         struct iscsi_tcp_task *tcp_task = task->dd_data;
998         struct iscsi_r2t_info *r2t = NULL;
999
1000         if (iscsi_task_has_unsol_data(task))
1001                 r2t = &task->unsol_r2t;
1002         else {
1003                 spin_lock_bh(&tcp_task->queue2pool);
1004                 if (tcp_task->r2t) {
1005                         r2t = tcp_task->r2t;
1006                         /* Continue with this R2T? */
1007                         if (r2t->data_length <= r2t->sent) {
1008                                 ISCSI_DBG_TCP(task->conn,
1009                                               "  done with r2t %p\n", r2t);
1010                                 kfifo_in(&tcp_task->r2tpool.queue,
1011                                             (void *)&tcp_task->r2t,
1012                                             sizeof(void *));
1013                                 tcp_task->r2t = r2t = NULL;
1014                         }
1015                 }
1016
1017                 if (r2t == NULL) {
1018                         if (kfifo_out(&tcp_task->r2tqueue,
1019                             (void *)&tcp_task->r2t, sizeof(void *)) !=
1020                             sizeof(void *))
1021                                 r2t = NULL;
1022                         else
1023                                 r2t = tcp_task->r2t;
1024                 }
1025                 spin_unlock_bh(&tcp_task->queue2pool);
1026         }
1027
1028         return r2t;
1029 }
1030
1031 /**
1032  * iscsi_tcp_task_xmit - xmit normal PDU task
1033  * @task: iscsi command task
1034  *
1035  * We're expected to return 0 when everything was transmitted successfully,
1036  * -EAGAIN if there's still data in the queue, or != 0 for any other kind
1037  * of error.
1038  */
1039 int iscsi_tcp_task_xmit(struct iscsi_task *task)
1040 {
1041         struct iscsi_conn *conn = task->conn;
1042         struct iscsi_session *session = conn->session;
1043         struct iscsi_r2t_info *r2t;
1044         int rc = 0;
1045
1046 flush:
1047         /* Flush any pending data first. */
1048         rc = session->tt->xmit_pdu(task);
1049         if (rc < 0)
1050                 return rc;
1051
1052         /* mgmt command */
1053         if (!task->sc) {
1054                 if (task->hdr->itt == RESERVED_ITT)
1055                         iscsi_put_task(task);
1056                 return 0;
1057         }
1058
1059         /* Are we done already? */
1060         if (task->sc->sc_data_direction != DMA_TO_DEVICE)
1061                 return 0;
1062
1063         r2t = iscsi_tcp_get_curr_r2t(task);
1064         if (r2t == NULL) {
1065                 /* Waiting for more R2Ts to arrive. */
1066                 ISCSI_DBG_TCP(conn, "no R2Ts yet\n");
1067                 return 0;
1068         }
1069
1070         rc = conn->session->tt->alloc_pdu(task, ISCSI_OP_SCSI_DATA_OUT);
1071         if (rc)
1072                 return rc;
1073         iscsi_prep_data_out_pdu(task, r2t, (struct iscsi_data *) task->hdr);
1074
1075         ISCSI_DBG_TCP(conn, "sol dout %p [dsn %d itt 0x%x doff %d dlen %d]\n",
1076                       r2t, r2t->datasn - 1, task->hdr->itt,
1077                       r2t->data_offset + r2t->sent, r2t->data_count);
1078
1079         rc = conn->session->tt->init_pdu(task, r2t->data_offset + r2t->sent,
1080                                          r2t->data_count);
1081         if (rc) {
1082                 iscsi_conn_failure(conn, ISCSI_ERR_XMIT_FAILED);
1083                 return rc;
1084         }
1085
1086         r2t->sent += r2t->data_count;
1087         goto flush;
1088 }
1089 EXPORT_SYMBOL_GPL(iscsi_tcp_task_xmit);
1090
1091 struct iscsi_cls_conn *
1092 iscsi_tcp_conn_setup(struct iscsi_cls_session *cls_session, int dd_data_size,
1093                       uint32_t conn_idx)
1094
1095 {
1096         struct iscsi_conn *conn;
1097         struct iscsi_cls_conn *cls_conn;
1098         struct iscsi_tcp_conn *tcp_conn;
1099
1100         cls_conn = iscsi_conn_setup(cls_session,
1101                                     sizeof(*tcp_conn) + dd_data_size, conn_idx);
1102         if (!cls_conn)
1103                 return NULL;
1104         conn = cls_conn->dd_data;
1105         /*
1106          * due to strange issues with iser these are not set
1107          * in iscsi_conn_setup
1108          */
1109         conn->max_recv_dlength = ISCSI_DEF_MAX_RECV_SEG_LEN;
1110
1111         tcp_conn = conn->dd_data;
1112         tcp_conn->iscsi_conn = conn;
1113         tcp_conn->dd_data = conn->dd_data + sizeof(*tcp_conn);
1114         return cls_conn;
1115 }
1116 EXPORT_SYMBOL_GPL(iscsi_tcp_conn_setup);
1117
1118 void iscsi_tcp_conn_teardown(struct iscsi_cls_conn *cls_conn)
1119 {
1120         iscsi_conn_teardown(cls_conn);
1121 }
1122 EXPORT_SYMBOL_GPL(iscsi_tcp_conn_teardown);
1123
1124 int iscsi_tcp_r2tpool_alloc(struct iscsi_session *session)
1125 {
1126         int i;
1127         int cmd_i;
1128
1129         /*
1130          * initialize per-task: R2T pool and xmit queue
1131          */
1132         for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) {
1133                 struct iscsi_task *task = session->cmds[cmd_i];
1134                 struct iscsi_tcp_task *tcp_task = task->dd_data;
1135
1136                 /*
1137                  * pre-allocated x2 as much r2ts to handle race when
1138                  * target acks DataOut faster than we data_xmit() queues
1139                  * could replenish r2tqueue.
1140                  */
1141
1142                 /* R2T pool */
1143                 if (iscsi_pool_init(&tcp_task->r2tpool,
1144                                     session->max_r2t * 2, NULL,
1145                                     sizeof(struct iscsi_r2t_info))) {
1146                         goto r2t_alloc_fail;
1147                 }
1148
1149                 /* R2T xmit queue */
1150                 if (kfifo_alloc(&tcp_task->r2tqueue,
1151                       session->max_r2t * 4 * sizeof(void*), GFP_KERNEL)) {
1152                         iscsi_pool_free(&tcp_task->r2tpool);
1153                         goto r2t_alloc_fail;
1154                 }
1155                 spin_lock_init(&tcp_task->pool2queue);
1156                 spin_lock_init(&tcp_task->queue2pool);
1157         }
1158
1159         return 0;
1160
1161 r2t_alloc_fail:
1162         for (i = 0; i < cmd_i; i++) {
1163                 struct iscsi_task *task = session->cmds[i];
1164                 struct iscsi_tcp_task *tcp_task = task->dd_data;
1165
1166                 kfifo_free(&tcp_task->r2tqueue);
1167                 iscsi_pool_free(&tcp_task->r2tpool);
1168         }
1169         return -ENOMEM;
1170 }
1171 EXPORT_SYMBOL_GPL(iscsi_tcp_r2tpool_alloc);
1172
1173 void iscsi_tcp_r2tpool_free(struct iscsi_session *session)
1174 {
1175         int i;
1176
1177         for (i = 0; i < session->cmds_max; i++) {
1178                 struct iscsi_task *task = session->cmds[i];
1179                 struct iscsi_tcp_task *tcp_task = task->dd_data;
1180
1181                 kfifo_free(&tcp_task->r2tqueue);
1182                 iscsi_pool_free(&tcp_task->r2tpool);
1183         }
1184 }
1185 EXPORT_SYMBOL_GPL(iscsi_tcp_r2tpool_free);
1186
1187 int iscsi_tcp_set_max_r2t(struct iscsi_conn *conn, char *buf)
1188 {
1189         struct iscsi_session *session = conn->session;
1190         unsigned short r2ts = 0;
1191
1192         sscanf(buf, "%hu", &r2ts);
1193         if (session->max_r2t == r2ts)
1194                 return 0;
1195
1196         if (!r2ts || !is_power_of_2(r2ts))
1197                 return -EINVAL;
1198
1199         session->max_r2t = r2ts;
1200         iscsi_tcp_r2tpool_free(session);
1201         return iscsi_tcp_r2tpool_alloc(session);
1202 }
1203 EXPORT_SYMBOL_GPL(iscsi_tcp_set_max_r2t);
1204
1205 void iscsi_tcp_conn_get_stats(struct iscsi_cls_conn *cls_conn,
1206                               struct iscsi_stats *stats)
1207 {
1208         struct iscsi_conn *conn = cls_conn->dd_data;
1209
1210         stats->txdata_octets = conn->txdata_octets;
1211         stats->rxdata_octets = conn->rxdata_octets;
1212         stats->scsicmd_pdus = conn->scsicmd_pdus_cnt;
1213         stats->dataout_pdus = conn->dataout_pdus_cnt;
1214         stats->scsirsp_pdus = conn->scsirsp_pdus_cnt;
1215         stats->datain_pdus = conn->datain_pdus_cnt;
1216         stats->r2t_pdus = conn->r2t_pdus_cnt;
1217         stats->tmfcmd_pdus = conn->tmfcmd_pdus_cnt;
1218         stats->tmfrsp_pdus = conn->tmfrsp_pdus_cnt;
1219 }
1220 EXPORT_SYMBOL_GPL(iscsi_tcp_conn_get_stats);