Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 388 insertions, 0 deletions

diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c
new file mode 100644
index 000000000000..8bb8222ea589
--- /dev/null
+++ b/drivers/scsi/scsi_transport_iscsi.c
@@ -0,0 +1,388 @@
+/* 
+ * iSCSI transport class definitions
+ *
+ * Copyright (C) IBM Corporation, 2004
+ * Copyright (C) Mike Christie, 2004
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+#include <linux/module.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_transport.h>
+#include <scsi/scsi_transport_iscsi.h>
+
+#define ISCSI_SESSION_ATTRS 20
+#define ISCSI_HOST_ATTRS 2
+
+struct iscsi_internal {
+        struct scsi_transport_template t;
+        struct iscsi_function_template *fnt;
+        /*
+         * We do not have any private or other attrs.
+         */
+        struct class_device_attribute *session_attrs[ISCSI_SESSION_ATTRS + 1];
+        struct class_device_attribute *host_attrs[ISCSI_HOST_ATTRS + 1];
+};
+
+#define to_iscsi_internal(tmpl) container_of(tmpl, struct iscsi_internal, t)
+
+static DECLARE_TRANSPORT_CLASS(iscsi_transport_class,
+                               "iscsi_transport",
+                               NULL,
+                               NULL,
+                               NULL);
+
+static DECLARE_TRANSPORT_CLASS(iscsi_host_class,
+                               "iscsi_host",
+                               NULL,
+                               NULL,
+                               NULL);
+/*
+ * iSCSI target and session attrs
+ */
+#define iscsi_session_show_fn(field, format)                            \
+                                                                        \
+static ssize_t                                                          \
+show_session_##field(struct class_device *cdev, char *buf)              \
+{                                                                       \
+        struct scsi_target *starget = transport_class_to_starget(cdev); \
+        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);    \
+        struct iscsi_internal *i = to_iscsi_internal(shost->transportt); \
+                                                                        \
+        if (i->fnt->get_##field)                                        \
+                i->fnt->get_##field(starget);                           \
+        return snprintf(buf, 20, format"\n", iscsi_##field(starget));   \
+}
+
+#define iscsi_session_rd_attr(field, format)                            \
+        iscsi_session_show_fn(field, format)                            \
+static CLASS_DEVICE_ATTR(field, S_IRUGO, show_session_##field, NULL);
+
+iscsi_session_rd_attr(tpgt, "%hu");
+iscsi_session_rd_attr(tsih, "%2x");
+iscsi_session_rd_attr(max_recv_data_segment_len, "%u");
+iscsi_session_rd_attr(max_burst_len, "%u");
+iscsi_session_rd_attr(first_burst_len, "%u");
+iscsi_session_rd_attr(def_time2wait, "%hu");
+iscsi_session_rd_attr(def_time2retain, "%hu");
+iscsi_session_rd_attr(max_outstanding_r2t, "%hu");
+iscsi_session_rd_attr(erl, "%d");
+
+
+#define iscsi_session_show_bool_fn(field)                               \
+                                                                        \
+static ssize_t                                                          \
+show_session_bool_##field(struct class_device *cdev, char *buf)         \
+{                                                                       \
+        struct scsi_target *starget = transport_class_to_starget(cdev); \
+        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);    \
+        struct iscsi_internal *i = to_iscsi_internal(shost->transportt); \
+                                                                        \
+        if (i->fnt->get_##field)                                        \
+                i->fnt->get_##field(starget);                           \
+                                                                        \
+        if (iscsi_##field(starget))                                     \
+                return sprintf(buf, "Yes\n");                           \
+        return sprintf(buf, "No\n");                                    \
+}
+
+#define iscsi_session_rd_bool_attr(field)                               \
+        iscsi_session_show_bool_fn(field)                               \
+static CLASS_DEVICE_ATTR(field, S_IRUGO, show_session_bool_##field, NULL);
+
+iscsi_session_rd_bool_attr(initial_r2t);
+iscsi_session_rd_bool_attr(immediate_data);
+iscsi_session_rd_bool_attr(data_pdu_in_order);
+iscsi_session_rd_bool_attr(data_sequence_in_order);
+
+#define iscsi_session_show_digest_fn(field)                             \
+                                                                        \
+static ssize_t                                                          \
+show_##field(struct class_device *cdev, char *buf)                      \
+{                                                                       \
+        struct scsi_target *starget = transport_class_to_starget(cdev); \
+        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);    \
+        struct iscsi_internal *i = to_iscsi_internal(shost->transportt); \
+                                                                        \
+        if (i->fnt->get_##field)                                        \
+                i->fnt->get_##field(starget);                           \
+                                                                        \
+        if (iscsi_##field(starget))                                     \
+                return sprintf(buf, "CRC32C\n");                        \
+        return sprintf(buf, "None\n");                                  \
+}
+
+#define iscsi_session_rd_digest_attr(field)                             \
+        iscsi_session_show_digest_fn(field)                             \
+static CLASS_DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
+
+iscsi_session_rd_digest_attr(header_digest);
+iscsi_session_rd_digest_attr(data_digest);
+
+static ssize_t
+show_port(struct class_device *cdev, char *buf)
+{
+        struct scsi_target *starget = transport_class_to_starget(cdev);
+        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
+        struct iscsi_internal *i = to_iscsi_internal(shost->transportt);
+
+        if (i->fnt->get_port)
+                i->fnt->get_port(starget);
+
+        return snprintf(buf, 20, "%hu\n", ntohs(iscsi_port(starget)));
+}
+static CLASS_DEVICE_ATTR(port, S_IRUGO, show_port, NULL);
+
+static ssize_t
+show_ip_address(struct class_device *cdev, char *buf)
+{
+        struct scsi_target *starget = transport_class_to_starget(cdev);
+        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
+        struct iscsi_internal *i = to_iscsi_internal(shost->transportt);
+
+        if (i->fnt->get_ip_address)
+                i->fnt->get_ip_address(starget);
+
+        if (iscsi_addr_type(starget) == AF_INET)
+                return sprintf(buf, "%u.%u.%u.%u\n",
+                               NIPQUAD(iscsi_sin_addr(starget)));
+        else if(iscsi_addr_type(starget) == AF_INET6)
+                return sprintf(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
+                               NIP6(iscsi_sin6_addr(starget)));
+        return -EINVAL;
+}
+static CLASS_DEVICE_ATTR(ip_address, S_IRUGO, show_ip_address, NULL);
+
+static ssize_t
+show_isid(struct class_device *cdev, char *buf)
+{
+        struct scsi_target *starget = transport_class_to_starget(cdev);
+        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
+        struct iscsi_internal *i = to_iscsi_internal(shost->transportt);
+
+        if (i->fnt->get_isid)
+                i->fnt->get_isid(starget);
+
+        return sprintf(buf, "%02x%02x%02x%02x%02x%02x\n",
+                       iscsi_isid(starget)[0], iscsi_isid(starget)[1],
+                       iscsi_isid(starget)[2], iscsi_isid(starget)[3],
+                       iscsi_isid(starget)[4], iscsi_isid(starget)[5]);
+}
+static CLASS_DEVICE_ATTR(isid, S_IRUGO, show_isid, NULL);
+
+/*
+ * This is used for iSCSI names. Normally, we follow
+ * the transport class convention of having the lld
+ * set the field, but in these cases the value is
+ * too large.
+ */
+#define iscsi_session_show_str_fn(field)                                \
+                                                                        \
+static ssize_t                                                          \
+show_session_str_##field(struct class_device *cdev, char *buf)          \
+{                                                                       \
+        ssize_t ret = 0;                                                \
+        struct scsi_target *starget = transport_class_to_starget(cdev); \
+        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);    \
+        struct iscsi_internal *i = to_iscsi_internal(shost->transportt); \
+                                                                        \
+        if (i->fnt->get_##field)                                        \
+                ret = i->fnt->get_##field(starget, buf, PAGE_SIZE);     \
+        return ret;                                                     \
+}
+
+#define iscsi_session_rd_str_attr(field)                                \
+        iscsi_session_show_str_fn(field)                                \
+static CLASS_DEVICE_ATTR(field, S_IRUGO, show_session_str_##field, NULL);
+
+iscsi_session_rd_str_attr(target_name);
+iscsi_session_rd_str_attr(target_alias);
+
+/*
+ * iSCSI host attrs
+ */
+
+/*
+ * Again, this is used for iSCSI names. Normally, we follow
+ * the transport class convention of having the lld set
+ * the field, but in these cases the value is too large.
+ */
+#define iscsi_host_show_str_fn(field)                                   \
+                                                                        \
+static ssize_t                                                          \
+show_host_str_##field(struct class_device *cdev, char *buf)             \
+{                                                                       \
+        int ret = 0;                                                    \
+        struct Scsi_Host *shost = transport_class_to_shost(cdev);       \
+        struct iscsi_internal *i = to_iscsi_internal(shost->transportt); \
+                                                                        \
+        if (i->fnt->get_##field)                                        \
+                ret = i->fnt->get_##field(shost, buf, PAGE_SIZE);       \
+        return ret;                                                     \
+}
+
+#define iscsi_host_rd_str_attr(field)                                   \
+        iscsi_host_show_str_fn(field)                                   \
+static CLASS_DEVICE_ATTR(field, S_IRUGO, show_host_str_##field, NULL);
+
+iscsi_host_rd_str_attr(initiator_name);
+iscsi_host_rd_str_attr(initiator_alias);
+
+#define SETUP_SESSION_RD_ATTR(field)                                    \
+        if (i->fnt->show_##field) {                                     \
+                i->session_attrs[count] = &class_device_attr_##field;   \
+                count++;                                                \
+        }
+
+#define SETUP_HOST_RD_ATTR(field)                                       \
+        if (i->fnt->show_##field) {                                     \
+                i->host_attrs[count] = &class_device_attr_##field;      \
+                count++;                                                \
+        }
+
+static int iscsi_host_match(struct attribute_container *cont,
+                          struct device *dev)
+{
+        struct Scsi_Host *shost;
+        struct iscsi_internal *i;
+
+        if (!scsi_is_host_device(dev))
+                return 0;
+
+        shost = dev_to_shost(dev);
+        if (!shost->transportt  || shost->transportt->host_attrs.ac.class
+            != &iscsi_host_class.class)
+                return 0;
+
+        i = to_iscsi_internal(shost->transportt);
+        
+        return &i->t.host_attrs.ac == cont;
+}
+
+static int iscsi_target_match(struct attribute_container *cont,
+                            struct device *dev)
+{
+        struct Scsi_Host *shost;
+        struct iscsi_internal *i;
+
+        if (!scsi_is_target_device(dev))
+                return 0;
+
+        shost = dev_to_shost(dev->parent);
+        if (!shost->transportt  || shost->transportt->host_attrs.ac.class
+            != &iscsi_host_class.class)
+                return 0;
+
+        i = to_iscsi_internal(shost->transportt);
+        
+        return &i->t.target_attrs.ac == cont;
+}
+
+struct scsi_transport_template *
+iscsi_attach_transport(struct iscsi_function_template *fnt)
+{
+        struct iscsi_internal *i = kmalloc(sizeof(struct iscsi_internal),
+                                           GFP_KERNEL);
+        int count = 0;
+
+        if (unlikely(!i))
+                return NULL;
+
+        memset(i, 0, sizeof(struct iscsi_internal));
+        i->fnt = fnt;
+
+        i->t.target_attrs.ac.attrs = &i->session_attrs[0];
+        i->t.target_attrs.ac.class = &iscsi_transport_class.class;
+        i->t.target_attrs.ac.match = iscsi_target_match;
+        transport_container_register(&i->t.target_attrs);
+        i->t.target_size = sizeof(struct iscsi_class_session);
+
+        SETUP_SESSION_RD_ATTR(tsih);
+        SETUP_SESSION_RD_ATTR(isid);
+        SETUP_SESSION_RD_ATTR(header_digest);
+        SETUP_SESSION_RD_ATTR(data_digest);
+        SETUP_SESSION_RD_ATTR(target_name);
+        SETUP_SESSION_RD_ATTR(target_alias);
+        SETUP_SESSION_RD_ATTR(port);
+        SETUP_SESSION_RD_ATTR(tpgt);
+        SETUP_SESSION_RD_ATTR(ip_address);
+        SETUP_SESSION_RD_ATTR(initial_r2t);
+        SETUP_SESSION_RD_ATTR(immediate_data);
+        SETUP_SESSION_RD_ATTR(max_recv_data_segment_len);
+        SETUP_SESSION_RD_ATTR(max_burst_len);
+        SETUP_SESSION_RD_ATTR(first_burst_len);
+        SETUP_SESSION_RD_ATTR(def_time2wait);
+        SETUP_SESSION_RD_ATTR(def_time2retain);
+        SETUP_SESSION_RD_ATTR(max_outstanding_r2t);
+        SETUP_SESSION_RD_ATTR(data_pdu_in_order);
+        SETUP_SESSION_RD_ATTR(data_sequence_in_order);
+        SETUP_SESSION_RD_ATTR(erl);
+
+        BUG_ON(count > ISCSI_SESSION_ATTRS);
+        i->session_attrs[count] = NULL;
+
+        i->t.host_attrs.ac.attrs = &i->host_attrs[0];
+        i->t.host_attrs.ac.class = &iscsi_host_class.class;
+        i->t.host_attrs.ac.match = iscsi_host_match;
+        transport_container_register(&i->t.host_attrs);
+        i->t.host_size = 0;
+
+        count = 0;
+        SETUP_HOST_RD_ATTR(initiator_name);
+        SETUP_HOST_RD_ATTR(initiator_alias);
+
+        BUG_ON(count > ISCSI_HOST_ATTRS);
+        i->host_attrs[count] = NULL;
+
+        return &i->t;
+}
+
+EXPORT_SYMBOL(iscsi_attach_transport);
+
+void iscsi_release_transport(struct scsi_transport_template *t)
+{
+        struct iscsi_internal *i = to_iscsi_internal(t);
+
+        transport_container_unregister(&i->t.target_attrs);
+        transport_container_unregister(&i->t.host_attrs);
+  
+        kfree(i);
+}
+
+EXPORT_SYMBOL(iscsi_release_transport);
+
+static __init int iscsi_transport_init(void)
+{
+        int err = transport_class_register(&iscsi_transport_class);
+
+        if (err)
+                return err;
+        return transport_class_register(&iscsi_host_class);
+}
+
+static void __exit iscsi_transport_exit(void)
+{
+        transport_class_unregister(&iscsi_host_class);
+        transport_class_unregister(&iscsi_transport_class);
+}
+
+module_init(iscsi_transport_init);
+module_exit(iscsi_transport_exit);
+
+MODULE_AUTHOR("Mike Christie");
+MODULE_DESCRIPTION("iSCSI Transport Attributes");
+MODULE_LICENSE("GPL");