Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
scsi: pm8001: Simplify pm8001_task_exec()
The main part of the pm8001_task_exec() function uses a do {} while(0) loop
that is useless and only makes the code harder to read. Remove this
loop. The unnecessary local variable t is also removed.
Additionally, avoid repeatedly declaring "struct task_status_struct *ts" to
handle error cases by declaring this variable for the entire function
scope. This allows simplifying the error cases, and together with the
addition of blank lines make the code more readable.
Finally, handling of the running_req counter is fixed to avoid decrementing
it without a corresponding incrementation in the case of an invalid task
protocol.
Link: https://lore.kernel.org/r/20220220031810.738362-29-damien.lemoal@opensource.wdc.com
Reviewed-by: John Garry <john.garry@huawei.com>
Reviewed-by: Jack Wang <jinpu.wang@ionos.com>
Signed-off-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
authored by
Damien Le Moal
and committed by
Martin K. Petersen
e29c47fe
f91767a3
+83
-97
+83
-97
drivers/scsi/pm8001/pm8001_sas.c
+83
-97
drivers/scsi/pm8001/pm8001_sas.c
···
375
375
*/
376
376
int pm8001_queue_command(struct sas_task *task, gfp_t gfp_flags)
377
377
{
378
+
struct task_status_struct *ts = &task->task_status;
379
+
enum sas_protocol task_proto = task->task_proto;
378
380
struct domain_device *dev = task->dev;
381
+
struct pm8001_device *pm8001_dev = dev->lldd_dev;
379
382
struct pm8001_hba_info *pm8001_ha;
380
-
struct pm8001_device *pm8001_dev;
381
383
struct pm8001_port *port = NULL;
382
-
struct sas_task *t = task;
383
384
struct pm8001_ccb_info *ccb;
384
-
u32 rc = 0, n_elem = 0;
385
-
unsigned long flags = 0;
386
-
enum sas_protocol task_proto = t->task_proto;
387
385
struct sas_tmf_task *tmf = task->tmf;
388
386
int is_tmf = !!task->tmf;
387
+
unsigned long flags;
388
+
u32 n_elem = 0;
389
+
int rc = 0;
389
390
390
391
if (!dev->port) {
391
-
struct task_status_struct *tsm = &t->task_status;
392
-
tsm->resp = SAS_TASK_UNDELIVERED;
393
-
tsm->stat = SAS_PHY_DOWN;
394
-
if (dev->dev_type != SAS_SATA_DEV)
395
-
t->task_done(t);
396
-
return 0;
397
-
}
398
-
pm8001_ha = pm8001_find_ha_by_dev(task->dev);
399
-
if (pm8001_ha->controller_fatal_error) {
400
-
struct task_status_struct *ts = &t->task_status;
401
-
402
392
ts->resp = SAS_TASK_UNDELIVERED;
403
-
t->task_done(t);
393
+
ts->stat = SAS_PHY_DOWN;
394
+
if (dev->dev_type != SAS_SATA_DEV)
395
+
task->task_done(task);
404
396
return 0;
405
397
}
398
+
399
+
pm8001_ha = pm8001_find_ha_by_dev(dev);
400
+
if (pm8001_ha->controller_fatal_error) {
401
+
ts->resp = SAS_TASK_UNDELIVERED;
402
+
task->task_done(task);
403
+
return 0;
404
+
}
405
+
406
406
pm8001_dbg(pm8001_ha, IO, "pm8001_task_exec device\n");
407
+
407
408
spin_lock_irqsave(&pm8001_ha->lock, flags);
408
-
do {
409
-
dev = t->dev;
410
-
pm8001_dev = dev->lldd_dev;
411
-
port = &pm8001_ha->port[sas_find_local_port_id(dev)];
412
-
if (DEV_IS_GONE(pm8001_dev) || !port->port_attached) {
413
-
if (sas_protocol_ata(task_proto)) {
414
-
struct task_status_struct *ts = &t->task_status;
415
-
ts->resp = SAS_TASK_UNDELIVERED;
416
-
ts->stat = SAS_PHY_DOWN;
417
409
418
-
spin_unlock_irqrestore(&pm8001_ha->lock, flags);
419
-
t->task_done(t);
420
-
spin_lock_irqsave(&pm8001_ha->lock, flags);
421
-
continue;
422
-
} else {
423
-
struct task_status_struct *ts = &t->task_status;
424
-
ts->resp = SAS_TASK_UNDELIVERED;
425
-
ts->stat = SAS_PHY_DOWN;
426
-
t->task_done(t);
427
-
continue;
428
-
}
429
-
}
410
+
pm8001_dev = dev->lldd_dev;
411
+
port = &pm8001_ha->port[sas_find_local_port_id(dev)];
430
412
431
-
ccb = pm8001_ccb_alloc(pm8001_ha, pm8001_dev, t);
432
-
if (!ccb) {
433
-
rc = -SAS_QUEUE_FULL;
434
-
goto err_out;
435
-
}
436
-
437
-
if (!sas_protocol_ata(task_proto)) {
438
-
if (t->num_scatter) {
439
-
n_elem = dma_map_sg(pm8001_ha->dev,
440
-
t->scatter,
441
-
t->num_scatter,
442
-
t->data_dir);
443
-
if (!n_elem) {
444
-
rc = -ENOMEM;
445
-
goto err_out_ccb;
446
-
}
447
-
}
413
+
if (DEV_IS_GONE(pm8001_dev) || !port->port_attached) {
414
+
ts->resp = SAS_TASK_UNDELIVERED;
415
+
ts->stat = SAS_PHY_DOWN;
416
+
if (sas_protocol_ata(task_proto)) {
417
+
spin_unlock_irqrestore(&pm8001_ha->lock, flags);
418
+
task->task_done(task);
419
+
spin_lock_irqsave(&pm8001_ha->lock, flags);
448
420
} else {
449
-
n_elem = t->num_scatter;
421
+
task->task_done(task);
450
422
}
423
+
rc = -ENODEV;
424
+
goto err_out;
425
+
}
451
426
452
-
t->lldd_task = ccb;
453
-
ccb->n_elem = n_elem;
427
+
ccb = pm8001_ccb_alloc(pm8001_ha, pm8001_dev, task);
428
+
if (!ccb) {
429
+
rc = -SAS_QUEUE_FULL;
430
+
goto err_out;
431
+
}
454
432
455
-
switch (task_proto) {
456
-
case SAS_PROTOCOL_SMP:
457
-
atomic_inc(&pm8001_dev->running_req);
458
-
rc = pm8001_task_prep_smp(pm8001_ha, ccb);
459
-
break;
460
-
case SAS_PROTOCOL_SSP:
461
-
atomic_inc(&pm8001_dev->running_req);
462
-
if (is_tmf)
463
-
rc = pm8001_task_prep_ssp_tm(pm8001_ha,
464
-
ccb, tmf);
465
-
else
466
-
rc = pm8001_task_prep_ssp(pm8001_ha, ccb);
467
-
break;
468
-
case SAS_PROTOCOL_SATA:
469
-
case SAS_PROTOCOL_STP:
470
-
atomic_inc(&pm8001_dev->running_req);
471
-
rc = pm8001_task_prep_ata(pm8001_ha, ccb);
472
-
break;
473
-
default:
474
-
dev_printk(KERN_ERR, pm8001_ha->dev,
475
-
"unknown sas_task proto: 0x%x\n", task_proto);
476
-
rc = -EINVAL;
477
-
break;
433
+
if (!sas_protocol_ata(task_proto)) {
434
+
if (task->num_scatter) {
435
+
n_elem = dma_map_sg(pm8001_ha->dev, task->scatter,
436
+
task->num_scatter, task->data_dir);
437
+
if (!n_elem) {
438
+
rc = -ENOMEM;
439
+
goto err_out_ccb;
440
+
}
478
441
}
442
+
} else {
443
+
n_elem = task->num_scatter;
444
+
}
479
445
480
-
if (rc) {
481
-
pm8001_dbg(pm8001_ha, IO, "rc is %x\n", rc);
482
-
atomic_dec(&pm8001_dev->running_req);
483
-
goto err_out_ccb;
484
-
}
485
-
/* TODO: select normal or high priority */
486
-
} while (0);
487
-
rc = 0;
488
-
goto out_done;
446
+
task->lldd_task = ccb;
447
+
ccb->n_elem = n_elem;
489
448
449
+
atomic_inc(&pm8001_dev->running_req);
450
+
451
+
switch (task_proto) {
452
+
case SAS_PROTOCOL_SMP:
453
+
rc = pm8001_task_prep_smp(pm8001_ha, ccb);
454
+
break;
455
+
case SAS_PROTOCOL_SSP:
456
+
if (is_tmf)
457
+
rc = pm8001_task_prep_ssp_tm(pm8001_ha, ccb, tmf);
458
+
else
459
+
rc = pm8001_task_prep_ssp(pm8001_ha, ccb);
460
+
break;
461
+
case SAS_PROTOCOL_SATA:
462
+
case SAS_PROTOCOL_STP:
463
+
rc = pm8001_task_prep_ata(pm8001_ha, ccb);
464
+
break;
465
+
default:
466
+
dev_printk(KERN_ERR, pm8001_ha->dev,
467
+
"unknown sas_task proto: 0x%x\n", task_proto);
468
+
rc = -EINVAL;
469
+
break;
470
+
}
471
+
472
+
if (rc) {
473
+
atomic_dec(&pm8001_dev->running_req);
474
+
if (!sas_protocol_ata(task_proto) && n_elem)
475
+
dma_unmap_sg(pm8001_ha->dev, task->scatter,
476
+
task->num_scatter, task->data_dir);
490
477
err_out_ccb:
491
-
pm8001_ccb_free(pm8001_ha, ccb);
478
+
pm8001_ccb_free(pm8001_ha, ccb);
479
+
492
480
err_out:
493
-
dev_printk(KERN_ERR, pm8001_ha->dev, "pm8001 exec failed[%d]!\n", rc);
494
-
if (!sas_protocol_ata(task_proto))
495
-
if (n_elem)
496
-
dma_unmap_sg(pm8001_ha->dev, t->scatter, t->num_scatter,
497
-
t->data_dir);
498
-
out_done:
481
+
pm8001_dbg(pm8001_ha, IO, "pm8001_task_exec failed[%d]!\n", rc);
482
+
}
483
+
499
484
spin_unlock_irqrestore(&pm8001_ha->lock, flags);
485
+
500
486
return rc;
501
487
}
502
488