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

2 files changed, 314 insertions, 128 deletions

diff --git a/drivers/scsi/osd/osd_initiator.c b/drivers/scsi/osd/osd_initiator.c
index 7a117c18114c..ee4b6914667f 100644
--- a/drivers/scsi/osd/osd_initiator.c
+++ b/drivers/scsi/osd/osd_initiator.c
@@ -39,6 +39,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <linux/slab.h>
+
 #include <scsi/osd_initiator.h>
 #include <scsi/osd_sec.h>
 #include <scsi/osd_attributes.h>
@@ -73,7 +75,8 @@ static const char *_osd_ver_desc(struct osd_request *or)
 
 #define ATTR_DEF_RI(id, len) ATTR_DEF(OSD_APAGE_ROOT_INFORMATION, id, len)
 
-static int _osd_print_system_info(struct osd_dev *od, void *caps)
+static int _osd_get_print_system_info(struct osd_dev *od,
+        void *caps, struct osd_dev_info *odi)
 {
         struct osd_request *or;
         struct osd_attr get_attrs[] = {
@@ -137,8 +140,12 @@ static int _osd_print_system_info(struct osd_dev *od, void *caps)
         OSD_INFO("PRODUCT_SERIAL_NUMBER  [%s]\n",
                 (char *)pFirst);
 
-        pFirst = get_attrs[a].val_ptr;
-        OSD_INFO("OSD_NAME               [%s]\n", (char *)pFirst);
+        odi->osdname_len = get_attrs[a].len;
+        /* Avoid NULL for memcmp optimization 0-length is good enough */
+        odi->osdname = kzalloc(odi->osdname_len + 1, GFP_KERNEL);
+        if (odi->osdname_len)
+                memcpy(odi->osdname, get_attrs[a].val_ptr, odi->osdname_len);
+        OSD_INFO("OSD_NAME               [%s]\n", odi->osdname);
         a++;
 
         pFirst = get_attrs[a++].val_ptr;
@@ -171,6 +178,14 @@ static int _osd_print_system_info(struct osd_dev *od, void *caps)
                                    sid_dump, sizeof(sid_dump), true);
                 OSD_INFO("OSD_SYSTEM_ID(%d)\n"
                          "        [%s]\n", len, sid_dump);
+
+                if (unlikely(len > sizeof(odi->systemid))) {
+                        OSD_ERR("OSD Target error: OSD_SYSTEM_ID too long(%d). "
+                                "device idetification might not work\n", len);
+                        len = sizeof(odi->systemid);
+                }
+                odi->systemid_len = len;
+                memcpy(odi->systemid, get_attrs[a].val_ptr, len);
                 a++;
         }
 out:
@@ -178,16 +193,17 @@ out:
         return ret;
 }
 
