|
From: Gleb C. <lna...@ya...> - 2025-10-21 09:19:09
|
Commit: 6ca7f49 GitHub URL: https://github.com/SCST-project/scst/commit/6ca7f49b8cd30fe52b8769e084ef6ba3fcdba25b Author: Gleb Chesnokov Date: 2025-10-21T12:18:36+03:00 Log Message: ----------- scst_tg: Fix multiple checkpatch warnings This patch does not change any functionality. Modified Paths: -------------- scst/src/scst_tg.c | 136 +++++++-------- 1 file changed, 59 insertions(+), 77 deletions(-) =================================================================== diff --git a/scst/src/scst_tg.c b/scst/src/scst_tg.c index f2415b0..e69899d 100644 --- a/scst/src/scst_tg.c +++ b/scst/src/scst_tg.c @@ -426,15 +426,13 @@ static void scst_alua_transitioning_work_fn(struct work_struct *work) TRACE_DBG("Retrying transitioning cmd %p", cmd); spin_lock_irq(&cmd->cmd_threads->cmd_list_lock); - list_add(&cmd->cmd_list_entry, - &cmd->cmd_threads->active_cmd_list); + list_add(&cmd->cmd_list_entry, &cmd->cmd_threads->active_cmd_list); wake_up(&cmd->cmd_threads->cmd_list_waitQ); spin_unlock_irq(&cmd->cmd_threads->cmd_list_lock); kfree(retry); TRACE_EXIT(); - return; } /* @@ -471,19 +469,17 @@ static int scst_tg_accept_transitioning(struct scst_cmd *cmd) break; } - if (cmd->already_transitioning) + if (cmd->already_transitioning) { TRACE_DBG("cmd %p already transitioned checked, failing", cmd); - else { + } else { struct scst_alua_retry *retry; TRACE_DBG("ALUA transitioning: delaying cmd %p", cmd); retry = kzalloc(sizeof(*retry), GFP_KERNEL); - if (retry == NULL) { - TRACE_DBG("Unable to allocate ALUA retry " - "struct, failing cmd %p", cmd); - scst_set_cmd_error(cmd, - SCST_LOAD_SENSE(scst_sense_alua_transitioning)); + if (!retry) { + TRACE_DBG("Unable to allocate ALUA retry struct, failing cmd %p", cmd); + scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_alua_transitioning)); res = SCST_ALUA_CHECK_ERROR; goto out; } @@ -493,13 +489,12 @@ static int scst_tg_accept_transitioning(struct scst_cmd *cmd) INIT_DELAYED_WORK(&retry->alua_retry_work, scst_alua_transitioning_work_fn); cmd->already_transitioning = 1; - schedule_delayed_work(&retry->alua_retry_work, HZ/2); + schedule_delayed_work(&retry->alua_retry_work, HZ / 2); res = SCST_ALUA_CHECK_DELAYED; goto out; } - scst_set_cmd_error(cmd, - SCST_LOAD_SENSE(scst_sense_alua_transitioning)); + scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_alua_transitioning)); res = SCST_ALUA_CHECK_ERROR; out: @@ -548,16 +543,14 @@ static void scst_check_alua_invariant(void) SCST_TG_STATE_OPTIMIZED; if (tgt_dev->alua_filter != scst_alua_filter[expected_state]) { - PRINT_ERROR("LUN %s/%s/%s/%lld/%s: ALUA filter" - " %p <> %p", - tgt_dev->acg_dev->acg->tgt->tgt_name, - tgt_dev->acg_dev->acg->acg_name ? : - "(default)", - tgt_dev->sess->initiator_name, - tgt_dev->lun, - tgt_dev->dev->virt_name ? : "(null)", - tgt_dev->alua_filter, - scst_alua_filter[expected_state]); + PRINT_ERROR("LUN %s/%s/%s/%lld/%s: ALUA filter %p <> %p", + tgt_dev->acg_dev->acg->tgt->tgt_name, + tgt_dev->acg_dev->acg->acg_name ?: "(default)", + tgt_dev->sess->initiator_name, + tgt_dev->lun, + tgt_dev->dev->virt_name ?: "(null)", + tgt_dev->alua_filter, + scst_alua_filter[expected_state]); } } } @@ -580,12 +573,11 @@ static void scst_tg_change_tgt_dev_state(struct scst_tgt_dev *tgt_dev, lockdep_assert_held(&scst_dg_mutex); TRACE_MGMT_DBG("ALUA state of tgt_dev %p has changed (gen_ua %d)", - tgt_dev, gen_ua); + tgt_dev, gen_ua); scst_update_tgt_dev_alua_filter(tgt_dev, state); if (gen_ua) - scst_gen_aen_or_ua(tgt_dev, - SCST_LOAD_SENSE(scst_sense_asym_access_state_changed)); + scst_gen_aen_or_ua(tgt_dev, SCST_LOAD_SENSE(scst_sense_asym_access_state_changed)); } /* Initialize ALUA state of LUN tgt_dev */ @@ -646,8 +638,7 @@ static void scst_reset_tgt_alua_filter(struct scst_target_group *tg, list_for_each_entry(tgt_dev, &dgd->dev->dev_tgt_dev_list, dev_tgt_dev_list_entry) { if (tgt_dev->acg_dev->acg->tgt == tgt) - scst_update_tgt_dev_alua_filter(tgt_dev, - SCST_TG_STATE_OPTIMIZED); + scst_update_tgt_dev_alua_filter(tgt_dev, SCST_TG_STATE_OPTIMIZED); } } @@ -882,9 +873,8 @@ static void scst_event_stpg_notify_fn(struct scst_event *event, TRACE_ENTRY(); - PRINT_INFO("Notification for event %u (id %d) received " - "with status %d (priv %p)", event->event_code, - event->event_id, status, priv); + PRINT_INFO("Notification for event %u (id %d) received with status %d (priv %p)", + event->event_code, event->event_id, status, priv); mutex_lock(&scst_mutex); mutex_lock(&scst_dg_mutex); @@ -892,14 +882,14 @@ static void scst_event_stpg_notify_fn(struct scst_event *event, dg = __lookup_dg_by_dev(cmd->dev); if (!dg) { PRINT_ERROR("STPG: unable to find DG for device %s", - cmd->dev->virt_name); + cmd->dev->virt_name); goto out_fail; } list_for_each_entry(dgd, &dg->dev_list, entry) { if (dgd->dev->stpg_ext_blocked) { TRACE_DBG("STPG: ext unblocking dev %s", - dgd->dev->virt_name); + dgd->dev->virt_name); scst_ext_unblock_dev(dgd->dev, true); dgd->dev->stpg_ext_blocked = 0; } @@ -910,7 +900,7 @@ static void scst_event_stpg_notify_fn(struct scst_event *event, if (status != 0) { PRINT_ERROR("on_stpg script for device group %s failed with status %d", - dg->name, status); + dg->name, status); goto out_fail; } @@ -921,9 +911,8 @@ static void scst_event_stpg_notify_fn(struct scst_event *event, PRINT_ERROR("STPG: unable to find TG %d", d->group_id); goto out_fail; } else if (tg->state == scst_alua_name_to_state(d->prev_state)) { - PRINT_ERROR("on_stpg script did not change ALUA state" - " for device group %s / target group %s", - dg->name, tg->name); + PRINT_ERROR("on_stpg script did not change ALUA state for device group %s / target group %s", + dg->name, tg->name); goto out_fail; } } @@ -953,9 +942,8 @@ out_fail: * @invoke_callbacks: Whether or not to invoke the on_alua_state_changed_* * callback functions. */ -static void __scst_tgt_set_state(struct scst_target_group *tg, - struct scst_tgt_dev *tgt_dev, enum scst_tg_state state, - bool invoke_callbacks) +static void __scst_tgt_set_state(struct scst_target_group *tg, struct scst_tgt_dev *tgt_dev, + enum scst_tg_state state, bool invoke_callbacks) { bool gen_ua = state != SCST_TG_STATE_TRANSITIONING; struct scst_tgt *tgt = tgt_dev->sess->tgt; @@ -1102,7 +1090,7 @@ static void __scst_gen_alua_state_changed_ua(struct scst_target_group *tg) tgt = tgt_dev->sess->tgt; if (__scst_tg_have_tgt(tg, tgt)) scst_gen_aen_or_ua(tgt_dev, - SCST_LOAD_SENSE(scst_sense_asym_access_state_changed)); + SCST_LOAD_SENSE(scst_sense_asym_access_state_changed)); } } } @@ -1127,8 +1115,7 @@ static void __scst_tg_set_preferred(struct scst_target_group *tg, __scst_gen_alua_state_changed_ua(tg); } -int scst_tg_set_preferred(struct scst_target_group *tg, - bool preferred) +int scst_tg_set_preferred(struct scst_target_group *tg, bool preferred) { int res; @@ -1235,8 +1222,8 @@ static void __scst_dg_dev_remove(struct scst_dev_group *dg, struct scst_dg_dev *dgdev) { if (dgdev->dev->stpg_ext_blocked) { - TRACE_DBG("DG %s remove: unblocking STPG ext blocked " - "dev %s", dg->name, dgdev->dev->virt_name); + TRACE_DBG("DG %s remove: unblocking STPG ext blocked dev %s", + dg->name, dgdev->dev->virt_name); scst_ext_unblock_dev(dgdev->dev, true); dgdev->dev->stpg_ext_blocked = 0; } @@ -1430,7 +1417,6 @@ struct scst_dev_group *scst_lookup_dg_by_dev(struct scst_device *dev) return __lookup_dg_by_dev(dev); } - /* * Target group module management. */ @@ -1534,7 +1520,7 @@ bool scst_alua_configured(struct scst_device *dev) dg = __lookup_dg_by_dev(dev); mutex_unlock(&scst_dg_mutex); - return dg != NULL; + return dg; } EXPORT_SYMBOL_GPL(scst_alua_configured); @@ -1671,21 +1657,19 @@ static void scst_stpg_check_blocking_done(struct scst_stpg_wait *wait) if (atomic_dec_and_test(&wait->stpg_wait_left)) { if (wait->status == 0) scst_event_queue(SCST_EVENT_STPG_USER_INVOKE, - SCST_EVENT_SCST_CORE_ISSUER, wait->event_entry); - else { + SCST_EVENT_SCST_CORE_ISSUER, wait->event_entry); + else wait->event_entry->event_notify_fn(&wait->event_entry->event, - wait->event_entry->notify_fn_priv, wait->status); - } + wait->event_entry->notify_fn_priv, + wait->status); kfree(wait); } TRACE_EXIT(); - return; } /* No locks */ -static void scst_stpg_ext_blocking_done(struct scst_device *dev, - uint8_t *data, int len) +static void scst_stpg_ext_blocking_done(struct scst_device *dev, uint8_t *data, int len) { sBUG_ON(len != sizeof(data)); scst_stpg_check_blocking_done(*((struct scst_stpg_wait **)data)); @@ -1723,15 +1707,16 @@ static int scst_emit_stpg_event(struct scst_cmd *cmd, struct scst_dev_group *dg, payload_len = sizeof(*payload) + sizeof(*descr) * tpg_desc_count; event_entry_len = sizeof(*event_entry) + payload_len; + event_entry = kzalloc(event_entry_len, GFP_KERNEL); - if (event_entry == NULL) { + if (!event_entry) { PRINT_ERROR("Unable to allocate event (size %d)", event_entry_len); res = -ENOMEM; goto out; } - TRACE_MEM("event_entry %p (len %d) allocated", event_entry, - event_entry_len); + TRACE_MEM("event_entry %p (len %d) allocated", + event_entry, event_entry_len); event = &event_entry->event; event->payload_len = payload_len; @@ -1741,8 +1726,7 @@ static int scst_emit_stpg_event(struct scst_cmd *cmd, struct scst_dev_group *dg, res = 1; - if (strscpy(payload->device_name, dev->virt_name, - sizeof(payload->device_name)) < 0) { + if (strscpy(payload->device_name, dev->virt_name, sizeof(payload->device_name)) < 0) { PRINT_ERROR("Device name %s too long", dev->virt_name); goto out_too_long; } @@ -1786,16 +1770,16 @@ static int scst_emit_stpg_event(struct scst_cmd *cmd, struct scst_dev_group *dg, dg->stpg_rel_tgt_id = cmd->tgt->rel_tgt_id; dg->stpg_transport_id = kmemdup(cmd->sess->transport_id, - scst_tid_size(cmd->sess->transport_id), GFP_KERNEL); - if (dg->stpg_transport_id == NULL) { + scst_tid_size(cmd->sess->transport_id), GFP_KERNEL); + if (!dg->stpg_transport_id) { PRINT_ERROR("Unable to duplicate stpg_transport_id"); goto out; } wait = kzalloc(sizeof(*wait), GFP_KERNEL); - if (wait == NULL) { - PRINT_ERROR("Unable to allocate STPG wait struct " - "(size %zd)", sizeof(*wait)); + if (!wait) { + PRINT_ERROR("Unable to allocate STPG wait struct (size %zd)", + sizeof(*wait)); res = -ENOMEM; goto out; } @@ -1822,8 +1806,8 @@ static int scst_emit_stpg_event(struct scst_cmd *cmd, struct scst_dev_group *dg, scst_stpg_ext_blocking_done, &wait, sizeof(wait), true); if (rc != 0) { - TRACE_DBG("scst_ext_block_dev() failed " - "with %d, reverting (cmd %p)", rc, cmd); + TRACE_DBG("scst_ext_block_dev() failed with %d, reverting (cmd %p)", + rc, cmd); wait->status = rc; wait->dg = dg; atomic_dec(&wait->stpg_wait_left); @@ -1897,7 +1881,7 @@ int scst_tg_set_group_info(struct scst_cmd *cmd) /* Check for some reasonable limit */ if (tpg_desc_count > 64) { PRINT_ERROR("Too many STPG descriptors (%d) for dev %s", - tpg_desc_count, dev->virt_name); + tpg_desc_count, dev->virt_name); res = -EINVAL; scst_set_invalid_field_in_cdb(cmd, 6, 0); goto out_put; @@ -1914,16 +1898,16 @@ int scst_tg_set_group_info(struct scst_cmd *cmd) res = mutex_lock_interruptible(&scst_mutex); if (res) { - PRINT_INFO("mutex_lock_interruptible() returned %d, finishing " - "cmd %p", res, cmd); + PRINT_INFO("mutex_lock_interruptible() returned %d, finishing cmd %p", + res, cmd); scst_set_busy(cmd); goto out_put; } res = mutex_lock_interruptible(&scst_dg_mutex); if (res) { - PRINT_INFO("mutex_lock_interruptible() returned %d, finishing " - "cmd %p", res, cmd); + PRINT_INFO("mutex_lock_interruptible() returned %d, finishing cmd %p", + res, cmd); scst_set_busy(cmd); goto out_unlock_sm_fail; } @@ -1978,15 +1962,14 @@ int scst_tg_set_group_info(struct scst_cmd *cmd) if (osi[j].tg->state == SCST_TG_STATE_TRANSITIONING) { TRACE_MGMT_DBG("TG %p is transitioning", osi[j].tg); res = -EBUSY; - scst_set_cmd_error(cmd, - SCST_LOAD_SENSE(scst_sense_alua_transitioning)); + scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_alua_transitioning)); /* second sense will not override the set one */ goto out_unlock_fail; } osi[j].prev_state = osi[j].tg->state; - TRACE_DBG("j %d, group_id %u, tg %s (%p), state %d", j, osi[j].group_id, - osi[j].tg->name, osi[j].tg, osi[j].tg->state); + TRACE_DBG("j %d, group_id %u, tg %s (%p), state %d", + j, osi[j].group_id, osi[j].tg->name, osi[j].tg, osi[j].tg->state); } mutex_unlock(&scst_dg_mutex); @@ -2006,8 +1989,7 @@ int scst_tg_set_group_info(struct scst_cmd *cmd) WARN_ONCE(true, "res = %d\n", res); fallthrough; case -EOVERFLOW: - scst_set_cmd_error(cmd, - SCST_LOAD_SENSE(scst_sense_set_target_pgs_failed)); + scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_set_target_pgs_failed)); break; } |