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 flush_work(&unit->scsi_work); 101 102 down(&zfcp_data.config_sema); 103 zfcp_unit_put(unit); 104 out_unit: 105 zfcp_port_put(port); 106 out_port: 107 zfcp_adapter_put(adapter); 108 out_adapter: 109 up(&zfcp_data.config_sema); 110 return; 111 } 112 113 static struct kmem_cache *zfcp_cache_create(int size, char *name) 114 { 115 int align = 1; 116 while ((size - align) > 0) 117 align <<= 1; 118 return kmem_cache_create(name , size, align, 0, NULL); 119 } 120 121 static void __init zfcp_init_device_setup(char *devstr) 122 { 123 char *token; 124 char *str; 125 char busid[ZFCP_BUS_ID_SIZE]; 126 u64 wwpn, lun; 127 128 /* duplicate devstr and keep the original for sysfs presentation*/ 129 str = kmalloc(strlen(devstr) + 1, GFP_KERNEL); 130 if (!str) 131 return; 132 133 strcpy(str, devstr); 134 135 token = strsep(&str, ","); 136 if (!token || strlen(token) >= ZFCP_BUS_ID_SIZE) 137 goto err_out; 138 strncpy(busid, token, ZFCP_BUS_ID_SIZE); 139 140 token = strsep(&str, ","); 141 if (!token || strict_strtoull(token, 0, (unsigned long long *) &wwpn)) 142 goto err_out; 143 144 token = strsep(&str, ","); 145 if (!token || strict_strtoull(token, 0, (unsigned long long *) &lun)) 146 goto err_out; 147 148 kfree(str); 149 zfcp_init_device_configure(busid, wwpn, lun); 150 return; 151 152 err_out: 153 kfree(str); 154 pr_err("%s is not a valid SCSI device\n", devstr); 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 sema_init(&zfcp_data.config_sema, 1); 179 rwlock_init(&zfcp_data.config_lock); 180 181 zfcp_data.scsi_transport_template = 182 fc_attach_transport(&zfcp_transport_functions); 183 if (!zfcp_data.scsi_transport_template) 184 goto out_transport; 185 186 retval = misc_register(&zfcp_cfdc_misc); 187 if (retval) { 188 pr_err("Registering the misc device zfcp_cfdc failed\n"); 189 goto out_misc; 190 } 191 192 retval = zfcp_ccw_register(); 193 if (retval) { 194 pr_err("The zfcp device driver could not register with " 195 "the common I/O layer\n"); 196 goto out_ccw_register; 197 } 198 199 if (init_device) 200 zfcp_init_device_setup(init_device); 201 return 0; 202 203 out_ccw_register: 204 misc_deregister(&zfcp_cfdc_misc); 205 out_misc: 206 fc_release_transport(zfcp_data.scsi_transport_template); 207 out_transport: 208 kmem_cache_destroy(zfcp_data.gid_pn_cache); 209 out_gid_cache: 210 kmem_cache_destroy(zfcp_data.sr_buffer_cache); 211 out_sr_cache: 212 kmem_cache_destroy(zfcp_data.fsf_req_qtcb_cache); 213 out: 214 return retval; 215 } 216 217 module_init(zfcp_module_init); 218 219 /** 220 * zfcp_get_unit_by_lun - find unit in unit list of port by FCP LUN 221 * @port: pointer to port to search for unit 222 * @fcp_lun: FCP LUN to search for 223 * 224 * Returns: pointer to zfcp_unit or NULL 225 */ 226 struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *port, u64 fcp_lun) 227 { 228 struct zfcp_unit *unit; 229 230 list_for_each_entry(unit, &port->unit_list_head, list) 231 if ((unit->fcp_lun == fcp_lun) && 232 !(atomic_read(&unit->status) & ZFCP_STATUS_COMMON_REMOVE)) 233 return unit; 234 return NULL; 235 } 236 237 /** 238 * zfcp_get_port_by_wwpn - find port in port list of adapter by wwpn 239 * @adapter: pointer to adapter to search for port 240 * @wwpn: wwpn to search for 241 * 242 * Returns: pointer to zfcp_port or NULL 243 */ 244 struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter, 245 u64 wwpn) 246 { 247 struct zfcp_port *port; 248 249 list_for_each_entry(port, &adapter->port_list_head, list) 250 if ((port->wwpn == wwpn) && 251 !(atomic_read(&port->status) & ZFCP_STATUS_COMMON_REMOVE)) 252 return port; 253 return NULL; 254 } 255 256 static void zfcp_sysfs_unit_release(struct device *dev) 257 { 258 kfree(container_of(dev, struct zfcp_unit, sysfs_device)); 259 } 260 261 /** 262 * zfcp_unit_enqueue - enqueue unit to unit list of a port. 263 * @port: pointer to port where unit is added 264 * @fcp_lun: FCP LUN of unit to be enqueued 265 * Returns: pointer to enqueued unit on success, ERR_PTR on error 266 * Locks: config_sema must be held to serialize changes to the unit list 267 * 268 * Sets up some unit internal structures and creates sysfs entry. 269 */ 270 struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, u64 fcp_lun) 271 { 272 struct zfcp_unit *unit; 273 274 unit = kzalloc(sizeof(struct zfcp_unit), GFP_KERNEL); 275 if (!unit) 276 return ERR_PTR(-ENOMEM); 277 278 atomic_set(&unit->refcount, 0); 279 init_waitqueue_head(&unit->remove_wq); 280 INIT_WORK(&unit->scsi_work, zfcp_scsi_scan); 281 282 unit->port = port; 283 unit->fcp_lun = fcp_lun; 284 285 dev_set_name(&unit->sysfs_device, "0x%016llx", 286 (unsigned long long) fcp_lun); 287 unit->sysfs_device.parent = &port->sysfs_device; 288 unit->sysfs_device.release = zfcp_sysfs_unit_release; 289 dev_set_drvdata(&unit->sysfs_device, unit); 290 291 /* mark unit unusable as long as sysfs registration is not complete */ 292 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status); 293 294 spin_lock_init(&unit->latencies.lock); 295 unit->latencies.write.channel.min = 0xFFFFFFFF; 296 unit->latencies.write.fabric.min = 0xFFFFFFFF; 297 unit->latencies.read.channel.min = 0xFFFFFFFF; 298 unit->latencies.read.fabric.min = 0xFFFFFFFF; 299 unit->latencies.cmd.channel.min = 0xFFFFFFFF; 300 unit->latencies.cmd.fabric.min = 0xFFFFFFFF; 301 302 read_lock_irq(&zfcp_data.config_lock); 303 if (zfcp_get_unit_by_lun(port, fcp_lun)) { 304 read_unlock_irq(&zfcp_data.config_lock); 305 goto err_out_free; 306 } 307 read_unlock_irq(&zfcp_data.config_lock); 308 309 if (device_register(&unit->sysfs_device)) 310 goto err_out_free; 311 312 if (sysfs_create_group(&unit->sysfs_device.kobj, 313 &zfcp_sysfs_unit_attrs)) { 314 device_unregister(&unit->sysfs_device); 315 return ERR_PTR(-EIO); 316 } 317 318 zfcp_unit_get(unit); 319 320 write_lock_irq(&zfcp_data.config_lock); 321 list_add_tail(&unit->list, &port->unit_list_head); 322 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status); 323 atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &unit->status); 324 325 write_unlock_irq(&zfcp_data.config_lock); 326 327 zfcp_port_get(port); 328 329 return unit; 330 331 err_out_free: 332 kfree(unit); 333 return ERR_PTR(-EINVAL); 334 } 335 336 /** 337 * zfcp_unit_dequeue - dequeue unit 338 * @unit: pointer to zfcp_unit 339 * 340 * waits until all work is done on unit and removes it then from the unit->list 341 * of the associated port. 342 */ 343 void zfcp_unit_dequeue(struct zfcp_unit *unit) 344 { 345 wait_event(unit->remove_wq, atomic_read(&unit->refcount) == 0); 346 write_lock_irq(&zfcp_data.config_lock); 347 list_del(&unit->list); 348 write_unlock_irq(&zfcp_data.config_lock); 349 zfcp_port_put(unit->port); 350 sysfs_remove_group(&unit->sysfs_device.kobj, &zfcp_sysfs_unit_attrs); 351 device_unregister(&unit->sysfs_device); 352 } 353 354 static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter) 355 { 356 /* must only be called with zfcp_data.config_sema taken */ 357 adapter->pool.fsf_req_erp = 358 mempool_create_slab_pool(1, zfcp_data.fsf_req_qtcb_cache); 359 if (!adapter->pool.fsf_req_erp) 360 return -ENOMEM; 361 362 adapter->pool.fsf_req_scsi = 363 mempool_create_slab_pool(1, zfcp_data.fsf_req_qtcb_cache); 364 if (!adapter->pool.fsf_req_scsi) 365 return -ENOMEM; 366 367 adapter->pool.fsf_req_abort = 368 mempool_create_slab_pool(1, zfcp_data.fsf_req_qtcb_cache); 369 if (!adapter->pool.fsf_req_abort) 370 return -ENOMEM; 371 372 adapter->pool.fsf_req_status_read = 373 mempool_create_kmalloc_pool(FSF_STATUS_READS_RECOM, 374 sizeof(struct zfcp_fsf_req)); 375 if (!adapter->pool.fsf_req_status_read) 376 return -ENOMEM; 377 378 adapter->pool.data_status_read = 379 mempool_create_slab_pool(FSF_STATUS_READS_RECOM, 380 zfcp_data.sr_buffer_cache); 381 if (!adapter->pool.data_status_read) 382 return -ENOMEM; 383 384 adapter->pool.data_gid_pn = 385 mempool_create_slab_pool(1, zfcp_data.gid_pn_cache); 386 if (!adapter->pool.data_gid_pn) 387 return -ENOMEM; 388 389 return 0; 390 } 391 392 static void zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter) 393 { 394 /* zfcp_data.config_sema must be held */ 395 if (adapter->pool.fsf_req_erp) 396 mempool_destroy(adapter->pool.fsf_req_erp); 397 if (adapter->pool.fsf_req_scsi) 398 mempool_destroy(adapter->pool.fsf_req_scsi); 399 if (adapter->pool.fsf_req_abort) 400 mempool_destroy(adapter->pool.fsf_req_abort); 401 if (adapter->pool.fsf_req_status_read) 402 mempool_destroy(adapter->pool.fsf_req_status_read); 403 if (adapter->pool.data_status_read) 404 mempool_destroy(adapter->pool.data_status_read); 405 if (adapter->pool.data_gid_pn) 406 mempool_destroy(adapter->pool.data_gid_pn); 407 } 408 409 /** 410 * zfcp_status_read_refill - refill the long running status_read_requests 411 * @adapter: ptr to struct zfcp_adapter for which the buffers should be refilled 412 * 413 * Returns: 0 on success, 1 otherwise 414 * 415 * if there are 16 or more status_read requests missing an adapter_reopen 416 * is triggered 417 */ 418 int zfcp_status_read_refill(struct zfcp_adapter *adapter) 419 { 420 while (atomic_read(&adapter->stat_miss) > 0) 421 if (zfcp_fsf_status_read(adapter)) { 422 if (atomic_read(&adapter->stat_miss) >= 16) { 423 zfcp_erp_adapter_reopen(adapter, 0, "axsref1", 424 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 static void zfcp_print_sl(struct seq_file *m, struct service_level *sl) 440 { 441 struct zfcp_adapter *adapter = 442 container_of(sl, struct zfcp_adapter, service_level); 443 444 seq_printf(m, "zfcp: %s microcode level %x\n", 445 dev_name(&adapter->ccw_device->dev), 446 adapter->fsf_lic_version); 447 } 448 449 /** 450 * zfcp_adapter_enqueue - enqueue a new adapter to the list 451 * @ccw_device: pointer to the struct cc_device 452 * 453 * Returns: 0 if a new adapter was successfully enqueued 454 * -ENOMEM if alloc failed 455 * Enqueues an adapter at the end of the adapter list in the driver data. 456 * All adapter internal structures are set up. 457 * Proc-fs entries are also created. 458 * locks: config_sema must be held to serialise changes to the adapter list 459 */ 460 int zfcp_adapter_enqueue(struct ccw_device *ccw_device) 461 { 462 struct zfcp_adapter *adapter; 463 464 /* 465 * Note: It is safe to release the list_lock, as any list changes 466 * are protected by the config_sema, which must be held to get here 467 */ 468 469 adapter = kzalloc(sizeof(struct zfcp_adapter), GFP_KERNEL); 470 if (!adapter) 471 return -ENOMEM; 472 473 ccw_device->handler = NULL; 474 adapter->ccw_device = ccw_device; 475 atomic_set(&adapter->refcount, 0); 476 477 if (zfcp_qdio_allocate(adapter)) 478 goto qdio_allocate_failed; 479 480 if (zfcp_allocate_low_mem_buffers(adapter)) 481 goto failed_low_mem_buffers; 482 483 if (zfcp_reqlist_alloc(adapter)) 484 goto failed_low_mem_buffers; 485 486 if (zfcp_adapter_debug_register(adapter)) 487 goto debug_register_failed; 488 489 init_waitqueue_head(&adapter->remove_wq); 490 init_waitqueue_head(&adapter->erp_thread_wqh); 491 init_waitqueue_head(&adapter->erp_done_wqh); 492 493 INIT_LIST_HEAD(&adapter->port_list_head); 494 INIT_LIST_HEAD(&adapter->erp_ready_head); 495 INIT_LIST_HEAD(&adapter->erp_running_head); 496 497 spin_lock_init(&adapter->req_list_lock); 498 499 spin_lock_init(&adapter->hba_dbf_lock); 500 spin_lock_init(&adapter->san_dbf_lock); 501 spin_lock_init(&adapter->scsi_dbf_lock); 502 spin_lock_init(&adapter->rec_dbf_lock); 503 spin_lock_init(&adapter->req_q_lock); 504 spin_lock_init(&adapter->qdio_stat_lock); 505 506 rwlock_init(&adapter->erp_lock); 507 rwlock_init(&adapter->abort_lock); 508 509 sema_init(&adapter->erp_ready_sem, 0); 510 511 INIT_WORK(&adapter->stat_work, _zfcp_status_read_scheduler); 512 INIT_WORK(&adapter->scan_work, _zfcp_scan_ports_later); 513 514 adapter->service_level.seq_print = zfcp_print_sl; 515 516 /* mark adapter unusable as long as sysfs registration is not complete */ 517 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status); 518 519 dev_set_drvdata(&ccw_device->dev, adapter); 520 521 if (sysfs_create_group(&ccw_device->dev.kobj, 522 &zfcp_sysfs_adapter_attrs)) 523 goto sysfs_failed; 524 525 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status); 526 527 zfcp_fc_nameserver_init(adapter); 528 529 if (!zfcp_adapter_scsi_register(adapter)) 530 return 0; 531 532 sysfs_failed: 533 zfcp_adapter_debug_unregister(adapter); 534 debug_register_failed: 535 dev_set_drvdata(&ccw_device->dev, NULL); 536 kfree(adapter->req_list); 537 failed_low_mem_buffers: 538 zfcp_free_low_mem_buffers(adapter); 539 qdio_allocate_failed: 540 zfcp_qdio_free(adapter); 541 kfree(adapter); 542 return -ENOMEM; 543 } 544 545 /** 546 * zfcp_adapter_dequeue - remove the adapter from the resource list 547 * @adapter: pointer to struct zfcp_adapter which should be removed 548 * locks: adapter list write lock is assumed to be held by caller 549 */ 550 void zfcp_adapter_dequeue(struct zfcp_adapter *adapter) 551 { 552 int retval = 0; 553 unsigned long flags; 554 555 cancel_work_sync(&adapter->scan_work); 556 cancel_work_sync(&adapter->stat_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 port->rport->dd_data = NULL; 675 zfcp_adapter_put(port->adapter); 676 sysfs_remove_group(&port->sysfs_device.kobj, &zfcp_sysfs_port_attrs); 677 device_unregister(&port->sysfs_device); 678 } 679 680 /** 681 * zfcp_sg_free_table - free memory used by scatterlists 682 * @sg: pointer to scatterlist 683 * @count: number of scatterlist which are to be free'ed 684 * the scatterlist are expected to reference pages always 685 */ 686 void zfcp_sg_free_table(struct scatterlist *sg, int count) 687 { 688 int i; 689 690 for (i = 0; i < count; i++, sg++) 691 if (sg) 692 free_page((unsigned long) sg_virt(sg)); 693 else 694 break; 695 } 696 697 /** 698 * zfcp_sg_setup_table - init scatterlist and allocate, assign buffers 699 * @sg: pointer to struct scatterlist 700 * @count: number of scatterlists which should be assigned with buffers 701 * of size page 702 * 703 * Returns: 0 on success, -ENOMEM otherwise 704 */ 705 int zfcp_sg_setup_table(struct scatterlist *sg, int count) 706 { 707 void *addr; 708 int i; 709 710 sg_init_table(sg, count); 711 for (i = 0; i < count; i++, sg++) { 712 addr = (void *) get_zeroed_page(GFP_KERNEL); 713 if (!addr) { 714 zfcp_sg_free_table(sg, i); 715 return -ENOMEM; 716 } 717 sg_set_buf(sg, addr, PAGE_SIZE); 718 } 719 return 0; 720 } 721