-int osd_auto_detect_ver(struct osd_dev *od, void *caps)
+int osd_auto_detect_ver(struct osd_dev *od,
+        void *caps, struct osd_dev_info *odi)
 {
         int ret;
 
         /* Auto-detect the osd version */
-        ret = _osd_print_system_info(od, caps);
+        ret = _osd_get_print_system_info(od, caps, odi);
         if (ret) {
                 osd_dev_set_ver(od, OSD_VER1);
                 OSD_DEBUG("converting to OSD1\n");
-                ret = _osd_print_system_info(od, caps);
+                ret = _osd_get_print_system_info(od, caps, odi);
         }
 
         return ret;
@@ -418,30 +434,23 @@ static void _osd_free_seg(struct osd_request *or __unused,
         seg->alloc_size = 0;
 }
 
-static void _put_request(struct request *rq , bool is_async)
+static void _put_request(struct request *rq)
 {
-        if (is_async) {
-                WARN_ON(rq->bio);
-                __blk_put_request(rq->q, rq);
-        } else {
-                /*
-                 * If osd_finalize_request() was called but the request was not
-                 * executed through the block layer, then we must release BIOs.
-                 * TODO: Keep error code in or->async_error. Need to audit all
-                 *       code paths.
-                 */
-                if (unlikely(rq->bio))
-                        blk_end_request(rq, -ENOMEM, blk_rq_bytes(rq));
-                else
-                        blk_put_request(rq);
-        }
+        /*
+         * If osd_finalize_request() was called but the request was not
+         * executed through the block layer, then we must release BIOs.
+         * TODO: Keep error code in or->async_error. Need to audit all
+         *       code paths.
+         */
+        if (unlikely(rq->bio))
+                blk_end_request(rq, -ENOMEM, blk_rq_bytes(rq));
+        else
+                blk_put_request(rq);
 }
 
 void osd_end_request(struct osd_request *or)
 {
         struct request *rq = or->request;
-        /* IMPORTANT: make sure this agrees with osd_execute_request_async */
-        bool is_async = (or->request->end_io_data == or);
 
         _osd_free_seg(or, &or->set_attr);
         _osd_free_seg(or, &or->enc_get_attr);
@@ -449,19 +458,34 @@ void osd_end_request(struct osd_request *or)
 
         if (rq) {
                 if (rq->next_rq) {
-                        _put_request(rq->next_rq, is_async);
+                        _put_request(rq->next_rq);
                         rq->next_rq = NULL;
                 }
 
-                _put_request(rq, is_async);
+                _put_request(rq);
         }
         _osd_request_free(or);
 }
 EXPORT_SYMBOL(osd_end_request);
 
+static void _set_error_resid(struct osd_request *or, struct request *req,
+                             int error)
+{
+        or->async_error = error;
+        or->req_errors = req->errors ? : error;
+        or->sense_len = req->sense_len;
+        if (or->out.req)
+                or->out.residual = or->out.req->resid_len;
+        if (or->in.req)
+                or->in.residual = or->in.req->resid_len;
+}
+
 int osd_execute_request(struct osd_request *or)
 {
-        return blk_execute_rq(or->request->q, NULL, or->request, 0);
+        int error = blk_execute_rq(or->request->q, NULL, or->request, 0);
+
+        _set_error_resid(or, or->request, error);
+        return error;
 }
 EXPORT_SYMBOL(osd_execute_request);
 
@@ -469,10 +493,16 @@ static void osd_request_async_done(struct request *req, int error)
 {
         struct osd_request *or = req->end_io_data;
 
-        or->async_error = error;
+        _set_error_resid(or, req, error);
+        if (req->next_rq) {
+                __blk_put_request(req->q, req->next_rq);
+                req->next_rq = NULL;
+        }
 
-        if (error)
-                OSD_DEBUG("osd_request_async_done error recieved %d\n", error);
+        __blk_put_request(req->q, req);
+        or->request = NULL;
+        or->in.req = NULL;
+        or->out.req = NULL;
 
         if (or->async_done)
                 or->async_done(or, or->async_private);
@@ -1153,6 +1183,7 @@ int osd_req_decode_get_attr_list(struct osd_request *or,
                                 "c=%d r=%d n=%d\n",
                                 cur_bytes, returned_bytes, n);
                         oa->val_ptr = NULL;
+                        cur_bytes = returned_bytes; /* break the caller loop */
                         break;
                 }
 
@@ -1404,6 +1435,10 @@ int osd_finalize_request(struct osd_request *or,
         cdbh->command_specific_options |= or->attributes_mode;
         if (or->attributes_mode == OSD_CDB_GET_ATTR_PAGE_SET_ONE) {
                 ret = _osd_req_finalize_attr_page(or);
+                if (ret) {
+                        OSD_DEBUG("_osd_req_finalize_attr_page failed\n");
+                        return ret;
+                }
         } else {
                 /* TODO: I think that for the GET_ATTR command these 2 should
                  * be reversed to keep them in execution order (for embeded
@@ -1436,6 +1471,15 @@ int osd_finalize_request(struct osd_request *or,
 }
 EXPORT_SYMBOL(osd_finalize_request);
 
+static bool _is_osd_security_code(int code)
+{
+        return  (code == osd_security_audit_value_frozen) ||
+                (code == osd_security_working_key_frozen) ||
+                (code == osd_nonce_not_unique) ||
+                (code == osd_nonce_timestamp_out_of_range) ||
+                (code == osd_invalid_dataout_buffer_integrity_check_value);
+}
+
 #define OSD_SENSE_PRINT1(fmt, a...) \
         do { \
                 if (__cur_sense_need_output) \
@@ -1458,27 +1502,29 @@ int osd_req_decode_sense_full(struct osd_request *or,
 #else
         bool __cur_sense_need_output = !silent;
 #endif
+        int ret;
 
-        if (!or->request->errors)
+        if (likely(!or->req_errors))
                 return 0;
 
-        ssdb = or->request->sense;
-        sense_len = or->request->sense_len;
+        osi = osi ? : &local_osi;
+        memset(osi, 0, sizeof(*osi));
+
+        ssdb = (typeof(ssdb))or->sense;
+        sense_len = or->sense_len;
         if ((sense_len < (int)sizeof(*ssdb) || !ssdb->sense_key)) {
                 OSD_ERR("Block-layer returned error(0x%x) but "
                         "sense_len(%u) || key(%d) is empty\n",
-                        or->request->errors, sense_len, ssdb->sense_key);
-                return -EIO;
+                        or->req_errors, sense_len, ssdb->sense_key);
+                goto analyze;
         }
 
         if ((ssdb->response_code != 0x72) && (ssdb->response_code != 0x73)) {
                 OSD_ERR("Unrecognized scsi sense: rcode=%x length=%d\n",
                         ssdb->response_code, sense_len);
-                return -EIO;
+                goto analyze;
         }
 
-        osi = osi ? : &local_osi;
-        memset(osi, 0, sizeof(*osi));
         osi->key = ssdb->sense_key;
         osi->additional_code = be16_to_cpu(ssdb->additional_sense_code);
         original_sense_len = ssdb->additional_sense_length + 8;
@@ -1488,9 +1534,10 @@ int osd_req_decode_sense_full(struct osd_request *or,
                 __cur_sense_need_output = (osi->key > scsi_sk_recovered_error);
 #endif
         OSD_SENSE_PRINT1("Main Sense information key=0x%x length(%d, %d) "
-                        "additional_code=0x%x\n",
+                        "additional_code=0x%x async_error=%d errors=0x%x\n",
                         osi->key, original_sense_len, sense_len,
-                        osi->additional_code);
+                        osi->additional_code, or->async_error,
+                        or->req_errors);
 
         if (original_sense_len < sense_len)
                 sense_len = original_sense_len;
@@ -1569,15 +1616,14 @@ int osd_req_decode_sense_full(struct osd_request *or,
                 {
                         struct osd_sense_attributes_data_descriptor
                                 *osadd = cur_descriptor;
-                        int len = min(cur_len, sense_len);
-                        int i = 0;
+                        unsigned len = min(cur_len, sense_len);
                         struct osd_sense_attr *pattr = osadd->sense_attrs;
 
-                        while (len < 0) {
+                        while (len >= sizeof(*pattr)) {
                                 u32 attr_page = be32_to_cpu(pattr->attr_page);
                                 u32 attr_id = be32_to_cpu(pattr->attr_id);
 
-                                if (i++ == 0) {
+                                if (!osi->attr.attr_page) {
                                         osi->attr.attr_page = attr_page;
                                         osi->attr.attr_id = attr_id;
                                 }
@@ -1588,6 +1634,8 @@ int osd_req_decode_sense_full(struct osd_request *or,
                                         bad_attr_list++;
                                         max_attr--;
                                 }
+
+                                len -= sizeof(*pattr);
                                 OSD_SENSE_PRINT2(
                                         "osd_sense_attribute_identification"
                                         "attr_page=0x%x attr_id=0x%x\n",
@@ -1621,7 +1669,50 @@ int osd_req_decode_sense_full(struct osd_request *or,
                 cur_descriptor += cur_len;
         }
 
-        return (osi->key > scsi_sk_recovered_error) ? -EIO : 0;
+analyze:
+        if (!osi->key) {
+                /* scsi sense is Empty, the request was never issued to target
+                 * linux return code might tell us what happened.
+                 */
+                if (or->async_error == -ENOMEM)
+                        osi->osd_err_pri = OSD_ERR_PRI_RESOURCE;
+                else
+                        osi->osd_err_pri = OSD_ERR_PRI_UNREACHABLE;
+                ret = or->async_error;
+        } else if (osi->key <= scsi_sk_recovered_error) {
+                osi->osd_err_pri = 0;
+                ret = 0;
+        } else if (osi->additional_code == scsi_invalid_field_in_cdb) {
+                if (osi->cdb_field_offset == OSD_CFO_STARTING_BYTE) {
+                        osi->osd_err_pri = OSD_ERR_PRI_CLEAR_PAGES;
+                        ret = -EFAULT; /* caller should recover from this */
+                } else if (osi->cdb_field_offset == OSD_CFO_OBJECT_ID) {
+                        osi->osd_err_pri = OSD_ERR_PRI_NOT_FOUND;
+                        ret = -ENOENT;
+                } else if (osi->cdb_field_offset == OSD_CFO_PERMISSIONS) {
+                        osi->osd_err_pri = OSD_ERR_PRI_NO_ACCESS;
+                        ret = -EACCES;
+                } else {
+                        osi->osd_err_pri = OSD_ERR_PRI_BAD_CRED;
+                        ret = -EINVAL;
+                }
+        } else if (osi->additional_code == osd_quota_error) {
+                osi->osd_err_pri = OSD_ERR_PRI_NO_SPACE;
+                ret = -ENOSPC;
+        } else if (_is_osd_security_code(osi->additional_code)) {
+                osi->osd_err_pri = OSD_ERR_PRI_BAD_CRED;
+                ret = -EINVAL;
+        } else {
+                osi->osd_err_pri = OSD_ERR_PRI_EIO;
+                ret = -EIO;
+        }
+
+        if (!or->out.residual)
+                or->out.residual = or->out.total_bytes;
+        if (!or->in.residual)
+                or->in.residual = or->in.total_bytes;
+
+        return ret;
 }
 EXPORT_SYMBOL(osd_req_decode_sense_full);
 
diff --git a/drivers/scsi/osd/osd_uld.c b/drivers/scsi/osd/osd_uld.c
index 0bdef3390902..ffdd9fdb9995 100644
--- a/drivers/scsi/osd/osd_uld.c
+++ b/drivers/scsi/osd/osd_uld.c
@@ -50,6 +50,7 @@
 #include <linux/idr.h>
 #include <linux/major.h>
 #include <linux/file.h>
+#include <linux/slab.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_driver.h>
@@ -71,8 +72,7 @@
 #define SCSI_OSD_MAX_MINOR 64
 
 static const char osd_name[] = "osd";
-static const char *osd_version_string = "open-osd 0.1.0";
-const char osd_symlink[] = "scsi_osd";
+static const char *osd_version_string = "open-osd 0.2.0";
 
 MODULE_AUTHOR("Boaz Harrosh <bharrosh@panasas.com>");
 MODULE_DESCRIPTION("open-osd Upper-Layer-Driver osd.ko");
@@ -82,15 +82,25 @@ MODULE_ALIAS_SCSI_DEVICE(TYPE_OSD);
 
 struct osd_uld_device {
         int minor;
-        struct kref kref;
+        struct device class_dev;
         struct cdev cdev;
         struct osd_dev od;
+        struct osd_dev_info odi;
         struct gendisk *disk;
-        struct device *class_member;
 };
 
-static void __uld_get(struct osd_uld_device *oud);
-static void __uld_put(struct osd_uld_device *oud);
+struct osd_dev_handle {
+        struct osd_dev od;
+        struct file *file;
+        struct osd_uld_device *oud;
+} ;
+
+static DEFINE_IDA(osd_minor_ida);
+
+static struct class osd_uld_class = {
+        .owner          = THIS_MODULE,
+        .name           = "scsi_osd",
+};
 
 /*
  * Char Device operations
@@ -101,7 +111,7 @@ static int osd_uld_open(struct inode *inode, struct file *file)
         struct osd_uld_device *oud = container_of(inode->i_cdev,
                                         struct osd_uld_device, cdev);
 
-        __uld_get(oud);
+        get_device(&oud->class_dev);
         /* cache osd_uld_device on file handle */
         file->private_data = oud;
         OSD_DEBUG("osd_uld_open %p\n", oud);
@@ -114,7 +124,7 @@ static int osd_uld_release(struct inode *inode, struct file *file)
 
         OSD_DEBUG("osd_uld_release %p\n", file->private_data);
         file->private_data = NULL;
-        __uld_put(oud);
+        put_device(&oud->class_dev);
         return 0;
 }
 
