Merge branch 'wip-2.6.34' into old-private-masterarchived-private-master

1 files changed, 205 insertions, 240 deletions

diff --git a/drivers/s390/scsi/zfcp_aux.c b/drivers/s390/scsi/zfcp_aux.c
index 2889e5f2dfd3..1e6183a86ce5 100644
--- a/drivers/s390/scsi/zfcp_aux.c
+++ b/drivers/s390/scsi/zfcp_aux.c
@@ -3,7 +3,7 @@
  *
  * Module interface and handling of zfcp data structures.
  *
- * Copyright IBM Corporation 2002, 2009
+ * Copyright IBM Corporation 2002, 2010
  */
 
 /*
@@ -30,7 +30,10 @@
 
 #include <linux/miscdevice.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 #include "zfcp_ext.h"
+#include "zfcp_fc.h"
+#include "zfcp_reqlist.h"
 
 #define ZFCP_BUS_ID_SIZE        20
 
@@ -48,80 +51,42 @@ static struct kmem_cache *zfcp_cache_hw_align(const char *name,
         return kmem_cache_create(name, size, roundup_pow_of_two(size), 0, NULL);
 }
 
-static int zfcp_reqlist_alloc(struct zfcp_adapter *adapter)
-{
-        int idx;
-
-        adapter->req_list = kcalloc(REQUEST_LIST_SIZE, sizeof(struct list_head),
-                                    GFP_KERNEL);
-        if (!adapter->req_list)
-                return -ENOMEM;
-
-        for (idx = 0; idx < REQUEST_LIST_SIZE; idx++)
-                INIT_LIST_HEAD(&adapter->req_list[idx]);
-        return 0;
-}
-
-/**
- * zfcp_reqlist_isempty - is the request list empty
- * @adapter: pointer to struct zfcp_adapter
- *
- * Returns: true if list is empty, false otherwise
- */
-int zfcp_reqlist_isempty(struct zfcp_adapter *adapter)
-{
-        unsigned int idx;
-
-        for (idx = 0; idx < REQUEST_LIST_SIZE; idx++)
-                if (!list_empty(&adapter->req_list[idx]))
-                        return 0;
-        return 1;
-}
-
 static void __init zfcp_init_device_configure(char *busid, u64 wwpn, u64 lun)
 {
-        struct ccw_device *ccwdev;
+        struct ccw_device *cdev;
         struct zfcp_adapter *adapter;
         struct zfcp_port *port;
         struct zfcp_unit *unit;
 
-        ccwdev = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
-        if (!ccwdev)
+        cdev = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
+        if (!cdev)
                 return;
 
-        if (ccw_device_set_online(ccwdev))
-                goto out_ccwdev;
+        if (ccw_device_set_online(cdev))
+                goto out_ccw_device;
 
-        mutex_lock(&zfcp_data.config_mutex);
-        adapter = dev_get_drvdata(&ccwdev->dev);
+        adapter = zfcp_ccw_adapter_by_cdev(cdev);
         if (!adapter)
-                goto out_unlock;
-        zfcp_adapter_get(adapter);
+                goto out_ccw_device;
 
         port = zfcp_get_port_by_wwpn(adapter, wwpn);
         if (!port)
                 goto out_port;
 
-        zfcp_port_get(port);
         unit = zfcp_unit_enqueue(port, lun);
         if (IS_ERR(unit))
                 goto out_unit;
-        mutex_unlock(&zfcp_data.config_mutex);
 
         zfcp_erp_unit_reopen(unit, 0, "auidc_1", NULL);
         zfcp_erp_wait(adapter);
         flush_work(&unit->scsi_work);
 
-        mutex_lock(&zfcp_data.config_mutex);
-        zfcp_unit_put(unit);
 out_unit:
-        zfcp_port_put(port);
+        put_device(&port->dev);
 out_port:
-        zfcp_adapter_put(adapter);
-out_unlock:
-        mutex_unlock(&zfcp_data.config_mutex);
-out_ccwdev:
-        put_device(&ccwdev->dev);
+        zfcp_ccw_adapter_put(adapter);
+out_ccw_device:
+        put_device(&cdev->dev);
         return;
 }
 
