Hannes Reinecke wrote:
> Before we're trying to send a PDU we have to check whether a TMF
> is active. If so and if the PDU will be affected by the TMF
> we should allow only Data-out PDUs to be sent, or, if
> fast_abort is set, no PDUs at all.

You sort of changed the behavior of the code and it does not match the 
description.

The fast_abort setting was a hack and not the iscsi RFC one as we 
discussed before. It used to apply to aborts and lu resets. Now, it only 
applies to lu resets.

Was this intentional?


> 
> Signed-off-by: Mike Christie <micha...@cs.wisc.edu>
> Signed-off-by: Hannes Reinecke <h...@suse.de>
> ---
>  drivers/scsi/libiscsi.c    |  112 
> +++++++++++++++++++++++++++++++++++++++-----
>  include/scsi/iscsi_proto.h |    2 +
>  2 files changed, 102 insertions(+), 12 deletions(-)
> 
> diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c
> index ef08f10..fd34347 100644
> --- a/drivers/scsi/libiscsi.c
> +++ b/drivers/scsi/libiscsi.c
> @@ -263,6 +263,88 @@ static int iscsi_prep_bidi_ahs(struct iscsi_task *task)
>  }
>  
>  /**
> + * iscsi_check_tmf_restrictions - check if a task is affected by TMF
> + * @task: iscsi task
> + * @opcode: opcode to check for
> + *
> + * During TMF a task has to be checked if it's affected.
> + * All unrelated I/O can be passed through, but I/O to the
> + * affected LUN should be restricted.
> + * If 'fast_abort' is set we won't be sending any I/O to the
> + * affected LUN.
> + * Otherwise the target is waiting for all TTTs to be completed,
> + * so we have to send all outstanding Data-Out PDUs to the target.
> + */
> +static int iscsi_check_tmf_restrictions(struct iscsi_task *task, int opcode)
> +{
> +     struct iscsi_conn *conn = task->conn;
> +     struct iscsi_tm *tmf = &conn->tmhdr;
> +     unsigned int hdr_lun;
> +
> +     if (conn->tmf_state == TMF_INITIAL)
> +             return 0;
> +
> +     if ((tmf->opcode & ISCSI_OPCODE_MASK) != ISCSI_OP_SCSI_TMFUNC)
> +             return 0;
> +
> +     switch (ISCSI_TM_FUNC_VALUE(tmf)) {
> +     case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET:
> +             /*
> +              * Allow PDUs for unrelated LUNs
> +              */
> +             hdr_lun = scsilun_to_int((struct scsi_lun *)tmf->lun);
> +             if (hdr_lun != task->sc->device->lun)
> +                     return 0;
> +
> +             /*
> +              * Fail all SCSI cmd PDUs
> +              */
> +             if (opcode != ISCSI_OP_SCSI_DATA_OUT) {
> +                     iscsi_conn_printk(KERN_INFO, conn,
> +                                       "task [op %x/%x itt "
> +                                       "0x%x/0x%x lun %u] "
> +                                       "rejected.\n",
> +                                       task->hdr->opcode, opcode,
> +                                       task->itt, task->hdr_itt, hdr_lun);
> +                     return -EACCES;
> +             }
> +             /*
> +              * And also all data-out PDUs in response to R2T
> +              * if fast_abort is set.
> +              */
> +             if (conn->session->fast_abort) {
> +                     iscsi_conn_printk(KERN_INFO, conn,
> +                                       "task [op %x/%x itt "
> +                                       "0x%x/0x%x lun %u] "
> +                                       "fast abort.\n",
> +                                       task->hdr->opcode, opcode,
> +                                       task->itt, task->hdr_itt, hdr_lun);
> +                     return -EACCES;
> +             }
> +             break;
> +     case ISCSI_TM_FUNC_ABORT_TASK:
> +             /*
> +              * the caller has already checked if the task
> +              * they want to abort was in the pending queue so if
> +              * we are here the cmd pdu has gone out already, and
> +              * we will only hit this for data-outs
> +              */
> +             if (opcode == ISCSI_OP_SCSI_DATA_OUT &&
> +                 task->hdr_itt == tmf->rtt) {
> +                     ISCSI_DBG_SESSION(conn->session,
> +                                       "Preventing task %x/%x from sending "
> +                                       "data-out due to abort task in "
> +                                       "progress\n", task->itt,
> +                                       task->hdr_itt);
> +                     return -EACCES;
> +             }
> +             break;
> +     }
> +
> +     return 0;
> +}
> +
> +/**
>   * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu
>   * @task: iscsi task
>   *
> @@ -279,6 +361,10 @@ static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task 
> *task)
>       itt_t itt;
>       int rc;
>  
> +     rc = iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_CMD);
> +     if (rc)
> +             return rc;
> +
>       if (conn->session->tt->alloc_pdu) {
>               rc = conn->session->tt->alloc_pdu(task, ISCSI_OP_SCSI_CMD);
>               if (rc)
> @@ -1329,6 +1415,7 @@ EXPORT_SYMBOL_GPL(iscsi_requeue_task);
>   **/
>  static int iscsi_data_xmit(struct iscsi_conn *conn)
>  {
> +     struct iscsi_task *task;
>       int rc = 0;
>  
>       spin_lock_bh(&conn->session->lock);
> @@ -1366,11 +1453,8 @@ check_mgmt:
>  
>       /* process pending command queue */
>       while (!list_empty(&conn->cmdqueue)) {
> -             if (conn->tmf_state == TMF_QUEUED)
> -                     break;
> -
> -             conn->task = list_entry(conn->cmdqueue.next,
> -                                      struct iscsi_task, running);
> +             conn->task = list_entry(conn->cmdqueue.next, struct iscsi_task,
> +                                     running);
>               list_del_init(&conn->task->running);
>               if (conn->session->state == ISCSI_STATE_LOGGING_OUT) {
>                       fail_scsi_task(conn->task, DID_IMM_RETRY);
> @@ -1378,7 +1462,7 @@ check_mgmt:
>               }
>               rc = iscsi_prep_scsi_cmd_pdu(conn->task);
>               if (rc) {
> -                     if (rc == -ENOMEM) {
> +                     if (rc == -ENOMEM || rc == -EACCES) {
>                               list_add_tail(&conn->task->running,
>                                             &conn->cmdqueue);
>                               conn->task = NULL;
> @@ -1400,17 +1484,18 @@ check_mgmt:
>       }
>  
>       while (!list_empty(&conn->requeue)) {
> -             if (conn->session->fast_abort && conn->tmf_state != TMF_INITIAL)
> -                     break;
> -
>               /*
>                * we always do fastlogout - conn stop code will clean up.
>                */
>               if (conn->session->state == ISCSI_STATE_LOGGING_OUT)
>                       break;
>  
> -             conn->task = list_entry(conn->requeue.next,
> -                                      struct iscsi_task, running);
> +             task = list_entry(conn->requeue.next, struct iscsi_task,
> +                               running);
> +             if (iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_DATA_OUT))
> +                     break;
> +
> +             conn->task = task;
>               list_del_init(&conn->task->running);
>               conn->task->state = ISCSI_TASK_RUNNING;
>               rc = iscsi_xmit_task(conn);
> @@ -1560,7 +1645,7 @@ int iscsi_queuecommand(struct scsi_cmnd *sc, void 
> (*done)(struct scsi_cmnd *))
>       if (!ihost->workq) {
>               reason = iscsi_prep_scsi_cmd_pdu(task);
>               if (reason) {
> -                     if (reason == -ENOMEM) {
> +                     if (reason == -ENOMEM ||  reason == -EACCES) {
>                               reason = FAILURE_OOM;
>                               goto prepd_reject;
>                       } else {
> @@ -2050,6 +2135,7 @@ int iscsi_eh_abort(struct scsi_cmnd *sc)
>               spin_lock_bh(&session->lock);
>               fail_scsi_task(task, DID_ABORT);
>               conn->tmf_state = TMF_INITIAL;
> +             memset(hdr, 0, sizeof(*hdr));
>               spin_unlock_bh(&session->lock);
>               iscsi_start_tx(conn);
>               goto success_unlocked;
> @@ -2060,6 +2146,7 @@ int iscsi_eh_abort(struct scsi_cmnd *sc)
>       case TMF_NOT_FOUND:
>               if (!sc->SCp.ptr) {
>                       conn->tmf_state = TMF_INITIAL;
> +                     memset(hdr, 0, sizeof(*hdr));
>                       /* task completed before tmf abort response */
>                       ISCSI_DBG_EH(session, "sc completed while abort in "
>                                             "progress\n");
> @@ -2796,6 +2883,7 @@ static void iscsi_start_session_recovery(struct 
> iscsi_session *session,
>       spin_lock_bh(&session->lock);
>       fail_scsi_tasks(conn, -1, DID_TRANSPORT_DISRUPTED);
>       fail_mgmt_tasks(session, conn);
> +     memset(&conn->tmhdr, 0, sizeof(conn->tmhdr));
>       spin_unlock_bh(&session->lock);
>       mutex_unlock(&session->eh_mutex);
>  }
> diff --git a/include/scsi/iscsi_proto.h b/include/scsi/iscsi_proto.h
> index f2a2c11..dd0a52c 100644
> --- a/include/scsi/iscsi_proto.h
> +++ b/include/scsi/iscsi_proto.h
> @@ -279,6 +279,8 @@ struct iscsi_tm {
>  #define ISCSI_TM_FUNC_TARGET_COLD_RESET              7
>  #define ISCSI_TM_FUNC_TASK_REASSIGN          8
>  
> +#define ISCSI_TM_FUNC_VALUE(hdr) ((hdr)->flags & ISCSI_FLAG_TM_FUNC_MASK)
> +
>  /* SCSI Task Management Response Header */
>  struct iscsi_tm_rsp {
>       uint8_t opcode;


--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"open-iscsi" group.
To post to this group, send email to open-iscsi@googlegroups.com
To unsubscribe from this group, send email to 
open-iscsi+unsubscr...@googlegroups.com
For more options, visit this group at http://groups.google.com/group/open-iscsi
-~----------~----~----~----~------~----~------~--~---

Reply via email to