@@ -177,7 +187,7 @@ static const struct file_operations osd_fops = {
 struct osd_dev *osduld_path_lookup(const char *name)
 {
         struct osd_uld_device *oud;
-        struct osd_dev *od;
+        struct osd_dev_handle *odh;
         struct file *file;
         int error;
 
@@ -186,8 +196,8 @@ struct osd_dev *osduld_path_lookup(const char *name)
                 return ERR_PTR(-EINVAL);
         }
 
-        od = kzalloc(sizeof(*od), GFP_KERNEL);
-        if (!od)
+        odh = kzalloc(sizeof(*odh), GFP_KERNEL);
+        if (unlikely(!odh))
                 return ERR_PTR(-ENOMEM);
 
         file = filp_open(name, O_RDWR, 0);
@@ -203,33 +213,134 @@ struct osd_dev *osduld_path_lookup(const char *name)
 
         oud = file->private_data;
 
-        *od = oud->od;
-        od->file = file;
+        odh->od = oud->od;
+        odh->file = file;
+        odh->oud = oud;
 
-        return od;
+        return &odh->od;
 
 close_file:
         fput(file);
 free_od:
-        kfree(od);
+        kfree(odh);
         return ERR_PTR(error);
 }
 EXPORT_SYMBOL(osduld_path_lookup);
 