@@ -167,7 +132,7 @@ static int __init zfcp_module_init(void)
         int retval = -ENOMEM;
 
         zfcp_data.gpn_ft_cache = zfcp_cache_hw_align("zfcp_gpn",
-                                        sizeof(struct ct_iu_gpn_ft_req));
+                                        sizeof(struct zfcp_fc_gpn_ft_req));
         if (!zfcp_data.gpn_ft_cache)
                 goto out;
 
@@ -182,12 +147,14 @@ static int __init zfcp_module_init(void)
                 goto out_sr_cache;
 
         zfcp_data.gid_pn_cache = zfcp_cache_hw_align("zfcp_gid",
-                                        sizeof(struct zfcp_gid_pn_data));
+                                        sizeof(struct zfcp_fc_gid_pn));
         if (!zfcp_data.gid_pn_cache)
                 goto out_gid_cache;
 
-        mutex_init(&zfcp_data.config_mutex);
-        rwlock_init(&zfcp_data.config_lock);
+        zfcp_data.adisc_cache = zfcp_cache_hw_align("zfcp_adisc",
+                                        sizeof(struct zfcp_fc_els_adisc));
+        if (!zfcp_data.adisc_cache)
+                goto out_adisc_cache;
 
         zfcp_data.scsi_transport_template =
                 fc_attach_transport(&zfcp_transport_functions);
@@ -200,7 +167,7 @@ static int __init zfcp_module_init(void)
                 goto out_misc;
         }
 
-        retval = zfcp_ccw_register();
+        retval = ccw_driver_register(&zfcp_ccw_driver);
         if (retval) {
                 pr_err("The zfcp device driver could not register with "
                        "the common I/O layer\n");
@@ -216,6 +183,8 @@ out_ccw_register:
 out_misc:
         fc_release_transport(zfcp_data.scsi_transport_template);
 out_transport:
+        kmem_cache_destroy(zfcp_data.adisc_cache);
+out_adisc_cache:
         kmem_cache_destroy(zfcp_data.gid_pn_cache);
 out_gid_cache:
         kmem_cache_destroy(zfcp_data.sr_buffer_cache);
@@ -229,6 +198,20 @@ out:
 
 module_init(zfcp_module_init);
 
+static void __exit zfcp_module_exit(void)
+{
+        ccw_driver_unregister(&zfcp_ccw_driver);
+        misc_deregister(&zfcp_cfdc_misc);
+        fc_release_transport(zfcp_data.scsi_transport_template);
+        kmem_cache_destroy(zfcp_data.adisc_cache);
+        kmem_cache_destroy(zfcp_data.gid_pn_cache);
+        kmem_cache_destroy(zfcp_data.sr_buffer_cache);
+        kmem_cache_destroy(zfcp_data.qtcb_cache);
+        kmem_cache_destroy(zfcp_data.gpn_ft_cache);
+}
+
+module_exit(zfcp_module_exit);
+
 /**
  * zfcp_get_unit_by_lun - find unit in unit list of port by FCP LUN
  * @port: pointer to port to search for unit
@@ -238,12 +221,18 @@ module_init(zfcp_module_init);
  */
 struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *port, u64 fcp_lun)
 {
+        unsigned long flags;
         struct zfcp_unit *unit;
 
-        list_for_each_entry(unit, &port->unit_list_head, list)
-                if ((unit->fcp_lun == fcp_lun) &&
-                    !(atomic_read(&unit->status) & ZFCP_STATUS_COMMON_REMOVE))
-                    return unit;
+        read_lock_irqsave(&port->unit_list_lock, flags);
+        list_for_each_entry(unit, &port->unit_list, list)
+                if (unit->fcp_lun == fcp_lun) {
+                        if (!get_device(&unit->dev))
+                                unit = NULL;
+                        read_unlock_irqrestore(&port->unit_list_lock, flags);
+                        return unit;
+                }
+        read_unlock_irqrestore(&port->unit_list_lock, flags);
         return NULL;
 }
 
