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, 92 (unsigned long long *) &zfcp_data.init_wwpn)) 93 goto err_out; 94 95 token = strsep(&str, ","); 96 if (!token || strict_strtoull(token, 0, 97 (unsigned long long *) &zfcp_data.init_fcp_lun)) 98 goto err_out; 99 100 kfree(str); 101 return 1; 102 103 err_out: 104 kfree(str); 105 pr_err("zfcp: %s is not a valid SCSI device\n", devstr); 106 return 0; 107 } 108 109 static void __init zfcp_init_device_configure(void) 110 { 111 struct zfcp_adapter *adapter; 112 struct zfcp_port *port; 113 struct zfcp_unit *unit; 114 115 down(&zfcp_data.config_sema); 116 read_lock_irq(&zfcp_data.config_lock); 117 adapter = zfcp_get_adapter_by_busid(zfcp_data.init_busid); 118 if (adapter) 119 zfcp_adapter_get(adapter); 120 read_unlock_irq(&zfcp_data.config_lock); 121 122 if (!adapter) 123 goto out_adapter; 124 port = zfcp_port_enqueue(adapter, zfcp_data.init_wwpn, 0, 0); 125 if (IS_ERR(port)) 126 goto out_port; 127 unit = zfcp_unit_enqueue(port, zfcp_data.init_fcp_lun); 128 if (IS_ERR(unit)) 129 goto out_unit; 130 up(&zfcp_data.config_sema); 131 ccw_device_set_online(adapter->ccw_device); 132 133 zfcp_erp_wait(adapter); 134 wait_event(adapter->erp_done_wqh, 135 !(atomic_read(&unit->status) & 136 ZFCP_STATUS_UNIT_SCSI_WORK_PENDING)); 137 138 down(&zfcp_data.config_sema); 139 zfcp_unit_put(unit); 140 out_unit: 141 zfcp_port_put(port); 142 out_port: 143 zfcp_adapter_put(adapter); 144 out_adapter: 145 up(&zfcp_data.config_sema); 146 return; 147 } 148 149 static struct kmem_cache *zfcp_cache_create(int size, char *name) 150 { 151 int align = 1; 152 while ((size - align) > 0) 153 align <<= 1; 154 return kmem_cache_create(name , size, align, 0, NULL); 155 } 156 157 static int __init zfcp_module_init(void) 158 { 159 int retval = -ENOMEM; 160 161 zfcp_data.fsf_req_qtcb_cache = zfcp_cache_create( 162 sizeof(struct zfcp_fsf_req_qtcb), "zfcp_fsf"); 163 if (!zfcp_data.fsf_req_qtcb_cache) 164 goto out; 165 166 zfcp_data.sr_buffer_cache = zfcp_cache_create( 167 sizeof(struct fsf_status_read_buffer), "zfcp_sr"); 168 if (!zfcp_data.sr_buffer_cache) 169 goto out_sr_cache; 170 171 zfcp_data.gid_pn_cache = zfcp_cache_create( 172 sizeof(struct zfcp_gid_pn_data), "zfcp_gid"); 173 if (!zfcp_data.gid_pn_cache) 174 goto out_gid_cache; 175 176 zfcp_data.work_queue = create_singlethread_workqueue("zfcp_wq"); 177 178 INIT_LIST_HEAD(&zfcp_data.adapter_list_head); 179 sema_init(&zfcp_data.config_sema, 1); 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("zfcp: 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("zfcp: The zfcp device driver could not register with " 196 "the common I/O layer\n"); 197 goto out_ccw_register; 198 } 199 200 if (zfcp_device_setup(device)) 201 zfcp_init_device_configure(); 202 203 goto out; 204 205 out_ccw_register: 206 misc_deregister(&zfcp_cfdc_misc); 207 out_misc: 208 fc_release_transport(zfcp_data.scsi_transport_template); 209 out_transport: 210 kmem_cache_destroy(zfcp_data.gid_pn_cache); 211 out_gid_cache: 212 kmem_cache_destroy(zfcp_data.sr_buffer_cache); 213 out_sr_cache: 214 kmem_cache_destroy(zfcp_data.fsf_req_qtcb_cache); 215 out: 216 return retval; 217 } 218 219 module_init(zfcp_module_init); 220 221 /** 222 * zfcp_get_unit_by_lun - find unit in unit list of port by FCP LUN 223 * @port: pointer to port to search for unit 224 * @fcp_lun: FCP LUN to search for 225 * 226 * Returns: pointer to zfcp_unit or NULL 227 */ 228 struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *port, u64 fcp_lun) 229 { 230 struct zfcp_unit *unit; 231 232 list_for_each_entry(unit, &port->unit_list_head, list) 233 if ((unit->fcp_lun == fcp_lun) && 234 !(atomic_read(&unit->status) & ZFCP_STATUS_COMMON_REMOVE)) 235 return unit; 236 return NULL; 237 } 238 239 /** 240 * zfcp_get_port_by_wwpn - find port in port list of adapter by wwpn 241 * @adapter: pointer to adapter to search for port 242 * @wwpn: wwpn to search for 243 * 244 * Returns: pointer to zfcp_port or NULL 245 */ 246 struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter, 247 u64 wwpn) 248 { 249 struct zfcp_port *port; 250 251 list_for_each_entry(port, &adapter->port_list_head, list) 252 if ((port->wwpn == wwpn) && !(atomic_read(&port->status) & 253 (ZFCP_STATUS_PORT_NO_WWPN | ZFCP_STATUS_COMMON_REMOVE))) 254 return port; 255 return NULL; 256 } 257 258 static void zfcp_sysfs_unit_release(struct device *dev) 259 { 260 kfree(container_of(dev, struct zfcp_unit, sysfs_device)); 261 } 262 263 /** 264 * zfcp_unit_enqueue - enqueue unit to unit list of a port. 265 * @port: pointer to port where unit is added 266 * @fcp_lun: FCP LUN of unit to be enqueued 267 * Returns: pointer to enqueued unit on success, ERR_PTR on error 268 * Locks: config_sema must be held to serialize changes to the unit list 269 * 270 * Sets up some unit internal structures and creates sysfs entry. 271 */ 272 struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, u64 fcp_lun) 273 { 274 struct zfcp_unit *unit; 275 276 unit = kzalloc(sizeof(struct zfcp_unit), GFP_KERNEL); 277 if (!unit) 278 return ERR_PTR(-ENOMEM); 279 280 atomic_set(&unit->refcount, 0); 281 init_waitqueue_head(&unit->remove_wq); 282 283 unit->port = port; 284 unit->fcp_lun = fcp_lun; 285 286 dev_set_name(&unit->sysfs_device, "0x%016llx", 287 (unsigned long long) fcp_lun); 288 unit->sysfs_device.parent = &port->sysfs_device; 289 unit->sysfs_device.release = zfcp_sysfs_unit_release; 290 dev_set_drvdata(&unit->sysfs_device, unit); 291 292 /* mark unit unusable as long as sysfs registration is not complete */ 293 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status); 294 295 spin_lock_init(&unit->latencies.lock); 296 unit->latencies.write.channel.min = 0xFFFFFFFF; 297 unit->latencies.write.fabric.min = 0xFFFFFFFF; 298 unit->latencies.read.channel.min = 0xFFFFFFFF; 299 unit->latencies.read.fabric.min = 0xFFFFFFFF; 300 unit->latencies.cmd.channel.min = 0xFFFFFFFF; 301 unit->latencies.cmd.fabric.min = 0xFFFFFFFF; 302 303 read_lock_irq(&zfcp_data.config_lock); 304 if (zfcp_get_unit_by_lun(port, fcp_lun)) { 305 read_unlock_irq(&zfcp_data.config_lock); 306 goto err_out_free; 307 } 308 read_unlock_irq(&zfcp_data.config_lock); 309 310 if (device_register(&unit->sysfs_device)) 311 goto err_out_free; 312 313 if (sysfs_create_group(&unit->sysfs_device.kobj, 314 &zfcp_sysfs_unit_attrs)) { 315 device_unregister(&unit->sysfs_device); 316 return ERR_PTR(-EIO); 317 } 318 319 zfcp_unit_get(unit); 320 321 write_lock_irq(&zfcp_data.config_lock); 322 list_add_tail(&unit->list, &port->unit_list_head); 323 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status); 324 atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &unit->status); 325 326 write_unlock_irq(&zfcp_data.config_lock); 327 328 zfcp_port_get(port); 329 330 return unit; 331 332 err_out_free: 333 kfree(unit); 334 return ERR_PTR(-EINVAL); 335 } 336 337 /** 338 * zfcp_unit_dequeue - dequeue unit 339 * @unit: pointer to zfcp_unit 340 * 341 * waits until all work is done on unit and removes it then from the unit->list 342 * of the associated port. 343 */ 344 void zfcp_unit_dequeue(struct zfcp_unit *unit) 345 { 346 wait_event(unit->remove_wq, atomic_read(&unit->refcount) == 0); 347 write_lock_irq(&zfcp_data.config_lock); 348 list_del(&unit->list); 349 write_unlock_irq(&zfcp_data.config_lock); 350 zfcp_port_put(unit->port); 351 sysfs_remove_group(&unit->sysfs_device.kobj, &zfcp_sysfs_unit_attrs); 352 device_unregister(&unit->sysfs_device); 353 } 354 355 static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter) 356 { 357 /* must only be called with zfcp_data.config_sema taken */ 358 adapter->pool.fsf_req_erp = 359 mempool_create_slab_pool(1, zfcp_data.fsf_req_qtcb_cache); 360 if (!adapter->pool.fsf_req_erp) 361 return -ENOMEM; 362 363 adapter->pool.fsf_req_scsi = 364 mempool_create_slab_pool(1, zfcp_data.fsf_req_qtcb_cache); 365 if (!adapter->pool.fsf_req_scsi) 366 return -ENOMEM; 367 368 adapter->pool.fsf_req_abort = 369 mempool_create_slab_pool(1, zfcp_data.fsf_req_qtcb_cache); 370 if (!adapter->pool.fsf_req_abort) 371 return -ENOMEM; 372 373 adapter->pool.fsf_req_status_read = 374 mempool_create_kmalloc_pool(FSF_STATUS_READS_RECOM, 375 sizeof(struct zfcp_fsf_req)); 376 if (!adapter->pool.fsf_req_status_read) 377 return -ENOMEM; 378 379 adapter->pool.data_status_read = 380 mempool_create_slab_pool(FSF_STATUS_READS_RECOM, 381 zfcp_data.sr_buffer_cache); 382 if (!adapter->pool.data_status_read) 383 return -ENOMEM; 384 385 adapter->pool.data_gid_pn = 386 mempool_create_slab_pool(1, zfcp_data.gid_pn_cache); 387 if (!adapter->pool.data_gid_pn) 388 return -ENOMEM; 389 390 return 0; 391 } 392 393 static void zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter) 394 { 395 /* zfcp_data.config_sema must be held */ 396 if (adapter->pool.fsf_req_erp) 397 mempool_destroy(adapter->pool.fsf_req_erp); 398 if (adapter->pool.fsf_req_scsi) 399 mempool_destroy(adapter->pool.fsf_req_scsi); 400 if (adapter->pool.fsf_req_abort) 401 mempool_destroy(adapter->pool.fsf_req_abort); 402 if (adapter->pool.fsf_req_status_read) 403 mempool_destroy(adapter->pool.fsf_req_status_read); 404 if (adapter->pool.data_status_read) 405 mempool_destroy(adapter->pool.data_status_read); 406 if (adapter->pool.data_gid_pn) 407 mempool_destroy(adapter->pool.data_gid_pn); 408 } 409 410 /** 411 * zfcp_status_read_refill - refill the long running status_read_requests 412 * @adapter: ptr to struct zfcp_adapter for which the buffers should be refilled 413 * 414 * Returns: 0 on success, 1 otherwise 415 * 416 * if there are 16 or more status_read requests missing an adapter_reopen 417 * is triggered 418 */ 419 int zfcp_status_read_refill(struct zfcp_adapter *adapter) 420 { 421 while (atomic_read(&adapter->stat_miss) > 0) 422 if (zfcp_fsf_status_read(adapter)) { 423 if (atomic_read(&adapter->stat_miss) >= 16) { 424 zfcp_erp_adapter_reopen(adapter, 0, 103, NULL); 425 return 1; 426 } 427 break; 428 } else 429 atomic_dec(&adapter->stat_miss); 430 return 0; 431 } 432 433 static void _zfcp_status_read_scheduler(struct work_struct *work) 434 { 435 zfcp_status_read_refill(container_of(work, struct zfcp_adapter, 436 stat_work)); 437 } 438 439 /** 440 * zfcp_adapter_enqueue - enqueue a new adapter to the list 441 * @ccw_device: pointer to the struct cc_device 442 * 443 * Returns: 0 if a new adapter was successfully enqueued 444 * -ENOMEM if alloc failed 445 * Enqueues an adapter at the end of the adapter list in the driver data. 446 * All adapter internal structures are set up. 447 * Proc-fs entries are also created. 448 * locks: config_sema must be held to serialise changes to the adapter list 449 */ 450 int zfcp_adapter_enqueue(struct ccw_device *ccw_device) 451 { 452 struct zfcp_adapter *adapter; 453 454 /* 455 * Note: It is safe to release the list_lock, as any list changes 456 * are protected by the config_sema, which must be held to get here 457 */ 458 459 adapter = kzalloc(sizeof(struct zfcp_adapter), GFP_KERNEL); 460 if (!adapter) 461 return -ENOMEM; 462 463 ccw_device->handler = NULL; 464 adapter->ccw_device = ccw_device; 465 atomic_set(&adapter->refcount, 0); 466 467 if (zfcp_qdio_allocate(adapter)) 468 goto qdio_allocate_failed; 469 470 if (zfcp_allocate_low_mem_buffers(adapter)) 471 goto failed_low_mem_buffers; 472 473 if (zfcp_reqlist_alloc(adapter)) 474 goto failed_low_mem_buffers; 475 476 if (zfcp_adapter_debug_register(adapter)) 477 goto debug_register_failed; 478 479 init_waitqueue_head(&adapter->remove_wq); 480 init_waitqueue_head(&adapter->erp_thread_wqh); 481 init_waitqueue_head(&adapter->erp_done_wqh); 482 483 INIT_LIST_HEAD(&adapter->port_list_head); 484 INIT_LIST_HEAD(&adapter->erp_ready_head); 485 INIT_LIST_HEAD(&adapter->erp_running_head); 486 487 spin_lock_init(&adapter->req_list_lock); 488 489 spin_lock_init(&adapter->hba_dbf_lock); 490 spin_lock_init(&adapter->san_dbf_lock); 491 spin_lock_init(&adapter->scsi_dbf_lock); 492 spin_lock_init(&adapter->rec_dbf_lock); 493 spin_lock_init(&adapter->req_q_lock); 494 495 rwlock_init(&adapter->erp_lock); 496 rwlock_init(&adapter->abort_lock); 497 498 sema_init(&adapter->erp_ready_sem, 0); 499 500 INIT_WORK(&adapter->stat_work, _zfcp_status_read_scheduler); 501 INIT_WORK(&adapter->scan_work, _zfcp_scan_ports_later); 502 503 /* mark adapter unusable as long as sysfs registration is not complete */ 504 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status); 505 506 dev_set_drvdata(&ccw_device->dev, adapter); 507 508 if (sysfs_create_group(&ccw_device->dev.kobj, 509 &zfcp_sysfs_adapter_attrs)) 510 goto sysfs_failed; 511 512 write_lock_irq(&zfcp_data.config_lock); 513 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status); 514 list_add_tail(&adapter->list, &zfcp_data.adapter_list_head); 515 write_unlock_irq(&zfcp_data.config_lock); 516 517 zfcp_fc_nameserver_init(adapter); 518 519 return 0; 520 521 sysfs_failed: 522 zfcp_adapter_debug_unregister(adapter); 523 debug_register_failed: 524 dev_set_drvdata(&ccw_device->dev, NULL); 525 kfree(adapter->req_list); 526 failed_low_mem_buffers: 527 zfcp_free_low_mem_buffers(adapter); 528 qdio_allocate_failed: 529 zfcp_qdio_free(adapter); 530 kfree(adapter); 531 return -ENOMEM; 532 } 533 534 /** 535 * zfcp_adapter_dequeue - remove the adapter from the resource list 536 * @adapter: pointer to struct zfcp_adapter which should be removed 537 * locks: adapter list write lock is assumed to be held by caller 538 */ 539 void zfcp_adapter_dequeue(struct zfcp_adapter *adapter) 540 { 541 int retval = 0; 542 unsigned long flags; 543 544 cancel_work_sync(&adapter->scan_work); 545 cancel_work_sync(&adapter->stat_work); 546 zfcp_adapter_scsi_unregister(adapter); 547 sysfs_remove_group(&adapter->ccw_device->dev.kobj, 548 &zfcp_sysfs_adapter_attrs); 549 dev_set_drvdata(&adapter->ccw_device->dev, NULL); 550 /* sanity check: no pending FSF requests */ 551 spin_lock_irqsave(&adapter->req_list_lock, flags); 552 retval = zfcp_reqlist_isempty(adapter); 553 spin_unlock_irqrestore(&adapter->req_list_lock, flags); 554 if (!retval) 555 return; 556 557 zfcp_adapter_debug_unregister(adapter); 558 559 /* remove specified adapter data structure from list */ 560 write_lock_irq(&zfcp_data.config_lock); 561 list_del(&adapter->list); 562 write_unlock_irq(&zfcp_data.config_lock); 563 564 zfcp_qdio_free(adapter); 565 566 zfcp_free_low_mem_buffers(adapter); 567 kfree(adapter->req_list); 568 kfree(adapter->fc_stats); 569 kfree(adapter->stats_reset_data); 570 kfree(adapter); 571 } 572 573 static void zfcp_sysfs_port_release(struct device *dev) 574 { 575 kfree(container_of(dev, struct zfcp_port, sysfs_device)); 576 } 577 578 /** 579 * zfcp_port_enqueue - enqueue port to port list of adapter 580 * @adapter: adapter where remote port is added 581 * @wwpn: WWPN of the remote port to be enqueued 582 * @status: initial status for the port 583 * @d_id: destination id of the remote port to be enqueued 584 * Returns: pointer to enqueued port on success, ERR_PTR on error 585 * Locks: config_sema must be held to serialize changes to the port list 586 * 587 * All port internal structures are set up and the sysfs entry is generated. 588 * d_id is used to enqueue ports with a well known address like the Directory 589 * Service for nameserver lookup. 590 */ 591 struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, u64 wwpn, 592 u32 status, u32 d_id) 593 { 594 struct zfcp_port *port; 595 int retval; 596 597 port = kzalloc(sizeof(struct zfcp_port), GFP_KERNEL); 598 if (!port) 599 return ERR_PTR(-ENOMEM); 600 601 init_waitqueue_head(&port->remove_wq); 602 INIT_LIST_HEAD(&port->unit_list_head); 603 INIT_WORK(&port->gid_pn_work, zfcp_erp_port_strategy_open_lookup); 604 605 port->adapter = adapter; 606 port->d_id = d_id; 607 port->wwpn = wwpn; 608 609 /* mark port unusable as long as sysfs registration is not complete */ 610 atomic_set_mask(status | ZFCP_STATUS_COMMON_REMOVE, &port->status); 611 atomic_set(&port->refcount, 0); 612 613 dev_set_name(&port->sysfs_device, "0x%016llx", wwpn); 614 port->sysfs_device.parent = &adapter->ccw_device->dev; 615 616 port->sysfs_device.release = zfcp_sysfs_port_release; 617 dev_set_drvdata(&port->sysfs_device, port); 618 619 read_lock_irq(&zfcp_data.config_lock); 620 if (!(status & ZFCP_STATUS_PORT_NO_WWPN)) 621 if (zfcp_get_port_by_wwpn(adapter, wwpn)) { 622 read_unlock_irq(&zfcp_data.config_lock); 623 goto err_out_free; 624 } 625 read_unlock_irq(&zfcp_data.config_lock); 626 627 if (device_register(&port->sysfs_device)) 628 goto err_out_free; 629 630 retval = sysfs_create_group(&port->sysfs_device.kobj, 631 &zfcp_sysfs_port_attrs); 632 633 if (retval) { 634 device_unregister(&port->sysfs_device); 635 goto err_out; 636 } 637 638 zfcp_port_get(port); 639 640 write_lock_irq(&zfcp_data.config_lock); 641 list_add_tail(&port->list, &adapter->port_list_head); 642 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status); 643 atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &port->status); 644 645 write_unlock_irq(&zfcp_data.config_lock); 646 647 zfcp_adapter_get(adapter); 648 return port; 649 650 err_out_free: 651 kfree(port); 652 err_out: 653 return ERR_PTR(-EINVAL); 654 } 655 656 /** 657 * zfcp_port_dequeue - dequeues a port from the port list of the adapter 658 * @port: pointer to struct zfcp_port which should be removed 659 */ 660 void zfcp_port_dequeue(struct zfcp_port *port) 661 { 662 wait_event(port->remove_wq, atomic_read(&port->refcount) == 0); 663 write_lock_irq(&zfcp_data.config_lock); 664 list_del(&port->list); 665 write_unlock_irq(&zfcp_data.config_lock); 666 if (port->rport) 667 fc_remote_port_delete(port->rport); 668 port->rport = NULL; 669 zfcp_adapter_put(port->adapter); 670 sysfs_remove_group(&port->sysfs_device.kobj, &zfcp_sysfs_port_attrs); 671 device_unregister(&port->sysfs_device); 672 } 673 674 /** 675 * zfcp_sg_free_table - free memory used by scatterlists 676 * @sg: pointer to scatterlist 677 * @count: number of scatterlist which are to be free'ed 678 * the scatterlist are expected to reference pages always 679 */ 680 void zfcp_sg_free_table(struct scatterlist *sg, int count) 681 { 682 int i; 683 684 for (i = 0; i < count; i++, sg++) 685 if (sg) 686 free_page((unsigned long) sg_virt(sg)); 687 else 688 break; 689 } 690 691 /** 692 * zfcp_sg_setup_table - init scatterlist and allocate, assign buffers 693 * @sg: pointer to struct scatterlist 694 * @count: number of scatterlists which should be assigned with buffers 695 * of size page 696 * 697 * Returns: 0 on success, -ENOMEM otherwise 698 */ 699 int zfcp_sg_setup_table(struct scatterlist *sg, int count) 700 { 701 void *addr; 702 int i; 703 704 sg_init_table(sg, count); 705 for (i = 0; i < count; i++, sg++) { 706 addr = (void *) get_zeroed_page(GFP_KERNEL); 707 if (!addr) { 708 zfcp_sg_free_table(sg, i); 709 return -ENOMEM; 710 } 711 sg_set_buf(sg, addr, PAGE_SIZE); 712 } 713 return 0; 714 } 715