-void osduld_put_device(struct osd_dev *od)
+static inline bool _the_same_or_null(const u8 *a1, unsigned a1_len,
+                                     const u8 *a2, unsigned a2_len)
 {
+        if (!a2_len) /* User string is Empty means don't care */
+                return true;
+
+        if (a1_len != a2_len)
+                return false;
+
+        return 0 == memcmp(a1, a2, a1_len);
+}
+
+struct find_oud_t {
+        const struct osd_dev_info *odi;
+        struct device *dev;
+        struct osd_uld_device *oud;
+} ;
+
+int _mach_odi(struct device *dev, void *find_data)
+{
+        struct osd_uld_device *oud = container_of(dev, struct osd_uld_device,
+                                                  class_dev);
+        struct find_oud_t *fot = find_data;
+        const struct osd_dev_info *odi = fot->odi;
+
+        if (_the_same_or_null(oud->odi.systemid, oud->odi.systemid_len,
+                              odi->systemid, odi->systemid_len) &&
+            _the_same_or_null(oud->odi.osdname, oud->odi.osdname_len,
+                              odi->osdname, odi->osdname_len)) {
+                OSD_DEBUG("found device sysid_len=%d osdname=%d\n",
+                          odi->systemid_len, odi->osdname_len);
+                fot->oud = oud;
+                return 1;
+        } else {
+                return 0;
+        }
+}
+
+/* osduld_info_lookup - Loop through all devices, return the requested osd_dev.
+ *
+ * if @odi->systemid_len and/or @odi->osdname_len are zero, they act as a don't
+ * care. .e.g if they're both zero /dev/osd0 is returned.
+ */
+struct osd_dev *osduld_info_lookup(const struct osd_dev_info *odi)
+{
+        struct find_oud_t find = {.odi = odi};
+
+        find.dev = class_find_device(&osd_uld_class, NULL, &find, _mach_odi);
+        if (likely(find.dev)) {
+                struct osd_dev_handle *odh = kzalloc(sizeof(*odh), GFP_KERNEL);
+
+                if (unlikely(!odh)) {
+                        put_device(find.dev);
+                        return ERR_PTR(-ENOMEM);
+                }
 
+                odh->od = find.oud->od;
+                odh->oud = find.oud;
+
+                return &odh->od;
+        }
+
+        return ERR_PTR(-ENODEV);
+}
+EXPORT_SYMBOL(osduld_info_lookup);
+
+void osduld_put_device(struct osd_dev *od)
+{
         if (od && !IS_ERR(od)) {
-                struct osd_uld_device *oud = od->file->private_data;
+                struct osd_dev_handle *odh =
+                                container_of(od, struct osd_dev_handle, od);
+                struct osd_uld_device *oud = odh->oud;
 
                 BUG_ON(od->scsi_device != oud->od.scsi_device);
 
-                fput(od->file);
-                kfree(od);
+                /* If scsi has released the device (logout), and exofs has last
+                 * reference on oud it will be freed by above osd_uld_release
+                 * within fput below. But this will oops in cdev_release which
+                 * is called after the fops->release. A get_/put_ pair makes
+                 * sure we have a cdev for the duration of fput
+                 */
+                if (odh->file) {
+                        get_device(&oud->class_dev);
+                        fput(odh->file);
+                }
+                put_device(&oud->class_dev);
+                kfree(odh);
         }
 }
 EXPORT_SYMBOL(osduld_put_device);
 
