Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge patch series "qla2xxx driver enhancements"
Nilesh Javali <njavali@marvell.com> says:
Please apply the qla2xxx driver enhancements to the SCSI tree at your
earliest convenience.
Link: https://lore.kernel.org/r/20221222043933.2825-1-njavali@marvell.com
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
+529
-671
+2
-3
drivers/scsi/qla2xxx/qla_attr.c
+2
-3
drivers/scsi/qla2xxx/qla_attr.c
···
2732
2732
spin_lock_irqsave(host->host_lock, flags);
2733
2733
/* Confirm port has not reappeared before clearing pointers. */
2734
2734
if (rport->port_state != FC_PORTSTATE_ONLINE) {
2735
-
fcport->rport = fcport->drport = NULL;
2735
+
fcport->rport = NULL;
2736
2736
*((fc_port_t **)rport->dd_data) = NULL;
2737
2737
}
2738
2738
spin_unlock_irqrestore(host->host_lock, flags);
···
3171
3171
3172
3172
set_bit(VPORT_DELETE, &vha->dpc_flags);
3173
3173
3174
-
while (test_bit(LOOP_RESYNC_ACTIVE, &vha->dpc_flags) ||
3175
-
test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags))
3174
+
while (test_bit(LOOP_RESYNC_ACTIVE, &vha->dpc_flags))
3176
3175
msleep(1000);
3177
3176
3178
3177
+31
-14
drivers/scsi/qla2xxx/qla_def.h
+31
-14
drivers/scsi/qla2xxx/qla_def.h
···
384
384
struct req_que;
385
385
struct qla_tgt_sess;
386
386
387
+
struct qla_buf_dsc {
388
+
u16 tag;
389
+
#define TAG_FREED 0xffff
390
+
void *buf;
391
+
dma_addr_t buf_dma;
392
+
};
393
+
387
394
/*
388
395
* SCSI Request Block
389
396
*/
···
399
392
uint32_t request_sense_length;
400
393
uint32_t fw_sense_length;
401
394
uint8_t *request_sense_ptr;
402
-
struct ct6_dsd *ct6_ctx;
403
395
struct crc_context *crc_ctx;
396
+
struct ct6_dsd ct6_ctx;
397
+
struct qla_buf_dsc buf_dsc;
404
398
};
405
399
406
400
/*
407
401
* SRB flag definitions
408
402
*/
409
403
#define SRB_DMA_VALID BIT_0 /* Command sent to ISP */
404
+
#define SRB_GOT_BUF BIT_1
410
405
#define SRB_FCP_CMND_DMA_VALID BIT_12 /* DIF: DSD List valid */
411
406
#define SRB_CRC_CTX_DMA_VALID BIT_2 /* DIF: context DMA valid */
412
407
#define SRB_CRC_PROT_DMA_VALID BIT_4 /* DIF: prot DMA valid */
···
2494
2485
2495
2486
enum discovery_state {
2496
2487
DSC_DELETED,
2497
-
DSC_GNN_ID,
2498
2488
DSC_GNL,
2499
2489
DSC_LOGIN_PEND,
2500
2490
DSC_LOGIN_FAILED,
···
2604
2596
2605
2597
int login_retry;
2606
2598
2607
-
struct fc_rport *rport, *drport;
2599
+
struct fc_rport *rport;
2608
2600
u32 supported_classes;
2609
2601
2610
2602
uint8_t fc4_type;
···
2707
2699
2708
2700
static const char *const port_dstate_str[] = {
2709
2701
[DSC_DELETED] = "DELETED",
2710
-
[DSC_GNN_ID] = "GNN_ID",
2711
2702
[DSC_GNL] = "GNL",
2712
2703
[DSC_LOGIN_PEND] = "LOGIN_PEND",
2713
2704
[DSC_LOGIN_FAILED] = "LOGIN_FAILED",
···
3469
3462
int have_irq;
3470
3463
int in_use;
3471
3464
uint32_t vector;
3465
+
uint32_t vector_base0;
3472
3466
uint16_t entry;
3473
3467
char name[30];
3474
3468
void *handle;
···
3487
3479
QLA_EVT_ASYNC_ADISC,
3488
3480
QLA_EVT_UEVENT,
3489
3481
QLA_EVT_AENFX,
3490
-
QLA_EVT_GPNID,
3491
3482
QLA_EVT_UNMAP,
3492
3483
QLA_EVT_NEW_SESS,
3493
3484
QLA_EVT_GPDB,
···
3500
3493
QLA_EVT_GPNFT,
3501
3494
QLA_EVT_GPNFT_DONE,
3502
3495
QLA_EVT_GNNFT_DONE,
3503
-
QLA_EVT_GNNID,
3504
3496
QLA_EVT_GFPNID,
3505
3497
QLA_EVT_SP_RETRY,
3506
3498
QLA_EVT_IIDMA,
···
3542
3536
} iosb;
3543
3537
struct {
3544
3538
port_id_t id;
3545
-
} gpnid;
3546
-
struct {
3547
-
port_id_t id;
3548
3539
u8 port_name[8];
3549
3540
u8 node_name[8];
3550
3541
void *pla;
3551
3542
u8 fc4_type;
3552
3543
} new_sess;
3553
-
struct { /*Get PDB, Get Speed, update fcport, gnl, gidpn */
3544
+
struct { /*Get PDB, Get Speed, update fcport, gnl */
3554
3545
fc_port_t *fcport;
3555
3546
u8 opt;
3556
3547
} fcport;
···
3732
3729
3733
3730
#define QLA_IOCB_PCT_LIMIT 95
3734
3731
3732
+
struct qla_buf_pool {
3733
+
u16 num_bufs;
3734
+
u16 num_active;
3735
+
u16 max_used;
3736
+
u16 num_alloc;
3737
+
u16 prev_max;
3738
+
u16 pad;
3739
+
uint32_t take_snapshot:1;
3740
+
unsigned long *buf_map;
3741
+
void **buf_array;
3742
+
dma_addr_t *dma_array;
3743
+
};
3744
+
3735
3745
/*Queue pair data structure */
3736
3746
struct qla_qpair {
3737
3747
spinlock_t qp_lock;
···
3798
3782
struct qla_tgt_counters tgt_counters;
3799
3783
uint16_t cpuid;
3800
3784
struct qla_fw_resources fwres ____cacheline_aligned;
3785
+
struct qla_buf_pool buf_pool;
3801
3786
u32 cmd_cnt;
3802
3787
u32 cmd_completion_cnt;
3803
3788
u32 prev_completion_cnt;
···
3959
3942
__le32 __iomem *atio_q_out;
3960
3943
3961
3944
const struct qla_tgt_func_tmpl *tgt_ops;
3962
-
struct qla_tgt_vp_map *tgt_vp_map;
3963
3945
3964
3946
int saved_set;
3965
3947
__le16 saved_exchange_count;
···
4126
4110
struct req_que **req_q_map;
4127
4111
struct rsp_que **rsp_q_map;
4128
4112
struct qla_qpair **queue_pair_map;
4113
+
struct qla_qpair **qp_cpu_map;
4129
4114
unsigned long req_qid_map[(QLA_MAX_QUEUES / 8) / sizeof(unsigned long)];
4130
4115
unsigned long rsp_qid_map[(QLA_MAX_QUEUES / 8) / sizeof(unsigned long)];
4131
4116
unsigned long qpair_qid_map[(QLA_MAX_QUEUES / 8)
···
4783
4766
spinlock_t sadb_lock; /* protects list */
4784
4767
struct els_reject elsrej;
4785
4768
u8 edif_post_stop_cnt_down;
4769
+
struct qla_vp_map *vp_map;
4786
4770
};
4787
4771
4788
4772
#define RX_ELS_SIZE (roundup(sizeof(struct enode) + ELS_MAX_PAYLOAD, SMP_CACHE_BYTES))
···
4879
4861
#define LOOP_READY 5
4880
4862
#define LOOP_DEAD 6
4881
4863
4864
+
unsigned long buf_expired;
4882
4865
unsigned long relogin_jif;
4883
4866
unsigned long dpc_flags;
4884
4867
#define RESET_MARKER_NEEDED 0 /* Send marker to ISP. */
···
4895
4876
#define ISP_ABORT_RETRY 10 /* ISP aborted. */
4896
4877
#define BEACON_BLINK_NEEDED 11
4897
4878
#define REGISTER_FDMI_NEEDED 12
4898
-
#define FCPORT_UPDATE_NEEDED 13
4899
4879
#define VP_DPC_NEEDED 14 /* wake up for VP dpc handling */
4900
4880
#define UNLOADING 15
4901
4881
#define NPIV_CONFIG_NEEDED 16
···
5044
5026
uint8_t n2n_port_name[WWN_SIZE];
5045
5027
uint16_t n2n_id;
5046
5028
__le16 dport_data[4];
5047
-
struct list_head gpnid_list;
5048
5029
struct fab_scan scan;
5049
5030
uint8_t scm_fabric_connection_flags;
5050
5031
···
5085
5068
#define SET_AL_PA 2
5086
5069
#define RESET_VP_IDX 3
5087
5070
#define RESET_AL_PA 4
5088
-
struct qla_tgt_vp_map {
5071
+
struct qla_vp_map {
5089
5072
uint8_t idx;
5090
5073
scsi_qla_host_t *vha;
5091
5074
};
+59
-30
drivers/scsi/qla2xxx/qla_edif.c
+59
-30
drivers/scsi/qla2xxx/qla_edif.c
···
480
480
}
481
481
482
482
/**
483
+
* qla_delete_n2n_sess_and_wait: search for N2N session, tear it down and
484
+
* wait for tear down to complete. In N2N topology, there is only one
485
+
* session being active in tracking the remote device.
486
+
* @vha: host adapter pointer
487
+
* return code: 0 - found the session and completed the tear down.
488
+
* 1 - timeout occurred. Caller to use link bounce to reset.
489
+
*/
490
+
static int qla_delete_n2n_sess_and_wait(scsi_qla_host_t *vha)
491
+
{
492
+
struct fc_port *fcport;
493
+
int rc = -EIO;
494
+
ulong expire = jiffies + 23 * HZ;
495
+
496
+
if (!N2N_TOPO(vha->hw))
497
+
return 0;
498
+
499
+
fcport = NULL;
500
+
list_for_each_entry(fcport, &vha->vp_fcports, list) {
501
+
if (!fcport->n2n_flag)
502
+
continue;
503
+
504
+
ql_dbg(ql_dbg_disc, fcport->vha, 0x2016,
505
+
"%s reset sess at app start \n", __func__);
506
+
507
+
qla_edif_sa_ctl_init(vha, fcport);
508
+
qlt_schedule_sess_for_deletion(fcport);
509
+
510
+
while (time_before_eq(jiffies, expire)) {
511
+
if (fcport->disc_state != DSC_DELETE_PEND) {
512
+
rc = 0;
513
+
break;
514
+
}
515
+
msleep(1);
516
+
}
517
+
518
+
set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
519
+
break;
520
+
}
521
+
522
+
return rc;
523
+
}
524
+
525
+
/**
483
526
* qla_edif_app_start: application has announce its present
484
527
* @vha: host adapter pointer
485
528
* @bsg_job: user request
···
561
518
fcport->n2n_link_reset_cnt = 0;
562
519
563
520
if (vha->hw->flags.n2n_fw_acc_sec) {
564
-
list_for_each_entry_safe(fcport, tf, &vha->vp_fcports, list)
565
-
qla_edif_sa_ctl_init(vha, fcport);
566
-
521
+
bool link_bounce = false;
567
522
/*
568
523
* While authentication app was not running, remote device
569
524
* could still try to login with this local port. Let's
570
-
* clear the state and try again.
525
+
* reset the session, reconnect and re-authenticate.
571
526
*/
572
-
qla2x00_wait_for_sess_deletion(vha);
527
+
if (qla_delete_n2n_sess_and_wait(vha))
528
+
link_bounce = true;
573
529
574
-
/* bounce the link to get the other guy to relogin */
575
-
if (!vha->hw->flags.n2n_bigger) {
530
+
/* bounce the link to start login */
531
+
if (!vha->hw->flags.n2n_bigger || link_bounce) {
576
532
set_bit(N2N_LINK_RESET, &vha->dpc_flags);
577
533
qla2xxx_wake_dpc(vha);
578
534
}
···
967
925
if (!(fcport->flags & FCF_FCSP_DEVICE))
968
926
continue;
969
927
970
-
tdid = app_req.remote_pid;
928
+
tdid.b.domain = app_req.remote_pid.domain;
929
+
tdid.b.area = app_req.remote_pid.area;
930
+
tdid.b.al_pa = app_req.remote_pid.al_pa;
971
931
972
932
ql_dbg(ql_dbg_edif, vha, 0x2058,
973
933
"APP request entry - portid=%06x.\n", tdid.b24);
···
3051
3007
goto queuing_error;
3052
3008
}
3053
3009
3054
-
ctx = sp->u.scmd.ct6_ctx =
3055
-
mempool_alloc(ha->ctx_mempool, GFP_ATOMIC);
3056
-
if (!ctx) {
3057
-
ql_log(ql_log_fatal, vha, 0x3010,
3058
-
"Failed to allocate ctx for cmd=%p.\n", cmd);
3059
-
goto queuing_error;
3060
-
}
3061
-
3062
-
memset(ctx, 0, sizeof(struct ct6_dsd));
3063
-
ctx->fcp_cmnd = dma_pool_zalloc(ha->fcp_cmnd_dma_pool,
3064
-
GFP_ATOMIC, &ctx->fcp_cmnd_dma);
3065
-
if (!ctx->fcp_cmnd) {
3010
+
if (qla_get_buf(vha, sp->qpair, &sp->u.scmd.buf_dsc)) {
3066
3011
ql_log(ql_log_fatal, vha, 0x3011,
3067
-
"Failed to allocate fcp_cmnd for cmd=%p.\n", cmd);
3012
+
"Failed to allocate buf for fcp_cmnd for cmd=%p.\n", cmd);
3068
3013
goto queuing_error;
3069
3014
}
3070
3015
3071
-
/* Initialize the DSD list and dma handle */
3072
-
INIT_LIST_HEAD(&ctx->dsd_list);
3073
-
ctx->dsd_use_cnt = 0;
3016
+
sp->flags |= SRB_GOT_BUF;
3017
+
ctx = &sp->u.scmd.ct6_ctx;
3018
+
ctx->fcp_cmnd = sp->u.scmd.buf_dsc.buf;
3019
+
ctx->fcp_cmnd_dma = sp->u.scmd.buf_dsc.buf_dma;
3074
3020
3075
3021
if (cmd->cmd_len > 16) {
3076
3022
additional_cdb_len = cmd->cmd_len - 16;
···
3179
3145
cmd_pkt->fcp_cmnd_dseg_len = cpu_to_le16(ctx->fcp_cmnd_len);
3180
3146
put_unaligned_le64(ctx->fcp_cmnd_dma, &cmd_pkt->fcp_cmnd_dseg_address);
3181
3147
3182
-
sp->flags |= SRB_FCP_CMND_DMA_VALID;
3183
3148
cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd));
3184
3149
/* Set total data segment count. */
3185
3150
cmd_pkt->entry_count = (uint8_t)req_cnt;
···
3210
3177
return QLA_SUCCESS;
3211
3178
3212
3179
queuing_error_fcp_cmnd:
3213
-
dma_pool_free(ha->fcp_cmnd_dma_pool, ctx->fcp_cmnd, ctx->fcp_cmnd_dma);
3214
3180
queuing_error:
3215
3181
if (tot_dsds)
3216
3182
scsi_dma_unmap(cmd);
3217
3183
3218
-
if (sp->u.scmd.ct6_ctx) {
3219
-
mempool_free(sp->u.scmd.ct6_ctx, ha->ctx_mempool);
3220
-
sp->u.scmd.ct6_ctx = NULL;
3221
-
}
3184
+
qla_put_buf(sp->qpair, &sp->u.scmd.buf_dsc);
3222
3185
qla_put_fw_resources(sp->qpair, &sp->iores);
3223
3186
spin_unlock_irqrestore(lock, flags);
3224
3187
+2
drivers/scsi/qla2xxx/qla_edif.h
+2
drivers/scsi/qla2xxx/qla_edif.h
+14
-1
drivers/scsi/qla2xxx/qla_edif_bsg.h
+14
-1
drivers/scsi/qla2xxx/qla_edif_bsg.h
···
89
89
struct app_pinfo_req {
90
90
struct app_id app_info;
91
91
uint8_t num_ports;
92
-
port_id_t remote_pid;
92
+
struct {
93
+
#ifdef __BIG_ENDIAN
94
+
uint8_t domain;
95
+
uint8_t area;
96
+
uint8_t al_pa;
97
+
#elif defined(__LITTLE_ENDIAN)
98
+
uint8_t al_pa;
99
+
uint8_t area;
100
+
uint8_t domain;
101
+
#else
102
+
#error "__BIG_ENDIAN or __LITTLE_ENDIAN must be defined!"
103
+
#endif
104
+
uint8_t rsvd_1;
105
+
} remote_pid;
93
106
uint8_t version;
94
107
uint8_t pad[VND_CMD_PAD_SIZE];
95
108
uint8_t reserved[VND_CMD_APP_RESERVED_SIZE];
+9
-9
drivers/scsi/qla2xxx/qla_gbl.h
+9
-9
drivers/scsi/qla2xxx/qla_gbl.h
···
257
257
/*
258
258
* Global Functions in qla_mid.c source file.
259
259
*/
260
+
extern void qla_update_vp_map(struct scsi_qla_host *, int);
260
261
extern struct scsi_host_template qla2xxx_driver_template;
261
262
extern struct scsi_transport_template *qla2xxx_transport_vport_template;
262
263
extern void qla2x00_timer(struct timer_list *);
···
293
292
extern void qla2x00_async_event(scsi_qla_host_t *, struct rsp_que *,
294
293
uint16_t *);
295
294
extern int qla2x00_vp_abort_isp(scsi_qla_host_t *);
295
+
void qla_adjust_buf(struct scsi_qla_host *);
296
296
297
297
/*
298
298
* Global Function Prototypes in qla_iocb.c source file.
···
723
721
struct ct_sns_rsp *, const char *);
724
722
extern void qla2x00_async_iocb_timeout(void *data);
725
723
726
-
extern int qla24xx_post_gpnid_work(struct scsi_qla_host *, port_id_t *);
727
-
extern int qla24xx_async_gpnid(scsi_qla_host_t *, port_id_t *);
728
-
void qla24xx_handle_gpnid_event(scsi_qla_host_t *, struct event_arg *);
729
-
730
724
int qla24xx_post_gpsc_work(struct scsi_qla_host *, fc_port_t *);
731
725
int qla24xx_async_gpsc(scsi_qla_host_t *, fc_port_t *);
732
726
void qla24xx_handle_gpsc_event(scsi_qla_host_t *, struct event_arg *);
···
732
734
int qla24xx_async_gpnft(scsi_qla_host_t *, u8, srb_t *);
733
735
void qla24xx_async_gpnft_done(scsi_qla_host_t *, srb_t *);
734
736
void qla24xx_async_gnnft_done(scsi_qla_host_t *, srb_t *);
735
-
int qla24xx_async_gnnid(scsi_qla_host_t *, fc_port_t *);
736
-
void qla24xx_handle_gnnid_event(scsi_qla_host_t *, struct event_arg *);
737
-
int qla24xx_post_gnnid_work(struct scsi_qla_host *, fc_port_t *);
738
737
int qla24xx_post_gfpnid_work(struct scsi_qla_host *, fc_port_t *);
739
738
int qla24xx_async_gfpnid(scsi_qla_host_t *, fc_port_t *);
740
739
void qla24xx_handle_gfpnid_event(scsi_qla_host_t *, struct event_arg *);
···
957
962
uint64_t wwn, port_id_t port_id, uint16_t loop_id, struct fc_port **);
958
963
void qla24xx_delete_sess_fn(struct work_struct *);
959
964
void qlt_unknown_atio_work_fn(struct work_struct *);
960
-
void qlt_update_host_map(struct scsi_qla_host *, port_id_t);
965
+
void qla_update_host_map(struct scsi_qla_host *, port_id_t);
961
966
void qla_remove_hostmap(struct qla_hw_data *ha);
962
967
void qlt_clr_qp_table(struct scsi_qla_host *vha);
963
968
void qlt_set_mode(struct scsi_qla_host *);
···
970
975
(struct abort_entry_24xx *abt, srb_t *sp);
971
976
extern void qla_nvme_abort_process_comp_status
972
977
(struct abort_entry_24xx *abt, srb_t *sp);
978
+
struct scsi_qla_host *qla_find_host_by_vp_idx(struct scsi_qla_host *vha,
979
+
uint16_t vp_idx);
973
980
974
981
/* nvme.c */
975
982
void qla_nvme_unregister_remote_port(struct fc_port *fcport);
···
1016
1019
1017
1020
uint64_t qla2x00_get_num_tgts(scsi_qla_host_t *vha);
1018
1021
uint64_t qla2x00_count_set_bits(u32 num);
1019
-
1022
+
int qla_create_buf_pool(struct scsi_qla_host *, struct qla_qpair *);
1023
+
void qla_free_buf_pool(struct qla_qpair *);
1024
+
int qla_get_buf(struct scsi_qla_host *, struct qla_qpair *, struct qla_buf_dsc *);
1025
+
void qla_put_buf(struct qla_qpair *, struct qla_buf_dsc *);
1020
1026
#endif /* _QLA_GBL_H */
-407
drivers/scsi/qla2xxx/qla_gs.c
-407
drivers/scsi/qla2xxx/qla_gs.c
···
2949
2949
return rval;
2950
2950
}
2951
2951
2952
-
int qla24xx_post_gpnid_work(struct scsi_qla_host *vha, port_id_t *id)
2953
-
{
2954
-
struct qla_work_evt *e;
2955
-
2956
-
if (test_bit(UNLOADING, &vha->dpc_flags) ||
2957
-
(vha->vp_idx && test_bit(VPORT_DELETE, &vha->dpc_flags)))
2958
-
return 0;
2959
-
2960
-
e = qla2x00_alloc_work(vha, QLA_EVT_GPNID);
2961
-
if (!e)
2962
-
return QLA_FUNCTION_FAILED;
2963
-
2964
-
e->u.gpnid.id = *id;
2965
-
return qla2x00_post_work(vha, e);
2966
-
}
2967
-
2968
2952
void qla24xx_sp_unmap(scsi_qla_host_t *vha, srb_t *sp)
2969
2953
{
2970
2954
struct srb_iocb *c = &sp->u.iocb_cmd;
···
2980
2996
/* ref: INIT */
2981
2997
kref_put(&sp->cmd_kref, qla2x00_sp_release);
2982
2998
}
2983
-
2984
-
void qla24xx_handle_gpnid_event(scsi_qla_host_t *vha, struct event_arg *ea)
2985
-
{
2986
-
fc_port_t *fcport, *conflict, *t;
2987
-
u16 data[2];
2988
-
2989
-
ql_dbg(ql_dbg_disc, vha, 0xffff,
2990
-
"%s %d port_id: %06x\n",
2991
-
__func__, __LINE__, ea->id.b24);
2992
-
2993
-
if (ea->rc) {
2994
-
/* cable is disconnected */
2995
-
list_for_each_entry_safe(fcport, t, &vha->vp_fcports, list) {
2996
-
if (fcport->d_id.b24 == ea->id.b24)
2997
-
fcport->scan_state = QLA_FCPORT_SCAN;
2998
-
2999
-
qlt_schedule_sess_for_deletion(fcport);
3000
-
}
3001
-
} else {
3002
-
/* cable is connected */
3003
-
fcport = qla2x00_find_fcport_by_wwpn(vha, ea->port_name, 1);
3004
-
if (fcport) {
3005
-
list_for_each_entry_safe(conflict, t, &vha->vp_fcports,
3006
-
list) {
3007
-
if ((conflict->d_id.b24 == ea->id.b24) &&
3008
-
(fcport != conflict))
3009
-
/*
3010
-
* 2 fcports with conflict Nport ID or
3011
-
* an existing fcport is having nport ID
3012
-
* conflict with new fcport.
3013
-
*/
3014
-
3015
-
conflict->scan_state = QLA_FCPORT_SCAN;
3016
-
3017
-
qlt_schedule_sess_for_deletion(conflict);
3018
-
}
3019
-
3020
-
fcport->scan_needed = 0;
3021
-
fcport->rscn_gen++;
3022
-
fcport->scan_state = QLA_FCPORT_FOUND;
3023
-
fcport->flags |= FCF_FABRIC_DEVICE;
3024
-
if (fcport->login_retry == 0) {
3025
-
fcport->login_retry =
3026
-
vha->hw->login_retry_count;
3027
-
ql_dbg(ql_dbg_disc, vha, 0xffff,
3028
-
"Port login retry %8phN, lid 0x%04x cnt=%d.\n",
3029
-
fcport->port_name, fcport->loop_id,
3030
-
fcport->login_retry);
3031
-
}
3032
-
switch (fcport->disc_state) {
3033
-
case DSC_LOGIN_COMPLETE:
3034
-
/* recheck session is still intact. */
3035
-
ql_dbg(ql_dbg_disc, vha, 0x210d,
3036
-
"%s %d %8phC revalidate session with ADISC\n",
3037
-
__func__, __LINE__, fcport->port_name);
3038
-
data[0] = data[1] = 0;
3039
-
qla2x00_post_async_adisc_work(vha, fcport,
3040
-
data);
3041
-
break;
3042
-
case DSC_DELETED:
3043
-
ql_dbg(ql_dbg_disc, vha, 0x210d,
3044
-
"%s %d %8phC login\n", __func__, __LINE__,
3045
-
fcport->port_name);
3046
-
fcport->d_id = ea->id;
3047
-
qla24xx_fcport_handle_login(vha, fcport);
3048
-
break;
3049
-
case DSC_DELETE_PEND:
3050
-
fcport->d_id = ea->id;
3051
-
break;
3052
-
default:
3053
-
fcport->d_id = ea->id;
3054
-
break;
3055
-
}
3056
-
} else {
3057
-
list_for_each_entry_safe(conflict, t, &vha->vp_fcports,
3058
-
list) {
3059
-
if (conflict->d_id.b24 == ea->id.b24) {
3060
-
/* 2 fcports with conflict Nport ID or
3061
-
* an existing fcport is having nport ID
3062
-
* conflict with new fcport.
3063
-
*/
3064
-
ql_dbg(ql_dbg_disc, vha, 0xffff,
3065
-
"%s %d %8phC DS %d\n",
3066
-
__func__, __LINE__,
3067
-
conflict->port_name,
3068
-
conflict->disc_state);
3069
-
3070
-
conflict->scan_state = QLA_FCPORT_SCAN;
3071
-
qlt_schedule_sess_for_deletion(conflict);
3072
-
}
3073
-
}
3074
-
3075
-
/* create new fcport */
3076
-
ql_dbg(ql_dbg_disc, vha, 0x2065,
3077
-
"%s %d %8phC post new sess\n",
3078
-
__func__, __LINE__, ea->port_name);
3079
-
qla24xx_post_newsess_work(vha, &ea->id,
3080
-
ea->port_name, NULL, NULL, 0);
3081
-
}
3082
-
}
3083
-
}
3084
-
3085
-
static void qla2x00_async_gpnid_sp_done(srb_t *sp, int res)
3086
-
{
3087
-
struct scsi_qla_host *vha = sp->vha;
3088
-
struct ct_sns_req *ct_req =
3089
-
(struct ct_sns_req *)sp->u.iocb_cmd.u.ctarg.req;
3090
-
struct ct_sns_rsp *ct_rsp =
3091
-
(struct ct_sns_rsp *)sp->u.iocb_cmd.u.ctarg.rsp;
3092
-
struct event_arg ea;
3093
-
struct qla_work_evt *e;
3094
-
unsigned long flags;
3095
-
3096
-
if (res)
3097
-
ql_dbg(ql_dbg_disc, vha, 0x2066,
3098
-
"Async done-%s fail res %x rscn gen %d ID %3phC. %8phC\n",
3099
-
sp->name, res, sp->gen1, &ct_req->req.port_id.port_id,
3100
-
ct_rsp->rsp.gpn_id.port_name);
3101
-
else
3102
-
ql_dbg(ql_dbg_disc, vha, 0x2066,
3103
-
"Async done-%s good rscn gen %d ID %3phC. %8phC\n",
3104
-
sp->name, sp->gen1, &ct_req->req.port_id.port_id,
3105
-
ct_rsp->rsp.gpn_id.port_name);
3106
-
3107
-
memset(&ea, 0, sizeof(ea));
3108
-
memcpy(ea.port_name, ct_rsp->rsp.gpn_id.port_name, WWN_SIZE);
3109
-
ea.sp = sp;
3110
-
ea.id = be_to_port_id(ct_req->req.port_id.port_id);
3111
-
ea.rc = res;
3112
-
3113
-
spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
3114
-
list_del(&sp->elem);
3115
-
spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
3116
-
3117
-
if (res) {
3118
-
if (res == QLA_FUNCTION_TIMEOUT) {
3119
-
qla24xx_post_gpnid_work(sp->vha, &ea.id);
3120
-
/* ref: INIT */
3121
-
kref_put(&sp->cmd_kref, qla2x00_sp_release);
3122
-
return;
3123
-
}
3124
-
} else if (sp->gen1) {
3125
-
/* There was another RSCN for this Nport ID */
3126
-
qla24xx_post_gpnid_work(sp->vha, &ea.id);
3127
-
/* ref: INIT */
3128
-
kref_put(&sp->cmd_kref, qla2x00_sp_release);
3129
-
return;
3130
-
}
3131
-
3132
-
qla24xx_handle_gpnid_event(vha, &ea);
3133
-
3134
-
e = qla2x00_alloc_work(vha, QLA_EVT_UNMAP);
3135
-
if (!e) {
3136
-
/* please ignore kernel warning. otherwise, we have mem leak. */
3137
-
dma_free_coherent(&vha->hw->pdev->dev,
3138
-
sp->u.iocb_cmd.u.ctarg.req_allocated_size,
3139
-
sp->u.iocb_cmd.u.ctarg.req,
3140
-
sp->u.iocb_cmd.u.ctarg.req_dma);
3141
-
sp->u.iocb_cmd.u.ctarg.req = NULL;
3142
-
3143
-
dma_free_coherent(&vha->hw->pdev->dev,
3144
-
sp->u.iocb_cmd.u.ctarg.rsp_allocated_size,
3145
-
sp->u.iocb_cmd.u.ctarg.rsp,
3146
-
sp->u.iocb_cmd.u.ctarg.rsp_dma);
3147
-
sp->u.iocb_cmd.u.ctarg.rsp = NULL;
3148
-
3149
-
/* ref: INIT */
3150
-
kref_put(&sp->cmd_kref, qla2x00_sp_release);
3151
-
return;
3152
-
}
3153
-
3154
-
e->u.iosb.sp = sp;
3155
-
qla2x00_post_work(vha, e);
3156
-
}
3157
-
3158
-
/* Get WWPN with Nport ID. */
3159
-
int qla24xx_async_gpnid(scsi_qla_host_t *vha, port_id_t *id)
3160
-
{
3161
-
int rval = QLA_FUNCTION_FAILED;
3162
-
struct ct_sns_req *ct_req;
3163
-
srb_t *sp, *tsp;
3164
-
struct ct_sns_pkt *ct_sns;
3165
-
unsigned long flags;
3166
-
3167
-
if (!vha->flags.online)
3168
-
goto done;
3169
-
3170
-
/* ref: INIT */
3171
-
sp = qla2x00_get_sp(vha, NULL, GFP_KERNEL);
3172
-
if (!sp)
3173
-
goto done;
3174
-
3175
-
sp->type = SRB_CT_PTHRU_CMD;
3176
-
sp->name = "gpnid";
3177
-
sp->u.iocb_cmd.u.ctarg.id = *id;
3178
-
sp->gen1 = 0;
3179
-
qla2x00_init_async_sp(sp, qla2x00_get_async_timeout(vha) + 2,
3180
-
qla2x00_async_gpnid_sp_done);
3181
-
3182
-
spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
3183
-
list_for_each_entry(tsp, &vha->gpnid_list, elem) {
3184
-
if (tsp->u.iocb_cmd.u.ctarg.id.b24 == id->b24) {
3185
-
tsp->gen1++;
3186
-
spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
3187
-
/* ref: INIT */
3188
-
kref_put(&sp->cmd_kref, qla2x00_sp_release);
3189
-
goto done;
3190
-
}
3191
-
}
3192
-
list_add_tail(&sp->elem, &vha->gpnid_list);
3193
-
spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
3194
-
3195
-
sp->u.iocb_cmd.u.ctarg.req = dma_alloc_coherent(&vha->hw->pdev->dev,
3196
-
sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.req_dma,
3197
-
GFP_KERNEL);
3198
-
sp->u.iocb_cmd.u.ctarg.req_allocated_size = sizeof(struct ct_sns_pkt);
3199
-
if (!sp->u.iocb_cmd.u.ctarg.req) {
3200
-
ql_log(ql_log_warn, vha, 0xd041,
3201
-
"Failed to allocate ct_sns request.\n");
3202
-
goto done_free_sp;
3203
-
}
3204
-
3205
-
sp->u.iocb_cmd.u.ctarg.rsp = dma_alloc_coherent(&vha->hw->pdev->dev,
3206
-
sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.rsp_dma,
3207
-
GFP_KERNEL);
3208
-
sp->u.iocb_cmd.u.ctarg.rsp_allocated_size = sizeof(struct ct_sns_pkt);
3209
-
if (!sp->u.iocb_cmd.u.ctarg.rsp) {
3210
-
ql_log(ql_log_warn, vha, 0xd042,
3211
-
"Failed to allocate ct_sns request.\n");
3212
-
goto done_free_sp;
3213
-
}
3214
-
3215
-
ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.rsp;
3216
-
memset(ct_sns, 0, sizeof(*ct_sns));
3217
-
3218
-
ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.req;
3219
-
/* CT_IU preamble */
3220
-
ct_req = qla2x00_prep_ct_req(ct_sns, GPN_ID_CMD, GPN_ID_RSP_SIZE);
3221
-
3222
-
/* GPN_ID req */
3223
-
ct_req->req.port_id.port_id = port_id_to_be_id(*id);
3224
-
3225
-
sp->u.iocb_cmd.u.ctarg.req_size = GPN_ID_REQ_SIZE;
3226
-
sp->u.iocb_cmd.u.ctarg.rsp_size = GPN_ID_RSP_SIZE;
3227
-
sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
3228
-
3229
-
ql_dbg(ql_dbg_disc, vha, 0x2067,
3230
-
"Async-%s hdl=%x ID %3phC.\n", sp->name,
3231
-
sp->handle, &ct_req->req.port_id.port_id);
3232
-
3233
-
rval = qla2x00_start_sp(sp);
3234
-
if (rval != QLA_SUCCESS)
3235
-
goto done_free_sp;
3236
-
3237
-
return rval;
3238
-
3239
-
done_free_sp:
3240
-
spin_lock_irqsave(&vha->hw->vport_slock, flags);
3241
-
list_del(&sp->elem);
3242
-
spin_unlock_irqrestore(&vha->hw->vport_slock, flags);
3243
-
3244
-
if (sp->u.iocb_cmd.u.ctarg.req) {
3245
-
dma_free_coherent(&vha->hw->pdev->dev,
3246
-
sizeof(struct ct_sns_pkt),
3247
-
sp->u.iocb_cmd.u.ctarg.req,
3248
-
sp->u.iocb_cmd.u.ctarg.req_dma);
3249
-
sp->u.iocb_cmd.u.ctarg.req = NULL;
3250
-
}
3251
-
if (sp->u.iocb_cmd.u.ctarg.rsp) {
3252
-
dma_free_coherent(&vha->hw->pdev->dev,
3253
-
sizeof(struct ct_sns_pkt),
3254
-
sp->u.iocb_cmd.u.ctarg.rsp,
3255
-
sp->u.iocb_cmd.u.ctarg.rsp_dma);
3256
-
sp->u.iocb_cmd.u.ctarg.rsp = NULL;
3257
-
}
3258
-
/* ref: INIT */
3259
-
kref_put(&sp->cmd_kref, qla2x00_sp_release);
3260
-
done:
3261
-
return rval;
3262
-
}
3263
-
3264
2999
3265
3000
void qla24xx_async_gffid_sp_done(srb_t *sp, int res)
3266
3001
{
···
3891
4188
spin_lock_irqsave(&vha->work_lock, flags);
3892
4189
vha->scan.scan_flags &= ~SF_QUEUED;
3893
4190
spin_unlock_irqrestore(&vha->work_lock, flags);
3894
-
}
3895
-
3896
-
/* GNN_ID */
3897
-
void qla24xx_handle_gnnid_event(scsi_qla_host_t *vha, struct event_arg *ea)
3898
-
{
3899
-
qla24xx_post_gnl_work(vha, ea->fcport);
3900
-
}
3901
-
3902
-
static void qla2x00_async_gnnid_sp_done(srb_t *sp, int res)
3903
-
{
3904
-
struct scsi_qla_host *vha = sp->vha;
3905
-
fc_port_t *fcport = sp->fcport;
3906
-
u8 *node_name = fcport->ct_desc.ct_sns->p.rsp.rsp.gnn_id.node_name;
3907
-
struct event_arg ea;
3908
-
u64 wwnn;
3909
-
3910
-
fcport->flags &= ~FCF_ASYNC_SENT;
3911
-
wwnn = wwn_to_u64(node_name);
3912
-
if (wwnn)
3913
-
memcpy(fcport->node_name, node_name, WWN_SIZE);
3914
-
3915
-
memset(&ea, 0, sizeof(ea));
3916
-
ea.fcport = fcport;
3917
-
ea.sp = sp;
3918
-
ea.rc = res;
3919
-
3920
-
ql_dbg(ql_dbg_disc, vha, 0x204f,
3921
-
"Async done-%s res %x, WWPN %8phC %8phC\n",
3922
-
sp->name, res, fcport->port_name, fcport->node_name);
3923
-
3924
-
qla24xx_handle_gnnid_event(vha, &ea);
3925
-
3926
-
/* ref: INIT */
3927
-
kref_put(&sp->cmd_kref, qla2x00_sp_release);
3928
-
}
3929
-
3930
-
int qla24xx_async_gnnid(scsi_qla_host_t *vha, fc_port_t *fcport)
3931
-
{
3932
-
int rval = QLA_FUNCTION_FAILED;
3933
-
struct ct_sns_req *ct_req;
3934
-
srb_t *sp;
3935
-
3936
-
if (!vha->flags.online || (fcport->flags & FCF_ASYNC_SENT))
3937
-
return rval;
3938
-
3939
-
qla2x00_set_fcport_disc_state(fcport, DSC_GNN_ID);
3940
-
/* ref: INIT */
3941
-
sp = qla2x00_get_sp(vha, fcport, GFP_ATOMIC);
3942
-
if (!sp)
3943
-
goto done;
3944
-
3945
-
fcport->flags |= FCF_ASYNC_SENT;
3946
-
sp->type = SRB_CT_PTHRU_CMD;
3947
-
sp->name = "gnnid";
3948
-
sp->gen1 = fcport->rscn_gen;
3949
-
sp->gen2 = fcport->login_gen;
3950
-
qla2x00_init_async_sp(sp, qla2x00_get_async_timeout(vha) + 2,
3951
-
qla2x00_async_gnnid_sp_done);
3952
-
3953
-
/* CT_IU preamble */
3954
-
ct_req = qla2x00_prep_ct_req(fcport->ct_desc.ct_sns, GNN_ID_CMD,
3955
-
GNN_ID_RSP_SIZE);
3956
-
3957
-
/* GNN_ID req */
3958
-
ct_req->req.port_id.port_id = port_id_to_be_id(fcport->d_id);
3959
-
3960
-
3961
-
/* req & rsp use the same buffer */
3962
-
sp->u.iocb_cmd.u.ctarg.req = fcport->ct_desc.ct_sns;
3963
-
sp->u.iocb_cmd.u.ctarg.req_dma = fcport->ct_desc.ct_sns_dma;
3964
-
sp->u.iocb_cmd.u.ctarg.rsp = fcport->ct_desc.ct_sns;
3965
-
sp->u.iocb_cmd.u.ctarg.rsp_dma = fcport->ct_desc.ct_sns_dma;
3966
-
sp->u.iocb_cmd.u.ctarg.req_size = GNN_ID_REQ_SIZE;
3967
-
sp->u.iocb_cmd.u.ctarg.rsp_size = GNN_ID_RSP_SIZE;
3968
-
sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
3969
-
3970
-
ql_dbg(ql_dbg_disc, vha, 0xffff,
3971
-
"Async-%s - %8phC hdl=%x loopid=%x portid %06x.\n",
3972
-
sp->name, fcport->port_name,
3973
-
sp->handle, fcport->loop_id, fcport->d_id.b24);
3974
-
3975
-
rval = qla2x00_start_sp(sp);
3976
-
if (rval != QLA_SUCCESS)
3977
-
goto done_free_sp;
3978
-
return rval;
3979
-
3980
-
done_free_sp:
3981
-
/* ref: INIT */
3982
-
kref_put(&sp->cmd_kref, qla2x00_sp_release);
3983
-
fcport->flags &= ~FCF_ASYNC_SENT;
3984
-
done:
3985
-
return rval;
3986
-
}
3987
-
3988
-
int qla24xx_post_gnnid_work(struct scsi_qla_host *vha, fc_port_t *fcport)
3989
-
{
3990
-
struct qla_work_evt *e;
3991
-
int ls;
3992
-
3993
-
ls = atomic_read(&vha->loop_state);
3994
-
if (((ls != LOOP_READY) && (ls != LOOP_UP)) ||
3995
-
test_bit(UNLOADING, &vha->dpc_flags))
3996
-
return 0;
3997
-
3998
-
e = qla2x00_alloc_work(vha, QLA_EVT_GNNID);
3999
-
if (!e)
4000
-
return QLA_FUNCTION_FAILED;
4001
-
4002
-
e->u.fcport.fcport = fcport;
4003
-
return qla2x00_post_work(vha, e);
4004
4191
}
4005
4192
4006
4193
/* GPFN_ID */
+16
-59
drivers/scsi/qla2xxx/qla_init.c
+16
-59
drivers/scsi/qla2xxx/qla_init.c
···
1718
1718
}
1719
1719
break;
1720
1720
default:
1721
-
if (wwn == 0) {
1722
-
ql_dbg(ql_dbg_disc, vha, 0xffff,
1723
-
"%s %d %8phC post GNNID\n",
1724
-
__func__, __LINE__, fcport->port_name);
1725
-
qla24xx_post_gnnid_work(vha, fcport);
1726
-
} else if (fcport->loop_id == FC_NO_LOOP_ID) {
1721
+
if (fcport->loop_id == FC_NO_LOOP_ID) {
1727
1722
ql_dbg(ql_dbg_disc, vha, 0x20bd,
1728
1723
"%s %d %8phC post gnl\n",
1729
1724
__func__, __LINE__, fcport->port_name);
···
2318
2323
ea->fcport->login_pause = 1;
2319
2324
2320
2325
ql_dbg(ql_dbg_disc, vha, 0x20ed,
2321
-
"%s %d %8phC NPortId %06x inuse with loopid 0x%x. post gidpn\n",
2326
+
"%s %d %8phC NPortId %06x inuse with loopid 0x%x.\n",
2322
2327
__func__, __LINE__, ea->fcport->port_name,
2323
2328
ea->fcport->d_id.b24, lid);
2324
2329
} else {
···
4822
4827
spin_lock_irqsave(&ha->hardware_lock, flags);
4823
4828
if (vha->hw->flags.edif_enabled) {
4824
4829
if (topo != 2)
4825
-
qlt_update_host_map(vha, id);
4830
+
qla_update_host_map(vha, id);
4826
4831
} else if (!(topo == 2 && ha->flags.n2n_bigger))
4827
-
qlt_update_host_map(vha, id);
4832
+
qla_update_host_map(vha, id);
4828
4833
spin_unlock_irqrestore(&ha->hardware_lock, flags);
4829
4834
4830
4835
if (!vha->flags.init_done)
···
5217
5222
"NVRAM configuration failed.\n");
5218
5223
}
5219
5224
return (rval);
5220
-
}
5221
-
5222
-
static void
5223
-
qla2x00_rport_del(void *data)
5224
-
{
5225
-
fc_port_t *fcport = data;
5226
-
struct fc_rport *rport;
5227
-
unsigned long flags;
5228
-
5229
-
spin_lock_irqsave(fcport->vha->host->host_lock, flags);
5230
-
rport = fcport->drport ? fcport->drport : fcport->rport;
5231
-
fcport->drport = NULL;
5232
-
spin_unlock_irqrestore(fcport->vha->host->host_lock, flags);
5233
-
if (rport) {
5234
-
ql_dbg(ql_dbg_disc, fcport->vha, 0x210b,
5235
-
"%s %8phN. rport %p roles %x\n",
5236
-
__func__, fcport->port_name, rport,
5237
-
rport->roles);
5238
-
5239
-
fc_remote_port_delete(rport);
5240
-
}
5241
5225
}
5242
5226
5243
5227
void qla2x00_set_fcport_state(fc_port_t *fcport, int state)
···
6733
6759
}
6734
6760
6735
6761
return rval;
6736
-
}
6737
-
6738
-
void
6739
-
qla2x00_update_fcports(scsi_qla_host_t *base_vha)
6740
-
{
6741
-
fc_port_t *fcport;
6742
-
struct scsi_qla_host *vha, *tvp;
6743
-
struct qla_hw_data *ha = base_vha->hw;
6744
-
unsigned long flags;
6745
-
6746
-
spin_lock_irqsave(&ha->vport_slock, flags);
6747
-
/* Go with deferred removal of rport references. */
6748
-
list_for_each_entry_safe(vha, tvp, &base_vha->hw->vp_list, list) {
6749
-
atomic_inc(&vha->vref_count);
6750
-
list_for_each_entry(fcport, &vha->vp_fcports, list) {
6751
-
if (fcport->drport &&
6752
-
atomic_read(&fcport->state) != FCS_UNCONFIGURED) {
6753
-
spin_unlock_irqrestore(&ha->vport_slock, flags);
6754
-
qla2x00_rport_del(fcport);
6755
-
6756
-
spin_lock_irqsave(&ha->vport_slock, flags);
6757
-
}
6758
-
}
6759
-
atomic_dec(&vha->vref_count);
6760
-
wake_up(&vha->vref_waitq);
6761
-
}
6762
-
spin_unlock_irqrestore(&ha->vport_slock, flags);
6763
6762
}
6764
6763
6765
6764
/* Assumes idc_lock always held on entry */
···
9426
9479
qpair->req = ha->req_q_map[req_id];
9427
9480
qpair->rsp->req = qpair->req;
9428
9481
qpair->rsp->qpair = qpair;
9429
-
/* init qpair to this cpu. Will adjust at run time. */
9430
-
qla_cpu_update(qpair, raw_smp_processor_id());
9431
9482
9432
9483
if (IS_T10_PI_CAPABLE(ha) && ql2xenabledif) {
9433
9484
if (ha->fw_attributes & BIT_4)
···
9438
9493
"Failed to create srb mempool for qpair %d\n",
9439
9494
qpair->id);
9440
9495
goto fail_mempool;
9496
+
}
9497
+
9498
+
if (qla_create_buf_pool(vha, qpair)) {
9499
+
ql_log(ql_log_warn, vha, 0xd036,
9500
+
"Failed to initialize buf pool for qpair %d\n",
9501
+
qpair->id);
9502
+
goto fail_bufpool;
9441
9503
}
9442
9504
9443
9505
/* Mark as online */
···
9462
9510
}
9463
9511
return qpair;
9464
9512
9513
+
fail_bufpool:
9514
+
mempool_destroy(qpair->srb_mempool);
9465
9515
fail_mempool:
9516
+
qla25xx_delete_req_que(vha, qpair->req);
9466
9517
fail_req:
9467
9518
qla25xx_delete_rsp_que(vha, qpair->rsp);
9468
9519
fail_rsp:
···
9490
9535
struct qla_hw_data *ha = qpair->hw;
9491
9536
9492
9537
qpair->delete_in_progress = 1;
9538
+
9539
+
qla_free_buf_pool(qpair);
9493
9540
9494
9541
ret = qla25xx_delete_req_que(vha, qpair->req);
9495
9542
if (ret != QLA_SUCCESS)
+55
drivers/scsi/qla2xxx/qla_inline.h
+55
drivers/scsi/qla2xxx/qla_inline.h
···
515
515
{
516
516
return !fcport_is_smaller(fcport);
517
517
}
518
+
519
+
static inline struct qla_qpair *
520
+
qla_mapq_nvme_select_qpair(struct qla_hw_data *ha, struct qla_qpair *qpair)
521
+
{
522
+
int cpuid = smp_processor_id();
523
+
524
+
if (qpair->cpuid != cpuid &&
525
+
ha->qp_cpu_map[cpuid]) {
526
+
qpair = ha->qp_cpu_map[cpuid];
527
+
}
528
+
return qpair;
529
+
}
530
+
531
+
static inline void
532
+
qla_mapq_init_qp_cpu_map(struct qla_hw_data *ha,
533
+
struct qla_msix_entry *msix,
534
+
struct qla_qpair *qpair)
535
+
{
536
+
const struct cpumask *mask;
537
+
unsigned int cpu;
538
+
539
+
if (!ha->qp_cpu_map)
540
+
return;
541
+
mask = pci_irq_get_affinity(ha->pdev, msix->vector_base0);
542
+
qpair->cpuid = cpumask_first(mask);
543
+
for_each_cpu(cpu, mask) {
544
+
ha->qp_cpu_map[cpu] = qpair;
545
+
}
546
+
msix->cpuid = qpair->cpuid;
547
+
}
548
+
549
+
static inline void
550
+
qla_mapq_free_qp_cpu_map(struct qla_hw_data *ha)
551
+
{
552
+
if (ha->qp_cpu_map) {
553
+
kfree(ha->qp_cpu_map);
554
+
ha->qp_cpu_map = NULL;
555
+
}
556
+
}
557
+
558
+
static inline int qla_mapq_alloc_qp_cpu_map(struct qla_hw_data *ha)
559
+
{
560
+
scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
561
+
562
+
if (!ha->qp_cpu_map) {
563
+
ha->qp_cpu_map = kcalloc(NR_CPUS, sizeof(struct qla_qpair *),
564
+
GFP_KERNEL);
565
+
if (!ha->qp_cpu_map) {
566
+
ql_log(ql_log_fatal, vha, 0x0180,
567
+
"Unable to allocate memory for qp_cpu_map ptrs.\n");
568
+
return -1;
569
+
}
570
+
}
571
+
return 0;
572
+
}
+3
-9
drivers/scsi/qla2xxx/qla_iocb.c
+3
-9
drivers/scsi/qla2xxx/qla_iocb.c
···
623
623
}
624
624
625
625
cur_seg = scsi_sglist(cmd);
626
-
ctx = sp->u.scmd.ct6_ctx;
626
+
ctx = &sp->u.scmd.ct6_ctx;
627
627
628
628
while (tot_dsds) {
629
629
avail_dsds = (tot_dsds > QLA_DSDS_PER_IOCB) ?
···
2920
2920
conflict_fcport->conflict = fcport;
2921
2921
fcport->login_pause = 1;
2922
2922
ql_dbg(ql_dbg_disc, vha, 0x20ed,
2923
-
"%s %d %8phC pid %06x inuse with lid %#x post gidpn\n",
2923
+
"%s %d %8phC pid %06x inuse with lid %#x.\n",
2924
2924
__func__, __LINE__,
2925
2925
fcport->port_name,
2926
2926
fcport->d_id.b24, lid);
···
3459
3459
goto queuing_error;
3460
3460
}
3461
3461
3462
-
ctx = sp->u.scmd.ct6_ctx =
3463
-
mempool_alloc(ha->ctx_mempool, GFP_ATOMIC);
3464
-
if (!ctx) {
3465
-
ql_log(ql_log_fatal, vha, 0x3010,
3466
-
"Failed to allocate ctx for cmd=%p.\n", cmd);
3467
-
goto queuing_error;
3468
-
}
3462
+
ctx = &sp->u.scmd.ct6_ctx;
3469
3463
3470
3464
memset(ctx, 0, sizeof(struct ct6_dsd));
3471
3465
ctx->fcp_cmnd = dma_pool_zalloc(ha->fcp_cmnd_dma_pool,
+2
-1
drivers/scsi/qla2xxx/qla_isr.c
+2
-1
drivers/scsi/qla2xxx/qla_isr.c
···
3769
3769
3770
3770
if (rsp->qpair->cpuid != smp_processor_id() || !rsp->qpair->rcv_intr) {
3771
3771
rsp->qpair->rcv_intr = 1;
3772
-
qla_cpu_update(rsp->qpair, smp_processor_id());
3773
3772
}
3774
3773
3775
3774
#define __update_rsp_in(_is_shadow_hba, _rsp, _rsp_in) \
···
4376
4377
for (i = 0; i < ha->msix_count; i++) {
4377
4378
qentry = &ha->msix_entries[i];
4378
4379
qentry->vector = pci_irq_vector(ha->pdev, i);
4380
+
qentry->vector_base0 = i;
4379
4381
qentry->entry = i;
4380
4382
qentry->have_irq = 0;
4381
4383
qentry->in_use = 0;
···
4604
4604
}
4605
4605
msix->have_irq = 1;
4606
4606
msix->handle = qpair;
4607
+
qla_mapq_init_qp_cpu_map(ha, msix, qpair);
4607
4608
return ret;
4608
4609
}
+4
-4
drivers/scsi/qla2xxx/qla_mbx.c
+4
-4
drivers/scsi/qla2xxx/qla_mbx.c
···
4010
4010
rptid_entry->port_id[2], rptid_entry->port_id[1],
4011
4011
rptid_entry->port_id[0]);
4012
4012
ha->current_topology = ISP_CFG_NL;
4013
-
qlt_update_host_map(vha, id);
4013
+
qla_update_host_map(vha, id);
4014
4014
4015
4015
} else if (rptid_entry->format == 1) {
4016
4016
/* fabric */
···
4126
4126
WWN_SIZE);
4127
4127
}
4128
4128
4129
-
qlt_update_host_map(vha, id);
4129
+
qla_update_host_map(vha, id);
4130
4130
}
4131
4131
4132
4132
set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
···
4153
4153
if (!found)
4154
4154
return;
4155
4155
4156
-
qlt_update_host_map(vp, id);
4156
+
qla_update_host_map(vp, id);
4157
4157
4158
4158
/*
4159
4159
* Cannot configure here as we are still sitting on the
···
4184
4184
4185
4185
ha->flags.n2n_ae = 1;
4186
4186
spin_lock_irqsave(&ha->vport_slock, flags);
4187
-
qlt_update_vp_map(vha, SET_AL_PA);
4187
+
qla_update_vp_map(vha, SET_AL_PA);
4188
4188
spin_unlock_irqrestore(&ha->vport_slock, flags);
4189
4189
4190
4190
list_for_each_entry(fcport, &vha->vp_fcports, list) {
+289
-13
drivers/scsi/qla2xxx/qla_mid.c
+289
-13
drivers/scsi/qla2xxx/qla_mid.c
···
52
52
spin_unlock_irqrestore(&ha->vport_slock, flags);
53
53
54
54
spin_lock_irqsave(&ha->hardware_lock, flags);
55
-
qlt_update_vp_map(vha, SET_VP_IDX);
55
+
qla_update_vp_map(vha, SET_VP_IDX);
56
56
spin_unlock_irqrestore(&ha->hardware_lock, flags);
57
57
58
58
mutex_unlock(&ha->vport_lock);
···
80
80
spin_lock_irqsave(&ha->vport_slock, flags);
81
81
if (atomic_read(&vha->vref_count) == 0) {
82
82
list_del(&vha->list);
83
-
qlt_update_vp_map(vha, RESET_VP_IDX);
83
+
qla_update_vp_map(vha, RESET_VP_IDX);
84
84
bailout = 1;
85
85
}
86
86
spin_unlock_irqrestore(&ha->vport_slock, flags);
···
95
95
"vha->vref_count=%u timeout\n", vha->vref_count.counter);
96
96
spin_lock_irqsave(&ha->vport_slock, flags);
97
97
list_del(&vha->list);
98
-
qlt_update_vp_map(vha, RESET_VP_IDX);
98
+
qla_update_vp_map(vha, RESET_VP_IDX);
99
99
spin_unlock_irqrestore(&ha->vport_slock, flags);
100
100
}
101
101
···
187
187
188
188
/* Remove port id from vp target map */
189
189
spin_lock_irqsave(&vha->hw->hardware_lock, flags);
190
-
qlt_update_vp_map(vha, RESET_AL_PA);
190
+
qla_update_vp_map(vha, RESET_AL_PA);
191
191
spin_unlock_irqrestore(&vha->hw->hardware_lock, flags);
192
192
193
193
qla2x00_mark_vp_devices_dead(vha);
···
382
382
qla24xx_process_purex_list(&vha->purex_list);
383
383
clear_bit(PROCESS_PUREX_IOCB, &vha->dpc_flags);
384
384
}
385
-
}
386
-
387
-
if (test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags)) {
388
-
ql_dbg(ql_dbg_dpc, vha, 0x4016,
389
-
"FCPort update scheduled.\n");
390
-
qla2x00_update_fcports(vha);
391
-
clear_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags);
392
-
ql_dbg(ql_dbg_dpc, vha, 0x4017,
393
-
"FCPort update end.\n");
394
385
}
395
386
396
387
if (test_bit(RELOGIN_NEEDED, &vha->dpc_flags) &&
···
1004
1013
/* ref: INIT */
1005
1014
kref_put(&sp->cmd_kref, qla2x00_sp_release);
1006
1015
return rval;
1016
+
}
1017
+
1018
+
struct scsi_qla_host *qla_find_host_by_vp_idx(struct scsi_qla_host *vha, uint16_t vp_idx)
1019
+
{
1020
+
struct qla_hw_data *ha = vha->hw;
1021
+
1022
+
if (vha->vp_idx == vp_idx)
1023
+
return vha;
1024
+
1025
+
BUG_ON(ha->vp_map == NULL);
1026
+
if (likely(test_bit(vp_idx, ha->vp_idx_map)))
1027
+
return ha->vp_map[vp_idx].vha;
1028
+
1029
+
return NULL;
1030
+
}
1031
+
1032
+
/* vport_slock to be held by the caller */
1033
+
void
1034
+
qla_update_vp_map(struct scsi_qla_host *vha, int cmd)
1035
+
{
1036
+
void *slot;
1037
+
u32 key;
1038
+
int rc;
1039
+
1040
+
if (!vha->hw->vp_map)
1041
+
return;
1042
+
1043
+
key = vha->d_id.b24;
1044
+
1045
+
switch (cmd) {
1046
+
case SET_VP_IDX:
1047
+
vha->hw->vp_map[vha->vp_idx].vha = vha;
1048
+
break;
1049
+
case SET_AL_PA:
1050
+
slot = btree_lookup32(&vha->hw->host_map, key);
1051
+
if (!slot) {
1052
+
ql_dbg(ql_dbg_disc, vha, 0xf018,
1053
+
"Save vha in host_map %p %06x\n", vha, key);
1054
+
rc = btree_insert32(&vha->hw->host_map,
1055
+
key, vha, GFP_ATOMIC);
1056
+
if (rc)
1057
+
ql_log(ql_log_info, vha, 0xd03e,
1058
+
"Unable to insert s_id into host_map: %06x\n",
1059
+
key);
1060
+
return;
1061
+
}
1062
+
ql_dbg(ql_dbg_disc, vha, 0xf019,
1063
+
"replace existing vha in host_map %p %06x\n", vha, key);
1064
+
btree_update32(&vha->hw->host_map, key, vha);
1065
+
break;
1066
+
case RESET_VP_IDX:
1067
+
vha->hw->vp_map[vha->vp_idx].vha = NULL;
1068
+
break;
1069
+
case RESET_AL_PA:
1070
+
ql_dbg(ql_dbg_disc, vha, 0xf01a,
1071
+
"clear vha in host_map %p %06x\n", vha, key);
1072
+
slot = btree_lookup32(&vha->hw->host_map, key);
1073
+
if (slot)
1074
+
btree_remove32(&vha->hw->host_map, key);
1075
+
vha->d_id.b24 = 0;
1076
+
break;
1077
+
}
1078
+
}
1079
+
1080
+
void qla_update_host_map(struct scsi_qla_host *vha, port_id_t id)
1081
+
{
1082
+
1083
+
if (!vha->d_id.b24) {
1084
+
vha->d_id = id;
1085
+
qla_update_vp_map(vha, SET_AL_PA);
1086
+
} else if (vha->d_id.b24 != id.b24) {
1087
+
qla_update_vp_map(vha, RESET_AL_PA);
1088
+
vha->d_id = id;
1089
+
qla_update_vp_map(vha, SET_AL_PA);
1090
+
}
1091
+
}
1092
+
1093
+
int qla_create_buf_pool(struct scsi_qla_host *vha, struct qla_qpair *qp)
1094
+
{
1095
+
int sz;
1096
+
1097
+
qp->buf_pool.num_bufs = qp->req->length;
1098
+
1099
+
sz = BITS_TO_LONGS(qp->req->length);
1100
+
qp->buf_pool.buf_map = kcalloc(sz, sizeof(long), GFP_KERNEL);
1101
+
if (!qp->buf_pool.buf_map) {
1102
+
ql_log(ql_log_warn, vha, 0x0186,
1103
+
"Failed to allocate buf_map(%ld).\n", sz * sizeof(unsigned long));
1104
+
return -ENOMEM;
1105
+
}
1106
+
sz = qp->req->length * sizeof(void *);
1107
+
qp->buf_pool.buf_array = kcalloc(qp->req->length, sizeof(void *), GFP_KERNEL);
1108
+
if (!qp->buf_pool.buf_array) {
1109
+
ql_log(ql_log_warn, vha, 0x0186,
1110
+
"Failed to allocate buf_array(%d).\n", sz);
1111
+
kfree(qp->buf_pool.buf_map);
1112
+
return -ENOMEM;
1113
+
}
1114
+
sz = qp->req->length * sizeof(dma_addr_t);
1115
+
qp->buf_pool.dma_array = kcalloc(qp->req->length, sizeof(dma_addr_t), GFP_KERNEL);
1116
+
if (!qp->buf_pool.dma_array) {
1117
+
ql_log(ql_log_warn, vha, 0x0186,
1118
+
"Failed to allocate dma_array(%d).\n", sz);
1119
+
kfree(qp->buf_pool.buf_map);
1120
+
kfree(qp->buf_pool.buf_array);
1121
+
return -ENOMEM;
1122
+
}
1123
+
set_bit(0, qp->buf_pool.buf_map);
1124
+
return 0;
1125
+
}
1126
+
1127
+
void qla_free_buf_pool(struct qla_qpair *qp)
1128
+
{
1129
+
int i;
1130
+
struct qla_hw_data *ha = qp->vha->hw;
1131
+
1132
+
for (i = 0; i < qp->buf_pool.num_bufs; i++) {
1133
+
if (qp->buf_pool.buf_array[i] && qp->buf_pool.dma_array[i])
1134
+
dma_pool_free(ha->fcp_cmnd_dma_pool, qp->buf_pool.buf_array[i],
1135
+
qp->buf_pool.dma_array[i]);
1136
+
qp->buf_pool.buf_array[i] = NULL;
1137
+
qp->buf_pool.dma_array[i] = 0;
1138
+
}
1139
+
1140
+
kfree(qp->buf_pool.dma_array);
1141
+
kfree(qp->buf_pool.buf_array);
1142
+
kfree(qp->buf_pool.buf_map);
1143
+
}
1144
+
1145
+
/* it is assume qp->qp_lock is held at this point */
1146
+
int qla_get_buf(struct scsi_qla_host *vha, struct qla_qpair *qp, struct qla_buf_dsc *dsc)
1147
+
{
1148
+
u16 tag, i = 0;
1149
+
void *buf;
1150
+
dma_addr_t buf_dma;
1151
+
struct qla_hw_data *ha = vha->hw;
1152
+
1153
+
dsc->tag = TAG_FREED;
1154
+
again:
1155
+
tag = find_first_zero_bit(qp->buf_pool.buf_map, qp->buf_pool.num_bufs);
1156
+
if (tag >= qp->buf_pool.num_bufs) {
1157
+
ql_dbg(ql_dbg_io, vha, 0x00e2,
1158
+
"qp(%d) ran out of buf resource.\n", qp->id);
1159
+
return -EIO;
1160
+
}
1161
+
if (tag == 0) {
1162
+
set_bit(0, qp->buf_pool.buf_map);
1163
+
i++;
1164
+
if (i == 5) {
1165
+
ql_dbg(ql_dbg_io, vha, 0x00e3,
1166
+
"qp(%d) unable to get tag.\n", qp->id);
1167
+
return -EIO;
1168
+
}
1169
+
goto again;
1170
+
}
1171
+
1172
+
if (!qp->buf_pool.buf_array[tag]) {
1173
+
buf = dma_pool_zalloc(ha->fcp_cmnd_dma_pool, GFP_ATOMIC, &buf_dma);
1174
+
if (!buf) {
1175
+
ql_log(ql_log_fatal, vha, 0x13b1,
1176
+
"Failed to allocate buf.\n");
1177
+
return -ENOMEM;
1178
+
}
1179
+
1180
+
dsc->buf = qp->buf_pool.buf_array[tag] = buf;
1181
+
dsc->buf_dma = qp->buf_pool.dma_array[tag] = buf_dma;
1182
+
qp->buf_pool.num_alloc++;
1183
+
} else {
1184
+
dsc->buf = qp->buf_pool.buf_array[tag];
1185
+
dsc->buf_dma = qp->buf_pool.dma_array[tag];
1186
+
memset(dsc->buf, 0, FCP_CMND_DMA_POOL_SIZE);
1187
+
}
1188
+
1189
+
qp->buf_pool.num_active++;
1190
+
if (qp->buf_pool.num_active > qp->buf_pool.max_used)
1191
+
qp->buf_pool.max_used = qp->buf_pool.num_active;
1192
+
1193
+
dsc->tag = tag;
1194
+
set_bit(tag, qp->buf_pool.buf_map);
1195
+
return 0;
1196
+
}
1197
+
1198
+
void qla_trim_buf(struct qla_qpair *qp, u16 trim)
1199
+
{
1200
+
int i, j;
1201
+
struct qla_hw_data *ha = qp->vha->hw;
1202
+
1203
+
if (!trim)
1204
+
return;
1205
+
1206
+
for (i = 0; i < trim; i++) {
1207
+
j = qp->buf_pool.num_alloc - 1;
1208
+
if (test_bit(j, qp->buf_pool.buf_map)) {
1209
+
ql_dbg(ql_dbg_io + ql_dbg_verbose, qp->vha, 0x300b,
1210
+
"QP id(%d): trim active buf[%d]. Remain %d bufs\n",
1211
+
qp->id, j, qp->buf_pool.num_alloc);
1212
+
return;
1213
+
}
1214
+
1215
+
if (qp->buf_pool.buf_array[j]) {
1216
+
dma_pool_free(ha->fcp_cmnd_dma_pool, qp->buf_pool.buf_array[j],
1217
+
qp->buf_pool.dma_array[j]);
1218
+
qp->buf_pool.buf_array[j] = NULL;
1219
+
qp->buf_pool.dma_array[j] = 0;
1220
+
}
1221
+
qp->buf_pool.num_alloc--;
1222
+
if (!qp->buf_pool.num_alloc)
1223
+
break;
1224
+
}
1225
+
ql_dbg(ql_dbg_io + ql_dbg_verbose, qp->vha, 0x3010,
1226
+
"QP id(%d): trimmed %d bufs. Remain %d bufs\n",
1227
+
qp->id, trim, qp->buf_pool.num_alloc);
1228
+
}
1229
+
1230
+
void __qla_adjust_buf(struct qla_qpair *qp)
1231
+
{
1232
+
u32 trim;
1233
+
1234
+
qp->buf_pool.take_snapshot = 0;
1235
+
qp->buf_pool.prev_max = qp->buf_pool.max_used;
1236
+
qp->buf_pool.max_used = qp->buf_pool.num_active;
1237
+
1238
+
if (qp->buf_pool.prev_max > qp->buf_pool.max_used &&
1239
+
qp->buf_pool.num_alloc > qp->buf_pool.max_used) {
1240
+
/* down trend */
1241
+
trim = qp->buf_pool.num_alloc - qp->buf_pool.max_used;
1242
+
trim = (trim * 10) / 100;
1243
+
trim = trim ? trim : 1;
1244
+
qla_trim_buf(qp, trim);
1245
+
} else if (!qp->buf_pool.prev_max && !qp->buf_pool.max_used) {
1246
+
/* 2 periods of no io */
1247
+
qla_trim_buf(qp, qp->buf_pool.num_alloc);
1248
+
}
1249
+
}
1250
+
1251
+
/* it is assume qp->qp_lock is held at this point */
1252
+
void qla_put_buf(struct qla_qpair *qp, struct qla_buf_dsc *dsc)
1253
+
{
1254
+
if (dsc->tag == TAG_FREED)
1255
+
return;
1256
+
lockdep_assert_held(qp->qp_lock_ptr);
1257
+
1258
+
clear_bit(dsc->tag, qp->buf_pool.buf_map);
1259
+
qp->buf_pool.num_active--;
1260
+
dsc->tag = TAG_FREED;
1261
+
1262
+
if (qp->buf_pool.take_snapshot)
1263
+
__qla_adjust_buf(qp);
1264
+
}
1265
+
1266
+
#define EXPIRE (60 * HZ)
1267
+
void qla_adjust_buf(struct scsi_qla_host *vha)
1268
+
{
1269
+
unsigned long flags;
1270
+
int i;
1271
+
struct qla_qpair *qp;
1272
+
1273
+
if (vha->vp_idx)
1274
+
return;
1275
+
1276
+
if (!vha->buf_expired) {
1277
+
vha->buf_expired = jiffies + EXPIRE;
1278
+
return;
1279
+
}
1280
+
if (time_before(jiffies, vha->buf_expired))
1281
+
return;
1282
+
1283
+
vha->buf_expired = jiffies + EXPIRE;
1284
+
1285
+
for (i = 0; i < vha->hw->num_qpairs; i++) {
1286
+
qp = vha->hw->queue_pair_map[i];
1287
+
if (!qp)
1288
+
continue;
1289
+
if (!qp->buf_pool.num_alloc)
1290
+
continue;
1291
+
1292
+
if (qp->buf_pool.take_snapshot) {
1293
+
/* no io has gone through in the last EXPIRE period */
1294
+
spin_lock_irqsave(qp->qp_lock_ptr, flags);
1295
+
__qla_adjust_buf(qp);
1296
+
spin_unlock_irqrestore(qp->qp_lock_ptr, flags);
1297
+
} else {
1298
+
qp->buf_pool.take_snapshot = 1;
1299
+
}
1300
+
}
1007
1301
}
+4
drivers/scsi/qla2xxx/qla_nvme.c
+4
drivers/scsi/qla2xxx/qla_nvme.c
···
609
609
fc_port_t *fcport;
610
610
struct srb_iocb *nvme;
611
611
struct scsi_qla_host *vha;
612
+
struct qla_hw_data *ha;
612
613
int rval;
613
614
srb_t *sp;
614
615
struct qla_qpair *qpair = hw_queue_handle;
···
630
629
return -ENODEV;
631
630
632
631
vha = fcport->vha;
632
+
ha = vha->hw;
633
633
634
634
if (test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags))
635
635
return -EBUSY;
···
644
642
*/
645
643
if (fcport->nvme_flag & NVME_FLAG_RESETTING)
646
644
return -EBUSY;
645
+
646
+
qpair = qla_mapq_nvme_select_qpair(ha, qpair);
647
647
648
648
/* Alloc SRB structure */
649
649
sp = qla2xxx_get_qpair_sp(vha, qpair, fcport, GFP_ATOMIC);
+29
-23
drivers/scsi/qla2xxx/qla_os.c
+29
-23
drivers/scsi/qla2xxx/qla_os.c
···
472
472
"Unable to allocate memory for queue pair ptrs.\n");
473
473
goto fail_qpair_map;
474
474
}
475
+
if (qla_mapq_alloc_qp_cpu_map(ha) != 0) {
476
+
kfree(ha->queue_pair_map);
477
+
ha->queue_pair_map = NULL;
478
+
goto fail_qpair_map;
479
+
}
475
480
}
476
481
477
482
/*
···
551
546
ha->base_qpair = NULL;
552
547
}
553
548
549
+
qla_mapq_free_qp_cpu_map(ha);
554
550
spin_lock_irqsave(&ha->hardware_lock, flags);
555
551
for (cnt = 0; cnt < ha->max_req_queues; cnt++) {
556
552
if (!test_bit(cnt, ha->req_qid_map))
···
739
733
}
740
734
741
735
if (sp->flags & SRB_FCP_CMND_DMA_VALID) {
742
-
struct ct6_dsd *ctx1 = sp->u.scmd.ct6_ctx;
736
+
struct ct6_dsd *ctx1 = &sp->u.scmd.ct6_ctx;
743
737
744
738
dma_pool_free(ha->fcp_cmnd_dma_pool, ctx1->fcp_cmnd,
745
739
ctx1->fcp_cmnd_dma);
746
740
list_splice(&ctx1->dsd_list, &ha->gbl_dsd_list);
747
741
ha->gbl_dsd_inuse -= ctx1->dsd_use_cnt;
748
742
ha->gbl_dsd_avail += ctx1->dsd_use_cnt;
749
-
mempool_free(ctx1, ha->ctx_mempool);
750
743
}
744
+
745
+
if (sp->flags & SRB_GOT_BUF)
746
+
qla_put_buf(sp->qpair, &sp->u.scmd.buf_dsc);
751
747
}
752
748
753
749
void qla2x00_sp_compl(srb_t *sp, int res)
···
825
817
}
826
818
827
819
if (sp->flags & SRB_FCP_CMND_DMA_VALID) {
828
-
struct ct6_dsd *ctx1 = sp->u.scmd.ct6_ctx;
820
+
struct ct6_dsd *ctx1 = &sp->u.scmd.ct6_ctx;
829
821
830
822
dma_pool_free(ha->fcp_cmnd_dma_pool, ctx1->fcp_cmnd,
831
823
ctx1->fcp_cmnd_dma);
832
824
list_splice(&ctx1->dsd_list, &ha->gbl_dsd_list);
833
825
ha->gbl_dsd_inuse -= ctx1->dsd_use_cnt;
834
826
ha->gbl_dsd_avail += ctx1->dsd_use_cnt;
835
-
mempool_free(ctx1, ha->ctx_mempool);
836
827
sp->flags &= ~SRB_FCP_CMND_DMA_VALID;
837
828
}
838
829
···
841
834
dma_pool_free(ha->dl_dma_pool, ctx0, ctx0->crc_ctx_dma);
842
835
sp->flags &= ~SRB_CRC_CTX_DMA_VALID;
843
836
}
837
+
838
+
if (sp->flags & SRB_GOT_BUF)
839
+
qla_put_buf(sp->qpair, &sp->u.scmd.buf_dsc);
844
840
}
845
841
846
842
void qla2xxx_qpair_sp_compl(srb_t *sp, int res)
···
4128
4118
char name[16];
4129
4119
int rc;
4130
4120
4121
+
if (QLA_TGT_MODE_ENABLED() || EDIF_CAP(ha)) {
4122
+
ha->vp_map = kcalloc(MAX_MULTI_ID_FABRIC, sizeof(struct qla_vp_map), GFP_KERNEL);
4123
+
if (!ha->vp_map)
4124
+
goto fail;
4125
+
}
4126
+
4131
4127
ha->init_cb = dma_alloc_coherent(&ha->pdev->dev, ha->init_cb_size,
4132
4128
&ha->init_cb_dma, GFP_KERNEL);
4133
4129
if (!ha->init_cb)
4134
-
goto fail;
4130
+
goto fail_free_vp_map;
4135
4131
4136
4132
rc = btree_init32(&ha->host_map);
4137
4133
if (rc)
···
4556
4540
ha->init_cb_dma);
4557
4541
ha->init_cb = NULL;
4558
4542
ha->init_cb_dma = 0;
4543
+
fail_free_vp_map:
4544
+
kfree(ha->vp_map);
4559
4545
fail:
4560
4546
ql_log(ql_log_fatal, NULL, 0x0030,
4561
4547
"Memory allocation failure.\n");
···
4999
4981
ha->sf_init_cb = NULL;
5000
4982
ha->sf_init_cb_dma = 0;
5001
4983
ha->loop_id_map = NULL;
4984
+
4985
+
kfree(ha->vp_map);
4986
+
ha->vp_map = NULL;
5002
4987
}
5003
4988
5004
4989
struct scsi_qla_host *qla2x00_create_host(struct scsi_host_template *sht,
···
5037
5016
INIT_LIST_HEAD(&vha->plogi_ack_list);
5038
5017
INIT_LIST_HEAD(&vha->qp_list);
5039
5018
INIT_LIST_HEAD(&vha->gnl.fcports);
5040
-
INIT_LIST_HEAD(&vha->gpnid_list);
5041
5019
INIT_WORK(&vha->iocb_work, qla2x00_iocb_work_fn);
5042
5020
5043
5021
INIT_LIST_HEAD(&vha->purex_list.head);
···
5481
5461
case QLA_EVT_AENFX:
5482
5462
qlafx00_process_aen(vha, e);
5483
5463
break;
5484
-
case QLA_EVT_GPNID:
5485
-
qla24xx_async_gpnid(vha, &e->u.gpnid.id);
5486
-
break;
5487
5464
case QLA_EVT_UNMAP:
5488
5465
qla24xx_sp_unmap(vha, e->u.iosb.sp);
5489
5466
break;
···
5522
5505
break;
5523
5506
case QLA_EVT_GNNFT_DONE:
5524
5507
qla24xx_async_gnnft_done(vha, e->u.iosb.sp);
5525
-
break;
5526
-
case QLA_EVT_GNNID:
5527
-
qla24xx_async_gnnid(vha, e->u.fcport.fcport);
5528
5508
break;
5529
5509
case QLA_EVT_GFPNID:
5530
5510
qla24xx_async_gfpnid(vha, e->u.fcport.fcport);
···
7039
7025
}
7040
7026
}
7041
7027
7042
-
if (test_and_clear_bit(FCPORT_UPDATE_NEEDED,
7043
-
&base_vha->dpc_flags)) {
7044
-
qla2x00_update_fcports(base_vha);
7045
-
}
7046
-
7047
7028
if (IS_QLAFX00(ha))
7048
7029
goto loop_resync_check;
7049
7030
···
7528
7519
set_bit(SET_ZIO_THRESHOLD_NEEDED, &vha->dpc_flags);
7529
7520
start_dpc++;
7530
7521
}
7522
+
qla_adjust_buf(vha);
7531
7523
7532
7524
/* borrowing w to signify dpc will run */
7533
7525
w = 0;
7534
7526
/* Schedule the DPC routine if needed */
7535
7527
if ((test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) ||
7536
7528
test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags) ||
7537
-
test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags) ||
7538
7529
start_dpc ||
7539
7530
test_bit(RESET_MARKER_NEEDED, &vha->dpc_flags) ||
7540
7531
test_bit(BEACON_BLINK_NEEDED, &vha->dpc_flags) ||
···
7545
7536
test_bit(PROCESS_PUREX_IOCB, &vha->dpc_flags))) {
7546
7537
ql_dbg(ql_dbg_timer, vha, 0x600b,
7547
7538
"isp_abort_needed=%d loop_resync_needed=%d "
7548
-
"fcport_update_needed=%d start_dpc=%d "
7549
-
"reset_marker_needed=%d",
7539
+
"start_dpc=%d reset_marker_needed=%d",
7550
7540
test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags),
7551
7541
test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags),
7552
-
test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags),
7553
-
start_dpc,
7554
-
test_bit(RESET_MARKER_NEEDED, &vha->dpc_flags));
7542
+
start_dpc, test_bit(RESET_MARKER_NEEDED, &vha->dpc_flags));
7555
7543
ql_dbg(ql_dbg_timer, vha, 0x600c,
7556
7544
"beacon_blink_needed=%d isp_unrecoverable=%d "
7557
7545
"fcoe_ctx_reset_needed=%d vp_dpc_needed=%d "
+8
-95
drivers/scsi/qla2xxx/qla_target.c
+8
-95
drivers/scsi/qla2xxx/qla_target.c
···
198
198
return host;
199
199
}
200
200
201
-
static inline
202
-
struct scsi_qla_host *qlt_find_host_by_vp_idx(struct scsi_qla_host *vha,
203
-
uint16_t vp_idx)
204
-
{
205
-
struct qla_hw_data *ha = vha->hw;
206
-
207
-
if (vha->vp_idx == vp_idx)
208
-
return vha;
209
-
210
-
BUG_ON(ha->tgt.tgt_vp_map == NULL);
211
-
if (likely(test_bit(vp_idx, ha->vp_idx_map)))
212
-
return ha->tgt.tgt_vp_map[vp_idx].vha;
213
-
214
-
return NULL;
215
-
}
216
-
217
201
static inline void qlt_incr_num_pend_cmds(struct scsi_qla_host *vha)
218
202
{
219
203
unsigned long flags;
···
355
371
356
372
if ((entry->u.isp24.vp_index != 0xFF) &&
357
373
(entry->u.isp24.nport_handle != cpu_to_le16(0xFFFF))) {
358
-
host = qlt_find_host_by_vp_idx(vha,
374
+
host = qla_find_host_by_vp_idx(vha,
359
375
entry->u.isp24.vp_index);
360
376
if (unlikely(!host)) {
361
377
ql_dbg(ql_dbg_tgt, vha, 0xe03f,
···
379
395
{
380
396
struct abts_recv_from_24xx *entry =
381
397
(struct abts_recv_from_24xx *)atio;
382
-
struct scsi_qla_host *host = qlt_find_host_by_vp_idx(vha,
398
+
struct scsi_qla_host *host = qla_find_host_by_vp_idx(vha,
383
399
entry->vp_index);
384
400
unsigned long flags;
385
401
···
422
438
case CTIO_TYPE7:
423
439
{
424
440
struct ctio7_from_24xx *entry = (struct ctio7_from_24xx *)pkt;
425
-
struct scsi_qla_host *host = qlt_find_host_by_vp_idx(vha,
441
+
struct scsi_qla_host *host = qla_find_host_by_vp_idx(vha,
426
442
entry->vp_index);
427
443
if (unlikely(!host)) {
428
444
ql_dbg(ql_dbg_tgt, vha, 0xe041,
···
441
457
struct imm_ntfy_from_isp *entry =
442
458
(struct imm_ntfy_from_isp *)pkt;
443
459
444
-
host = qlt_find_host_by_vp_idx(vha, entry->u.isp24.vp_index);
460
+
host = qla_find_host_by_vp_idx(vha, entry->u.isp24.vp_index);
445
461
if (unlikely(!host)) {
446
462
ql_dbg(ql_dbg_tgt, vha, 0xe042,
447
463
"qla_target(%d): Response pkt (IMMED_NOTIFY_TYPE) "
···
459
475
struct nack_to_isp *entry = (struct nack_to_isp *)pkt;
460
476
461
477
if (0xFF != entry->u.isp24.vp_index) {
462
-
host = qlt_find_host_by_vp_idx(vha,
478
+
host = qla_find_host_by_vp_idx(vha,
463
479
entry->u.isp24.vp_index);
464
480
if (unlikely(!host)) {
465
481
ql_dbg(ql_dbg_tgt, vha, 0xe043,
···
479
495
{
480
496
struct abts_recv_from_24xx *entry =
481
497
(struct abts_recv_from_24xx *)pkt;
482
-
struct scsi_qla_host *host = qlt_find_host_by_vp_idx(vha,
498
+
struct scsi_qla_host *host = qla_find_host_by_vp_idx(vha,
483
499
entry->vp_index);
484
500
if (unlikely(!host)) {
485
501
ql_dbg(ql_dbg_tgt, vha, 0xe044,
···
496
512
{
497
513
struct abts_resp_to_24xx *entry =
498
514
(struct abts_resp_to_24xx *)pkt;
499
-
struct scsi_qla_host *host = qlt_find_host_by_vp_idx(vha,
515
+
struct scsi_qla_host *host = qla_find_host_by_vp_idx(vha,
500
516
entry->vp_index);
501
517
if (unlikely(!host)) {
502
518
ql_dbg(ql_dbg_tgt, vha, 0xe045,
···
7129
7145
7130
7146
qlt_clear_mode(base_vha);
7131
7147
7132
-
qlt_update_vp_map(base_vha, SET_VP_IDX);
7148
+
qla_update_vp_map(base_vha, SET_VP_IDX);
7133
7149
}
7134
7150
7135
7151
irqreturn_t
···
7208
7224
if (!QLA_TGT_MODE_ENABLED())
7209
7225
return 0;
7210
7226
7211
-
ha->tgt.tgt_vp_map = kcalloc(MAX_MULTI_ID_FABRIC,
7212
-
sizeof(struct qla_tgt_vp_map),
7213
-
GFP_KERNEL);
7214
-
if (!ha->tgt.tgt_vp_map)
7215
-
return -ENOMEM;
7216
-
7217
7227
ha->tgt.atio_ring = dma_alloc_coherent(&ha->pdev->dev,
7218
7228
(ha->tgt.atio_q_length + 1) * sizeof(struct atio_from_isp),
7219
7229
&ha->tgt.atio_dma, GFP_KERNEL);
7220
7230
if (!ha->tgt.atio_ring) {
7221
-
kfree(ha->tgt.tgt_vp_map);
7222
7231
return -ENOMEM;
7223
7232
}
7224
7233
return 0;
···
7230
7253
}
7231
7254
ha->tgt.atio_ring = NULL;
7232
7255
ha->tgt.atio_dma = 0;
7233
-
kfree(ha->tgt.tgt_vp_map);
7234
-
ha->tgt.tgt_vp_map = NULL;
7235
-
}
7236
-
7237
-
/* vport_slock to be held by the caller */
7238
-
void
7239
-
qlt_update_vp_map(struct scsi_qla_host *vha, int cmd)
7240
-
{
7241
-
void *slot;
7242
-
u32 key;
7243
-
int rc;
7244
-
7245
-
key = vha->d_id.b24;
7246
-
7247
-
switch (cmd) {
7248
-
case SET_VP_IDX:
7249
-
if (!QLA_TGT_MODE_ENABLED())
7250
-
return;
7251
-
vha->hw->tgt.tgt_vp_map[vha->vp_idx].vha = vha;
7252
-
break;
7253
-
case SET_AL_PA:
7254
-
slot = btree_lookup32(&vha->hw->host_map, key);
7255
-
if (!slot) {
7256
-
ql_dbg(ql_dbg_tgt_mgt, vha, 0xf018,
7257
-
"Save vha in host_map %p %06x\n", vha, key);
7258
-
rc = btree_insert32(&vha->hw->host_map,
7259
-
key, vha, GFP_ATOMIC);
7260
-
if (rc)
7261
-
ql_log(ql_log_info, vha, 0xd03e,
7262
-
"Unable to insert s_id into host_map: %06x\n",
7263
-
key);
7264
-
return;
7265
-
}
7266
-
ql_dbg(ql_dbg_tgt_mgt, vha, 0xf019,
7267
-
"replace existing vha in host_map %p %06x\n", vha, key);
7268
-
btree_update32(&vha->hw->host_map, key, vha);
7269
-
break;
7270
-
case RESET_VP_IDX:
7271
-
if (!QLA_TGT_MODE_ENABLED())
7272
-
return;
7273
-
vha->hw->tgt.tgt_vp_map[vha->vp_idx].vha = NULL;
7274
-
break;
7275
-
case RESET_AL_PA:
7276
-
ql_dbg(ql_dbg_tgt_mgt, vha, 0xf01a,
7277
-
"clear vha in host_map %p %06x\n", vha, key);
7278
-
slot = btree_lookup32(&vha->hw->host_map, key);
7279
-
if (slot)
7280
-
btree_remove32(&vha->hw->host_map, key);
7281
-
vha->d_id.b24 = 0;
7282
-
break;
7283
-
}
7284
-
}
7285
-
7286
-
void qlt_update_host_map(struct scsi_qla_host *vha, port_id_t id)
7287
-
{
7288
-
7289
-
if (!vha->d_id.b24) {
7290
-
vha->d_id = id;
7291
-
qlt_update_vp_map(vha, SET_AL_PA);
7292
-
} else if (vha->d_id.b24 != id.b24) {
7293
-
qlt_update_vp_map(vha, RESET_AL_PA);
7294
-
vha->d_id = id;
7295
-
qlt_update_vp_map(vha, SET_AL_PA);
7296
-
}
7297
7256
}
7298
7257
7299
7258
static int __init qlt_parse_ini_mode(void)
-1
drivers/scsi/qla2xxx/qla_target.h
-1
drivers/scsi/qla2xxx/qla_target.h
···
1017
1017
extern void qlt_fc_port_deleted(struct scsi_qla_host *, fc_port_t *, int);
1018
1018
extern int __init qlt_init(void);
1019
1019
extern void qlt_exit(void);
1020
-
extern void qlt_update_vp_map(struct scsi_qla_host *, int);
1021
1020
extern void qlt_free_session_done(struct work_struct *);
1022
1021
/*
1023
1022
* This macro is used during early initializations when host->active_mode
+2
-2
drivers/scsi/qla2xxx/qla_version.h
+2
-2
drivers/scsi/qla2xxx/qla_version.h
···
6
6
/*
7
7
* Driver version
8
8
*/
9
-
#define QLA2XXX_VERSION "10.02.08.100-k"
9
+
#define QLA2XXX_VERSION "10.02.08.200-k"
10
10
11
11
#define QLA_DRIVER_MAJOR_VER 10
12
12
#define QLA_DRIVER_MINOR_VER 2
13
13
#define QLA_DRIVER_PATCH_VER 8
14
-
#define QLA_DRIVER_BETA_VER 100
14
+
#define QLA_DRIVER_BETA_VER 200