zfcp_aux.c revision 317e6b6519b5a34263a33f150ed57ad468b26a64
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 31static char *device; 32 33MODULE_AUTHOR("IBM Deutschland Entwicklung GmbH - linux390@de.ibm.com"); 34MODULE_DESCRIPTION("FCP HBA driver"); 35MODULE_LICENSE("GPL"); 36 37module_param(device, charp, 0400); 38MODULE_PARM_DESC(device, "specify initial device"); 39 40static 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 */ 60int 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 70static 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 108static 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 121static 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); 147out_unit: 148 zfcp_port_put(port); 149out_port: 150 zfcp_adapter_put(adapter); 151out_adapter: 152 up(&zfcp_data.config_sema); 153 return; 154} 155 156static 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 164static 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 211out_ccw_register: 212 misc_deregister(&zfcp_cfdc_misc); 213out_misc: 214 fc_release_transport(zfcp_data.scsi_transport_template); 215out_transport: 216 kmem_cache_destroy(zfcp_data.gid_pn_cache); 217out_gid_cache: 218 kmem_cache_destroy(zfcp_data.sr_buffer_cache); 219out_sr_cache: 220 kmem_cache_destroy(zfcp_data.fsf_req_qtcb_cache); 221out: 222 return retval; 223} 224 225module_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 */ 234struct 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 */ 253struct 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/** 266 * zfcp_unit_enqueue - enqueue unit to unit list of a port. 267 * @port: pointer to port where unit is added 268 * @fcp_lun: FCP LUN of unit to be enqueued 269 * Returns: pointer to enqueued unit on success, ERR_PTR on error 270 * Locks: config_sema must be held to serialize changes to the unit list 271 * 272 * Sets up some unit internal structures and creates sysfs entry. 273 */ 274struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, fcp_lun_t fcp_lun) 275{ 276 struct zfcp_unit *unit; 277 278 unit = kzalloc(sizeof(struct zfcp_unit), GFP_KERNEL); 279 if (!unit) 280 return ERR_PTR(-ENOMEM); 281 282 atomic_set(&unit->refcount, 0); 283 init_waitqueue_head(&unit->remove_wq); 284 285 unit->port = port; 286 unit->fcp_lun = fcp_lun; 287 288 snprintf(unit->sysfs_device.bus_id, BUS_ID_SIZE, "0x%016llx", fcp_lun); 289 unit->sysfs_device.parent = &port->sysfs_device; 290 unit->sysfs_device.release = zfcp_sysfs_unit_release; 291 dev_set_drvdata(&unit->sysfs_device, unit); 292 293 /* mark unit unusable as long as sysfs registration is not complete */ 294 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status); 295 296 spin_lock_init(&unit->latencies.lock); 297 unit->latencies.write.channel.min = 0xFFFFFFFF; 298 unit->latencies.write.fabric.min = 0xFFFFFFFF; 299 unit->latencies.read.channel.min = 0xFFFFFFFF; 300 unit->latencies.read.fabric.min = 0xFFFFFFFF; 301 unit->latencies.cmd.channel.min = 0xFFFFFFFF; 302 unit->latencies.cmd.fabric.min = 0xFFFFFFFF; 303 304 read_lock_irq(&zfcp_data.config_lock); 305 if (zfcp_get_unit_by_lun(port, fcp_lun)) { 306 read_unlock_irq(&zfcp_data.config_lock); 307 goto err_out_free; 308 } 309 read_unlock_irq(&zfcp_data.config_lock); 310 311 if (device_register(&unit->sysfs_device)) 312 goto err_out_free; 313 314 if (zfcp_sysfs_unit_create_files(&unit->sysfs_device)) { 315 device_unregister(&unit->sysfs_device); 316 return ERR_PTR(-EIO); 317 } 318 319 zfcp_unit_get(unit); 320 unit->scsi_lun = scsilun_to_int((struct scsi_lun *)&unit->fcp_lun); 321 322 write_lock_irq(&zfcp_data.config_lock); 323 list_add_tail(&unit->list, &port->unit_list_head); 324 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status); 325 atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &unit->status); 326 327 write_unlock_irq(&zfcp_data.config_lock); 328 329 port->units++; 330 zfcp_port_get(port); 331 332 return unit; 333 334err_out_free: 335 kfree(unit); 336 return ERR_PTR(-EINVAL); 337} 338 339/** 340 * zfcp_unit_dequeue - dequeue unit 341 * @unit: pointer to zfcp_unit 342 * 343 * waits until all work is done on unit and removes it then from the unit->list 344 * of the associated port. 345 */ 346void zfcp_unit_dequeue(struct zfcp_unit *unit) 347{ 348 zfcp_unit_wait(unit); 349 write_lock_irq(&zfcp_data.config_lock); 350 list_del(&unit->list); 351 write_unlock_irq(&zfcp_data.config_lock); 352 unit->port->units--; 353 zfcp_port_put(unit->port); 354 zfcp_sysfs_unit_remove_files(&unit->sysfs_device); 355 device_unregister(&unit->sysfs_device); 356} 357 358static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter) 359{ 360 /* must only be called with zfcp_data.config_sema taken */ 361 adapter->pool.fsf_req_erp = 362 mempool_create_slab_pool(1, zfcp_data.fsf_req_qtcb_cache); 363 if (!adapter->pool.fsf_req_erp) 364 return -ENOMEM; 365 366 adapter->pool.fsf_req_scsi = 367 mempool_create_slab_pool(1, zfcp_data.fsf_req_qtcb_cache); 368 if (!adapter->pool.fsf_req_scsi) 369 return -ENOMEM; 370 371 adapter->pool.fsf_req_abort = 372 mempool_create_slab_pool(1, zfcp_data.fsf_req_qtcb_cache); 373 if (!adapter->pool.fsf_req_abort) 374 return -ENOMEM; 375 376 adapter->pool.fsf_req_status_read = 377 mempool_create_kmalloc_pool(FSF_STATUS_READS_RECOM, 378 sizeof(struct zfcp_fsf_req)); 379 if (!adapter->pool.fsf_req_status_read) 380 return -ENOMEM; 381 382 adapter->pool.data_status_read = 383 mempool_create_slab_pool(FSF_STATUS_READS_RECOM, 384 zfcp_data.sr_buffer_cache); 385 if (!adapter->pool.data_status_read) 386 return -ENOMEM; 387 388 adapter->pool.data_gid_pn = 389 mempool_create_slab_pool(1, zfcp_data.gid_pn_cache); 390 if (!adapter->pool.data_gid_pn) 391 return -ENOMEM; 392 393 return 0; 394} 395 396static void zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter) 397{ 398 /* zfcp_data.config_sema must be held */ 399 if (adapter->pool.fsf_req_erp) 400 mempool_destroy(adapter->pool.fsf_req_erp); 401 if (adapter->pool.fsf_req_scsi) 402 mempool_destroy(adapter->pool.fsf_req_scsi); 403 if (adapter->pool.fsf_req_abort) 404 mempool_destroy(adapter->pool.fsf_req_abort); 405 if (adapter->pool.fsf_req_status_read) 406 mempool_destroy(adapter->pool.fsf_req_status_read); 407 if (adapter->pool.data_status_read) 408 mempool_destroy(adapter->pool.data_status_read); 409 if (adapter->pool.data_gid_pn) 410 mempool_destroy(adapter->pool.data_gid_pn); 411} 412 413static void zfcp_dummy_release(struct device *dev) 414{ 415 return; 416} 417 418/** 419 * zfcp_status_read_refill - refill the long running status_read_requests 420 * @adapter: ptr to struct zfcp_adapter for which the buffers should be refilled 421 * 422 * Returns: 0 on success, 1 otherwise 423 * 424 * if there are 16 or more status_read requests missing an adapter_reopen 425 * is triggered 426 */ 427int zfcp_status_read_refill(struct zfcp_adapter *adapter) 428{ 429 while (atomic_read(&adapter->stat_miss) > 0) 430 if (zfcp_fsf_status_read(adapter, ZFCP_WAIT_FOR_SBAL)) { 431 if (atomic_read(&adapter->stat_miss) >= 16) { 432 zfcp_erp_adapter_reopen(adapter, 0, 103, NULL); 433 return 1; 434 } 435 break; 436 } else 437 atomic_dec(&adapter->stat_miss); 438 return 0; 439} 440 441static void _zfcp_status_read_scheduler(struct work_struct *work) 442{ 443 zfcp_status_read_refill(container_of(work, struct zfcp_adapter, 444 stat_work)); 445} 446 447static int zfcp_nameserver_enqueue(struct zfcp_adapter *adapter) 448{ 449 struct zfcp_port *port; 450 451 port = zfcp_port_enqueue(adapter, 0, ZFCP_STATUS_PORT_WKA, 452 ZFCP_DID_DIRECTORY_SERVICE); 453 if (IS_ERR(port)) 454 return PTR_ERR(port); 455 zfcp_port_put(port); 456 457 return 0; 458} 459 460/** 461 * zfcp_adapter_enqueue - enqueue a new adapter to the list 462 * @ccw_device: pointer to the struct cc_device 463 * 464 * Returns: 0 if a new adapter was successfully enqueued 465 * -ENOMEM if alloc failed 466 * Enqueues an adapter at the end of the adapter list in the driver data. 467 * All adapter internal structures are set up. 468 * Proc-fs entries are also created. 469 * locks: config_sema must be held to serialise changes to the adapter list 470 */ 471int zfcp_adapter_enqueue(struct ccw_device *ccw_device) 472{ 473 struct zfcp_adapter *adapter; 474 475 /* 476 * Note: It is safe to release the list_lock, as any list changes 477 * are protected by the config_sema, which must be held to get here 478 */ 479 480 adapter = kzalloc(sizeof(struct zfcp_adapter), GFP_KERNEL); 481 if (!adapter) 482 return -ENOMEM; 483 484 ccw_device->handler = NULL; 485 adapter->ccw_device = ccw_device; 486 atomic_set(&adapter->refcount, 0); 487 488 if (zfcp_qdio_allocate(adapter)) 489 goto qdio_allocate_failed; 490 491 if (zfcp_allocate_low_mem_buffers(adapter)) 492 goto failed_low_mem_buffers; 493 494 if (zfcp_reqlist_alloc(adapter)) 495 goto failed_low_mem_buffers; 496 497 if (zfcp_adapter_debug_register(adapter)) 498 goto debug_register_failed; 499 500 init_waitqueue_head(&adapter->remove_wq); 501 init_waitqueue_head(&adapter->erp_thread_wqh); 502 init_waitqueue_head(&adapter->erp_done_wqh); 503 504 INIT_LIST_HEAD(&adapter->port_list_head); 505 INIT_LIST_HEAD(&adapter->port_remove_lh); 506 INIT_LIST_HEAD(&adapter->erp_ready_head); 507 INIT_LIST_HEAD(&adapter->erp_running_head); 508 509 spin_lock_init(&adapter->req_list_lock); 510 511 spin_lock_init(&adapter->hba_dbf_lock); 512 spin_lock_init(&adapter->san_dbf_lock); 513 spin_lock_init(&adapter->scsi_dbf_lock); 514 spin_lock_init(&adapter->rec_dbf_lock); 515 516 rwlock_init(&adapter->erp_lock); 517 rwlock_init(&adapter->abort_lock); 518 rwlock_init(&adapter->req_q.lock); 519 520 sema_init(&adapter->erp_ready_sem, 0); 521 522 INIT_WORK(&adapter->stat_work, _zfcp_status_read_scheduler); 523 INIT_WORK(&adapter->scan_work, _zfcp_scan_ports_later); 524 525 /* mark adapter unusable as long as sysfs registration is not complete */ 526 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status); 527 528 dev_set_drvdata(&ccw_device->dev, adapter); 529 530 if (zfcp_sysfs_adapter_create_files(&ccw_device->dev)) 531 goto sysfs_failed; 532 533 adapter->generic_services.parent = &adapter->ccw_device->dev; 534 adapter->generic_services.release = zfcp_dummy_release; 535 snprintf(adapter->generic_services.bus_id, BUS_ID_SIZE, 536 "generic_services"); 537 538 if (device_register(&adapter->generic_services)) 539 goto generic_services_failed; 540 541 write_lock_irq(&zfcp_data.config_lock); 542 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status); 543 list_add_tail(&adapter->list, &zfcp_data.adapter_list_head); 544 write_unlock_irq(&zfcp_data.config_lock); 545 546 zfcp_data.adapters++; 547 548 zfcp_nameserver_enqueue(adapter); 549 550 return 0; 551 552generic_services_failed: 553 zfcp_sysfs_adapter_remove_files(&adapter->ccw_device->dev); 554sysfs_failed: 555 zfcp_adapter_debug_unregister(adapter); 556debug_register_failed: 557 dev_set_drvdata(&ccw_device->dev, NULL); 558 kfree(adapter->req_list); 559failed_low_mem_buffers: 560 zfcp_free_low_mem_buffers(adapter); 561qdio_allocate_failed: 562 zfcp_qdio_free(adapter); 563 kfree(adapter); 564 return -ENOMEM; 565} 566 567/** 568 * zfcp_adapter_dequeue - remove the adapter from the resource list 569 * @adapter: pointer to struct zfcp_adapter which should be removed 570 * locks: adapter list write lock is assumed to be held by caller 571 */ 572void zfcp_adapter_dequeue(struct zfcp_adapter *adapter) 573{ 574 int retval = 0; 575 unsigned long flags; 576 577 cancel_work_sync(&adapter->scan_work); 578 cancel_work_sync(&adapter->stat_work); 579 zfcp_adapter_scsi_unregister(adapter); 580 device_unregister(&adapter->generic_services); 581 zfcp_sysfs_adapter_remove_files(&adapter->ccw_device->dev); 582 dev_set_drvdata(&adapter->ccw_device->dev, NULL); 583 /* sanity check: no pending FSF requests */ 584 spin_lock_irqsave(&adapter->req_list_lock, flags); 585 retval = zfcp_reqlist_isempty(adapter); 586 spin_unlock_irqrestore(&adapter->req_list_lock, flags); 587 if (!retval) 588 return; 589 590 zfcp_adapter_debug_unregister(adapter); 591 592 /* remove specified adapter data structure from list */ 593 write_lock_irq(&zfcp_data.config_lock); 594 list_del(&adapter->list); 595 write_unlock_irq(&zfcp_data.config_lock); 596 597 /* decrease number of adapters in list */ 598 zfcp_data.adapters--; 599 600 zfcp_qdio_free(adapter); 601 602 zfcp_free_low_mem_buffers(adapter); 603 kfree(adapter->req_list); 604 kfree(adapter->fc_stats); 605 kfree(adapter->stats_reset_data); 606 kfree(adapter); 607} 608 609/** 610 * zfcp_port_enqueue - enqueue port to port list of adapter 611 * @adapter: adapter where remote port is added 612 * @wwpn: WWPN of the remote port to be enqueued 613 * @status: initial status for the port 614 * @d_id: destination id of the remote port to be enqueued 615 * Returns: pointer to enqueued port on success, ERR_PTR on error 616 * Locks: config_sema must be held to serialize changes to the port list 617 * 618 * All port internal structures are set up and the sysfs entry is generated. 619 * d_id is used to enqueue ports with a well known address like the Directory 620 * Service for nameserver lookup. 621 */ 622struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, wwn_t wwpn, 623 u32 status, u32 d_id) 624{ 625 struct zfcp_port *port; 626 char *bus_id; 627 628 port = kzalloc(sizeof(struct zfcp_port), GFP_KERNEL); 629 if (!port) 630 return ERR_PTR(-ENOMEM); 631 632 init_waitqueue_head(&port->remove_wq); 633 634 INIT_LIST_HEAD(&port->unit_list_head); 635 INIT_LIST_HEAD(&port->unit_remove_lh); 636 637 port->adapter = adapter; 638 port->d_id = d_id; 639 port->wwpn = wwpn; 640 641 /* mark port unusable as long as sysfs registration is not complete */ 642 atomic_set_mask(status | ZFCP_STATUS_COMMON_REMOVE, &port->status); 643 atomic_set(&port->refcount, 0); 644 645 if (status & ZFCP_STATUS_PORT_WKA) { 646 switch (d_id) { 647 case ZFCP_DID_DIRECTORY_SERVICE: 648 bus_id = "directory"; 649 break; 650 case ZFCP_DID_MANAGEMENT_SERVICE: 651 bus_id = "management"; 652 break; 653 case ZFCP_DID_KEY_DISTRIBUTION_SERVICE: 654 bus_id = "key_distribution"; 655 break; 656 case ZFCP_DID_ALIAS_SERVICE: 657 bus_id = "alias"; 658 break; 659 case ZFCP_DID_TIME_SERVICE: 660 bus_id = "time"; 661 break; 662 default: 663 kfree(port); 664 return ERR_PTR(-EINVAL); 665 } 666 snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE, "%s", bus_id); 667 port->sysfs_device.parent = &adapter->generic_services; 668 } else { 669 snprintf(port->sysfs_device.bus_id, 670 BUS_ID_SIZE, "0x%016llx", wwpn); 671 port->sysfs_device.parent = &adapter->ccw_device->dev; 672 } 673 674 port->sysfs_device.release = zfcp_sysfs_port_release; 675 dev_set_drvdata(&port->sysfs_device, port); 676 677 read_lock_irq(&zfcp_data.config_lock); 678 if (!(status & ZFCP_STATUS_PORT_NO_WWPN)) 679 if (zfcp_get_port_by_wwpn(adapter, wwpn)) { 680 read_unlock_irq(&zfcp_data.config_lock); 681 goto err_out_free; 682 } 683 read_unlock_irq(&zfcp_data.config_lock); 684 685 if (device_register(&port->sysfs_device)) 686 goto err_out_free; 687 688 if (zfcp_sysfs_port_create_files(&port->sysfs_device, status)) { 689 device_unregister(&port->sysfs_device); 690 goto err_out; 691 } 692 693 zfcp_port_get(port); 694 695 write_lock_irq(&zfcp_data.config_lock); 696 list_add_tail(&port->list, &adapter->port_list_head); 697 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status); 698 atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &port->status); 699 if (d_id == ZFCP_DID_DIRECTORY_SERVICE) 700 if (!adapter->nameserver_port) 701 adapter->nameserver_port = port; 702 adapter->ports++; 703 704 write_unlock_irq(&zfcp_data.config_lock); 705 706 zfcp_adapter_get(adapter); 707 return port; 708 709err_out_free: 710 kfree(port); 711err_out: 712 return ERR_PTR(-EINVAL); 713} 714 715/** 716 * zfcp_port_dequeue - dequeues a port from the port list of the adapter 717 * @port: pointer to struct zfcp_port which should be removed 718 */ 719void zfcp_port_dequeue(struct zfcp_port *port) 720{ 721 zfcp_port_wait(port); 722 write_lock_irq(&zfcp_data.config_lock); 723 list_del(&port->list); 724 port->adapter->ports--; 725 write_unlock_irq(&zfcp_data.config_lock); 726 if (port->rport) 727 fc_remote_port_delete(port->rport); 728 port->rport = NULL; 729 zfcp_adapter_put(port->adapter); 730 zfcp_sysfs_port_remove_files(&port->sysfs_device, 731 atomic_read(&port->status)); 732 device_unregister(&port->sysfs_device); 733} 734 735/** 736 * zfcp_sg_free_table - free memory used by scatterlists 737 * @sg: pointer to scatterlist 738 * @count: number of scatterlist which are to be free'ed 739 * the scatterlist are expected to reference pages always 740 */ 741void zfcp_sg_free_table(struct scatterlist *sg, int count) 742{ 743 int i; 744 745 for (i = 0; i < count; i++, sg++) 746 if (sg) 747 free_page((unsigned long) sg_virt(sg)); 748 else 749 break; 750} 751 752/** 753 * zfcp_sg_setup_table - init scatterlist and allocate, assign buffers 754 * @sg: pointer to struct scatterlist 755 * @count: number of scatterlists which should be assigned with buffers 756 * of size page 757 * 758 * Returns: 0 on success, -ENOMEM otherwise 759 */ 760int zfcp_sg_setup_table(struct scatterlist *sg, int count) 761{ 762 void *addr; 763 int i; 764 765 sg_init_table(sg, count); 766 for (i = 0; i < count; i++, sg++) { 767 addr = (void *) get_zeroed_page(GFP_KERNEL); 768 if (!addr) { 769 zfcp_sg_free_table(sg, i); 770 return -ENOMEM; 771 } 772 sg_set_buf(sg, addr, PAGE_SIZE); 773 } 774 return 0; 775} 776