+const struct osd_dev_info *osduld_device_info(struct osd_dev *od)
+{
+        struct osd_dev_handle *odh =
+                                container_of(od, struct osd_dev_handle, od);
+        return &odh->oud->odi;
+}
+EXPORT_SYMBOL(osduld_device_info);
+
+bool osduld_device_same(struct osd_dev *od, const struct osd_dev_info *odi)
+{
+        struct osd_dev_handle *odh =
+                                container_of(od, struct osd_dev_handle, od);
+        struct osd_uld_device *oud = odh->oud;
+
+        return (oud->odi.systemid_len == odi->systemid_len) &&
+                _the_same_or_null(oud->odi.systemid, oud->odi.systemid_len,
+                                 odi->systemid, odi->systemid_len) &&
+                (oud->odi.osdname_len == odi->osdname_len) &&
+                _the_same_or_null(oud->odi.osdname, oud->odi.osdname_len,
+                                  odi->osdname, odi->osdname_len);
+}
+EXPORT_SYMBOL(osduld_device_same);
+
 /*
  * Scsi Device operations
  */
@@ -250,14 +361,35 @@ static int __detect_osd(struct osd_uld_device *oud)
                 OSD_ERR("warning: scsi_test_unit_ready failed\n");
 
         osd_sec_init_nosec_doall_caps(caps, &osd_root_object, false, true);