@@ -257,18 +246,34 @@ struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *port, u64 fcp_lun)
 struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter,
                                         u64 wwpn)
 {
+        unsigned long flags;
         struct zfcp_port *port;
 
-        list_for_each_entry(port, &adapter->port_list_head, list)
-                if ((port->wwpn == wwpn) &&
-                    !(atomic_read(&port->status) & ZFCP_STATUS_COMMON_REMOVE))
+        read_lock_irqsave(&adapter->port_list_lock, flags);
+        list_for_each_entry(port, &adapter->port_list, list)
+                if (port->wwpn == wwpn) {
+                        if (!get_device(&port->dev))
+                                port = NULL;
+                        read_unlock_irqrestore(&adapter->port_list_lock, flags);
                         return port;
+                }
+        read_unlock_irqrestore(&adapter->port_list_lock, flags);
         return NULL;
 }
 
-static void zfcp_sysfs_unit_release(struct device *dev)
+/**
+ * zfcp_unit_release - dequeue unit
+ * @dev: pointer to device
+ *
+ * waits until all work is done on unit and removes it then from the unit->list
+ * of the associated port.
+ */
+static void zfcp_unit_release(struct device *dev)
 {
-        kfree(container_of(dev, struct zfcp_unit, sysfs_device));
+        struct zfcp_unit *unit = container_of(dev, struct zfcp_unit, dev);
+
+        put_device(&unit->port->dev);
+        kfree(unit);
 }
 
 /**
@@ -276,43 +281,40 @@ static void zfcp_sysfs_unit_release(struct device *dev)
  * @port: pointer to port where unit is added
  * @fcp_lun: FCP LUN of unit to be enqueued
  * Returns: pointer to enqueued unit on success, ERR_PTR on error
- * Locks: config_mutex must be held to serialize changes to the unit list
  *
  * Sets up some unit internal structures and creates sysfs entry.
  */
 struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, u64 fcp_lun)
 {
         struct zfcp_unit *unit;
+        int retval = -ENOMEM;
+
+        get_device(&port->dev);
 
-        read_lock_irq(&zfcp_data.config_lock);
-        if (zfcp_get_unit_by_lun(port, fcp_lun)) {
-                read_unlock_irq(&zfcp_data.config_lock);
-                return ERR_PTR(-EINVAL);
+        unit = zfcp_get_unit_by_lun(port, fcp_lun);
+        if (unit) {
+                put_device(&unit->dev);
+                retval = -EEXIST;
+                goto err_out;
         }
-        read_unlock_irq(&zfcp_data.config_lock);
 
         unit = kzalloc(sizeof(struct zfcp_unit), GFP_KERNEL);
         if (!unit)
-                return ERR_PTR(-ENOMEM);
-
-        atomic_set(&unit->refcount, 0);
-        init_waitqueue_head(&unit->remove_wq);
-        INIT_WORK(&unit->scsi_work, zfcp_scsi_scan);
+                goto err_out;
 
         unit->port = port;
         unit->fcp_lun = fcp_lun;
+        unit->dev.parent = &port->dev;
+        unit->dev.release = zfcp_unit_release;
 
-        if (dev_set_name(&unit->sysfs_device, "0x%016llx",
+        if (dev_set_name(&unit->dev, "0x%016llx",
                          (unsigned long long) fcp_lun)) {
                 kfree(unit);
-                return ERR_PTR(-ENOMEM);
+                goto err_out;
         }
-        unit->sysfs_device.parent = &port->sysfs_device;
-        unit->sysfs_device.release = zfcp_sysfs_unit_release;
-        dev_set_drvdata(&unit->sysfs_device, unit);
+        retval = -EINVAL;
 
-        /* mark unit unusable as long as sysfs registration is not complete */
-        atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status);
+        INIT_WORK(&unit->scsi_work, zfcp_scsi_scan);
 
         spin_lock_init(&unit->latencies.lock);
         unit->latencies.write.channel.min = 0xFFFFFFFF;
@@ -322,52 +324,31 @@ struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, u64 fcp_lun)
         unit->latencies.cmd.channel.min = 0xFFFFFFFF;
         unit->latencies.cmd.fabric.min = 0xFFFFFFFF;
 
-        if (device_register(&unit->sysfs_device)) {
-                put_device(&unit->sysfs_device);
-                return ERR_PTR(-EINVAL);
+        if (device_register(&unit->dev)) {
+                put_device(&unit->dev);
+                goto err_out;
         }
 
-        if (sysfs_create_group(&unit->sysfs_device.kobj,
-                               &zfcp_sysfs_unit_attrs)) {
-                device_unregister(&unit->sysfs_device);
-                return ERR_PTR(-EINVAL);
-        }
+        if (sysfs_create_group(&unit->dev.kobj, &zfcp_sysfs_unit_attrs))
+                goto err_out_put;
 
-        zfcp_unit_get(unit);
+        write_lock_irq(&port->unit_list_lock);
+        list_add_tail(&unit->list, &port->unit_list);
+        write_unlock_irq(&port->unit_list_lock);
 
-        write_lock_irq(&zfcp_data.config_lock);
-        list_add_tail(&unit->list, &port->unit_list_head);
-        atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status);
         atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &unit->status);
 
-        write_unlock_irq(&zfcp_data.config_lock);
-
-        zfcp_port_get(port);
-
         return unit;
-}
 
