1 /* 2 * zfcp device driver 3 * 4 * Module interface and handling of zfcp data structures. 5 * 6 * Copyright IBM Corporation 2002, 2008 7 */ 8 9 /* 10 * Driver authors: 11 * Martin Peschke (originator of the driver) 12 * Raimund Schroeder 13 * Aron Zeh 14 * Wolfgang Taphorn 15 * Stefan Bader 16 * Heiko Carstens (kernel 2.6 port of the driver) 17 * Andreas Herrmann 18 * Maxim Shchetynin 19 * Volker Sameske 20 * Ralph Wuerthner 21 * Michael Loehr 22 * Swen Schillig 23 * Christof Schmitt 24 * Martin Petermann 25 * Sven Schuetz 26 */ 27 28 #include <linux/miscdevice.h> 29 #include "zfcp_ext.h" 30 31 static char *device; 32 33 MODULE_AUTHOR("IBM Deutschland Entwicklung GmbH - linux390@de.ibm.com"); 34 MODULE_DESCRIPTION("FCP HBA driver"); 35 MODULE_LICENSE("GPL"); 36 37 module_param(device, charp, 0400); 38 MODULE_PARM_DESC(device, "specify initial device"); 39 40 static int zfcp_reqlist_alloc(struct zfcp_adapter *adapter) 41 { 42 int idx; 43 44 adapter->req_list = kcalloc(REQUEST_LIST_SIZE, sizeof(struct list_head), 45 GFP_KERNEL); 46 if (!adapter->req_list) 47 return -ENOMEM; 48 49 for (idx = 0; idx < REQUEST_LIST_SIZE; idx++) 50 INIT_LIST_HEAD(&adapter->req_list[idx]); 51 return 0; 52 } 53 54 /** 55 * zfcp_reqlist_isempty - is the request list empty 56 * @adapter: pointer to struct zfcp_adapter 57 * 58 * Returns: true if list is empty, false otherwise 59 */ 60 int zfcp_reqlist_isempty(struct zfcp_adapter *adapter) 61 { 62 unsigned int idx; 63 64 for (idx = 0; idx < REQUEST_LIST_SIZE; idx++) 65 if (!list_empty(&adapter->req_list[idx])) 66 return 0; 67 return 1; 68 } 69 70 static int __init zfcp_device_setup(char *devstr) 71 { 72 char *token; 73 char *str; 74 75 if (!devstr) 76 return 0; 77 78 /* duplicate devstr and keep the original for sysfs presentation*/ 79 str = kmalloc(strlen(devstr) + 1, GFP_KERNEL); 80 if (!str) 81 return 0; 82 83 strcpy(str, devstr); 84 85 token = strsep(&str, ","); 86 if (!token || strlen(token) >= BUS_ID_SIZE) 87 goto err_out; 88 strncpy(zfcp_data.init_busid, token, BUS_ID_SIZE); 89 90 token = strsep(&str, ","); 91 if (!token || strict_strtoull(token, 0, &zfcp_data.init_wwpn)) 92 goto err_out; 93 94 token = strsep(&str, ","); 95 if (!token || strict_strtoull(token, 0, &zfcp_data.init_fcp_lun)) 96 goto err_out; 97 98 kfree(str); 99 return 1; 100 101 err_out: 102 kfree(str); 103 pr_err("zfcp: Parse error for device parameter string %s, " 104 "device not attached.\n", devstr); 105 return 0; 106 } 107 108 static struct zfcp_adapter *zfcp_get_adapter_by_busid(char *bus_id) 109 { 110 struct zfcp_adapter *adapter; 111 112 list_for_each_entry(adapter, &zfcp_data.adapter_list_head, list) 113 if ((strncmp(bus_id, adapter->ccw_device->dev.bus_id, 114 BUS_ID_SIZE) == 0) && 115 !(atomic_read(&adapter->status) & 116 ZFCP_STATUS_COMMON_REMOVE)) 117 return adapter; 118 return NULL; 119 } 120 121 static void __init zfcp_init_device_configure(void) 122 { 123 struct zfcp_adapter *adapter; 124 struct zfcp_port *port; 125 struct zfcp_unit *unit; 126 127 down(&zfcp_data.config_sema); 128 read_lock_irq(&zfcp_data.config_lock); 129 adapter = zfcp_get_adapter_by_busid(zfcp_data.init_busid); 130 if (adapter) 131 zfcp_adapter_get(adapter); 132 read_unlock_irq(&zfcp_data.config_lock); 133 134 if (!adapter) 135 goto out_adapter; 136 port = zfcp_port_enqueue(adapter, zfcp_data.init_wwpn, 0, 0); 137 if (IS_ERR(port)) 138 goto out_port; 139 unit = zfcp_unit_enqueue(port, zfcp_data.init_fcp_lun); 140 if (IS_ERR(unit)) 141 goto out_unit; 142 up(&zfcp_data.config_sema); 143 ccw_device_set_online(adapter->ccw_device); 144 zfcp_erp_wait(adapter); 145 down(&zfcp_data.config_sema); 146 zfcp_unit_put(unit); 147 out_unit: 148 zfcp_port_put(port); 149 out_port: 150 zfcp_adapter_put(adapter); 151 out_adapter: 152 up(&zfcp_data.config_sema); 153 return; 154 } 155 156 static struct kmem_cache *zfcp_cache_create(int size, char *name) 157 { 158 int align = 1; 159 while ((size - align) > 0) 160 align <<= 1; 161 return kmem_cache_create(name , size, align, 0, NULL); 162 } 163 164 static int __init zfcp_module_init(void) 165 { 166 int retval = -ENOMEM; 167 168 zfcp_data.fsf_req_qtcb_cache = zfcp_cache_create( 169 sizeof(struct zfcp_fsf_req_qtcb), "zfcp_fsf"); 170 if (!zfcp_data.fsf_req_qtcb_cache) 171 goto out; 172 173 zfcp_data.sr_buffer_cache = zfcp_cache_create( 174 sizeof(struct fsf_status_read_buffer), "zfcp_sr"); 175 if (!zfcp_data.sr_buffer_cache) 176 goto out_sr_cache; 177 178 zfcp_data.gid_pn_cache = zfcp_cache_create( 179 sizeof(struct zfcp_gid_pn_data), "zfcp_gid"); 180 if (!zfcp_data.gid_pn_cache) 181 goto out_gid_cache; 182 183 INIT_LIST_HEAD(&zfcp_data.adapter_list_head); 184 INIT_LIST_HEAD(&zfcp_data.adapter_remove_lh); 185 186 sema_init(&zfcp_data.config_sema, 1); 187 rwlock_init(&zfcp_data.config_lock); 188 189 zfcp_data.scsi_transport_template = 190 fc_attach_transport(&zfcp_transport_functions); 191 if (!zfcp_data.scsi_transport_template) 192 goto out_transport; 193 194 retval = misc_register(&zfcp_cfdc_misc); 195 if (retval) { 196 pr_err("zfcp: registration of misc device zfcp_cfdc failed\n"); 197 goto out_misc; 198 } 199 200 retval = zfcp_ccw_register(); 201 if (retval) { 202 pr_err("zfcp: Registration with common I/O layer failed.\n"); 203 goto out_ccw_register; 204 } 205 206 if (zfcp_device_setup(device)) 207 zfcp_init_device_configure(); 208 209 goto out; 210 211 out_ccw_register: 212 misc_deregister(&zfcp_cfdc_misc); 213 out_misc: 214 fc_release_transport(zfcp_data.scsi_transport_template); 215 out_transport: 216 kmem_cache_destroy(zfcp_data.gid_pn_cache); 217 out_gid_cache: 218 kmem_cache_destroy(zfcp_data.sr_buffer_cache); 219 out_sr_cache: 220 kmem_cache_destroy(zfcp_data.fsf_req_qtcb_cache); 221 out: 222 return retval; 223 } 224 225 module_init(zfcp_module_init); 226 227 /** 228 * zfcp_get_unit_by_lun - find unit in unit list of port by FCP LUN 229 * @port: pointer to port to search for unit 230 * @fcp_lun: FCP LUN to search for 231 * 232 * Returns: pointer to zfcp_unit or NULL 233 */ 234 struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *port, 235 fcp_lun_t fcp_lun) 236 { 237 struct zfcp_unit *unit; 238 239 list_for_each_entry(unit, &port->unit_list_head, list) 240 if ((unit->fcp_lun == fcp_lun) && 241 !(atomic_read(&unit->status) & ZFCP_STATUS_COMMON_REMOVE)) 242 return unit; 243 return NULL; 244 } 245 246 /** 247 * zfcp_get_port_by_wwpn - find port in port list of adapter by wwpn 248 * @adapter: pointer to adapter to search for port 249 * @wwpn: wwpn to search for 250 * 251 * Returns: pointer to zfcp_port or NULL 252 */ 253 struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter, 254 wwn_t wwpn) 255 { 256 struct zfcp_port *port; 257 258 list_for_each_entry(port, &adapter->port_list_head, list) 259 if ((port->wwpn == wwpn) && !(atomic_read(&port->status) & 260 (ZFCP_STATUS_PORT_NO_WWPN | ZFCP_STATUS_COMMON_REMOVE))) 261 return port; 262 return NULL; 263 } 264 265 static void zfcp_sysfs_unit_release(struct device *dev) 266 { 267 kfree(container_of(dev, struct zfcp_unit, sysfs_device)); 268 } 269 270 /** 271 * zfcp_unit_enqueue - enqueue unit to unit list of a port. 272 * @port: pointer to port where unit is added 273 * @fcp_lun: FCP LUN of unit to be enqueued 274 * Returns: pointer to enqueued unit on success, ERR_PTR on error 275 * Locks: config_sema must be held to serialize changes to the unit list 276 * 277 * Sets up some unit internal structures and creates sysfs entry. 278 */ 279 struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, fcp_lun_t fcp_lun) 280 { 281 struct zfcp_unit *unit; 282 283 unit = kzalloc(sizeof(struct zfcp_unit), GFP_KERNEL); 284 if (!unit) 285 return ERR_PTR(-ENOMEM); 286 287 atomic_set(&unit->refcount, 0); 288 init_waitqueue_head(&unit->remove_wq); 289 290 unit->port = port; 291 unit->fcp_lun = fcp_lun; 292 293 snprintf(unit->sysfs_device.bus_id, BUS_ID_SIZE, "0x%016llx", fcp_lun); 294 unit->sysfs_device.parent = &port->sysfs_device; 295 unit->sysfs_device.release = zfcp_sysfs_unit_release; 296 dev_set_drvdata(&unit->sysfs_device, unit); 297 298 /* mark unit unusable as long as sysfs registration is not complete */ 299 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status); 300 301 spin_lock_init(&unit->latencies.lock); 302 unit->latencies.write.channel.min = 0xFFFFFFFF; 303 unit->latencies.write.fabric.min = 0xFFFFFFFF; 304 unit->latencies.read.channel.min = 0xFFFFFFFF; 305 unit->latencies.read.fabric.min = 0xFFFFFFFF; 306 unit->latencies.cmd.channel.min = 0xFFFFFFFF; 307 unit->latencies.cmd.fabric.min = 0xFFFFFFFF; 308 309 read_lock_irq(&zfcp_data.config_lock); 310 if (zfcp_get_unit_by_lun(port, fcp_lun)) { 311 read_unlock_irq(&zfcp_data.config_lock); 312 goto err_out_free; 313 } 314 read_unlock_irq(&zfcp_data.config_lock); 315 316 if (device_register(&unit->sysfs_device)) 317 goto err_out_free; 318 319 if (sysfs_create_group(&unit->sysfs_device.kobj, 320 &zfcp_sysfs_unit_attrs)) { 321 device_unregister(&unit->sysfs_device); 322 return ERR_PTR(-EIO); 323 } 324 325 zfcp_unit_get(unit); 326 unit->scsi_lun = scsilun_to_int((struct scsi_lun *)&unit->fcp_lun); 327 328 write_lock_irq(&zfcp_data.config_lock); 329 list_add_tail(&unit->list, &port->unit_list_head); 330 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status); 331 atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &unit->status); 332 333 write_unlock_irq(&zfcp_data.config_lock); 334 335 port->units++; 336 zfcp_port_get(port); 337 338 return unit; 339 340 err_out_free: 341 kfree(unit); 342 return ERR_PTR(-EINVAL); 343 } 344 345 /** 346 * zfcp_unit_dequeue - dequeue unit 347 * @unit: pointer to zfcp_unit 348 * 349 * waits until all work is done on unit and removes it then from the unit->list 350 * of the associated port. 351 */ 352 void zfcp_unit_dequeue(struct zfcp_unit *unit) 353 { 354 zfcp_unit_wait(unit); 355 write_lock_irq(&zfcp_data.config_lock); 356 list_del(&unit->list); 357 write_unlock_irq(&zfcp_data.config_lock); 358 unit->port->units--; 359 zfcp_port_put(unit->port); 360 sysfs_remove_group(&unit->sysfs_device.kobj, &zfcp_sysfs_unit_attrs); 361 device_unregister(&unit->sysfs_device); 362 } 363 364 static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter) 365 { 366 /* must only be called with zfcp_data.config_sema taken */ 367 adapter->pool.fsf_req_erp = 368 mempool_create_slab_pool(1, zfcp_data.fsf_req_qtcb_cache); 369 if (!adapter->pool.fsf_req_erp) 370 return -ENOMEM; 371 372 adapter->pool.fsf_req_scsi = 373 mempool_create_slab_pool(1, zfcp_data.fsf_req_qtcb_cache); 374 if (!adapter->pool.fsf_req_scsi) 375 return -ENOMEM; 376 377 adapter->pool.fsf_req_abort = 378 mempool_create_slab_pool(1, zfcp_data.fsf_req_qtcb_cache); 379 if (!adapter->pool.fsf_req_abort) 380 return -ENOMEM; 381 382 adapter->pool.fsf_req_status_read = 383 mempool_create_kmalloc_pool(FSF_STATUS_READS_RECOM, 384 sizeof(struct zfcp_fsf_req)); 385 if (!adapter->pool.fsf_req_status_read) 386 return -ENOMEM; 387 388 adapter->pool.data_status_read = 389 mempool_create_slab_pool(FSF_STATUS_READS_RECOM, 390 zfcp_data.sr_buffer_cache); 391 if (!adapter->pool.data_status_read) 392 return -ENOMEM; 393 394 adapter->pool.data_gid_pn = 395 mempool_create_slab_pool(1, zfcp_data.gid_pn_cache); 396 if (!adapter->pool.data_gid_pn) 397 return -ENOMEM; 398 399 return 0; 400 } 401 402 static void zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter) 403 { 404 /* zfcp_data.config_sema must be held */ 405 if (adapter->pool.fsf_req_erp) 406 mempool_destroy(adapter->pool.fsf_req_erp); 407 if (adapter->pool.fsf_req_scsi) 408 mempool_destroy(adapter->pool.fsf_req_scsi); 409 if (adapter->pool.fsf_req_abort) 410 mempool_destroy(adapter->pool.fsf_req_abort); 411 if (adapter->pool.fsf_req_status_read) 412 mempool_destroy(adapter->pool.fsf_req_status_read); 413 if (adapter->pool.data_status_read) 414 mempool_destroy(adapter->pool.data_status_read); 415 if (adapter->pool.data_gid_pn) 416 mempool_destroy(adapter->pool.data_gid_pn); 417 } 418 419 static void zfcp_dummy_release(struct device *dev) 420 { 421 return; 422 } 423 424 /** 425 * zfcp_status_read_refill - refill the long running status_read_requests 426 * @adapter: ptr to struct zfcp_adapter for which the buffers should be refilled 427 * 428 * Returns: 0 on success, 1 otherwise 429 * 430 * if there are 16 or more status_read requests missing an adapter_reopen 431 * is triggered 432 */ 433 int zfcp_status_read_refill(struct zfcp_adapter *adapter) 434 { 435 while (atomic_read(&adapter->stat_miss) > 0) 436 if (zfcp_fsf_status_read(adapter)) { 437 if (atomic_read(&adapter->stat_miss) >= 16) { 438 zfcp_erp_adapter_reopen(adapter, 0, 103, NULL); 439 return 1; 440 } 441 break; 442 } else 443 atomic_dec(&adapter->stat_miss); 444 return 0; 445 } 446 447 static void _zfcp_status_read_scheduler(struct work_struct *work) 448 { 449 zfcp_status_read_refill(container_of(work, struct zfcp_adapter, 450 stat_work)); 451 } 452 453 static int zfcp_nameserver_enqueue(struct zfcp_adapter *adapter) 454 { 455 struct zfcp_port *port; 456 457 port = zfcp_port_enqueue(adapter, 0, ZFCP_STATUS_PORT_WKA, 458 ZFCP_DID_DIRECTORY_SERVICE); 459 if (IS_ERR(port)) 460 return PTR_ERR(port); 461 zfcp_port_put(port); 462 463 return 0; 464 } 465 466 /** 467 * zfcp_adapter_enqueue - enqueue a new adapter to the list 468 * @ccw_device: pointer to the struct cc_device 469 * 470 * Returns: 0 if a new adapter was successfully enqueued 471 * -ENOMEM if alloc failed 472 * Enqueues an adapter at the end of the adapter list in the driver data. 473 * All adapter internal structures are set up. 474 * Proc-fs entries are also created. 475 * locks: config_sema must be held to serialise changes to the adapter list 476 */ 477 int zfcp_adapter_enqueue(struct ccw_device *ccw_device) 478 { 479 struct zfcp_adapter *adapter; 480 481 /* 482 * Note: It is safe to release the list_lock, as any list changes 483 * are protected by the config_sema, which must be held to get here 484 */ 485 486 adapter = kzalloc(sizeof(struct zfcp_adapter), GFP_KERNEL); 487 if (!adapter) 488 return -ENOMEM; 489 490 ccw_device->handler = NULL; 491 adapter->ccw_device = ccw_device; 492 atomic_set(&adapter->refcount, 0); 493 494 if (zfcp_qdio_allocate(adapter)) 495 goto qdio_allocate_failed; 496 497 if (zfcp_allocate_low_mem_buffers(adapter)) 498 goto failed_low_mem_buffers; 499 500 if (zfcp_reqlist_alloc(adapter)) 501 goto failed_low_mem_buffers; 502 503 if (zfcp_adapter_debug_register(adapter)) 504 goto debug_register_failed; 505 506 init_waitqueue_head(&adapter->remove_wq); 507 init_waitqueue_head(&adapter->erp_thread_wqh); 508 init_waitqueue_head(&adapter->erp_done_wqh); 509 510 INIT_LIST_HEAD(&adapter->port_list_head); 511 INIT_LIST_HEAD(&adapter->port_remove_lh); 512 INIT_LIST_HEAD(&adapter->erp_ready_head); 513 INIT_LIST_HEAD(&adapter->erp_running_head); 514 515 spin_lock_init(&adapter->req_list_lock); 516 517 spin_lock_init(&adapter->hba_dbf_lock); 518 spin_lock_init(&adapter->san_dbf_lock); 519 spin_lock_init(&adapter->scsi_dbf_lock); 520 spin_lock_init(&adapter->rec_dbf_lock); 521 spin_lock_init(&adapter->req_q.lock); 522 523 rwlock_init(&adapter->erp_lock); 524 rwlock_init(&adapter->abort_lock); 525 526 sema_init(&adapter->erp_ready_sem, 0); 527 528 INIT_WORK(&adapter->stat_work, _zfcp_status_read_scheduler); 529 INIT_WORK(&adapter->scan_work, _zfcp_scan_ports_later); 530 531 /* mark adapter unusable as long as sysfs registration is not complete */ 532 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status); 533 534 dev_set_drvdata(&ccw_device->dev, adapter); 535 536 if (sysfs_create_group(&ccw_device->dev.kobj, 537 &zfcp_sysfs_adapter_attrs)) 538 goto sysfs_failed; 539 540 adapter->generic_services.parent = &adapter->ccw_device->dev; 541 adapter->generic_services.release = zfcp_dummy_release; 542 snprintf(adapter->generic_services.bus_id, BUS_ID_SIZE, 543 "generic_services"); 544 545 if (device_register(&adapter->generic_services)) 546 goto generic_services_failed; 547 548 write_lock_irq(&zfcp_data.config_lock); 549 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status); 550 list_add_tail(&adapter->list, &zfcp_data.adapter_list_head); 551 write_unlock_irq(&zfcp_data.config_lock); 552 553 zfcp_data.adapters++; 554 555 zfcp_nameserver_enqueue(adapter); 556 557 return 0; 558 559 generic_services_failed: 560 sysfs_remove_group(&ccw_device->dev.kobj, 561 &zfcp_sysfs_adapter_attrs); 562 sysfs_failed: 563 zfcp_adapter_debug_unregister(adapter); 564 debug_register_failed: 565 dev_set_drvdata(&ccw_device->dev, NULL); 566 kfree(adapter->req_list); 567 failed_low_mem_buffers: 568 zfcp_free_low_mem_buffers(adapter); 569 qdio_allocate_failed: 570 zfcp_qdio_free(adapter); 571 kfree(adapter); 572 return -ENOMEM; 573 } 574 575 /** 576 * zfcp_adapter_dequeue - remove the adapter from the resource list 577 * @adapter: pointer to struct zfcp_adapter which should be removed 578 * locks: adapter list write lock is assumed to be held by caller 579 */ 580 void zfcp_adapter_dequeue(struct zfcp_adapter *adapter) 581 { 582 int retval = 0; 583 unsigned long flags; 584 585 cancel_work_sync(&adapter->scan_work); 586 cancel_work_sync(&adapter->stat_work); 587 zfcp_adapter_scsi_unregister(adapter); 588 device_unregister(&adapter->generic_services); 589 sysfs_remove_group(&adapter->ccw_device->dev.kobj, 590 &zfcp_sysfs_adapter_attrs); 591 dev_set_drvdata(&adapter->ccw_device->dev, NULL); 592 /* sanity check: no pending FSF requests */ 593 spin_lock_irqsave(&adapter->req_list_lock, flags); 594 retval = zfcp_reqlist_isempty(adapter); 595 spin_unlock_irqrestore(&adapter->req_list_lock, flags); 596 if (!retval) 597 return; 598 599 zfcp_adapter_debug_unregister(adapter); 600 601 /* remove specified adapter data structure from list */ 602 write_lock_irq(&zfcp_data.config_lock); 603 list_del(&adapter->list); 604 write_unlock_irq(&zfcp_data.config_lock); 605 606 /* decrease number of adapters in list */ 607 zfcp_data.adapters--; 608 609 zfcp_qdio_free(adapter); 610 611 zfcp_free_low_mem_buffers(adapter); 612 kfree(adapter->req_list); 613 kfree(adapter->fc_stats); 614 kfree(adapter->stats_reset_data); 615 kfree(adapter); 616 } 617 618 static void zfcp_sysfs_port_release(struct device *dev) 619 { 620 kfree(container_of(dev, struct zfcp_port, sysfs_device)); 621 } 622 623 /** 624 * zfcp_port_enqueue - enqueue port to port list of adapter 625 * @adapter: adapter where remote port is added 626 * @wwpn: WWPN of the remote port to be enqueued 627 * @status: initial status for the port 628 * @d_id: destination id of the remote port to be enqueued 629 * Returns: pointer to enqueued port on success, ERR_PTR on error 630 * Locks: config_sema must be held to serialize changes to the port list 631 * 632 * All port internal structures are set up and the sysfs entry is generated. 633 * d_id is used to enqueue ports with a well known address like the Directory 634 * Service for nameserver lookup. 635 */ 636 struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, wwn_t wwpn, 637 u32 status, u32 d_id) 638 { 639 struct zfcp_port *port; 640 int retval; 641 char *bus_id; 642 643 port = kzalloc(sizeof(struct zfcp_port), GFP_KERNEL); 644 if (!port) 645 return ERR_PTR(-ENOMEM); 646 647 init_waitqueue_head(&port->remove_wq); 648 649 INIT_LIST_HEAD(&port->unit_list_head); 650 INIT_LIST_HEAD(&port->unit_remove_lh); 651 652 port->adapter = adapter; 653 port->d_id = d_id; 654 port->wwpn = wwpn; 655 656 /* mark port unusable as long as sysfs registration is not complete */ 657 atomic_set_mask(status | ZFCP_STATUS_COMMON_REMOVE, &port->status); 658 atomic_set(&port->refcount, 0); 659 660 if (status & ZFCP_STATUS_PORT_WKA) { 661 switch (d_id) { 662 case ZFCP_DID_DIRECTORY_SERVICE: 663 bus_id = "directory"; 664 break; 665 case ZFCP_DID_MANAGEMENT_SERVICE: 666 bus_id = "management"; 667 break; 668 case ZFCP_DID_KEY_DISTRIBUTION_SERVICE: 669 bus_id = "key_distribution"; 670 break; 671 case ZFCP_DID_ALIAS_SERVICE: 672 bus_id = "alias"; 673 break; 674 case ZFCP_DID_TIME_SERVICE: 675 bus_id = "time"; 676 break; 677 default: 678 kfree(port); 679 return ERR_PTR(-EINVAL); 680 } 681 snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE, "%s", bus_id); 682 port->sysfs_device.parent = &adapter->generic_services; 683 } else { 684 snprintf(port->sysfs_device.bus_id, 685 BUS_ID_SIZE, "0x%016llx", wwpn); 686 port->sysfs_device.parent = &adapter->ccw_device->dev; 687 } 688 689 port->sysfs_device.release = zfcp_sysfs_port_release; 690 dev_set_drvdata(&port->sysfs_device, port); 691 692 read_lock_irq(&zfcp_data.config_lock); 693 if (!(status & ZFCP_STATUS_PORT_NO_WWPN)) 694 if (zfcp_get_port_by_wwpn(adapter, wwpn)) { 695 read_unlock_irq(&zfcp_data.config_lock); 696 goto err_out_free; 697 } 698 read_unlock_irq(&zfcp_data.config_lock); 699 700 if (device_register(&port->sysfs_device)) 701 goto err_out_free; 702 703 if (status & ZFCP_STATUS_PORT_WKA) 704 retval = sysfs_create_group(&port->sysfs_device.kobj, 705 &zfcp_sysfs_ns_port_attrs); 706 else 707 retval = sysfs_create_group(&port->sysfs_device.kobj, 708 &zfcp_sysfs_port_attrs); 709 710 if (retval) { 711 device_unregister(&port->sysfs_device); 712 goto err_out; 713 } 714 715 zfcp_port_get(port); 716 717 write_lock_irq(&zfcp_data.config_lock); 718 list_add_tail(&port->list, &adapter->port_list_head); 719 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status); 720 atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &port->status); 721 if (d_id == ZFCP_DID_DIRECTORY_SERVICE) 722 if (!adapter->nameserver_port) 723 adapter->nameserver_port = port; 724 adapter->ports++; 725 726 write_unlock_irq(&zfcp_data.config_lock); 727 728 zfcp_adapter_get(adapter); 729 return port; 730 731 err_out_free: 732 kfree(port); 733 err_out: 734 return ERR_PTR(-EINVAL); 735 } 736 737 /** 738 * zfcp_port_dequeue - dequeues a port from the port list of the adapter 739 * @port: pointer to struct zfcp_port which should be removed 740 */ 741 void zfcp_port_dequeue(struct zfcp_port *port) 742 { 743 zfcp_port_wait(port); 744 write_lock_irq(&zfcp_data.config_lock); 745 list_del(&port->list); 746 port->adapter->ports--; 747 write_unlock_irq(&zfcp_data.config_lock); 748 if (port->rport) 749 fc_remote_port_delete(port->rport); 750 port->rport = NULL; 751 zfcp_adapter_put(port->adapter); 752 if (atomic_read(&port->status) & ZFCP_STATUS_PORT_WKA) 753 sysfs_remove_group(&port->sysfs_device.kobj, 754 &zfcp_sysfs_ns_port_attrs); 755 else 756 sysfs_remove_group(&port->sysfs_device.kobj, 757 &zfcp_sysfs_port_attrs); 758 device_unregister(&port->sysfs_device); 759 } 760 761 /** 762 * zfcp_sg_free_table - free memory used by scatterlists 763 * @sg: pointer to scatterlist 764 * @count: number of scatterlist which are to be free'ed 765 * the scatterlist are expected to reference pages always 766 */ 767 void zfcp_sg_free_table(struct scatterlist *sg, int count) 768 { 769 int i; 770 771 for (i = 0; i < count; i++, sg++) 772 if (sg) 773 free_page((unsigned long) sg_virt(sg)); 774 else 775 break; 776 } 777 778 /** 779 * zfcp_sg_setup_table - init scatterlist and allocate, assign buffers 780 * @sg: pointer to struct scatterlist 781 * @count: number of scatterlists which should be assigned with buffers 782 * of size page 783 * 784 * Returns: 0 on success, -ENOMEM otherwise 785 */ 786 int zfcp_sg_setup_table(struct scatterlist *sg, int count) 787 { 788 void *addr; 789 int i; 790 791 sg_init_table(sg, count); 792 for (i = 0; i < count; i++, sg++) { 793 addr = (void *) get_zeroed_page(GFP_KERNEL); 794 if (!addr) { 795 zfcp_sg_free_table(sg, i); 796 return -ENOMEM; 797 } 798 sg_set_buf(sg, addr, PAGE_SIZE); 799 } 800 return 0; 801 } 802