Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
iscsi_target_util.c
Go to the documentation of this file.
1 /*******************************************************************************
2  * This file contains the iSCSI Target specific utility functions.
3  *
4  * \u00a9 Copyright 2007-2011 RisingTide Systems LLC.
5  *
6  * Licensed to the Linux Foundation under the General Public License (GPL) version 2.
7  *
8  * Author: Nicholas A. Bellinger <[email protected]>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU General Public License for more details.
19  ******************************************************************************/
20 
21 #include <linux/list.h>
22 #include <scsi/scsi_tcq.h>
23 #include <scsi/iscsi_proto.h>
27 
28 #include "iscsi_target_core.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 
57 extern struct list_head g_tiqn_list;
58 extern spinlock_t tiqn_lock;
59 
60 /*
61  * Called with cmd->r2t_lock held.
62  */
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 
87 
88  spin_lock_bh(&cmd->r2t_lock);
89  return 0;
90 }
91 
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);
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 
115 {
116  struct iscsi_r2t *r2t;
117 
118  spin_lock_bh(&cmd->r2t_lock);
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  */
135 void iscsit_free_r2t(struct iscsi_r2t *r2t, struct iscsi_cmd *cmd)
136 {
137  list_del(&r2t->r2t_list);
139 }
140 
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  */
156 {
157  struct iscsi_cmd *cmd;
158 
159  cmd = kmem_cache_zalloc(lio_cmd_cache, gfp_mask);
160  if (!cmd) {
161  pr_err("Unable to allocate memory for struct iscsi_cmd.\n");
162  return NULL;
163  }
164 
165  cmd->conn = conn;
166  INIT_LIST_HEAD(&cmd->i_conn_node);
167  INIT_LIST_HEAD(&cmd->datain_list);
168  INIT_LIST_HEAD(&cmd->cmd_r2t_list);
169  init_completion(&cmd->reject_comp);
173  spin_lock_init(&cmd->error_lock);
174  spin_lock_init(&cmd->r2t_lock);
175 
176  return cmd;
177 }
178 
180  struct iscsi_cmd *cmd,
182 {
183  u32 i;
184 
185  for (i = 0; i < cmd->seq_count; i++)
186  if (cmd->seq_list[i].seq_send_order == seq_send_order)
187  return &cmd->seq_list[i];
188 
189  return NULL;
190 }
191 
193 {
194  u32 i;
195 
196  if (!cmd->seq_list) {
197  pr_err("struct iscsi_cmd->seq_list is NULL!\n");
198  return NULL;
199  }
200 
201  for (i = 0; i < cmd->seq_count; i++) {
202  if (cmd->seq_list[i].type != SEQTYPE_NORMAL)
203  continue;
204  if (cmd->seq_list[i].seq_send_order == cmd->seq_send_order) {
205  cmd->seq_send_order++;
206  return &cmd->seq_list[i];
207  }
208  }
209 
210  return NULL;
211 }
212 
214  struct iscsi_cmd *cmd,
215  u32 r2t_sn)
216 {
217  struct iscsi_r2t *r2t;
218 
219  spin_lock_bh(&cmd->r2t_lock);
221  if (r2t->r2t_sn == r2t_sn) {
222  spin_unlock_bh(&cmd->r2t_lock);
223  return r2t;
224  }
225  }
226  spin_unlock_bh(&cmd->r2t_lock);
227 
228  return NULL;
229 }
230 
231 static inline int iscsit_check_received_cmdsn(struct iscsi_session *sess, u32 cmdsn)
232 {
233  int ret;
234 
235  /*
236  * This is the proper method of checking received CmdSN against
237  * ExpCmdSN and MaxCmdSN values, as well as accounting for out
238  * or order CmdSNs due to multiple connection sessions and/or
239  * CRC failures.
240  */
241  if (iscsi_sna_gt(cmdsn, sess->max_cmd_sn)) {
242  pr_err("Received CmdSN: 0x%08x is greater than"
243  " MaxCmdSN: 0x%08x, protocol error.\n", cmdsn,
244  sess->max_cmd_sn);
246 
247  } else if (cmdsn == sess->exp_cmd_sn) {
248  sess->exp_cmd_sn++;
249  pr_debug("Received CmdSN matches ExpCmdSN,"
250  " incremented ExpCmdSN to: 0x%08x\n",
251  sess->exp_cmd_sn);
253 
254  } else if (iscsi_sna_gt(cmdsn, sess->exp_cmd_sn)) {
255  pr_debug("Received CmdSN: 0x%08x is greater"
256  " than ExpCmdSN: 0x%08x, not acknowledging.\n",
257  cmdsn, sess->exp_cmd_sn);
258  ret = CMDSN_HIGHER_THAN_EXP;
259 
260  } else {
261  pr_err("Received CmdSN: 0x%08x is less than"
262  " ExpCmdSN: 0x%08x, ignoring.\n", cmdsn,
263  sess->exp_cmd_sn);
264  ret = CMDSN_LOWER_THAN_EXP;
265  }
266 
267  return ret;
268 }
269 
270 /*
271  * Commands may be received out of order if MC/S is in use.
272  * Ensure they are executed in CmdSN order.
273  */
275  struct iscsi_conn *conn,
276  struct iscsi_cmd *cmd,
277  __be32 cmdsn)
278 {
279  int ret;
280  int cmdsn_ret;
281 
282  mutex_lock(&conn->sess->cmdsn_mutex);
283 
284  cmdsn_ret = iscsit_check_received_cmdsn(conn->sess, be32_to_cpu(cmdsn));
285  switch (cmdsn_ret) {
287  ret = iscsit_execute_cmd(cmd, 0);
288  if ((ret >= 0) && !list_empty(&conn->sess->sess_ooo_cmdsn_list))
290  break;
292  ret = iscsit_handle_ooo_cmdsn(conn->sess, cmd, be32_to_cpu(cmdsn));
293  break;
295  cmd->i_state = ISTATE_REMOVE;
297  ret = cmdsn_ret;
298  break;
299  default:
300  ret = cmdsn_ret;
301  break;
302  }
303  mutex_unlock(&conn->sess->cmdsn_mutex);
304 
305  return ret;
306 }
307 
308 int iscsit_check_unsolicited_dataout(struct iscsi_cmd *cmd, unsigned char *buf)
309 {
310  struct iscsi_conn *conn = cmd->conn;
311  struct se_cmd *se_cmd = &cmd->se_cmd;
312  struct iscsi_data *hdr = (struct iscsi_data *) buf;
314 
315  if (conn->sess->sess_ops->InitialR2T) {
316  pr_err("Received unexpected unsolicited data"
317  " while InitialR2T=Yes, protocol error.\n");
320  return -1;
321  }
322 
323  if ((cmd->first_burst_len + payload_length) >
324  conn->sess->sess_ops->FirstBurstLength) {
325  pr_err("Total %u bytes exceeds FirstBurstLength: %u"
326  " for this Unsolicited DataOut Burst.\n",
327  (cmd->first_burst_len + payload_length),
328  conn->sess->sess_ops->FirstBurstLength);
331  return -1;
332  }
333 
334  if (!(hdr->flags & ISCSI_FLAG_CMD_FINAL))
335  return 0;
336 
337  if (((cmd->first_burst_len + payload_length) != cmd->se_cmd.data_length) &&
338  ((cmd->first_burst_len + payload_length) !=
339  conn->sess->sess_ops->FirstBurstLength)) {
340  pr_err("Unsolicited non-immediate data received %u"
341  " does not equal FirstBurstLength: %u, and does"
342  " not equal ExpXferLen %u.\n",
343  (cmd->first_burst_len + payload_length),
344  conn->sess->sess_ops->FirstBurstLength, cmd->se_cmd.data_length);
347  return -1;
348  }
349  return 0;
350 }
351 
353  struct iscsi_conn *conn,
355 {
356  struct iscsi_cmd *cmd;
357 
358  spin_lock_bh(&conn->cmd_lock);
360  if (cmd->init_task_tag == init_task_tag) {
361  spin_unlock_bh(&conn->cmd_lock);
362  return cmd;
363  }
364  }
365  spin_unlock_bh(&conn->cmd_lock);
366 
367  pr_err("Unable to locate ITT: 0x%08x on CID: %hu",
368  init_task_tag, conn->cid);
369  return NULL;
370 }
371 
373  struct iscsi_conn *conn,
375  u32 length)
376 {
377  struct iscsi_cmd *cmd;
378 
379  spin_lock_bh(&conn->cmd_lock);
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  " dumping payload\n", init_task_tag, conn->cid);
390  if (length)
391  iscsit_dump_data_payload(conn, length, 1);
392 
393  return NULL;
394 }
395 
397  struct iscsi_conn *conn,
399 {
400  struct iscsi_cmd *cmd = NULL;
401 
402  spin_lock_bh(&conn->cmd_lock);
404  if (cmd->targ_xfer_tag == targ_xfer_tag) {
405  spin_unlock_bh(&conn->cmd_lock);
406  return cmd;
407  }
408  }
409  spin_unlock_bh(&conn->cmd_lock);
410 
411  pr_err("Unable to locate TTT: 0x%08x on CID: %hu\n",
412  targ_xfer_tag, conn->cid);
413  return NULL;
414 }
415 
417  struct iscsi_session *sess,
418  struct iscsi_cmd **cmd_ptr,
419  struct iscsi_conn_recovery **cr_ptr,
421 {
422  struct iscsi_cmd *cmd = NULL;
423  struct iscsi_conn_recovery *cr;
424  /*
425  * Scan through the inactive connection recovery list's command list.
426  * If init_task_tag matches the command is still alligent.
427  */
428  spin_lock(&sess->cr_i_lock);
430  spin_lock(&cr->conn_recovery_cmd_lock);
431  list_for_each_entry(cmd, &cr->conn_recovery_cmd_list, i_conn_node) {
432  if (cmd->init_task_tag == init_task_tag) {
433  spin_unlock(&cr->conn_recovery_cmd_lock);
434  spin_unlock(&sess->cr_i_lock);
435 
436  *cr_ptr = cr;
437  *cmd_ptr = cmd;
438  return -2;
439  }
440  }
441  spin_unlock(&cr->conn_recovery_cmd_lock);
442  }
443  spin_unlock(&sess->cr_i_lock);
444  /*
445  * Scan through the active connection recovery list's command list.
446  * If init_task_tag matches the command is ready to be reassigned.
447  */
448  spin_lock(&sess->cr_a_lock);
450  spin_lock(&cr->conn_recovery_cmd_lock);
451  list_for_each_entry(cmd, &cr->conn_recovery_cmd_list, i_conn_node) {
452  if (cmd->init_task_tag == init_task_tag) {
453  spin_unlock(&cr->conn_recovery_cmd_lock);
454  spin_unlock(&sess->cr_a_lock);
455 
456  *cr_ptr = cr;
457  *cmd_ptr = cmd;
458  return 0;
459  }
460  }
461  spin_unlock(&cr->conn_recovery_cmd_lock);
462  }
463  spin_unlock(&sess->cr_a_lock);
464 
465  return -1;
466 }
467 
469  struct iscsi_cmd *cmd,
470  struct iscsi_conn *conn,
471  u8 state)
472 {
473  struct iscsi_queue_req *qr;
474 
475  qr = kmem_cache_zalloc(lio_qr_cache, GFP_ATOMIC);
476  if (!qr) {
477  pr_err("Unable to allocate memory for"
478  " struct iscsi_queue_req\n");
479  return;
480  }
481  INIT_LIST_HEAD(&qr->qr_list);
482  qr->cmd = cmd;
483  qr->state = state;
484 
485  spin_lock_bh(&conn->immed_queue_lock);
486  list_add_tail(&qr->qr_list, &conn->immed_queue_list);
489  spin_unlock_bh(&conn->immed_queue_lock);
490 
491  wake_up(&conn->queues_wq);
492 }
493 
495 {
496  struct iscsi_queue_req *qr;
497 
498  spin_lock_bh(&conn->immed_queue_lock);
499  if (list_empty(&conn->immed_queue_list)) {
500  spin_unlock_bh(&conn->immed_queue_lock);
501  return NULL;
502  }
504  break;
505 
506  list_del(&qr->qr_list);
507  if (qr->cmd)
508  atomic_dec(&qr->cmd->immed_queue_count);
509  spin_unlock_bh(&conn->immed_queue_lock);
510 
511  return qr;
512 }
513 
514 static void iscsit_remove_cmd_from_immediate_queue(
515  struct iscsi_cmd *cmd,
516  struct iscsi_conn *conn)
517 {
518  struct iscsi_queue_req *qr, *qr_tmp;
519 
520  spin_lock_bh(&conn->immed_queue_lock);
521  if (!atomic_read(&cmd->immed_queue_count)) {
522  spin_unlock_bh(&conn->immed_queue_lock);
523  return;
524  }
525 
526  list_for_each_entry_safe(qr, qr_tmp, &conn->immed_queue_list, qr_list) {
527  if (qr->cmd != cmd)
528  continue;
529 
530  atomic_dec(&qr->cmd->immed_queue_count);
531  list_del(&qr->qr_list);
533  }
534  spin_unlock_bh(&conn->immed_queue_lock);
535 
536  if (atomic_read(&cmd->immed_queue_count)) {
537  pr_err("ITT: 0x%08x immed_queue_count: %d\n",
538  cmd->init_task_tag,
540  }
541 }
542 
544  struct iscsi_cmd *cmd,
545  struct iscsi_conn *conn,
546  u8 state)
547 {
548  struct iscsi_queue_req *qr;
549 
550  qr = kmem_cache_zalloc(lio_qr_cache, GFP_ATOMIC);
551  if (!qr) {
552  pr_err("Unable to allocate memory for"
553  " struct iscsi_queue_req\n");
554  return;
555  }
556  INIT_LIST_HEAD(&qr->qr_list);
557  qr->cmd = cmd;
558  qr->state = state;
559 
560  spin_lock_bh(&conn->response_queue_lock);
563  spin_unlock_bh(&conn->response_queue_lock);
564 
565  wake_up(&conn->queues_wq);
566 }
567 
569 {
570  struct iscsi_queue_req *qr;
571 
572  spin_lock_bh(&conn->response_queue_lock);
573  if (list_empty(&conn->response_queue_list)) {
574  spin_unlock_bh(&conn->response_queue_lock);
575  return NULL;
576  }
577 
579  break;
580 
581  list_del(&qr->qr_list);
582  if (qr->cmd)
583  atomic_dec(&qr->cmd->response_queue_count);
584  spin_unlock_bh(&conn->response_queue_lock);
585 
586  return qr;
587 }
588 
589 static void iscsit_remove_cmd_from_response_queue(
590  struct iscsi_cmd *cmd,
591  struct iscsi_conn *conn)
592 {
593  struct iscsi_queue_req *qr, *qr_tmp;
594 
595  spin_lock_bh(&conn->response_queue_lock);
596  if (!atomic_read(&cmd->response_queue_count)) {
597  spin_unlock_bh(&conn->response_queue_lock);
598  return;
599  }
600 
602  qr_list) {
603  if (qr->cmd != cmd)
604  continue;
605 
606  atomic_dec(&qr->cmd->response_queue_count);
607  list_del(&qr->qr_list);
609  }
610  spin_unlock_bh(&conn->response_queue_lock);
611 
612  if (atomic_read(&cmd->response_queue_count)) {
613  pr_err("ITT: 0x%08x response_queue_count: %d\n",
614  cmd->init_task_tag,
616  }
617 }
618 
620 {
621  bool empty;
622 
623  spin_lock_bh(&conn->immed_queue_lock);
624  empty = list_empty(&conn->immed_queue_list);
625  spin_unlock_bh(&conn->immed_queue_lock);
626 
627  if (!empty)
628  return empty;
629 
630  spin_lock_bh(&conn->response_queue_lock);
631  empty = list_empty(&conn->response_queue_list);
632  spin_unlock_bh(&conn->response_queue_lock);
633 
634  return empty;
635 }
636 
638 {
639  struct iscsi_queue_req *qr, *qr_tmp;
640 
641  spin_lock_bh(&conn->immed_queue_lock);
642  list_for_each_entry_safe(qr, qr_tmp, &conn->immed_queue_list, qr_list) {
643  list_del(&qr->qr_list);
644  if (qr->cmd)
645  atomic_dec(&qr->cmd->immed_queue_count);
646 
648  }
649  spin_unlock_bh(&conn->immed_queue_lock);
650 
651  spin_lock_bh(&conn->response_queue_lock);
653  qr_list) {
654  list_del(&qr->qr_list);
655  if (qr->cmd)
656  atomic_dec(&qr->cmd->response_queue_count);
657 
659  }
660  spin_unlock_bh(&conn->response_queue_lock);
661 }
662 
663 void iscsit_release_cmd(struct iscsi_cmd *cmd)
664 {
665  struct iscsi_conn *conn = cmd->conn;
666 
669 
670  kfree(cmd->buf_ptr);
671  kfree(cmd->pdu_list);
672  kfree(cmd->seq_list);
673  kfree(cmd->tmr_req);
674  kfree(cmd->iov_data);
675 
676  if (conn) {
677  iscsit_remove_cmd_from_immediate_queue(cmd, conn);
678  iscsit_remove_cmd_from_response_queue(cmd, conn);
679  }
680 
682 }
683 
684 void iscsit_free_cmd(struct iscsi_cmd *cmd)
685 {
686  /*
687  * Determine if a struct se_cmd is assoicated with
688  * this struct iscsi_cmd.
689  */
690  switch (cmd->iscsi_opcode) {
691  case ISCSI_OP_SCSI_CMD:
694  break;
695  case ISCSI_OP_REJECT:
696  /*
697  * Handle special case for REJECT when iscsi_add_reject*() has
698  * overwritten the original iscsi_opcode assignment, and the
699  * associated cmd->se_cmd needs to be released.
700  */
701  if (cmd->se_cmd.se_tfo != NULL) {
703  break;
704  }
705  /* Fall-through */
706  default:
707  iscsit_release_cmd(cmd);
708  break;
709  }
710 }
711 
713 {
714  spin_lock_bh(&sess->session_usage_lock);
715  if (sess->session_usage_count != 0) {
716  sess->session_waiting_on_uc = 1;
717  spin_unlock_bh(&sess->session_usage_lock);
718  if (in_interrupt())
719  return 2;
720 
722  return 1;
723  }
724  spin_unlock_bh(&sess->session_usage_lock);
725 
726  return 0;
727 }
728 
730 {
731  spin_lock_bh(&sess->session_usage_lock);
732  sess->session_usage_count--;
733 
734  if (!sess->session_usage_count && sess->session_waiting_on_uc)
736 
737  spin_unlock_bh(&sess->session_usage_lock);
738 }
739 
741 {
742  spin_lock_bh(&sess->session_usage_lock);
743  sess->session_usage_count++;
744  spin_unlock_bh(&sess->session_usage_lock);
745 }
746 
747 /*
748  * Setup conn->if_marker and conn->of_marker values based upon
749  * the initial marker-less interval. (see iSCSI v19 A.2)
750  */
752 {
753  int login_ifmarker_count = 0, login_ofmarker_count = 0, next_marker = 0;
754  /*
755  * IFMarkInt and OFMarkInt are negotiated as 32-bit words.
756  */
757  u32 IFMarkInt = (conn->conn_ops->IFMarkInt * 4);
758  u32 OFMarkInt = (conn->conn_ops->OFMarkInt * 4);
759 
760  if (conn->conn_ops->OFMarker) {
761  /*
762  * Account for the first Login Command received not
763  * via iscsi_recv_msg().
764  */
765  conn->of_marker += ISCSI_HDR_LEN;
766  if (conn->of_marker <= OFMarkInt) {
767  conn->of_marker = (OFMarkInt - conn->of_marker);
768  } else {
769  login_ofmarker_count = (conn->of_marker / OFMarkInt);
770  next_marker = (OFMarkInt * (login_ofmarker_count + 1)) +
771  (login_ofmarker_count * MARKER_SIZE);
772  conn->of_marker = (next_marker - conn->of_marker);
773  }
774  conn->of_marker_offset = 0;
775  pr_debug("Setting OFMarker value to %u based on Initial"
776  " Markerless Interval.\n", conn->of_marker);
777  }
778 
779  if (conn->conn_ops->IFMarker) {
780  if (conn->if_marker <= IFMarkInt) {
781  conn->if_marker = (IFMarkInt - conn->if_marker);
782  } else {
783  login_ifmarker_count = (conn->if_marker / IFMarkInt);
784  next_marker = (IFMarkInt * (login_ifmarker_count + 1)) +
785  (login_ifmarker_count * MARKER_SIZE);
786  conn->if_marker = (next_marker - conn->if_marker);
787  }
788  pr_debug("Setting IFMarker value to %u based on Initial"
789  " Markerless Interval.\n", conn->if_marker);
790  }
791 
792  return 0;
793 }
794 
796 {
797  struct iscsi_conn *conn;
798 
799  spin_lock_bh(&sess->conn_lock);
801  if ((conn->cid == cid) &&
804  spin_unlock_bh(&sess->conn_lock);
805  return conn;
806  }
807  }
808  spin_unlock_bh(&sess->conn_lock);
809 
810  return NULL;
811 }
812 
814 {
815  struct iscsi_conn *conn;
816 
817  spin_lock_bh(&sess->conn_lock);
819  if (conn->cid == cid) {
821  spin_lock(&conn->state_lock);
822  atomic_set(&conn->connection_wait_rcfr, 1);
823  spin_unlock(&conn->state_lock);
824  spin_unlock_bh(&sess->conn_lock);
825  return conn;
826  }
827  }
828  spin_unlock_bh(&sess->conn_lock);
829 
830  return NULL;
831 }
832 
834 {
835  spin_lock_bh(&conn->conn_usage_lock);
836  if (conn->conn_usage_count != 0) {
837  conn->conn_waiting_on_uc = 1;
838  spin_unlock_bh(&conn->conn_usage_lock);
839 
841  return;
842  }
843  spin_unlock_bh(&conn->conn_usage_lock);
844 }
845 
847 {
848  spin_lock_bh(&conn->conn_usage_lock);
849  conn->conn_usage_count--;
850 
851  if (!conn->conn_usage_count && conn->conn_waiting_on_uc)
853 
854  spin_unlock_bh(&conn->conn_usage_lock);
855 }
856 
858 {
859  spin_lock_bh(&conn->conn_usage_lock);
860  conn->conn_usage_count++;
861  spin_unlock_bh(&conn->conn_usage_lock);
862 }
863 
864 static int iscsit_add_nopin(struct iscsi_conn *conn, int want_response)
865 {
866  u8 state;
867  struct iscsi_cmd *cmd;
868 
869  cmd = iscsit_allocate_cmd(conn, GFP_ATOMIC);
870  if (!cmd)
871  return -1;
872 
874  state = (want_response) ? ISTATE_SEND_NOPIN_WANT_RESPONSE :
877  spin_lock_bh(&conn->sess->ttt_lock);
878  cmd->targ_xfer_tag = (want_response) ? conn->sess->targ_xfer_tag++ :
879  0xFFFFFFFF;
880  if (want_response && (cmd->targ_xfer_tag == 0xFFFFFFFF))
881  cmd->targ_xfer_tag = conn->sess->targ_xfer_tag++;
882  spin_unlock_bh(&conn->sess->ttt_lock);
883 
884  spin_lock_bh(&conn->cmd_lock);
885  list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
886  spin_unlock_bh(&conn->cmd_lock);
887 
888  if (want_response)
890  iscsit_add_cmd_to_immediate_queue(cmd, conn, state);
891 
892  return 0;
893 }
894 
895 static void iscsit_handle_nopin_response_timeout(unsigned long data)
896 {
897  struct iscsi_conn *conn = (struct iscsi_conn *) data;
898 
900 
901  spin_lock_bh(&conn->nopin_timer_lock);
903  spin_unlock_bh(&conn->nopin_timer_lock);
905  return;
906  }
907 
908  pr_debug("Did not receive response to NOPIN on CID: %hu on"
909  " SID: %u, failing connection.\n", conn->cid,
910  conn->sess->sid);
912  spin_unlock_bh(&conn->nopin_timer_lock);
913 
914  {
915  struct iscsi_portal_group *tpg = conn->sess->tpg;
916  struct iscsi_tiqn *tiqn = tpg->tpg_tiqn;
917 
918  if (tiqn) {
919  spin_lock_bh(&tiqn->sess_err_stats.lock);
920  strcpy(tiqn->sess_err_stats.last_sess_fail_rem_name,
921  conn->sess->sess_ops->InitiatorName);
922  tiqn->sess_err_stats.last_sess_failure_type =
924  tiqn->sess_err_stats.cxn_timeout_errors++;
925  conn->sess->conn_timeout_errors++;
926  spin_unlock_bh(&tiqn->sess_err_stats.lock);
927  }
928  }
929 
932 }
933 
935 {
936  struct iscsi_session *sess = conn->sess;
938 
939  spin_lock_bh(&conn->nopin_timer_lock);
941  spin_unlock_bh(&conn->nopin_timer_lock);
942  return;
943  }
944 
947  spin_unlock_bh(&conn->nopin_timer_lock);
948 }
949 
950 /*
951  * Called with conn->nopin_timer_lock held.
952  */
954 {
955  struct iscsi_session *sess = conn->sess;
957 
958  spin_lock_bh(&conn->nopin_timer_lock);
960  spin_unlock_bh(&conn->nopin_timer_lock);
961  return;
962  }
963 
965  conn->nopin_response_timer.expires =
967  conn->nopin_response_timer.data = (unsigned long)conn;
968  conn->nopin_response_timer.function = iscsit_handle_nopin_response_timeout;
972 
973  pr_debug("Started NOPIN Response Timer on CID: %d to %u"
974  " seconds\n", conn->cid, na->nopin_response_timeout);
975  spin_unlock_bh(&conn->nopin_timer_lock);
976 }
977 
979 {
980  spin_lock_bh(&conn->nopin_timer_lock);
982  spin_unlock_bh(&conn->nopin_timer_lock);
983  return;
984  }
986  spin_unlock_bh(&conn->nopin_timer_lock);
987 
989 
990  spin_lock_bh(&conn->nopin_timer_lock);
992  spin_unlock_bh(&conn->nopin_timer_lock);
993 }
994 
995 static void iscsit_handle_nopin_timeout(unsigned long data)
996 {
997  struct iscsi_conn *conn = (struct iscsi_conn *) data;
998 
1000 
1001  spin_lock_bh(&conn->nopin_timer_lock);
1002  if (conn->nopin_timer_flags & ISCSI_TF_STOP) {
1003  spin_unlock_bh(&conn->nopin_timer_lock);
1005  return;
1006  }
1008  spin_unlock_bh(&conn->nopin_timer_lock);
1009 
1010  iscsit_add_nopin(conn, 1);
1012 }
1013 
1014 /*
1015  * Called with conn->nopin_timer_lock held.
1016  */
1018 {
1019  struct iscsi_session *sess = conn->sess;
1020  struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
1021  /*
1022  * NOPIN timeout is disabled.
1023  */
1024  if (!na->nopin_timeout)
1025  return;
1026 
1027  if (conn->nopin_timer_flags & ISCSI_TF_RUNNING)
1028  return;
1029 
1030  init_timer(&conn->nopin_timer);
1031  conn->nopin_timer.expires = (get_jiffies_64() + na->nopin_timeout * HZ);
1032  conn->nopin_timer.data = (unsigned long)conn;
1033  conn->nopin_timer.function = iscsit_handle_nopin_timeout;
1034  conn->nopin_timer_flags &= ~ISCSI_TF_STOP;
1036  add_timer(&conn->nopin_timer);
1037 
1038  pr_debug("Started NOPIN Timer on CID: %d at %u second"
1039  " interval\n", conn->cid, na->nopin_timeout);
1040 }
1041 
1043 {
1044  struct iscsi_session *sess = conn->sess;
1045  struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
1046  /*
1047  * NOPIN timeout is disabled..
1048  */
1049  if (!na->nopin_timeout)
1050  return;
1051 
1052  spin_lock_bh(&conn->nopin_timer_lock);
1053  if (conn->nopin_timer_flags & ISCSI_TF_RUNNING) {
1054  spin_unlock_bh(&conn->nopin_timer_lock);
1055  return;
1056  }
1057 
1058  init_timer(&conn->nopin_timer);
1059  conn->nopin_timer.expires = (get_jiffies_64() + na->nopin_timeout * HZ);
1060  conn->nopin_timer.data = (unsigned long)conn;
1061  conn->nopin_timer.function = iscsit_handle_nopin_timeout;
1062  conn->nopin_timer_flags &= ~ISCSI_TF_STOP;
1064  add_timer(&conn->nopin_timer);
1065 
1066  pr_debug("Started NOPIN Timer on CID: %d at %u second"
1067  " interval\n", conn->cid, na->nopin_timeout);
1068  spin_unlock_bh(&conn->nopin_timer_lock);
1069 }
1070 
1072 {
1073  spin_lock_bh(&conn->nopin_timer_lock);
1074  if (!(conn->nopin_timer_flags & ISCSI_TF_RUNNING)) {
1075  spin_unlock_bh(&conn->nopin_timer_lock);
1076  return;
1077  }
1079  spin_unlock_bh(&conn->nopin_timer_lock);
1080 
1081  del_timer_sync(&conn->nopin_timer);
1082 
1083  spin_lock_bh(&conn->nopin_timer_lock);
1085  spin_unlock_bh(&conn->nopin_timer_lock);
1086 }
1087 
1089  struct iscsi_cmd *cmd,
1090  struct iscsi_conn *conn,
1091  int use_misc)
1092 {
1093  int tx_sent, tx_size;
1094  u32 iov_count;
1095  struct kvec *iov;
1096 
1097 send_data:
1098  tx_size = cmd->tx_size;
1099 
1100  if (!use_misc) {
1101  iov = &cmd->iov_data[0];
1102  iov_count = cmd->iov_data_count;
1103  } else {
1104  iov = &cmd->iov_misc[0];
1105  iov_count = cmd->iov_misc_count;
1106  }
1107 
1108  tx_sent = tx_data(conn, &iov[0], iov_count, tx_size);
1109  if (tx_size != tx_sent) {
1110  if (tx_sent == -EAGAIN) {
1111  pr_err("tx_data() returned -EAGAIN\n");
1112  goto send_data;
1113  } else
1114  return -1;
1115  }
1116  cmd->tx_size = 0;
1117 
1118  return 0;
1119 }
1120 
1122  struct iscsi_cmd *cmd,
1123  struct iscsi_conn *conn)
1124 {
1125  struct scatterlist *sg = cmd->first_data_sg;
1126  struct kvec iov;
1127  u32 tx_hdr_size, data_len;
1128  u32 offset = cmd->first_data_sg_off;
1129  int tx_sent, iov_off;
1130 
1131 send_hdr:
1132  tx_hdr_size = ISCSI_HDR_LEN;
1133  if (conn->conn_ops->HeaderDigest)
1134  tx_hdr_size += ISCSI_CRC_LEN;
1135 
1136  iov.iov_base = cmd->pdu;
1137  iov.iov_len = tx_hdr_size;
1138 
1139  tx_sent = tx_data(conn, &iov, 1, tx_hdr_size);
1140  if (tx_hdr_size != tx_sent) {
1141  if (tx_sent == -EAGAIN) {
1142  pr_err("tx_data() returned -EAGAIN\n");
1143  goto send_hdr;
1144  }
1145  return -1;
1146  }
1147 
1148  data_len = cmd->tx_size - tx_hdr_size - cmd->padding;
1149  /*
1150  * Set iov_off used by padding and data digest tx_data() calls below
1151  * in order to determine proper offset into cmd->iov_data[]
1152  */
1153  if (conn->conn_ops->DataDigest) {
1154  data_len -= ISCSI_CRC_LEN;
1155  if (cmd->padding)
1156  iov_off = (cmd->iov_data_count - 2);
1157  else
1158  iov_off = (cmd->iov_data_count - 1);
1159  } else {
1160  iov_off = (cmd->iov_data_count - 1);
1161  }
1162  /*
1163  * Perform sendpage() for each page in the scatterlist
1164  */
1165  while (data_len) {
1166  u32 space = (sg->length - offset);
1167  u32 sub_len = min_t(u32, data_len, space);
1168 send_pg:
1169  tx_sent = conn->sock->ops->sendpage(conn->sock,
1170  sg_page(sg), sg->offset + offset, sub_len, 0);
1171  if (tx_sent != sub_len) {
1172  if (tx_sent == -EAGAIN) {
1173  pr_err("tcp_sendpage() returned"
1174  " -EAGAIN\n");
1175  goto send_pg;
1176  }
1177 
1178  pr_err("tcp_sendpage() failure: %d\n",
1179  tx_sent);
1180  return -1;
1181  }
1182 
1183  data_len -= sub_len;
1184  offset = 0;
1185  sg = sg_next(sg);
1186  }
1187 
1188 send_padding:
1189  if (cmd->padding) {
1190  struct kvec *iov_p = &cmd->iov_data[iov_off++];
1191 
1192  tx_sent = tx_data(conn, iov_p, 1, cmd->padding);
1193  if (cmd->padding != tx_sent) {
1194  if (tx_sent == -EAGAIN) {
1195  pr_err("tx_data() returned -EAGAIN\n");
1196  goto send_padding;
1197  }
1198  return -1;
1199  }
1200  }
1201 
1202 send_datacrc:
1203  if (conn->conn_ops->DataDigest) {
1204  struct kvec *iov_d = &cmd->iov_data[iov_off];
1205 
1206  tx_sent = tx_data(conn, iov_d, 1, ISCSI_CRC_LEN);
1207  if (ISCSI_CRC_LEN != tx_sent) {
1208  if (tx_sent == -EAGAIN) {
1209  pr_err("tx_data() returned -EAGAIN\n");
1210  goto send_datacrc;
1211  }
1212  return -1;
1213  }
1214  }
1215 
1216  return 0;
1217 }
1218 
1219 /*
1220  * This function is used for mainly sending a ISCSI_TARG_LOGIN_RSP PDU
1221  * back to the Initiator when an expection condition occurs with the
1222  * errors set in status_class and status_detail.
1223  *
1224  * Parameters: iSCSI Connection, Status Class, Status Detail.
1225  * Returns: 0 on success, -1 on error.
1226  */
1227 int iscsit_tx_login_rsp(struct iscsi_conn *conn, u8 status_class, u8 status_detail)
1228 {
1230  int err;
1231  struct kvec iov;
1232  struct iscsi_login_rsp *hdr;
1233 
1234  iscsit_collect_login_stats(conn, status_class, status_detail);
1235 
1236  memset(&iov, 0, sizeof(struct kvec));
1237  memset(&iscsi_hdr, 0x0, ISCSI_HDR_LEN);
1238 
1239  hdr = (struct iscsi_login_rsp *)&iscsi_hdr;
1240  hdr->opcode = ISCSI_OP_LOGIN_RSP;
1241  hdr->status_class = status_class;
1243  hdr->itt = conn->login_itt;
1244 
1245  iov.iov_base = &iscsi_hdr;
1246  iov.iov_len = ISCSI_HDR_LEN;
1247 
1248  PRINT_BUFF(iscsi_hdr, ISCSI_HDR_LEN);
1249 
1250  err = tx_data(conn, &iov, 1, ISCSI_HDR_LEN);
1251  if (err != ISCSI_HDR_LEN) {
1252  pr_err("tx_data returned less than expected\n");
1253  return -1;
1254  }
1255 
1256  return 0;
1257 }
1258 
1260 {
1261  struct iscsi_conn *conn;
1262 
1263  pr_debug("-----------------------------[Session Params for"
1264  " SID: %u]-----------------------------\n", sess->sid);
1265  spin_lock_bh(&sess->conn_lock);
1268  spin_unlock_bh(&sess->conn_lock);
1269 
1271 }
1272 
1273 static int iscsit_do_rx_data(
1274  struct iscsi_conn *conn,
1275  struct iscsi_data_count *count)
1276 {
1277  int data = count->data_length, rx_loop = 0, total_rx = 0, iov_len;
1278  struct kvec *iov_p;
1279  struct msghdr msg;
1280 
1281  if (!conn || !conn->sock || !conn->conn_ops)
1282  return -1;
1283 
1284  memset(&msg, 0, sizeof(struct msghdr));
1285 
1286  iov_p = count->iov;
1287  iov_len = count->iov_count;
1288 
1289  while (total_rx < data) {
1290  rx_loop = kernel_recvmsg(conn->sock, &msg, iov_p, iov_len,
1291  (data - total_rx), MSG_WAITALL);
1292  if (rx_loop <= 0) {
1293  pr_debug("rx_loop: %d total_rx: %d\n",
1294  rx_loop, total_rx);
1295  return rx_loop;
1296  }
1297  total_rx += rx_loop;
1298  pr_debug("rx_loop: %d, total_rx: %d, data: %d\n",
1299  rx_loop, total_rx, data);
1300  }
1301 
1302  return total_rx;
1303 }
1304 
1305 static int iscsit_do_tx_data(
1306  struct iscsi_conn *conn,
1307  struct iscsi_data_count *count)
1308 {
1309  int data = count->data_length, total_tx = 0, tx_loop = 0, iov_len;
1310  struct kvec *iov_p;
1311  struct msghdr msg;
1312 
1313  if (!conn || !conn->sock || !conn->conn_ops)
1314  return -1;
1315 
1316  if (data <= 0) {
1317  pr_err("Data length is: %d\n", data);
1318  return -1;
1319  }
1320 
1321  memset(&msg, 0, sizeof(struct msghdr));
1322 
1323  iov_p = count->iov;
1324  iov_len = count->iov_count;
1325 
1326  while (total_tx < data) {
1327  tx_loop = kernel_sendmsg(conn->sock, &msg, iov_p, iov_len,
1328  (data - total_tx));
1329  if (tx_loop <= 0) {
1330  pr_debug("tx_loop: %d total_tx %d\n",
1331  tx_loop, total_tx);
1332  return tx_loop;
1333  }
1334  total_tx += tx_loop;
1335  pr_debug("tx_loop: %d, total_tx: %d, data: %d\n",
1336  tx_loop, total_tx, data);
1337  }
1338 
1339  return total_tx;
1340 }
1341 
1343  struct iscsi_conn *conn,
1344  struct kvec *iov,
1345  int iov_count,
1346  int data)
1347 {
1348  struct iscsi_data_count c;
1349 
1350  if (!conn || !conn->sock || !conn->conn_ops)
1351  return -1;
1352 
1353  memset(&c, 0, sizeof(struct iscsi_data_count));
1354  c.iov = iov;
1355  c.iov_count = iov_count;
1356  c.data_length = data;
1357  c.type = ISCSI_RX_DATA;
1358 
1359  return iscsit_do_rx_data(conn, &c);
1360 }
1361 
1363  struct iscsi_conn *conn,
1364  struct kvec *iov,
1365  int iov_count,
1366  int data)
1367 {
1368  struct iscsi_data_count c;
1369 
1370  if (!conn || !conn->sock || !conn->conn_ops)
1371  return -1;
1372 
1373  memset(&c, 0, sizeof(struct iscsi_data_count));
1374  c.iov = iov;
1375  c.iov_count = iov_count;
1376  c.data_length = data;
1377  c.type = ISCSI_TX_DATA;
1378 
1379  return iscsit_do_tx_data(conn, &c);
1380 }
1381 
1383  struct iscsi_conn *conn,
1384  u8 status_class,
1385  u8 status_detail)
1386 {
1387  struct iscsi_param *intrname = NULL;
1388  struct iscsi_tiqn *tiqn;
1389  struct iscsi_login_stats *ls;
1390 
1391  tiqn = iscsit_snmp_get_tiqn(conn);
1392  if (!tiqn)
1393  return;
1394 
1395  ls = &tiqn->login_stats;
1396 
1397  spin_lock(&ls->lock);
1398  if (!strcmp(conn->login_ip, ls->last_intr_fail_ip_addr) &&
1399  ((get_jiffies_64() - ls->last_fail_time) < 10)) {
1400  /* We already have the failure info for this login */
1401  spin_unlock(&ls->lock);
1402  return;
1403  }
1404 
1405  if (status_class == ISCSI_STATUS_CLS_SUCCESS)
1406  ls->accepts++;
1407  else if (status_class == ISCSI_STATUS_CLS_REDIRECT) {
1408  ls->redirects++;
1410  } else if ((status_class == ISCSI_STATUS_CLS_INITIATOR_ERR) &&
1411  (status_detail == ISCSI_LOGIN_STATUS_AUTH_FAILED)) {
1412  ls->authenticate_fails++;
1414  } else if ((status_class == ISCSI_STATUS_CLS_INITIATOR_ERR) &&
1415  (status_detail == ISCSI_LOGIN_STATUS_TGT_FORBIDDEN)) {
1416  ls->authorize_fails++;
1418  } else if ((status_class == ISCSI_STATUS_CLS_INITIATOR_ERR) &&
1419  (status_detail == ISCSI_LOGIN_STATUS_INIT_ERR)) {
1420  ls->negotiate_fails++;
1422  } else {
1423  ls->other_fails++;
1425  }
1426 
1427  /* Save initiator name, ip address and time, if it is a failed login */
1428  if (status_class != ISCSI_STATUS_CLS_SUCCESS) {
1429  if (conn->param_list)
1431  conn->param_list);
1433  (intrname ? intrname->value : "Unknown"));
1434 
1435  ls->last_intr_fail_ip_family = conn->sock->sk->sk_family;
1437  "%s", conn->login_ip);
1439  }
1440 
1441  spin_unlock(&ls->lock);
1442 }
1443 
1445 {
1446  struct iscsi_portal_group *tpg;
1447 
1448  if (!conn || !conn->sess)
1449  return NULL;
1450 
1451  tpg = conn->sess->tpg;
1452  if (!tpg)
1453  return NULL;
1454 
1455  if (!tpg->tpg_tiqn)
1456  return NULL;
1457 
1458  return tpg->tpg_tiqn;
1459 }