* [PATCH 8/8] scsi tgt: IBM eServer i/pSeries virtual SCSI target driver
@ 2006-11-16 10:24 FUJITA Tomonori
2006-11-28 14:31 ` FUJITA Tomonori
0 siblings, 1 reply; 5+ messages in thread
From: FUJITA Tomonori @ 2006-11-16 10:24 UTC (permalink / raw)
To: linux-scsi
This is IBM Virtual SCSI target driver for tgt. The driver is based on
the original ibmvscsis driver:
http://lkml.org/lkml/2005/10/17/99
Signed-off-by: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
---
drivers/scsi/Kconfig | 14 +
drivers/scsi/Makefile | 1 +
drivers/scsi/ibmvscsi/Makefile | 2 +
drivers/scsi/ibmvscsi/ibmvstgt.c | 958 ++++++++++++++++++++++++++++++++++++++
4 files changed, 975 insertions(+), 0 deletions(-)
diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index e5dd59e..87c51fd 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -804,6 +804,20 @@ config SCSI_IBMVSCSI
To compile this driver as a module, choose M here: the
module will be called ibmvscsic.
+config SCSI_IBMVSCSIS
+ tristate "IBM Virtual SCSI Server support"
+ depends on PPC_PSERIES && SCSI_TGT && SCSI_SRP
+ help
+ This is the SRP target driver for IBM pSeries virtual environments.
+
+ The userspace component needed to initialize the driver and
+ documentation can be found:
+
+ http://stgt.berlios.de/
+
+ To compile this driver as a module, choose M here: the
+ module will be called ibmvstgt.
+
config SCSI_INITIO
tristate "Initio 9100U(W) support"
depends on PCI && SCSI
diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile
index a6281fd..854b98b 100644
--- a/drivers/scsi/Makefile
+++ b/drivers/scsi/Makefile
@@ -128,6 +128,7 @@ obj-$(CONFIG_SCSI_NSP32) += nsp32.o
obj-$(CONFIG_SCSI_IPR) += ipr.o
obj-$(CONFIG_SCSI_SRP) += libsrp.o
obj-$(CONFIG_SCSI_IBMVSCSI) += ibmvscsi/
+obj-$(CONFIG_SCSI_IBMVSCSIS) += ibmvscsi/
obj-$(CONFIG_SCSI_HPTIOP) += hptiop.o
obj-$(CONFIG_SCSI_STEX) += stex.o
diff --git a/drivers/scsi/ibmvscsi/Makefile b/drivers/scsi/ibmvscsi/Makefile
index 4e247b6..6ac0633 100644
--- a/drivers/scsi/ibmvscsi/Makefile
+++ b/drivers/scsi/ibmvscsi/Makefile
@@ -3,3 +3,5 @@ obj-$(CONFIG_SCSI_IBMVSCSI) += ibmvscsic
ibmvscsic-y += ibmvscsi.o
ibmvscsic-$(CONFIG_PPC_ISERIES) += iseries_vscsi.o
ibmvscsic-$(CONFIG_PPC_PSERIES) += rpa_vscsi.o
+
+obj-$(CONFIG_SCSI_IBMVSCSIS) += ibmvstgt.o
diff --git a/drivers/scsi/ibmvscsi/ibmvstgt.c b/drivers/scsi/ibmvscsi/ibmvstgt.c
new file mode 100644
index 0000000..73fcfca
--- /dev/null
+++ b/drivers/scsi/ibmvscsi/ibmvstgt.c
@@ -0,0 +1,958 @@
+/*
+ * IBM eServer i/pSeries Virtual SCSI Target Driver
+ * Copyright (C) 2003-2005 Dave Boutcher (boutcher@us.ibm.com) IBM Corp.
+ * Santiago Leon (santil@us.ibm.com) IBM Corp.
+ * Linda Xie (lxie@us.ibm.com) IBM Corp.
+ *
+ * Copyright (C) 2005-2006 FUJITA Tomonori <tomof@acm.org>
+ *
+ * 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/interrupt.h>
+#include <linux/module.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_tgt.h>
+#include <scsi/libsrp.h>
+#include <asm/hvcall.h>
+#include <asm/iommu.h>
+#include <asm/prom.h>
+#include <asm/vio.h>
+
+#include "ibmvscsi.h"
+
+#define INITIAL_SRP_LIMIT 16
+#define DEFAULT_MAX_SECTORS 512
+
+#define TGT_NAME "ibmvstgt"
+
+/*
+ * Hypervisor calls.
+ */
+#define h_copy_rdma(l, sa, sb, da, db) \
+ plpar_hcall_norets(H_COPY_RDMA, l, sa, sb, da, db)
+#define h_send_crq(ua, l, h) \
+ plpar_hcall_norets(H_SEND_CRQ, ua, l, h)
+#define h_reg_crq(ua, tok, sz)\
+ plpar_hcall_norets(H_REG_CRQ, ua, tok, sz);
+#define h_free_crq(ua) \
+ plpar_hcall_norets(H_FREE_CRQ, ua);
+
+/* tmp - will replace with SCSI logging stuff */
+#define eprintk(fmt, args...) \
+do { \
+ printk("%s(%d) " fmt, __FUNCTION__, __LINE__, ##args); \
+} while (0)
+/* #define dprintk eprintk */
+#define dprintk(fmt, args...)
+
+struct vio_port {
+ struct vio_dev *dma_dev;
+
+ struct crq_queue crq_queue;
+ struct work_struct crq_work;
+
+ unsigned long liobn;
+ unsigned long riobn;
+};
+
+static struct workqueue_struct *vtgtd;
+
+/*
+ * These are fixed for the system and come from the Open Firmware device tree.
+ * We just store them here to save getting them every time.
+ */
+static char system_id[64] = "";
+static char partition_name[97] = "UNKNOWN";
+static unsigned int partition_number = -1;
+
+static struct vio_port *target_to_port(struct srp_target *target)
+{
+ return (struct vio_port *) target->ldata;
+}
+
+static inline union viosrp_iu *vio_iu(struct iu_entry *iue)
+{
+ return (union viosrp_iu *) (iue->sbuf->buf);
+}
+
+static int send_iu(struct iu_entry *iue, uint64_t length, uint8_t format)
+{
+ struct srp_target *target = iue->target;
+ struct vio_port *vport = target_to_port(target);
+ long rc, rc1;
+ union {
+ struct viosrp_crq cooked;
+ uint64_t raw[2];
+ } crq;
+
+ /* First copy the SRP */
+ rc = h_copy_rdma(length, vport->liobn, iue->sbuf->dma,
+ vport->riobn, iue->remote_token);
+
+ if (rc)
+ eprintk("Error %ld transferring data\n", rc);
+
+ crq.cooked.valid = 0x80;
+ crq.cooked.format = format;
+ crq.cooked.reserved = 0x00;
+ crq.cooked.timeout = 0x00;
+ crq.cooked.IU_length = length;
+ crq.cooked.IU_data_ptr = vio_iu(iue)->srp.rsp.tag;
+
+ if (rc == 0)
+ crq.cooked.status = 0x99; /* Just needs to be non-zero */
+ else
+ crq.cooked.status = 0x00;
+
+ rc1 = h_send_crq(vport->dma_dev->unit_address, crq.raw[0], crq.raw[1]);
+
+ if (rc1) {
+ eprintk("%ld sending response\n", rc1);
+ return rc1;
+ }
+
+ return rc;
+}
+
+#define SRP_RSP_SENSE_DATA_LEN 18
+
+static int send_rsp(struct iu_entry *iue, struct scsi_cmnd *sc,
+ unsigned char status, unsigned char asc)
+{
+ union viosrp_iu *iu = vio_iu(iue);
+ uint64_t tag = iu->srp.rsp.tag;
+
+ /* If the linked bit is on and status is good */
+ if (test_bit(V_LINKED, &iue->flags) && (status == NO_SENSE))
+ status = 0x10;
+
+ memset(iu, 0, sizeof(struct srp_rsp));
+ iu->srp.rsp.opcode = SRP_RSP;
+ iu->srp.rsp.req_lim_delta = 1;
+ iu->srp.rsp.tag = tag;
+
+ if (test_bit(V_DIOVER, &iue->flags))
+ iu->srp.rsp.flags |= SRP_RSP_FLAG_DIOVER;
+
+ iu->srp.rsp.data_in_res_cnt = 0;
+ iu->srp.rsp.data_out_res_cnt = 0;
+
+ iu->srp.rsp.flags &= ~SRP_RSP_FLAG_RSPVALID;
+
+ iu->srp.rsp.resp_data_len = 0;
+ iu->srp.rsp.status = status;
+ if (status) {
+ uint8_t *sense = iu->srp.rsp.data;
+
+ if (sc) {
+ iu->srp.rsp.flags |= SRP_RSP_FLAG_SNSVALID;
+ iu->srp.rsp.sense_data_len = SCSI_SENSE_BUFFERSIZE;
+ memcpy(sense, sc->sense_buffer, SCSI_SENSE_BUFFERSIZE);
+ } else {
+ iu->srp.rsp.status = SAM_STAT_CHECK_CONDITION;
+ iu->srp.rsp.flags |= SRP_RSP_FLAG_SNSVALID;
+ iu->srp.rsp.sense_data_len = SRP_RSP_SENSE_DATA_LEN;
+
+ /* Valid bit and 'current errors' */
+ sense[0] = (0x1 << 7 | 0x70);
+ /* Sense key */
+ sense[2] = status;
+ /* Additional sense length */
+ sense[7] = 0xa; /* 10 bytes */
+ /* Additional sense code */
+ sense[12] = asc;
+ }
+ }
+
+ send_iu(iue, sizeof(iu->srp.rsp) + SRP_RSP_SENSE_DATA_LEN,
+ VIOSRP_SRP_FORMAT);
+
+ return 0;
+}
+
+static void handle_cmd_queue(struct srp_target *target)
+{
+ struct Scsi_Host *shost = target->shost;
+ struct iu_entry *iue;
+ struct srp_cmd *cmd;
+ unsigned long flags;
+ int err;
+
+retry:
+ spin_lock_irqsave(&target->lock, flags);
+
+ list_for_each_entry(iue, &target->cmd_queue, ilist) {
+ if (!test_and_set_bit(V_FLYING, &iue->flags)) {
+ spin_unlock_irqrestore(&target->lock, flags);
+ cmd = iue->sbuf->buf;
+ err = srp_cmd_queue(shost, cmd, iue, 0);
+ if (err) {
+ eprintk("cannot queue cmd %p %d\n", cmd, err);
+ srp_iu_put(iue);
+ }
+ goto retry;
+ }
+ }
+
+ spin_unlock_irqrestore(&target->lock, flags);
+}
+
+static int ibmvstgt_rdma(struct scsi_cmnd *sc, struct scatterlist *sg, int nsg,
+ struct srp_direct_buf *md, int nmd,
+ enum dma_data_direction dir, unsigned int rest)
+{
+ struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr;
+ struct srp_target *target = iue->target;
+ struct vio_port *vport = target_to_port(target);
+ dma_addr_t token;
+ long err;
+ unsigned int done = 0;
+ int i, sidx, soff;
+
+ sidx = soff = 0;
+ token = sg_dma_address(sg + sidx);
+
+ for (i = 0; i < nmd && rest; i++) {
+ unsigned int mdone, mlen;
+
+ mlen = min(rest, md[i].len);
+ for (mdone = 0; mlen;) {
+ int slen = min(sg_dma_len(sg + sidx) - soff, mlen);
+
+ if (dir == DMA_TO_DEVICE)
+ err = h_copy_rdma(slen,
+ vport->riobn,
+ md[i].va + mdone,
+ vport->liobn,
+ token + soff);
+ else
+ err = h_copy_rdma(slen,
+ vport->liobn,
+ token + soff,
+ vport->riobn,
+ md[i].va + mdone);
+
+ if (err != H_SUCCESS) {
+ eprintk("rdma error %d %d\n", dir, slen);
+ goto out;
+ }
+
+ mlen -= slen;
+ mdone += slen;
+ soff += slen;
+ done += slen;
+
+ if (soff == sg_dma_len(sg + sidx)) {
+ sidx++;
+ soff = 0;
+ token = sg_dma_address(sg + sidx);
+
+ if (sidx > nsg) {
+ eprintk("out of sg %p %d %d\n",
+ iue, sidx, nsg);
+ goto out;
+ }
+ }
+ };
+
+ rest -= mlen;
+ }
+out:
+
+ return 0;
+}
+
+static int ibmvstgt_transfer_data(struct scsi_cmnd *sc,
+ void (*done)(struct scsi_cmnd *))
+{
+ struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr;
+ int err;
+
+ err = srp_transfer_data(sc, &vio_iu(iue)->srp.cmd, ibmvstgt_rdma, 1, 1);
+
+ done(sc);
+
+ return err;
+}
+
+static int ibmvstgt_cmd_done(struct scsi_cmnd *sc,
+ void (*done)(struct scsi_cmnd *))
+{
+ unsigned long flags;
+ struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr;
+ struct srp_target *target = iue->target;
+
+ dprintk("%p %p %x\n", iue, target, vio_iu(iue)->srp.cmd.cdb[0]);
+
+ spin_lock_irqsave(&target->lock, flags);
+ list_del(&iue->ilist);
+ spin_unlock_irqrestore(&target->lock, flags);
+
+ if (sc->result != SAM_STAT_GOOD) {
+ eprintk("operation failed %p %d %x\n",
+ iue, sc->result, vio_iu(iue)->srp.cmd.cdb[0]);
+ send_rsp(iue, sc, HARDWARE_ERROR, 0x00);
+ } else
+ send_rsp(iue, sc, NO_SENSE, 0x00);
+
+ done(sc);
+ srp_iu_put(iue);
+ return 0;
+}
+
+int send_adapter_info(struct iu_entry *iue,
+ dma_addr_t remote_buffer, uint16_t length)
+{
+ struct srp_target *target = iue->target;
+ struct vio_port *vport = target_to_port(target);
+ struct Scsi_Host *shost = target->shost;
+ dma_addr_t data_token;
+ struct mad_adapter_info_data *info;
+ int err;
+
+ info = dma_alloc_coherent(target->dev, sizeof(*info), &data_token,
+ GFP_KERNEL);
+ if (!info) {
+ eprintk("bad dma_alloc_coherent %p\n", target);
+ return 1;
+ }
+
+ /* Get remote info */
+ err = h_copy_rdma(sizeof(*info), vport->riobn, remote_buffer,
+ vport->liobn, data_token);
+ if (err == H_SUCCESS) {
+ dprintk("Client connect: %s (%d)\n",
+ info->partition_name, info->partition_number);
+ }
+
+ memset(info, 0, sizeof(*info));
+
+ strcpy(info->srp_version, "16.a");
+ strncpy(info->partition_name, partition_name,
+ sizeof(info->partition_name));
+ info->partition_number = partition_number;
+ info->mad_version = 1;
+ info->os_type = 2;
+ info->port_max_txu[0] = shost->hostt->max_sectors << 9;
+
+ /* Send our info to remote */
+ err = h_copy_rdma(sizeof(*info), vport->liobn, data_token,
+ vport->riobn, remote_buffer);
+
+ dma_free_coherent(target->dev, sizeof(*info), info, data_token);
+
+ if (err != H_SUCCESS) {
+ eprintk("Error sending adapter info %d\n", err);
+ return 1;
+ }
+
+ return 0;
+}
+
+static void process_login(struct iu_entry *iue)
+{
+ union viosrp_iu *iu = vio_iu(iue);
+ struct srp_login_rsp *rsp = &iu->srp.login_rsp;
+ uint64_t tag = iu->srp.rsp.tag;
+
+ /* TODO handle case that requested size is wrong and
+ * buffer format is wrong
+ */
+ memset(iu, 0, sizeof(struct srp_login_rsp));
+ rsp->opcode = SRP_LOGIN_RSP;
+ rsp->req_lim_delta = INITIAL_SRP_LIMIT;
+ rsp->tag = tag;
+ rsp->max_it_iu_len = sizeof(union srp_iu);
+ rsp->max_ti_iu_len = sizeof(union srp_iu);
+ /* direct and indirect */
+ rsp->buf_fmt = SRP_BUF_FORMAT_DIRECT | SRP_BUF_FORMAT_INDIRECT;
+
+ send_iu(iue, sizeof(*rsp), VIOSRP_SRP_FORMAT);
+}
+
+static inline void queue_cmd(struct iu_entry *iue)
+{
+ struct srp_target *target = iue->target;
+ unsigned long flags;
+
+ spin_lock_irqsave(&target->lock, flags);
+ list_add_tail(&iue->ilist, &target->cmd_queue);
+ spin_unlock_irqrestore(&target->lock, flags);
+}
+
+static int process_tsk_mgmt(struct iu_entry *iue)
+{
+ union viosrp_iu *iu = vio_iu(iue);
+ int fn;
+
+ dprintk("%p %u\n", iue, iu->srp.tsk_mgmt.tsk_mgmt_func);
+
+ switch (iu->srp.tsk_mgmt.tsk_mgmt_func) {
+ case SRP_TSK_ABORT_TASK:
+ fn = ABORT_TASK;
+ break;
+ case SRP_TSK_ABORT_TASK_SET:
+ fn = ABORT_TASK_SET;
+ break;
+ case SRP_TSK_CLEAR_TASK_SET:
+ fn = CLEAR_TASK_SET;
+ break;
+ case SRP_TSK_LUN_RESET:
+ fn = LOGICAL_UNIT_RESET;
+ break;
+ case SRP_TSK_CLEAR_ACA:
+ fn = CLEAR_ACA;
+ break;
+ default:
+ fn = 0;
+ }
+ if (fn)
+ scsi_tgt_tsk_mgmt_request(iue->target->shost, fn,
+ iu->srp.tsk_mgmt.task_tag,
+ (struct scsi_lun *) &iu->srp.tsk_mgmt.lun,
+ iue);
+ else
+ send_rsp(iue, NULL, ILLEGAL_REQUEST, 0x20);
+
+ return !fn;
+}
+
+static int process_mad_iu(struct iu_entry *iue)
+{
+ union viosrp_iu *iu = vio_iu(iue);
+ struct viosrp_adapter_info *info;
+ struct viosrp_host_config *conf;
+
+ switch (iu->mad.empty_iu.common.type) {
+ case VIOSRP_EMPTY_IU_TYPE:
+ eprintk("%s\n", "Unsupported EMPTY MAD IU");
+ break;
+ case VIOSRP_ERROR_LOG_TYPE:
+ eprintk("%s\n", "Unsupported ERROR LOG MAD IU");
+ iu->mad.error_log.common.status = 1;
+ send_iu(iue, sizeof(iu->mad.error_log), VIOSRP_MAD_FORMAT);
+ break;
+ case VIOSRP_ADAPTER_INFO_TYPE:
+ info = &iu->mad.adapter_info;
+ info->common.status = send_adapter_info(iue, info->buffer,
+ info->common.length);
+ send_iu(iue, sizeof(*info), VIOSRP_MAD_FORMAT);
+ break;
+ case VIOSRP_HOST_CONFIG_TYPE:
+ conf = &iu->mad.host_config;
+ conf->common.status = 1;
+ send_iu(iue, sizeof(*conf), VIOSRP_MAD_FORMAT);
+ break;
+ default:
+ eprintk("Unknown type %u\n", iu->srp.rsp.opcode);
+ }
+
+ return 1;
+}
+
+static int process_srp_iu(struct iu_entry *iue)
+{
+ union viosrp_iu *iu = vio_iu(iue);
+ int done = 1;
+ u8 opcode = iu->srp.rsp.opcode;
+
+ switch (opcode) {
+ case SRP_LOGIN_REQ:
+ process_login(iue);
+ break;
+ case SRP_TSK_MGMT:
+ done = process_tsk_mgmt(iue);
+ break;
+ case SRP_CMD:
+ queue_cmd(iue);
+ done = 0;
+ break;
+ case SRP_LOGIN_RSP:
+ case SRP_I_LOGOUT:
+ case SRP_T_LOGOUT:
+ case SRP_RSP:
+ case SRP_CRED_REQ:
+ case SRP_CRED_RSP:
+ case SRP_AER_REQ:
+ case SRP_AER_RSP:
+ eprintk("Unsupported type %u\n", opcode);
+ break;
+ default:
+ eprintk("Unknown type %u\n", opcode);
+ }
+
+ return done;
+}
+
+static void process_iu(struct viosrp_crq *crq, struct srp_target *target)
+{
+ struct vio_port *vport = target_to_port(target);
+ struct iu_entry *iue;
+ long err, done;
+
+ iue = srp_iu_get(target);
+ if (!iue) {
+ eprintk("Error getting IU from pool, %p\n", target);
+ return;
+ }
+
+ iue->remote_token = crq->IU_data_ptr;
+
+ err = h_copy_rdma(crq->IU_length, vport->riobn,
+ iue->remote_token, vport->liobn, iue->sbuf->dma);
+
+ if (err != H_SUCCESS) {
+ eprintk("%ld transferring data error %p\n", err, iue);
+ done = 1;
+ goto out;
+ }
+
+ if (crq->format == VIOSRP_MAD_FORMAT)
+ done = process_mad_iu(iue);
+ else
+ done = process_srp_iu(iue);
+out:
+ if (done)
+ srp_iu_put(iue);
+}
+
+static irqreturn_t ibmvstgt_interrupt(int irq, void *data)
+{
+ struct srp_target *target = (struct srp_target *) data;
+ struct vio_port *vport = target_to_port(target);
+
+ vio_disable_interrupts(vport->dma_dev);
+ queue_work(vtgtd, &vport->crq_work);
+
+ return IRQ_HANDLED;
+}
+
+static int crq_queue_create(struct crq_queue *queue, struct srp_target *target)
+{
+ int err;
+ struct vio_port *vport = target_to_port(target);
+
+ queue->msgs = (struct viosrp_crq *) get_zeroed_page(GFP_KERNEL);
+ if (!queue->msgs)
+ goto malloc_failed;
+ queue->size = PAGE_SIZE / sizeof(*queue->msgs);
+
+ queue->msg_token = dma_map_single(target->dev, queue->msgs,
+ queue->size * sizeof(*queue->msgs),
+ DMA_BIDIRECTIONAL);
+
+ if (dma_mapping_error(queue->msg_token))
+ goto map_failed;
+
+ err = h_reg_crq(vport->dma_dev->unit_address, queue->msg_token,
+ PAGE_SIZE);
+
+ /* If the adapter was left active for some reason (like kexec)
+ * try freeing and re-registering
+ */
+ if (err == H_RESOURCE) {
+ do {
+ err = h_free_crq(vport->dma_dev->unit_address);
+ } while (err == H_BUSY || H_IS_LONG_BUSY(err));
+
+ err = h_reg_crq(vport->dma_dev->unit_address, queue->msg_token,
+ PAGE_SIZE);
+ }
+
+ if (err != H_SUCCESS && err != 2) {
+ eprintk("Error 0x%x opening virtual adapter\n", err);
+ goto reg_crq_failed;
+ }
+
+ err = request_irq(vport->dma_dev->irq, &ibmvstgt_interrupt,
+ SA_INTERRUPT, "ibmvstgt", target);
+ if (err)
+ goto req_irq_failed;
+
+ vio_enable_interrupts(vport->dma_dev);
+
+ h_send_crq(vport->dma_dev->unit_address, 0xC001000000000000, 0);
+
+ queue->cur = 0;
+ spin_lock_init(&queue->lock);
+
+ return 0;
+
+req_irq_failed:
+ do {
+ err = h_free_crq(vport->dma_dev->unit_address);
+ } while (err == H_BUSY || H_IS_LONG_BUSY(err));
+
+reg_crq_failed:
+ dma_unmap_single(target->dev, queue->msg_token,
+ queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL);
+map_failed:
+ free_page((unsigned long) queue->msgs);
+
+malloc_failed:
+ return -ENOMEM;
+}
+
+static void crq_queue_destroy(struct srp_target *target)
+{
+ struct vio_port *vport = target_to_port(target);
+ struct crq_queue *queue = &vport->crq_queue;
+ int err;
+
+ free_irq(vport->dma_dev->irq, target);
+ do {
+ err = h_free_crq(vport->dma_dev->unit_address);
+ } while (err == H_BUSY || H_IS_LONG_BUSY(err));
+
+ dma_unmap_single(target->dev, queue->msg_token,
+ queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL);
+
+ free_page((unsigned long) queue->msgs);
+}
+
+static void process_crq(struct viosrp_crq *crq, struct srp_target *target)
+{
+ struct vio_port *vport = target_to_port(target);
+ dprintk("%x %x\n", crq->valid, crq->format);
+
+ switch (crq->valid) {
+ case 0xC0:
+ /* initialization */
+ switch (crq->format) {
+ case 0x01:
+ h_send_crq(vport->dma_dev->unit_address,
+ 0xC002000000000000, 0);
+ break;
+ case 0x02:
+ break;
+ default:
+ eprintk("Unknown format %u\n", crq->format);
+ }
+ break;
+ case 0xFF:
+ /* transport event */
+ break;
+ case 0x80:
+ /* real payload */
+ switch (crq->format) {
+ case VIOSRP_SRP_FORMAT:
+ case VIOSRP_MAD_FORMAT:
+ process_iu(crq, target);
+ break;
+ case VIOSRP_OS400_FORMAT:
+ case VIOSRP_AIX_FORMAT:
+ case VIOSRP_LINUX_FORMAT:
+ case VIOSRP_INLINE_FORMAT:
+ eprintk("Unsupported format %u\n", crq->format);
+ break;
+ default:
+ eprintk("Unknown format %u\n", crq->format);
+ }
+ break;
+ default:
+ eprintk("unknown message type 0x%02x!?\n", crq->valid);
+ }
+}
+
+static inline struct viosrp_crq *next_crq(struct crq_queue *queue)
+{
+ struct viosrp_crq *crq;
+ unsigned long flags;
+
+ spin_lock_irqsave(&queue->lock, flags);
+ crq = &queue->msgs[queue->cur];
+ if (crq->valid & 0x80) {
+ if (++queue->cur == queue->size)
+ queue->cur = 0;
+ } else
+ crq = NULL;
+ spin_unlock_irqrestore(&queue->lock, flags);
+
+ return crq;
+}
+
+static void handle_crq(void *data)
+{
+ struct srp_target *target = (struct srp_target *) data;
+ struct vio_port *vport = target_to_port(target);
+ struct viosrp_crq *crq;
+ int done = 0;
+
+ while (!done) {
+ while ((crq = next_crq(&vport->crq_queue)) != NULL) {
+ process_crq(crq, target);
+ crq->valid = 0x00;
+ }
+
+ vio_enable_interrupts(vport->dma_dev);
+
+ crq = next_crq(&vport->crq_queue);
+ if (crq) {
+ vio_disable_interrupts(vport->dma_dev);
+ process_crq(crq, target);
+ crq->valid = 0x00;
+ } else
+ done = 1;
+ }
+
+ handle_cmd_queue(target);
+}
+
+
+static int ibmvstgt_eh_abort_handler(struct scsi_cmnd *sc)
+{
+ unsigned long flags;
+ struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr;
+ struct srp_target *target = iue->target;
+
+ dprintk("%p %p %x\n", iue, target, vio_iu(iue)->srp.cmd.cdb[0]);
+
+ spin_lock_irqsave(&target->lock, flags);
+ list_del(&iue->ilist);
+ spin_unlock_irqrestore(&target->lock, flags);
+
+ srp_iu_put(iue);
+
+ return 0;
+}
+
+static int ibmvstgt_tsk_mgmt_response(u64 mid, int result)
+{
+ struct iu_entry *iue = (struct iu_entry *) ((void *) mid);
+ union viosrp_iu *iu = vio_iu(iue);
+ unsigned char status, asc;
+
+ eprintk("%p %d\n", iue, result);
+ status = NO_SENSE;
+ asc = 0;
+
+ switch (iu->srp.tsk_mgmt.tsk_mgmt_func) {
+ case SRP_TSK_ABORT_TASK:
+ asc = 0x14;
+ if (result)
+ status = ABORTED_COMMAND;
+ break;
+ default:
+ break;
+ }
+
+ send_rsp(iue, NULL, status, asc);
+ srp_iu_put(iue);
+
+ return 0;
+}
+
+static ssize_t system_id_show(struct class_device *cdev, char *buf)
+{
+ return snprintf(buf, PAGE_SIZE, "%s\n", system_id);
+}
+
+static ssize_t partition_number_show(struct class_device *cdev, char *buf)
+{
+ return snprintf(buf, PAGE_SIZE, "%x\n", partition_number);
+}
+
+static ssize_t unit_address_show(struct class_device *cdev, char *buf)
+{
+ struct Scsi_Host *shost = class_to_shost(cdev);
+ struct srp_target *target = host_to_srp_target(shost);
+ struct vio_port *vport = target_to_port(target);
+ return snprintf(buf, PAGE_SIZE, "%x\n", vport->dma_dev->unit_address);
+}
+
+static CLASS_DEVICE_ATTR(system_id, S_IRUGO, system_id_show, NULL);
+static CLASS_DEVICE_ATTR(partition_number, S_IRUGO, partition_number_show, NULL);
+static CLASS_DEVICE_ATTR(unit_address, S_IRUGO, unit_address_show, NULL);
+
+static struct class_device_attribute *ibmvstgt_attrs[] = {
+ &class_device_attr_system_id,
+ &class_device_attr_partition_number,
+ &class_device_attr_unit_address,
+ NULL,
+};
+
+static struct scsi_host_template ibmvstgt_sht = {
+ .name = TGT_NAME,
+ .module = THIS_MODULE,
+ .can_queue = INITIAL_SRP_LIMIT,
+ .sg_tablesize = SG_ALL,
+ .use_clustering = DISABLE_CLUSTERING,
+ .max_sectors = DEFAULT_MAX_SECTORS,
+ .transfer_response = ibmvstgt_cmd_done,
+ .transfer_data = ibmvstgt_transfer_data,
+ .eh_abort_handler = ibmvstgt_eh_abort_handler,
+ .tsk_mgmt_response = ibmvstgt_tsk_mgmt_response,
+ .shost_attrs = ibmvstgt_attrs,
+ .proc_name = TGT_NAME,
+};
+
+static int ibmvstgt_probe(struct vio_dev *dev, const struct vio_device_id *id)
+{
+ struct Scsi_Host *shost;
+ struct srp_target *target;
+ struct vio_port *vport;
+ unsigned int *dma, dma_size;
+ int err = -ENOMEM;
+
+ vport = kzalloc(sizeof(struct vio_port), GFP_KERNEL);
+ if (!vport)
+ return err;
+ shost = scsi_host_alloc(&ibmvstgt_sht, sizeof(struct srp_target));
+ if (!shost)
+ goto free_vport;
+ err = scsi_tgt_alloc_queue(shost);
+ if (err)
+ goto put_host;
+
+ target = host_to_srp_target(shost);
+ target->shost = shost;
+ vport->dma_dev = dev;
+ target->ldata = vport;
+ err = srp_target_alloc(target, &dev->dev, INITIAL_SRP_LIMIT,
+ SRP_MAX_IU_LEN);
+ if (err)
+ goto put_host;
+
+ dma = (unsigned int *) vio_get_attribute(dev, "ibm,my-dma-window",
+ &dma_size);
+ if (!dma || dma_size != 40) {
+ eprintk("Couldn't get window property %d\n", dma_size);
+ err = -EIO;
+ goto free_srp_target;
+ }
+ vport->liobn = dma[0];
+ vport->riobn = dma[5];
+
+ INIT_WORK(&vport->crq_work, handle_crq, target);
+
+ err = crq_queue_create(&vport->crq_queue, target);
+ if (err)
+ goto free_srp_target;
+
+ err = scsi_add_host(shost, target->dev);
+ if (err)
+ goto destroy_queue;
+ return 0;
+
+destroy_queue:
+ crq_queue_destroy(target);
+free_srp_target:
+ srp_target_free(target);
+put_host:
+ scsi_host_put(shost);
+free_vport:
+ kfree(vport);
+ return err;
+}
+
+static int ibmvstgt_remove(struct vio_dev *dev)
+{
+ struct srp_target *target = (struct srp_target *) dev->dev.driver_data;
+ struct Scsi_Host *shost = target->shost;
+ struct vio_port *vport = target->ldata;
+
+ crq_queue_destroy(target);
+ scsi_remove_host(shost);
+ scsi_tgt_free_queue(shost);
+ srp_target_free(target);
+ kfree(vport);
+ scsi_host_put(shost);
+ return 0;
+}
+
+static struct vio_device_id ibmvstgt_device_table[] __devinitdata = {
+ {"v-scsi-host", "IBM,v-scsi-host"},
+ {"",""}
+};
+
+MODULE_DEVICE_TABLE(vio, ibmvstgt_device_table);
+
+static struct vio_driver ibmvstgt_driver = {
+ .id_table = ibmvstgt_device_table,
+ .probe = ibmvstgt_probe,
+ .remove = ibmvstgt_remove,
+ .driver = {
+ .name = "ibmvscsis",
+ .owner = THIS_MODULE,
+ }
+};
+
+static int get_system_info(void)
+{
+ struct device_node *rootdn;
+ const char *id, *model, *name;
+ unsigned int *num;
+
+ rootdn = find_path_device("/");
+ if (!rootdn)
+ return -ENOENT;
+
+ model = get_property(rootdn, "model", NULL);
+ id = get_property(rootdn, "system-id", NULL);
+ if (model && id)
+ snprintf(system_id, sizeof(system_id), "%s-%s", model, id);
+
+ name = get_property(rootdn, "ibm,partition-name", NULL);
+ if (name)
+ strncpy(partition_name, name, sizeof(partition_name));
+
+ num = (unsigned int *) get_property(rootdn, "ibm,partition-no", NULL);
+ if (num)
+ partition_number = *num;
+
+ return 0;
+}
+
+static int ibmvstgt_init(void)
+{
+ int err = -ENOMEM;
+
+ printk("IBM eServer i/pSeries Virtual SCSI Target Driver\n");
+
+ vtgtd = create_workqueue("ibmvtgtd");
+ if (!vtgtd)
+ return err;
+
+ err = get_system_info();
+ if (err)
+ goto destroy_wq;
+
+ err = vio_register_driver(&ibmvstgt_driver);
+ if (err)
+ goto destroy_wq;
+
+ return 0;
+
+destroy_wq:
+ destroy_workqueue(vtgtd);
+ return err;
+}
+
+static void ibmvstgt_exit(void)
+{
+ printk("Unregister IBM virtual SCSI driver\n");
+
+ destroy_workqueue(vtgtd);
+ vio_unregister_driver(&ibmvstgt_driver);
+}
+
+MODULE_DESCRIPTION("IBM Virtual SCSI Target");
+MODULE_AUTHOR("Dave Boutcher");
+MODULE_LICENSE("GPL");
+
+module_init(ibmvstgt_init);
+module_exit(ibmvstgt_exit);
--
1.4.3.2
^ permalink raw reply related [flat|nested] 5+ messages in thread
* Re: [PATCH 8/8] scsi tgt: IBM eServer i/pSeries virtual SCSI target driver
2006-11-16 10:24 [PATCH 8/8] scsi tgt: IBM eServer i/pSeries virtual SCSI target driver FUJITA Tomonori
@ 2006-11-28 14:31 ` FUJITA Tomonori
2006-11-30 15:38 ` Santiago Leon
0 siblings, 1 reply; 5+ messages in thread
From: FUJITA Tomonori @ 2006-11-28 14:31 UTC (permalink / raw)
To: santil, boutcher; +Cc: linux-scsi
Hi ibmvscsi team,
Can I get your ACK on this patch to get it merged into the scsi-misc?
From: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
Subject: [PATCH 8/8] scsi tgt: IBM eServer i/pSeries virtual SCSI target driver
Date: Thu, 16 Nov 2006 19:24:26 +0900
> This is IBM Virtual SCSI target driver for tgt. The driver is based on
> the original ibmvscsis driver:
>
> http://lkml.org/lkml/2005/10/17/99
>
>
> Signed-off-by: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
> Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
> Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
> ---
> drivers/scsi/Kconfig | 14 +
> drivers/scsi/Makefile | 1 +
> drivers/scsi/ibmvscsi/Makefile | 2 +
> drivers/scsi/ibmvscsi/ibmvstgt.c | 958 ++++++++++++++++++++++++++++++++++++++
> 4 files changed, 975 insertions(+), 0 deletions(-)
>
> diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
> index e5dd59e..87c51fd 100644
> --- a/drivers/scsi/Kconfig
> +++ b/drivers/scsi/Kconfig
> @@ -804,6 +804,20 @@ config SCSI_IBMVSCSI
> To compile this driver as a module, choose M here: the
> module will be called ibmvscsic.
>
> +config SCSI_IBMVSCSIS
> + tristate "IBM Virtual SCSI Server support"
> + depends on PPC_PSERIES && SCSI_TGT && SCSI_SRP
> + help
> + This is the SRP target driver for IBM pSeries virtual environments.
> +
> + The userspace component needed to initialize the driver and
> + documentation can be found:
> +
> + http://stgt.berlios.de/
> +
> + To compile this driver as a module, choose M here: the
> + module will be called ibmvstgt.
> +
> config SCSI_INITIO
> tristate "Initio 9100U(W) support"
> depends on PCI && SCSI
> diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile
> index a6281fd..854b98b 100644
> --- a/drivers/scsi/Makefile
> +++ b/drivers/scsi/Makefile
> @@ -128,6 +128,7 @@ obj-$(CONFIG_SCSI_NSP32) += nsp32.o
> obj-$(CONFIG_SCSI_IPR) += ipr.o
> obj-$(CONFIG_SCSI_SRP) += libsrp.o
> obj-$(CONFIG_SCSI_IBMVSCSI) += ibmvscsi/
> +obj-$(CONFIG_SCSI_IBMVSCSIS) += ibmvscsi/
> obj-$(CONFIG_SCSI_HPTIOP) += hptiop.o
> obj-$(CONFIG_SCSI_STEX) += stex.o
>
> diff --git a/drivers/scsi/ibmvscsi/Makefile b/drivers/scsi/ibmvscsi/Makefile
> index 4e247b6..6ac0633 100644
> --- a/drivers/scsi/ibmvscsi/Makefile
> +++ b/drivers/scsi/ibmvscsi/Makefile
> @@ -3,3 +3,5 @@ obj-$(CONFIG_SCSI_IBMVSCSI) += ibmvscsic
> ibmvscsic-y += ibmvscsi.o
> ibmvscsic-$(CONFIG_PPC_ISERIES) += iseries_vscsi.o
> ibmvscsic-$(CONFIG_PPC_PSERIES) += rpa_vscsi.o
> +
> +obj-$(CONFIG_SCSI_IBMVSCSIS) += ibmvstgt.o
> diff --git a/drivers/scsi/ibmvscsi/ibmvstgt.c b/drivers/scsi/ibmvscsi/ibmvstgt.c
> new file mode 100644
> index 0000000..73fcfca
> --- /dev/null
> +++ b/drivers/scsi/ibmvscsi/ibmvstgt.c
> @@ -0,0 +1,958 @@
> +/*
> + * IBM eServer i/pSeries Virtual SCSI Target Driver
> + * Copyright (C) 2003-2005 Dave Boutcher (boutcher@us.ibm.com) IBM Corp.
> + * Santiago Leon (santil@us.ibm.com) IBM Corp.
> + * Linda Xie (lxie@us.ibm.com) IBM Corp.
> + *
> + * Copyright (C) 2005-2006 FUJITA Tomonori <tomof@acm.org>
> + *
> + * 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/interrupt.h>
> +#include <linux/module.h>
> +#include <scsi/scsi.h>
> +#include <scsi/scsi_host.h>
> +#include <scsi/scsi_tgt.h>
> +#include <scsi/libsrp.h>
> +#include <asm/hvcall.h>
> +#include <asm/iommu.h>
> +#include <asm/prom.h>
> +#include <asm/vio.h>
> +
> +#include "ibmvscsi.h"
> +
> +#define INITIAL_SRP_LIMIT 16
> +#define DEFAULT_MAX_SECTORS 512
> +
> +#define TGT_NAME "ibmvstgt"
> +
> +/*
> + * Hypervisor calls.
> + */
> +#define h_copy_rdma(l, sa, sb, da, db) \
> + plpar_hcall_norets(H_COPY_RDMA, l, sa, sb, da, db)
> +#define h_send_crq(ua, l, h) \
> + plpar_hcall_norets(H_SEND_CRQ, ua, l, h)
> +#define h_reg_crq(ua, tok, sz)\
> + plpar_hcall_norets(H_REG_CRQ, ua, tok, sz);
> +#define h_free_crq(ua) \
> + plpar_hcall_norets(H_FREE_CRQ, ua);
> +
> +/* tmp - will replace with SCSI logging stuff */
> +#define eprintk(fmt, args...) \
> +do { \
> + printk("%s(%d) " fmt, __FUNCTION__, __LINE__, ##args); \
> +} while (0)
> +/* #define dprintk eprintk */
> +#define dprintk(fmt, args...)
> +
> +struct vio_port {
> + struct vio_dev *dma_dev;
> +
> + struct crq_queue crq_queue;
> + struct work_struct crq_work;
> +
> + unsigned long liobn;
> + unsigned long riobn;
> +};
> +
> +static struct workqueue_struct *vtgtd;
> +
> +/*
> + * These are fixed for the system and come from the Open Firmware device tree.
> + * We just store them here to save getting them every time.
> + */
> +static char system_id[64] = "";
> +static char partition_name[97] = "UNKNOWN";
> +static unsigned int partition_number = -1;
> +
> +static struct vio_port *target_to_port(struct srp_target *target)
> +{
> + return (struct vio_port *) target->ldata;
> +}
> +
> +static inline union viosrp_iu *vio_iu(struct iu_entry *iue)
> +{
> + return (union viosrp_iu *) (iue->sbuf->buf);
> +}
> +
> +static int send_iu(struct iu_entry *iue, uint64_t length, uint8_t format)
> +{
> + struct srp_target *target = iue->target;
> + struct vio_port *vport = target_to_port(target);
> + long rc, rc1;
> + union {
> + struct viosrp_crq cooked;
> + uint64_t raw[2];
> + } crq;
> +
> + /* First copy the SRP */
> + rc = h_copy_rdma(length, vport->liobn, iue->sbuf->dma,
> + vport->riobn, iue->remote_token);
> +
> + if (rc)
> + eprintk("Error %ld transferring data\n", rc);
> +
> + crq.cooked.valid = 0x80;
> + crq.cooked.format = format;
> + crq.cooked.reserved = 0x00;
> + crq.cooked.timeout = 0x00;
> + crq.cooked.IU_length = length;
> + crq.cooked.IU_data_ptr = vio_iu(iue)->srp.rsp.tag;
> +
> + if (rc == 0)
> + crq.cooked.status = 0x99; /* Just needs to be non-zero */
> + else
> + crq.cooked.status = 0x00;
> +
> + rc1 = h_send_crq(vport->dma_dev->unit_address, crq.raw[0], crq.raw[1]);
> +
> + if (rc1) {
> + eprintk("%ld sending response\n", rc1);
> + return rc1;
> + }
> +
> + return rc;
> +}
> +
> +#define SRP_RSP_SENSE_DATA_LEN 18
> +
> +static int send_rsp(struct iu_entry *iue, struct scsi_cmnd *sc,
> + unsigned char status, unsigned char asc)
> +{
> + union viosrp_iu *iu = vio_iu(iue);
> + uint64_t tag = iu->srp.rsp.tag;
> +
> + /* If the linked bit is on and status is good */
> + if (test_bit(V_LINKED, &iue->flags) && (status == NO_SENSE))
> + status = 0x10;
> +
> + memset(iu, 0, sizeof(struct srp_rsp));
> + iu->srp.rsp.opcode = SRP_RSP;
> + iu->srp.rsp.req_lim_delta = 1;
> + iu->srp.rsp.tag = tag;
> +
> + if (test_bit(V_DIOVER, &iue->flags))
> + iu->srp.rsp.flags |= SRP_RSP_FLAG_DIOVER;
> +
> + iu->srp.rsp.data_in_res_cnt = 0;
> + iu->srp.rsp.data_out_res_cnt = 0;
> +
> + iu->srp.rsp.flags &= ~SRP_RSP_FLAG_RSPVALID;
> +
> + iu->srp.rsp.resp_data_len = 0;
> + iu->srp.rsp.status = status;
> + if (status) {
> + uint8_t *sense = iu->srp.rsp.data;
> +
> + if (sc) {
> + iu->srp.rsp.flags |= SRP_RSP_FLAG_SNSVALID;
> + iu->srp.rsp.sense_data_len = SCSI_SENSE_BUFFERSIZE;
> + memcpy(sense, sc->sense_buffer, SCSI_SENSE_BUFFERSIZE);
> + } else {
> + iu->srp.rsp.status = SAM_STAT_CHECK_CONDITION;
> + iu->srp.rsp.flags |= SRP_RSP_FLAG_SNSVALID;
> + iu->srp.rsp.sense_data_len = SRP_RSP_SENSE_DATA_LEN;
> +
> + /* Valid bit and 'current errors' */
> + sense[0] = (0x1 << 7 | 0x70);
> + /* Sense key */
> + sense[2] = status;
> + /* Additional sense length */
> + sense[7] = 0xa; /* 10 bytes */
> + /* Additional sense code */
> + sense[12] = asc;
> + }
> + }
> +
> + send_iu(iue, sizeof(iu->srp.rsp) + SRP_RSP_SENSE_DATA_LEN,
> + VIOSRP_SRP_FORMAT);
> +
> + return 0;
> +}
> +
> +static void handle_cmd_queue(struct srp_target *target)
> +{
> + struct Scsi_Host *shost = target->shost;
> + struct iu_entry *iue;
> + struct srp_cmd *cmd;
> + unsigned long flags;
> + int err;
> +
> +retry:
> + spin_lock_irqsave(&target->lock, flags);
> +
> + list_for_each_entry(iue, &target->cmd_queue, ilist) {
> + if (!test_and_set_bit(V_FLYING, &iue->flags)) {
> + spin_unlock_irqrestore(&target->lock, flags);
> + cmd = iue->sbuf->buf;
> + err = srp_cmd_queue(shost, cmd, iue, 0);
> + if (err) {
> + eprintk("cannot queue cmd %p %d\n", cmd, err);
> + srp_iu_put(iue);
> + }
> + goto retry;
> + }
> + }
> +
> + spin_unlock_irqrestore(&target->lock, flags);
> +}
> +
> +static int ibmvstgt_rdma(struct scsi_cmnd *sc, struct scatterlist *sg, int nsg,
> + struct srp_direct_buf *md, int nmd,
> + enum dma_data_direction dir, unsigned int rest)
> +{
> + struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr;
> + struct srp_target *target = iue->target;
> + struct vio_port *vport = target_to_port(target);
> + dma_addr_t token;
> + long err;
> + unsigned int done = 0;
> + int i, sidx, soff;
> +
> + sidx = soff = 0;
> + token = sg_dma_address(sg + sidx);
> +
> + for (i = 0; i < nmd && rest; i++) {
> + unsigned int mdone, mlen;
> +
> + mlen = min(rest, md[i].len);
> + for (mdone = 0; mlen;) {
> + int slen = min(sg_dma_len(sg + sidx) - soff, mlen);
> +
> + if (dir == DMA_TO_DEVICE)
> + err = h_copy_rdma(slen,
> + vport->riobn,
> + md[i].va + mdone,
> + vport->liobn,
> + token + soff);
> + else
> + err = h_copy_rdma(slen,
> + vport->liobn,
> + token + soff,
> + vport->riobn,
> + md[i].va + mdone);
> +
> + if (err != H_SUCCESS) {
> + eprintk("rdma error %d %d\n", dir, slen);
> + goto out;
> + }
> +
> + mlen -= slen;
> + mdone += slen;
> + soff += slen;
> + done += slen;
> +
> + if (soff == sg_dma_len(sg + sidx)) {
> + sidx++;
> + soff = 0;
> + token = sg_dma_address(sg + sidx);
> +
> + if (sidx > nsg) {
> + eprintk("out of sg %p %d %d\n",
> + iue, sidx, nsg);
> + goto out;
> + }
> + }
> + };
> +
> + rest -= mlen;
> + }
> +out:
> +
> + return 0;
> +}
> +
> +static int ibmvstgt_transfer_data(struct scsi_cmnd *sc,
> + void (*done)(struct scsi_cmnd *))
> +{
> + struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr;
> + int err;
> +
> + err = srp_transfer_data(sc, &vio_iu(iue)->srp.cmd, ibmvstgt_rdma, 1, 1);
> +
> + done(sc);
> +
> + return err;
> +}
> +
> +static int ibmvstgt_cmd_done(struct scsi_cmnd *sc,
> + void (*done)(struct scsi_cmnd *))
> +{
> + unsigned long flags;
> + struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr;
> + struct srp_target *target = iue->target;
> +
> + dprintk("%p %p %x\n", iue, target, vio_iu(iue)->srp.cmd.cdb[0]);
> +
> + spin_lock_irqsave(&target->lock, flags);
> + list_del(&iue->ilist);
> + spin_unlock_irqrestore(&target->lock, flags);
> +
> + if (sc->result != SAM_STAT_GOOD) {
> + eprintk("operation failed %p %d %x\n",
> + iue, sc->result, vio_iu(iue)->srp.cmd.cdb[0]);
> + send_rsp(iue, sc, HARDWARE_ERROR, 0x00);
> + } else
> + send_rsp(iue, sc, NO_SENSE, 0x00);
> +
> + done(sc);
> + srp_iu_put(iue);
> + return 0;
> +}
> +
> +int send_adapter_info(struct iu_entry *iue,
> + dma_addr_t remote_buffer, uint16_t length)
> +{
> + struct srp_target *target = iue->target;
> + struct vio_port *vport = target_to_port(target);
> + struct Scsi_Host *shost = target->shost;
> + dma_addr_t data_token;
> + struct mad_adapter_info_data *info;
> + int err;
> +
> + info = dma_alloc_coherent(target->dev, sizeof(*info), &data_token,
> + GFP_KERNEL);
> + if (!info) {
> + eprintk("bad dma_alloc_coherent %p\n", target);
> + return 1;
> + }
> +
> + /* Get remote info */
> + err = h_copy_rdma(sizeof(*info), vport->riobn, remote_buffer,
> + vport->liobn, data_token);
> + if (err == H_SUCCESS) {
> + dprintk("Client connect: %s (%d)\n",
> + info->partition_name, info->partition_number);
> + }
> +
> + memset(info, 0, sizeof(*info));
> +
> + strcpy(info->srp_version, "16.a");
> + strncpy(info->partition_name, partition_name,
> + sizeof(info->partition_name));
> + info->partition_number = partition_number;
> + info->mad_version = 1;
> + info->os_type = 2;
> + info->port_max_txu[0] = shost->hostt->max_sectors << 9;
> +
> + /* Send our info to remote */
> + err = h_copy_rdma(sizeof(*info), vport->liobn, data_token,
> + vport->riobn, remote_buffer);
> +
> + dma_free_coherent(target->dev, sizeof(*info), info, data_token);
> +
> + if (err != H_SUCCESS) {
> + eprintk("Error sending adapter info %d\n", err);
> + return 1;
> + }
> +
> + return 0;
> +}
> +
> +static void process_login(struct iu_entry *iue)
> +{
> + union viosrp_iu *iu = vio_iu(iue);
> + struct srp_login_rsp *rsp = &iu->srp.login_rsp;
> + uint64_t tag = iu->srp.rsp.tag;
> +
> + /* TODO handle case that requested size is wrong and
> + * buffer format is wrong
> + */
> + memset(iu, 0, sizeof(struct srp_login_rsp));
> + rsp->opcode = SRP_LOGIN_RSP;
> + rsp->req_lim_delta = INITIAL_SRP_LIMIT;
> + rsp->tag = tag;
> + rsp->max_it_iu_len = sizeof(union srp_iu);
> + rsp->max_ti_iu_len = sizeof(union srp_iu);
> + /* direct and indirect */
> + rsp->buf_fmt = SRP_BUF_FORMAT_DIRECT | SRP_BUF_FORMAT_INDIRECT;
> +
> + send_iu(iue, sizeof(*rsp), VIOSRP_SRP_FORMAT);
> +}
> +
> +static inline void queue_cmd(struct iu_entry *iue)
> +{
> + struct srp_target *target = iue->target;
> + unsigned long flags;
> +
> + spin_lock_irqsave(&target->lock, flags);
> + list_add_tail(&iue->ilist, &target->cmd_queue);
> + spin_unlock_irqrestore(&target->lock, flags);
> +}
> +
> +static int process_tsk_mgmt(struct iu_entry *iue)
> +{
> + union viosrp_iu *iu = vio_iu(iue);
> + int fn;
> +
> + dprintk("%p %u\n", iue, iu->srp.tsk_mgmt.tsk_mgmt_func);
> +
> + switch (iu->srp.tsk_mgmt.tsk_mgmt_func) {
> + case SRP_TSK_ABORT_TASK:
> + fn = ABORT_TASK;
> + break;
> + case SRP_TSK_ABORT_TASK_SET:
> + fn = ABORT_TASK_SET;
> + break;
> + case SRP_TSK_CLEAR_TASK_SET:
> + fn = CLEAR_TASK_SET;
> + break;
> + case SRP_TSK_LUN_RESET:
> + fn = LOGICAL_UNIT_RESET;
> + break;
> + case SRP_TSK_CLEAR_ACA:
> + fn = CLEAR_ACA;
> + break;
> + default:
> + fn = 0;
> + }
> + if (fn)
> + scsi_tgt_tsk_mgmt_request(iue->target->shost, fn,
> + iu->srp.tsk_mgmt.task_tag,
> + (struct scsi_lun *) &iu->srp.tsk_mgmt.lun,
> + iue);
> + else
> + send_rsp(iue, NULL, ILLEGAL_REQUEST, 0x20);
> +
> + return !fn;
> +}
> +
> +static int process_mad_iu(struct iu_entry *iue)
> +{
> + union viosrp_iu *iu = vio_iu(iue);
> + struct viosrp_adapter_info *info;
> + struct viosrp_host_config *conf;
> +
> + switch (iu->mad.empty_iu.common.type) {
> + case VIOSRP_EMPTY_IU_TYPE:
> + eprintk("%s\n", "Unsupported EMPTY MAD IU");
> + break;
> + case VIOSRP_ERROR_LOG_TYPE:
> + eprintk("%s\n", "Unsupported ERROR LOG MAD IU");
> + iu->mad.error_log.common.status = 1;
> + send_iu(iue, sizeof(iu->mad.error_log), VIOSRP_MAD_FORMAT);
> + break;
> + case VIOSRP_ADAPTER_INFO_TYPE:
> + info = &iu->mad.adapter_info;
> + info->common.status = send_adapter_info(iue, info->buffer,
> + info->common.length);
> + send_iu(iue, sizeof(*info), VIOSRP_MAD_FORMAT);
> + break;
> + case VIOSRP_HOST_CONFIG_TYPE:
> + conf = &iu->mad.host_config;
> + conf->common.status = 1;
> + send_iu(iue, sizeof(*conf), VIOSRP_MAD_FORMAT);
> + break;
> + default:
> + eprintk("Unknown type %u\n", iu->srp.rsp.opcode);
> + }
> +
> + return 1;
> +}
> +
> +static int process_srp_iu(struct iu_entry *iue)
> +{
> + union viosrp_iu *iu = vio_iu(iue);
> + int done = 1;
> + u8 opcode = iu->srp.rsp.opcode;
> +
> + switch (opcode) {
> + case SRP_LOGIN_REQ:
> + process_login(iue);
> + break;
> + case SRP_TSK_MGMT:
> + done = process_tsk_mgmt(iue);
> + break;
> + case SRP_CMD:
> + queue_cmd(iue);
> + done = 0;
> + break;
> + case SRP_LOGIN_RSP:
> + case SRP_I_LOGOUT:
> + case SRP_T_LOGOUT:
> + case SRP_RSP:
> + case SRP_CRED_REQ:
> + case SRP_CRED_RSP:
> + case SRP_AER_REQ:
> + case SRP_AER_RSP:
> + eprintk("Unsupported type %u\n", opcode);
> + break;
> + default:
> + eprintk("Unknown type %u\n", opcode);
> + }
> +
> + return done;
> +}
> +
> +static void process_iu(struct viosrp_crq *crq, struct srp_target *target)
> +{
> + struct vio_port *vport = target_to_port(target);
> + struct iu_entry *iue;
> + long err, done;
> +
> + iue = srp_iu_get(target);
> + if (!iue) {
> + eprintk("Error getting IU from pool, %p\n", target);
> + return;
> + }
> +
> + iue->remote_token = crq->IU_data_ptr;
> +
> + err = h_copy_rdma(crq->IU_length, vport->riobn,
> + iue->remote_token, vport->liobn, iue->sbuf->dma);
> +
> + if (err != H_SUCCESS) {
> + eprintk("%ld transferring data error %p\n", err, iue);
> + done = 1;
> + goto out;
> + }
> +
> + if (crq->format == VIOSRP_MAD_FORMAT)
> + done = process_mad_iu(iue);
> + else
> + done = process_srp_iu(iue);
> +out:
> + if (done)
> + srp_iu_put(iue);
> +}
> +
> +static irqreturn_t ibmvstgt_interrupt(int irq, void *data)
> +{
> + struct srp_target *target = (struct srp_target *) data;
> + struct vio_port *vport = target_to_port(target);
> +
> + vio_disable_interrupts(vport->dma_dev);
> + queue_work(vtgtd, &vport->crq_work);
> +
> + return IRQ_HANDLED;
> +}
> +
> +static int crq_queue_create(struct crq_queue *queue, struct srp_target *target)
> +{
> + int err;
> + struct vio_port *vport = target_to_port(target);
> +
> + queue->msgs = (struct viosrp_crq *) get_zeroed_page(GFP_KERNEL);
> + if (!queue->msgs)
> + goto malloc_failed;
> + queue->size = PAGE_SIZE / sizeof(*queue->msgs);
> +
> + queue->msg_token = dma_map_single(target->dev, queue->msgs,
> + queue->size * sizeof(*queue->msgs),
> + DMA_BIDIRECTIONAL);
> +
> + if (dma_mapping_error(queue->msg_token))
> + goto map_failed;
> +
> + err = h_reg_crq(vport->dma_dev->unit_address, queue->msg_token,
> + PAGE_SIZE);
> +
> + /* If the adapter was left active for some reason (like kexec)
> + * try freeing and re-registering
> + */
> + if (err == H_RESOURCE) {
> + do {
> + err = h_free_crq(vport->dma_dev->unit_address);
> + } while (err == H_BUSY || H_IS_LONG_BUSY(err));
> +
> + err = h_reg_crq(vport->dma_dev->unit_address, queue->msg_token,
> + PAGE_SIZE);
> + }
> +
> + if (err != H_SUCCESS && err != 2) {
> + eprintk("Error 0x%x opening virtual adapter\n", err);
> + goto reg_crq_failed;
> + }
> +
> + err = request_irq(vport->dma_dev->irq, &ibmvstgt_interrupt,
> + SA_INTERRUPT, "ibmvstgt", target);
> + if (err)
> + goto req_irq_failed;
> +
> + vio_enable_interrupts(vport->dma_dev);
> +
> + h_send_crq(vport->dma_dev->unit_address, 0xC001000000000000, 0);
> +
> + queue->cur = 0;
> + spin_lock_init(&queue->lock);
> +
> + return 0;
> +
> +req_irq_failed:
> + do {
> + err = h_free_crq(vport->dma_dev->unit_address);
> + } while (err == H_BUSY || H_IS_LONG_BUSY(err));
> +
> +reg_crq_failed:
> + dma_unmap_single(target->dev, queue->msg_token,
> + queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL);
> +map_failed:
> + free_page((unsigned long) queue->msgs);
> +
> +malloc_failed:
> + return -ENOMEM;
> +}
> +
> +static void crq_queue_destroy(struct srp_target *target)
> +{
> + struct vio_port *vport = target_to_port(target);
> + struct crq_queue *queue = &vport->crq_queue;
> + int err;
> +
> + free_irq(vport->dma_dev->irq, target);
> + do {
> + err = h_free_crq(vport->dma_dev->unit_address);
> + } while (err == H_BUSY || H_IS_LONG_BUSY(err));
> +
> + dma_unmap_single(target->dev, queue->msg_token,
> + queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL);
> +
> + free_page((unsigned long) queue->msgs);
> +}
> +
> +static void process_crq(struct viosrp_crq *crq, struct srp_target *target)
> +{
> + struct vio_port *vport = target_to_port(target);
> + dprintk("%x %x\n", crq->valid, crq->format);
> +
> + switch (crq->valid) {
> + case 0xC0:
> + /* initialization */
> + switch (crq->format) {
> + case 0x01:
> + h_send_crq(vport->dma_dev->unit_address,
> + 0xC002000000000000, 0);
> + break;
> + case 0x02:
> + break;
> + default:
> + eprintk("Unknown format %u\n", crq->format);
> + }
> + break;
> + case 0xFF:
> + /* transport event */
> + break;
> + case 0x80:
> + /* real payload */
> + switch (crq->format) {
> + case VIOSRP_SRP_FORMAT:
> + case VIOSRP_MAD_FORMAT:
> + process_iu(crq, target);
> + break;
> + case VIOSRP_OS400_FORMAT:
> + case VIOSRP_AIX_FORMAT:
> + case VIOSRP_LINUX_FORMAT:
> + case VIOSRP_INLINE_FORMAT:
> + eprintk("Unsupported format %u\n", crq->format);
> + break;
> + default:
> + eprintk("Unknown format %u\n", crq->format);
> + }
> + break;
> + default:
> + eprintk("unknown message type 0x%02x!?\n", crq->valid);
> + }
> +}
> +
> +static inline struct viosrp_crq *next_crq(struct crq_queue *queue)
> +{
> + struct viosrp_crq *crq;
> + unsigned long flags;
> +
> + spin_lock_irqsave(&queue->lock, flags);
> + crq = &queue->msgs[queue->cur];
> + if (crq->valid & 0x80) {
> + if (++queue->cur == queue->size)
> + queue->cur = 0;
> + } else
> + crq = NULL;
> + spin_unlock_irqrestore(&queue->lock, flags);
> +
> + return crq;
> +}
> +
> +static void handle_crq(void *data)
> +{
> + struct srp_target *target = (struct srp_target *) data;
> + struct vio_port *vport = target_to_port(target);
> + struct viosrp_crq *crq;
> + int done = 0;
> +
> + while (!done) {
> + while ((crq = next_crq(&vport->crq_queue)) != NULL) {
> + process_crq(crq, target);
> + crq->valid = 0x00;
> + }
> +
> + vio_enable_interrupts(vport->dma_dev);
> +
> + crq = next_crq(&vport->crq_queue);
> + if (crq) {
> + vio_disable_interrupts(vport->dma_dev);
> + process_crq(crq, target);
> + crq->valid = 0x00;
> + } else
> + done = 1;
> + }
> +
> + handle_cmd_queue(target);
> +}
> +
> +
> +static int ibmvstgt_eh_abort_handler(struct scsi_cmnd *sc)
> +{
> + unsigned long flags;
> + struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr;
> + struct srp_target *target = iue->target;
> +
> + dprintk("%p %p %x\n", iue, target, vio_iu(iue)->srp.cmd.cdb[0]);
> +
> + spin_lock_irqsave(&target->lock, flags);
> + list_del(&iue->ilist);
> + spin_unlock_irqrestore(&target->lock, flags);
> +
> + srp_iu_put(iue);
> +
> + return 0;
> +}
> +
> +static int ibmvstgt_tsk_mgmt_response(u64 mid, int result)
> +{
> + struct iu_entry *iue = (struct iu_entry *) ((void *) mid);
> + union viosrp_iu *iu = vio_iu(iue);
> + unsigned char status, asc;
> +
> + eprintk("%p %d\n", iue, result);
> + status = NO_SENSE;
> + asc = 0;
> +
> + switch (iu->srp.tsk_mgmt.tsk_mgmt_func) {
> + case SRP_TSK_ABORT_TASK:
> + asc = 0x14;
> + if (result)
> + status = ABORTED_COMMAND;
> + break;
> + default:
> + break;
> + }
> +
> + send_rsp(iue, NULL, status, asc);
> + srp_iu_put(iue);
> +
> + return 0;
> +}
> +
> +static ssize_t system_id_show(struct class_device *cdev, char *buf)
> +{
> + return snprintf(buf, PAGE_SIZE, "%s\n", system_id);
> +}
> +
> +static ssize_t partition_number_show(struct class_device *cdev, char *buf)
> +{
> + return snprintf(buf, PAGE_SIZE, "%x\n", partition_number);
> +}
> +
> +static ssize_t unit_address_show(struct class_device *cdev, char *buf)
> +{
> + struct Scsi_Host *shost = class_to_shost(cdev);
> + struct srp_target *target = host_to_srp_target(shost);
> + struct vio_port *vport = target_to_port(target);
> + return snprintf(buf, PAGE_SIZE, "%x\n", vport->dma_dev->unit_address);
> +}
> +
> +static CLASS_DEVICE_ATTR(system_id, S_IRUGO, system_id_show, NULL);
> +static CLASS_DEVICE_ATTR(partition_number, S_IRUGO, partition_number_show, NULL);
> +static CLASS_DEVICE_ATTR(unit_address, S_IRUGO, unit_address_show, NULL);
> +
> +static struct class_device_attribute *ibmvstgt_attrs[] = {
> + &class_device_attr_system_id,
> + &class_device_attr_partition_number,
> + &class_device_attr_unit_address,
> + NULL,
> +};
> +
> +static struct scsi_host_template ibmvstgt_sht = {
> + .name = TGT_NAME,
> + .module = THIS_MODULE,
> + .can_queue = INITIAL_SRP_LIMIT,
> + .sg_tablesize = SG_ALL,
> + .use_clustering = DISABLE_CLUSTERING,
> + .max_sectors = DEFAULT_MAX_SECTORS,
> + .transfer_response = ibmvstgt_cmd_done,
> + .transfer_data = ibmvstgt_transfer_data,
> + .eh_abort_handler = ibmvstgt_eh_abort_handler,
> + .tsk_mgmt_response = ibmvstgt_tsk_mgmt_response,
> + .shost_attrs = ibmvstgt_attrs,
> + .proc_name = TGT_NAME,
> +};
> +
> +static int ibmvstgt_probe(struct vio_dev *dev, const struct vio_device_id *id)
> +{
> + struct Scsi_Host *shost;
> + struct srp_target *target;
> + struct vio_port *vport;
> + unsigned int *dma, dma_size;
> + int err = -ENOMEM;
> +
> + vport = kzalloc(sizeof(struct vio_port), GFP_KERNEL);
> + if (!vport)
> + return err;
> + shost = scsi_host_alloc(&ibmvstgt_sht, sizeof(struct srp_target));
> + if (!shost)
> + goto free_vport;
> + err = scsi_tgt_alloc_queue(shost);
> + if (err)
> + goto put_host;
> +
> + target = host_to_srp_target(shost);
> + target->shost = shost;
> + vport->dma_dev = dev;
> + target->ldata = vport;
> + err = srp_target_alloc(target, &dev->dev, INITIAL_SRP_LIMIT,
> + SRP_MAX_IU_LEN);
> + if (err)
> + goto put_host;
> +
> + dma = (unsigned int *) vio_get_attribute(dev, "ibm,my-dma-window",
> + &dma_size);
> + if (!dma || dma_size != 40) {
> + eprintk("Couldn't get window property %d\n", dma_size);
> + err = -EIO;
> + goto free_srp_target;
> + }
> + vport->liobn = dma[0];
> + vport->riobn = dma[5];
> +
> + INIT_WORK(&vport->crq_work, handle_crq, target);
> +
> + err = crq_queue_create(&vport->crq_queue, target);
> + if (err)
> + goto free_srp_target;
> +
> + err = scsi_add_host(shost, target->dev);
> + if (err)
> + goto destroy_queue;
> + return 0;
> +
> +destroy_queue:
> + crq_queue_destroy(target);
> +free_srp_target:
> + srp_target_free(target);
> +put_host:
> + scsi_host_put(shost);
> +free_vport:
> + kfree(vport);
> + return err;
> +}
> +
> +static int ibmvstgt_remove(struct vio_dev *dev)
> +{
> + struct srp_target *target = (struct srp_target *) dev->dev.driver_data;
> + struct Scsi_Host *shost = target->shost;
> + struct vio_port *vport = target->ldata;
> +
> + crq_queue_destroy(target);
> + scsi_remove_host(shost);
> + scsi_tgt_free_queue(shost);
> + srp_target_free(target);
> + kfree(vport);
> + scsi_host_put(shost);
> + return 0;
> +}
> +
> +static struct vio_device_id ibmvstgt_device_table[] __devinitdata = {
> + {"v-scsi-host", "IBM,v-scsi-host"},
> + {"",""}
> +};
> +
> +MODULE_DEVICE_TABLE(vio, ibmvstgt_device_table);
> +
> +static struct vio_driver ibmvstgt_driver = {
> + .id_table = ibmvstgt_device_table,
> + .probe = ibmvstgt_probe,
> + .remove = ibmvstgt_remove,
> + .driver = {
> + .name = "ibmvscsis",
> + .owner = THIS_MODULE,
> + }
> +};
> +
> +static int get_system_info(void)
> +{
> + struct device_node *rootdn;
> + const char *id, *model, *name;
> + unsigned int *num;
> +
> + rootdn = find_path_device("/");
> + if (!rootdn)
> + return -ENOENT;
> +
> + model = get_property(rootdn, "model", NULL);
> + id = get_property(rootdn, "system-id", NULL);
> + if (model && id)
> + snprintf(system_id, sizeof(system_id), "%s-%s", model, id);
> +
> + name = get_property(rootdn, "ibm,partition-name", NULL);
> + if (name)
> + strncpy(partition_name, name, sizeof(partition_name));
> +
> + num = (unsigned int *) get_property(rootdn, "ibm,partition-no", NULL);
> + if (num)
> + partition_number = *num;
> +
> + return 0;
> +}
> +
> +static int ibmvstgt_init(void)
> +{
> + int err = -ENOMEM;
> +
> + printk("IBM eServer i/pSeries Virtual SCSI Target Driver\n");
> +
> + vtgtd = create_workqueue("ibmvtgtd");
> + if (!vtgtd)
> + return err;
> +
> + err = get_system_info();
> + if (err)
> + goto destroy_wq;
> +
> + err = vio_register_driver(&ibmvstgt_driver);
> + if (err)
> + goto destroy_wq;
> +
> + return 0;
> +
> +destroy_wq:
> + destroy_workqueue(vtgtd);
> + return err;
> +}
> +
> +static void ibmvstgt_exit(void)
> +{
> + printk("Unregister IBM virtual SCSI driver\n");
> +
> + destroy_workqueue(vtgtd);
> + vio_unregister_driver(&ibmvstgt_driver);
> +}
> +
> +MODULE_DESCRIPTION("IBM Virtual SCSI Target");
> +MODULE_AUTHOR("Dave Boutcher");
> +MODULE_LICENSE("GPL");
> +
> +module_init(ibmvstgt_init);
> +module_exit(ibmvstgt_exit);
> --
> 1.4.3.2
>
> -
> To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
>
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH 8/8] scsi tgt: IBM eServer i/pSeries virtual SCSI target driver
2006-11-28 14:31 ` FUJITA Tomonori
@ 2006-11-30 15:38 ` Santiago Leon
2006-11-30 17:06 ` FUJITA Tomonori
0 siblings, 1 reply; 5+ messages in thread
From: Santiago Leon @ 2006-11-30 15:38 UTC (permalink / raw)
To: FUJITA Tomonori; +Cc: boutcher, linux-scsi
FUJITA Tomonori wrote:
> Hi ibmvscsi team,
>
> Can I get your ACK on this patch to get it merged into the scsi-misc?
No problem, Ive been playing with it for a while now. Just one tiny
thing, Dave Boutcher has changed jobs within IBM, so please put me in
the MODULE_AUTHOR() call.
> From: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
> Subject: [PATCH 8/8] scsi tgt: IBM eServer i/pSeries virtual SCSI target driver
> Date: Thu, 16 Nov 2006 19:24:26 +0900
>
>> This is IBM Virtual SCSI target driver for tgt. The driver is based on
>> the original ibmvscsis driver:
>>
>> http://lkml.org/lkml/2005/10/17/99
>>
>>
>> Signed-off-by: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
>> Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
>> Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
Signed-off-by: Santiago Leon <santil@us.ibm.com>
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH 8/8] scsi tgt: IBM eServer i/pSeries virtual SCSI target driver
2006-11-30 15:38 ` Santiago Leon
@ 2006-11-30 17:06 ` FUJITA Tomonori
2006-11-30 17:23 ` James Bottomley
0 siblings, 1 reply; 5+ messages in thread
From: FUJITA Tomonori @ 2006-11-30 17:06 UTC (permalink / raw)
To: santil, James.Bottomley; +Cc: fujita.tomonori, boutcher, linux-scsi
From: Santiago Leon <santil@us.ibm.com>
Subject: Re: [PATCH 8/8] scsi tgt: IBM eServer i/pSeries virtual SCSI target driver
Date: Thu, 30 Nov 2006 09:38:35 -0600
> FUJITA Tomonori wrote:
> > Hi ibmvscsi team,
> >
> > Can I get your ACK on this patch to get it merged into the scsi-misc?
>
> No problem, Ive been playing with it for a while now.
Great!
> Just one tiny thing, Dave Boutcher has changed jobs within IBM, so
> please put me in the MODULE_AUTHOR() call.
Sure.
James, would you like me to submit an updated version of the patch?
> > From: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
> > Subject: [PATCH 8/8] scsi tgt: IBM eServer i/pSeries virtual SCSI target driver
> > Date: Thu, 16 Nov 2006 19:24:26 +0900
> >
> >> This is IBM Virtual SCSI target driver for tgt. The driver is based on
> >> the original ibmvscsis driver:
> >>
> >> http://lkml.org/lkml/2005/10/17/99
> >>
> >>
> >> Signed-off-by: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
> >> Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
> >> Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
>
> Signed-off-by: Santiago Leon <santil@us.ibm.com>
>
> --
> Santiago A. Leon
> Power Linux Development
> IBM Linux Technology Center
> -
> To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
>
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH 8/8] scsi tgt: IBM eServer i/pSeries virtual SCSI target driver
2006-11-30 17:06 ` FUJITA Tomonori
@ 2006-11-30 17:23 ` James Bottomley
0 siblings, 0 replies; 5+ messages in thread
From: James Bottomley @ 2006-11-30 17:23 UTC (permalink / raw)
To: FUJITA Tomonori; +Cc: santil, boutcher, linux-scsi
On Fri, 2006-12-01 at 02:06 +0900, FUJITA Tomonori wrote:
> James, would you like me to submit an updated version of the patch?
Yes please, just so we know what everyone agrees to.
James
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2006-11-30 17:24 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2006-11-16 10:24 [PATCH 8/8] scsi tgt: IBM eServer i/pSeries virtual SCSI target driver FUJITA Tomonori
2006-11-28 14:31 ` FUJITA Tomonori
2006-11-30 15:38 ` Santiago Leon
2006-11-30 17:06 ` FUJITA Tomonori
2006-11-30 17:23 ` James Bottomley
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.