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