-        if (osd_auto_detect_ver(&oud->od, caps))
+        if (osd_auto_detect_ver(&oud->od, caps, &oud->odi))
                 return -ENODEV;
 
         return 0;
 }
 
-static struct class *osd_sysfs_class;
-static DEFINE_IDA(osd_minor_ida);
+static void __remove(struct device *dev)
+{
+        struct osd_uld_device *oud = container_of(dev, struct osd_uld_device,
+                                                  class_dev);
+        struct scsi_device *scsi_device = oud->od.scsi_device;
+
+        kfree(oud->odi.osdname);
+
+        if (oud->cdev.owner)
+                cdev_del(&oud->cdev);
+
+        osd_dev_fini(&oud->od);
+        scsi_device_put(scsi_device);
+
+        OSD_INFO("osd_remove %s\n",
+                 oud->disk ? oud->disk->disk_name : NULL);
+
+        if (oud->disk)
+                put_disk(oud->disk);
+        ida_remove(&osd_minor_ida, oud->minor);
+
+        kfree(oud);
+}
 
 static int osd_probe(struct device *dev)
 {
@@ -289,7 +421,6 @@ static int osd_probe(struct device *dev)
         if (NULL == oud)
                 goto err_retract_minor;
 
-        kref_init(&oud->kref);
         dev_set_drvdata(dev, oud);
         oud->minor = minor;
 
@@ -327,18 +458,25 @@ static int osd_probe(struct device *dev)
                 OSD_ERR("cdev_add failed\n");
                 goto err_put_disk;
         }
