source: src/linux/universal/linux-3.18/drivers/target/iscsi/iscsi_target_util.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 2 months ago

update

File size: 38.1 KB
Line 
1/*******************************************************************************
2 * This file contains the iSCSI Target specific utility functions.
3 *
4 * (c) Copyright 2007-2013 Datera, Inc.
5 *
6 * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program 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 the
16 * GNU General Public License for more details.
17 ******************************************************************************/
18
19#include <linux/list.h>
20#include <linux/percpu_ida.h>
21#include <scsi/scsi_tcq.h>
22#include <scsi/iscsi_proto.h>
23#include <target/target_core_base.h>
24#include <target/target_core_fabric.h>
25#include <target/target_core_configfs.h>
26#include <target/iscsi/iscsi_transport.h>
27
28#include "iscsi_target_core.h"
29#include "iscsi_target_parameters.h"
30#include "iscsi_target_seq_pdu_list.h"
31#include "iscsi_target_datain_values.h"
32#include "iscsi_target_erl0.h"
33#include "iscsi_target_erl1.h"
34#include "iscsi_target_erl2.h"
35#include "iscsi_target_tpg.h"
36#include "iscsi_target_tq.h"
37#include "iscsi_target_util.h"
38#include "iscsi_target.h"
39
40#define PRINT_BUFF(buff, len)                                   \
41{                                                               \
42        int zzz;                                                \
43                                                                \
44        pr_debug("%d:\n", __LINE__);                            \
45        for (zzz = 0; zzz < len; zzz++) {                       \
46                if (zzz % 16 == 0) {                            \
47                        if (zzz)                                \
48                                pr_debug("\n");                 \
49                        pr_debug("%4i: ", zzz);                 \
50                }                                               \
51                pr_debug("%02x ", (unsigned char) (buff)[zzz]); \
52        }                                                       \
53        if ((len + 1) % 16)                                     \
54                pr_debug("\n");                                 \
55}
56
57extern struct list_head g_tiqn_list;
58extern spinlock_t tiqn_lock;
59
60/*
61 *      Called with cmd->r2t_lock held.
62 */
63int iscsit_add_r2t_to_list(
64        struct iscsi_cmd *cmd,
65        u32 offset,
66        u32 xfer_len,
67        int recovery,
68        u32 r2t_sn)
69{
70        struct iscsi_r2t *r2t;
71
72        r2t = kmem_cache_zalloc(lio_r2t_cache, GFP_ATOMIC);
73        if (!r2t) {
74                pr_err("Unable to allocate memory for struct iscsi_r2t.\n");
75                return -1;
76        }
77        INIT_LIST_HEAD(&r2t->r2t_list);
78
79        r2t->recovery_r2t = recovery;
80        r2t->r2t_sn = (!r2t_sn) ? cmd->r2t_sn++ : r2t_sn;
81        r2t->offset = offset;
82        r2t->xfer_len = xfer_len;
83        list_add_tail(&r2t->r2t_list, &cmd->cmd_r2t_list);
84        spin_unlock_bh(&cmd->r2t_lock);
85
86        iscsit_add_cmd_to_immediate_queue(cmd, cmd->conn, ISTATE_SEND_R2T);
87
88        spin_lock_bh(&cmd->r2t_lock);
89        return 0;
90}
91
92struct iscsi_r2t *iscsit_get_r2t_for_eos(
93        struct iscsi_cmd *cmd,
94        u32 offset,
95        u32 length)
96{
97        struct iscsi_r2t *r2t;
98
99        spin_lock_bh(&cmd->r2t_lock);
100        list_for_each_entry(r2t, &cmd->cmd_r2t_list, r2t_list) {
101                if ((r2t->offset <= offset) &&
102                    (r2t->offset + r2t->xfer_len) >= (offset + length)) {
103                        spin_unlock_bh(&cmd->r2t_lock);
104                        return r2t;
105                }
106        }
107        spin_unlock_bh(&cmd->r2t_lock);
108
109        pr_err("Unable to locate R2T for Offset: %u, Length:"
110                        " %u\n", offset, length);
111        return NULL;
112}
113
114struct iscsi_r2t *iscsit_get_r2t_from_list(struct iscsi_cmd *cmd)
115{
116        struct iscsi_r2t *r2t;
117
118        spin_lock_bh(&cmd->r2t_lock);
119        list_for_each_entry(r2t, &cmd->cmd_r2t_list, r2t_list) {
120                if (!r2t->sent_r2t) {
121                        spin_unlock_bh(&cmd->r2t_lock);
122                        return r2t;
123                }
124        }
125        spin_unlock_bh(&cmd->r2t_lock);
126
127        pr_err("Unable to locate next R2T to send for ITT:"
128                        " 0x%08x.\n", cmd->init_task_tag);
129        return NULL;
130}
131
132/*
133 *      Called with cmd->r2t_lock held.
134 */
135void iscsit_free_r2t(struct iscsi_r2t *r2t, struct iscsi_cmd *cmd)
136{
137        list_del(&r2t->r2t_list);
138        kmem_cache_free(lio_r2t_cache, r2t);
139}
140
141void iscsit_free_r2ts_from_list(struct iscsi_cmd *cmd)
142{
143        struct iscsi_r2t *r2t, *r2t_tmp;
144
145        spin_lock_bh(&cmd->r2t_lock);
146        list_for_each_entry_safe(r2t, r2t_tmp, &cmd->cmd_r2t_list, r2t_list)
147                iscsit_free_r2t(r2t, cmd);
148        spin_unlock_bh(&cmd->r2t_lock);
149}
150
151/*
152 * May be called from software interrupt (timer) context for allocating
153 * iSCSI NopINs.
154 */
155struct iscsi_cmd *iscsit_allocate_cmd(struct iscsi_conn *conn, int state)
156{
157        struct iscsi_cmd *cmd;
158        struct se_session *se_sess = conn->sess->se_sess;
159        int size, tag;
160
161        tag = percpu_ida_alloc(&se_sess->sess_tag_pool, state);
162        if (tag < 0)
163                return NULL;
164
165        size = sizeof(struct iscsi_cmd) + conn->conn_transport->priv_size;
166        cmd = (struct iscsi_cmd *)(se_sess->sess_cmd_map + (tag * size));
167        memset(cmd, 0, size);
168
169        cmd->se_cmd.map_tag = tag;
170        cmd->conn = conn;
171        INIT_LIST_HEAD(&cmd->i_conn_node);
172        INIT_LIST_HEAD(&cmd->datain_list);
173        INIT_LIST_HEAD(&cmd->cmd_r2t_list);
174        spin_lock_init(&cmd->datain_lock);
175        spin_lock_init(&cmd->dataout_timeout_lock);
176        spin_lock_init(&cmd->istate_lock);
177        spin_lock_init(&cmd->error_lock);
178        spin_lock_init(&cmd->r2t_lock);
179
180        return cmd;
181}
182EXPORT_SYMBOL(iscsit_allocate_cmd);
183
184struct iscsi_seq *iscsit_get_seq_holder_for_datain(
185        struct iscsi_cmd *cmd,
186        u32 seq_send_order)
187{
188        u32 i;
189
190        for (i = 0; i < cmd->seq_count; i++)
191                if (cmd->seq_list[i].seq_send_order == seq_send_order)
192                        return &cmd->seq_list[i];
193
194        return NULL;
195}
196
197struct iscsi_seq *iscsit_get_seq_holder_for_r2t(struct iscsi_cmd *cmd)
198{
199        u32 i;
200
201        if (!cmd->seq_list) {
202                pr_err("struct iscsi_cmd->seq_list is NULL!\n");
203                return NULL;
204        }
205
206        for (i = 0; i < cmd->seq_count; i++) {
207                if (cmd->seq_list[i].type != SEQTYPE_NORMAL)
208                        continue;
209                if (cmd->seq_list[i].seq_send_order == cmd->seq_send_order) {
210                        cmd->seq_send_order++;
211                        return &cmd->seq_list[i];
212                }
213        }
214
215        return NULL;
216}
217
218struct iscsi_r2t *iscsit_get_holder_for_r2tsn(
219        struct iscsi_cmd *cmd,
220        u32 r2t_sn)
221{
222        struct iscsi_r2t *r2t;
223
224        spin_lock_bh(&cmd->r2t_lock);
225        list_for_each_entry(r2t, &cmd->cmd_r2t_list, r2t_list) {
226                if (r2t->r2t_sn == r2t_sn) {
227                        spin_unlock_bh(&cmd->r2t_lock);
228                        return r2t;
229                }
230        }
231        spin_unlock_bh(&cmd->r2t_lock);
232
233        return NULL;
234}
235
236static inline int iscsit_check_received_cmdsn(struct iscsi_session *sess, u32 cmdsn)
237{
238        int ret;
239
240        /*
241         * This is the proper method of checking received CmdSN against
242         * ExpCmdSN and MaxCmdSN values, as well as accounting for out
243         * or order CmdSNs due to multiple connection sessions and/or
244         * CRC failures.
245         */
246        if (iscsi_sna_gt(cmdsn, sess->max_cmd_sn)) {
247                pr_err("Received CmdSN: 0x%08x is greater than"
248                       " MaxCmdSN: 0x%08x, ignoring.\n", cmdsn,
249                       sess->max_cmd_sn);
250                ret = CMDSN_MAXCMDSN_OVERRUN;
251
252        } else if (cmdsn == sess->exp_cmd_sn) {
253                sess->exp_cmd_sn++;
254                pr_debug("Received CmdSN matches ExpCmdSN,"
255                      " incremented ExpCmdSN to: 0x%08x\n",
256                      sess->exp_cmd_sn);
257                ret = CMDSN_NORMAL_OPERATION;
258
259        } else if (iscsi_sna_gt(cmdsn, sess->exp_cmd_sn)) {
260                pr_debug("Received CmdSN: 0x%08x is greater"
261                      " than ExpCmdSN: 0x%08x, not acknowledging.\n",
262                      cmdsn, sess->exp_cmd_sn);
263                ret = CMDSN_HIGHER_THAN_EXP;
264
265        } else {
266                pr_err("Received CmdSN: 0x%08x is less than"
267                       " ExpCmdSN: 0x%08x, ignoring.\n", cmdsn,
268                       sess->exp_cmd_sn);
269                ret = CMDSN_LOWER_THAN_EXP;
270        }
271
272        return ret;
273}
274
275/*
276 * Commands may be received out of order if MC/S is in use.
277 * Ensure they are executed in CmdSN order.
278 */
279int iscsit_sequence_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
280                        unsigned char *buf, __be32 cmdsn)
281{
282        int ret, cmdsn_ret;
283        bool reject = false;
284        u8 reason = ISCSI_REASON_BOOKMARK_NO_RESOURCES;
285
286        mutex_lock(&conn->sess->cmdsn_mutex);
287
288        cmdsn_ret = iscsit_check_received_cmdsn(conn->sess, be32_to_cpu(cmdsn));
289        switch (cmdsn_ret) {
290        case CMDSN_NORMAL_OPERATION:
291                ret = iscsit_execute_cmd(cmd, 0);
292                if ((ret >= 0) && !list_empty(&conn->sess->sess_ooo_cmdsn_list))
293                        iscsit_execute_ooo_cmdsns(conn->sess);
294                else if (ret < 0) {
295                        reject = true;
296                        ret = CMDSN_ERROR_CANNOT_RECOVER;
297                }
298                break;
299        case CMDSN_HIGHER_THAN_EXP:
300                ret = iscsit_handle_ooo_cmdsn(conn->sess, cmd, be32_to_cpu(cmdsn));
301                if (ret < 0) {
302                        reject = true;
303                        ret = CMDSN_ERROR_CANNOT_RECOVER;
304                        break;
305                }
306                ret = CMDSN_HIGHER_THAN_EXP;
307                break;
308        case CMDSN_LOWER_THAN_EXP:
309        case CMDSN_MAXCMDSN_OVERRUN:
310        default:
311                cmd->i_state = ISTATE_REMOVE;
312                iscsit_add_cmd_to_immediate_queue(cmd, conn, cmd->i_state);
313                /*
314                 * Existing callers for iscsit_sequence_cmd() will silently
315                 * ignore commands with CMDSN_LOWER_THAN_EXP, so force this
316                 * return for CMDSN_MAXCMDSN_OVERRUN as well..
317                 */
318                ret = CMDSN_LOWER_THAN_EXP;
319                break;
320        }
321        mutex_unlock(&conn->sess->cmdsn_mutex);
322
323        if (reject)
324                iscsit_reject_cmd(cmd, reason, buf);
325
326        return ret;
327}
328EXPORT_SYMBOL(iscsit_sequence_cmd);
329
330int iscsit_check_unsolicited_dataout(struct iscsi_cmd *cmd, unsigned char *buf)
331{
332        struct iscsi_conn *conn = cmd->conn;
333        struct se_cmd *se_cmd = &cmd->se_cmd;
334        struct iscsi_data *hdr = (struct iscsi_data *) buf;
335        u32 payload_length = ntoh24(hdr->dlength);
336
337        if (conn->sess->sess_ops->InitialR2T) {
338                pr_err("Received unexpected unsolicited data"
339                        " while InitialR2T=Yes, protocol error.\n");
340                transport_send_check_condition_and_sense(se_cmd,
341                                TCM_UNEXPECTED_UNSOLICITED_DATA, 0);
342                return -1;
343        }
344
345        if ((cmd->first_burst_len + payload_length) >
346             conn->sess->sess_ops->FirstBurstLength) {
347                pr_err("Total %u bytes exceeds FirstBurstLength: %u"
348                        " for this Unsolicited DataOut Burst.\n",
349                        (cmd->first_burst_len + payload_length),
350                                conn->sess->sess_ops->FirstBurstLength);
351                transport_send_check_condition_and_sense(se_cmd,
352                                TCM_INCORRECT_AMOUNT_OF_DATA, 0);
353                return -1;
354        }
355
356        if (!(hdr->flags & ISCSI_FLAG_CMD_FINAL))
357                return 0;
358
359        if (((cmd->first_burst_len + payload_length) != cmd->se_cmd.data_length) &&
360            ((cmd->first_burst_len + payload_length) !=
361              conn->sess->sess_ops->FirstBurstLength)) {
362                pr_err("Unsolicited non-immediate data received %u"
363                        " does not equal FirstBurstLength: %u, and does"
364                        " not equal ExpXferLen %u.\n",
365                        (cmd->first_burst_len + payload_length),
366                        conn->sess->sess_ops->FirstBurstLength, cmd->se_cmd.data_length);
367                transport_send_check_condition_and_sense(se_cmd,
368                                TCM_INCORRECT_AMOUNT_OF_DATA, 0);
369                return -1;
370        }
371        return 0;
372}
373
374struct iscsi_cmd *iscsit_find_cmd_from_itt(
375        struct iscsi_conn *conn,
376        itt_t init_task_tag)
377{
378        struct iscsi_cmd *cmd;
379
380        spin_lock_bh(&conn->cmd_lock);
381        list_for_each_entry(cmd, &conn->conn_cmd_list, i_conn_node) {
382                if (cmd->init_task_tag == init_task_tag) {
383                        spin_unlock_bh(&conn->cmd_lock);
384                        return cmd;
385                }
386        }
387        spin_unlock_bh(&conn->cmd_lock);
388
389        pr_err("Unable to locate ITT: 0x%08x on CID: %hu",
390                        init_task_tag, conn->cid);
391        return NULL;
392}
393
394struct iscsi_cmd *iscsit_find_cmd_from_itt_or_dump(
395        struct iscsi_conn *conn,
396        itt_t init_task_tag,
397        u32 length)
398{
399        struct iscsi_cmd *cmd;
400
401        spin_lock_bh(&conn->cmd_lock);
402        list_for_each_entry(cmd, &conn->conn_cmd_list, i_conn_node) {
403                if (cmd->cmd_flags & ICF_GOT_LAST_DATAOUT)
404                        continue;
405                if (cmd->init_task_tag == init_task_tag) {
406                        spin_unlock_bh(&conn->cmd_lock);
407                        return cmd;
408                }
409        }
410        spin_unlock_bh(&conn->cmd_lock);
411
412        pr_err("Unable to locate ITT: 0x%08x on CID: %hu,"
413                        " dumping payload\n", init_task_tag, conn->cid);
414        if (length)
415                iscsit_dump_data_payload(conn, length, 1);
416
417        return NULL;
418}
419
420struct iscsi_cmd *iscsit_find_cmd_from_ttt(
421        struct iscsi_conn *conn,
422        u32 targ_xfer_tag)
423{
424        struct iscsi_cmd *cmd = NULL;
425
426        spin_lock_bh(&conn->cmd_lock);
427        list_for_each_entry(cmd, &conn->conn_cmd_list, i_conn_node) {
428                if (cmd->targ_xfer_tag == targ_xfer_tag) {
429                        spin_unlock_bh(&conn->cmd_lock);
430                        return cmd;
431                }
432        }
433        spin_unlock_bh(&conn->cmd_lock);
434
435        pr_err("Unable to locate TTT: 0x%08x on CID: %hu\n",
436                        targ_xfer_tag, conn->cid);
437        return NULL;
438}
439
440int iscsit_find_cmd_for_recovery(
441        struct iscsi_session *sess,
442        struct iscsi_cmd **cmd_ptr,
443        struct iscsi_conn_recovery **cr_ptr,
444        itt_t init_task_tag)
445{
446        struct iscsi_cmd *cmd = NULL;
447        struct iscsi_conn_recovery *cr;
448        /*
449         * Scan through the inactive connection recovery list's command list.
450         * If init_task_tag matches the command is still alligent.
451         */
452        spin_lock(&sess->cr_i_lock);
453        list_for_each_entry(cr, &sess->cr_inactive_list, cr_list) {
454                spin_lock(&cr->conn_recovery_cmd_lock);
455                list_for_each_entry(cmd, &cr->conn_recovery_cmd_list, i_conn_node) {
456                        if (cmd->init_task_tag == init_task_tag) {
457                                spin_unlock(&cr->conn_recovery_cmd_lock);
458                                spin_unlock(&sess->cr_i_lock);
459
460                                *cr_ptr = cr;
461                                *cmd_ptr = cmd;
462                                return -2;
463                        }
464                }
465                spin_unlock(&cr->conn_recovery_cmd_lock);
466        }
467        spin_unlock(&sess->cr_i_lock);
468        /*
469         * Scan through the active connection recovery list's command list.
470         * If init_task_tag matches the command is ready to be reassigned.
471         */
472        spin_lock(&sess->cr_a_lock);
473        list_for_each_entry(cr, &sess->cr_active_list, cr_list) {
474                spin_lock(&cr->conn_recovery_cmd_lock);
475                list_for_each_entry(cmd, &cr->conn_recovery_cmd_list, i_conn_node) {
476                        if (cmd->init_task_tag == init_task_tag) {
477                                spin_unlock(&cr->conn_recovery_cmd_lock);
478                                spin_unlock(&sess->cr_a_lock);
479
480                                *cr_ptr = cr;
481                                *cmd_ptr = cmd;
482                                return 0;
483                        }
484                }
485                spin_unlock(&cr->conn_recovery_cmd_lock);
486        }
487        spin_unlock(&sess->cr_a_lock);
488
489        return -1;
490}
491
492void iscsit_add_cmd_to_immediate_queue(
493        struct iscsi_cmd *cmd,
494        struct iscsi_conn *conn,
495        u8 state)
496{
497        struct iscsi_queue_req *qr;
498
499        qr = kmem_cache_zalloc(lio_qr_cache, GFP_ATOMIC);
500        if (!qr) {
501                pr_err("Unable to allocate memory for"
502                                " struct iscsi_queue_req\n");
503                return;
504        }
505        INIT_LIST_HEAD(&qr->qr_list);
506        qr->cmd = cmd;
507        qr->state = state;
508
509        spin_lock_bh(&conn->immed_queue_lock);
510        list_add_tail(&qr->qr_list, &conn->immed_queue_list);
511        atomic_inc(&cmd->immed_queue_count);
512        atomic_set(&conn->check_immediate_queue, 1);
513        spin_unlock_bh(&conn->immed_queue_lock);
514
515        wake_up(&conn->queues_wq);
516}
517
518struct iscsi_queue_req *iscsit_get_cmd_from_immediate_queue(struct iscsi_conn *conn)
519{
520        struct iscsi_queue_req *qr;
521
522        spin_lock_bh(&conn->immed_queue_lock);
523        if (list_empty(&conn->immed_queue_list)) {
524                spin_unlock_bh(&conn->immed_queue_lock);
525                return NULL;
526        }
527        qr = list_first_entry(&conn->immed_queue_list,
528                              struct iscsi_queue_req, qr_list);
529
530        list_del(&qr->qr_list);
531        if (qr->cmd)
532                atomic_dec(&qr->cmd->immed_queue_count);
533        spin_unlock_bh(&conn->immed_queue_lock);
534
535        return qr;
536}
537
538static void iscsit_remove_cmd_from_immediate_queue(
539        struct iscsi_cmd *cmd,
540        struct iscsi_conn *conn)
541{
542        struct iscsi_queue_req *qr, *qr_tmp;
543
544        spin_lock_bh(&conn->immed_queue_lock);
545        if (!atomic_read(&cmd->immed_queue_count)) {
546                spin_unlock_bh(&conn->immed_queue_lock);
547                return;
548        }
549
550        list_for_each_entry_safe(qr, qr_tmp, &conn->immed_queue_list, qr_list) {
551                if (qr->cmd != cmd)
552                        continue;
553
554                atomic_dec(&qr->cmd->immed_queue_count);
555                list_del(&qr->qr_list);
556                kmem_cache_free(lio_qr_cache, qr);
557        }
558        spin_unlock_bh(&conn->immed_queue_lock);
559
560        if (atomic_read(&cmd->immed_queue_count)) {
561                pr_err("ITT: 0x%08x immed_queue_count: %d\n",
562                        cmd->init_task_tag,
563                        atomic_read(&cmd->immed_queue_count));
564        }
565}
566
567void iscsit_add_cmd_to_response_queue(
568        struct iscsi_cmd *cmd,
569        struct iscsi_conn *conn,
570        u8 state)
571{
572        struct iscsi_queue_req *qr;
573
574        qr = kmem_cache_zalloc(lio_qr_cache, GFP_ATOMIC);
575        if (!qr) {
576                pr_err("Unable to allocate memory for"
577                        " struct iscsi_queue_req\n");
578                return;
579        }
580        INIT_LIST_HEAD(&qr->qr_list);
581        qr->cmd = cmd;
582        qr->state = state;
583
584        spin_lock_bh(&conn->response_queue_lock);
585        list_add_tail(&qr->qr_list, &conn->response_queue_list);
586        atomic_inc(&cmd->response_queue_count);
587        spin_unlock_bh(&conn->response_queue_lock);
588
589        wake_up(&conn->queues_wq);
590}
591
592struct iscsi_queue_req *iscsit_get_cmd_from_response_queue(struct iscsi_conn *conn)
593{
594        struct iscsi_queue_req *qr;
595
596        spin_lock_bh(&conn->response_queue_lock);
597        if (list_empty(&conn->response_queue_list)) {
598                spin_unlock_bh(&conn->response_queue_lock);
599                return NULL;
600        }
601
602        qr = list_first_entry(&conn->response_queue_list,
603                              struct iscsi_queue_req, qr_list);
604
605        list_del(&qr->qr_list);
606        if (qr->cmd)
607                atomic_dec(&qr->cmd->response_queue_count);
608        spin_unlock_bh(&conn->response_queue_lock);
609
610        return qr;
611}
612
613static void iscsit_remove_cmd_from_response_queue(
614        struct iscsi_cmd *cmd,
615        struct iscsi_conn *conn)
616{
617        struct iscsi_queue_req *qr, *qr_tmp;
618
619        spin_lock_bh(&conn->response_queue_lock);
620        if (!atomic_read(&cmd->response_queue_count)) {
621                spin_unlock_bh(&conn->response_queue_lock);
622                return;
623        }
624
625        list_for_each_entry_safe(qr, qr_tmp, &conn->response_queue_list,
626                                qr_list) {
627                if (qr->cmd != cmd)
628                        continue;
629
630                atomic_dec(&qr->cmd->response_queue_count);
631                list_del(&qr->qr_list);
632                kmem_cache_free(lio_qr_cache, qr);
633        }
634        spin_unlock_bh(&conn->response_queue_lock);
635
636        if (atomic_read(&cmd->response_queue_count)) {
637                pr_err("ITT: 0x%08x response_queue_count: %d\n",
638                        cmd->init_task_tag,
639                        atomic_read(&cmd->response_queue_count));
640        }
641}
642
643bool iscsit_conn_all_queues_empty(struct iscsi_conn *conn)
644{
645        bool empty;
646
647        spin_lock_bh(&conn->immed_queue_lock);
648        empty = list_empty(&conn->immed_queue_list);
649        spin_unlock_bh(&conn->immed_queue_lock);
650
651        if (!empty)
652                return empty;
653
654        spin_lock_bh(&conn->response_queue_lock);
655        empty = list_empty(&conn->response_queue_list);
656        spin_unlock_bh(&conn->response_queue_lock);
657
658        return empty;
659}
660
661void iscsit_free_queue_reqs_for_conn(struct iscsi_conn *conn)
662{
663        struct iscsi_queue_req *qr, *qr_tmp;
664
665        spin_lock_bh(&conn->immed_queue_lock);
666        list_for_each_entry_safe(qr, qr_tmp, &conn->immed_queue_list, qr_list) {
667                list_del(&qr->qr_list);
668                if (qr->cmd)
669                        atomic_dec(&qr->cmd->immed_queue_count);
670
671                kmem_cache_free(lio_qr_cache, qr);
672        }
673        spin_unlock_bh(&conn->immed_queue_lock);
674
675        spin_lock_bh(&conn->response_queue_lock);
676        list_for_each_entry_safe(qr, qr_tmp, &conn->response_queue_list,
677                        qr_list) {
678                list_del(&qr->qr_list);
679                if (qr->cmd)
680                        atomic_dec(&qr->cmd->response_queue_count);
681
682                kmem_cache_free(lio_qr_cache, qr);
683        }
684        spin_unlock_bh(&conn->response_queue_lock);
685}
686
687void iscsit_release_cmd(struct iscsi_cmd *cmd)
688{
689        struct iscsi_session *sess;
690        struct se_cmd *se_cmd = &cmd->se_cmd;
691
692        if (cmd->conn)
693                sess = cmd->conn->sess;
694        else
695                sess = cmd->sess;
696
697        BUG_ON(!sess || !sess->se_sess);
698
699        kfree(cmd->buf_ptr);
700        kfree(cmd->pdu_list);
701        kfree(cmd->seq_list);
702        kfree(cmd->tmr_req);
703        kfree(cmd->iov_data);
704        kfree(cmd->text_in_ptr);
705
706        percpu_ida_free(&sess->se_sess->sess_tag_pool, se_cmd->map_tag);
707}
708EXPORT_SYMBOL(iscsit_release_cmd);
709
710void __iscsit_free_cmd(struct iscsi_cmd *cmd, bool scsi_cmd,
711                       bool check_queues)
712{
713        struct iscsi_conn *conn = cmd->conn;
714
715        if (scsi_cmd) {
716                if (cmd->data_direction == DMA_TO_DEVICE) {
717                        iscsit_stop_dataout_timer(cmd);
718                        iscsit_free_r2ts_from_list(cmd);
719                }
720                if (cmd->data_direction == DMA_FROM_DEVICE)
721                        iscsit_free_all_datain_reqs(cmd);
722        }
723
724        if (conn && check_queues) {
725                iscsit_remove_cmd_from_immediate_queue(cmd, conn);
726                iscsit_remove_cmd_from_response_queue(cmd, conn);
727        }
728}
729
730void iscsit_free_cmd(struct iscsi_cmd *cmd, bool shutdown)
731{
732        struct se_cmd *se_cmd = NULL;
733        int rc;
734        bool op_scsi = false;
735        /*
736         * Determine if a struct se_cmd is associated with
737         * this struct iscsi_cmd.
738         */
739        switch (cmd->iscsi_opcode) {
740        case ISCSI_OP_SCSI_CMD:
741                op_scsi = true;
742                /*
743                 * Fallthrough
744                 */
745        case ISCSI_OP_SCSI_TMFUNC:
746                se_cmd = &cmd->se_cmd;
747                __iscsit_free_cmd(cmd, op_scsi, shutdown);
748                rc = transport_generic_free_cmd(se_cmd, shutdown);
749                if (!rc && shutdown && se_cmd->se_sess) {
750                        __iscsit_free_cmd(cmd, op_scsi, shutdown);
751                        target_put_sess_cmd(se_cmd);
752                }
753                break;
754        case ISCSI_OP_REJECT:
755                /*
756                 * Handle special case for REJECT when iscsi_add_reject*() has
757                 * overwritten the original iscsi_opcode assignment, and the
758                 * associated cmd->se_cmd needs to be released.
759                 */
760                if (cmd->se_cmd.se_tfo != NULL) {
761                        se_cmd = &cmd->se_cmd;
762                        __iscsit_free_cmd(cmd, true, shutdown);
763
764                        rc = transport_generic_free_cmd(&cmd->se_cmd, shutdown);
765                        if (!rc && shutdown && se_cmd->se_sess) {
766                                __iscsit_free_cmd(cmd, true, shutdown);
767                                target_put_sess_cmd(se_cmd);
768                        }
769                        break;
770                }
771                /* Fall-through */
772        default:
773                __iscsit_free_cmd(cmd, false, shutdown);
774                iscsit_release_cmd(cmd);
775                break;
776        }
777}
778
779int iscsit_check_session_usage_count(struct iscsi_session *sess)
780{
781        spin_lock_bh(&sess->session_usage_lock);
782        if (sess->session_usage_count != 0) {
783                sess->session_waiting_on_uc = 1;
784                spin_unlock_bh(&sess->session_usage_lock);
785                if (in_interrupt())
786                        return 2;
787
788                wait_for_completion(&sess->session_waiting_on_uc_comp);
789                return 1;
790        }
791        spin_unlock_bh(&sess->session_usage_lock);
792
793        return 0;
794}
795
796void iscsit_dec_session_usage_count(struct iscsi_session *sess)
797{
798        spin_lock_bh(&sess->session_usage_lock);
799        sess->session_usage_count--;
800
801        if (!sess->session_usage_count && sess->session_waiting_on_uc)
802                complete(&sess->session_waiting_on_uc_comp);
803
804        spin_unlock_bh(&sess->session_usage_lock);
805}
806
807void iscsit_inc_session_usage_count(struct iscsi_session *sess)
808{
809        spin_lock_bh(&sess->session_usage_lock);
810        sess->session_usage_count++;
811        spin_unlock_bh(&sess->session_usage_lock);
812}
813
814/*
815 *      Setup conn->if_marker and conn->of_marker values based upon
816 *      the initial marker-less interval. (see iSCSI v19 A.2)
817 */
818int iscsit_set_sync_and_steering_values(struct iscsi_conn *conn)
819{
820        int login_ifmarker_count = 0, login_ofmarker_count = 0, next_marker = 0;
821        /*
822         * IFMarkInt and OFMarkInt are negotiated as 32-bit words.
823         */
824        u32 IFMarkInt = (conn->conn_ops->IFMarkInt * 4);
825        u32 OFMarkInt = (conn->conn_ops->OFMarkInt * 4);
826
827        if (conn->conn_ops->OFMarker) {
828                /*
829                 * Account for the first Login Command received not
830                 * via iscsi_recv_msg().
831                 */
832                conn->of_marker += ISCSI_HDR_LEN;
833                if (conn->of_marker <= OFMarkInt) {
834                        conn->of_marker = (OFMarkInt - conn->of_marker);
835                } else {
836                        login_ofmarker_count = (conn->of_marker / OFMarkInt);
837                        next_marker = (OFMarkInt * (login_ofmarker_count + 1)) +
838                                        (login_ofmarker_count * MARKER_SIZE);
839                        conn->of_marker = (next_marker - conn->of_marker);
840                }
841                conn->of_marker_offset = 0;
842                pr_debug("Setting OFMarker value to %u based on Initial"
843                        " Markerless Interval.\n", conn->of_marker);
844        }
845
846        if (conn->conn_ops->IFMarker) {
847                if (conn->if_marker <= IFMarkInt) {
848                        conn->if_marker = (IFMarkInt - conn->if_marker);
849                } else {
850                        login_ifmarker_count = (conn->if_marker / IFMarkInt);
851                        next_marker = (IFMarkInt * (login_ifmarker_count + 1)) +
852                                        (login_ifmarker_count * MARKER_SIZE);
853                        conn->if_marker = (next_marker - conn->if_marker);
854                }
855                pr_debug("Setting IFMarker value to %u based on Initial"
856                        " Markerless Interval.\n", conn->if_marker);
857        }
858
859        return 0;
860}
861
862struct iscsi_conn *iscsit_get_conn_from_cid(struct iscsi_session *sess, u16 cid)
863{
864        struct iscsi_conn *conn;
865
866        spin_lock_bh(&sess->conn_lock);
867        list_for_each_entry(conn, &sess->sess_conn_list, conn_list) {
868                if ((conn->cid == cid) &&
869                    (conn->conn_state == TARG_CONN_STATE_LOGGED_IN)) {
870                        iscsit_inc_conn_usage_count(conn);
871                        spin_unlock_bh(&sess->conn_lock);
872                        return conn;
873                }
874        }
875        spin_unlock_bh(&sess->conn_lock);
876
877        return NULL;
878}
879
880struct iscsi_conn *iscsit_get_conn_from_cid_rcfr(struct iscsi_session *sess, u16 cid)
881{
882        struct iscsi_conn *conn;
883
884        spin_lock_bh(&sess->conn_lock);
885        list_for_each_entry(conn, &sess->sess_conn_list, conn_list) {
886                if (conn->cid == cid) {
887                        iscsit_inc_conn_usage_count(conn);
888                        spin_lock(&conn->state_lock);
889                        atomic_set(&conn->connection_wait_rcfr, 1);
890                        spin_unlock(&conn->state_lock);
891                        spin_unlock_bh(&sess->conn_lock);
892                        return conn;
893                }
894        }
895        spin_unlock_bh(&sess->conn_lock);
896
897        return NULL;
898}
899
900void iscsit_check_conn_usage_count(struct iscsi_conn *conn)
901{
902        spin_lock_bh(&conn->conn_usage_lock);
903        if (conn->conn_usage_count != 0) {
904                conn->conn_waiting_on_uc = 1;
905                spin_unlock_bh(&conn->conn_usage_lock);
906
907                wait_for_completion(&conn->conn_waiting_on_uc_comp);
908                return;
909        }
910        spin_unlock_bh(&conn->conn_usage_lock);
911}
912
913void iscsit_dec_conn_usage_count(struct iscsi_conn *conn)
914{
915        spin_lock_bh(&conn->conn_usage_lock);
916        conn->conn_usage_count--;
917
918        if (!conn->conn_usage_count && conn->conn_waiting_on_uc)
919                complete(&conn->conn_waiting_on_uc_comp);
920
921        spin_unlock_bh(&conn->conn_usage_lock);
922}
923
924void iscsit_inc_conn_usage_count(struct iscsi_conn *conn)
925{
926        spin_lock_bh(&conn->conn_usage_lock);
927        conn->conn_usage_count++;
928        spin_unlock_bh(&conn->conn_usage_lock);
929}
930
931static int iscsit_add_nopin(struct iscsi_conn *conn, int want_response)
932{
933        u8 state;
934        struct iscsi_cmd *cmd;
935
936        cmd = iscsit_allocate_cmd(conn, TASK_RUNNING);
937        if (!cmd)
938                return -1;
939
940        cmd->iscsi_opcode = ISCSI_OP_NOOP_IN;
941        state = (want_response) ? ISTATE_SEND_NOPIN_WANT_RESPONSE :
942                                ISTATE_SEND_NOPIN_NO_RESPONSE;
943        cmd->init_task_tag = RESERVED_ITT;
944        spin_lock_bh(&conn->sess->ttt_lock);
945        cmd->targ_xfer_tag = (want_response) ? conn->sess->targ_xfer_tag++ :
946                        0xFFFFFFFF;
947        if (want_response && (cmd->targ_xfer_tag == 0xFFFFFFFF))
948                cmd->targ_xfer_tag = conn->sess->targ_xfer_tag++;
949        spin_unlock_bh(&conn->sess->ttt_lock);
950
951        spin_lock_bh(&conn->cmd_lock);
952        list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
953        spin_unlock_bh(&conn->cmd_lock);
954
955        if (want_response)
956                iscsit_start_nopin_response_timer(conn);
957        iscsit_add_cmd_to_immediate_queue(cmd, conn, state);
958
959        return 0;
960}
961
962static void iscsit_handle_nopin_response_timeout(unsigned long data)
963{
964        struct iscsi_conn *conn = (struct iscsi_conn *) data;
965
966        iscsit_inc_conn_usage_count(conn);
967
968        spin_lock_bh(&conn->nopin_timer_lock);
969        if (conn->nopin_response_timer_flags & ISCSI_TF_STOP) {
970                spin_unlock_bh(&conn->nopin_timer_lock);
971                iscsit_dec_conn_usage_count(conn);
972                return;
973        }
974
975        pr_debug("Did not receive response to NOPIN on CID: %hu on"
976                " SID: %u, failing connection.\n", conn->cid,
977                        conn->sess->sid);
978        conn->nopin_response_timer_flags &= ~ISCSI_TF_RUNNING;
979        spin_unlock_bh(&conn->nopin_timer_lock);
980
981        {
982        struct iscsi_portal_group *tpg = conn->sess->tpg;
983        struct iscsi_tiqn *tiqn = tpg->tpg_tiqn;
984
985        if (tiqn) {
986                spin_lock_bh(&tiqn->sess_err_stats.lock);
987                strcpy(tiqn->sess_err_stats.last_sess_fail_rem_name,
988                                conn->sess->sess_ops->InitiatorName);
989                tiqn->sess_err_stats.last_sess_failure_type =
990                                ISCSI_SESS_ERR_CXN_TIMEOUT;
991                tiqn->sess_err_stats.cxn_timeout_errors++;
992                atomic_long_inc(&conn->sess->conn_timeout_errors);
993                spin_unlock_bh(&tiqn->sess_err_stats.lock);
994        }
995        }
996
997        iscsit_cause_connection_reinstatement(conn, 0);
998        iscsit_dec_conn_usage_count(conn);
999}
1000
1001void iscsit_mod_nopin_response_timer(struct iscsi_conn *conn)
1002{
1003        struct iscsi_session *sess = conn->sess;
1004        struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
1005
1006        spin_lock_bh(&conn->nopin_timer_lock);
1007        if (!(conn->nopin_response_timer_flags & ISCSI_TF_RUNNING)) {
1008                spin_unlock_bh(&conn->nopin_timer_lock);
1009                return;
1010        }
1011
1012        mod_timer(&conn->nopin_response_timer,
1013                (get_jiffies_64() + na->nopin_response_timeout * HZ));
1014        spin_unlock_bh(&conn->nopin_timer_lock);
1015}
1016
1017/*
1018 *      Called with conn->nopin_timer_lock held.
1019 */
1020void iscsit_start_nopin_response_timer(struct iscsi_conn *conn)
1021{
1022        struct iscsi_session *sess = conn->sess;
1023        struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
1024
1025        spin_lock_bh(&conn->nopin_timer_lock);
1026        if (conn->nopin_response_timer_flags & ISCSI_TF_RUNNING) {
1027                spin_unlock_bh(&conn->nopin_timer_lock);
1028                return;
1029        }
1030
1031        init_timer(&conn->nopin_response_timer);
1032        conn->nopin_response_timer.expires =
1033                (get_jiffies_64() + na->nopin_response_timeout * HZ);
1034        conn->nopin_response_timer.data = (unsigned long)conn;
1035        conn->nopin_response_timer.function = iscsit_handle_nopin_response_timeout;
1036        conn->nopin_response_timer_flags &= ~ISCSI_TF_STOP;
1037        conn->nopin_response_timer_flags |= ISCSI_TF_RUNNING;
1038        add_timer(&conn->nopin_response_timer);
1039
1040        pr_debug("Started NOPIN Response Timer on CID: %d to %u"
1041                " seconds\n", conn->cid, na->nopin_response_timeout);
1042        spin_unlock_bh(&conn->nopin_timer_lock);
1043}
1044
1045void iscsit_stop_nopin_response_timer(struct iscsi_conn *conn)
1046{
1047        spin_lock_bh(&conn->nopin_timer_lock);
1048        if (!(conn->nopin_response_timer_flags & ISCSI_TF_RUNNING)) {
1049                spin_unlock_bh(&conn->nopin_timer_lock);
1050                return;
1051        }
1052        conn->nopin_response_timer_flags |= ISCSI_TF_STOP;
1053        spin_unlock_bh(&conn->nopin_timer_lock);
1054
1055        del_timer_sync(&conn->nopin_response_timer);
1056
1057        spin_lock_bh(&conn->nopin_timer_lock);
1058        conn->nopin_response_timer_flags &= ~ISCSI_TF_RUNNING;
1059        spin_unlock_bh(&conn->nopin_timer_lock);
1060}
1061
1062static void iscsit_handle_nopin_timeout(unsigned long data)
1063{
1064        struct iscsi_conn *conn = (struct iscsi_conn *) data;
1065
1066        iscsit_inc_conn_usage_count(conn);
1067
1068        spin_lock_bh(&conn->nopin_timer_lock);
1069        if (conn->nopin_timer_flags & ISCSI_TF_STOP) {
1070                spin_unlock_bh(&conn->nopin_timer_lock);
1071                iscsit_dec_conn_usage_count(conn);
1072                return;
1073        }
1074        conn->nopin_timer_flags &= ~ISCSI_TF_RUNNING;
1075        spin_unlock_bh(&conn->nopin_timer_lock);
1076
1077        iscsit_add_nopin(conn, 1);
1078        iscsit_dec_conn_usage_count(conn);
1079}
1080
1081/*
1082 * Called with conn->nopin_timer_lock held.
1083 */
1084void __iscsit_start_nopin_timer(struct iscsi_conn *conn)
1085{
1086        struct iscsi_session *sess = conn->sess;
1087        struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
1088        /*
1089        * NOPIN timeout is disabled.
1090         */
1091        if (!na->nopin_timeout)
1092                return;
1093
1094        if (conn->nopin_timer_flags & ISCSI_TF_RUNNING)
1095                return;
1096
1097        init_timer(&conn->nopin_timer);
1098        conn->nopin_timer.expires = (get_jiffies_64() + na->nopin_timeout * HZ);
1099        conn->nopin_timer.data = (unsigned long)conn;
1100        conn->nopin_timer.function = iscsit_handle_nopin_timeout;
1101        conn->nopin_timer_flags &= ~ISCSI_TF_STOP;
1102        conn->nopin_timer_flags |= ISCSI_TF_RUNNING;
1103        add_timer(&conn->nopin_timer);
1104
1105        pr_debug("Started NOPIN Timer on CID: %d at %u second"
1106                " interval\n", conn->cid, na->nopin_timeout);
1107}
1108
1109void iscsit_start_nopin_timer(struct iscsi_conn *conn)
1110{
1111        struct iscsi_session *sess = conn->sess;
1112        struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
1113        /*
1114         * NOPIN timeout is disabled..
1115         */
1116        if (!na->nopin_timeout)
1117                return;
1118
1119        spin_lock_bh(&conn->nopin_timer_lock);
1120        if (conn->nopin_timer_flags & ISCSI_TF_RUNNING) {
1121                spin_unlock_bh(&conn->nopin_timer_lock);
1122                return;
1123        }
1124
1125        init_timer(&conn->nopin_timer);
1126        conn->nopin_timer.expires = (get_jiffies_64() + na->nopin_timeout * HZ);
1127        conn->nopin_timer.data = (unsigned long)conn;
1128        conn->nopin_timer.function = iscsit_handle_nopin_timeout;
1129        conn->nopin_timer_flags &= ~ISCSI_TF_STOP;
1130        conn->nopin_timer_flags |= ISCSI_TF_RUNNING;
1131        add_timer(&conn->nopin_timer);
1132
1133        pr_debug("Started NOPIN Timer on CID: %d at %u second"
1134                        " interval\n", conn->cid, na->nopin_timeout);
1135        spin_unlock_bh(&conn->nopin_timer_lock);
1136}
1137
1138void iscsit_stop_nopin_timer(struct iscsi_conn *conn)
1139{
1140        spin_lock_bh(&conn->nopin_timer_lock);
1141        if (!(conn->nopin_timer_flags & ISCSI_TF_RUNNING)) {
1142                spin_unlock_bh(&conn->nopin_timer_lock);
1143                return;
1144        }
1145        conn->nopin_timer_flags |= ISCSI_TF_STOP;
1146        spin_unlock_bh(&conn->nopin_timer_lock);
1147
1148        del_timer_sync(&conn->nopin_timer);
1149
1150        spin_lock_bh(&conn->nopin_timer_lock);
1151        conn->nopin_timer_flags &= ~ISCSI_TF_RUNNING;
1152        spin_unlock_bh(&conn->nopin_timer_lock);
1153}
1154
1155int iscsit_send_tx_data(
1156        struct iscsi_cmd *cmd,
1157        struct iscsi_conn *conn,
1158        int use_misc)
1159{
1160        int tx_sent, tx_size;
1161        u32 iov_count;
1162        struct kvec *iov;
1163
1164send_data:
1165        tx_size = cmd->tx_size;
1166
1167        if (!use_misc) {
1168                iov = &cmd->iov_data[0];
1169                iov_count = cmd->iov_data_count;
1170        } else {
1171                iov = &cmd->iov_misc[0];
1172                iov_count = cmd->iov_misc_count;
1173        }
1174
1175        tx_sent = tx_data(conn, &iov[0], iov_count, tx_size);
1176        if (tx_size != tx_sent) {
1177                if (tx_sent == -EAGAIN) {
1178                        pr_err("tx_data() returned -EAGAIN\n");
1179                        goto send_data;
1180                } else
1181                        return -1;
1182        }
1183        cmd->tx_size = 0;
1184
1185        return 0;
1186}
1187
1188int iscsit_fe_sendpage_sg(
1189        struct iscsi_cmd *cmd,
1190        struct iscsi_conn *conn)
1191{
1192        struct scatterlist *sg = cmd->first_data_sg;
1193        struct kvec iov;
1194        u32 tx_hdr_size, data_len;
1195        u32 offset = cmd->first_data_sg_off;
1196        int tx_sent, iov_off;
1197
1198send_hdr:
1199        tx_hdr_size = ISCSI_HDR_LEN;
1200        if (conn->conn_ops->HeaderDigest)
1201                tx_hdr_size += ISCSI_CRC_LEN;
1202
1203        iov.iov_base = cmd->pdu;
1204        iov.iov_len = tx_hdr_size;
1205
1206        tx_sent = tx_data(conn, &iov, 1, tx_hdr_size);
1207        if (tx_hdr_size != tx_sent) {
1208                if (tx_sent == -EAGAIN) {
1209                        pr_err("tx_data() returned -EAGAIN\n");
1210                        goto send_hdr;
1211                }
1212                return -1;
1213        }
1214
1215        data_len = cmd->tx_size - tx_hdr_size - cmd->padding;
1216        /*
1217         * Set iov_off used by padding and data digest tx_data() calls below
1218         * in order to determine proper offset into cmd->iov_data[]
1219         */
1220        if (conn->conn_ops->DataDigest) {
1221                data_len -= ISCSI_CRC_LEN;
1222                if (cmd->padding)
1223                        iov_off = (cmd->iov_data_count - 2);
1224                else
1225                        iov_off = (cmd->iov_data_count - 1);
1226        } else {
1227                iov_off = (cmd->iov_data_count - 1);
1228        }
1229        /*
1230         * Perform sendpage() for each page in the scatterlist
1231         */
1232        while (data_len) {
1233                u32 space = (sg->length - offset);
1234                u32 sub_len = min_t(u32, data_len, space);
1235send_pg:
1236                tx_sent = conn->sock->ops->sendpage(conn->sock,
1237                                        sg_page(sg), sg->offset + offset, sub_len, 0);
1238                if (tx_sent != sub_len) {
1239                        if (tx_sent == -EAGAIN) {
1240                                pr_err("tcp_sendpage() returned"
1241                                                " -EAGAIN\n");
1242                                goto send_pg;
1243                        }
1244
1245                        pr_err("tcp_sendpage() failure: %d\n",
1246                                        tx_sent);
1247                        return -1;
1248                }
1249
1250                data_len -= sub_len;
1251                offset = 0;
1252                sg = sg_next(sg);
1253        }
1254
1255send_padding:
1256        if (cmd->padding) {
1257                struct kvec *iov_p = &cmd->iov_data[iov_off++];
1258
1259                tx_sent = tx_data(conn, iov_p, 1, cmd->padding);
1260                if (cmd->padding != tx_sent) {
1261                        if (tx_sent == -EAGAIN) {
1262                                pr_err("tx_data() returned -EAGAIN\n");
1263                                goto send_padding;
1264                        }
1265                        return -1;
1266                }
1267        }
1268
1269send_datacrc:
1270        if (conn->conn_ops->DataDigest) {
1271                struct kvec *iov_d = &cmd->iov_data[iov_off];
1272
1273                tx_sent = tx_data(conn, iov_d, 1, ISCSI_CRC_LEN);
1274                if (ISCSI_CRC_LEN != tx_sent) {
1275                        if (tx_sent == -EAGAIN) {
1276                                pr_err("tx_data() returned -EAGAIN\n");
1277                                goto send_datacrc;
1278                        }
1279                        return -1;
1280                }
1281        }
1282
1283        return 0;
1284}
1285
1286/*
1287 *      This function is used for mainly sending a ISCSI_TARG_LOGIN_RSP PDU
1288 *      back to the Initiator when an expection condition occurs with the
1289 *      errors set in status_class and status_detail.
1290 *
1291 *      Parameters:     iSCSI Connection, Status Class, Status Detail.
1292 *      Returns:        0 on success, -1 on error.
1293 */
1294int iscsit_tx_login_rsp(struct iscsi_conn *conn, u8 status_class, u8 status_detail)
1295{
1296        struct iscsi_login_rsp *hdr;
1297        struct iscsi_login *login = conn->conn_login;
1298
1299        login->login_failed = 1;
1300        iscsit_collect_login_stats(conn, status_class, status_detail);
1301
1302        memset(&login->rsp[0], 0, ISCSI_HDR_LEN);
1303
1304        hdr     = (struct iscsi_login_rsp *)&login->rsp[0];
1305        hdr->opcode             = ISCSI_OP_LOGIN_RSP;
1306        hdr->status_class       = status_class;
1307        hdr->status_detail      = status_detail;
1308        hdr->itt                = conn->login_itt;
1309
1310        return conn->conn_transport->iscsit_put_login_tx(conn, login, 0);
1311}
1312
1313void iscsit_print_session_params(struct iscsi_session *sess)
1314{
1315        struct iscsi_conn *conn;
1316
1317        pr_debug("-----------------------------[Session Params for"
1318                " SID: %u]-----------------------------\n", sess->sid);
1319        spin_lock_bh(&sess->conn_lock);
1320        list_for_each_entry(conn, &sess->sess_conn_list, conn_list)
1321                iscsi_dump_conn_ops(conn->conn_ops);
1322        spin_unlock_bh(&sess->conn_lock);
1323
1324        iscsi_dump_sess_ops(sess->sess_ops);
1325}
1326
1327static int iscsit_do_rx_data(
1328        struct iscsi_conn *conn,
1329        struct iscsi_data_count *count)
1330{
1331        int data = count->data_length, rx_loop = 0, total_rx = 0, iov_len;
1332        struct kvec *iov_p;
1333        struct msghdr msg;
1334
1335        if (!conn || !conn->sock || !conn->conn_ops)
1336                return -1;
1337
1338        memset(&msg, 0, sizeof(struct msghdr));
1339
1340        iov_p = count->iov;
1341        iov_len = count->iov_count;
1342
1343        while (total_rx < data) {
1344                rx_loop = kernel_recvmsg(conn->sock, &msg, iov_p, iov_len,
1345                                        (data - total_rx), MSG_WAITALL);
1346                if (rx_loop <= 0) {
1347                        pr_debug("rx_loop: %d total_rx: %d\n",
1348                                rx_loop, total_rx);
1349                        return rx_loop;
1350                }
1351                total_rx += rx_loop;
1352                pr_debug("rx_loop: %d, total_rx: %d, data: %d\n",
1353                                rx_loop, total_rx, data);
1354        }
1355
1356        return total_rx;
1357}
1358
1359static int iscsit_do_tx_data(
1360        struct iscsi_conn *conn,
1361        struct iscsi_data_count *count)
1362{
1363        int ret, iov_len;
1364        struct kvec *iov_p;
1365        struct msghdr msg;
1366
1367        if (!conn || !conn->sock || !conn->conn_ops)
1368                return -1;
1369
1370        if (count->data_length <= 0) {
1371                pr_err("Data length is: %d\n", count->data_length);
1372                return -1;
1373        }
1374
1375        memset(&msg, 0, sizeof(struct msghdr));
1376
1377        iov_p = count->iov;
1378        iov_len = count->iov_count;
1379
1380        ret = kernel_sendmsg(conn->sock, &msg, iov_p, iov_len,
1381                             count->data_length);
1382        if (ret != count->data_length) {
1383                pr_err("Unexpected ret: %d send data %d\n",
1384                       ret, count->data_length);
1385                return -EPIPE;
1386        }
1387        pr_debug("ret: %d, sent data: %d\n", ret, count->data_length);
1388
1389        return ret;
1390}
1391
1392int rx_data(
1393        struct iscsi_conn *conn,
1394        struct kvec *iov,
1395        int iov_count,
1396        int data)
1397{
1398        struct iscsi_data_count c;
1399
1400        if (!conn || !conn->sock || !conn->conn_ops)
1401                return -1;
1402
1403        memset(&c, 0, sizeof(struct iscsi_data_count));
1404        c.iov = iov;
1405        c.iov_count = iov_count;
1406        c.data_length = data;
1407        c.type = ISCSI_RX_DATA;
1408
1409        return iscsit_do_rx_data(conn, &c);
1410}
1411
1412int tx_data(
1413        struct iscsi_conn *conn,
1414        struct kvec *iov,
1415        int iov_count,
1416        int data)
1417{
1418        struct iscsi_data_count c;
1419
1420        if (!conn || !conn->sock || !conn->conn_ops)
1421                return -1;
1422
1423        memset(&c, 0, sizeof(struct iscsi_data_count));
1424        c.iov = iov;
1425        c.iov_count = iov_count;
1426        c.data_length = data;
1427        c.type = ISCSI_TX_DATA;
1428
1429        return iscsit_do_tx_data(conn, &c);
1430}
1431
1432void iscsit_collect_login_stats(
1433        struct iscsi_conn *conn,
1434        u8 status_class,
1435        u8 status_detail)
1436{
1437        struct iscsi_param *intrname = NULL;
1438        struct iscsi_tiqn *tiqn;
1439        struct iscsi_login_stats *ls;
1440
1441        tiqn = iscsit_snmp_get_tiqn(conn);
1442        if (!tiqn)
1443                return;
1444
1445        ls = &tiqn->login_stats;
1446
1447        spin_lock(&ls->lock);
1448        if (!strcmp(conn->login_ip, ls->last_intr_fail_ip_addr) &&
1449            ((get_jiffies_64() - ls->last_fail_time) < 10)) {
1450                /* We already have the failure info for this login */
1451                spin_unlock(&ls->lock);
1452                return;
1453        }
1454
1455        if (status_class == ISCSI_STATUS_CLS_SUCCESS)
1456                ls->accepts++;
1457        else if (status_class == ISCSI_STATUS_CLS_REDIRECT) {
1458                ls->redirects++;
1459                ls->last_fail_type = ISCSI_LOGIN_FAIL_REDIRECT;
1460        } else if ((status_class == ISCSI_STATUS_CLS_INITIATOR_ERR)  &&
1461                 (status_detail == ISCSI_LOGIN_STATUS_AUTH_FAILED)) {
1462                ls->authenticate_fails++;
1463                ls->last_fail_type =  ISCSI_LOGIN_FAIL_AUTHENTICATE;
1464        } else if ((status_class == ISCSI_STATUS_CLS_INITIATOR_ERR)  &&
1465                 (status_detail == ISCSI_LOGIN_STATUS_TGT_FORBIDDEN)) {
1466                ls->authorize_fails++;
1467                ls->last_fail_type = ISCSI_LOGIN_FAIL_AUTHORIZE;
1468        } else if ((status_class == ISCSI_STATUS_CLS_INITIATOR_ERR) &&
1469                 (status_detail == ISCSI_LOGIN_STATUS_INIT_ERR)) {
1470                ls->negotiate_fails++;
1471                ls->last_fail_type = ISCSI_LOGIN_FAIL_NEGOTIATE;
1472        } else {
1473                ls->other_fails++;
1474                ls->last_fail_type = ISCSI_LOGIN_FAIL_OTHER;
1475        }
1476
1477        /* Save initiator name, ip address and time, if it is a failed login */
1478        if (status_class != ISCSI_STATUS_CLS_SUCCESS) {
1479                if (conn->param_list)
1480                        intrname = iscsi_find_param_from_key(INITIATORNAME,
1481                                                             conn->param_list);
1482                strlcpy(ls->last_intr_fail_name,
1483                       (intrname ? intrname->value : "Unknown"),
1484                       sizeof(ls->last_intr_fail_name));
1485
1486                ls->last_intr_fail_ip_family = conn->login_family;
1487
1488                snprintf(ls->last_intr_fail_ip_addr, IPV6_ADDRESS_SPACE,
1489                                "%s", conn->login_ip);
1490                ls->last_fail_time = get_jiffies_64();
1491        }
1492
1493        spin_unlock(&ls->lock);
1494}
1495
1496struct iscsi_tiqn *iscsit_snmp_get_tiqn(struct iscsi_conn *conn)
1497{
1498        struct iscsi_portal_group *tpg;
1499
1500        if (!conn || !conn->sess)
1501                return NULL;
1502
1503        tpg = conn->sess->tpg;
1504        if (!tpg)
1505                return NULL;
1506
1507        if (!tpg->tpg_tiqn)
1508                return NULL;
1509
1510        return tpg->tpg_tiqn;
1511}
Note: See TracBrowser for help on using the repository browser.