4 files changed, 114 insertions, 169 deletions

diff --git a/drivers/scsi/osd/Kbuild b/drivers/scsi/osd/Kbuild
index 0e207aa67d16..5fd73d77c3af 100644
--- a/drivers/scsi/osd/Kbuild
+++ b/drivers/scsi/osd/Kbuild
@@ -11,31 +11,6 @@
 # it under the terms of the GNU General Public License version 2
 #
 
-ifneq ($(OSD_INC),)
-# we are built out-of-tree Kconfigure everything as on
-
-CONFIG_SCSI_OSD_INITIATOR=m
-ccflags-y += -DCONFIG_SCSI_OSD_INITIATOR -DCONFIG_SCSI_OSD_INITIATOR_MODULE
-
-CONFIG_SCSI_OSD_ULD=m
-ccflags-y += -DCONFIG_SCSI_OSD_ULD -DCONFIG_SCSI_OSD_ULD_MODULE
-
-# CONFIG_SCSI_OSD_DPRINT_SENSE =
-#       0 - no print of errors
-#       1 - print errors
-#       2 - errors + warrnings
-ccflags-y += -DCONFIG_SCSI_OSD_DPRINT_SENSE=1
-
-# Uncomment to turn debug on
-# ccflags-y += -DCONFIG_SCSI_OSD_DEBUG
-
-# if we are built out-of-tree and the hosting kernel has OSD headers
-# then "ccflags-y +=" will not pick the out-off-tree headers. Only by doing
-# this it will work. This might break in future kernels
-LINUXINCLUDE := -I$(OSD_INC) $(LINUXINCLUDE)
-
-endif
-
 # libosd.ko - osd-initiator library
 libosd-y := osd_initiator.o
 obj-$(CONFIG_SCSI_OSD_INITIATOR) += libosd.o
diff --git a/drivers/scsi/osd/Makefile b/drivers/scsi/osd/Makefile
deleted file mode 100755
index d905344f83ba..000000000000
--- a/drivers/scsi/osd/Makefile
+++ /dev/null
@@ -1,37 +0,0 @@
-#
-# Makefile for the OSD modules (out of tree)
-#
-# Copyright (C) 2008 Panasas Inc.  All rights reserved.
-#
-# Authors:
-#   Boaz Harrosh <bharrosh@panasas.com>
-#   Benny Halevy <bhalevy@panasas.com>
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 2
-#
-# This Makefile is used to call the kernel Makefile in case of an out-of-tree
-# build.
-# $KSRC should point to a Kernel source tree otherwise host's default is
-# used. (eg. /lib/modules/`uname -r`/build)
-
-# include path for out-of-tree Headers
-OSD_INC ?= `pwd`/../../../include
-
-# allow users to override these
-# e.g. to compile for a kernel that you aren't currently running
-KSRC ?= /lib/modules/$(shell uname -r)/build
-KBUILD_OUTPUT ?=
-ARCH ?=
-V ?= 0
-
-# this is the basic Kbuild out-of-tree invocation, with the M= option
-KBUILD_BASE = +$(MAKE) -C $(KSRC) M=`pwd` KBUILD_OUTPUT=$(KBUILD_OUTPUT) ARCH=$(ARCH) V=$(V)
-
-all: libosd
-
-libosd: ;
-        $(KBUILD_BASE) OSD_INC=$(OSD_INC) modules
-
-clean:
-        $(KBUILD_BASE) clean
diff --git a/drivers/scsi/osd/osd_initiator.c b/drivers/scsi/osd/osd_initiator.c
index 1ce6b24abab2..7a117c18114c 100644
--- a/drivers/scsi/osd/osd_initiator.c
+++ b/drivers/scsi/osd/osd_initiator.c
@@ -118,39 +118,39 @@ static int _osd_print_system_info(struct osd_dev *od, void *caps)
                 _osd_ver_desc(or));
 
         pFirst = get_attrs[a++].val_ptr;