-/**
- * zfcp_unit_dequeue - dequeue unit
- * @unit: pointer to zfcp_unit
- *
- * waits until all work is done on unit and removes it then from the unit->list
- * of the associated port.
- */
-void zfcp_unit_dequeue(struct zfcp_unit *unit)
-{
-        wait_event(unit->remove_wq, atomic_read(&unit->refcount) == 0);
-        write_lock_irq(&zfcp_data.config_lock);
-        list_del(&unit->list);
-        write_unlock_irq(&zfcp_data.config_lock);
-        zfcp_port_put(unit->port);
-        sysfs_remove_group(&unit->sysfs_device.kobj, &zfcp_sysfs_unit_attrs);
-        device_unregister(&unit->sysfs_device);
+err_out_put:
+        device_unregister(&unit->dev);
+err_out:
+        put_device(&port->dev);
+        return ERR_PTR(retval);
 }
 
 static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter)
 {
-        /* must only be called with zfcp_data.config_mutex taken */
         adapter->pool.erp_req =
                 mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req));
         if (!adapter->pool.erp_req)
@@ -405,9 +386,9 @@ static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter)
         if (!adapter->pool.status_read_data)
                 return -ENOMEM;
 
-        adapter->pool.gid_pn_data =
+        adapter->pool.gid_pn =
                 mempool_create_slab_pool(1, zfcp_data.gid_pn_cache);
-        if (!adapter->pool.gid_pn_data)
+        if (!adapter->pool.gid_pn)
                 return -ENOMEM;
 
         return 0;
@@ -415,7 +396,6 @@ static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter)
 
 static void zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter)
 {
-        /* zfcp_data.config_mutex must be held */
         if (adapter->pool.erp_req)
                 mempool_destroy(adapter->pool.erp_req);
         if (adapter->pool.scsi_req)
@@ -428,8 +408,8 @@ static void zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter)
                 mempool_destroy(adapter->pool.status_read_req);
         if (adapter->pool.status_read_data)
                 mempool_destroy(adapter->pool.status_read_data);
-        if (adapter->pool.gid_pn_data)
-                mempool_destroy(adapter->pool.gid_pn_data);
+        if (adapter->pool.gid_pn)
+                mempool_destroy(adapter->pool.gid_pn);
 }
 
 /**
@@ -497,139 +477,142 @@ static void zfcp_destroy_adapter_work_queue(struct zfcp_adapter *adapter)
  * zfcp_adapter_enqueue - enqueue a new adapter to the list
  * @ccw_device: pointer to the struct cc_device
  *
- * Returns:     0             if a new adapter was successfully enqueued
- *              -ENOMEM       if alloc failed
+ * Returns:     struct zfcp_adapter*
  * Enqueues an adapter at the end of the adapter list in the driver data.
  * All adapter internal structures are set up.
  * Proc-fs entries are also created.
- * locks: config_mutex must be held to serialize changes to the adapter list
  */
