4 * Module interface and handling of zfcp data structures.
6 * Copyright IBM Corporation 2002, 2008
11 * Martin Peschke (originator of the driver)
16 * Heiko Carstens (kernel 2.6 port of the driver)
28 #include <linux/miscdevice.h>
33 MODULE_AUTHOR("IBM Deutschland Entwicklung GmbH - linux390@de.ibm.com");
34 MODULE_DESCRIPTION("FCP HBA driver");
35 MODULE_LICENSE("GPL");
37 module_param(device
, charp
, 0400);
38 MODULE_PARM_DESC(device
, "specify initial device");
40 static int zfcp_reqlist_alloc(struct zfcp_adapter
*adapter
)
44 adapter
->req_list
= kcalloc(REQUEST_LIST_SIZE
, sizeof(struct list_head
),
46 if (!adapter
->req_list
)
49 for (idx
= 0; idx
< REQUEST_LIST_SIZE
; idx
++)
50 INIT_LIST_HEAD(&adapter
->req_list
[idx
]);
55 * zfcp_reqlist_isempty - is the request list empty
56 * @adapter: pointer to struct zfcp_adapter
58 * Returns: true if list is empty, false otherwise
60 int zfcp_reqlist_isempty(struct zfcp_adapter
*adapter
)
64 for (idx
= 0; idx
< REQUEST_LIST_SIZE
; idx
++)
65 if (!list_empty(&adapter
->req_list
[idx
]))
70 static int __init
zfcp_device_setup(char *devstr
)
78 /* duplicate devstr and keep the original for sysfs presentation*/
79 str
= kmalloc(strlen(devstr
) + 1, GFP_KERNEL
);
85 token
= strsep(&str
, ",");
86 if (!token
|| strlen(token
) >= BUS_ID_SIZE
)
88 strncpy(zfcp_data
.init_busid
, token
, BUS_ID_SIZE
);
90 token
= strsep(&str
, ",");
91 if (!token
|| strict_strtoull(token
, 0, &zfcp_data
.init_wwpn
))
94 token
= strsep(&str
, ",");
95 if (!token
|| strict_strtoull(token
, 0, &zfcp_data
.init_fcp_lun
))
103 pr_err("zfcp: %s is not a valid SCSI device\n", devstr
);
107 static struct zfcp_adapter
*zfcp_get_adapter_by_busid(char *bus_id
)
109 struct zfcp_adapter
*adapter
;
111 list_for_each_entry(adapter
, &zfcp_data
.adapter_list_head
, list
)
112 if ((strncmp(bus_id
, adapter
->ccw_device
->dev
.bus_id
,
113 BUS_ID_SIZE
) == 0) &&
114 !(atomic_read(&adapter
->status
) &
115 ZFCP_STATUS_COMMON_REMOVE
))
120 static void __init
zfcp_init_device_configure(void)
122 struct zfcp_adapter
*adapter
;
123 struct zfcp_port
*port
;
124 struct zfcp_unit
*unit
;
126 down(&zfcp_data
.config_sema
);
127 read_lock_irq(&zfcp_data
.config_lock
);
128 adapter
= zfcp_get_adapter_by_busid(zfcp_data
.init_busid
);
130 zfcp_adapter_get(adapter
);
131 read_unlock_irq(&zfcp_data
.config_lock
);
135 port
= zfcp_port_enqueue(adapter
, zfcp_data
.init_wwpn
, 0, 0);
138 unit
= zfcp_unit_enqueue(port
, zfcp_data
.init_fcp_lun
);
141 up(&zfcp_data
.config_sema
);
142 ccw_device_set_online(adapter
->ccw_device
);
143 zfcp_erp_wait(adapter
);
144 down(&zfcp_data
.config_sema
);
149 zfcp_adapter_put(adapter
);
151 up(&zfcp_data
.config_sema
);
155 static struct kmem_cache
*zfcp_cache_create(int size
, char *name
)
158 while ((size
- align
) > 0)
160 return kmem_cache_create(name
, size
, align
, 0, NULL
);
163 static int __init
zfcp_module_init(void)
165 int retval
= -ENOMEM
;
167 zfcp_data
.fsf_req_qtcb_cache
= zfcp_cache_create(
168 sizeof(struct zfcp_fsf_req_qtcb
), "zfcp_fsf");
169 if (!zfcp_data
.fsf_req_qtcb_cache
)
172 zfcp_data
.sr_buffer_cache
= zfcp_cache_create(
173 sizeof(struct fsf_status_read_buffer
), "zfcp_sr");
174 if (!zfcp_data
.sr_buffer_cache
)
177 zfcp_data
.gid_pn_cache
= zfcp_cache_create(
178 sizeof(struct zfcp_gid_pn_data
), "zfcp_gid");
179 if (!zfcp_data
.gid_pn_cache
)
182 INIT_LIST_HEAD(&zfcp_data
.adapter_list_head
);
183 INIT_LIST_HEAD(&zfcp_data
.adapter_remove_lh
);
185 sema_init(&zfcp_data
.config_sema
, 1);
186 rwlock_init(&zfcp_data
.config_lock
);
188 zfcp_data
.scsi_transport_template
=
189 fc_attach_transport(&zfcp_transport_functions
);
190 if (!zfcp_data
.scsi_transport_template
)
193 retval
= misc_register(&zfcp_cfdc_misc
);
195 pr_err("zfcp: Registering the misc device zfcp_cfdc failed\n");
199 retval
= zfcp_ccw_register();
201 pr_err("zfcp: The zfcp device driver could not register with "
202 "the common I/O layer\n");
203 goto out_ccw_register
;
206 if (zfcp_device_setup(device
))
207 zfcp_init_device_configure();
212 misc_deregister(&zfcp_cfdc_misc
);
214 fc_release_transport(zfcp_data
.scsi_transport_template
);
216 kmem_cache_destroy(zfcp_data
.gid_pn_cache
);
218 kmem_cache_destroy(zfcp_data
.sr_buffer_cache
);
220 kmem_cache_destroy(zfcp_data
.fsf_req_qtcb_cache
);
225 module_init(zfcp_module_init
);
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
232 * Returns: pointer to zfcp_unit or NULL
234 struct zfcp_unit
*zfcp_get_unit_by_lun(struct zfcp_port
*port
,
237 struct zfcp_unit
*unit
;
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
))
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
251 * Returns: pointer to zfcp_port or NULL
253 struct zfcp_port
*zfcp_get_port_by_wwpn(struct zfcp_adapter
*adapter
,
256 struct zfcp_port
*port
;
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
)))
265 static void zfcp_sysfs_unit_release(struct device
*dev
)
267 kfree(container_of(dev
, struct zfcp_unit
, sysfs_device
));
271 * zfcp_unit_enqueue - enqueue unit to unit list of a port.
272 * @port: pointer to port where unit is added
273 * @fcp_lun: FCP LUN of unit to be enqueued
274 * Returns: pointer to enqueued unit on success, ERR_PTR on error
275 * Locks: config_sema must be held to serialize changes to the unit list
277 * Sets up some unit internal structures and creates sysfs entry.
279 struct zfcp_unit
*zfcp_unit_enqueue(struct zfcp_port
*port
, fcp_lun_t fcp_lun
)
281 struct zfcp_unit
*unit
;
283 unit
= kzalloc(sizeof(struct zfcp_unit
), GFP_KERNEL
);
285 return ERR_PTR(-ENOMEM
);
287 atomic_set(&unit
->refcount
, 0);
288 init_waitqueue_head(&unit
->remove_wq
);
291 unit
->fcp_lun
= fcp_lun
;
293 snprintf(unit
->sysfs_device
.bus_id
, BUS_ID_SIZE
, "0x%016llx", fcp_lun
);
294 unit
->sysfs_device
.parent
= &port
->sysfs_device
;
295 unit
->sysfs_device
.release
= zfcp_sysfs_unit_release
;
296 dev_set_drvdata(&unit
->sysfs_device
, unit
);
298 /* mark unit unusable as long as sysfs registration is not complete */
299 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE
, &unit
->status
);
301 spin_lock_init(&unit
->latencies
.lock
);
302 unit
->latencies
.write
.channel
.min
= 0xFFFFFFFF;
303 unit
->latencies
.write
.fabric
.min
= 0xFFFFFFFF;
304 unit
->latencies
.read
.channel
.min
= 0xFFFFFFFF;
305 unit
->latencies
.read
.fabric
.min
= 0xFFFFFFFF;
306 unit
->latencies
.cmd
.channel
.min
= 0xFFFFFFFF;
307 unit
->latencies
.cmd
.fabric
.min
= 0xFFFFFFFF;
309 read_lock_irq(&zfcp_data
.config_lock
);
310 if (zfcp_get_unit_by_lun(port
, fcp_lun
)) {
311 read_unlock_irq(&zfcp_data
.config_lock
);
314 read_unlock_irq(&zfcp_data
.config_lock
);
316 if (device_register(&unit
->sysfs_device
))
319 if (sysfs_create_group(&unit
->sysfs_device
.kobj
,
320 &zfcp_sysfs_unit_attrs
)) {
321 device_unregister(&unit
->sysfs_device
);
322 return ERR_PTR(-EIO
);
326 unit
->scsi_lun
= scsilun_to_int((struct scsi_lun
*)&unit
->fcp_lun
);
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
);
333 write_unlock_irq(&zfcp_data
.config_lock
);
342 return ERR_PTR(-EINVAL
);
346 * zfcp_unit_dequeue - dequeue unit
347 * @unit: pointer to zfcp_unit
349 * waits until all work is done on unit and removes it then from the unit->list
350 * of the associated port.
352 void zfcp_unit_dequeue(struct zfcp_unit
*unit
)
354 wait_event(unit
->remove_wq
, atomic_read(&unit
->refcount
) == 0);
355 write_lock_irq(&zfcp_data
.config_lock
);
356 list_del(&unit
->list
);
357 write_unlock_irq(&zfcp_data
.config_lock
);
359 zfcp_port_put(unit
->port
);
360 sysfs_remove_group(&unit
->sysfs_device
.kobj
, &zfcp_sysfs_unit_attrs
);
361 device_unregister(&unit
->sysfs_device
);
364 static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter
*adapter
)
366 /* must only be called with zfcp_data.config_sema taken */
367 adapter
->pool
.fsf_req_erp
=
368 mempool_create_slab_pool(1, zfcp_data
.fsf_req_qtcb_cache
);
369 if (!adapter
->pool
.fsf_req_erp
)
372 adapter
->pool
.fsf_req_scsi
=
373 mempool_create_slab_pool(1, zfcp_data
.fsf_req_qtcb_cache
);
374 if (!adapter
->pool
.fsf_req_scsi
)
377 adapter
->pool
.fsf_req_abort
=
378 mempool_create_slab_pool(1, zfcp_data
.fsf_req_qtcb_cache
);
379 if (!adapter
->pool
.fsf_req_abort
)
382 adapter
->pool
.fsf_req_status_read
=
383 mempool_create_kmalloc_pool(FSF_STATUS_READS_RECOM
,
384 sizeof(struct zfcp_fsf_req
));
385 if (!adapter
->pool
.fsf_req_status_read
)
388 adapter
->pool
.data_status_read
=
389 mempool_create_slab_pool(FSF_STATUS_READS_RECOM
,
390 zfcp_data
.sr_buffer_cache
);
391 if (!adapter
->pool
.data_status_read
)
394 adapter
->pool
.data_gid_pn
=
395 mempool_create_slab_pool(1, zfcp_data
.gid_pn_cache
);
396 if (!adapter
->pool
.data_gid_pn
)
402 static void zfcp_free_low_mem_buffers(struct zfcp_adapter
*adapter
)
404 /* zfcp_data.config_sema must be held */
405 if (adapter
->pool
.fsf_req_erp
)
406 mempool_destroy(adapter
->pool
.fsf_req_erp
);
407 if (adapter
->pool
.fsf_req_scsi
)
408 mempool_destroy(adapter
->pool
.fsf_req_scsi
);
409 if (adapter
->pool
.fsf_req_abort
)
410 mempool_destroy(adapter
->pool
.fsf_req_abort
);
411 if (adapter
->pool
.fsf_req_status_read
)
412 mempool_destroy(adapter
->pool
.fsf_req_status_read
);
413 if (adapter
->pool
.data_status_read
)
414 mempool_destroy(adapter
->pool
.data_status_read
);
415 if (adapter
->pool
.data_gid_pn
)
416 mempool_destroy(adapter
->pool
.data_gid_pn
);
419 static void zfcp_dummy_release(struct device
*dev
)
425 * zfcp_status_read_refill - refill the long running status_read_requests
426 * @adapter: ptr to struct zfcp_adapter for which the buffers should be refilled
428 * Returns: 0 on success, 1 otherwise
430 * if there are 16 or more status_read requests missing an adapter_reopen
433 int zfcp_status_read_refill(struct zfcp_adapter
*adapter
)
435 while (atomic_read(&adapter
->stat_miss
) > 0)
436 if (zfcp_fsf_status_read(adapter
)) {
437 if (atomic_read(&adapter
->stat_miss
) >= 16) {
438 zfcp_erp_adapter_reopen(adapter
, 0, 103, NULL
);
443 atomic_dec(&adapter
->stat_miss
);
447 static void _zfcp_status_read_scheduler(struct work_struct
*work
)
449 zfcp_status_read_refill(container_of(work
, struct zfcp_adapter
,
453 static int zfcp_nameserver_enqueue(struct zfcp_adapter
*adapter
)
455 struct zfcp_port
*port
;
457 port
= zfcp_port_enqueue(adapter
, 0, ZFCP_STATUS_PORT_WKA
,
458 ZFCP_DID_DIRECTORY_SERVICE
);
460 return PTR_ERR(port
);
467 * zfcp_adapter_enqueue - enqueue a new adapter to the list
468 * @ccw_device: pointer to the struct cc_device
470 * Returns: 0 if a new adapter was successfully enqueued
471 * -ENOMEM if alloc failed
472 * Enqueues an adapter at the end of the adapter list in the driver data.
473 * All adapter internal structures are set up.
474 * Proc-fs entries are also created.
475 * locks: config_sema must be held to serialise changes to the adapter list
477 int zfcp_adapter_enqueue(struct ccw_device
*ccw_device
)
479 struct zfcp_adapter
*adapter
;
482 * Note: It is safe to release the list_lock, as any list changes
483 * are protected by the config_sema, which must be held to get here
486 adapter
= kzalloc(sizeof(struct zfcp_adapter
), GFP_KERNEL
);
490 ccw_device
->handler
= NULL
;
491 adapter
->ccw_device
= ccw_device
;
492 atomic_set(&adapter
->refcount
, 0);
494 if (zfcp_qdio_allocate(adapter
))
495 goto qdio_allocate_failed
;
497 if (zfcp_allocate_low_mem_buffers(adapter
))
498 goto failed_low_mem_buffers
;
500 if (zfcp_reqlist_alloc(adapter
))
501 goto failed_low_mem_buffers
;
503 if (zfcp_adapter_debug_register(adapter
))
504 goto debug_register_failed
;
506 init_waitqueue_head(&adapter
->remove_wq
);
507 init_waitqueue_head(&adapter
->erp_thread_wqh
);
508 init_waitqueue_head(&adapter
->erp_done_wqh
);
510 INIT_LIST_HEAD(&adapter
->port_list_head
);
511 INIT_LIST_HEAD(&adapter
->port_remove_lh
);
512 INIT_LIST_HEAD(&adapter
->erp_ready_head
);
513 INIT_LIST_HEAD(&adapter
->erp_running_head
);
515 spin_lock_init(&adapter
->req_list_lock
);
517 spin_lock_init(&adapter
->hba_dbf_lock
);
518 spin_lock_init(&adapter
->san_dbf_lock
);
519 spin_lock_init(&adapter
->scsi_dbf_lock
);
520 spin_lock_init(&adapter
->rec_dbf_lock
);
521 spin_lock_init(&adapter
->req_q
.lock
);
523 rwlock_init(&adapter
->erp_lock
);
524 rwlock_init(&adapter
->abort_lock
);
526 sema_init(&adapter
->erp_ready_sem
, 0);
528 INIT_WORK(&adapter
->stat_work
, _zfcp_status_read_scheduler
);
529 INIT_WORK(&adapter
->scan_work
, _zfcp_scan_ports_later
);
531 /* mark adapter unusable as long as sysfs registration is not complete */
532 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE
, &adapter
->status
);
534 dev_set_drvdata(&ccw_device
->dev
, adapter
);
536 if (sysfs_create_group(&ccw_device
->dev
.kobj
,
537 &zfcp_sysfs_adapter_attrs
))
540 adapter
->generic_services
.parent
= &adapter
->ccw_device
->dev
;
541 adapter
->generic_services
.release
= zfcp_dummy_release
;
542 snprintf(adapter
->generic_services
.bus_id
, BUS_ID_SIZE
,
545 if (device_register(&adapter
->generic_services
))
546 goto generic_services_failed
;
548 write_lock_irq(&zfcp_data
.config_lock
);
549 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE
, &adapter
->status
);
550 list_add_tail(&adapter
->list
, &zfcp_data
.adapter_list_head
);
551 write_unlock_irq(&zfcp_data
.config_lock
);
553 zfcp_data
.adapters
++;
555 zfcp_nameserver_enqueue(adapter
);
559 generic_services_failed
:
560 sysfs_remove_group(&ccw_device
->dev
.kobj
,
561 &zfcp_sysfs_adapter_attrs
);
563 zfcp_adapter_debug_unregister(adapter
);
564 debug_register_failed
:
565 dev_set_drvdata(&ccw_device
->dev
, NULL
);
566 kfree(adapter
->req_list
);
567 failed_low_mem_buffers
:
568 zfcp_free_low_mem_buffers(adapter
);
569 qdio_allocate_failed
:
570 zfcp_qdio_free(adapter
);
576 * zfcp_adapter_dequeue - remove the adapter from the resource list
577 * @adapter: pointer to struct zfcp_adapter which should be removed
578 * locks: adapter list write lock is assumed to be held by caller
580 void zfcp_adapter_dequeue(struct zfcp_adapter
*adapter
)
585 cancel_work_sync(&adapter
->scan_work
);
586 cancel_work_sync(&adapter
->stat_work
);
587 zfcp_adapter_scsi_unregister(adapter
);
588 device_unregister(&adapter
->generic_services
);
589 sysfs_remove_group(&adapter
->ccw_device
->dev
.kobj
,
590 &zfcp_sysfs_adapter_attrs
);
591 dev_set_drvdata(&adapter
->ccw_device
->dev
, NULL
);
592 /* sanity check: no pending FSF requests */
593 spin_lock_irqsave(&adapter
->req_list_lock
, flags
);
594 retval
= zfcp_reqlist_isempty(adapter
);
595 spin_unlock_irqrestore(&adapter
->req_list_lock
, flags
);
599 zfcp_adapter_debug_unregister(adapter
);
601 /* remove specified adapter data structure from list */
602 write_lock_irq(&zfcp_data
.config_lock
);
603 list_del(&adapter
->list
);
604 write_unlock_irq(&zfcp_data
.config_lock
);
606 /* decrease number of adapters in list */
607 zfcp_data
.adapters
--;
609 zfcp_qdio_free(adapter
);
611 zfcp_free_low_mem_buffers(adapter
);
612 kfree(adapter
->req_list
);
613 kfree(adapter
->fc_stats
);
614 kfree(adapter
->stats_reset_data
);
618 static void zfcp_sysfs_port_release(struct device
*dev
)
620 kfree(container_of(dev
, struct zfcp_port
, sysfs_device
));
624 * zfcp_port_enqueue - enqueue port to port list of adapter
625 * @adapter: adapter where remote port is added
626 * @wwpn: WWPN of the remote port to be enqueued
627 * @status: initial status for the port
628 * @d_id: destination id of the remote port to be enqueued
629 * Returns: pointer to enqueued port on success, ERR_PTR on error
630 * Locks: config_sema must be held to serialize changes to the port list
632 * All port internal structures are set up and the sysfs entry is generated.
633 * d_id is used to enqueue ports with a well known address like the Directory
634 * Service for nameserver lookup.
636 struct zfcp_port
*zfcp_port_enqueue(struct zfcp_adapter
*adapter
, wwn_t wwpn
,
637 u32 status
, u32 d_id
)
639 struct zfcp_port
*port
;
643 port
= kzalloc(sizeof(struct zfcp_port
), GFP_KERNEL
);
645 return ERR_PTR(-ENOMEM
);
647 init_waitqueue_head(&port
->remove_wq
);
649 INIT_LIST_HEAD(&port
->unit_list_head
);
650 INIT_LIST_HEAD(&port
->unit_remove_lh
);
652 port
->adapter
= adapter
;
656 /* mark port unusable as long as sysfs registration is not complete */
657 atomic_set_mask(status
| ZFCP_STATUS_COMMON_REMOVE
, &port
->status
);
658 atomic_set(&port
->refcount
, 0);
660 if (status
& ZFCP_STATUS_PORT_WKA
) {
662 case ZFCP_DID_DIRECTORY_SERVICE
:
663 bus_id
= "directory";
665 case ZFCP_DID_MANAGEMENT_SERVICE
:
666 bus_id
= "management";
668 case ZFCP_DID_KEY_DISTRIBUTION_SERVICE
:
669 bus_id
= "key_distribution";
671 case ZFCP_DID_ALIAS_SERVICE
:
674 case ZFCP_DID_TIME_SERVICE
:
679 return ERR_PTR(-EINVAL
);
681 snprintf(port
->sysfs_device
.bus_id
, BUS_ID_SIZE
, "%s", bus_id
);
682 port
->sysfs_device
.parent
= &adapter
->generic_services
;
684 snprintf(port
->sysfs_device
.bus_id
,
685 BUS_ID_SIZE
, "0x%016llx", wwpn
);
686 port
->sysfs_device
.parent
= &adapter
->ccw_device
->dev
;
689 port
->sysfs_device
.release
= zfcp_sysfs_port_release
;
690 dev_set_drvdata(&port
->sysfs_device
, port
);
692 read_lock_irq(&zfcp_data
.config_lock
);
693 if (!(status
& ZFCP_STATUS_PORT_NO_WWPN
))
694 if (zfcp_get_port_by_wwpn(adapter
, wwpn
)) {
695 read_unlock_irq(&zfcp_data
.config_lock
);
698 read_unlock_irq(&zfcp_data
.config_lock
);
700 if (device_register(&port
->sysfs_device
))
703 if (status
& ZFCP_STATUS_PORT_WKA
)
704 retval
= sysfs_create_group(&port
->sysfs_device
.kobj
,
705 &zfcp_sysfs_ns_port_attrs
);
707 retval
= sysfs_create_group(&port
->sysfs_device
.kobj
,
708 &zfcp_sysfs_port_attrs
);
711 device_unregister(&port
->sysfs_device
);
717 write_lock_irq(&zfcp_data
.config_lock
);
718 list_add_tail(&port
->list
, &adapter
->port_list_head
);
719 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE
, &port
->status
);
720 atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING
, &port
->status
);
721 if (d_id
== ZFCP_DID_DIRECTORY_SERVICE
)
722 if (!adapter
->nameserver_port
)
723 adapter
->nameserver_port
= port
;
726 write_unlock_irq(&zfcp_data
.config_lock
);
728 zfcp_adapter_get(adapter
);
734 return ERR_PTR(-EINVAL
);
738 * zfcp_port_dequeue - dequeues a port from the port list of the adapter
739 * @port: pointer to struct zfcp_port which should be removed
741 void zfcp_port_dequeue(struct zfcp_port
*port
)
743 wait_event(port
->remove_wq
, atomic_read(&port
->refcount
) == 0);
744 write_lock_irq(&zfcp_data
.config_lock
);
745 list_del(&port
->list
);
746 port
->adapter
->ports
--;
747 write_unlock_irq(&zfcp_data
.config_lock
);
749 fc_remote_port_delete(port
->rport
);
751 zfcp_adapter_put(port
->adapter
);
752 if (atomic_read(&port
->status
) & ZFCP_STATUS_PORT_WKA
)
753 sysfs_remove_group(&port
->sysfs_device
.kobj
,
754 &zfcp_sysfs_ns_port_attrs
);
756 sysfs_remove_group(&port
->sysfs_device
.kobj
,
757 &zfcp_sysfs_port_attrs
);
758 device_unregister(&port
->sysfs_device
);
762 * zfcp_sg_free_table - free memory used by scatterlists
763 * @sg: pointer to scatterlist
764 * @count: number of scatterlist which are to be free'ed
765 * the scatterlist are expected to reference pages always
767 void zfcp_sg_free_table(struct scatterlist
*sg
, int count
)
771 for (i
= 0; i
< count
; i
++, sg
++)
773 free_page((unsigned long) sg_virt(sg
));
779 * zfcp_sg_setup_table - init scatterlist and allocate, assign buffers
780 * @sg: pointer to struct scatterlist
781 * @count: number of scatterlists which should be assigned with buffers
784 * Returns: 0 on success, -ENOMEM otherwise
786 int zfcp_sg_setup_table(struct scatterlist
*sg
, int count
)
791 sg_init_table(sg
, count
);
792 for (i
= 0; i
< count
; i
++, sg
++) {
793 addr
= (void *) get_zeroed_page(GFP_KERNEL
);
795 zfcp_sg_free_table(sg
, i
);
798 sg_set_buf(sg
, addr
, PAGE_SIZE
);