| | 1 | /* |
| | 2 | * zfcp device driver |
| | 3 | * |
| | 4 | * Fibre Channel related functions for the zfcp device driver. |
| | 5 | * |
| | 6 | * Copyright IBM Corporation 2008, 2009 |
| | 7 | */ |
| | 8 | |
| | 9 | #define KMSG_COMPONENT "zfcp" |
| | 10 | #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt |
| | 11 | |
| | 12 | #include "zfcp_ext.h" |
| | 13 | |
| | 14 | enum rscn_address_format { |
| | 15 | RSCN_PORT_ADDRESS = 0x0, |
| | 16 | RSCN_AREA_ADDRESS = 0x1, |
| | 17 | RSCN_DOMAIN_ADDRESS = 0x2, |
| | 18 | RSCN_FABRIC_ADDRESS = 0x3, |
| | 19 | }; |
| | 20 | |
| | 21 | static u32 rscn_range_mask[] = { |
| | 22 | [RSCN_PORT_ADDRESS] = 0xFFFFFF, |
| | 23 | [RSCN_AREA_ADDRESS] = 0xFFFF00, |
| | 24 | [RSCN_DOMAIN_ADDRESS] = 0xFF0000, |
| | 25 | [RSCN_FABRIC_ADDRESS] = 0x000000, |
| | 26 | }; |
| | 27 | |
| | 28 | struct gpn_ft_resp_acc { |
| | 29 | u8 control; |
| | 30 | u8 port_id[3]; |
| | 31 | u8 reserved[4]; |
| | 32 | u64 wwpn; |
| | 33 | } __attribute__ ((packed)); |
| | 34 | |
| | 35 | #define ZFCP_CT_SIZE_ONE_PAGE (PAGE_SIZE - sizeof(struct ct_hdr)) |
| | 36 | #define ZFCP_GPN_FT_ENTRIES (ZFCP_CT_SIZE_ONE_PAGE \ |
| | 37 | / sizeof(struct gpn_ft_resp_acc)) |
| | 38 | #define ZFCP_GPN_FT_BUFFERS 4 |
| | 39 | #define ZFCP_GPN_FT_MAX_SIZE (ZFCP_GPN_FT_BUFFERS * PAGE_SIZE \ |
| | 40 | - sizeof(struct ct_hdr)) |
| | 41 | #define ZFCP_GPN_FT_MAX_ENTRIES ZFCP_GPN_FT_BUFFERS * (ZFCP_GPN_FT_ENTRIES + 1) |
| | 42 | |
| | 43 | struct ct_iu_gpn_ft_resp { |
| | 44 | struct ct_hdr header; |
| | 45 | struct gpn_ft_resp_acc accept[ZFCP_GPN_FT_ENTRIES]; |
| | 46 | } __attribute__ ((packed)); |
| | 47 | |
| | 48 | struct zfcp_gpn_ft { |
| | 49 | struct zfcp_send_ct ct; |
| | 50 | struct scatterlist sg_req; |
| | 51 | struct scatterlist sg_resp[ZFCP_GPN_FT_BUFFERS]; |
| | 52 | }; |
| | 53 | |
| | 54 | struct zfcp_fc_ns_handler_data { |
| | 55 | struct completion done; |
| | 56 | void (*handler)(unsigned long); |
| | 57 | unsigned long handler_data; |
| | 58 | }; |
| | 59 | |
| | 60 | static int zfcp_fc_wka_port_get(struct zfcp_wka_port *wka_port) |
| | 61 | { |
| | 62 | if (mutex_lock_interruptible(&wka_port->mutex)) |
| | 63 | return -ERESTARTSYS; |
| | 64 | |
| | 65 | if (wka_port->status == ZFCP_WKA_PORT_OFFLINE || |
| | 66 | wka_port->status == ZFCP_WKA_PORT_CLOSING) { |
| | 67 | wka_port->status = ZFCP_WKA_PORT_OPENING; |
| | 68 | if (zfcp_fsf_open_wka_port(wka_port)) |
| | 69 | wka_port->status = ZFCP_WKA_PORT_OFFLINE; |
| | 70 | } |
| | 71 | |
| | 72 | mutex_unlock(&wka_port->mutex); |
| | 73 | |
| | 74 | wait_event(wka_port->completion_wq, |
| | 75 | wka_port->status == ZFCP_WKA_PORT_ONLINE || |
| | 76 | wka_port->status == ZFCP_WKA_PORT_OFFLINE); |
| | 77 | |
| | 78 | if (wka_port->status == ZFCP_WKA_PORT_ONLINE) { |
| | 79 | atomic_inc(&wka_port->refcount); |
| | 80 | return 0; |
| | 81 | } |
| | 82 | return -EIO; |
| | 83 | } |
| | 84 | |
| | 85 | static void zfcp_fc_wka_port_offline(struct work_struct *work) |
| | 86 | { |
| | 87 | struct delayed_work *dw = to_delayed_work(work); |
| | 88 | struct zfcp_wka_port *wka_port = |
| | 89 | container_of(dw, struct zfcp_wka_port, work); |
| | 90 | |
| | 91 | mutex_lock(&wka_port->mutex); |
| | 92 | if ((atomic_read(&wka_port->refcount) != 0) || |
| | 93 | (wka_port->status != ZFCP_WKA_PORT_ONLINE)) |
| | 94 | goto out; |
| | 95 | |
| | 96 | wka_port->status = ZFCP_WKA_PORT_CLOSING; |
| | 97 | if (zfcp_fsf_close_wka_port(wka_port)) { |
| | 98 | wka_port->status = ZFCP_WKA_PORT_OFFLINE; |
| | 99 | wake_up(&wka_port->completion_wq); |
| | 100 | } |
| | 101 | out: |
| | 102 | mutex_unlock(&wka_port->mutex); |
| | 103 | } |
| | 104 | |
| | 105 | static void zfcp_fc_wka_port_put(struct zfcp_wka_port *wka_port) |
| | 106 | { |
| | 107 | if (atomic_dec_return(&wka_port->refcount) != 0) |
| | 108 | return; |
| | 109 | /* wait 10 milliseconds, other reqs might pop in */ |
| | 110 | schedule_delayed_work(&wka_port->work, HZ / 100); |
| | 111 | } |
| | 112 | |
| | 113 | static void zfcp_fc_wka_port_init(struct zfcp_wka_port *wka_port, u32 d_id, |
| | 114 | struct zfcp_adapter *adapter) |
| | 115 | { |
| | 116 | init_waitqueue_head(&wka_port->completion_wq); |
| | 117 | |
| | 118 | wka_port->adapter = adapter; |
| | 119 | wka_port->d_id = d_id; |
| | 120 | |
| | 121 | wka_port->status = ZFCP_WKA_PORT_OFFLINE; |
| | 122 | atomic_set(&wka_port->refcount, 0); |
| | 123 | mutex_init(&wka_port->mutex); |
| | 124 | INIT_DELAYED_WORK(&wka_port->work, zfcp_fc_wka_port_offline); |
| | 125 | } |
| | 126 | |
| | 127 | static void zfcp_fc_wka_port_force_offline(struct zfcp_wka_port *wka) |
| | 128 | { |
| | 129 | cancel_delayed_work_sync(&wka->work); |
| | 130 | mutex_lock(&wka->mutex); |
| | 131 | wka->status = ZFCP_WKA_PORT_OFFLINE; |
| | 132 | mutex_unlock(&wka->mutex); |
| | 133 | } |
| | 134 | |
| | 135 | void zfcp_fc_wka_ports_force_offline(struct zfcp_wka_ports *gs) |
| | 136 | { |
| | 137 | if (!gs) |
| | 138 | return; |
| | 139 | zfcp_fc_wka_port_force_offline(&gs->ms); |
| | 140 | zfcp_fc_wka_port_force_offline(&gs->ts); |
| | 141 | zfcp_fc_wka_port_force_offline(&gs->ds); |
| | 142 | zfcp_fc_wka_port_force_offline(&gs->as); |
| | 143 | zfcp_fc_wka_port_force_offline(&gs->ks); |
| | 144 | } |
| | 145 | |
| | 146 | static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req, u32 range, |
| | 147 | struct fcp_rscn_element *elem) |
| | 148 | { |
| | 149 | unsigned long flags; |
| | 150 | struct zfcp_adapter *adapter = fsf_req->adapter; |
| | 151 | struct zfcp_port *port; |
| | 152 | |
| | 153 | read_lock_irqsave(&adapter->port_list_lock, flags); |
| | 154 | list_for_each_entry(port, &adapter->port_list, list) { |
| | 155 | if ((port->d_id & range) == (elem->nport_did & range)) |
| | 156 | zfcp_fc_test_link(port); |
| | 157 | if (!port->d_id) |
| | 158 | zfcp_erp_port_reopen(port, |
| | 159 | ZFCP_STATUS_COMMON_ERP_FAILED, |
| | 160 | "fcrscn1", NULL); |
| | 161 | } |
| | 162 | read_unlock_irqrestore(&adapter->port_list_lock, flags); |
| | 163 | } |
| | 164 | |
| | 165 | static void zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req) |
| | 166 | { |
| | 167 | struct fsf_status_read_buffer *status_buffer = (void *)fsf_req->data; |
| | 168 | struct fcp_rscn_head *fcp_rscn_head; |
| | 169 | struct fcp_rscn_element *fcp_rscn_element; |
| | 170 | u16 i; |
| | 171 | u16 no_entries; |
| | 172 | u32 range_mask; |
| | 173 | |
| | 174 | fcp_rscn_head = (struct fcp_rscn_head *) status_buffer->payload.data; |
| | 175 | fcp_rscn_element = (struct fcp_rscn_element *) fcp_rscn_head; |
| | 176 | |
| | 177 | /* see FC-FS */ |
| | 178 | no_entries = fcp_rscn_head->payload_len / |
| | 179 | sizeof(struct fcp_rscn_element); |
| | 180 | |
| | 181 | for (i = 1; i < no_entries; i++) { |
| | 182 | /* skip head and start with 1st element */ |
| | 183 | fcp_rscn_element++; |
| | 184 | range_mask = rscn_range_mask[fcp_rscn_element->addr_format]; |
| | 185 | _zfcp_fc_incoming_rscn(fsf_req, range_mask, fcp_rscn_element); |
| | 186 | } |
| | 187 | schedule_work(&fsf_req->adapter->scan_work); |
| | 188 | } |
| | 189 | |
| | 190 | static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req *req, u64 wwpn) |
| | 191 | { |
| | 192 | unsigned long flags; |
| | 193 | struct zfcp_adapter *adapter = req->adapter; |
| | 194 | struct zfcp_port *port; |
| | 195 | |
| | 196 | read_lock_irqsave(&adapter->port_list_lock, flags); |
| | 197 | list_for_each_entry(port, &adapter->port_list, list) |
| | 198 | if (port->wwpn == wwpn) { |
| | 199 | zfcp_erp_port_forced_reopen(port, 0, "fciwwp1", req); |
| | 200 | break; |
| | 201 | } |
| | 202 | read_unlock_irqrestore(&adapter->port_list_lock, flags); |
| | 203 | } |
| | 204 | |
| | 205 | static void zfcp_fc_incoming_plogi(struct zfcp_fsf_req *req) |
| | 206 | { |
| | 207 | struct fsf_status_read_buffer *status_buffer = |
| | 208 | (struct fsf_status_read_buffer *)req->data; |
| | 209 | struct fsf_plogi *els_plogi = |
| | 210 | (struct fsf_plogi *) status_buffer->payload.data; |
| | 211 | |
| | 212 | zfcp_fc_incoming_wwpn(req, els_plogi->serv_param.wwpn); |
| | 213 | } |
| | 214 | |
| | 215 | static void zfcp_fc_incoming_logo(struct zfcp_fsf_req *req) |
| | 216 | { |
| | 217 | struct fsf_status_read_buffer *status_buffer = |
| | 218 | (struct fsf_status_read_buffer *)req->data; |
| | 219 | struct fcp_logo *els_logo = |
| | 220 | (struct fcp_logo *) status_buffer->payload.data; |
| | 221 | |
| | 222 | zfcp_fc_incoming_wwpn(req, els_logo->nport_wwpn); |
| | 223 | } |
| | 224 | |
| | 225 | /** |
| | 226 | * zfcp_fc_incoming_els - handle incoming ELS |
| | 227 | * @fsf_req - request which contains incoming ELS |
| | 228 | */ |
| | 229 | void zfcp_fc_incoming_els(struct zfcp_fsf_req *fsf_req) |
| | 230 | { |
| | 231 | struct fsf_status_read_buffer *status_buffer = |
| | 232 | (struct fsf_status_read_buffer *) fsf_req->data; |
| | 233 | unsigned int els_type = status_buffer->payload.data[0]; |
| | 234 | |
| | 235 | zfcp_dbf_san_incoming_els(fsf_req); |
| | 236 | if (els_type == LS_PLOGI) |
| | 237 | zfcp_fc_incoming_plogi(fsf_req); |
| | 238 | else if (els_type == LS_LOGO) |
| | 239 | zfcp_fc_incoming_logo(fsf_req); |
| | 240 | else if (els_type == LS_RSCN) |
| | 241 | zfcp_fc_incoming_rscn(fsf_req); |
| | 242 | } |
| | 243 | |
| | 244 | static void zfcp_fc_ns_handler(unsigned long data) |
| | 245 | { |
| | 246 | struct zfcp_fc_ns_handler_data *compl_rec = |
| | 247 | (struct zfcp_fc_ns_handler_data *) data; |
| | 248 | |
| | 249 | if (compl_rec->handler) |
| | 250 | compl_rec->handler(compl_rec->handler_data); |
| | 251 | |
| | 252 | complete(&compl_rec->done); |
| | 253 | } |
| | 254 | |
| | 255 | static void zfcp_fc_ns_gid_pn_eval(unsigned long data) |
| | 256 | { |
| | 257 | struct zfcp_gid_pn_data *gid_pn = (struct zfcp_gid_pn_data *) data; |
| | 258 | struct zfcp_send_ct *ct = &gid_pn->ct; |
| | 259 | struct ct_iu_gid_pn_req *ct_iu_req = sg_virt(ct->req); |
| | 260 | struct ct_iu_gid_pn_resp *ct_iu_resp = sg_virt(ct->resp); |
| | 261 | struct zfcp_port *port = gid_pn->port; |
| | 262 | |
| | 263 | if (ct->status) |
| | 264 | return; |
| | 265 | if (ct_iu_resp->header.cmd_rsp_code != ZFCP_CT_ACCEPT) |
| | 266 | return; |
| | 267 | |
| | 268 | /* paranoia */ |
| | 269 | if (ct_iu_req->wwpn != port->wwpn) |
| | 270 | return; |
| | 271 | /* looks like a valid d_id */ |
| | 272 | port->d_id = ct_iu_resp->d_id & ZFCP_DID_MASK; |
| | 273 | } |
| | 274 | |
| | 275 | static int zfcp_fc_ns_gid_pn_request(struct zfcp_port *port, |
| | 276 | struct zfcp_gid_pn_data *gid_pn) |
| | 277 | { |
| | 278 | struct zfcp_adapter *adapter = port->adapter; |
| | 279 | struct zfcp_fc_ns_handler_data compl_rec; |
| | 280 | int ret; |
| | 281 | |
| | 282 | /* setup parameters for send generic command */ |
| | 283 | gid_pn->port = port; |
| | 284 | gid_pn->ct.wka_port = &adapter->gs->ds; |
| | 285 | gid_pn->ct.handler = zfcp_fc_ns_handler; |
| | 286 | gid_pn->ct.handler_data = (unsigned long) &compl_rec; |
| | 287 | gid_pn->ct.req = &gid_pn->req; |
| | 288 | gid_pn->ct.resp = &gid_pn->resp; |
| | 289 | sg_init_one(&gid_pn->req, &gid_pn->ct_iu_req, |
| | 290 | sizeof(struct ct_iu_gid_pn_req)); |
| | 291 | sg_init_one(&gid_pn->resp, &gid_pn->ct_iu_resp, |
| | 292 | sizeof(struct ct_iu_gid_pn_resp)); |
| | 293 | |
| | 294 | /* setup nameserver request */ |
| | 295 | gid_pn->ct_iu_req.header.revision = ZFCP_CT_REVISION; |
| | 296 | gid_pn->ct_iu_req.header.gs_type = ZFCP_CT_DIRECTORY_SERVICE; |
| | 297 | gid_pn->ct_iu_req.header.gs_subtype = ZFCP_CT_NAME_SERVER; |
| | 298 | gid_pn->ct_iu_req.header.options = ZFCP_CT_SYNCHRONOUS; |
| | 299 | gid_pn->ct_iu_req.header.cmd_rsp_code = ZFCP_CT_GID_PN; |
| | 300 | gid_pn->ct_iu_req.header.max_res_size = ZFCP_CT_SIZE_ONE_PAGE / 4; |
| | 301 | gid_pn->ct_iu_req.wwpn = port->wwpn; |
| | 302 | |
| | 303 | init_completion(&compl_rec.done); |
| | 304 | compl_rec.handler = zfcp_fc_ns_gid_pn_eval; |
| | 305 | compl_rec.handler_data = (unsigned long) gid_pn; |
| | 306 | ret = zfcp_fsf_send_ct(&gid_pn->ct, adapter->pool.gid_pn_req); |
| | 307 | if (!ret) |
| | 308 | wait_for_completion(&compl_rec.done); |
| | 309 | return ret; |
| | 310 | } |
| | 311 | |
| | 312 | /** |
| | 313 | * zfcp_fc_ns_gid_pn_request - initiate GID_PN nameserver request |
| | 314 | * @port: port where GID_PN request is needed |
| | 315 | * return: -ENOMEM on error, 0 otherwise |
| | 316 | */ |
| | 317 | static int zfcp_fc_ns_gid_pn(struct zfcp_port *port) |
| | 318 | { |
| | 319 | int ret; |
| | 320 | struct zfcp_gid_pn_data *gid_pn; |
| | 321 | struct zfcp_adapter *adapter = port->adapter; |
| | 322 | |
| | 323 | gid_pn = mempool_alloc(adapter->pool.gid_pn_data, GFP_ATOMIC); |
| | 324 | if (!gid_pn) |
| | 325 | return -ENOMEM; |
| | 326 | |
| | 327 | memset(gid_pn, 0, sizeof(*gid_pn)); |
| | 328 | |
| | 329 | ret = zfcp_fc_wka_port_get(&adapter->gs->ds); |
| | 330 | if (ret) |
| | 331 | goto out; |
| | 332 | |
| | 333 | ret = zfcp_fc_ns_gid_pn_request(port, gid_pn); |
| | 334 | |
| | 335 | zfcp_fc_wka_port_put(&adapter->gs->ds); |
| | 336 | out: |
| | 337 | mempool_free(gid_pn, adapter->pool.gid_pn_data); |
| | 338 | return ret; |
| | 339 | } |
| | 340 | |
| | 341 | void zfcp_fc_port_did_lookup(struct work_struct *work) |
| | 342 | { |
| | 343 | int ret; |
| | 344 | struct zfcp_port *port = container_of(work, struct zfcp_port, |
| | 345 | gid_pn_work); |
| | 346 | |
| | 347 | ret = zfcp_fc_ns_gid_pn(port); |
| | 348 | if (ret) { |
| | 349 | /* could not issue gid_pn for some reason */ |
| | 350 | zfcp_erp_adapter_reopen(port->adapter, 0, "fcgpn_1", NULL); |
| | 351 | goto out; |
| | 352 | } |
| | 353 | |
| | 354 | if (!port->d_id) { |
| | 355 | zfcp_erp_port_failed(port, "fcgpn_2", NULL); |
| | 356 | goto out; |
| | 357 | } |
| | 358 | |
| | 359 | zfcp_erp_port_reopen(port, 0, "fcgpn_3", NULL); |
| | 360 | out: |
| | 361 | put_device(&port->sysfs_device); |
| | 362 | } |
| | 363 | |
| | 364 | /** |
| | 365 | * zfcp_fc_trigger_did_lookup - trigger the d_id lookup using a GID_PN request |
| | 366 | * @port: The zfcp_port to lookup the d_id for. |
| | 367 | */ |
| | 368 | void zfcp_fc_trigger_did_lookup(struct zfcp_port *port) |
| | 369 | { |
| | 370 | get_device(&port->sysfs_device); |
| | 371 | if (!queue_work(port->adapter->work_queue, &port->gid_pn_work)) |
| | 372 | put_device(&port->sysfs_device); |
| | 373 | } |
| | 374 | |
| | 375 | /** |
| | 376 | * zfcp_fc_plogi_evaluate - evaluate PLOGI playload |
| | 377 | * @port: zfcp_port structure |
| | 378 | * @plogi: plogi payload |
| | 379 | * |
| | 380 | * Evaluate PLOGI playload and copy important fields into zfcp_port structure |
| | 381 | */ |
| | 382 | void zfcp_fc_plogi_evaluate(struct zfcp_port *port, struct fsf_plogi *plogi) |
| | 383 | { |
| | 384 | port->maxframe_size = plogi->serv_param.common_serv_param[7] | |
| | 385 | ((plogi->serv_param.common_serv_param[6] & 0x0F) << 8); |
| | 386 | if (plogi->serv_param.class1_serv_param[0] & 0x80) |
| | 387 | port->supported_classes |= FC_COS_CLASS1; |
| | 388 | if (plogi->serv_param.class2_serv_param[0] & 0x80) |
| | 389 | port->supported_classes |= FC_COS_CLASS2; |
| | 390 | if (plogi->serv_param.class3_serv_param[0] & 0x80) |
| | 391 | port->supported_classes |= FC_COS_CLASS3; |
| | 392 | if (plogi->serv_param.class4_serv_param[0] & 0x80) |
| | 393 | port->supported_classes |= FC_COS_CLASS4; |
| | 394 | } |
| | 395 | |
| | 396 | struct zfcp_els_adisc { |
| | 397 | struct zfcp_send_els els; |
| | 398 | struct scatterlist req; |
| | 399 | struct scatterlist resp; |
| | 400 | struct zfcp_ls_adisc ls_adisc; |
| | 401 | struct zfcp_ls_adisc ls_adisc_acc; |
| | 402 | }; |
| | 403 | |
| | 404 | static void zfcp_fc_adisc_handler(unsigned long data) |
| | 405 | { |
| | 406 | struct zfcp_els_adisc *adisc = (struct zfcp_els_adisc *) data; |
| | 407 | struct zfcp_port *port = adisc->els.port; |
| | 408 | struct zfcp_ls_adisc *ls_adisc = &adisc->ls_adisc_acc; |
| | 409 | |
| | 410 | if (adisc->els.status) { |
| | 411 | /* request rejected or timed out */ |
| | 412 | zfcp_erp_port_forced_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, |
| | 413 | "fcadh_1", NULL); |
| | 414 | goto out; |
| | 415 | } |
| | 416 | |
| | 417 | if (!port->wwnn) |
| | 418 | port->wwnn = ls_adisc->wwnn; |
| | 419 | |
| | 420 | if ((port->wwpn != ls_adisc->wwpn) || |
| | 421 | !(atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN)) { |
| | 422 | zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, |
| | 423 | "fcadh_2", NULL); |
| | 424 | goto out; |
| | 425 | } |
| | 426 | |
| | 427 | /* port is good, unblock rport without going through erp */ |
| | 428 | zfcp_scsi_schedule_rport_register(port); |
| | 429 | out: |
| | 430 | atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST, &port->status); |
| | 431 | put_device(&port->sysfs_device); |
| | 432 | kfree(adisc); |
| | 433 | } |
| | 434 | |
| | 435 | static int zfcp_fc_adisc(struct zfcp_port *port) |
| | 436 | { |
| | 437 | struct zfcp_els_adisc *adisc; |
| | 438 | struct zfcp_adapter *adapter = port->adapter; |
| | 439 | |
| | 440 | adisc = kzalloc(sizeof(struct zfcp_els_adisc), GFP_ATOMIC); |
| | 441 | if (!adisc) |
| | 442 | return -ENOMEM; |
| | 443 | |
| | 444 | adisc->els.req = &adisc->req; |
| | 445 | adisc->els.resp = &adisc->resp; |
| | 446 | sg_init_one(adisc->els.req, &adisc->ls_adisc, |
| | 447 | sizeof(struct zfcp_ls_adisc)); |
| | 448 | sg_init_one(adisc->els.resp, &adisc->ls_adisc_acc, |
| | 449 | sizeof(struct zfcp_ls_adisc)); |
| | 450 | |
| | 451 | adisc->els.adapter = adapter; |
| | 452 | adisc->els.port = port; |
| | 453 | adisc->els.d_id = port->d_id; |
| | 454 | adisc->els.handler = zfcp_fc_adisc_handler; |
| | 455 | adisc->els.handler_data = (unsigned long) adisc; |
| | 456 | adisc->els.ls_code = adisc->ls_adisc.code = ZFCP_LS_ADISC; |
| | 457 | |
| | 458 | /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports |
| | 459 | without FC-AL-2 capability, so we don't set it */ |
| | 460 | adisc->ls_adisc.wwpn = fc_host_port_name(adapter->scsi_host); |
| | 461 | adisc->ls_adisc.wwnn = fc_host_node_name(adapter->scsi_host); |
| | 462 | adisc->ls_adisc.nport_id = fc_host_port_id(adapter->scsi_host); |
| | 463 | |
| | 464 | return zfcp_fsf_send_els(&adisc->els); |
| | 465 | } |
| | 466 | |
| | 467 | void zfcp_fc_link_test_work(struct work_struct *work) |
| | 468 | { |
| | 469 | struct zfcp_port *port = |
| | 470 | container_of(work, struct zfcp_port, test_link_work); |
| | 471 | int retval; |
| | 472 | |
| | 473 | get_device(&port->sysfs_device); |
| | 474 | port->rport_task = RPORT_DEL; |
| | 475 | zfcp_scsi_rport_work(&port->rport_work); |
| | 476 | |
| | 477 | /* only issue one test command at one time per port */ |
| | 478 | if (atomic_read(&port->status) & ZFCP_STATUS_PORT_LINK_TEST) |
| | 479 | goto out; |
| | 480 | |
| | 481 | atomic_set_mask(ZFCP_STATUS_PORT_LINK_TEST, &port->status); |
| | 482 | |
| | 483 | retval = zfcp_fc_adisc(port); |
| | 484 | if (retval == 0) |
| | 485 | return; |
| | 486 | |
| | 487 | /* send of ADISC was not possible */ |
| | 488 | atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST, &port->status); |
| | 489 | zfcp_erp_port_forced_reopen(port, 0, "fcltwk1", NULL); |
| | 490 | |
| | 491 | out: |
| | 492 | put_device(&port->sysfs_device); |
| | 493 | } |
| | 494 | |
| | 495 | /** |
| | 496 | * zfcp_fc_test_link - lightweight link test procedure |
| | 497 | * @port: port to be tested |
| | 498 | * |
| | 499 | * Test status of a link to a remote port using the ELS command ADISC. |
| | 500 | * If there is a problem with the remote port, error recovery steps |
| | 501 | * will be triggered. |
| | 502 | */ |
| | 503 | void zfcp_fc_test_link(struct zfcp_port *port) |
| | 504 | { |
| | 505 | get_device(&port->sysfs_device); |
| | 506 | if (!queue_work(port->adapter->work_queue, &port->test_link_work)) |
| | 507 | put_device(&port->sysfs_device); |
| | 508 | } |
| | 509 | |
| | 510 | static void zfcp_free_sg_env(struct zfcp_gpn_ft *gpn_ft, int buf_num) |
| | 511 | { |
| | 512 | struct scatterlist *sg = &gpn_ft->sg_req; |
| | 513 | |
| | 514 | kmem_cache_free(zfcp_data.gpn_ft_cache, sg_virt(sg)); |
| | 515 | zfcp_sg_free_table(gpn_ft->sg_resp, buf_num); |
| | 516 | |
| | 517 | kfree(gpn_ft); |
| | 518 | } |
| | 519 | |
| | 520 | static struct zfcp_gpn_ft *zfcp_alloc_sg_env(int buf_num) |
| | 521 | { |
| | 522 | struct zfcp_gpn_ft *gpn_ft; |
| | 523 | struct ct_iu_gpn_ft_req *req; |
| | 524 | |
| | 525 | gpn_ft = kzalloc(sizeof(*gpn_ft), GFP_KERNEL); |
| | 526 | if (!gpn_ft) |
| | 527 | return NULL; |
| | 528 | |
| | 529 | req = kmem_cache_alloc(zfcp_data.gpn_ft_cache, GFP_KERNEL); |
| | 530 | if (!req) { |
| | 531 | kfree(gpn_ft); |
| | 532 | gpn_ft = NULL; |
| | 533 | goto out; |
| | 534 | } |
| | 535 | sg_init_one(&gpn_ft->sg_req, req, sizeof(*req)); |
| | 536 | |
| | 537 | if (zfcp_sg_setup_table(gpn_ft->sg_resp, buf_num)) { |
| | 538 | zfcp_free_sg_env(gpn_ft, buf_num); |
| | 539 | gpn_ft = NULL; |
| | 540 | } |
| | 541 | out: |
| | 542 | return gpn_ft; |
| | 543 | } |
| | 544 | |
| | 545 | |
| | 546 | static int zfcp_fc_send_gpn_ft(struct zfcp_gpn_ft *gpn_ft, |
| | 547 | struct zfcp_adapter *adapter, int max_bytes) |
| | 548 | { |
| | 549 | struct zfcp_send_ct *ct = &gpn_ft->ct; |
| | 550 | struct ct_iu_gpn_ft_req *req = sg_virt(&gpn_ft->sg_req); |
| | 551 | struct zfcp_fc_ns_handler_data compl_rec; |
| | 552 | int ret; |
| | 553 | |
| | 554 | /* prepare CT IU for GPN_FT */ |
| | 555 | req->header.revision = ZFCP_CT_REVISION; |
| | 556 | req->header.gs_type = ZFCP_CT_DIRECTORY_SERVICE; |
| | 557 | req->header.gs_subtype = ZFCP_CT_NAME_SERVER; |
| | 558 | req->header.options = ZFCP_CT_SYNCHRONOUS; |
| | 559 | req->header.cmd_rsp_code = ZFCP_CT_GPN_FT; |
| | 560 | req->header.max_res_size = max_bytes / 4; |
| | 561 | req->flags = 0; |
| | 562 | req->domain_id_scope = 0; |
| | 563 | req->area_id_scope = 0; |
| | 564 | req->fc4_type = ZFCP_CT_SCSI_FCP; |
| | 565 | |
| | 566 | /* prepare zfcp_send_ct */ |
| | 567 | ct->wka_port = &adapter->gs->ds; |
| | 568 | ct->handler = zfcp_fc_ns_handler; |
| | 569 | ct->handler_data = (unsigned long)&compl_rec; |
| | 570 | ct->req = &gpn_ft->sg_req; |
| | 571 | ct->resp = gpn_ft->sg_resp; |
| | 572 | |
| | 573 | init_completion(&compl_rec.done); |
| | 574 | compl_rec.handler = NULL; |
| | 575 | ret = zfcp_fsf_send_ct(ct, NULL); |
| | 576 | if (!ret) |
| | 577 | wait_for_completion(&compl_rec.done); |
| | 578 | return ret; |
| | 579 | } |
| | 580 | |
| | 581 | static void zfcp_fc_validate_port(struct zfcp_port *port, struct list_head *lh) |
| | 582 | { |
| | 583 | if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC)) |
| | 584 | return; |
| | 585 | |
| | 586 | atomic_clear_mask(ZFCP_STATUS_COMMON_NOESC, &port->status); |
| | 587 | |
| | 588 | if ((port->supported_classes != 0) || |
| | 589 | !list_empty(&port->unit_list)) |
| | 590 | return; |
| | 591 | |
| | 592 | list_move_tail(&port->list, lh); |
| | 593 | } |
| | 594 | |
| | 595 | static int zfcp_fc_eval_gpn_ft(struct zfcp_gpn_ft *gpn_ft, int max_entries) |
| | 596 | { |
| | 597 | struct zfcp_send_ct *ct = &gpn_ft->ct; |
| | 598 | struct scatterlist *sg = gpn_ft->sg_resp; |
| | 599 | struct ct_hdr *hdr = sg_virt(sg); |
| | 600 | struct gpn_ft_resp_acc *acc = sg_virt(sg); |
| | 601 | struct zfcp_adapter *adapter = ct->wka_port->adapter; |
| | 602 | struct zfcp_port *port, *tmp; |
| | 603 | unsigned long flags; |
| | 604 | LIST_HEAD(remove_lh); |
| | 605 | u32 d_id; |
| | 606 | int ret = 0, x, last = 0; |
| | 607 | |
| | 608 | if (ct->status) |
| | 609 | return -EIO; |
| | 610 | |
| | 611 | if (hdr->cmd_rsp_code != ZFCP_CT_ACCEPT) { |
| | 612 | if (hdr->reason_code == ZFCP_CT_UNABLE_TO_PERFORM_CMD) |
| | 613 | return -EAGAIN; /* might be a temporary condition */ |
| | 614 | return -EIO; |
| | 615 | } |
| | 616 | |
| | 617 | if (hdr->max_res_size) { |
| | 618 | dev_warn(&adapter->ccw_device->dev, |
| | 619 | "The name server reported %d words residual data\n", |
| | 620 | hdr->max_res_size); |
| | 621 | return -E2BIG; |
| | 622 | } |
| | 623 | |
| | 624 | /* first entry is the header */ |
| | 625 | for (x = 1; x < max_entries && !last; x++) { |
| | 626 | if (x % (ZFCP_GPN_FT_ENTRIES + 1)) |
| | 627 | acc++; |
| | 628 | else |
| | 629 | acc = sg_virt(++sg); |
| | 630 | |
| | 631 | last = acc->control & 0x80; |
| | 632 | d_id = acc->port_id[0] << 16 | acc->port_id[1] << 8 | |
| | 633 | acc->port_id[2]; |
| | 634 | |
| | 635 | /* don't attach ports with a well known address */ |
| | 636 | if ((d_id & ZFCP_DID_WKA) == ZFCP_DID_WKA) |
| | 637 | continue; |
| | 638 | /* skip the adapter's port and known remote ports */ |
| | 639 | if (acc->wwpn == fc_host_port_name(adapter->scsi_host)) |
| | 640 | continue; |
| | 641 | |
| | 642 | port = zfcp_port_enqueue(adapter, acc->wwpn, |
| | 643 | ZFCP_STATUS_COMMON_NOESC, d_id); |
| | 644 | if (!IS_ERR(port)) |
| | 645 | zfcp_erp_port_reopen(port, 0, "fcegpf1", NULL); |
| | 646 | else if (PTR_ERR(port) != -EEXIST) |
| | 647 | ret = PTR_ERR(port); |
| | 648 | } |
| | 649 | |
| | 650 | zfcp_erp_wait(adapter); |
| | 651 | write_lock_irqsave(&adapter->port_list_lock, flags); |
| | 652 | list_for_each_entry_safe(port, tmp, &adapter->port_list, list) |
| | 653 | zfcp_fc_validate_port(port, &remove_lh); |
| | 654 | write_unlock_irqrestore(&adapter->port_list_lock, flags); |
| | 655 | |
| | 656 | list_for_each_entry_safe(port, tmp, &remove_lh, list) { |
| | 657 | zfcp_erp_port_shutdown(port, 0, "fcegpf2", NULL); |
| | 658 | zfcp_device_unregister(&port->sysfs_device, |
| | 659 | &zfcp_sysfs_port_attrs); |
| | 660 | } |
| | 661 | |
| | 662 | return ret; |
| | 663 | } |
| | 664 | |
| | 665 | /** |
| | 666 | * zfcp_fc_scan_ports - scan remote ports and attach new ports |
| | 667 | * @adapter: pointer to struct zfcp_adapter |
| | 668 | */ |
| | 669 | int zfcp_fc_scan_ports(struct zfcp_adapter *adapter) |
| | 670 | { |
| | 671 | int ret, i; |
| | 672 | struct zfcp_gpn_ft *gpn_ft; |
| | 673 | int chain, max_entries, buf_num, max_bytes; |
| | 674 | |
| | 675 | chain = adapter->adapter_features & FSF_FEATURE_ELS_CT_CHAINED_SBALS; |
| | 676 | buf_num = chain ? ZFCP_GPN_FT_BUFFERS : 1; |
| | 677 | max_entries = chain ? ZFCP_GPN_FT_MAX_ENTRIES : ZFCP_GPN_FT_ENTRIES; |
| | 678 | max_bytes = chain ? ZFCP_GPN_FT_MAX_SIZE : ZFCP_CT_SIZE_ONE_PAGE; |
| | 679 | |
| | 680 | if (fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPORT && |
| | 681 | fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPIV) |
| | 682 | return 0; |
| | 683 | |
| | 684 | ret = zfcp_fc_wka_port_get(&adapter->gs->ds); |
| | 685 | if (ret) |
| | 686 | return ret; |
| | 687 | |
| | 688 | gpn_ft = zfcp_alloc_sg_env(buf_num); |
| | 689 | if (!gpn_ft) { |
| | 690 | ret = -ENOMEM; |
| | 691 | goto out; |
| | 692 | } |
| | 693 | |
| | 694 | for (i = 0; i < 3; i++) { |
| | 695 | ret = zfcp_fc_send_gpn_ft(gpn_ft, adapter, max_bytes); |
| | 696 | if (!ret) { |
| | 697 | ret = zfcp_fc_eval_gpn_ft(gpn_ft, max_entries); |
| | 698 | if (ret == -EAGAIN) |
| | 699 | ssleep(1); |
| | 700 | else |
| | 701 | break; |
| | 702 | } |
| | 703 | } |
| | 704 | zfcp_free_sg_env(gpn_ft, buf_num); |
| | 705 | out: |
| | 706 | zfcp_fc_wka_port_put(&adapter->gs->ds); |
| | 707 | return ret; |
| | 708 | } |
| | 709 | |
| | 710 | |
| | 711 | void _zfcp_fc_scan_ports_later(struct work_struct *work) |
| | 712 | { |
| | 713 | zfcp_fc_scan_ports(container_of(work, struct zfcp_adapter, scan_work)); |
| | 714 | } |
| | 715 | |
| | 716 | struct zfcp_els_fc_job { |
| | 717 | struct zfcp_send_els els; |
| | 718 | struct fc_bsg_job *job; |
| | 719 | }; |
| | 720 | |
| | 721 | static void zfcp_fc_generic_els_handler(unsigned long data) |
| | 722 | { |
| | 723 | struct zfcp_els_fc_job *els_fc_job = (struct zfcp_els_fc_job *) data; |
| | 724 | struct fc_bsg_job *job = els_fc_job->job; |
| | 725 | struct fc_bsg_reply *reply = job->reply; |
| | 726 | |
| | 727 | if (els_fc_job->els.status) { |
| | 728 | /* request rejected or timed out */ |
| | 729 | reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_REJECT; |
| | 730 | goto out; |
| | 731 | } |
| | 732 | |
| | 733 | reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK; |
| | 734 | reply->reply_payload_rcv_len = job->reply_payload.payload_len; |
| | 735 | |
| | 736 | out: |
| | 737 | job->state_flags = FC_RQST_STATE_DONE; |
| | 738 | job->job_done(job); |
| | 739 | kfree(els_fc_job); |
| | 740 | } |
| | 741 | |
| | 742 | int zfcp_fc_execute_els_fc_job(struct fc_bsg_job *job) |
| | 743 | { |
| | 744 | struct zfcp_els_fc_job *els_fc_job; |
| | 745 | struct fc_rport *rport = job->rport; |
| | 746 | struct Scsi_Host *shost; |
| | 747 | struct zfcp_adapter *adapter; |
| | 748 | struct zfcp_port *port; |
| | 749 | u8 *port_did; |
| | 750 | |
| | 751 | shost = rport ? rport_to_shost(rport) : job->shost; |
| | 752 | adapter = (struct zfcp_adapter *)shost->hostdata[0]; |
| | 753 | |
| | 754 | if (!(atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN)) |
| | 755 | return -EINVAL; |
| | 756 | |
| | 757 | els_fc_job = kzalloc(sizeof(struct zfcp_els_fc_job), GFP_KERNEL); |
| | 758 | if (!els_fc_job) |
| | 759 | return -ENOMEM; |
| | 760 | |
| | 761 | els_fc_job->els.adapter = adapter; |
| | 762 | if (rport) { |
| | 763 | port = zfcp_get_port_by_wwpn(adapter, rport->port_name); |
| | 764 | if (!port) { |
| | 765 | kfree(els_fc_job); |
| | 766 | return -EINVAL; |
| | 767 | } |
| | 768 | |
| | 769 | els_fc_job->els.d_id = port->d_id; |
| | 770 | put_device(&port->sysfs_device); |
| | 771 | } else { |
| | 772 | port_did = job->request->rqst_data.h_els.port_id; |
| | 773 | els_fc_job->els.d_id = (port_did[0] << 16) + |
| | 774 | (port_did[1] << 8) + port_did[2]; |
| | 775 | } |
| | 776 | |
| | 777 | els_fc_job->els.req = job->request_payload.sg_list; |
| | 778 | els_fc_job->els.resp = job->reply_payload.sg_list; |
| | 779 | els_fc_job->els.handler = zfcp_fc_generic_els_handler; |
| | 780 | els_fc_job->els.handler_data = (unsigned long) els_fc_job; |
| | 781 | els_fc_job->job = job; |
| | 782 | |
| | 783 | return zfcp_fsf_send_els(&els_fc_job->els); |
| | 784 | } |
| | 785 | |
| | 786 | struct zfcp_ct_fc_job { |
| | 787 | struct zfcp_send_ct ct; |
| | 788 | struct fc_bsg_job *job; |
| | 789 | }; |
| | 790 | |
| | 791 | static void zfcp_fc_generic_ct_handler(unsigned long data) |
| | 792 | { |
| | 793 | struct zfcp_ct_fc_job *ct_fc_job = (struct zfcp_ct_fc_job *) data; |
| | 794 | struct fc_bsg_job *job = ct_fc_job->job; |
| | 795 | |
| | 796 | job->reply->reply_data.ctels_reply.status = ct_fc_job->ct.status ? |
| | 797 | FC_CTELS_STATUS_REJECT : FC_CTELS_STATUS_OK; |
| | 798 | job->reply->reply_payload_rcv_len = job->reply_payload.payload_len; |
| | 799 | job->state_flags = FC_RQST_STATE_DONE; |
| | 800 | job->job_done(job); |
| | 801 | |
| | 802 | zfcp_fc_wka_port_put(ct_fc_job->ct.wka_port); |
| | 803 | |
| | 804 | kfree(ct_fc_job); |
| | 805 | } |
| | 806 | |
| | 807 | int zfcp_fc_execute_ct_fc_job(struct fc_bsg_job *job) |
| | 808 | { |
| | 809 | int ret; |
| | 810 | u8 gs_type; |
| | 811 | struct fc_rport *rport = job->rport; |
| | 812 | struct Scsi_Host *shost; |
| | 813 | struct zfcp_adapter *adapter; |
| | 814 | struct zfcp_ct_fc_job *ct_fc_job; |
| | 815 | u32 preamble_word1; |
| | 816 | |
| | 817 | shost = rport ? rport_to_shost(rport) : job->shost; |
| | 818 | |
| | 819 | adapter = (struct zfcp_adapter *)shost->hostdata[0]; |
| | 820 | if (!(atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN)) |
| | 821 | return -EINVAL; |
| | 822 | |
| | 823 | ct_fc_job = kzalloc(sizeof(struct zfcp_ct_fc_job), GFP_KERNEL); |
| | 824 | if (!ct_fc_job) |
| | 825 | return -ENOMEM; |
| | 826 | |
| | 827 | preamble_word1 = job->request->rqst_data.r_ct.preamble_word1; |
| | 828 | gs_type = (preamble_word1 & 0xff000000) >> 24; |
| | 829 | |
| | 830 | switch (gs_type) { |
| | 831 | case FC_FST_ALIAS: |
| | 832 | ct_fc_job->ct.wka_port = &adapter->gs->as; |
| | 833 | break; |
| | 834 | case FC_FST_MGMT: |
| | 835 | ct_fc_job->ct.wka_port = &adapter->gs->ms; |
| | 836 | break; |
| | 837 | case FC_FST_TIME: |
| | 838 | ct_fc_job->ct.wka_port = &adapter->gs->ts; |
| | 839 | break; |
| | 840 | case FC_FST_DIR: |
| | 841 | ct_fc_job->ct.wka_port = &adapter->gs->ds; |
| | 842 | break; |
| | 843 | default: |
| | 844 | kfree(ct_fc_job); |
| | 845 | return -EINVAL; /* no such service */ |
| | 846 | } |
| | 847 | |
| | 848 | ret = zfcp_fc_wka_port_get(ct_fc_job->ct.wka_port); |
| | 849 | if (ret) { |
| | 850 | kfree(ct_fc_job); |
| | 851 | return ret; |
| | 852 | } |
| | 853 | |
| | 854 | ct_fc_job->ct.req = job->request_payload.sg_list; |
| | 855 | ct_fc_job->ct.resp = job->reply_payload.sg_list; |
| | 856 | ct_fc_job->ct.handler = zfcp_fc_generic_ct_handler; |
| | 857 | ct_fc_job->ct.handler_data = (unsigned long) ct_fc_job; |
| | 858 | ct_fc_job->ct.completion = NULL; |
| | 859 | ct_fc_job->job = job; |
| | 860 | |
| | 861 | ret = zfcp_fsf_send_ct(&ct_fc_job->ct, NULL); |
| | 862 | if (ret) { |
| | 863 | kfree(ct_fc_job); |
| | 864 | zfcp_fc_wka_port_put(ct_fc_job->ct.wka_port); |
| | 865 | } |
| | 866 | return ret; |
| | 867 | } |
| | 868 | |
| | 869 | int zfcp_fc_gs_setup(struct zfcp_adapter *adapter) |
| | 870 | { |
| | 871 | struct zfcp_wka_ports *wka_ports; |
| | 872 | |
| | 873 | wka_ports = kzalloc(sizeof(struct zfcp_wka_ports), GFP_KERNEL); |
| | 874 | if (!wka_ports) |
| | 875 | return -ENOMEM; |
| | 876 | |
| | 877 | adapter->gs = wka_ports; |
| | 878 | zfcp_fc_wka_port_init(&wka_ports->ms, FC_FID_MGMT_SERV, adapter); |
| | 879 | zfcp_fc_wka_port_init(&wka_ports->ts, FC_FID_TIME_SERV, adapter); |
| | 880 | zfcp_fc_wka_port_init(&wka_ports->ds, FC_FID_DIR_SERV, adapter); |
| | 881 | zfcp_fc_wka_port_init(&wka_ports->as, FC_FID_ALIASES, adapter); |
| | 882 | zfcp_fc_wka_port_init(&wka_ports->ks, FC_FID_SEC_KEY, adapter); |
| | 883 | |
| | 884 | return 0; |
| | 885 | } |
| | 886 | |
| | 887 | void zfcp_fc_gs_destroy(struct zfcp_adapter *adapter) |
| | 888 | { |
| | 889 | kfree(adapter->gs); |
| | 890 | adapter->gs = NULL; |
| | 891 | } |
| | 892 | |
projects / deliverable / linux.git / blame_incremental