-int zfcp_adapter_enqueue(struct ccw_device *ccw_device)
+struct zfcp_adapter *zfcp_adapter_enqueue(struct ccw_device *ccw_device)
 {
         struct zfcp_adapter *adapter;
 
-        /*
-         * Note: It is safe to release the list_lock, as any list changes
-         * are protected by the config_mutex, which must be held to get here
-         */
+        if (!get_device(&ccw_device->dev))
+                return ERR_PTR(-ENODEV);
 
         adapter = kzalloc(sizeof(struct zfcp_adapter), GFP_KERNEL);
-        if (!adapter)
-                return -ENOMEM;
+        if (!adapter) {
+                put_device(&ccw_device->dev);
+                return ERR_PTR(-ENOMEM);
+        }
+
+        kref_init(&adapter->ref);
 
         ccw_device->handler = NULL;
         adapter->ccw_device = ccw_device;
-        atomic_set(&adapter->refcount, 0);
+
+        INIT_WORK(&adapter->stat_work, _zfcp_status_read_scheduler);
+        INIT_WORK(&adapter->scan_work, zfcp_fc_scan_ports);
 
         if (zfcp_qdio_setup(adapter))
-                goto qdio_failed;
+                goto failed;
 
         if (zfcp_allocate_low_mem_buffers(adapter))
-                goto low_mem_buffers_failed;
+                goto failed;
 
-        if (zfcp_reqlist_alloc(adapter))
-                goto low_mem_buffers_failed;
+        adapter->req_list = zfcp_reqlist_alloc();
+        if (!adapter->req_list)
+                goto failed;
 
         if (zfcp_dbf_adapter_register(adapter))
-                goto debug_register_failed;
+                goto failed;
 
         if (zfcp_setup_adapter_work_queue(adapter))
-                goto work_queue_failed;
+                goto failed;
 
         if (zfcp_fc_gs_setup(adapter))
-                goto generic_services_failed;
+                goto failed;
+
+        rwlock_init(&adapter->port_list_lock);
+        INIT_LIST_HEAD(&adapter->port_list);
 
-        init_waitqueue_head(&adapter->remove_wq);
         init_waitqueue_head(&adapter->erp_ready_wq);
         init_waitqueue_head(&adapter->erp_done_wqh);
 
-        INIT_LIST_HEAD(&adapter->port_list_head);
         INIT_LIST_HEAD(&adapter->erp_ready_head);
         INIT_LIST_HEAD(&adapter->erp_running_head);
 
-        spin_lock_init(&adapter->req_list_lock);
-
         rwlock_init(&adapter->erp_lock);
         rwlock_init(&adapter->abort_lock);
 
         if (zfcp_erp_thread_setup(adapter))
-                goto erp_thread_failed;
-
-        INIT_WORK(&adapter->stat_work, _zfcp_status_read_scheduler);
-        INIT_WORK(&adapter->scan_work, _zfcp_fc_scan_ports_later);
+                goto failed;
 
         adapter->service_level.seq_print = zfcp_print_sl;
 
-        /* mark adapter unusable as long as sysfs registration is not complete */
-        atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
-
         dev_set_drvdata(&ccw_device->dev, adapter);
 
         if (sysfs_create_group(&ccw_device->dev.kobj,
                                &zfcp_sysfs_adapter_attrs))
-                goto sysfs_failed;
-
-        atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
+                goto failed;
 
         if (!zfcp_adapter_scsi_register(adapter))
-                return 0;
+                return adapter;
 
-sysfs_failed:
-        zfcp_erp_thread_kill(adapter);
-erp_thread_failed:
-        zfcp_fc_gs_destroy(adapter);
-generic_services_failed:
+failed:
+        zfcp_adapter_unregister(adapter);
+        return ERR_PTR(-ENOMEM);
+}
+
+void zfcp_adapter_unregister(struct zfcp_adapter *adapter)
+{
+        struct ccw_device *cdev = adapter->ccw_device;
+
+        cancel_work_sync(&adapter->scan_work);
+        cancel_work_sync(&adapter->stat_work);
         zfcp_destroy_adapter_work_queue(adapter);
-work_queue_failed:
+
+        zfcp_fc_wka_ports_force_offline(adapter->gs);
+        zfcp_adapter_scsi_unregister(adapter);
+        sysfs_remove_group(&cdev->dev.kobj, &zfcp_sysfs_adapter_attrs);
+
+        zfcp_erp_thread_kill(adapter);
         zfcp_dbf_adapter_unregister(adapter->dbf);
-debug_register_failed:
-        dev_set_drvdata(&ccw_device->dev, NULL);
-        kfree(adapter->req_list);
-low_mem_buffers_failed:
-        zfcp_free_low_mem_buffers(adapter);
-qdio_failed:
         zfcp_qdio_destroy(adapter->qdio);
-        kfree(adapter);
-        return -ENOMEM;
+
+        zfcp_ccw_adapter_put(adapter); /* final put to release */
 }
 
 /**
- * zfcp_adapter_dequeue - remove the adapter from the resource list
- * @adapter: pointer to struct zfcp_adapter which should be removed
+ * zfcp_adapter_release - remove the adapter from the resource list
+ * @ref: pointer to struct kref
  * locks:       adapter list write lock is assumed to be held by caller
  */
