Index: target/iscsi_target_reportluns.c =================================================================== --- target/iscsi_target_reportluns.c (revision 308) +++ target/iscsi_target_reportluns.c (working copy) @@ -164,6 +164,7 @@ u64 iscsi_lun) { u32 unpacked_lun; + unsigned long flags; rl_cmd_t *rl_cmd = NULL; iscsi_task_t *task = NULL; @@ -208,9 +209,9 @@ task->iscsi_dev = ISCSI_DEV(cmd); task->transport_req = (void *) rl_cmd; - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); list_add(&task->t_list, &T_TASK(cmd)->t_task_list); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); if (iscsi_allocate_iovecs_for_cmd(cmd, ISCSI_IOV_DATA_BUFFER + 1) < 0) goto failure; Index: target/iscsi_target_iblock.h =================================================================== --- target/iscsi_target_iblock.h (revision 308) +++ target/iscsi_target_iblock.h (working copy) @@ -32,7 +32,7 @@ #define IBLOCK_BLOCKSIZE 512 #define IBLOCK_MAX_SECTORS 128 #define IBLOCK_HBA_QUEUE_DEPTH 512 -#define IBLOCK_DEVICE_QUEUE_DEPTH 1 +#define IBLOCK_DEVICE_QUEUE_DEPTH 32 #define IBLOCK_MAX_CDBS 16 #define IBLOCK_LBA_SHIFT 9 Index: target/iscsi_target.c =================================================================== --- target/iscsi_target.c (revision 308) +++ target/iscsi_target.c (working copy) @@ -1786,6 +1786,7 @@ iscsi_unmap_sg_t unmap_sg; struct iscsi_init_scsi_data_out *hdr; struct iovec *iov; + unsigned long flags; hdr = (struct iscsi_init_scsi_data_out *) buf; hdr->length = be32_to_cpu(hdr->length); @@ -1885,11 +1886,11 @@ * and Unsupported SAM WRITE Opcodes and SE resource allocation * failures; */ - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); wait_for_transport = (cmd->t_state != TRANSPORT_WRITE_PENDING); if (wait_for_transport && cmd->immediate_data) wait_for_transport = 0; - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); if (wait_for_transport) down(&cmd->unsolicited_data_sem); Index: target/iscsi_target_device.c =================================================================== --- target/iscsi_target_device.c (revision 308) +++ target/iscsi_target_device.c (working copy) @@ -217,6 +217,7 @@ iscsi_lun_t *iscsi_lun = NULL; iscsi_portal_group_t *tpg = conn->tpg; iscsi_session_t *sess = SESS(conn); + unsigned long flags; unpacked_lun = iscsi_unpack_lun((unsigned char *)&lun); @@ -307,13 +308,13 @@ * Add the iscsi_cmd_t to the iscsi_lun_t's cmd list. This list is used * for tracking state of iscsi_cmd_ts during LUN shutdown events. */ - spin_lock_irq(&iscsi_lun->lun_cmd_lock); + spin_lock_irqsave(&iscsi_lun->lun_cmd_lock, flags); ADD_ENTRY_TO_LIST_PREFIX(l, cmd, iscsi_lun->lun_cmd_head, iscsi_lun->lun_cmd_tail); atomic_set(&T_TASK(cmd)->transport_lun_active, 1); #if 0 TRACE_ERROR("Adding ITT: 0x%08x to LUN LIST[%d]\n", cmd->init_task_tag, iscsi_lun->iscsi_lun); #endif - spin_unlock_irq(&iscsi_lun->lun_cmd_lock); + spin_unlock_irqrestore(&iscsi_lun->lun_cmd_lock, flags); return(0); } @@ -542,12 +543,13 @@ extern void iscsi_clear_lun_from_sessions (iscsi_lun_t *lun, iscsi_portal_group_t *tpg) { iscsi_cmd_t *cmd; + unsigned long flags; /* * Do exception processing and return CHECK_CONDITION status to the * Initiator Port. */ - spin_lock_irq(&lun->lun_cmd_lock); + spin_lock_irqsave(&lun->lun_cmd_lock, flags); while ((cmd = lun->lun_cmd_head)) { if (!(T_TASK(cmd))) { TRACE_ERROR("ITT: 0x%08x, T_TASK(cmd) = NULL [i,t]_state: %u/%u\n", @@ -568,7 +570,7 @@ atomic_set(&T_TASK(cmd)->transport_lun_stop, 1); spin_unlock(&T_TASK(cmd)->t_state_lock); - spin_unlock_irq(&lun->lun_cmd_lock); + spin_unlock_irqrestore(&lun->lun_cmd_lock, flags); if (!(ISCSI_LUN(cmd))) { TRACE_ERROR("ITT: 0x%08x, [i,t]_state: %u/%u\n", cmd->init_task_tag, @@ -584,7 +586,7 @@ ISCSI_LUN(cmd)->iscsi_lun, cmd->init_task_tag); if (transport_lun_wait_for_tasks(cmd, ISCSI_LUN(cmd)) < 0) { - spin_lock_irq(&lun->lun_cmd_lock); + spin_lock_irqsave(&lun->lun_cmd_lock, flags); continue; } @@ -603,14 +605,14 @@ * If the iSCSI frontend is waiting for this iscsi_cmd_t to be released, * notify the waiting thread now that LU has finished accessing it. */ - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); if (atomic_read(&T_TASK(cmd)->transport_lun_fe_stop)) { DEBUG_CLEAR_L("iSCSI_LUN[%d] - Detected FE stop for iscsi_cmd_t:" " %p ITT: 0x%08x\n", lun->iscsi_lun, cmd, cmd->init_task_tag); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); up(&T_TASK(cmd)->transport_lun_fe_stop_sem); - spin_lock_irq(&lun->lun_cmd_lock); + spin_lock_irqsave(&lun->lun_cmd_lock, flags); continue; } atomic_set(&T_TASK(cmd)->transport_lun_stop, 0); @@ -618,10 +620,10 @@ DEBUG_CLEAR_L("iSCSI_LUN[%d] - ITT: 0x%08x finished processing\n", lun->iscsi_lun, cmd->init_task_tag); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); - spin_lock_irq(&lun->lun_cmd_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); + spin_lock_irqsave(&lun->lun_cmd_lock, flags); } - spin_unlock_irq(&lun->lun_cmd_lock); + spin_unlock_irqrestore(&lun->lun_cmd_lock, flags); return; } Index: target/iscsi_target_transport.c =================================================================== --- target/iscsi_target_transport.c (revision 308) +++ target/iscsi_target_transport.c (working copy) @@ -689,6 +689,7 @@ { iscsi_device_t *dev; iscsi_task_t *task; + unsigned long flags; if (!T_TASK(cmd)) return; @@ -703,11 +704,11 @@ if (!(atomic_read(&task->task_state_active))) continue; - spin_lock(&dev->execute_task_lock); + spin_lock_irqsave(&dev->execute_task_lock, flags); REMOVE_ENTRY_FROM_LIST_PREFIX(ts, task, dev->state_task_head, dev->state_task_tail); DEBUG_TSTATE("Removed ITT: 0x%08x dev: %p task[%p]\n", cmd->init_task_tag, dev, task); - spin_unlock(&dev->execute_task_lock); + spin_unlock_irqrestore(&dev->execute_task_lock, flags); atomic_set(&task->task_state_active, 0); atomic_dec(&T_TASK(cmd)->t_task_cdbs_ex_left); @@ -729,6 +730,7 @@ extern void transport_task_dev_remove_state (iscsi_task_t *task, iscsi_device_t *dev) { iscsi_cmd_t *cmd = task->iscsi_cmd; + unsigned long flags; /* * We cannot remove the task from the state list while said task is @@ -743,12 +745,12 @@ } if (atomic_read(&task->task_state_active)) { - spin_lock(&dev->execute_task_lock); + spin_lock_irqsave(&dev->execute_task_lock, flags); REMOVE_ENTRY_FROM_LIST_PREFIX(ts, task, dev->state_task_head, dev->state_task_tail); DEBUG_TSTATE("Removed ITT: 0x%08x dev: %p task[%p]\n", task->iscsi_cmd->init_task_tag, dev, task); - spin_unlock(&dev->execute_task_lock); + spin_unlock_irqrestore(&dev->execute_task_lock, flags); atomic_set(&task->task_state_active, 0); atomic_dec(&T_TASK(cmd)->t_task_cdbs_ex_left); @@ -789,7 +791,9 @@ */ static int transport_cmd_check_stop (iscsi_cmd_t *cmd, int transport_off, u8 t_state) { - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + unsigned long flags; + + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); /* * Determine if IOCTL context caller in requesting the stopping of this command * for LUN shutdown purposes. @@ -803,7 +807,7 @@ atomic_set(&T_TASK(cmd)->t_transport_active, 0); if (transport_off == 2) transport_all_task_dev_remove_state(cmd); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); up(&T_TASK(cmd)->transport_lun_stop_sem); return(1); @@ -827,7 +831,7 @@ */ if ((transport_off == 2) && !(cmd->cmd_flags & ICF_CMD_PASSTHROUGH)) cmd->iscsi_lun = NULL; - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); up(&T_TASK(cmd)->t_transport_stop_sem); return(1); @@ -843,12 +847,12 @@ */ if ((transport_off == 2) && !(cmd->cmd_flags & ICF_CMD_PASSTHROUGH)) cmd->iscsi_lun = NULL; - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return(0); } else if (t_state) cmd->t_state = t_state; - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return(0); } @@ -856,6 +860,7 @@ static void transport_lun_remove_cmd (iscsi_cmd_t *cmd) { iscsi_lun_t *lun = ISCSI_LUN(cmd); + unsigned long flags; if (!lun) return; @@ -872,7 +877,7 @@ if (cmd->cmd_flags & ICF_REPORT_LUNS) return; - spin_lock_irq(&lun->lun_cmd_lock); + spin_lock_irqsave(&lun->lun_cmd_lock, flags); if (atomic_read(&T_TASK(cmd)->transport_lun_active)) { REMOVE_ENTRY_FROM_LIST_PREFIX(l, cmd, lun->lun_cmd_head, @@ -882,7 +887,7 @@ TRACE_ERROR("Removed ITT: 0x%08x from LUN LIST[%d]\n", cmd->init_task_tag, lun->iscsi_lun); #endif } - spin_unlock_irq(&lun->lun_cmd_lock); + spin_unlock_irqrestore(&lun->lun_cmd_lock, flags); return; } @@ -890,6 +895,7 @@ extern int transport_add_cmd_to_queue (iscsi_cmd_t *cmd, se_queue_obj_t *qobj, u8 t_state) { iscsi_queue_req_t *qr; + unsigned long flags; if (!(qr = kmalloc(sizeof(iscsi_queue_req_t), GFP_ATOMIC))) { TRACE_ERROR("Unable to allocate memory for iscsi_queue_req_t\n"); @@ -901,16 +907,16 @@ qr->state = t_state; if (t_state) { - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); cmd->t_state = t_state; atomic_set(&T_TASK(cmd)->t_transport_active, 1); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); } - spin_lock_irq(&qobj->cmd_queue_lock); + spin_lock_irqsave(&qobj->cmd_queue_lock, flags); ADD_ENTRY_TO_LIST(qr, qobj->queue_head, qobj->queue_tail); atomic_inc(&T_TASK(cmd)->t_transport_queue_active); - spin_unlock_irq(&qobj->cmd_queue_lock); + spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags); up(&qobj->thread_sem); @@ -957,10 +963,11 @@ { iscsi_cmd_t *cmd; iscsi_queue_req_t *qr; + unsigned long flags; - spin_lock_irq(&qobj->cmd_queue_lock); + spin_lock_irqsave(&qobj->cmd_queue_lock, flags); if (!qobj->queue_head) { - spin_unlock_irq(&qobj->cmd_queue_lock); + spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags); return(NULL); } @@ -977,7 +984,7 @@ qobj->queue_tail = NULL; else qobj->queue_head->prev = NULL; - spin_unlock_irq(&qobj->cmd_queue_lock); + spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags); return(qr); } @@ -986,10 +993,11 @@ { iscsi_cmd_t *q_cmd; iscsi_queue_req_t *qr, *qr_next; + unsigned long flags; - spin_lock_irq(&qobj->cmd_queue_lock); + spin_lock_irqsave(&qobj->cmd_queue_lock, flags); if (!(atomic_read(&T_TASK(cmd)->t_transport_queue_active))) { - spin_unlock_irq(&qobj->cmd_queue_lock); + spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags); return; } @@ -1009,7 +1017,7 @@ qr = qr_next; } - spin_unlock_irq(&qobj->cmd_queue_lock); + spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags); if (atomic_read(&T_TASK(cmd)->t_transport_queue_active)) { TRACE_ERROR("ITT: 0x%08x t_transport_queue_active: %d\n", cmd->init_task_tag, @@ -1022,8 +1030,9 @@ extern void transport_complete_cmd (iscsi_cmd_t *cmd, int success) { int t_state; + unsigned long flags; - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); if (!success) { cmd->transport_error_status = PYX_TRANSPORT_LOGICAL_UNIT_COMMUNICATION_FAILURE; t_state = TRANSPORT_COMPLETE_FAILURE; @@ -1031,7 +1040,7 @@ t_state = TRANSPORT_COMPLETE_OK; } atomic_set(&T_TASK(cmd)->t_transport_complete, 1); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); cmd->transport_add_cmd_to_queue(cmd, t_state); @@ -1048,17 +1057,18 @@ iscsi_cmd_t *cmd = task->iscsi_cmd; iscsi_device_t *dev = task->iscsi_dev; int t_state; + unsigned long flags; #if 0 TRACE_ERROR("task: %p CDB: 0x%02x obj_ptr: %p\n", task, T_TASK(cmd)->t_task_cdb[0], dev); #endif if (dev) { - spin_lock_irq(&ISCSI_HBA(dev)->hba_queue_lock); + spin_lock_irqsave(&ISCSI_HBA(dev)->hba_queue_lock, flags); atomic_inc(&dev->depth_left); atomic_inc(&ISCSI_HBA(dev)->left_queue_depth); - spin_unlock_irq(&ISCSI_HBA(dev)->hba_queue_lock); + spin_unlock_irqrestore(&ISCSI_HBA(dev)->hba_queue_lock, flags); } - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); atomic_set(&task->task_active, 0); /* @@ -1089,7 +1099,7 @@ atomic_dec(&T_TASK(cmd)->t_se_count); atomic_set(&task->task_timeout, 0); } - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); up(&task->task_stop_sem); return; @@ -1101,11 +1111,11 @@ */ if (atomic_read(&task->task_timeout)) { if (!(atomic_dec_and_test(&T_TASK(cmd)->t_task_cdbs_timeout_left))) { - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return; } t_state = TRANSPORT_COMPLETE_TIMEOUT; - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); cmd->transport_add_cmd_to_queue(cmd, t_state); return; @@ -1131,7 +1141,7 @@ if (!success) T_TASK(cmd)->t_tasks_failed = 1; - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return; } @@ -1145,7 +1155,7 @@ atomic_set(&T_TASK(cmd)->t_transport_complete, 1); t_state = TRANSPORT_COMPLETE_OK; } - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); cmd->transport_add_cmd_to_queue(cmd, t_state); @@ -1186,7 +1196,9 @@ */ extern void transport_add_task_to_execute_queue (iscsi_task_t *task, iscsi_device_t *dev) { - spin_lock_irq(&dev->execute_task_lock); + unsigned long flags; + + spin_lock_irqsave(&dev->execute_task_lock, flags); if (!dev->execute_task_head && !dev->execute_task_tail) { dev->execute_task_head = dev->execute_task_tail = task; task->t_next = task->t_prev = NULL; @@ -1198,7 +1210,7 @@ atomic_inc(&dev->execute_tasks); if (atomic_read(&task->task_state_active)) { - spin_unlock_irq(&dev->execute_task_lock); + spin_unlock_irqrestore(&dev->execute_task_lock, flags); return; } @@ -1208,7 +1220,7 @@ DEBUG_TSTATE("Added ITT: 0x%08x task[%p] to dev: %p\n", task->iscsi_cmd->init_task_tag, task, dev); - spin_unlock_irq(&dev->execute_task_lock); + spin_unlock_irqrestore(&dev->execute_task_lock, flags); return; } @@ -1217,8 +1229,9 @@ { iscsi_device_t *dev; iscsi_task_t *task; + unsigned long flags; - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); list_for_each_entry(task, &T_TASK(cmd)->t_task_list, t_list) { dev = task->iscsi_dev; @@ -1234,7 +1247,7 @@ spin_unlock(&dev->execute_task_lock); } - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return; } @@ -1247,8 +1260,9 @@ { iscsi_device_t *dev = ISCSI_DEV(cmd); iscsi_task_t *task; + unsigned long flags; - spin_lock_irq(&dev->execute_task_lock); + spin_lock_irqsave(&dev->execute_task_lock, flags); list_for_each_entry(task, &T_TASK(cmd)->t_task_list, t_list) { if (atomic_read(&task->task_execute_queue)) continue; @@ -1256,7 +1270,7 @@ __transport_add_task_to_execute_queue(task, dev); atomic_set(&task->task_execute_queue, 1); } - spin_unlock_irq(&dev->execute_task_lock); + spin_unlock_irqrestore(&dev->execute_task_lock, flags); return; } @@ -1292,7 +1306,9 @@ */ static void transport_remove_task_from_execute_queue (iscsi_task_t *task, iscsi_device_t *dev) { - spin_lock_irq(&dev->execute_task_lock); + unsigned long flags; + + spin_lock_irqsave(&dev->execute_task_lock, flags); if (!task->t_prev && !task->t_next) dev->execute_task_head = dev->execute_task_tail = NULL; else { @@ -1312,7 +1328,7 @@ task->t_next = task->t_prev = NULL; } atomic_dec(&dev->execute_tasks); - spin_unlock_irq(&dev->execute_task_lock); + spin_unlock_irqrestore(&dev->execute_task_lock, flags); return; } @@ -1351,12 +1367,13 @@ iscsi_cmd_t *cmd = NULL; iscsi_queue_req_t *qr, *qr_next; int bug_out = 0, t_state; + unsigned long flags; - spin_lock_irq(&dev->dev_queue_obj->cmd_queue_lock); + spin_lock_irqsave(&dev->dev_queue_obj->cmd_queue_lock, flags); qr = dev->dev_queue_obj->queue_head; while (qr) { qr_next = qr->next; - spin_unlock_irq(&dev->dev_queue_obj->cmd_queue_lock); + spin_unlock_irqrestore(&dev->dev_queue_obj->cmd_queue_lock, flags); cmd = qr->cmd; t_state = qr->state; @@ -1369,10 +1386,10 @@ transport_release_fe_cmd(cmd); bug_out = 1; - spin_lock_irq(&dev->dev_queue_obj->cmd_queue_lock); + spin_lock_irqsave(&dev->dev_queue_obj->cmd_queue_lock, flags); qr = qr_next; } - spin_unlock_irq(&dev->dev_queue_obj->cmd_queue_lock); + spin_unlock_irqrestore(&dev->dev_queue_obj->cmd_queue_lock, flags); #if 0 if (bug_out) BUG(); @@ -2017,6 +2034,7 @@ se_obj_lun_type_t *se_obj_api) { iscsi_task_t *task; + unsigned long flags; if (!(task = kmalloc(sizeof(iscsi_task_t), GFP_KERNEL))) { TRACE_ERROR("Unable to allocate iscsi_task_t\n"); @@ -2036,9 +2054,9 @@ if (!(task->transport_req = se_obj_api->get_transport_req(se_obj_ptr, task))) return(NULL); - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); list_add_tail(&task->t_list, &T_TASK(cmd)->t_task_list); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); task->se_obj_api = se_obj_api; task->se_obj_ptr = se_obj_ptr; @@ -2178,14 +2196,15 @@ { int ret; iscsi_transform_info_t ti; + unsigned long flags; /* * Note that tasks that have not been returned from the transport * plugin will not be released here. */ - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); transport_all_task_dev_remove_state(cmd); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); transport_release_tasks(cmd); T_TASK(cmd)->t_tasks_failed = 0; @@ -2414,13 +2433,14 @@ extern void transport_stop_tasks_for_cmd (iscsi_cmd_t *cmd) { iscsi_task_t *task, *task_tmp; + unsigned long flags; DEBUG_TS("ITT[0x%08x] - Stopping tasks\n", cmd->init_task_tag); /* * No tasks remain in the execution queue */ - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); list_for_each_entry_safe(task, task_tmp, &T_TASK(cmd)->t_task_list, t_list) { DEBUG_TS("task_no[%d] - Processing task %p\n", task->task_no, task); /* @@ -2429,11 +2449,11 @@ */ if (!atomic_read(&task->task_sent) && !atomic_read(&task->task_active)) { - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); transport_remove_task_from_execute_queue(task, task->iscsi_dev); DEBUG_TS("task_no[%d] - Removed from execute queue\n", task->task_no); - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); continue; } @@ -2443,13 +2463,13 @@ */ if (atomic_read(&task->task_active)) { atomic_set(&task->task_stop, 1); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); DEBUG_TS("task_no[%d] - Waiting to complete\n", task->task_no); down(&task->task_stop_sem); DEBUG_TS("task_no[%d] - Stopped successfully\n", task->task_no); - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); atomic_dec(&T_TASK(cmd)->t_task_cdbs_left); atomic_set(&task->task_active, 0); @@ -2460,17 +2480,19 @@ __transport_stop_task_timer(task); } - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return; } static void transport_failure_reset_queue_depth (iscsi_device_t *dev) { - spin_lock_irq(&ISCSI_HBA(dev)->hba_queue_lock); + unsigned long flags; + + spin_lock_irqsave(&ISCSI_HBA(dev)->hba_queue_lock, flags);; atomic_inc(&dev->depth_left); atomic_inc(&ISCSI_HBA(dev)->left_queue_depth); - spin_unlock_irq(&ISCSI_HBA(dev)->hba_queue_lock); + spin_unlock_irqrestore(&ISCSI_HBA(dev)->hba_queue_lock, flags); return; } @@ -2480,6 +2502,7 @@ */ extern int transport_failure_tasks_generic (iscsi_cmd_t *cmd) { + unsigned long flags; /* * This causes problems when EVPD INQUIRY fails, disable this functionality * for now. @@ -2489,17 +2512,17 @@ if (!(cmd->cmd_flags & ICF_SE_DISABLE_ONLINE_CHECK)) goto done; - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); list_for_each_entry(task, &T_TASK(cmd)->t_task_list, t_list) { DEBUG_TF("Exception Cmd ITT: 0x%08x: task[%p]: se_obj_api: %p" " se_obj_ptr: %p task_scsi_status: %d\n", cmd->init_task_tag, task, task->se_obj_api, task->se_obj_ptr, task->task_scsi_status); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); task->se_obj_api->signal_offline(task->se_obj_ptr); - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); } - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); done: cmd->transport_error_status = PYX_TRANSPORT_LOGICAL_UNIT_COMMUNICATION_FAILURE; @@ -2600,13 +2623,15 @@ extern void transport_direct_request_timeout (iscsi_cmd_t *cmd) { - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + unsigned long flags; + + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); if (!(atomic_read(&T_TASK(cmd)->t_transport_timeout))) { - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return; } if (atomic_read(&T_TASK(cmd)->t_task_cdbs_timeout_left)) { - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return; } @@ -2614,7 +2639,7 @@ &T_TASK(cmd)->t_se_count); CMD_ORIG_OBJ_API(cmd)->clear_tur_bit(cmd->se_orig_obj_ptr); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return; } @@ -2623,18 +2648,19 @@ { unsigned char *cdb; iscsi_task_t *task; + unsigned long flags; /* * Reset T_TASK(cmd)->t_se_count to allow transport_generic_remove() * to allow last call to free memory resources. */ - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); if (atomic_read(&T_TASK(cmd)->t_transport_timeout) > 1) { int tmp = (atomic_read(&T_TASK(cmd)->t_transport_timeout) - 1); atomic_sub(tmp, &T_TASK(cmd)->t_se_count); } - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); /* * Clear the TUR bit that the status thread will be checking to determine @@ -3179,12 +3205,13 @@ { iscsi_task_t *task = (iscsi_task_t *)data; iscsi_cmd_t *cmd = task->iscsi_cmd; - + unsigned long flags; +#if 0 DEBUG_TT("transport task timeout fired! task: %p cmd: %p\n", task, cmd); - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); if (task->task_flags & TF_STOP) { - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return; } task->task_flags &= ~TF_RUNNING; @@ -3194,7 +3221,7 @@ */ if (!(atomic_read(&task->task_active))) { DEBUG_TT("transport task: %p cmd: %p timeout task_active == 0\n", task, cmd); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return; } @@ -3208,23 +3235,23 @@ if (atomic_read(&task->task_stop)) { DEBUG_TT("transport task: %p cmd: %p timeout task_stop == 1\n", task, cmd); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); up(&task->task_stop_sem); return; } if (!(atomic_dec_and_test(&T_TASK(cmd)->t_task_cdbs_left))) { DEBUG_TT("transport task: %p cmd: %p timeout non zero t_task_cdbs_left\n", task, cmd); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return; } DEBUG_TT("transport task: %p cmd: %p timeout ZERO t_task_cdbs_left\n", task, cmd); cmd->t_state = TRANSPORT_COMPLETE_FAILURE; - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); cmd->transport_add_cmd_to_queue(cmd, TRANSPORT_COMPLETE_FAILURE); - +#endif return; } @@ -3235,10 +3262,9 @@ { unsigned char *cdb; int timeout; - +#if 0 if (task->task_flags & TF_RUNNING) return; - if (task->se_obj_api->set_task_timeout_handler) { if (task->se_obj_api->set_task_timeout_handler(task->se_obj_ptr, task) == 1) return; @@ -3262,16 +3288,18 @@ TRACE_ERROR("Starting task timer for cmd: %p task: %p seconds: %d\n", task->iscsi_cmd, task, timeout); #endif +#endif return; } /* * Called with spin_lock_irq(&T_TASK(cmd)->t_state_lock) held. */ +#warning HMM, SPINLOCK irqsave breakage extern void __transport_stop_task_timer (iscsi_task_t *task) { iscsi_cmd_t *cmd = task->iscsi_cmd; - +#if 0 if (!(task->task_flags & TF_RUNNING)) return; @@ -3283,44 +3311,47 @@ spin_lock_irq(&T_TASK(cmd)->t_state_lock); task->task_flags &= ~TF_RUNNING; task->task_flags &= ~TF_STOP; - +#endif return; } extern void transport_stop_task_timer (iscsi_task_t *task) { iscsi_cmd_t *cmd = task->iscsi_cmd; + unsigned long flags; #if 0 TRACE_ERROR("Stopping task timer for cmd: %p task: %p\n", cmd, task); #endif - spin_lock_irq(&T_TASK(cmd)->t_state_lock); +#if 0 + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); if (!(task->task_flags & TF_RUNNING)) { - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return; } task->task_flags |= TF_STOP; - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); del_timer_sync(&task->task_timer); - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); task->task_flags &= ~TF_RUNNING; task->task_flags &= ~TF_STOP; - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); - + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); +#endif return; } extern void transport_stop_all_task_timers (iscsi_cmd_t *cmd) { iscsi_task_t *task = NULL, *task_tmp; - - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + unsigned long flags; +#if 0 + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); list_for_each_entry_safe(task, task_tmp, &T_TASK(cmd)->t_task_list, t_list) { __transport_stop_task_timer(task); } - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); - + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); +#endif return; } @@ -3373,16 +3404,17 @@ int error; iscsi_cmd_t *cmd = NULL; iscsi_task_t *task; + unsigned long flags; /* * Check if there is enough room in the device and HBA queue to send * iscsi_transport_task_t's to the selected transport. */ check_depth: - spin_lock_irq(&ISCSI_HBA(dev)->hba_queue_lock); + spin_lock_irqsave(&ISCSI_HBA(dev)->hba_queue_lock, flags); if (!(atomic_read(&dev->depth_left)) || !(atomic_read(&ISCSI_HBA(dev)->left_queue_depth))) { - spin_unlock_irq(&ISCSI_HBA(dev)->hba_queue_lock); + spin_unlock_irqrestore(&ISCSI_HBA(dev)->hba_queue_lock, flags); return(transport_tcq_window_closed(dev)); } dev->dev_tcq_window_closed = 0; @@ -3392,17 +3424,17 @@ spin_unlock(&dev->execute_task_lock); if (!task) { - spin_unlock_irq(&ISCSI_HBA(dev)->hba_queue_lock); + spin_unlock_irqrestore(&ISCSI_HBA(dev)->hba_queue_lock, flags); return(0); } atomic_dec(&dev->depth_left); atomic_dec(&ISCSI_HBA(dev)->left_queue_depth); - spin_unlock_irq(&ISCSI_HBA(dev)->hba_queue_lock); + spin_unlock_irqrestore(&ISCSI_HBA(dev)->hba_queue_lock, flags); cmd = task->iscsi_cmd; - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); atomic_set(&task->task_active, 1); atomic_set(&task->task_sent, 1); atomic_inc(&T_TASK(cmd)->t_task_cdbs_sent); @@ -3412,7 +3444,7 @@ atomic_set(&cmd->transport_sent, 1); transport_start_task_timer(task); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); if ((error = TRANSPORT(dev)->do_task(task)) != 0) { cmd->transport_error_status = error; @@ -3830,6 +3862,7 @@ unsigned char *buffer = NULL, *sense_buffer = NULL; iscsi_device_t *dev; iscsi_task_t *task = NULL, *task_tmp; + unsigned long flags; if (!ISCSI_LUN(cmd)) { TRACE_ERROR("ISCSI_LUN(cmd) is NULL\n"); @@ -3851,7 +3884,7 @@ buffer[0] = ((ISCSI_SENSE_BUFFER >> 8) & 0xff); buffer[1] = (ISCSI_SENSE_BUFFER & 0xff); - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); list_for_each_entry_safe(task, task_tmp, &T_TASK(cmd)->t_task_list, t_list) { if (!task->task_sense) @@ -3871,7 +3904,7 @@ cmd->init_task_tag, task->task_no); continue; } - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); memcpy((void *)&buffer[2], (void *)sense_buffer, ISCSI_SENSE_BUFFER); cmd->scsi_status = task->task_scsi_status; @@ -3882,7 +3915,7 @@ return(0); } - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return(-1); } @@ -4739,8 +4772,9 @@ extern void transport_free_dev_tasks (iscsi_cmd_t *cmd) { iscsi_task_t *task, *task_tmp; + unsigned long flags; - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); list_for_each_entry_safe(task, task_tmp, &T_TASK(cmd)->t_task_list, t_list) { if (atomic_read(&task->task_active)) continue; @@ -4750,17 +4784,17 @@ kfree(task->task_buf); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); if (task->iscsi_dev) TRANSPORT(task->iscsi_dev)->free_task(task); else TRACE_ERROR("task[%u] - task->iscsi_dev is NULL\n", task->task_no); - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); list_del(&task->t_list); kfree(task); } - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return; } @@ -4821,33 +4855,37 @@ static inline int transport_dec_and_check (iscsi_cmd_t *cmd) { - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + unsigned long flags; + + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); if (atomic_read(&T_TASK(cmd)->t_fe_count)) { if (!(atomic_dec_and_test(&T_TASK(cmd)->t_fe_count))) { - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return(1); } } if (atomic_read(&T_TASK(cmd)->t_se_count)) { if (!(atomic_dec_and_test(&T_TASK(cmd)->t_se_count))) { - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return(1); } } - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return(0); } extern void transport_release_fe_cmd (iscsi_cmd_t *cmd) { + unsigned long flags; + if (transport_dec_and_check(cmd)) return; - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); transport_all_task_dev_remove_state(cmd); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); transport_release_tasks(cmd); transport_free_pages(cmd); @@ -4863,21 +4901,23 @@ */ extern int transport_generic_remove (iscsi_cmd_t *cmd, int release_to_pool, int session_reinstatement) { + unsigned long flags; + if (!(T_TASK(cmd))) goto release_cmd; if (transport_dec_and_check(cmd)) { if (session_reinstatement) { - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); transport_all_task_dev_remove_state(cmd); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); } return(1); } - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); transport_all_task_dev_remove_state(cmd); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); transport_release_tasks(cmd); transport_free_pages(cmd); @@ -5861,6 +5901,8 @@ */ static int transport_generic_write_pending (iscsi_cmd_t *cmd) { + unsigned long flags; + if (cmd->cmd_flags & ICF_CMD_PASSTHROUGH) { if (!(cmd->cmd_flags & ICF_CMD_PASSTHROUGH_NOALLOC)) { up(&T_TASK(cmd)->t_transport_passthrough_wsem); @@ -5873,9 +5915,9 @@ return(PYX_TRANSPORT_WRITE_PENDING); } - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); cmd->t_state = TRANSPORT_WRITE_PENDING; - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); if (cmd->immediate_data || cmd->unsolicited_data) up(&cmd->unsolicited_data_sem); @@ -5958,19 +6000,21 @@ */ extern int transport_lun_wait_for_tasks (iscsi_cmd_t *cmd, iscsi_lun_t *lun) { + unsigned long flags; + /* * If the frontend has already requested this iscsi_cmd_t to * be stopped, we can safely ignore this iscsi_cmd_t. */ - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); if (atomic_read(&T_TASK(cmd)->t_transport_stop)) { atomic_set(&T_TASK(cmd)->transport_lun_stop, 0); DEBUG_TRANSPORT_S("IOCTL: ITT[0x%08x] - t_transport_stop == TRUE," " skipping\n", cmd->init_task_tag); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return(-1); } - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); CMD_ORIG_OBJ_API(cmd)->notify_obj(cmd->se_orig_obj_ptr); @@ -5978,9 +6022,9 @@ down(&T_TASK(cmd)->transport_lun_stop_sem); DEBUG_TRANSPORT_S("IOCTL: ITT[0x%08x] - stopped cmd....\n", cmd->init_task_tag); - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); atomic_set(&T_TASK(cmd)->transport_lun_stop, 0); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); return(0); } @@ -5992,10 +6036,12 @@ */ static void transport_generic_wait_for_tasks (iscsi_cmd_t *cmd, int remove_cmd, int session_reinstatement) { + unsigned long flags; + if (!(cmd->cmd_flags & ICF_SE_LUN_CMD)) return; - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); /* * If we are already stopped due to an external event (ie: LUN shutdown) * sleep until the connection can have the passed iscsi_cmd_t back. @@ -6015,10 +6061,10 @@ * in transport_lun_wait_for_tasks(). We go ahead and up transport_lun_stop_sem * just to be sure here. */ - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); up(&T_TASK(cmd)->transport_lun_stop_sem); down(&T_TASK(cmd)->transport_lun_fe_stop_sem); - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); /* * At this point, the frontend who was the originator of this @@ -6040,20 +6086,20 @@ " t_state/def_t_state: %d/%d, t_transport_stop = TRUE\n", cmd, cmd->init_task_tag, cmd->cmd_sn, cmd->i_state, cmd->deferred_i_state, cmd->t_state, cmd->deferred_t_state); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); CMD_ORIG_OBJ_API(cmd)->notify_obj(cmd->se_orig_obj_ptr); down(&T_TASK(cmd)->t_transport_stop_sem); - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); atomic_set(&T_TASK(cmd)->t_transport_active, 0); atomic_set(&T_TASK(cmd)->t_transport_stop, 0); DEBUG_TRANSPORT_S("wait_for_tasks: Stopped down(&T_TASK(cmd)->t_transport_stop_sem) for ITT:" " 0x%08x\n", cmd->init_task_tag); remove: - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); if (!remove_cmd) return; @@ -6185,6 +6231,7 @@ static int transport_add_qr_to_queue (se_queue_obj_t *qobj, void *se_obj_ptr, int state) { iscsi_queue_req_t *qr; + unsigned long flags; if (!(qr = kmalloc(sizeof(iscsi_queue_req_t), GFP_ATOMIC))) { TRACE_ERROR("Unable to allocate memory for iscsi_queue_req_t\n"); @@ -6195,9 +6242,9 @@ qr->state = state; qr->queue_se_obj_ptr = se_obj_ptr; - spin_lock_irq(&qobj->cmd_queue_lock); + spin_lock_irqsave(&qobj->cmd_queue_lock, flags); ADD_ENTRY_TO_LIST(qr, qobj->queue_head, qobj->queue_tail); - spin_unlock_irq(&qobj->cmd_queue_lock); + spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags); #if 0 TRACE_ERROR("Adding obj_ptr: %p state: %d to qobj: %p\n", se_obj_ptr, state, qobj); #endif @@ -6432,8 +6479,9 @@ iscsi_cmd_t *cmd; iscsi_task_t *task, *task_next; int complete = 0, remove = 0; + unsigned long flags; - spin_lock_irq(&dev->execute_task_lock); + spin_lock_irqsave(&dev->execute_task_lock, flags); task = dev->state_task_head; while (task) { task_next = task->ts_next; @@ -6450,9 +6498,9 @@ task = task_next; continue; } - spin_unlock_irq(&dev->execute_task_lock); + spin_unlock_irqrestore(&dev->execute_task_lock, flags); - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); DEBUG_DO("DO: task: %p cmd: %p ITT/CmdSN: 0x%08x/0x%08x " "i_state/def_i_state: %d/%d t_state/def_t_state: %d/%d\n", task, cmd, cmd->init_task_tag, cmd->cmd_sn, cmd->i_state, @@ -6472,14 +6520,14 @@ if (atomic_read(&task->task_active)) { if (atomic_read(&task->task_timeout)) { DEBUG_DO("DO: task->task_timeout == 1, skipping task\n"); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); - spin_lock_irq(&dev->execute_task_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); + spin_lock_irqsave(&dev->execute_task_lock, flags); task = task_next; continue; } atomic_set(&task->task_stop, 1); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); DEBUG_DO("DO: BEFORE down(&task->task_stop_sem); ITT:" " 0x%08x\n", cmd->init_task_tag); @@ -6487,7 +6535,7 @@ DEBUG_DO("DO: AFTER down(&task->task_stop_sem); ITT:" " 0x%08x\n", cmd->init_task_tag); - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); if (atomic_dec_and_test(&T_TASK(cmd)->t_task_cdbs_left)) complete = 1; @@ -6503,9 +6551,9 @@ goto fail_cmd; if (!complete) { - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); - spin_lock_irq(&dev->execute_task_lock); + spin_lock_irqsave(&dev->execute_task_lock, flags); REMOVE_ENTRY_FROM_LIST_PREFIX(ts, task, dev->state_task_head, dev->state_task_tail); task = task_next; @@ -6527,12 +6575,12 @@ cmd->init_task_tag, task); cmd->t_state = TRANSPORT_COMPLETE_FAILURE; - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); cmd->transport_add_cmd_to_queue(cmd, TRANSPORT_COMPLETE_FAILURE); complete = 0; - spin_lock_irq(&dev->execute_task_lock); + spin_lock_irqsave(&dev->execute_task_lock, flags); REMOVE_ENTRY_FROM_LIST_PREFIX(ts, task, dev->state_task_head, dev->state_task_tail); task = task_next; @@ -6540,7 +6588,7 @@ fail_cmd: remove = (cmd->i_state == ISTATE_REMOVE); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); if (!remove) iscsi_send_check_condition_and_sense(cmd, LOGICAL_UNIT_COMMUNICATION_FAILURE, 0); @@ -6552,12 +6600,12 @@ if (!(transport_cmd_check_stop(cmd, 1, 0))) transport_passthrough_check_stop(cmd); - spin_lock_irq(&dev->execute_task_lock); + spin_lock_irqsave(&dev->execute_task_lock, flags); REMOVE_ENTRY_FROM_LIST_PREFIX(ts, task, dev->state_task_head, dev->state_task_tail); task = task_next; } - spin_unlock_irq(&dev->execute_task_lock); + spin_unlock_irqrestore(&dev->execute_task_lock, flags); return(0); } @@ -6565,15 +6613,16 @@ static void transport_status_empty_queue (se_queue_obj_t *qobj) { iscsi_queue_req_t *qr; + unsigned long flags; - spin_lock_irq(&qobj->cmd_queue_lock); + spin_lock_irqsave(&qobj->cmd_queue_lock, flags); while ((qr = __transport_get_qr_from_queue(qobj))) { #if 0 TRACE_ERROR("Freeing qr: %p qr->state: %d\n", qr, qr->state); #endif kfree(qr); } - spin_unlock_irq(&qobj->cmd_queue_lock); + spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags); return; } @@ -6725,11 +6774,13 @@ iscsi_queue_req_t *qr; iscsi_task_t *task; u8 state; + unsigned long flags; + /* * Empty the iscsi_device_t's iscsi_task_t state list. */ - spin_lock_irq(&dev->execute_task_lock); + spin_lock_irqsave(&dev->execute_task_lock, flags); while ((task = transport_get_task_from_state_list(dev))) { if (!task->iscsi_cmd) { TRACE_ERROR("task->iscsi_cmd is NULL!\n"); @@ -6742,9 +6793,9 @@ task, cmd, cmd->init_task_tag); continue; } - spin_unlock_irq(&dev->execute_task_lock); + spin_unlock_irqrestore(&dev->execute_task_lock, flags); - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); DEBUG_DO("PT: cmd: %p task: %p ITT/CmdSN: 0x%08x/0x%08x, i_state/def_i_state: %d/%d," " t_state/def_t_state: %d/%d cdb: 0x%02x\n", cmd, task, cmd->init_task_tag, @@ -6761,13 +6812,13 @@ if (atomic_read(&task->task_active)) { atomic_set(&task->task_stop, 1); - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); DEBUG_DO("Waiting for task: %p to shutdown for dev: %p\n", task, dev); down(&task->task_stop_sem); DEBUG_DO("Completed task: %p shutdown for dev: %p\n", task, dev); - spin_lock_irq(&T_TASK(cmd)->t_state_lock); + spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags); atomic_dec(&T_TASK(cmd)->t_task_cdbs_left); atomic_set(&task->task_active, 0); @@ -6776,12 +6827,12 @@ __transport_stop_task_timer(task); if (!(atomic_dec_and_test(&T_TASK(cmd)->t_task_cdbs_ex_left))) { - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); DEBUG_DO("Skipping task: %p, dev: %p for t_task_cdbs_ex_left: %d\n", task, dev, atomic_read(&T_TASK(cmd)->t_task_cdbs_ex_left)); - spin_lock_irq(&dev->execute_task_lock); + spin_lock_irqsave(&dev->execute_task_lock, flags); continue; } @@ -6789,7 +6840,7 @@ DEBUG_DO("got t_transport_active = 1 for task: %p, dev: %p\n", task, dev); if (atomic_read(&T_TASK(cmd)->t_fe_count)) { - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); iscsi_send_check_condition_and_sense(cmd, LOGICAL_UNIT_COMMUNICATION_FAILURE, 0); transport_remove_cmd_from_queue(cmd, CMD_ORIG_OBJ_API(cmd)->get_queue_obj(cmd->se_orig_obj_ptr)); @@ -6798,7 +6849,7 @@ if (!(transport_cmd_check_stop(cmd, 1, 0))) transport_passthrough_check_stop(cmd); } else { - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); transport_remove_cmd_from_queue(cmd, CMD_ORIG_OBJ_API(cmd)->get_queue_obj(cmd->se_orig_obj_ptr)); @@ -6810,14 +6861,14 @@ transport_generic_remove(cmd, 0, 0); } - spin_lock_irq(&dev->execute_task_lock); + spin_lock_irqsave(&dev->execute_task_lock, flags); continue; } DEBUG_DO("Got t_transport_active = 0 for task: %p, dev: %p\n", task, dev); if (atomic_read(&T_TASK(cmd)->t_fe_count)) { - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); iscsi_send_check_condition_and_sense(cmd, LOGICAL_UNIT_COMMUNICATION_FAILURE, 0); transport_remove_cmd_from_queue(cmd, CMD_ORIG_OBJ_API(cmd)->get_queue_obj(cmd->se_orig_obj_ptr)); @@ -6826,7 +6877,7 @@ if (!(transport_cmd_check_stop(cmd, 1, 0))) transport_passthrough_check_stop(cmd); } else { - spin_unlock_irq(&T_TASK(cmd)->t_state_lock); + spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags); transport_remove_cmd_from_queue(cmd, CMD_ORIG_OBJ_API(cmd)->get_queue_obj(cmd->se_orig_obj_ptr)); @@ -6838,16 +6889,16 @@ transport_generic_remove(cmd, 0, 0); } - spin_lock_irq(&dev->execute_task_lock); + spin_lock_irqsave(&dev->execute_task_lock, flags); } - spin_unlock_irq(&dev->execute_task_lock); + spin_unlock_irqrestore(&dev->execute_task_lock, flags); /* * Empty the iscsi_device_t's iscsi_cmd_t list. */ - spin_lock_irq(&dev->dev_queue_obj->cmd_queue_lock); + spin_lock_irqsave(&dev->dev_queue_obj->cmd_queue_lock, flags); while ((qr = __transport_get_qr_from_queue(dev->dev_queue_obj))) { - spin_unlock_irq(&dev->dev_queue_obj->cmd_queue_lock); + spin_unlock_irqrestore(&dev->dev_queue_obj->cmd_queue_lock, flags); cmd = qr->cmd; state = qr->state; kfree(qr); @@ -6868,9 +6919,9 @@ else transport_generic_remove(cmd, 0, 0); } - spin_lock_irq(&dev->dev_queue_obj->cmd_queue_lock); + spin_lock_irqsave(&dev->dev_queue_obj->cmd_queue_lock, flags); } - spin_unlock_irq(&dev->dev_queue_obj->cmd_queue_lock); + spin_unlock_irqrestore(&dev->dev_queue_obj->cmd_queue_lock, flags); return; }