-        kobject_get(&oud->cdev.kobj); /* 2nd ref see osd_remove() */
-
-        /* class_member */
-        oud->class_member = device_create(osd_sysfs_class, dev,
-                MKDEV(SCSI_OSD_MAJOR, oud->minor), "%s", disk->disk_name);
-        if (IS_ERR(oud->class_member)) {
-                OSD_ERR("class_device_create failed\n");
-                error = PTR_ERR(oud->class_member);
+
+        /* class device member */
+        oud->class_dev.devt = oud->cdev.dev;
+        oud->class_dev.class = &osd_uld_class;
+        oud->class_dev.parent = dev;
+        oud->class_dev.release = __remove;
+        error = dev_set_name(&oud->class_dev, disk->disk_name);
+        if (error) {
+                OSD_ERR("dev_set_name failed => %d\n", error);
+                goto err_put_cdev;
+        }
+
+        error = device_register(&oud->class_dev);
+        if (error) {
+                OSD_ERR("device_register failed => %d\n", error);
                 goto err_put_cdev;
         }
 
-        dev_set_drvdata(oud->class_member, oud);
+        get_device(&oud->class_dev);
 
         OSD_INFO("osd_probe %s\n", disk->disk_name);
         return 0;
@@ -367,54 +505,12 @@ static int osd_remove(struct device *dev)
                         scsi_device);
         }
 
-        if (oud->class_member)
-                device_destroy(osd_sysfs_class,
-                               MKDEV(SCSI_OSD_MAJOR, oud->minor));
+        device_unregister(&oud->class_dev);
 
-        /* We have 2 references to the cdev. One is released here
-         * and also takes down the /dev/osdX mapping. The second
-         * Will be released in __remove() after all users have released
-         * the osd_uld_device.
-         */
-        if (oud->cdev.owner)
-                cdev_del(&oud->cdev);
-
-        __uld_put(oud);
+        put_device(&oud->class_dev);
         return 0;
 }
 
-static void __remove(struct kref *kref)
-{
-        struct osd_uld_device *oud = container_of(kref,
-                                        struct osd_uld_device, kref);
-        struct scsi_device *scsi_device = oud->od.scsi_device;
-
-        /* now let delete the char_dev */
-        kobject_put(&oud->cdev.kobj);
-
-        osd_dev_fini(&oud->od);
-        scsi_device_put(scsi_device);
-
-        OSD_INFO("osd_remove %s\n",
-                 oud->disk ? oud->disk->disk_name : NULL);
-
-        if (oud->disk)
-                put_disk(oud->disk);
-
-        ida_remove(&osd_minor_ida, oud->minor);
-        kfree(oud);
-}
-
-static void __uld_get(struct osd_uld_device *oud)
-{
-        kref_get(&oud->kref);
-}
-
-static void __uld_put(struct osd_uld_device *oud)
-{
-        kref_put(&oud->kref, __remove);
-}
-
 /*
  * Global driver and scsi registration
  */
@@ -432,11 +528,10 @@ static int __init osd_uld_init(void)
 {
         int err;
 
-        osd_sysfs_class = class_create(THIS_MODULE, osd_symlink);
-        if (IS_ERR(osd_sysfs_class)) {
-                OSD_ERR("Unable to register sysfs class => %ld\n",
-                        PTR_ERR(osd_sysfs_class));
-                return PTR_ERR(osd_sysfs_class);
+        err = class_register(&osd_uld_class);
+        if (err) {
+                OSD_ERR("Unable to register sysfs class => %d\n", err);
+                return err;
         }
 
         err = register_chrdev_region(MKDEV(SCSI_OSD_MAJOR, 0),
@@ -459,7 +554,7 @@ static int __init osd_uld_init(void)
 err_out_chrdev:
         unregister_chrdev_region(MKDEV(SCSI_OSD_MAJOR, 0), SCSI_OSD_MAX_MINOR);
 err_out:
-        class_destroy(osd_sysfs_class);
+        class_unregister(&osd_uld_class);
         return err;
 }
 
@@ -467,7 +562,7 @@ static void __exit osd_uld_exit(void)
 {
         scsi_unregister_driver(&osd_driver.gendrv);
         unregister_chrdev_region(MKDEV(SCSI_OSD_MAJOR, 0), SCSI_OSD_MAX_MINOR);
-        class_destroy(osd_sysfs_class);
+        class_unregister(&osd_uld_class);
         OSD_INFO("UNLOADED %s\n", osd_version_string);
 }