-void zfcp_adapter_dequeue(struct zfcp_adapter *adapter)
+void zfcp_adapter_release(struct kref *ref)
 {
-        int retval = 0;
-        unsigned long flags;
+        struct zfcp_adapter *adapter = container_of(ref, struct zfcp_adapter,
+                                                    ref);
+        struct ccw_device *cdev = adapter->ccw_device;
 
-        cancel_work_sync(&adapter->stat_work);
-        zfcp_fc_wka_ports_force_offline(adapter->gs);
-        sysfs_remove_group(&adapter->ccw_device->dev.kobj,
-                           &zfcp_sysfs_adapter_attrs);
         dev_set_drvdata(&adapter->ccw_device->dev, NULL);
-        /* sanity check: no pending FSF requests */
-        spin_lock_irqsave(&adapter->req_list_lock, flags);
-        retval = zfcp_reqlist_isempty(adapter);
-        spin_unlock_irqrestore(&adapter->req_list_lock, flags);
-        if (!retval)
-                return;
-
         zfcp_fc_gs_destroy(adapter);
-        zfcp_erp_thread_kill(adapter);
-        zfcp_destroy_adapter_work_queue(adapter);
-        zfcp_dbf_adapter_unregister(adapter->dbf);
         zfcp_free_low_mem_buffers(adapter);
-        zfcp_qdio_destroy(adapter->qdio);
         kfree(adapter->req_list);
         kfree(adapter->fc_stats);
         kfree(adapter->stats_reset_data);
         kfree(adapter);
+        put_device(&cdev->dev);
 }
 
