aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/scsi/iscsi_tcp.c
diff options
context:
space:
mode:
authorMike Christie <michaelc@cs.wisc.edu>2006-04-06 22:13:39 -0400
committerJames Bottomley <jejb@mulgrave.il.steeleye.com>2006-04-14 15:05:09 -0400
commit30a6c65236f9d26e3325cae468f330b833a3878c (patch)
tree355519ccc74d4b3984c06d7dcb5852282e47c845 /drivers/scsi/iscsi_tcp.c
parentfd7255f51a13ea915099c7e488001dfbbeb05104 (diff)
[SCSI] iscsi: fix up iscsi eh
The current iscsi_tcp eh is not nicely setup for dm-multipath and performs some extra task management functions when they are not needed. The attached patch: - Fixes the TMF issues. If a session is rebuilt then we do not send aborts. - Fixes the problem where if the host reset fired, we would return SUCCESS even though we had not really done anything yet. This ends up causing problem with scsi_error.c's TUR. - If someone has turned on the userspace nop daemon code to try and detect network problems before the scsi command timeout we can now drop and clean up the session before the scsi command timesout and fires the eh speeding up the time it takes for a command to go from one patch to another. For network problems we fail the command with DID_BUS_BUSY so if failfast is set scsi_decide_disposition fails the command up to dm for it to try on another path. - And we had to add some basic iscsi session block code. Previously if we were trying to repair a session we would retrun a MLQUEUE code in the queuecommand. This worked but it was not the most efficient or pretty thing to do since it would take a while to relogin to the target. For iscsi_tcp/open-iscsi a lot of the iscsi error handler is in userspace the block code is pretty bare. We will be adding to that for qla4xxx. Signed-off-by: Mike Christie <michaelc@cs.wisc.edu> Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
Diffstat (limited to 'drivers/scsi/iscsi_tcp.c')
-rw-r--r--drivers/scsi/iscsi_tcp.c659
1 files changed, 395 insertions, 264 deletions
diff --git a/drivers/scsi/iscsi_tcp.c b/drivers/scsi/iscsi_tcp.c
index 6e510f3cfbf..aca3e23b1b9 100644
--- a/drivers/scsi/iscsi_tcp.c
+++ b/drivers/scsi/iscsi_tcp.c
@@ -82,6 +82,9 @@ module_param_named(max_lun, iscsi_max_lun, uint, S_IRUGO);
82/* global data */ 82/* global data */
83static kmem_cache_t *taskcache; 83static kmem_cache_t *taskcache;
84 84
85#define session_to_cls(_sess) \
86 hostdata_session(_sess->host->hostdata)
87
85static inline void 88static inline void
86iscsi_buf_init_virt(struct iscsi_buf *ibuf, char *vbuf, int size) 89iscsi_buf_init_virt(struct iscsi_buf *ibuf, char *vbuf, int size)
87{ 90{
@@ -230,17 +233,19 @@ iscsi_hdr_extract(struct iscsi_conn *conn)
230 return 0; 233 return 0;
231} 234}
232 235
233static inline void 236/*
234iscsi_ctask_cleanup(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask) 237 * must be called with session lock
238 */
239static void
240__iscsi_ctask_cleanup(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
235{ 241{
236 struct scsi_cmnd *sc = ctask->sc;
237 struct iscsi_session *session = conn->session; 242 struct iscsi_session *session = conn->session;
243 struct scsi_cmnd *sc;
238 244
239 spin_lock(&session->lock); 245 sc = ctask->sc;
240 if (unlikely(!sc)) { 246 if (unlikely(!sc))
241 spin_unlock(&session->lock);
242 return; 247 return;
243 } 248
244 if (sc->sc_data_direction == DMA_TO_DEVICE) { 249 if (sc->sc_data_direction == DMA_TO_DEVICE) {
245 struct iscsi_data_task *dtask, *n; 250 struct iscsi_data_task *dtask, *n;
246 /* WRITE: cleanup Data-Out's if any */ 251 /* WRITE: cleanup Data-Out's if any */
@@ -252,7 +257,20 @@ iscsi_ctask_cleanup(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
252 ctask->xmstate = XMSTATE_IDLE; 257 ctask->xmstate = XMSTATE_IDLE;
253 ctask->r2t = NULL; 258 ctask->r2t = NULL;
254 ctask->sc = NULL; 259 ctask->sc = NULL;
260 list_del(&ctask->running);
261
255 __kfifo_put(session->cmdpool.queue, (void*)&ctask, sizeof(void*)); 262 __kfifo_put(session->cmdpool.queue, (void*)&ctask, sizeof(void*));
263
264 sc->scsi_done(sc);
265}
266
267static void
268iscsi_ctask_cleanup(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
269{
270 struct iscsi_session *session = conn->session;
271
272 spin_lock(&session->lock);
273 __iscsi_ctask_cleanup(conn, ctask);
256 spin_unlock(&session->lock); 274 spin_unlock(&session->lock);
257} 275}
258 276
@@ -311,7 +329,6 @@ out:
311 (long)sc, sc->result, ctask->itt); 329 (long)sc, sc->result, ctask->itt);
312 conn->scsirsp_pdus_cnt++; 330 conn->scsirsp_pdus_cnt++;
313 iscsi_ctask_cleanup(conn, ctask); 331 iscsi_ctask_cleanup(conn, ctask);
314 sc->scsi_done(sc);
315 return rc; 332 return rc;
316} 333}
317 334
@@ -395,6 +412,7 @@ iscsi_solicit_data_init(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask,
395 412
396 dtask = mempool_alloc(ctask->datapool, GFP_ATOMIC); 413 dtask = mempool_alloc(ctask->datapool, GFP_ATOMIC);
397 BUG_ON(!dtask); 414 BUG_ON(!dtask);
415 INIT_LIST_HEAD(&dtask->item);
398 hdr = &dtask->hdr; 416 hdr = &dtask->hdr;
399 memset(hdr, 0, sizeof(struct iscsi_data)); 417 memset(hdr, 0, sizeof(struct iscsi_data));
400 hdr->ttt = r2t->ttt; 418 hdr->ttt = r2t->ttt;
@@ -710,8 +728,6 @@ iscsi_hdr_recv(struct iscsi_conn *conn)
710 conn->tmfrsp_pdus_cnt++; 728 conn->tmfrsp_pdus_cnt++;
711 spin_lock(&session->lock); 729 spin_lock(&session->lock);
712 if (conn->tmabort_state == TMABORT_INITIAL) { 730 if (conn->tmabort_state == TMABORT_INITIAL) {
713 __kfifo_put(session->mgmtpool.queue,
714 (void*)&mtask, sizeof(void*));
715 conn->tmabort_state = 731 conn->tmabort_state =
716 ((struct iscsi_tm_rsp *)hdr)-> 732 ((struct iscsi_tm_rsp *)hdr)->
717 response == ISCSI_TMF_RSP_COMPLETE ? 733 response == ISCSI_TMF_RSP_COMPLETE ?
@@ -986,7 +1002,6 @@ done:
986 (long)sc, sc->result, ctask->itt); 1002 (long)sc, sc->result, ctask->itt);
987 conn->scsirsp_pdus_cnt++; 1003 conn->scsirsp_pdus_cnt++;
988 iscsi_ctask_cleanup(conn, ctask); 1004 iscsi_ctask_cleanup(conn, ctask);
989 sc->scsi_done(sc);
990 } 1005 }
991 1006
992 return rc; 1007 return rc;
@@ -1460,6 +1475,7 @@ iscsi_solicit_data_cont(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask,
1460 1475
1461 dtask = mempool_alloc(ctask->datapool, GFP_ATOMIC); 1476 dtask = mempool_alloc(ctask->datapool, GFP_ATOMIC);
1462 BUG_ON(!dtask); 1477 BUG_ON(!dtask);
1478 INIT_LIST_HEAD(&dtask->item);
1463 hdr = &dtask->hdr; 1479 hdr = &dtask->hdr;
1464 memset(hdr, 0, sizeof(struct iscsi_data)); 1480 memset(hdr, 0, sizeof(struct iscsi_data));
1465 hdr->ttt = r2t->ttt; 1481 hdr->ttt = r2t->ttt;
@@ -1506,6 +1522,7 @@ iscsi_unsolicit_data_init(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
1506 1522
1507 dtask = mempool_alloc(ctask->datapool, GFP_ATOMIC); 1523 dtask = mempool_alloc(ctask->datapool, GFP_ATOMIC);
1508 BUG_ON(!dtask); 1524 BUG_ON(!dtask);
1525 INIT_LIST_HEAD(&dtask->item);
1509 hdr = &dtask->hdr; 1526 hdr = &dtask->hdr;
1510 memset(hdr, 0, sizeof(struct iscsi_data)); 1527 memset(hdr, 0, sizeof(struct iscsi_data));
1511 hdr->ttt = cpu_to_be32(ISCSI_RESERVED_TAG); 1528 hdr->ttt = cpu_to_be32(ISCSI_RESERVED_TAG);
@@ -1550,6 +1567,7 @@ iscsi_cmd_init(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask,
1550 1567
1551 BUG_ON(__kfifo_len(ctask->r2tqueue)); 1568 BUG_ON(__kfifo_len(ctask->r2tqueue));
1552 1569
1570 INIT_LIST_HEAD(&ctask->running);
1553 ctask->sc = sc; 1571 ctask->sc = sc;
1554 ctask->conn = conn; 1572 ctask->conn = conn;
1555 ctask->hdr.opcode = ISCSI_OP_SCSI_CMD; 1573 ctask->hdr.opcode = ISCSI_OP_SCSI_CMD;
@@ -1680,7 +1698,7 @@ iscsi_mtask_xmit(struct iscsi_conn *conn, struct iscsi_mgmt_task *mtask)
1680 if (mtask->data_count) 1698 if (mtask->data_count)
1681 mtask->xmstate |= XMSTATE_IMM_DATA; 1699 mtask->xmstate |= XMSTATE_IMM_DATA;
1682 if (conn->c_stage != ISCSI_CONN_INITIAL_STAGE && 1700 if (conn->c_stage != ISCSI_CONN_INITIAL_STAGE &&
1683 conn->stop_stage != STOP_CONN_RECOVER && 1701 conn->stop_stage != STOP_CONN_RECOVER &&
1684 conn->hdrdgst_en) 1702 conn->hdrdgst_en)
1685 iscsi_hdr_digest(conn, &mtask->headbuf, 1703 iscsi_hdr_digest(conn, &mtask->headbuf,
1686 (u8*)mtask->hdrext); 1704 (u8*)mtask->hdrext);
@@ -2226,6 +2244,7 @@ iscsi_data_xmit(struct iscsi_conn *conn)
2226 /* process command queue */ 2244 /* process command queue */
2227 while (__kfifo_get(conn->xmitqueue, (void*)&conn->ctask, 2245 while (__kfifo_get(conn->xmitqueue, (void*)&conn->ctask,
2228 sizeof(void*))) { 2246 sizeof(void*))) {
2247 list_add_tail(&conn->ctask->running, &conn->run_list);
2229 if (iscsi_ctask_xmit(conn, conn->ctask)) 2248 if (iscsi_ctask_xmit(conn, conn->ctask))
2230 goto again; 2249 goto again;
2231 } 2250 }
@@ -2277,11 +2296,14 @@ iscsi_xmitworker(void *data)
2277 mutex_unlock(&conn->xmitmutex); 2296 mutex_unlock(&conn->xmitmutex);
2278} 2297}
2279 2298
2280#define FAILURE_BAD_HOST 1 2299enum {
2281#define FAILURE_SESSION_FAILED 2 2300 FAILURE_BAD_HOST = 1,
2282#define FAILURE_SESSION_FREED 3 2301 FAILURE_SESSION_FAILED,
2283#define FAILURE_WINDOW_CLOSED 4 2302 FAILURE_SESSION_FREED,
2284#define FAILURE_SESSION_TERMINATE 5 2303 FAILURE_WINDOW_CLOSED,
2304 FAILURE_SESSION_TERMINATE,
2305 FAILURE_SESSION_RECOVERY_TIMEOUT,
2306};
2285 2307
2286static int 2308static int
2287iscsi_queuecommand(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *)) 2309iscsi_queuecommand(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *))
@@ -2297,12 +2319,14 @@ iscsi_queuecommand(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *))
2297 2319
2298 host = sc->device->host; 2320 host = sc->device->host;
2299 session = iscsi_hostdata(host->hostdata); 2321 session = iscsi_hostdata(host->hostdata);
2300 BUG_ON(host != session->host);
2301 2322
2302 spin_lock(&session->lock); 2323 spin_lock(&session->lock);
2303 2324
2304 if (session->state != ISCSI_STATE_LOGGED_IN) { 2325 if (session->state != ISCSI_STATE_LOGGED_IN) {
2305 if (session->state == ISCSI_STATE_FAILED) { 2326 if (session->recovery_failed) {
2327 reason = FAILURE_SESSION_RECOVERY_TIMEOUT;
2328 goto fault;
2329 } else if (session->state == ISCSI_STATE_FAILED) {
2306 reason = FAILURE_SESSION_FAILED; 2330 reason = FAILURE_SESSION_FAILED;
2307 goto reject; 2331 goto reject;
2308 } else if (session->state == ISCSI_STATE_TERMINATE) { 2332 } else if (session->state == ISCSI_STATE_TERMINATE) {
@@ -2350,11 +2374,6 @@ fault:
2350 spin_unlock(&session->lock); 2374 spin_unlock(&session->lock);
2351 printk(KERN_ERR "iscsi_tcp: cmd 0x%x is not queued (%d)\n", 2375 printk(KERN_ERR "iscsi_tcp: cmd 0x%x is not queued (%d)\n",
2352 sc->cmnd[0], reason); 2376 sc->cmnd[0], reason);
2353 sc->sense_buffer[0] = 0x70;
2354 sc->sense_buffer[2] = NOT_READY;
2355 sc->sense_buffer[7] = 0x6;
2356 sc->sense_buffer[12] = 0x08;
2357 sc->sense_buffer[13] = 0x00;
2358 sc->result = (DID_NO_CONNECT << 16); 2377 sc->result = (DID_NO_CONNECT << 16);
2359 sc->resid = sc->request_bufflen; 2378 sc->resid = sc->request_bufflen;
2360 sc->scsi_done(sc); 2379 sc->scsi_done(sc);
@@ -2445,6 +2464,7 @@ iscsi_conn_create(struct iscsi_cls_session *cls_session, uint32_t conn_idx)
2445 conn->id = conn_idx; 2464 conn->id = conn_idx;
2446 conn->exp_statsn = 0; 2465 conn->exp_statsn = 0;
2447 conn->tmabort_state = TMABORT_INITIAL; 2466 conn->tmabort_state = TMABORT_INITIAL;
2467 INIT_LIST_HEAD(&conn->run_list);
2448 2468
2449 /* initial operational parameters */ 2469 /* initial operational parameters */
2450 conn->hdr_size = sizeof(struct iscsi_hdr); 2470 conn->hdr_size = sizeof(struct iscsi_hdr);
@@ -2701,6 +2721,22 @@ iscsi_conn_bind(struct iscsi_cls_session *cls_session,
2701 return 0; 2721 return 0;
2702} 2722}
2703 2723
2724static void
2725iscsi_session_recovery_timedout(struct iscsi_cls_session *csession)
2726{
2727 struct Scsi_Host *shost = iscsi_session_to_shost(csession);
2728 struct iscsi_session *session = iscsi_hostdata(shost->hostdata);
2729 struct iscsi_conn *conn = session->leadconn;
2730
2731 spin_lock_bh(&session->lock);
2732 if (session->state != ISCSI_STATE_LOGGED_IN) {
2733 session->recovery_failed = 1;
2734 if (conn)
2735 wake_up(&conn->ehwait);
2736 }
2737 spin_unlock_bh(&session->lock);
2738}
2739
2704static int 2740static int
2705iscsi_conn_start(struct iscsi_cls_conn *cls_conn) 2741iscsi_conn_start(struct iscsi_cls_conn *cls_conn)
2706{ 2742{
@@ -2716,7 +2752,6 @@ iscsi_conn_start(struct iscsi_cls_conn *cls_conn)
2716 } 2752 }
2717 2753
2718 sk = conn->sock->sk; 2754 sk = conn->sock->sk;
2719
2720 write_lock_bh(&sk->sk_callback_lock); 2755 write_lock_bh(&sk->sk_callback_lock);
2721 spin_lock_bh(&session->lock); 2756 spin_lock_bh(&session->lock);
2722 conn->c_stage = ISCSI_CONN_STARTED; 2757 conn->c_stage = ISCSI_CONN_STARTED;
@@ -2732,8 +2767,13 @@ iscsi_conn_start(struct iscsi_cls_conn *cls_conn)
2732 conn->stop_stage = 0; 2767 conn->stop_stage = 0;
2733 conn->tmabort_state = TMABORT_INITIAL; 2768 conn->tmabort_state = TMABORT_INITIAL;
2734 session->age++; 2769 session->age++;
2770 session->recovery_failed = 0;
2771 spin_unlock_bh(&session->lock);
2772 write_unlock_bh(&sk->sk_callback_lock);
2773
2774 iscsi_unblock_session(session_to_cls(session));
2735 wake_up(&conn->ehwait); 2775 wake_up(&conn->ehwait);
2736 break; 2776 return 0;
2737 case STOP_CONN_TERM: 2777 case STOP_CONN_TERM:
2738 session->conn_cnt++; 2778 session->conn_cnt++;
2739 conn->stop_stage = 0; 2779 conn->stop_stage = 0;
@@ -2752,105 +2792,199 @@ iscsi_conn_start(struct iscsi_cls_conn *cls_conn)
2752 return 0; 2792 return 0;
2753} 2793}
2754 2794
2755static void 2795static int
2756iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag) 2796iscsi_ctask_mtask_cleanup(struct iscsi_cmd_task *ctask)
2757{ 2797{
2758 struct iscsi_conn *conn = cls_conn->dd_data; 2798 struct iscsi_conn *conn = ctask->conn;
2759 struct iscsi_session *session = conn->session; 2799 struct iscsi_session *session = conn->session;
2800 struct iscsi_mgmt_task *mtask;
2801
2802 if (!ctask->mtask)
2803 return -EINVAL;
2804
2805 while (__kfifo_get(conn->immqueue, (void*)&mtask, sizeof(void*))) {
2806 if (mtask == ctask->mtask)
2807 break;
2808 __kfifo_put(conn->immqueue, (void*)&mtask, sizeof(void*));
2809 }
2810
2811 __kfifo_put(session->mgmtpool.queue, (void*)&ctask->mtask,
2812 sizeof(void*));
2813 ctask->mtask = NULL;
2814 return 0;
2815}
2816
2817static void
2818fail_command(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask, int err)
2819{
2820 struct iscsi_r2t_info *r2t;
2821 struct scsi_cmnd *sc;
2822
2823 /* flush ctask's r2t queues */
2824 while (__kfifo_get(ctask->r2tqueue, (void*)&r2t, sizeof(void*)))
2825 __kfifo_put(ctask->r2tpool.queue, (void*)&r2t, sizeof(void*));
2826
2827 iscsi_ctask_mtask_cleanup(ctask);
2828
2829 sc = ctask->sc;
2830 if (!sc)
2831 return;
2832
2833 sc->result = err;
2834 sc->resid = sc->request_bufflen;
2835
2836 __iscsi_ctask_cleanup(conn, ctask);
2837}
2838
2839/* Fail commands. Mutex and session lock held */
2840static void
2841fail_all_commands(struct iscsi_session *session, struct iscsi_conn *conn)
2842{
2843 struct iscsi_cmd_task *ctask, *tmp;
2844
2845 /* flush pending */
2846 while (__kfifo_get(conn->xmitqueue, (void*)&ctask, sizeof(void*))) {
2847 debug_scsi("failing pending sc %p itt 0x%x\n", ctask->sc,
2848 ctask->itt);
2849 fail_command(conn, ctask, DID_BUS_BUSY << 16);
2850 }
2851
2852 /* fail running */
2853 list_for_each_entry_safe(ctask, tmp, &conn->run_list, running) {
2854 debug_scsi("failing in progress sc %p itt 0x%x\n",
2855 ctask->sc, ctask->itt);
2856 fail_command(conn, ctask, DID_BUS_BUSY << 16);
2857 }
2858
2859 conn->ctask = NULL;
2860}
2861
2862static void
2863flush_control_queues(struct iscsi_session *session, struct iscsi_conn *conn)
2864{
2865 struct iscsi_mgmt_task *mtask;
2866
2867 /* TODO: handle running pdus */
2868 while (__kfifo_get(conn->immqueue, (void*)&mtask, sizeof(void*)) ||
2869 __kfifo_get(conn->mgmtqueue, (void*)&mtask, sizeof(void*))) {
2870 if (mtask == conn->login_mtask)
2871 continue;
2872 __kfifo_put(session->mgmtpool.queue, (void*)&mtask,
2873 sizeof(void*));
2874 }
2875
2876 if (conn->mtask && conn->mtask != conn->login_mtask)
2877 __kfifo_put(session->mgmtpool.queue, (void*)&conn->mtask,
2878 sizeof(void*));
2879 conn->mtask = NULL;
2880}
2881
2882static void
2883iscsi_suspend_conn_rx(struct iscsi_conn *conn)
2884{
2760 struct sock *sk; 2885 struct sock *sk;
2761 unsigned long flags;
2762 2886
2763 BUG_ON(!conn->sock); 2887 BUG_ON(!conn->sock);
2764 sk = conn->sock->sk; 2888 sk = conn->sock->sk;
2765 write_lock_bh(&sk->sk_callback_lock); 2889 write_lock_bh(&sk->sk_callback_lock);
2766 set_bit(SUSPEND_BIT, &conn->suspend_rx); 2890 set_bit(SUSPEND_BIT, &conn->suspend_rx);
2767 write_unlock_bh(&sk->sk_callback_lock); 2891 write_unlock_bh(&sk->sk_callback_lock);
2892}
2768 2893
2769 mutex_lock(&conn->xmitmutex); 2894static void
2770 2895iscsi_start_session_recovery(struct iscsi_session *session,
2771 spin_lock_irqsave(session->host->host_lock, flags); 2896 struct iscsi_conn *conn, int flag)
2772 spin_lock(&session->lock); 2897{
2898 spin_lock_bh(&session->lock);
2899 if (conn->stop_stage == STOP_CONN_RECOVER ||
2900 conn->stop_stage == STOP_CONN_TERM) {
2901 spin_unlock_bh(&session->lock);
2902 return;
2903 }
2773 conn->stop_stage = flag; 2904 conn->stop_stage = flag;
2905 spin_unlock_bh(&session->lock);
2906
2907 iscsi_suspend_conn_rx(conn);
2908
2909 mutex_lock(&conn->xmitmutex);
2910 spin_lock_bh(&session->lock);
2774 conn->c_stage = ISCSI_CONN_STOPPED; 2911 conn->c_stage = ISCSI_CONN_STOPPED;
2775 set_bit(SUSPEND_BIT, &conn->suspend_tx); 2912 set_bit(SUSPEND_BIT, &conn->suspend_tx);
2776 2913
2777 if (flag != STOP_CONN_SUSPEND) 2914 session->conn_cnt--;
2778 session->conn_cnt--;
2779
2780 if (session->conn_cnt == 0 || session->leadconn == conn) 2915 if (session->conn_cnt == 0 || session->leadconn == conn)
2781 session->state = ISCSI_STATE_FAILED; 2916 session->state = ISCSI_STATE_FAILED;
2782 2917
2783 spin_unlock(&session->lock); 2918 spin_unlock_bh(&session->lock);
2784 spin_unlock_irqrestore(session->host->host_lock, flags);
2785
2786 if (flag == STOP_CONN_TERM || flag == STOP_CONN_RECOVER) {
2787 struct iscsi_cmd_task *ctask;
2788 struct iscsi_mgmt_task *mtask;
2789 2919
2790 /* 2920 /*
2791 * Socket must go now. 2921 * Socket must go now.
2792 */ 2922 */
2793 sock_hold(conn->sock->sk); 2923 sock_hold(conn->sock->sk);
2794 iscsi_conn_restore_callbacks(conn); 2924 iscsi_conn_restore_callbacks(conn);
2795 sock_put(conn->sock->sk); 2925 sock_put(conn->sock->sk);
2796 2926
2797 /* 2927 /*
2798 * flush xmit queues. 2928 * flush queues.
2799 */ 2929 */
2800 spin_lock_bh(&session->lock); 2930 spin_lock_bh(&session->lock);
2801 while (__kfifo_get(conn->writequeue, (void*)&ctask, 2931 fail_all_commands(session, conn);
2802 sizeof(void*)) || 2932 flush_control_queues(session, conn);
2803 __kfifo_get(conn->xmitqueue, (void*)&ctask, 2933 spin_unlock_bh(&session->lock);
2804 sizeof(void*))) {
2805 struct iscsi_r2t_info *r2t;
2806
2807 /*
2808 * flush ctask's r2t queues
2809 */
2810 while (__kfifo_get(ctask->r2tqueue, (void*)&r2t,
2811 sizeof(void*)))
2812 __kfifo_put(ctask->r2tpool.queue, (void*)&r2t,
2813 sizeof(void*));
2814 2934
2815 spin_unlock_bh(&session->lock); 2935 /*
2816 local_bh_disable(); 2936 * release socket only after we stopped data_xmit()
2817 iscsi_ctask_cleanup(conn, ctask); 2937 * activity and flushed all outstandings
2818 local_bh_enable(); 2938 */
2819 spin_lock_bh(&session->lock); 2939 sock_release(conn->sock);
2820 } 2940 conn->sock = NULL;
2821 conn->ctask = NULL;
2822 while (__kfifo_get(conn->immqueue, (void*)&mtask,
2823 sizeof(void*)) ||
2824 __kfifo_get(conn->mgmtqueue, (void*)&mtask,
2825 sizeof(void*))) {
2826 __kfifo_put(session->mgmtpool.queue,
2827 (void*)&mtask, sizeof(void*));
2828 }
2829 conn->mtask = NULL;
2830 spin_unlock_bh(&session->lock);
2831 2941
2832 /* 2942 /*
2833 * release socket only after we stopped data_xmit() 2943 * for connection level recovery we should not calculate
2834 * activity and flushed all outstandings 2944 * header digest. conn->hdr_size used for optimization
2835 */ 2945 * in hdr_extract() and will be re-negotiated at
2836 sock_release(conn->sock); 2946 * set_param() time.
2837 conn->sock = NULL; 2947 */
2948 if (flag == STOP_CONN_RECOVER) {
2949 conn->hdr_size = sizeof(struct iscsi_hdr);
2950 conn->hdrdgst_en = 0;
2951 conn->datadgst_en = 0;
2838 2952
2839 /* 2953 if (session->state == ISCSI_STATE_FAILED)
2840 * for connection level recovery we should not calculate 2954 iscsi_block_session(session_to_cls(session));
2841 * header digest. conn->hdr_size used for optimization
2842 * in hdr_extract() and will be re-negotiated at
2843 * set_param() time.
2844 */
2845 if (flag == STOP_CONN_RECOVER) {
2846 conn->hdr_size = sizeof(struct iscsi_hdr);
2847 conn->hdrdgst_en = 0;
2848 conn->datadgst_en = 0;
2849 }
2850 } 2955 }
2851 mutex_unlock(&conn->xmitmutex); 2956 mutex_unlock(&conn->xmitmutex);
2852} 2957}
2853 2958
2959static void
2960iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag)
2961{
2962 struct iscsi_conn *conn = cls_conn->dd_data;
2963 struct iscsi_session *session = conn->session;
2964
2965 switch (flag) {
2966 case STOP_CONN_RECOVER:
2967 case STOP_CONN_TERM:
2968 iscsi_start_session_recovery(session, conn, flag);
2969 return;
2970 case STOP_CONN_SUSPEND:
2971 iscsi_suspend_conn_rx(conn);
2972
2973 mutex_lock(&conn->xmitmutex);
2974 spin_lock_bh(&session->lock);
2975
2976 conn->stop_stage = flag;
2977 conn->c_stage = ISCSI_CONN_STOPPED;
2978 set_bit(SUSPEND_BIT, &conn->suspend_tx);
2979
2980 spin_unlock_bh(&session->lock);
2981 mutex_unlock(&conn->xmitmutex);
2982 break;
2983 default:
2984 printk(KERN_ERR "invalid stop flag %d\n", flag);
2985 }
2986}
2987
2854static int 2988static int
2855iscsi_conn_send_generic(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 2989iscsi_conn_send_generic(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
2856 char *data, uint32_t data_size) 2990 char *data, uint32_t data_size)
@@ -2940,23 +3074,54 @@ iscsi_conn_send_generic(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
2940static int 3074static int
2941iscsi_eh_host_reset(struct scsi_cmnd *sc) 3075iscsi_eh_host_reset(struct scsi_cmnd *sc)
2942{ 3076{
2943 struct iscsi_cmd_task *ctask = (struct iscsi_cmd_task *)sc->SCp.ptr; 3077 struct Scsi_Host *host = sc->device->host;
2944 struct iscsi_conn *conn = ctask->conn; 3078 struct iscsi_session *session = iscsi_hostdata(host->hostdata);
2945 struct iscsi_session *session = conn->session; 3079 struct iscsi_conn *conn = session->leadconn;
3080 int fail_session = 0;
2946 3081
2947 spin_lock_bh(&session->lock); 3082 spin_lock_bh(&session->lock);
2948 if (session->state == ISCSI_STATE_TERMINATE) { 3083 if (session->state == ISCSI_STATE_TERMINATE) {
3084failed:
2949 debug_scsi("failing host reset: session terminated " 3085 debug_scsi("failing host reset: session terminated "
2950 "[CID %d age %d]", conn->id, session->age); 3086 "[CID %d age %d]", conn->id, session->age);
2951 spin_unlock_bh(&session->lock); 3087 spin_unlock_bh(&session->lock);
2952 return FAILED; 3088 return FAILED;
2953 } 3089 }
3090
3091 if (sc->SCp.phase == session->age) {
3092 debug_scsi("failing connection CID %d due to SCSI host reset",
3093 conn->id);
3094 fail_session = 1;
3095 }
2954 spin_unlock_bh(&session->lock); 3096 spin_unlock_bh(&session->lock);
2955 3097
2956 debug_scsi("failing connection CID %d due to SCSI host reset " 3098 /*
2957 "[itt 0x%x age %d]", conn->id, ctask->itt, 3099 * we drop the lock here but the leadconn cannot be destoyed while
2958 session->age); 3100 * we are in the scsi eh
2959 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 3101 */
3102 if (fail_session) {
3103 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
3104 /*
3105 * if userspace cannot respond then we must kick this off
3106 * here for it
3107 */
3108 iscsi_start_session_recovery(session, conn, STOP_CONN_RECOVER);
3109 }
3110
3111 debug_scsi("iscsi_eh_host_reset wait for relogin\n");
3112 wait_event_interruptible(conn->ehwait,
3113 session->state == ISCSI_STATE_TERMINATE ||
3114 session->state == ISCSI_STATE_LOGGED_IN ||
3115 session->recovery_failed);
3116 if (signal_pending(current))
3117 flush_signals(current);
3118
3119 spin_lock_bh(&session->lock);
3120 if (session->state == ISCSI_STATE_LOGGED_IN)
3121 printk(KERN_INFO "host reset succeeded\n");
3122 else
3123 goto failed;
3124 spin_unlock_bh(&session->lock);
2960 3125
2961 return SUCCESS; 3126 return SUCCESS;
2962} 3127}
@@ -2970,8 +3135,6 @@ iscsi_tmabort_timedout(unsigned long data)
2970 3135
2971 spin_lock(&session->lock); 3136 spin_lock(&session->lock);
2972 if (conn->tmabort_state == TMABORT_INITIAL) { 3137 if (conn->tmabort_state == TMABORT_INITIAL) {
2973 __kfifo_put(session->mgmtpool.queue,
2974 (void*)&ctask->mtask, sizeof(void*));
2975 conn->tmabort_state = TMABORT_TIMEDOUT; 3138 conn->tmabort_state = TMABORT_TIMEDOUT;
2976 debug_scsi("tmabort timedout [sc %lx itt 0x%x]\n", 3139 debug_scsi("tmabort timedout [sc %lx itt 0x%x]\n",
2977 (long)ctask->sc, ctask->itt); 3140 (long)ctask->sc, ctask->itt);
@@ -2981,186 +3144,163 @@ iscsi_tmabort_timedout(unsigned long data)
2981 spin_unlock(&session->lock); 3144 spin_unlock(&session->lock);
2982} 3145}
2983 3146
3147/* must be called with the mutex lock */
2984static int 3148static int
2985iscsi_eh_abort(struct scsi_cmnd *sc) 3149iscsi_exec_abort_task(struct scsi_cmnd *sc, struct iscsi_cmd_task *ctask)
2986{ 3150{
2987 int rc;
2988 struct iscsi_cmd_task *ctask = (struct iscsi_cmd_task *)sc->SCp.ptr;
2989 struct iscsi_conn *conn = ctask->conn; 3151 struct iscsi_conn *conn = ctask->conn;
2990 struct iscsi_session *session = conn->session; 3152 struct iscsi_session *session = conn->session;
2991 3153 struct iscsi_tm *hdr = &conn->tmhdr;
2992 conn->eh_abort_cnt++; 3154 int rc;
2993 debug_scsi("aborting [sc %lx itt 0x%x]\n", (long)sc, ctask->itt);
2994 3155
2995 /* 3156 /*
2996 * two cases for ERL=0 here: 3157 * ctask timed out but session is OK requests must be serialized.
2997 *
2998 * 1) connection-level failure;
2999 * 2) recovery due protocol error;
3000 */ 3158 */
3001 mutex_lock(&conn->xmitmutex); 3159 memset(hdr, 0, sizeof(struct iscsi_tm));
3002 spin_lock_bh(&session->lock); 3160 hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE;
3003 if (session->state != ISCSI_STATE_LOGGED_IN) { 3161 hdr->flags = ISCSI_TM_FUNC_ABORT_TASK;
3004 if (session->state == ISCSI_STATE_TERMINATE) { 3162 hdr->flags |= ISCSI_FLAG_CMD_FINAL;
3005 spin_unlock_bh(&session->lock); 3163 memcpy(hdr->lun, ctask->hdr.lun, sizeof(hdr->lun));
3006 mutex_unlock(&conn->xmitmutex); 3164 hdr->rtt = ctask->hdr.itt;
3007 goto failed; 3165 hdr->refcmdsn = ctask->hdr.cmdsn;
3008 }
3009 spin_unlock_bh(&session->lock);
3010 } else {
3011 struct iscsi_tm *hdr = &conn->tmhdr;
3012 3166
3013 /* 3167 rc = iscsi_conn_send_generic(conn, (struct iscsi_hdr *)hdr,
3014 * Still LOGGED_IN... 3168 NULL, 0);
3015 */ 3169 if (rc) {
3170 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
3171 debug_scsi("abort sent failure [itt 0x%x] %d", ctask->itt, rc);
3172 return rc;
3173 }
3016 3174
3017 if (!ctask->sc || sc->SCp.phase != session->age) { 3175 debug_scsi("abort sent [itt 0x%x]\n", ctask->itt);
3018 /*
3019 * 1) ctask completed before time out. But session
3020 * is still ok => Happy Retry.
3021 * 2) session was re-open during time out of ctask.
3022 */
3023 spin_unlock_bh(&session->lock);
3024 mutex_unlock(&conn->xmitmutex);
3025 goto success;
3026 }
3027 conn->tmabort_state = TMABORT_INITIAL;
3028 spin_unlock_bh(&session->lock);
3029 3176
3030 /* 3177 spin_lock_bh(&session->lock);
3031 * ctask timed out but session is OK 3178 ctask->mtask = (struct iscsi_mgmt_task *)
3032 * ERL=0 requires task mgmt abort to be issued on each 3179 session->mgmt_cmds[(hdr->itt & ITT_MASK) -
3033 * failed command. requests must be serialized. 3180 ISCSI_MGMT_ITT_OFFSET];
3034 */ 3181
3035 memset(hdr, 0, sizeof(struct iscsi_tm)); 3182 if (conn->tmabort_state == TMABORT_INITIAL) {
3036 hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 3183 conn->tmfcmd_pdus_cnt++;
3037 hdr->flags = ISCSI_TM_FUNC_ABORT_TASK; 3184 conn->tmabort_timer.expires = 10*HZ + jiffies;
3038 hdr->flags |= ISCSI_FLAG_CMD_FINAL; 3185 conn->tmabort_timer.function = iscsi_tmabort_timedout;
3039 memcpy(hdr->lun, ctask->hdr.lun, sizeof(hdr->lun)); 3186 conn->tmabort_timer.data = (unsigned long)ctask;
3040 hdr->rtt = ctask->hdr.itt; 3187 add_timer(&conn->tmabort_timer);
3041 hdr->refcmdsn = ctask->hdr.cmdsn; 3188 debug_scsi("abort set timeout [itt 0x%x]", ctask->itt);
3042
3043 rc = iscsi_conn_send_generic(conn, (struct iscsi_hdr *)hdr,
3044 NULL, 0);
3045 if (rc) {
3046 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
3047 debug_scsi("abort sent failure [itt 0x%x]", ctask->itt);
3048 } else {
3049 struct iscsi_r2t_info *r2t;
3050
3051 /*
3052 * TMF abort vs. TMF response race logic
3053 */
3054 spin_lock_bh(&session->lock);
3055 ctask->mtask = (struct iscsi_mgmt_task *)
3056 session->mgmt_cmds[(hdr->itt & ITT_MASK) -
3057 ISCSI_MGMT_ITT_OFFSET];
3058 /*
3059 * have to flush r2tqueue to avoid r2t leaks
3060 */
3061 while (__kfifo_get(ctask->r2tqueue, (void*)&r2t,
3062 sizeof(void*))) {
3063 __kfifo_put(ctask->r2tpool.queue, (void*)&r2t,
3064 sizeof(void*));
3065 }
3066 if (conn->tmabort_state == TMABORT_INITIAL) {
3067 conn->tmfcmd_pdus_cnt++;
3068 conn->tmabort_timer.expires = 3*HZ + jiffies;
3069 conn->tmabort_timer.function =
3070 iscsi_tmabort_timedout;
3071 conn->tmabort_timer.data = (unsigned long)ctask;
3072 add_timer(&conn->tmabort_timer);
3073 debug_scsi("abort sent [itt 0x%x]", ctask->itt);
3074 } else {
3075 if (!ctask->sc ||
3076 conn->tmabort_state == TMABORT_SUCCESS) {
3077 conn->tmabort_state = TMABORT_INITIAL;
3078 spin_unlock_bh(&session->lock);
3079 mutex_unlock(&conn->xmitmutex);
3080 goto success;
3081 }
3082 conn->tmabort_state = TMABORT_INITIAL;
3083 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
3084 }
3085 spin_unlock_bh(&session->lock);
3086 }
3087 } 3189 }
3190 spin_unlock_bh(&session->lock);
3088 mutex_unlock(&conn->xmitmutex); 3191 mutex_unlock(&conn->xmitmutex);
3089 3192
3090
3091 /* 3193 /*
3092 * block eh thread until: 3194 * block eh thread until:
3093 * 3195 *
3094 * 1) abort response; 3196 * 1) abort response
3095 * 2) abort timeout; 3197 * 2) abort timeout
3096 * 3) session re-opened; 3198 * 3) session is terminated or restarted or userspace has
3097 * 4) session terminated; 3199 * given up on recovery
3098 */ 3200 */
3099 for (;;) { 3201 wait_event_interruptible(conn->ehwait,
3100 int p_state = session->state; 3202 sc->SCp.phase != session->age ||
3101 3203 session->state != ISCSI_STATE_LOGGED_IN ||
3102 rc = wait_event_interruptible(conn->ehwait, 3204 conn->tmabort_state != TMABORT_INITIAL ||
3103 (p_state == ISCSI_STATE_LOGGED_IN ? 3205 session->recovery_failed);
3104 (session->state == ISCSI_STATE_TERMINATE || 3206 if (signal_pending(current))
3105 conn->tmabort_state != TMABORT_INITIAL) : 3207 flush_signals(current);
3106 (session->state == ISCSI_STATE_TERMINATE || 3208 del_timer_sync(&conn->tmabort_timer);
3107 session->state == ISCSI_STATE_LOGGED_IN)));
3108 if (rc) {
3109 /* shutdown.. */
3110 session->state = ISCSI_STATE_TERMINATE;
3111 goto failed;
3112 }
3113 3209
3114 if (signal_pending(current)) 3210 mutex_lock(&conn->xmitmutex);
3115 flush_signals(current); 3211 return 0;
3212}
3116 3213
3117 if (session->state == ISCSI_STATE_TERMINATE) 3214static int
3118 goto failed; 3215iscsi_eh_abort(struct scsi_cmnd *sc)
3216{
3217 struct iscsi_cmd_task *ctask = (struct iscsi_cmd_task *)sc->SCp.ptr;
3218 struct iscsi_cmd_task *tmp_ctask;
3219 struct iscsi_conn *conn = ctask->conn;
3220 struct iscsi_session *session = conn->session;
3221 int rc;
3119 3222
3120 spin_lock_bh(&session->lock); 3223 conn->eh_abort_cnt++;
3121 if (sc->SCp.phase == session->age && 3224 debug_scsi("aborting [sc %p itt 0x%x]\n", sc, ctask->itt);
3122 (conn->tmabort_state == TMABORT_TIMEDOUT || 3225
3123 conn->tmabort_state == TMABORT_FAILED)) { 3226 mutex_lock(&conn->xmitmutex);
3124 conn->tmabort_state = TMABORT_INITIAL; 3227 spin_lock_bh(&session->lock);
3125 if (!ctask->sc) { 3228
3126 /* 3229 /*
3127 * ctask completed before tmf abort response or 3230 * If we are not logged in or we have started a new session
3128 * time out. 3231 * then let the host reset code handle this
3129 * But session is still ok => Happy Retry. 3232 */
3130 */ 3233 if (session->state != ISCSI_STATE_LOGGED_IN ||
3131 spin_unlock_bh(&session->lock); 3234 sc->SCp.phase != session->age)
3132 break; 3235 goto failed;
3133 } 3236
3134 spin_unlock_bh(&session->lock); 3237 /* ctask completed before time out */
3135 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 3238 if (!ctask->sc)
3136 continue; 3239 goto success;
3240
3241 /* what should we do here ? */
3242 if (conn->ctask == ctask) {
3243 printk(KERN_INFO "sc %p itt 0x%x partially sent. Failing "
3244 "abort\n", sc, ctask->itt);
3245 goto failed;
3246 }
3247
3248 /* check for the easy pending cmd abort */
3249 while (__kfifo_get(conn->xmitqueue, (void*)&tmp_ctask, sizeof(void*))) {
3250 if (tmp_ctask->itt == ctask->itt) {
3251 debug_scsi("found pending task\n");
3252 goto success;
3137 } 3253 }
3254 __kfifo_put(conn->xmitqueue, (void*)&tmp_ctask, sizeof(void*));
3255 }
3256
3257 conn->tmabort_state = TMABORT_INITIAL;
3258
3259 spin_unlock_bh(&session->lock);
3260 rc = iscsi_exec_abort_task(sc, ctask);
3261 spin_lock_bh(&session->lock);
3262
3263 iscsi_ctask_mtask_cleanup(ctask);
3264 if (rc || sc->SCp.phase != session->age ||
3265 session->state != ISCSI_STATE_LOGGED_IN)
3266 goto failed;
3267
3268 /* ctask completed before tmf abort response */
3269 if (!ctask->sc) {
3270 debug_scsi("sc completed while abort in progress\n");
3271 goto success;
3272 }
3273
3274 if (conn->tmabort_state != TMABORT_SUCCESS) {
3138 spin_unlock_bh(&session->lock); 3275 spin_unlock_bh(&session->lock);
3139 break; 3276 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
3277 spin_lock_bh(&session->lock);
3278 goto failed;
3140 } 3279 }
3141 3280
3142success: 3281success:
3143 debug_scsi("abort success [sc %lx itt 0x%x]\n", (long)sc, ctask->itt); 3282 debug_scsi("abort success [sc %lx itt 0x%x]\n", (long)sc, ctask->itt);
3144 rc = SUCCESS; 3283 spin_unlock_bh(&session->lock);
3145 goto exit;
3146
3147failed:
3148 debug_scsi("abort failed [sc %lx itt 0x%x]\n", (long)sc, ctask->itt);
3149 rc = FAILED;
3150
3151exit:
3152 del_timer_sync(&conn->tmabort_timer);
3153 3284
3154 mutex_lock(&conn->xmitmutex); 3285 /* clean up task if aborted */
3155 if (conn->sock) { 3286 if (conn->sock) {
3156 struct sock *sk = conn->sock->sk; 3287 struct sock *sk = conn->sock->sk;
3157 3288
3158 write_lock_bh(&sk->sk_callback_lock); 3289 write_lock_bh(&sk->sk_callback_lock);
3159 iscsi_ctask_cleanup(conn, ctask); 3290 spin_lock(&session->lock);
3291 fail_command(conn, ctask, DRIVER_TIMEOUT << 24);
3292 spin_unlock(&session->lock);
3160 write_unlock_bh(&sk->sk_callback_lock); 3293 write_unlock_bh(&sk->sk_callback_lock);
3161 } 3294 }
3162 mutex_unlock(&conn->xmitmutex); 3295 mutex_unlock(&conn->xmitmutex);
3163 return rc; 3296 return SUCCESS;
3297
3298failed:
3299 spin_unlock_bh(&session->lock);
3300 mutex_unlock(&conn->xmitmutex);
3301
3302 debug_scsi("abort failed [sc %lx itt 0x%x]\n", (long)sc, ctask->itt);
3303 return FAILED;
3164} 3304}
3165 3305
3166static int 3306static int
@@ -3359,16 +3499,6 @@ iscsi_conn_set_param(struct iscsi_cls_conn *cls_conn, enum iscsi_param param,
3359 struct iscsi_conn *conn = cls_conn->dd_data; 3499 struct iscsi_conn *conn = cls_conn->dd_data;
3360 struct iscsi_session *session = conn->session; 3500 struct iscsi_session *session = conn->session;
3361 3501
3362 spin_lock_bh(&session->lock);
3363 if (conn->c_stage != ISCSI_CONN_INITIAL_STAGE &&
3364 conn->stop_stage != STOP_CONN_RECOVER) {
3365 printk(KERN_ERR "iscsi_tcp: can not change parameter [%d]\n",
3366 param);
3367 spin_unlock_bh(&session->lock);
3368 return 0;
3369 }
3370 spin_unlock_bh(&session->lock);
3371
3372 switch(param) { 3502 switch(param) {
3373 case ISCSI_PARAM_MAX_RECV_DLENGTH: { 3503 case ISCSI_PARAM_MAX_RECV_DLENGTH: {
3374 char *saveptr = conn->data; 3504 char *saveptr = conn->data;
@@ -3691,6 +3821,7 @@ static struct iscsi_transport iscsi_tcp_transport = {
3691 .stop_conn = iscsi_conn_stop, 3821 .stop_conn = iscsi_conn_stop,
3692 .send_pdu = iscsi_conn_send_pdu, 3822 .send_pdu = iscsi_conn_send_pdu,
3693 .get_stats = iscsi_conn_get_stats, 3823 .get_stats = iscsi_conn_get_stats,
3824 .session_recovery_timedout = iscsi_session_recovery_timedout,
3694}; 3825};
3695 3826
3696static int __init 3827static int __init