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

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

update

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