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 int zfcp_reqlist_alloc(struct zfcp_adapter *adapter) 46 { 47 int idx; 48 49 adapter->req_list = kcalloc(REQUEST_LIST_SIZE, sizeof(struct list_head), 50 GFP_KERNEL); 51 if (!adapter->req_list) 52 return -ENOMEM; 53 54 for (idx = 0; idx < REQUEST_LIST_SIZE; idx++) 55 INIT_LIST_HEAD(&adapter->req_list[idx]); 56 return 0; 57 } 58 59 /** 60 * zfcp_reqlist_isempty - is the request list empty 61 * @adapter: pointer to struct zfcp_adapter 62 * 63 * Returns: true if list is empty, false otherwise 64 */ 65 int zfcp_reqlist_isempty(struct zfcp_adapter *adapter) 66 { 67 unsigned int idx; 68 69 for (idx = 0; idx < REQUEST_LIST_SIZE; idx++) 70 if (!list_empty(&adapter->req_list[idx])) 71 return 0; 72 return 1; 73 } 74 75 static void __init zfcp_init_device_configure(char *busid, u64 wwpn, u64 lun) 76 { 77 struct zfcp_adapter *adapter; 78 struct zfcp_port *port; 79 struct zfcp_unit *unit; 80 81 down(&zfcp_data.config_sema); 82 read_lock_irq(&zfcp_data.config_lock); 83 adapter = zfcp_get_adapter_by_busid(busid); 84 if (adapter) 85 zfcp_adapter_get(adapter); 86 read_unlock_irq(&zfcp_data.config_lock); 87 88 if (!adapter) 89 goto out_adapter; 90 port = zfcp_port_enqueue(adapter, wwpn, 0, 0); 91 if (IS_ERR(port)) 92 goto out_port; 93 unit = zfcp_unit_enqueue(port, lun); 94 if (IS_ERR(unit)) 95 goto out_unit; 96 up(&zfcp_data.config_sema); 97 ccw_device_set_online(adapter->ccw_device); 98 99 zfcp_erp_wait(adapter); 100 wait_event(adapter->erp_done_wqh, 101 !(atomic_read(&unit->status) & 102 ZFCP_STATUS_UNIT_SCSI_WORK_PENDING)); 103 104 down(&zfcp_data.config_sema); 105 zfcp_unit_put(unit); 106 out_unit: 107 zfcp_port_put(port); 108 out_port: 109 zfcp_adapter_put(adapter); 110 out_adapter: 111 up(&zfcp_data.config_sema); 112 return; 113 } 114 115 static struct kmem_cache *zfcp_cache_create(int size, char *name) 116 { 117 int align = 1; 118 while ((size - align) > 0) 119 align <<= 1; 120 return kmem_cache_create(name , size, align, 0, NULL); 121 } 122 123 static void __init zfcp_init_device_setup(char *devstr) 124 { 125 char *token; 126 char *str; 127 char busid[ZFCP_BUS_ID_SIZE]; 128 u64 wwpn, lun; 129 130 /* duplicate devstr and keep the original for sysfs presentation*/ 131 str = kmalloc(strlen(devstr) + 1, GFP_KERNEL); 132 if (!str) 133 return; 134 135 strcpy(str, devstr); 136 137 token = strsep(&str, ","); 138 if (!token || strlen(token) >= ZFCP_BUS_ID_SIZE) 139 goto err_out; 140 strncpy(busid, token, ZFCP_BUS_ID_SIZE); 141 142 token = strsep(&str, ","); 143 if (!token || strict_strtoull(token, 0, (unsigned long long *) &wwpn)) 144 goto err_out; 145 146 token = strsep(&str, ","); 147 if (!token || strict_strtoull(token, 0, (unsigned long long *) &lun)) 148 goto err_out; 149 150 kfree(str); 151 zfcp_init_device_configure(busid, wwpn, lun); 152 return; 153 154 err_out: 155 kfree(str); 156 pr_err("%s is not a valid SCSI device\n", devstr); 157 } 158 159 static int __init zfcp_module_init(void) 160 { 161 int retval = -ENOMEM; 162 163 zfcp_data.fsf_req_qtcb_cache = zfcp_cache_create( 164 sizeof(struct zfcp_fsf_req_qtcb), "zfcp_fsf"); 165 if (!zfcp_data.fsf_req_qtcb_cache) 166 goto out; 167 168 zfcp_data.sr_buffer_cache = zfcp_cache_create( 169 sizeof(struct fsf_status_read_buffer), "zfcp_sr"); 170 if (!zfcp_data.sr_buffer_cache) 171 goto out_sr_cache; 172 173 zfcp_data.gid_pn_cache = zfcp_cache_create( 174 sizeof(struct zfcp_gid_pn_data), "zfcp_gid"); 175 if (!zfcp_data.gid_pn_cache) 176 goto out_gid_cache; 177 178 zfcp_data.work_queue = create_singlethread_workqueue("zfcp_wq"); 179 180 sema_init(&zfcp_data.config_sema, 1); 181 rwlock_init(&zfcp_data.config_lock); 182 183 zfcp_data.scsi_transport_template = 184 fc_attach_transport(&zfcp_transport_functions); 185 if (!zfcp_data.scsi_transport_template) 186 goto out_transport; 187 188 retval = misc_register(&zfcp_cfdc_misc); 189 if (retval) { 190 pr_err("Registering the misc device zfcp_cfdc failed\n"); 191 goto out_misc; 192 } 193 194 retval = zfcp_ccw_register(); 195 if (retval) { 196 pr_err("The zfcp device driver could not register with " 197 "the common I/O layer\n"); 198 goto out_ccw_register; 199 } 200 201 if (init_device) 202 zfcp_init_device_setup(init_device); 203 return 0; 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) && 253 !(atomic_read(&port->status) & 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, "axsref1", 425 NULL); 426 return 1; 427 } 428 break; 429 } else 430 atomic_dec(&adapter->stat_miss); 431 return 0; 432 } 433 434 static void _zfcp_status_read_scheduler(struct work_struct *work) 435 { 436 zfcp_status_read_refill(container_of(work, struct zfcp_adapter, 437 stat_work)); 438 } 439 440 static void zfcp_print_sl(struct seq_file *m, struct service_level *sl) 441 { 442 struct zfcp_adapter *adapter = 443 container_of(sl, struct zfcp_adapter, service_level); 444 445 seq_printf(m, "zfcp: %s microcode level %x\n", 446 dev_name(&adapter->ccw_device->dev), 447 adapter->fsf_lic_version); 448 } 449 450 /** 451 * zfcp_adapter_enqueue - enqueue a new adapter to the list 452 * @ccw_device: pointer to the struct cc_device 453 * 454 * Returns: 0 if a new adapter was successfully enqueued 455 * -ENOMEM if alloc failed 456 * Enqueues an adapter at the end of the adapter list in the driver data. 457 * All adapter internal structures are set up. 458 * Proc-fs entries are also created. 459 * locks: config_sema must be held to serialise changes to the adapter list 460 */ 461 int zfcp_adapter_enqueue(struct ccw_device *ccw_device) 462 { 463 struct zfcp_adapter *adapter; 464 465 /* 466 * Note: It is safe to release the list_lock, as any list changes 467 * are protected by the config_sema, which must be held to get here 468 */ 469 470 adapter = kzalloc(sizeof(struct zfcp_adapter), GFP_KERNEL); 471 if (!adapter) 472 return -ENOMEM; 473 474 ccw_device->handler = NULL; 475 adapter->ccw_device = ccw_device; 476 atomic_set(&adapter->refcount, 0); 477 478 if (zfcp_qdio_allocate(adapter)) 479 goto qdio_allocate_failed; 480 481 if (zfcp_allocate_low_mem_buffers(adapter)) 482 goto failed_low_mem_buffers; 483 484 if (zfcp_reqlist_alloc(adapter)) 485 goto failed_low_mem_buffers; 486 487 if (zfcp_adapter_debug_register(adapter)) 488 goto debug_register_failed; 489 490 init_waitqueue_head(&adapter->remove_wq); 491 init_waitqueue_head(&adapter->erp_thread_wqh); 492 init_waitqueue_head(&adapter->erp_done_wqh); 493 494 INIT_LIST_HEAD(&adapter->port_list_head); 495 INIT_LIST_HEAD(&adapter->erp_ready_head); 496 INIT_LIST_HEAD(&adapter->erp_running_head); 497 498 spin_lock_init(&adapter->req_list_lock); 499 500 spin_lock_init(&adapter->hba_dbf_lock); 501 spin_lock_init(&adapter->san_dbf_lock); 502 spin_lock_init(&adapter->scsi_dbf_lock); 503 spin_lock_init(&adapter->rec_dbf_lock); 504 spin_lock_init(&adapter->req_q_lock); 505 spin_lock_init(&adapter->qdio_stat_lock); 506 507 rwlock_init(&adapter->erp_lock); 508 rwlock_init(&adapter->abort_lock); 509 510 sema_init(&adapter->erp_ready_sem, 0); 511 512 INIT_WORK(&adapter->stat_work, _zfcp_status_read_scheduler); 513 INIT_WORK(&adapter->scan_work, _zfcp_scan_ports_later); 514 515 adapter->service_level.seq_print = zfcp_print_sl; 516 517 /* mark adapter unusable as long as sysfs registration is not complete */ 518 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status); 519 520 dev_set_drvdata(&ccw_device->dev, adapter); 521 522 if (sysfs_create_group(&ccw_device->dev.kobj, 523 &zfcp_sysfs_adapter_attrs)) 524 goto sysfs_failed; 525 526 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status); 527 528 if (!zfcp_adapter_scsi_register(adapter)) 529 return 0; 530 531 sysfs_failed: 532 zfcp_adapter_debug_unregister(adapter); 533 debug_register_failed: 534 dev_set_drvdata(&ccw_device->dev, NULL); 535 kfree(adapter->req_list); 536 failed_low_mem_buffers: 537 zfcp_free_low_mem_buffers(adapter); 538 qdio_allocate_failed: 539 zfcp_qdio_free(adapter); 540 kfree(adapter); 541 return -ENOMEM; 542 } 543 544 /** 545 * zfcp_adapter_dequeue - remove the adapter from the resource list 546 * @adapter: pointer to struct zfcp_adapter which should be removed 547 * locks: adapter list write lock is assumed to be held by caller 548 */ 549 void zfcp_adapter_dequeue(struct zfcp_adapter *adapter) 550 { 551 int retval = 0; 552 unsigned long flags; 553 554 cancel_work_sync(&adapter->scan_work); 555 cancel_work_sync(&adapter->stat_work); 556 cancel_delayed_work_sync(&adapter->nsp.work); 557 zfcp_adapter_scsi_unregister(adapter); 558 sysfs_remove_group(&adapter->ccw_device->dev.kobj, 559 &zfcp_sysfs_adapter_attrs); 560 dev_set_drvdata(&adapter->ccw_device->dev, NULL); 561 /* sanity check: no pending FSF requests */ 562 spin_lock_irqsave(&adapter->req_list_lock, flags); 563 retval = zfcp_reqlist_isempty(adapter); 564 spin_unlock_irqrestore(&adapter->req_list_lock, flags); 565 if (!retval) 566 return; 567 568 zfcp_adapter_debug_unregister(adapter); 569 zfcp_qdio_free(adapter); 570 zfcp_free_low_mem_buffers(adapter); 571 kfree(adapter->req_list); 572 kfree(adapter->fc_stats); 573 kfree(adapter->stats_reset_data); 574 kfree(adapter); 575 } 576 577 static void zfcp_sysfs_port_release(struct device *dev) 578 { 579 kfree(container_of(dev, struct zfcp_port, sysfs_device)); 580 } 581 582 /** 583 * zfcp_port_enqueue - enqueue port to port list of adapter 584 * @adapter: adapter where remote port is added 585 * @wwpn: WWPN of the remote port to be enqueued 586 * @status: initial status for the port 587 * @d_id: destination id of the remote port to be enqueued 588 * Returns: pointer to enqueued port on success, ERR_PTR on error 589 * Locks: config_sema must be held to serialize changes to the port list 590 * 591 * All port internal structures are set up and the sysfs entry is generated. 592 * d_id is used to enqueue ports with a well known address like the Directory 593 * Service for nameserver lookup. 594 */ 595 struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, u64 wwpn, 596 u32 status, u32 d_id) 597 { 598 struct zfcp_port *port; 599 int retval; 600 601 port = kzalloc(sizeof(struct zfcp_port), GFP_KERNEL); 602 if (!port) 603 return ERR_PTR(-ENOMEM); 604 605 init_waitqueue_head(&port->remove_wq); 606 INIT_LIST_HEAD(&port->unit_list_head); 607 INIT_WORK(&port->gid_pn_work, zfcp_erp_port_strategy_open_lookup); 608 INIT_WORK(&port->test_link_work, zfcp_fc_link_test_work); 609 INIT_WORK(&port->rport_work, zfcp_scsi_rport_work); 610 611 port->adapter = adapter; 612 port->d_id = d_id; 613 port->wwpn = wwpn; 614 port->rport_task = RPORT_NONE; 615 616 /* mark port unusable as long as sysfs registration is not complete */ 617 atomic_set_mask(status | ZFCP_STATUS_COMMON_REMOVE, &port->status); 618 atomic_set(&port->refcount, 0); 619 620 dev_set_name(&port->sysfs_device, "0x%016llx", 621 (unsigned long long)wwpn); 622 port->sysfs_device.parent = &adapter->ccw_device->dev; 623 624 port->sysfs_device.release = zfcp_sysfs_port_release; 625 dev_set_drvdata(&port->sysfs_device, port); 626 627 read_lock_irq(&zfcp_data.config_lock); 628 if (zfcp_get_port_by_wwpn(adapter, wwpn)) { 629 read_unlock_irq(&zfcp_data.config_lock); 630 goto err_out_free; 631 } 632 read_unlock_irq(&zfcp_data.config_lock); 633 634 if (device_register(&port->sysfs_device)) 635 goto err_out_free; 636 637 retval = sysfs_create_group(&port->sysfs_device.kobj, 638 &zfcp_sysfs_port_attrs); 639 640 if (retval) { 641 device_unregister(&port->sysfs_device); 642 goto err_out; 643 } 644 645 zfcp_port_get(port); 646 647 write_lock_irq(&zfcp_data.config_lock); 648 list_add_tail(&port->list, &adapter->port_list_head); 649 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status); 650 atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &port->status); 651 652 write_unlock_irq(&zfcp_data.config_lock); 653 654 zfcp_adapter_get(adapter); 655 return port; 656 657 err_out_free: 658 kfree(port); 659 err_out: 660 return ERR_PTR(-EINVAL); 661 } 662 663 /** 664 * zfcp_port_dequeue - dequeues a port from the port list of the adapter 665 * @port: pointer to struct zfcp_port which should be removed 666 */ 667 void zfcp_port_dequeue(struct zfcp_port *port) 668 { 669 wait_event(port->remove_wq, atomic_read(&port->refcount) == 0); 670 write_lock_irq(&zfcp_data.config_lock); 671 list_del(&port->list); 672 write_unlock_irq(&zfcp_data.config_lock); 673 if (port->rport) 674 fc_remote_port_delete(port->rport); 675 port->rport = NULL; 676 zfcp_adapter_put(port->adapter); 677 sysfs_remove_group(&port->sysfs_device.kobj, &zfcp_sysfs_port_attrs); 678 device_unregister(&port->sysfs_device); 679 } 680 681 /** 682 * zfcp_sg_free_table - free memory used by scatterlists 683 * @sg: pointer to scatterlist 684 * @count: number of scatterlist which are to be free'ed 685 * the scatterlist are expected to reference pages always 686 */ 687 void zfcp_sg_free_table(struct scatterlist *sg, int count) 688 { 689 int i; 690 691 for (i = 0; i < count; i++, sg++) 692 if (sg) 693 free_page((unsigned long) sg_virt(sg)); 694 else 695 break; 696 } 697 698 /** 699 * zfcp_sg_setup_table - init scatterlist and allocate, assign buffers 700 * @sg: pointer to struct scatterlist 701 * @count: number of scatterlists which should be assigned with buffers 702 * of size page 703 * 704 * Returns: 0 on success, -ENOMEM otherwise 705 */ 706 int zfcp_sg_setup_table(struct scatterlist *sg, int count) 707 { 708 void *addr; 709 int i; 710 711 sg_init_table(sg, count); 712 for (i = 0; i < count; i++, sg++) { 713 addr = (void *) get_zeroed_page(GFP_KERNEL); 714 if (!addr) { 715 zfcp_sg_free_table(sg, i); 716 return -ENOMEM; 717 } 718 sg_set_buf(sg, addr, PAGE_SIZE); 719 } 720 return 0; 721 } 722