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: Parse error for device parameter string %s, "
104 "device not attached.\n", devstr
);
108 static struct zfcp_adapter
*zfcp_get_adapter_by_busid(char *bus_id
)
110 struct zfcp_adapter
*adapter
;
112 list_for_each_entry(adapter
, &zfcp_data
.adapter_list_head
, list
)
113 if ((strncmp(bus_id
, adapter
->ccw_device
->dev
.bus_id
,
114 BUS_ID_SIZE
) == 0) &&
115 !(atomic_read(&adapter
->status
) &
116 ZFCP_STATUS_COMMON_REMOVE
))
121 static void __init
zfcp_init_device_configure(void)
123 struct zfcp_adapter
*adapter
;
124 struct zfcp_port
*port
;
125 struct zfcp_unit
*unit
;
127 down(&zfcp_data
.config_sema
);
128 read_lock_irq(&zfcp_data
.config_lock
);
129 adapter
= zfcp_get_adapter_by_busid(zfcp_data
.init_busid
);
131 zfcp_adapter_get(adapter
);
132 read_unlock_irq(&zfcp_data
.config_lock
);
136 port
= zfcp_port_enqueue(adapter
, zfcp_data
.init_wwpn
, 0, 0);
139 unit
= zfcp_unit_enqueue(port
, zfcp_data
.init_fcp_lun
);
142 up(&zfcp_data
.config_sema
);
143 ccw_device_set_online(adapter
->ccw_device
);
144 zfcp_erp_wait(adapter
);
145 down(&zfcp_data
.config_sema
);
150 zfcp_adapter_put(adapter
);
152 up(&zfcp_data
.config_sema
);
156 static struct kmem_cache
*zfcp_cache_create(int size
, char *name
)
159 while ((size
- align
) > 0)
161 return kmem_cache_create(name
, size
, align
, 0, NULL
);
164 static int __init
zfcp_module_init(void)
166 int retval
= -ENOMEM
;
168 zfcp_data
.fsf_req_qtcb_cache
= zfcp_cache_create(
169 sizeof(struct zfcp_fsf_req_qtcb
), "zfcp_fsf");
170 if (!zfcp_data
.fsf_req_qtcb_cache
)
173 zfcp_data
.sr_buffer_cache
= zfcp_cache_create(
174 sizeof(struct fsf_status_read_buffer
), "zfcp_sr");
175 if (!zfcp_data
.sr_buffer_cache
)
178 zfcp_data
.gid_pn_cache
= zfcp_cache_create(
179 sizeof(struct zfcp_gid_pn_data
), "zfcp_gid");
180 if (!zfcp_data
.gid_pn_cache
)
183 INIT_LIST_HEAD(&zfcp_data
.adapter_list_head
);
184 INIT_LIST_HEAD(&zfcp_data
.adapter_remove_lh
);
186 sema_init(&zfcp_data
.config_sema
, 1);
187 rwlock_init(&zfcp_data
.config_lock
);
189 zfcp_data
.scsi_transport_template
=
190 fc_attach_transport(&zfcp_transport_functions
);
191 if (!zfcp_data
.scsi_transport_template
)
194 retval
= misc_register(&zfcp_cfdc_misc
);
196 pr_err("zfcp: registration of misc device zfcp_cfdc failed\n");
200 retval
= zfcp_ccw_register();
202 pr_err("zfcp: Registration with common I/O layer failed.\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
)))
266 * zfcp_unit_enqueue - enqueue unit to unit list of a port.
267 * @port: pointer to port where unit is added
268 * @fcp_lun: FCP LUN of unit to be enqueued
269 * Returns: pointer to enqueued unit on success, ERR_PTR on error
270 * Locks: config_sema must be held to serialize changes to the unit list
272 * Sets up some unit internal structures and creates sysfs entry.
274 struct zfcp_unit
*zfcp_unit_enqueue(struct zfcp_port
*port
, fcp_lun_t fcp_lun
)
276 struct zfcp_unit
*unit
;
278 unit
= kzalloc(sizeof(struct zfcp_unit
), GFP_KERNEL
);
280 return ERR_PTR(-ENOMEM
);
282 atomic_set(&unit
->refcount
, 0);
283 init_waitqueue_head(&unit
->remove_wq
);
286 unit
->fcp_lun
= fcp_lun
;
288 snprintf(unit
->sysfs_device
.bus_id
, BUS_ID_SIZE
, "0x%016llx", fcp_lun
);
289 unit
->sysfs_device
.parent
= &port
->sysfs_device
;
290 unit
->sysfs_device
.release
= zfcp_sysfs_unit_release
;
291 dev_set_drvdata(&unit
->sysfs_device
, unit
);
293 /* mark unit unusable as long as sysfs registration is not complete */
294 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE
, &unit
->status
);
296 spin_lock_init(&unit
->latencies
.lock
);
297 unit
->latencies
.write
.channel
.min
= 0xFFFFFFFF;
298 unit
->latencies
.write
.fabric
.min
= 0xFFFFFFFF;
299 unit
->latencies
.read
.channel
.min
= 0xFFFFFFFF;
300 unit
->latencies
.read
.fabric
.min
= 0xFFFFFFFF;
301 unit
->latencies
.cmd
.channel
.min
= 0xFFFFFFFF;
302 unit
->latencies
.cmd
.fabric
.min
= 0xFFFFFFFF;
304 read_lock_irq(&zfcp_data
.config_lock
);
305 if (zfcp_get_unit_by_lun(port
, fcp_lun
)) {
306 read_unlock_irq(&zfcp_data
.config_lock
);
309 read_unlock_irq(&zfcp_data
.config_lock
);
311 if (device_register(&unit
->sysfs_device
))
314 if (zfcp_sysfs_unit_create_files(&unit
->sysfs_device
)) {
315 device_unregister(&unit
->sysfs_device
);
316 return ERR_PTR(-EIO
);
320 unit
->scsi_lun
= scsilun_to_int((struct scsi_lun
*)&unit
->fcp_lun
);
322 write_lock_irq(&zfcp_data
.config_lock
);
323 list_add_tail(&unit
->list
, &port
->unit_list_head
);
324 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE
, &unit
->status
);
325 atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING
, &unit
->status
);
327 write_unlock_irq(&zfcp_data
.config_lock
);
336 return ERR_PTR(-EINVAL
);
340 * zfcp_unit_dequeue - dequeue unit
341 * @unit: pointer to zfcp_unit
343 * waits until all work is done on unit and removes it then from the unit->list
344 * of the associated port.
346 void zfcp_unit_dequeue(struct zfcp_unit
*unit
)
348 zfcp_unit_wait(unit
);
349 write_lock_irq(&zfcp_data
.config_lock
);
350 list_del(&unit
->list
);
351 write_unlock_irq(&zfcp_data
.config_lock
);
353 zfcp_port_put(unit
->port
);
354 zfcp_sysfs_unit_remove_files(&unit
->sysfs_device
);
355 device_unregister(&unit
->sysfs_device
);
358 static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter
*adapter
)
360 /* must only be called with zfcp_data.config_sema taken */
361 adapter
->pool
.fsf_req_erp
=
362 mempool_create_slab_pool(1, zfcp_data
.fsf_req_qtcb_cache
);
363 if (!adapter
->pool
.fsf_req_erp
)
366 adapter
->pool
.fsf_req_scsi
=
367 mempool_create_slab_pool(1, zfcp_data
.fsf_req_qtcb_cache
);
368 if (!adapter
->pool
.fsf_req_scsi
)
371 adapter
->pool
.fsf_req_abort
=
372 mempool_create_slab_pool(1, zfcp_data
.fsf_req_qtcb_cache
);
373 if (!adapter
->pool
.fsf_req_abort
)
376 adapter
->pool
.fsf_req_status_read
=
377 mempool_create_kmalloc_pool(FSF_STATUS_READS_RECOM
,
378 sizeof(struct zfcp_fsf_req
));
379 if (!adapter
->pool
.fsf_req_status_read
)
382 adapter
->pool
.data_status_read
=
383 mempool_create_slab_pool(FSF_STATUS_READS_RECOM
,
384 zfcp_data
.sr_buffer_cache
);
385 if (!adapter
->pool
.data_status_read
)
388 adapter
->pool
.data_gid_pn
=
389 mempool_create_slab_pool(1, zfcp_data
.gid_pn_cache
);
390 if (!adapter
->pool
.data_gid_pn
)
396 static void zfcp_free_low_mem_buffers(struct zfcp_adapter
*adapter
)
398 /* zfcp_data.config_sema must be held */
399 if (adapter
->pool
.fsf_req_erp
)
400 mempool_destroy(adapter
->pool
.fsf_req_erp
);
401 if (adapter
->pool
.fsf_req_scsi
)
402 mempool_destroy(adapter
->pool
.fsf_req_scsi
);
403 if (adapter
->pool
.fsf_req_abort
)
404 mempool_destroy(adapter
->pool
.fsf_req_abort
);
405 if (adapter
->pool
.fsf_req_status_read
)
406 mempool_destroy(adapter
->pool
.fsf_req_status_read
);
407 if (adapter
->pool
.data_status_read
)
408 mempool_destroy(adapter
->pool
.data_status_read
);
409 if (adapter
->pool
.data_gid_pn
)
410 mempool_destroy(adapter
->pool
.data_gid_pn
);
413 static void zfcp_dummy_release(struct device
*dev
)
419 * zfcp_status_read_refill - refill the long running status_read_requests
420 * @adapter: ptr to struct zfcp_adapter for which the buffers should be refilled
422 * Returns: 0 on success, 1 otherwise
424 * if there are 16 or more status_read requests missing an adapter_reopen
427 int zfcp_status_read_refill(struct zfcp_adapter
*adapter
)
429 while (atomic_read(&adapter
->stat_miss
) > 0)
430 if (zfcp_fsf_status_read(adapter
, ZFCP_WAIT_FOR_SBAL
)) {
431 if (atomic_read(&adapter
->stat_miss
) >= 16) {
432 zfcp_erp_adapter_reopen(adapter
, 0, 103, NULL
);
437 atomic_dec(&adapter
->stat_miss
);
441 static void _zfcp_status_read_scheduler(struct work_struct
*work
)
443 zfcp_status_read_refill(container_of(work
, struct zfcp_adapter
,
447 static int zfcp_nameserver_enqueue(struct zfcp_adapter
*adapter
)
449 struct zfcp_port
*port
;
451 port
= zfcp_port_enqueue(adapter
, 0, ZFCP_STATUS_PORT_WKA
,
452 ZFCP_DID_DIRECTORY_SERVICE
);
454 return PTR_ERR(port
);
461 * zfcp_adapter_enqueue - enqueue a new adapter to the list
462 * @ccw_device: pointer to the struct cc_device
464 * Returns: 0 if a new adapter was successfully enqueued
465 * -ENOMEM if alloc failed
466 * Enqueues an adapter at the end of the adapter list in the driver data.
467 * All adapter internal structures are set up.
468 * Proc-fs entries are also created.
469 * locks: config_sema must be held to serialise changes to the adapter list
471 int zfcp_adapter_enqueue(struct ccw_device
*ccw_device
)
473 struct zfcp_adapter
*adapter
;
476 * Note: It is safe to release the list_lock, as any list changes
477 * are protected by the config_sema, which must be held to get here
480 adapter
= kzalloc(sizeof(struct zfcp_adapter
), GFP_KERNEL
);
484 ccw_device
->handler
= NULL
;
485 adapter
->ccw_device
= ccw_device
;
486 atomic_set(&adapter
->refcount
, 0);
488 if (zfcp_qdio_allocate(adapter
))
489 goto qdio_allocate_failed
;
491 if (zfcp_allocate_low_mem_buffers(adapter
))
492 goto failed_low_mem_buffers
;
494 if (zfcp_reqlist_alloc(adapter
))
495 goto failed_low_mem_buffers
;
497 if (zfcp_adapter_debug_register(adapter
))
498 goto debug_register_failed
;
500 init_waitqueue_head(&adapter
->remove_wq
);
501 init_waitqueue_head(&adapter
->erp_thread_wqh
);
502 init_waitqueue_head(&adapter
->erp_done_wqh
);
504 INIT_LIST_HEAD(&adapter
->port_list_head
);
505 INIT_LIST_HEAD(&adapter
->port_remove_lh
);
506 INIT_LIST_HEAD(&adapter
->erp_ready_head
);
507 INIT_LIST_HEAD(&adapter
->erp_running_head
);
509 spin_lock_init(&adapter
->req_list_lock
);
511 spin_lock_init(&adapter
->hba_dbf_lock
);
512 spin_lock_init(&adapter
->san_dbf_lock
);
513 spin_lock_init(&adapter
->scsi_dbf_lock
);
514 spin_lock_init(&adapter
->rec_dbf_lock
);
516 rwlock_init(&adapter
->erp_lock
);
517 rwlock_init(&adapter
->abort_lock
);
518 rwlock_init(&adapter
->req_q
.lock
);
520 sema_init(&adapter
->erp_ready_sem
, 0);
522 INIT_WORK(&adapter
->stat_work
, _zfcp_status_read_scheduler
);
523 INIT_WORK(&adapter
->scan_work
, _zfcp_scan_ports_later
);
525 /* mark adapter unusable as long as sysfs registration is not complete */
526 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE
, &adapter
->status
);
528 dev_set_drvdata(&ccw_device
->dev
, adapter
);
530 if (zfcp_sysfs_adapter_create_files(&ccw_device
->dev
))
533 adapter
->generic_services
.parent
= &adapter
->ccw_device
->dev
;
534 adapter
->generic_services
.release
= zfcp_dummy_release
;
535 snprintf(adapter
->generic_services
.bus_id
, BUS_ID_SIZE
,
538 if (device_register(&adapter
->generic_services
))
539 goto generic_services_failed
;
541 write_lock_irq(&zfcp_data
.config_lock
);
542 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE
, &adapter
->status
);
543 list_add_tail(&adapter
->list
, &zfcp_data
.adapter_list_head
);
544 write_unlock_irq(&zfcp_data
.config_lock
);
546 zfcp_data
.adapters
++;
548 zfcp_nameserver_enqueue(adapter
);
552 generic_services_failed
:
553 zfcp_sysfs_adapter_remove_files(&adapter
->ccw_device
->dev
);
555 zfcp_adapter_debug_unregister(adapter
);
556 debug_register_failed
:
557 dev_set_drvdata(&ccw_device
->dev
, NULL
);
558 kfree(adapter
->req_list
);
559 failed_low_mem_buffers
:
560 zfcp_free_low_mem_buffers(adapter
);
561 qdio_allocate_failed
:
562 zfcp_qdio_free(adapter
);
568 * zfcp_adapter_dequeue - remove the adapter from the resource list
569 * @adapter: pointer to struct zfcp_adapter which should be removed
570 * locks: adapter list write lock is assumed to be held by caller
572 void zfcp_adapter_dequeue(struct zfcp_adapter
*adapter
)
577 cancel_work_sync(&adapter
->scan_work
);
578 cancel_work_sync(&adapter
->stat_work
);
579 zfcp_adapter_scsi_unregister(adapter
);
580 device_unregister(&adapter
->generic_services
);
581 zfcp_sysfs_adapter_remove_files(&adapter
->ccw_device
->dev
);
582 dev_set_drvdata(&adapter
->ccw_device
->dev
, NULL
);
583 /* sanity check: no pending FSF requests */
584 spin_lock_irqsave(&adapter
->req_list_lock
, flags
);
585 retval
= zfcp_reqlist_isempty(adapter
);
586 spin_unlock_irqrestore(&adapter
->req_list_lock
, flags
);
590 zfcp_adapter_debug_unregister(adapter
);
592 /* remove specified adapter data structure from list */
593 write_lock_irq(&zfcp_data
.config_lock
);
594 list_del(&adapter
->list
);
595 write_unlock_irq(&zfcp_data
.config_lock
);
597 /* decrease number of adapters in list */
598 zfcp_data
.adapters
--;
600 zfcp_qdio_free(adapter
);
602 zfcp_free_low_mem_buffers(adapter
);
603 kfree(adapter
->req_list
);
604 kfree(adapter
->fc_stats
);
605 kfree(adapter
->stats_reset_data
);
610 * zfcp_port_enqueue - enqueue port to port list of adapter
611 * @adapter: adapter where remote port is added
612 * @wwpn: WWPN of the remote port to be enqueued
613 * @status: initial status for the port
614 * @d_id: destination id of the remote port to be enqueued
615 * Returns: pointer to enqueued port on success, ERR_PTR on error
616 * Locks: config_sema must be held to serialize changes to the port list
618 * All port internal structures are set up and the sysfs entry is generated.
619 * d_id is used to enqueue ports with a well known address like the Directory
620 * Service for nameserver lookup.
622 struct zfcp_port
*zfcp_port_enqueue(struct zfcp_adapter
*adapter
, wwn_t wwpn
,
623 u32 status
, u32 d_id
)
625 struct zfcp_port
*port
;
628 port
= kzalloc(sizeof(struct zfcp_port
), GFP_KERNEL
);
630 return ERR_PTR(-ENOMEM
);
632 init_waitqueue_head(&port
->remove_wq
);
634 INIT_LIST_HEAD(&port
->unit_list_head
);
635 INIT_LIST_HEAD(&port
->unit_remove_lh
);
637 port
->adapter
= adapter
;
641 /* mark port unusable as long as sysfs registration is not complete */
642 atomic_set_mask(status
| ZFCP_STATUS_COMMON_REMOVE
, &port
->status
);
643 atomic_set(&port
->refcount
, 0);
645 if (status
& ZFCP_STATUS_PORT_WKA
) {
647 case ZFCP_DID_DIRECTORY_SERVICE
:
648 bus_id
= "directory";
650 case ZFCP_DID_MANAGEMENT_SERVICE
:
651 bus_id
= "management";
653 case ZFCP_DID_KEY_DISTRIBUTION_SERVICE
:
654 bus_id
= "key_distribution";
656 case ZFCP_DID_ALIAS_SERVICE
:
659 case ZFCP_DID_TIME_SERVICE
:
664 return ERR_PTR(-EINVAL
);
666 snprintf(port
->sysfs_device
.bus_id
, BUS_ID_SIZE
, "%s", bus_id
);
667 port
->sysfs_device
.parent
= &adapter
->generic_services
;
669 snprintf(port
->sysfs_device
.bus_id
,
670 BUS_ID_SIZE
, "0x%016llx", wwpn
);
671 port
->sysfs_device
.parent
= &adapter
->ccw_device
->dev
;
674 port
->sysfs_device
.release
= zfcp_sysfs_port_release
;
675 dev_set_drvdata(&port
->sysfs_device
, port
);
677 read_lock_irq(&zfcp_data
.config_lock
);
678 if (!(status
& ZFCP_STATUS_PORT_NO_WWPN
))
679 if (zfcp_get_port_by_wwpn(adapter
, wwpn
)) {
680 read_unlock_irq(&zfcp_data
.config_lock
);
683 read_unlock_irq(&zfcp_data
.config_lock
);
685 if (device_register(&port
->sysfs_device
))
688 if (zfcp_sysfs_port_create_files(&port
->sysfs_device
, status
)) {
689 device_unregister(&port
->sysfs_device
);
695 write_lock_irq(&zfcp_data
.config_lock
);
696 list_add_tail(&port
->list
, &adapter
->port_list_head
);
697 atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE
, &port
->status
);
698 atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING
, &port
->status
);
699 if (d_id
== ZFCP_DID_DIRECTORY_SERVICE
)
700 if (!adapter
->nameserver_port
)
701 adapter
->nameserver_port
= port
;
704 write_unlock_irq(&zfcp_data
.config_lock
);
706 zfcp_adapter_get(adapter
);
712 return ERR_PTR(-EINVAL
);
716 * zfcp_port_dequeue - dequeues a port from the port list of the adapter
717 * @port: pointer to struct zfcp_port which should be removed
719 void zfcp_port_dequeue(struct zfcp_port
*port
)
721 zfcp_port_wait(port
);
722 write_lock_irq(&zfcp_data
.config_lock
);
723 list_del(&port
->list
);
724 port
->adapter
->ports
--;
725 write_unlock_irq(&zfcp_data
.config_lock
);
727 fc_remote_port_delete(port
->rport
);
729 zfcp_adapter_put(port
->adapter
);
730 zfcp_sysfs_port_remove_files(&port
->sysfs_device
,
731 atomic_read(&port
->status
));
732 device_unregister(&port
->sysfs_device
);
736 * zfcp_sg_free_table - free memory used by scatterlists
737 * @sg: pointer to scatterlist
738 * @count: number of scatterlist which are to be free'ed
739 * the scatterlist are expected to reference pages always
741 void zfcp_sg_free_table(struct scatterlist
*sg
, int count
)
745 for (i
= 0; i
< count
; i
++, sg
++)
747 free_page((unsigned long) sg_virt(sg
));
753 * zfcp_sg_setup_table - init scatterlist and allocate, assign buffers
754 * @sg: pointer to struct scatterlist
755 * @count: number of scatterlists which should be assigned with buffers
758 * Returns: 0 on success, -ENOMEM otherwise
760 int zfcp_sg_setup_table(struct scatterlist
*sg
, int count
)
765 sg_init_table(sg
, count
);
766 for (i
= 0; i
< count
; i
++, sg
++) {
767 addr
= (void *) get_zeroed_page(GFP_KERNEL
);
769 zfcp_sg_free_table(sg
, i
);
772 sg_set_buf(sg
, addr
, PAGE_SIZE
);