drivers/s390/scsi/zfcp_fc.c

   1 /*
   2  * zfcp device driver
   3  *
   4  * Fibre Channel related functions for the zfcp device driver.
   5  *
   6  * Copyright IBM Corporation 2008, 2010
   7  */
   8
   9 #define KMSG_COMPONENT "zfcp"
  10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  11
  12 #include <linux/types.h>
  13 #include <linux/slab.h>
  14 #include <scsi/fc/fc_els.h>
  15 #include <scsi/libfc.h>
  16 #include "zfcp_ext.h"
  17 #include "zfcp_fc.h"
  18
  19 struct kmem_cache *zfcp_fc_req_cache;
  20
  21 static u32 zfcp_fc_rscn_range_mask[] = {
  22         [ELS_ADDR_FMT_PORT]             = 0xFFFFFF,
  23         [ELS_ADDR_FMT_AREA]             = 0xFFFF00,
  24         [ELS_ADDR_FMT_DOM]              = 0xFF0000,
  25         [ELS_ADDR_FMT_FAB]              = 0x000000,
  26 };
  27
  28 /**
  29  * zfcp_fc_post_event - post event to userspace via fc_transport
  30  * @work: work struct with enqueued events
  31  */
  32 void zfcp_fc_post_event(struct work_struct *work)
  33 {
  34         struct zfcp_fc_event *event = NULL, *tmp = NULL;
  35         LIST_HEAD(tmp_lh);
  36         struct zfcp_fc_events *events = container_of(work,
  37                                         struct zfcp_fc_events, work);
  38         struct zfcp_adapter *adapter = container_of(events, struct zfcp_adapter,
  39                                                 events);
  40
  41         spin_lock_bh(&events->list_lock);
  42         list_splice_init(&events->list, &tmp_lh);
  43         spin_unlock_bh(&events->list_lock);
  44
  45         list_for_each_entry_safe(event, tmp, &tmp_lh, list) {
  46                 fc_host_post_event(adapter->scsi_host, fc_get_event_number(),
  47                                 event->code, event->data);
  48                 list_del(&event->list);
  49                 kfree(event);
  50         }
  51
  52 }
  53
  54 /**
  55  * zfcp_fc_enqueue_event - safely enqueue FC HBA API event from irq context
  56  * @adapter: The adapter where to enqueue the event
  57  * @event_code: The event code (as defined in fc_host_event_code in
  58  *              scsi_transport_fc.h)
  59  * @event_data: The event data (e.g. n_port page in case of els)
  60  */
  61 void zfcp_fc_enqueue_event(struct zfcp_adapter *adapter,
  62                         enum fc_host_event_code event_code, u32 event_data)
  63 {
  64         struct zfcp_fc_event *event;
  65
  66         event = kmalloc(sizeof(struct zfcp_fc_event), GFP_ATOMIC);
  67         if (!event)
  68                 return;
  69
  70         event->code = event_code;
  71         event->data = event_data;
  72
  73         spin_lock(&adapter->events.list_lock);
  74         list_add_tail(&event->list, &adapter->events.list);
  75         spin_unlock(&adapter->events.list_lock);
  76
  77         queue_work(adapter->work_queue, &adapter->events.work);
  78 }
  79
  80 static int zfcp_fc_wka_port_get(struct zfcp_fc_wka_port *wka_port)
  81 {
  82         if (mutex_lock_interruptible(&wka_port->mutex))
  83                 return -ERESTARTSYS;
  84
  85         if (wka_port->status == ZFCP_FC_WKA_PORT_OFFLINE ||
  86             wka_port->status == ZFCP_FC_WKA_PORT_CLOSING) {
  87                 wka_port->status = ZFCP_FC_WKA_PORT_OPENING;
  88                 if (zfcp_fsf_open_wka_port(wka_port))
  89                         wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
  90         }
  91
  92         mutex_unlock(&wka_port->mutex);
  93
  94         wait_event(wka_port->completion_wq,
  95                    wka_port->status == ZFCP_FC_WKA_PORT_ONLINE ||
  96                    wka_port->status == ZFCP_FC_WKA_PORT_OFFLINE);
  97
  98         if (wka_port->status == ZFCP_FC_WKA_PORT_ONLINE) {
  99                 atomic_inc(&wka_port->refcount);
 100                 return 0;
 101         }
 102         return -EIO;
 103 }
 104
 105 static void zfcp_fc_wka_port_offline(struct work_struct *work)
 106 {
 107         struct delayed_work *dw = to_delayed_work(work);
 108         struct zfcp_fc_wka_port *wka_port =
 109                         container_of(dw, struct zfcp_fc_wka_port, work);
 110
 111         mutex_lock(&wka_port->mutex);
 112         if ((atomic_read(&wka_port->refcount) != 0) ||
 113             (wka_port->status != ZFCP_FC_WKA_PORT_ONLINE))
 114                 goto out;
 115
 116         wka_port->status = ZFCP_FC_WKA_PORT_CLOSING;
 117         if (zfcp_fsf_close_wka_port(wka_port)) {
 118                 wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
 119                 wake_up(&wka_port->completion_wq);
 120         }
 121 out:
 122         mutex_unlock(&wka_port->mutex);
 123 }
 124
 125 static void zfcp_fc_wka_port_put(struct zfcp_fc_wka_port *wka_port)
 126 {
 127         if (atomic_dec_return(&wka_port->refcount) != 0)
 128                 return;
 129         /* wait 10 milliseconds, other reqs might pop in */
 130         schedule_delayed_work(&wka_port->work, HZ / 100);
 131 }
 132
 133 static void zfcp_fc_wka_port_init(struct zfcp_fc_wka_port *wka_port, u32 d_id,
 134                                   struct zfcp_adapter *adapter)
 135 {
 136         init_waitqueue_head(&wka_port->completion_wq);
 137
 138         wka_port->adapter = adapter;
 139         wka_port->d_id = d_id;
 140
 141         wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
 142         atomic_set(&wka_port->refcount, 0);
 143         mutex_init(&wka_port->mutex);
 144         INIT_DELAYED_WORK(&wka_port->work, zfcp_fc_wka_port_offline);
 145 }
 146
 147 static void zfcp_fc_wka_port_force_offline(struct zfcp_fc_wka_port *wka)
 148 {
 149         cancel_delayed_work_sync(&wka->work);
 150         mutex_lock(&wka->mutex);
 151         wka->status = ZFCP_FC_WKA_PORT_OFFLINE;
 152         mutex_unlock(&wka->mutex);
 153 }
 154
 155 void zfcp_fc_wka_ports_force_offline(struct zfcp_fc_wka_ports *gs)
 156 {
 157         if (!gs)
 158                 return;
 159         zfcp_fc_wka_port_force_offline(&gs->ms);
 160         zfcp_fc_wka_port_force_offline(&gs->ts);
 161         zfcp_fc_wka_port_force_offline(&gs->ds);
 162         zfcp_fc_wka_port_force_offline(&gs->as);
 163 }
 164
 165 static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req, u32 range,
 166                                    struct fc_els_rscn_page *page)
 167 {
 168         unsigned long flags;
 169         struct zfcp_adapter *adapter = fsf_req->adapter;
 170         struct zfcp_port *port;
 171
 172         read_lock_irqsave(&adapter->port_list_lock, flags);
 173         list_for_each_entry(port, &adapter->port_list, list) {
 174                 if ((port->d_id & range) == (ntoh24(page->rscn_fid) & range))
 175                         zfcp_fc_test_link(port);
 176                 if (!port->d_id)
 177                         zfcp_erp_port_reopen(port,
 178                                              ZFCP_STATUS_COMMON_ERP_FAILED,
 179                                              "fcrscn1");
 180         }
 181         read_unlock_irqrestore(&adapter->port_list_lock, flags);
 182 }
 183
 184 static void zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req)
 185 {
 186         struct fsf_status_read_buffer *status_buffer = (void *)fsf_req->data;
 187         struct fc_els_rscn *head;
 188         struct fc_els_rscn_page *page;
 189         u16 i;
 190         u16 no_entries;
 191         unsigned int afmt;
 192
 193         head = (struct fc_els_rscn *) status_buffer->payload.data;
 194         page = (struct fc_els_rscn_page *) head;
 195
 196         /* see FC-FS */
 197         no_entries = head->rscn_plen / sizeof(struct fc_els_rscn_page);
 198
 199         for (i = 1; i < no_entries; i++) {
 200                 /* skip head and start with 1st element */
 201                 page++;
 202                 afmt = page->rscn_page_flags & ELS_RSCN_ADDR_FMT_MASK;
 203                 _zfcp_fc_incoming_rscn(fsf_req, zfcp_fc_rscn_range_mask[afmt],
 204                                        page);
 205                 zfcp_fc_enqueue_event(fsf_req->adapter, FCH_EVT_RSCN,
 206                                       *(u32 *)page);
 207         }
 208         queue_work(fsf_req->adapter->work_queue, &fsf_req->adapter->scan_work);
 209 }
 210
 211 static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req *req, u64 wwpn)
 212 {
 213         unsigned long flags;
 214         struct zfcp_adapter *adapter = req->adapter;
 215         struct zfcp_port *port;
 216
 217         read_lock_irqsave(&adapter->port_list_lock, flags);
 218         list_for_each_entry(port, &adapter->port_list, list)
 219                 if (port->wwpn == wwpn) {
 220                         zfcp_erp_port_forced_reopen(port, 0, "fciwwp1");
 221                         break;
 222                 }
 223         read_unlock_irqrestore(&adapter->port_list_lock, flags);
 224 }
 225
 226 static void zfcp_fc_incoming_plogi(struct zfcp_fsf_req *req)
 227 {
 228         struct fsf_status_read_buffer *status_buffer;
 229         struct fc_els_flogi *plogi;
 230
 231         status_buffer = (struct fsf_status_read_buffer *) req->data;
 232         plogi = (struct fc_els_flogi *) status_buffer->payload.data;
 233         zfcp_fc_incoming_wwpn(req, plogi->fl_wwpn);
 234 }
 235
 236 static void zfcp_fc_incoming_logo(struct zfcp_fsf_req *req)
 237 {
 238         struct fsf_status_read_buffer *status_buffer =
 239                 (struct fsf_status_read_buffer *)req->data;
 240         struct fc_els_logo *logo =
 241                 (struct fc_els_logo *) status_buffer->payload.data;
 242
 243         zfcp_fc_incoming_wwpn(req, logo->fl_n_port_wwn);
 244 }
 245
 246 /**
 247  * zfcp_fc_incoming_els - handle incoming ELS
 248  * @fsf_req - request which contains incoming ELS
 249  */
 250 void zfcp_fc_incoming_els(struct zfcp_fsf_req *fsf_req)
 251 {
 252         struct fsf_status_read_buffer *status_buffer =
 253                 (struct fsf_status_read_buffer *) fsf_req->data;
 254         unsigned int els_type = status_buffer->payload.data[0];
 255
 256         zfcp_dbf_san_in_els("fciels1", fsf_req);
 257         if (els_type == ELS_PLOGI)
 258                 zfcp_fc_incoming_plogi(fsf_req);
 259         else if (els_type == ELS_LOGO)
 260                 zfcp_fc_incoming_logo(fsf_req);
 261         else if (els_type == ELS_RSCN)
 262                 zfcp_fc_incoming_rscn(fsf_req);
 263 }
 264
 265 static void zfcp_fc_ns_gid_pn_eval(struct zfcp_fc_req *fc_req)
 266 {
 267         struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
 268         struct zfcp_fc_gid_pn_rsp *gid_pn_rsp = &fc_req->u.gid_pn.rsp;
 269
 270         if (ct_els->status)
 271                 return;
 272         if (gid_pn_rsp->ct_hdr.ct_cmd != FC_FS_ACC)
 273                 return;
 274
 275         /* looks like a valid d_id */
 276         ct_els->port->d_id = ntoh24(gid_pn_rsp->gid_pn.fp_fid);
 277 }
 278
 279 static void zfcp_fc_complete(void *data)
 280 {
 281         complete(data);
 282 }
 283
 284 static void zfcp_fc_ct_ns_init(struct fc_ct_hdr *ct_hdr, u16 cmd, u16 mr_size)
 285 {
 286         ct_hdr->ct_rev = FC_CT_REV;
 287         ct_hdr->ct_fs_type = FC_FST_DIR;
 288         ct_hdr->ct_fs_subtype = FC_NS_SUBTYPE;
 289         ct_hdr->ct_cmd = cmd;
 290         ct_hdr->ct_mr_size = mr_size / 4;
 291 }
 292
 293 static int zfcp_fc_ns_gid_pn_request(struct zfcp_port *port,
 294                                      struct zfcp_fc_req *fc_req)
 295 {
 296         struct zfcp_adapter *adapter = port->adapter;
 297         DECLARE_COMPLETION_ONSTACK(completion);
 298         struct zfcp_fc_gid_pn_req *gid_pn_req = &fc_req->u.gid_pn.req;
 299         struct zfcp_fc_gid_pn_rsp *gid_pn_rsp = &fc_req->u.gid_pn.rsp;
 300         int ret;
 301
 302         /* setup parameters for send generic command */
 303         fc_req->ct_els.port = port;
 304         fc_req->ct_els.handler = zfcp_fc_complete;
 305         fc_req->ct_els.handler_data = &completion;
 306         fc_req->ct_els.req = &fc_req->sg_req;
 307         fc_req->ct_els.resp = &fc_req->sg_rsp;
 308         sg_init_one(&fc_req->sg_req, gid_pn_req, sizeof(*gid_pn_req));
 309         sg_init_one(&fc_req->sg_rsp, gid_pn_rsp, sizeof(*gid_pn_rsp));
 310
 311         zfcp_fc_ct_ns_init(&gid_pn_req->ct_hdr,
 312                            FC_NS_GID_PN, ZFCP_FC_CT_SIZE_PAGE);
 313         gid_pn_req->gid_pn.fn_wwpn = port->wwpn;
 314
 315         ret = zfcp_fsf_send_ct(&adapter->gs->ds, &fc_req->ct_els,
 316                                adapter->pool.gid_pn_req,
 317                                ZFCP_FC_CTELS_TMO);
 318         if (!ret) {
 319                 wait_for_completion(&completion);
 320                 zfcp_fc_ns_gid_pn_eval(fc_req);
 321         }
 322         return ret;
 323 }
 324
 325 /**
 326  * zfcp_fc_ns_gid_pn - initiate GID_PN nameserver request
 327  * @port: port where GID_PN request is needed
 328  * return: -ENOMEM on error, 0 otherwise
 329  */
 330 static int zfcp_fc_ns_gid_pn(struct zfcp_port *port)
 331 {
 332         int ret;
 333         struct zfcp_fc_req *fc_req;
 334         struct zfcp_adapter *adapter = port->adapter;
 335
 336         fc_req = mempool_alloc(adapter->pool.gid_pn, GFP_ATOMIC);
 337         if (!fc_req)
 338                 return -ENOMEM;
 339
 340         memset(fc_req, 0, sizeof(*fc_req));
 341
 342         ret = zfcp_fc_wka_port_get(&adapter->gs->ds);
 343         if (ret)
 344                 goto out;
 345
 346         ret = zfcp_fc_ns_gid_pn_request(port, fc_req);
 347
 348         zfcp_fc_wka_port_put(&adapter->gs->ds);
 349 out:
 350         mempool_free(fc_req, adapter->pool.gid_pn);
 351         return ret;
 352 }
 353
 354 void zfcp_fc_port_did_lookup(struct work_struct *work)
 355 {
 356         int ret;
 357         struct zfcp_port *port = container_of(work, struct zfcp_port,
 358                                               gid_pn_work);
 359
 360         ret = zfcp_fc_ns_gid_pn(port);
 361         if (ret) {
 362                 /* could not issue gid_pn for some reason */
 363                 zfcp_erp_adapter_reopen(port->adapter, 0, "fcgpn_1");
 364                 goto out;
 365         }
 366
 367         if (!port->d_id) {
 368                 zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED);
 369                 goto out;
 370         }
 371
 372         zfcp_erp_port_reopen(port, 0, "fcgpn_3");
 373 out:
 374         put_device(&port->dev);
 375 }
 376
 377 /**
 378  * zfcp_fc_trigger_did_lookup - trigger the d_id lookup using a GID_PN request
 379  * @port: The zfcp_port to lookup the d_id for.
 380  */
 381 void zfcp_fc_trigger_did_lookup(struct zfcp_port *port)
 382 {
 383         get_device(&port->dev);
 384         if (!queue_work(port->adapter->work_queue, &port->gid_pn_work))
 385                 put_device(&port->dev);
 386 }
 387
 388 /**
 389  * zfcp_fc_plogi_evaluate - evaluate PLOGI playload
 390  * @port: zfcp_port structure
 391  * @plogi: plogi payload
 392  *
 393  * Evaluate PLOGI playload and copy important fields into zfcp_port structure
 394  */
 395 void zfcp_fc_plogi_evaluate(struct zfcp_port *port, struct fc_els_flogi *plogi)
 396 {
 397         if (plogi->fl_wwpn != port->wwpn) {
 398                 port->d_id = 0;
 399                 dev_warn(&port->adapter->ccw_device->dev,
 400                          "A port opened with WWPN 0x%016Lx returned data that "
 401                          "identifies it as WWPN 0x%016Lx\n",
 402                          (unsigned long long) port->wwpn,
 403                          (unsigned long long) plogi->fl_wwpn);
 404                 return;
 405         }
 406
 407         port->wwnn = plogi->fl_wwnn;
 408         port->maxframe_size = plogi->fl_csp.sp_bb_data;
 409
 410         if (plogi->fl_cssp[0].cp_class & FC_CPC_VALID)
 411                 port->supported_classes |= FC_COS_CLASS1;
 412         if (plogi->fl_cssp[1].cp_class & FC_CPC_VALID)
 413                 port->supported_classes |= FC_COS_CLASS2;
 414         if (plogi->fl_cssp[2].cp_class & FC_CPC_VALID)
 415                 port->supported_classes |= FC_COS_CLASS3;
 416         if (plogi->fl_cssp[3].cp_class & FC_CPC_VALID)
 417                 port->supported_classes |= FC_COS_CLASS4;
 418 }
 419
 420 static void zfcp_fc_adisc_handler(void *data)
 421 {
 422         struct zfcp_fc_req *fc_req = data;
 423         struct zfcp_port *port = fc_req->ct_els.port;
 424         struct fc_els_adisc *adisc_resp = &fc_req->u.adisc.rsp;
 425
 426         if (fc_req->ct_els.status) {
 427                 /* request rejected or timed out */
 428                 zfcp_erp_port_forced_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED,
 429                                             "fcadh_1");
 430                 goto out;
 431         }
 432
 433         if (!port->wwnn)
 434                 port->wwnn = adisc_resp->adisc_wwnn;
 435
 436         if ((port->wwpn != adisc_resp->adisc_wwpn) ||
 437             !(atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN)) {
 438                 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED,
 439                                      "fcadh_2");
 440                 goto out;
 441         }
 442
 443         /* port is good, unblock rport without going through erp */
 444         zfcp_scsi_schedule_rport_register(port);
 445  out:
 446         atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST, &port->status);
 447         put_device(&port->dev);
 448         kmem_cache_free(zfcp_fc_req_cache, fc_req);
 449 }
 450
 451 static int zfcp_fc_adisc(struct zfcp_port *port)
 452 {
 453         struct zfcp_fc_req *fc_req;
 454         struct zfcp_adapter *adapter = port->adapter;
 455         struct Scsi_Host *shost = adapter->scsi_host;
 456         int ret;
 457
 458         fc_req = kmem_cache_zalloc(zfcp_fc_req_cache, GFP_ATOMIC);
 459         if (!fc_req)
 460                 return -ENOMEM;
 461
 462         fc_req->ct_els.port = port;
 463         fc_req->ct_els.req = &fc_req->sg_req;
 464         fc_req->ct_els.resp = &fc_req->sg_rsp;
 465         sg_init_one(&fc_req->sg_req, &fc_req->u.adisc.req,
 466                     sizeof(struct fc_els_adisc));
 467         sg_init_one(&fc_req->sg_rsp, &fc_req->u.adisc.rsp,
 468                     sizeof(struct fc_els_adisc));
 469
 470         fc_req->ct_els.handler = zfcp_fc_adisc_handler;
 471         fc_req->ct_els.handler_data = fc_req;
 472
 473         /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports
 474            without FC-AL-2 capability, so we don't set it */
 475         fc_req->u.adisc.req.adisc_wwpn = fc_host_port_name(shost);
 476         fc_req->u.adisc.req.adisc_wwnn = fc_host_node_name(shost);
 477         fc_req->u.adisc.req.adisc_cmd = ELS_ADISC;
 478         hton24(fc_req->u.adisc.req.adisc_port_id, fc_host_port_id(shost));
 479
 480         ret = zfcp_fsf_send_els(adapter, port->d_id, &fc_req->ct_els,
 481                                 ZFCP_FC_CTELS_TMO);
 482         if (ret)
 483                 kmem_cache_free(zfcp_fc_req_cache, fc_req);
 484
 485         return ret;
 486 }
 487
 488 void zfcp_fc_link_test_work(struct work_struct *work)
 489 {
 490         struct zfcp_port *port =
 491                 container_of(work, struct zfcp_port, test_link_work);
 492         int retval;
 493
 494         get_device(&port->dev);
 495         port->rport_task = RPORT_DEL;
 496         zfcp_scsi_rport_work(&port->rport_work);
 497
 498         /* only issue one test command at one time per port */
 499         if (atomic_read(&port->status) & ZFCP_STATUS_PORT_LINK_TEST)
 500                 goto out;
 501
 502         atomic_set_mask(ZFCP_STATUS_PORT_LINK_TEST, &port->status);
 503
 504         retval = zfcp_fc_adisc(port);
 505         if (retval == 0)
 506                 return;
 507
 508         /* send of ADISC was not possible */
 509         atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST, &port->status);
 510         zfcp_erp_port_forced_reopen(port, 0, "fcltwk1");
 511
 512 out:
 513         put_device(&port->dev);
 514 }
 515
 516 /**
 517  * zfcp_fc_test_link - lightweight link test procedure
 518  * @port: port to be tested
 519  *
 520  * Test status of a link to a remote port using the ELS command ADISC.
 521  * If there is a problem with the remote port, error recovery steps
 522  * will be triggered.
 523  */
 524 void zfcp_fc_test_link(struct zfcp_port *port)
 525 {
 526         get_device(&port->dev);
 527         if (!queue_work(port->adapter->work_queue, &port->test_link_work))
 528                 put_device(&port->dev);
 529 }
 530
 531 static struct zfcp_fc_req *zfcp_alloc_sg_env(int buf_num)
 532 {
 533         struct zfcp_fc_req *fc_req;
 534
 535         fc_req = kmem_cache_zalloc(zfcp_fc_req_cache, GFP_KERNEL);
 536         if (!fc_req)
 537                 return NULL;
 538
 539         if (zfcp_sg_setup_table(&fc_req->sg_rsp, buf_num)) {
 540                 kmem_cache_free(zfcp_fc_req_cache, fc_req);
 541                 return NULL;
 542         }
 543
 544         sg_init_one(&fc_req->sg_req, &fc_req->u.gpn_ft.req,
 545                     sizeof(struct zfcp_fc_gpn_ft_req));
 546
 547         return fc_req;
 548 }
 549
 550 static int zfcp_fc_send_gpn_ft(struct zfcp_fc_req *fc_req,
 551                                struct zfcp_adapter *adapter, int max_bytes)
 552 {
 553         struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
 554         struct zfcp_fc_gpn_ft_req *req = &fc_req->u.gpn_ft.req;
 555         DECLARE_COMPLETION_ONSTACK(completion);
 556         int ret;
 557
 558         zfcp_fc_ct_ns_init(&req->ct_hdr, FC_NS_GPN_FT, max_bytes);
 559         req->gpn_ft.fn_fc4_type = FC_TYPE_FCP;
 560
 561         ct_els->handler = zfcp_fc_complete;
 562         ct_els->handler_data = &completion;
 563         ct_els->req = &fc_req->sg_req;
 564         ct_els->resp = &fc_req->sg_rsp;
 565
 566         ret = zfcp_fsf_send_ct(&adapter->gs->ds, ct_els, NULL,
 567                                ZFCP_FC_CTELS_TMO);
 568         if (!ret)
 569                 wait_for_completion(&completion);
 570         return ret;
 571 }
 572
 573 static void zfcp_fc_validate_port(struct zfcp_port *port, struct list_head *lh)
 574 {
 575         if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC))
 576                 return;
 577
 578         atomic_clear_mask(ZFCP_STATUS_COMMON_NOESC, &port->status);
 579
 580         if ((port->supported_classes != 0) ||
 581             !list_empty(&port->unit_list))
 582                 return;
 583
 584         list_move_tail(&port->list, lh);
 585 }
 586
 587 static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_req *fc_req,
 588                                struct zfcp_adapter *adapter, int max_entries)
 589 {
 590         struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
 591         struct scatterlist *sg = &fc_req->sg_rsp;
 592         struct fc_ct_hdr *hdr = sg_virt(sg);
 593         struct fc_gpn_ft_resp *acc = sg_virt(sg);
 594         struct zfcp_port *port, *tmp;
 595         unsigned long flags;
 596         LIST_HEAD(remove_lh);
 597         u32 d_id;
 598         int ret = 0, x, last = 0;
 599
 600         if (ct_els->status)
 601                 return -EIO;
 602
 603         if (hdr->ct_cmd != FC_FS_ACC) {
 604                 if (hdr->ct_reason == FC_BA_RJT_UNABLE)
 605                         return -EAGAIN; /* might be a temporary condition */
 606                 return -EIO;
 607         }
 608
 609         if (hdr->ct_mr_size) {
 610                 dev_warn(&adapter->ccw_device->dev,
 611                          "The name server reported %d words residual data\n",
 612                          hdr->ct_mr_size);
 613                 return -E2BIG;
 614         }
 615
 616         /* first entry is the header */
 617         for (x = 1; x < max_entries && !last; x++) {
 618                 if (x % (ZFCP_FC_GPN_FT_ENT_PAGE + 1))
 619                         acc++;
 620                 else
 621                         acc = sg_virt(++sg);
 622
 623                 last = acc->fp_flags & FC_NS_FID_LAST;
 624                 d_id = ntoh24(acc->fp_fid);
 625
 626                 /* don't attach ports with a well known address */
 627                 if (d_id >= FC_FID_WELL_KNOWN_BASE)
 628                         continue;
 629                 /* skip the adapter's port and known remote ports */
 630                 if (acc->fp_wwpn == fc_host_port_name(adapter->scsi_host))
 631                         continue;
 632
 633                 port = zfcp_port_enqueue(adapter, acc->fp_wwpn,
 634                                          ZFCP_STATUS_COMMON_NOESC, d_id);
 635                 if (!IS_ERR(port))
 636                         zfcp_erp_port_reopen(port, 0, "fcegpf1");
 637                 else if (PTR_ERR(port) != -EEXIST)
 638                         ret = PTR_ERR(port);
 639         }
 640
 641         zfcp_erp_wait(adapter);
 642         write_lock_irqsave(&adapter->port_list_lock, flags);
 643         list_for_each_entry_safe(port, tmp, &adapter->port_list, list)
 644                 zfcp_fc_validate_port(port, &remove_lh);
 645         write_unlock_irqrestore(&adapter->port_list_lock, flags);
 646
 647         list_for_each_entry_safe(port, tmp, &remove_lh, list) {
 648                 zfcp_erp_port_shutdown(port, 0, "fcegpf2");
 649                 zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs);
 650         }
 651
 652         return ret;
 653 }
 654
 655 /**
 656  * zfcp_fc_scan_ports - scan remote ports and attach new ports
 657  * @work: reference to scheduled work
 658  */
 659 void zfcp_fc_scan_ports(struct work_struct *work)
 660 {
 661         struct zfcp_adapter *adapter = container_of(work, struct zfcp_adapter,
 662                                                     scan_work);
 663         int ret, i;
 664         struct zfcp_fc_req *fc_req;
 665         int chain, max_entries, buf_num, max_bytes;
 666
 667         chain = adapter->adapter_features & FSF_FEATURE_ELS_CT_CHAINED_SBALS;
 668         buf_num = chain ? ZFCP_FC_GPN_FT_NUM_BUFS : 1;
 669         max_entries = chain ? ZFCP_FC_GPN_FT_MAX_ENT : ZFCP_FC_GPN_FT_ENT_PAGE;
 670         max_bytes = chain ? ZFCP_FC_GPN_FT_MAX_SIZE : ZFCP_FC_CT_SIZE_PAGE;
 671
 672         if (fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPORT &&
 673             fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPIV)
 674                 return;
 675
 676         if (zfcp_fc_wka_port_get(&adapter->gs->ds))
 677                 return;
 678
 679         fc_req = zfcp_alloc_sg_env(buf_num);
 680         if (!fc_req)
 681                 goto out;
 682
 683         for (i = 0; i < 3; i++) {
 684                 ret = zfcp_fc_send_gpn_ft(fc_req, adapter, max_bytes);
 685                 if (!ret) {
 686                         ret = zfcp_fc_eval_gpn_ft(fc_req, adapter, max_entries);
 687                         if (ret == -EAGAIN)
 688                                 ssleep(1);
 689                         else
 690                                 break;
 691                 }
 692         }
 693         zfcp_sg_free_table(&fc_req->sg_rsp, buf_num);
 694         kmem_cache_free(zfcp_fc_req_cache, fc_req);
 695 out:
 696         zfcp_fc_wka_port_put(&adapter->gs->ds);
 697 }
 698
 699 static void zfcp_fc_ct_els_job_handler(void *data)
 700 {
 701         struct fc_bsg_job *job = data;
 702         struct zfcp_fsf_ct_els *zfcp_ct_els = job->dd_data;
 703         struct fc_bsg_reply *jr = job->reply;
 704
 705         jr->reply_payload_rcv_len = job->reply_payload.payload_len;
 706         jr->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
 707         jr->result = zfcp_ct_els->status ? -EIO : 0;
 708         job->job_done(job);
 709 }
 710
 711 static struct zfcp_fc_wka_port *zfcp_fc_job_wka_port(struct fc_bsg_job *job)
 712 {
 713         u32 preamble_word1;
 714         u8 gs_type;
 715         struct zfcp_adapter *adapter;
 716
 717         preamble_word1 = job->request->rqst_data.r_ct.preamble_word1;
 718         gs_type = (preamble_word1 & 0xff000000) >> 24;
 719
 720         adapter = (struct zfcp_adapter *) job->shost->hostdata[0];
 721
 722         switch (gs_type) {
 723         case FC_FST_ALIAS:
 724                 return &adapter->gs->as;
 725         case FC_FST_MGMT:
 726                 return &adapter->gs->ms;
 727         case FC_FST_TIME:
 728                 return &adapter->gs->ts;
 729                 break;
 730         case FC_FST_DIR:
 731                 return &adapter->gs->ds;
 732                 break;
 733         default:
 734                 return NULL;
 735         }
 736 }
 737
 738 static void zfcp_fc_ct_job_handler(void *data)
 739 {
 740         struct fc_bsg_job *job = data;
 741         struct zfcp_fc_wka_port *wka_port;
 742
 743         wka_port = zfcp_fc_job_wka_port(job);
 744         zfcp_fc_wka_port_put(wka_port);
 745
 746         zfcp_fc_ct_els_job_handler(data);
 747 }
 748
 749 static int zfcp_fc_exec_els_job(struct fc_bsg_job *job,
 750                                 struct zfcp_adapter *adapter)
 751 {
 752         struct zfcp_fsf_ct_els *els = job->dd_data;
 753         struct fc_rport *rport = job->rport;
 754         struct zfcp_port *port;
 755         u32 d_id;
 756
 757         if (rport) {
 758                 port = zfcp_get_port_by_wwpn(adapter, rport->port_name);
 759                 if (!port)
 760                         return -EINVAL;
 761
 762                 d_id = port->d_id;
 763                 put_device(&port->dev);
 764         } else
 765                 d_id = ntoh24(job->request->rqst_data.h_els.port_id);
 766
 767         els->handler = zfcp_fc_ct_els_job_handler;
 768         return zfcp_fsf_send_els(adapter, d_id, els, job->req->timeout / HZ);
 769 }
 770
 771 static int zfcp_fc_exec_ct_job(struct fc_bsg_job *job,
 772                                struct zfcp_adapter *adapter)
 773 {
 774         int ret;
 775         struct zfcp_fsf_ct_els *ct = job->dd_data;
 776         struct zfcp_fc_wka_port *wka_port;
 777
 778         wka_port = zfcp_fc_job_wka_port(job);
 779         if (!wka_port)
 780                 return -EINVAL;
 781
 782         ret = zfcp_fc_wka_port_get(wka_port);
 783         if (ret)
 784                 return ret;
 785
 786         ct->handler = zfcp_fc_ct_job_handler;
 787         ret = zfcp_fsf_send_ct(wka_port, ct, NULL, job->req->timeout / HZ);
 788         if (ret)
 789                 zfcp_fc_wka_port_put(wka_port);
 790
 791         return ret;
 792 }
 793
 794 int zfcp_fc_exec_bsg_job(struct fc_bsg_job *job)
 795 {
 796         struct Scsi_Host *shost;
 797         struct zfcp_adapter *adapter;
 798         struct zfcp_fsf_ct_els *ct_els = job->dd_data;
 799
 800         shost = job->rport ? rport_to_shost(job->rport) : job->shost;
 801         adapter = (struct zfcp_adapter *)shost->hostdata[0];
 802
 803         if (!(atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN))
 804                 return -EINVAL;
 805
 806         ct_els->req = job->request_payload.sg_list;
 807         ct_els->resp = job->reply_payload.sg_list;
 808         ct_els->handler_data = job;
 809
 810         switch (job->request->msgcode) {
 811         case FC_BSG_RPT_ELS:
 812         case FC_BSG_HST_ELS_NOLOGIN:
 813                 return zfcp_fc_exec_els_job(job, adapter);
 814         case FC_BSG_RPT_CT:
 815         case FC_BSG_HST_CT:
 816                 return zfcp_fc_exec_ct_job(job, adapter);
 817         default:
 818                 return -EINVAL;
 819         }
 820 }
 821
 822 int zfcp_fc_timeout_bsg_job(struct fc_bsg_job *job)
 823 {
 824         /* hardware tracks timeout, reset bsg timeout to not interfere */
 825         return -EAGAIN;
 826 }
 827
 828 int zfcp_fc_gs_setup(struct zfcp_adapter *adapter)
 829 {
 830         struct zfcp_fc_wka_ports *wka_ports;
 831
 832         wka_ports = kzalloc(sizeof(struct zfcp_fc_wka_ports), GFP_KERNEL);
 833         if (!wka_ports)
 834                 return -ENOMEM;
 835
 836         adapter->gs = wka_ports;
 837         zfcp_fc_wka_port_init(&wka_ports->ms, FC_FID_MGMT_SERV, adapter);
 838         zfcp_fc_wka_port_init(&wka_ports->ts, FC_FID_TIME_SERV, adapter);
 839         zfcp_fc_wka_port_init(&wka_ports->ds, FC_FID_DIR_SERV, adapter);
 840         zfcp_fc_wka_port_init(&wka_ports->as, FC_FID_ALIASES, adapter);
 841
 842         return 0;
 843 }
 844
 845 void zfcp_fc_gs_destroy(struct zfcp_adapter *adapter)
 846 {
 847         kfree(adapter->gs);
 848         adapter->gs = NULL;
 849 }
 850