-        OSD_INFO("OSD_ATTR_RI_VENDOR_IDENTIFICATION [%s]\n",
+        OSD_INFO("VENDOR_IDENTIFICATION  [%s]\n",
                 (char *)pFirst);
 
         pFirst = get_attrs[a++].val_ptr;
-        OSD_INFO("OSD_ATTR_RI_PRODUCT_IDENTIFICATION [%s]\n",
+        OSD_INFO("PRODUCT_IDENTIFICATION [%s]\n",
                 (char *)pFirst);
 
         pFirst = get_attrs[a++].val_ptr;
-        OSD_INFO("OSD_ATTR_RI_PRODUCT_MODEL [%s]\n",
+        OSD_INFO("PRODUCT_MODEL          [%s]\n",
                 (char *)pFirst);
 
         pFirst = get_attrs[a++].val_ptr;
-        OSD_INFO("OSD_ATTR_RI_PRODUCT_REVISION_LEVEL [%u]\n",
+        OSD_INFO("PRODUCT_REVISION_LEVEL [%u]\n",
                 pFirst ? get_unaligned_be32(pFirst) : ~0U);
 
         pFirst = get_attrs[a++].val_ptr;
-        OSD_INFO("OSD_ATTR_RI_PRODUCT_SERIAL_NUMBER [%s]\n",
+        OSD_INFO("PRODUCT_SERIAL_NUMBER  [%s]\n",
                 (char *)pFirst);
 
         pFirst = get_attrs[a].val_ptr;
-        OSD_INFO("OSD_ATTR_RI_OSD_NAME [%s]\n", (char *)pFirst);
+        OSD_INFO("OSD_NAME               [%s]\n", (char *)pFirst);
         a++;
 
         pFirst = get_attrs[a++].val_ptr;
-        OSD_INFO("OSD_ATTR_RI_TOTAL_CAPACITY [0x%llx]\n",
+        OSD_INFO("TOTAL_CAPACITY         [0x%llx]\n",
                 pFirst ? _LLU(get_unaligned_be64(pFirst)) : ~0ULL);
 
         pFirst = get_attrs[a++].val_ptr;
-        OSD_INFO("OSD_ATTR_RI_USED_CAPACITY [0x%llx]\n",
+        OSD_INFO("USED_CAPACITY          [0x%llx]\n",
                 pFirst ? _LLU(get_unaligned_be64(pFirst)) : ~0ULL);
 
         pFirst = get_attrs[a++].val_ptr;
-        OSD_INFO("OSD_ATTR_RI_NUMBER_OF_PARTITIONS [%llu]\n",
+        OSD_INFO("NUMBER_OF_PARTITIONS   [%llu]\n",
                 pFirst ? _LLU(get_unaligned_be64(pFirst)) : ~0ULL);
 
         if (a >= nelem)
@@ -158,7 +158,7 @@ static int _osd_print_system_info(struct osd_dev *od, void *caps)
 
         /* FIXME: Where are the time utilities */
         pFirst = get_attrs[a++].val_ptr;
-        OSD_INFO("OSD_ATTR_RI_CLOCK [0x%02x%02x%02x%02x%02x%02x]\n",
+        OSD_INFO("CLOCK                  [0x%02x%02x%02x%02x%02x%02x]\n",
                 ((char *)pFirst)[0], ((char *)pFirst)[1],
                 ((char *)pFirst)[2], ((char *)pFirst)[3],
                 ((char *)pFirst)[4], ((char *)pFirst)[5]);
@@ -169,7 +169,8 @@ static int _osd_print_system_info(struct osd_dev *od, void *caps)
 
                 hex_dump_to_buffer(get_attrs[a].val_ptr, len, 32, 1,
                                    sid_dump, sizeof(sid_dump), true);
-                OSD_INFO("OSD_ATTR_RI_OSD_SYSTEM_ID(%d) [%s]\n", len, sid_dump);
+                OSD_INFO("OSD_SYSTEM_ID(%d)\n"
+                         "        [%s]\n", len, sid_dump);
                 a++;
         }
 out:
@@ -669,7 +670,7 @@ static int _osd_req_list_objects(struct osd_request *or,
         __be16 action, const struct osd_obj_id *obj, osd_id initial_id,
         struct osd_obj_id_list *list, unsigned nelem)
 {
-        struct request_queue *q = or->osd_dev->scsi_device->request_queue;
+        struct request_queue *q = osd_request_queue(or->osd_dev);
         u64 len = nelem * sizeof(osd_id) + sizeof(*list);
         struct bio *bio;
 
@@ -778,16 +779,32 @@ EXPORT_SYMBOL(osd_req_remove_object);
 */
 
 void osd_req_write(struct osd_request *or,
-        const struct osd_obj_id *obj, struct bio *bio, u64 offset)
+        const struct osd_obj_id *obj, u64 offset,
+        struct bio *bio, u64 len)
 {
-        _osd_req_encode_common(or, OSD_ACT_WRITE, obj, offset, bio->bi_size);
+        _osd_req_encode_common(or, OSD_ACT_WRITE, obj, offset, len);
         WARN_ON(or->out.bio || or->out.total_bytes);
-        bio->bi_rw |= (1 << BIO_RW);
+        WARN_ON(0 ==  bio_rw_flagged(bio, BIO_RW));
         or->out.bio = bio;
-        or->out.total_bytes = bio->bi_size;
+        or->out.total_bytes = len;
 }
 EXPORT_SYMBOL(osd_req_write);
 
+int osd_req_write_kern(struct osd_request *or,
+        const struct osd_obj_id *obj, u64 offset, void* buff, u64 len)
+{
+        struct request_queue *req_q = osd_request_queue(or->osd_dev);
+        struct bio *bio = bio_map_kern(req_q, buff, len, GFP_KERNEL);
+
+        if (IS_ERR(bio))
+                return PTR_ERR(bio);
+
+        bio->bi_rw |= (1 << BIO_RW); /* FIXME: bio_set_dir() */
+        osd_req_write(or, obj, offset, bio, len);
+        return 0;
+}
+EXPORT_SYMBOL(osd_req_write_kern);
+
 /*TODO: void osd_req_append(struct osd_request *,
         const struct osd_obj_id *, struct bio *data_out); */
 /*TODO: void osd_req_create_write(struct osd_request *,
@@ -813,16 +830,31 @@ void osd_req_flush_object(struct osd_request *or,
 EXPORT_SYMBOL(osd_req_flush_object);
 
 void osd_req_read(struct osd_request *or,
-        const struct osd_obj_id *obj, struct bio *bio, u64 offset)
+        const struct osd_obj_id *obj, u64 offset,
+        struct bio *bio, u64 len)
 {
-        _osd_req_encode_common(or, OSD_ACT_READ, obj, offset, bio->bi_size);
+        _osd_req_encode_common(or, OSD_ACT_READ, obj, offset, len);
         WARN_ON(or->in.bio || or->in.total_bytes);
-        bio->bi_rw &= ~(1 << BIO_RW);
+        WARN_ON(1 == bio_rw_flagged(bio, BIO_RW));
         or->in.bio = bio;
-        or->in.total_bytes = bio->bi_size;
+        or->in.total_bytes = len;
 }
 EXPORT_SYMBOL(osd_req_read);
 
+int osd_req_read_kern(struct osd_request *or,
+        const struct osd_obj_id *obj, u64 offset, void* buff, u64 len)
+{
+        struct request_queue *req_q = osd_request_queue(or->osd_dev);
+        struct bio *bio = bio_map_kern(req_q, buff, len, GFP_KERNEL);
+
+        if (IS_ERR(bio))
+                return PTR_ERR(bio);
+
+        osd_req_read(or, obj, offset, bio, len);
+        return 0;
+}
+EXPORT_SYMBOL(osd_req_read_kern);
+
 void osd_req_get_attributes(struct osd_request *or,
         const struct osd_obj_id *obj)
 {
@@ -889,26 +921,6 @@ int osd_req_add_set_attr_list(struct osd_request *or,
 }
 EXPORT_SYMBOL(osd_req_add_set_attr_list);
 
-static int _append_map_kern(struct request *req,
-        void *buff, unsigned len, gfp_t flags)
-{
-        struct bio *bio;
-        int ret;
-
-        bio = bio_map_kern(req->q, buff, len, flags);
-        if (IS_ERR(bio)) {
-                OSD_ERR("Failed bio_map_kern(%p, %d) => %ld\n", buff, len,
-                        PTR_ERR(bio));
-                return PTR_ERR(bio);
-        }
-        ret = blk_rq_append_bio(req->q, req, bio);
-        if (ret) {
-                OSD_ERR("Failed blk_rq_append_bio(%p) => %d\n", bio, ret);
-                bio_put(bio);
-        }
-        return ret;
-}
-
 static int _req_append_segment(struct osd_request *or,
         unsigned padding, struct _osd_req_data_segment *seg,
         struct _osd_req_data_segment *last_seg, struct _osd_io_info *io)
@@ -924,14 +936,14 @@ static int _req_append_segment(struct osd_request *or,
                 else
                         pad_buff = io->pad_buff;
 
-                ret = _append_map_kern(io->req, pad_buff, padding,
+                ret = blk_rq_map_kern(io->req->q, io->req, pad_buff, padding,
                                        or->alloc_flags);
                 if (ret)
                         return ret;
                 io->total_bytes += padding;
         }
 
-        ret = _append_map_kern(io->req, seg->buff, seg->total_bytes,
+        ret = blk_rq_map_kern(io->req->q, io->req, seg->buff, seg->total_bytes,
                                or->alloc_flags);
         if (ret)
                 return ret;
@@ -1233,7 +1245,7 @@ static inline void osd_sec_parms_set_in_offset(bool is_v1,
 }
 
 static int _osd_req_finalize_data_integrity(struct osd_request *or,
-        bool has_in, bool has_out, const u8 *cap_key)
+        bool has_in, bool has_out, u64 out_data_bytes, const u8 *cap_key)
 {
         struct osd_security_parameters *sec_parms = _osd_req_sec_params(or);
         int ret;
@@ -1248,8 +1260,7 @@ static int _osd_req_finalize_data_integrity(struct osd_request *or,
                 };
                 unsigned pad;
 
-                or->out_data_integ.data_bytes = cpu_to_be64(
-                        or->out.bio ? or->out.bio->bi_size : 0);
+                or->out_data_integ.data_bytes = cpu_to_be64(out_data_bytes);
                 or->out_data_integ.set_attributes_bytes = cpu_to_be64(
                         or->set_attr.total_bytes);
                 or->out_data_integ.get_attributes_bytes = cpu_to_be64(
@@ -1293,6 +1304,21 @@ static int _osd_req_finalize_data_integrity(struct osd_request *or,
 /*
  * osd_finalize_request and helpers
  */
+static struct request *_make_request(struct request_queue *q, bool has_write,
+                              struct _osd_io_info *oii, gfp_t flags)
+{
+        if (oii->bio)
+                return blk_make_request(q, oii->bio, flags);
+        else {
+                struct request *req;
+
+                req = blk_get_request(q, has_write ? WRITE : READ, flags);
+                if (unlikely(!req))
+                        return ERR_PTR(-ENOMEM);
+
+                return req;
+        }
+}
 
 static int _init_blk_request(struct osd_request *or,
         bool has_in, bool has_out)
@@ -1301,14 +1327,18 @@ static int _init_blk_request(struct osd_request *or,
         struct scsi_device *scsi_device = or->osd_dev->scsi_device;
         struct request_queue *q = scsi_device->request_queue;
         struct request *req;
-        int ret = -ENOMEM;
+        int ret;
 
-        req = blk_get_request(q, has_out, flags);
-        if (!req)
+        req = _make_request(q, has_out, has_out ? &or->out : &or->in, flags);
+        if (IS_ERR(req)) {
+                ret = PTR_ERR(req);
                 goto out;
+        }
 
         or->request = req;
         req->cmd_type = REQ_TYPE_BLOCK_PC;
+        req->cmd_flags |= REQ_QUIET;
+
         req->timeout = or->timeout;
         req->retries = or->retries;
         req->sense = or->sense;
@@ -1318,9 +1348,10 @@ static int _init_blk_request(struct osd_request *or,
                 or->out.req = req;
                 if (has_in) {
                         /* allocate bidi request */
-                        req = blk_get_request(q, READ, flags);
-                        if (!req) {
+                        req = _make_request(q, false, &or->in, flags);
+                        if (IS_ERR(req)) {
                                 OSD_DEBUG("blk_get_request for bidi failed\n");
+                                ret = PTR_ERR(req);
                                 goto out;
                         }
                         req->cmd_type = REQ_TYPE_BLOCK_PC;
@@ -1341,6 +1372,7 @@ int osd_finalize_request(struct osd_request *or,
 {
         struct osd_cdb_head *cdbh = osd_cdb_head(&or->cdb);
         bool has_in, has_out;
+        u64 out_data_bytes = or->out.total_bytes;
         int ret;
 
         if (options & OSD_REQ_FUA)
@@ -1364,26 +1396,6 @@ int osd_finalize_request(struct osd_request *or,
                 return ret;
         }
 
-        if (or->out.bio) {
-                ret = blk_rq_append_bio(or->request->q, or->out.req,
-                                        or->out.bio);
-                if (ret) {
-                        OSD_DEBUG("blk_rq_append_bio out failed\n");
-                        return ret;
-                }
-                OSD_DEBUG("out bytes=%llu (bytes_req=%u)\n",
-                        _LLU(or->out.total_bytes), or->out.req->data_len);
-        }
-        if (or->in.bio) {
-                ret = blk_rq_append_bio(or->request->q, or->in.req, or->in.bio);
-                if (ret) {
-                        OSD_DEBUG("blk_rq_append_bio in failed\n");
-                        return ret;
-                }
-                OSD_DEBUG("in bytes=%llu (bytes_req=%u)\n",
-                        _LLU(or->in.total_bytes), or->in.req->data_len);
-        }
-
         or->out.pad_buff = sg_out_pad_buffer;
         or->in.pad_buff = sg_in_pad_buffer;
 
@@ -1410,7 +1422,8 @@ int osd_finalize_request(struct osd_request *or,
                 }
         }
 
-        ret = _osd_req_finalize_data_integrity(or, has_in, has_out, cap_key);
+        ret = _osd_req_finalize_data_integrity(or, has_in, has_out,
+                                               out_data_bytes, cap_key);
         if (ret)
                 return ret;
 
diff --git a/drivers/scsi/osd/osd_uld.c b/drivers/scsi/osd/osd_uld.c
index 22b59e13ba83..0bdef3390902 100644
--- a/drivers/scsi/osd/osd_uld.c
+++ b/drivers/scsi/osd/osd_uld.c
@@ -49,6 +49,7 @@
 #include <linux/device.h>
 #include <linux/idr.h>
 #include <linux/major.h>
+#include <linux/file.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_driver.h>
@@ -175,10 +176,9 @@ static const struct file_operations osd_fops = {
 
 struct osd_dev *osduld_path_lookup(const char *name)
 {
-        struct path path;
-        struct inode *inode;
-        struct cdev *cdev;
-        struct osd_uld_device *uninitialized_var(oud);
+        struct osd_uld_device *oud;
+        struct osd_dev *od;
+        struct file *file;
         int error;
 
         if (!name || !*name) {
@@ -186,52 +186,46 @@ struct osd_dev *osduld_path_lookup(const char *name)
                 return ERR_PTR(-EINVAL);
         }
 
-        error = kern_path(name, LOOKUP_FOLLOW, &path);
-        if (error) {
-                OSD_ERR("path_lookup of %s failed=>%d\n", name, error);
-                return ERR_PTR(error);
-        }
+        od = kzalloc(sizeof(*od), GFP_KERNEL);
+        if (!od)
+                return ERR_PTR(-ENOMEM);
 
-        inode = path.dentry->d_inode;
-        error = -EINVAL; /* Not the right device e.g osd_uld_device */
-        if (!S_ISCHR(inode->i_mode)) {
-                OSD_DEBUG("!S_ISCHR()\n");
-                goto out;
+        file = filp_open(name, O_RDWR, 0);
+        if (IS_ERR(file)) {
+                error = PTR_ERR(file);
+                goto free_od;
         }
 
-        cdev = inode->i_cdev;
-        if (!cdev) {
-                OSD_ERR("Before mounting an OSD Based filesystem\n");
-                OSD_ERR("  user-mode must open+close the %s device\n", name);
-                OSD_ERR("  Example: bash: echo < %s\n", name);
-                goto out;
+        if (file->f_op != &osd_fops){
+                error = -EINVAL;
+                goto close_file;
         }
 
-        /* The Magic wand. Is it our char-dev */
-        /* TODO: Support sg devices */
-        if (cdev->owner != THIS_MODULE) {
-                OSD_ERR("Error mounting %s - is not an OSD device\n", name);
-                goto out;
-        }
+        oud = file->private_data;
 
-        oud = container_of(cdev, struct osd_uld_device, cdev);
+        *od = oud->od;
+        od->file = file;
 
-        __uld_get(oud);
-        error = 0;
+        return od;
 
-out:
-        path_put(&path);
-        return error ? ERR_PTR(error) : &oud->od;
+close_file:
+        fput(file);
+free_od:
+        kfree(od);
+        return ERR_PTR(error);
 }
 EXPORT_SYMBOL(osduld_path_lookup);
 
 void osduld_put_device(struct osd_dev *od)
 {
-        if (od) {
-                struct osd_uld_device *oud = container_of(od,
-                                                struct osd_uld_device, od);
 
-                __uld_put(oud);
+        if (od && !IS_ERR(od)) {
+                struct osd_uld_device *oud = od->file->private_data;
+
+                BUG_ON(od->scsi_device != oud->od.scsi_device);
+
+                fput(od->file);
+                kfree(od);
         }
 }
 EXPORT_SYMBOL(osduld_put_device);