-static void zfcp_sysfs_port_release(struct device *dev)
+/**
+ * zfcp_device_unregister - remove port, unit from system
+ * @dev: reference to device which is to be removed
+ * @grp: related reference to attribute group
+ *
+ * Helper function to unregister port, unit from system
+ */
+void zfcp_device_unregister(struct device *dev,
+                            const struct attribute_group *grp)
 {
-        kfree(container_of(dev, struct zfcp_port, sysfs_device));
+        sysfs_remove_group(&dev->kobj, grp);
+        device_unregister(dev);
+}
+
+static void zfcp_port_release(struct device *dev)
+{
+        struct zfcp_port *port = container_of(dev, struct zfcp_port, dev);
+
+        zfcp_ccw_adapter_put(port->adapter);
+        kfree(port);
 }
 
 /**
@@ -639,7 +622,6 @@ static void zfcp_sysfs_port_release(struct device *dev)
  * @status: initial status for the port
  * @d_id: destination id of the remote port to be enqueued
  * Returns: pointer to enqueued port on success, ERR_PTR on error
- * Locks: config_mutex must be held to serialize changes to the port list
  *
  * All port internal structures are set up and the sysfs entry is generated.
  * d_id is used to enqueue ports with a well known address like the Directory
@@ -649,20 +631,24 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, u64 wwpn,
                                      u32 status, u32 d_id)
 {
         struct zfcp_port *port;
+        int retval = -ENOMEM;
+
+        kref_get(&adapter->ref);
 
-        read_lock_irq(&zfcp_data.config_lock);
-        if (zfcp_get_port_by_wwpn(adapter, wwpn)) {
-                read_unlock_irq(&zfcp_data.config_lock);
-                return ERR_PTR(-EINVAL);
+        port = zfcp_get_port_by_wwpn(adapter, wwpn);
+        if (port) {
+                put_device(&port->dev);
+                retval = -EEXIST;
+                goto err_out;
         }
-        read_unlock_irq(&zfcp_data.config_lock);
 
         port = kzalloc(sizeof(struct zfcp_port), GFP_KERNEL);
         if (!port)
-                return ERR_PTR(-ENOMEM);
+                goto err_out;
+
+        rwlock_init(&port->unit_list_lock);
+        INIT_LIST_HEAD(&port->unit_list);
 
-        init_waitqueue_head(&port->remove_wq);
-        INIT_LIST_HEAD(&port->unit_list_head);
         INIT_WORK(&port->gid_pn_work, zfcp_fc_port_did_lookup);
         INIT_WORK(&port->test_link_work, zfcp_fc_link_test_work);
         INIT_WORK(&port->rport_work, zfcp_scsi_rport_work);
@@ -671,58 +657,37 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, u64 wwpn,
         port->d_id = d_id;
         port->wwpn = wwpn;
         port->rport_task = RPORT_NONE;
+        port->dev.parent = &adapter->ccw_device->dev;
+        port->dev.release = zfcp_port_release;
 
-        /* mark port unusable as long as sysfs registration is not complete */
-        atomic_set_mask(status | ZFCP_STATUS_COMMON_REMOVE, &port->status);
-        atomic_set(&port->refcount, 0);
-
-        if (dev_set_name(&port->sysfs_device, "0x%016llx",
-                         (unsigned long long)wwpn)) {
+        if (dev_set_name(&port->dev, "0x%016llx", (unsigned long long)wwpn)) {
                 kfree(port);
-                return ERR_PTR(-ENOMEM);
-        }
-        port->sysfs_device.parent = &adapter->ccw_device->dev;
-        port->sysfs_device.release = zfcp_sysfs_port_release;
-        dev_set_drvdata(&port->sysfs_device, port);
-
-        if (device_register(&port->sysfs_device)) {
-                put_device(&port->sysfs_device);
-                return ERR_PTR(-EINVAL);
+                goto err_out;
         }
+        retval = -EINVAL;
 
-        if (sysfs_create_group(&port->sysfs_device.kobj,
-                               &zfcp_sysfs_port_attrs)) {
-                device_unregister(&port->sysfs_device);
-                return ERR_PTR(-EINVAL);
+        if (device_register(&port->dev)) {
+                put_device(&port->dev);
+                goto err_out;
         }
 
-        zfcp_port_get(port);
+        if (sysfs_create_group(&port->dev.kobj,
+                               &zfcp_sysfs_port_attrs))
+                goto err_out_put;
 
-        write_lock_irq(&zfcp_data.config_lock);
-        list_add_tail(&port->list, &adapter->port_list_head);
-        atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
-        atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &port->status);
+        write_lock_irq(&adapter->port_list_lock);
+        list_add_tail(&port->list, &adapter->port_list);
+        write_unlock_irq(&adapter->port_list_lock);
 
-        write_unlock_irq(&zfcp_data.config_lock);
+        atomic_set_mask(status | ZFCP_STATUS_COMMON_RUNNING, &port->status);
 
-        zfcp_adapter_get(adapter);
         return port;
-}
 
-/**
- * zfcp_port_dequeue - dequeues a port from the port list of the adapter
- * @port: pointer to struct zfcp_port which should be removed
- */
-void zfcp_port_dequeue(struct zfcp_port *port)
-{
-        write_lock_irq(&zfcp_data.config_lock);
-        list_del(&port->list);
-        write_unlock_irq(&zfcp_data.config_lock);
-        wait_event(port->remove_wq, atomic_read(&port->refcount) == 0);
-        cancel_work_sync(&port->rport_work); /* usually not necessary */
-        zfcp_adapter_put(port->adapter);
-        sysfs_remove_group(&port->sysfs_device.kobj, &zfcp_sysfs_port_attrs);
-        device_unregister(&port->sysfs_device);
+err_out_put:
+        device_unregister(&port->dev);
+err_out:
+        zfcp_ccw_adapter_put(adapter);
+        return ERR_PTR(retval);
 }
 
 /**