diff options
| author | Carlo Landmeter <clandmeter@gmail.com> | 2012-01-26 15:48:06 +0000 |
|---|---|---|
| committer | Carlo Landmeter <clandmeter@gmail.com> | 2012-01-26 15:48:06 +0000 |
| commit | 6160b20b4f9a1cb388556228aecb583f0da590b2 (patch) | |
| tree | d7cb31259015a67805cd01ef64b56c03948e31a3 /main/linux-scst/scst-2.2.0-3.2.2.patch | |
| parent | 6d05d77a399d7abcbcb308533a5ddc7399a79ead (diff) | |
| download | aports-6160b20b4f9a1cb388556228aecb583f0da590b2.tar.bz2 aports-6160b20b4f9a1cb388556228aecb583f0da590b2.tar.xz | |
main/linux-scst: update scst to 2.2.0 and kernel to 3.2.2
Diffstat (limited to 'main/linux-scst/scst-2.2.0-3.2.2.patch')
| -rw-r--r-- | main/linux-scst/scst-2.2.0-3.2.2.patch | 80901 |
1 files changed, 80901 insertions, 0 deletions
diff --git a/main/linux-scst/scst-2.2.0-3.2.2.patch b/main/linux-scst/scst-2.2.0-3.2.2.patch new file mode 100644 index 0000000000..a6fef8db26 --- /dev/null +++ b/main/linux-scst/scst-2.2.0-3.2.2.patch @@ -0,0 +1,80901 @@ +=== modified file 'block/blk-map.c' +--- old/block/blk-map.c 2012-01-10 22:58:17 +0000 ++++ new/block/blk-map.c 2012-01-10 23:01:21 +0000 +@@ -5,6 +5,8 @@ + #include <linux/module.h> + #include <linux/bio.h> + #include <linux/blkdev.h> ++#include <linux/scatterlist.h> ++#include <linux/slab.h> + #include <scsi/sg.h> /* for struct sg_iovec */ + + #include "blk.h" +@@ -275,6 +277,339 @@ int blk_rq_unmap_user(struct bio *bio) + } + EXPORT_SYMBOL(blk_rq_unmap_user); + ++struct blk_kern_sg_work { ++ atomic_t bios_inflight; ++ struct sg_table sg_table; ++ struct scatterlist *src_sgl; ++}; ++ ++static void blk_free_kern_sg_work(struct blk_kern_sg_work *bw) ++{ ++ struct sg_table *sgt = &bw->sg_table; ++ struct scatterlist *sg; ++ int i; ++ ++ for_each_sg(sgt->sgl, sg, sgt->orig_nents, i) { ++ struct page *pg = sg_page(sg); ++ if (pg == NULL) ++ break; ++ __free_page(pg); ++ } ++ ++ sg_free_table(sgt); ++ kfree(bw); ++ return; ++} ++ ++static void blk_bio_map_kern_endio(struct bio *bio, int err) ++{ ++ struct blk_kern_sg_work *bw = bio->bi_private; ++ ++ if (bw != NULL) { ++ /* Decrement the bios in processing and, if zero, free */ ++ BUG_ON(atomic_read(&bw->bios_inflight) <= 0); ++ if (atomic_dec_and_test(&bw->bios_inflight)) { ++ if ((bio_data_dir(bio) == READ) && (err == 0)) { ++ unsigned long flags; ++ ++ local_irq_save(flags); /* to protect KMs */ ++ sg_copy(bw->src_sgl, bw->sg_table.sgl, 0, 0, ++ KM_BIO_DST_IRQ, KM_BIO_SRC_IRQ); ++ local_irq_restore(flags); ++ } ++ blk_free_kern_sg_work(bw); ++ } ++ } ++ ++ bio_put(bio); ++ return; ++} ++ ++static int blk_rq_copy_kern_sg(struct request *rq, struct scatterlist *sgl, ++ int nents, struct blk_kern_sg_work **pbw, ++ gfp_t gfp, gfp_t page_gfp) ++{ ++ int res = 0, i; ++ struct scatterlist *sg; ++ struct scatterlist *new_sgl; ++ int new_sgl_nents; ++ size_t len = 0, to_copy; ++ struct blk_kern_sg_work *bw; ++ ++ bw = kzalloc(sizeof(*bw), gfp); ++ if (bw == NULL) ++ goto out; ++ ++ bw->src_sgl = sgl; ++ ++ for_each_sg(sgl, sg, nents, i) ++ len += sg->length; ++ to_copy = len; ++ ++ new_sgl_nents = PFN_UP(len); ++ ++ res = sg_alloc_table(&bw->sg_table, new_sgl_nents, gfp); ++ if (res != 0) ++ goto err_free; ++ ++ new_sgl = bw->sg_table.sgl; ++ ++ for_each_sg(new_sgl, sg, new_sgl_nents, i) { ++ struct page *pg; ++ ++ pg = alloc_page(page_gfp); ++ if (pg == NULL) ++ goto err_free; ++ ++ sg_assign_page(sg, pg); ++ sg->length = min_t(size_t, PAGE_SIZE, len); ++ ++ len -= PAGE_SIZE; ++ } ++ ++ if (rq_data_dir(rq) == WRITE) { ++ /* ++ * We need to limit amount of copied data to to_copy, because ++ * sgl might have the last element in sgl not marked as last in ++ * SG chaining. ++ */ ++ sg_copy(new_sgl, sgl, 0, to_copy, ++ KM_USER0, KM_USER1); ++ } ++ ++ *pbw = bw; ++ /* ++ * REQ_COPY_USER name is misleading. It should be something like ++ * REQ_HAS_TAIL_SPACE_FOR_PADDING. ++ */ ++ rq->cmd_flags |= REQ_COPY_USER; ++ ++out: ++ return res; ++ ++err_free: ++ blk_free_kern_sg_work(bw); ++ res = -ENOMEM; ++ goto out; ++} ++ ++static int __blk_rq_map_kern_sg(struct request *rq, struct scatterlist *sgl, ++ int nents, struct blk_kern_sg_work *bw, gfp_t gfp) ++{ ++ int res; ++ struct request_queue *q = rq->q; ++ int rw = rq_data_dir(rq); ++ int max_nr_vecs, i; ++ size_t tot_len; ++ bool need_new_bio; ++ struct scatterlist *sg, *prev_sg = NULL; ++ struct bio *bio = NULL, *hbio = NULL, *tbio = NULL; ++ int bios; ++ ++ if (unlikely((sgl == NULL) || (sgl->length == 0) || (nents <= 0))) { ++ WARN_ON(1); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ /* ++ * Let's keep each bio allocation inside a single page to decrease ++ * probability of failure. ++ */ ++ max_nr_vecs = min_t(size_t, ++ ((PAGE_SIZE - sizeof(struct bio)) / sizeof(struct bio_vec)), ++ BIO_MAX_PAGES); ++ ++ need_new_bio = true; ++ tot_len = 0; ++ bios = 0; ++ for_each_sg(sgl, sg, nents, i) { ++ struct page *page = sg_page(sg); ++ void *page_addr = page_address(page); ++ size_t len = sg->length, l; ++ size_t offset = sg->offset; ++ ++ tot_len += len; ++ prev_sg = sg; ++ ++ /* ++ * Each segment must be aligned on DMA boundary and ++ * not on stack. The last one may have unaligned ++ * length as long as the total length is aligned to ++ * DMA padding alignment. ++ */ ++ if (i == nents - 1) ++ l = 0; ++ else ++ l = len; ++ if (((sg->offset | l) & queue_dma_alignment(q)) || ++ (page_addr && object_is_on_stack(page_addr + sg->offset))) { ++ res = -EINVAL; ++ goto out_free_bios; ++ } ++ ++ while (len > 0) { ++ size_t bytes; ++ int rc; ++ ++ if (need_new_bio) { ++ bio = bio_kmalloc(gfp, max_nr_vecs); ++ if (bio == NULL) { ++ res = -ENOMEM; ++ goto out_free_bios; ++ } ++ ++ if (rw == WRITE) ++ bio->bi_rw |= REQ_WRITE; ++ ++ bios++; ++ bio->bi_private = bw; ++ bio->bi_end_io = blk_bio_map_kern_endio; ++ ++ if (hbio == NULL) ++ hbio = tbio = bio; ++ else ++ tbio = tbio->bi_next = bio; ++ } ++ ++ bytes = min_t(size_t, len, PAGE_SIZE - offset); ++ ++ rc = bio_add_pc_page(q, bio, page, bytes, offset); ++ if (rc < bytes) { ++ if (unlikely(need_new_bio || (rc < 0))) { ++ if (rc < 0) ++ res = rc; ++ else ++ res = -EIO; ++ goto out_free_bios; ++ } else { ++ need_new_bio = true; ++ len -= rc; ++ offset += rc; ++ continue; ++ } ++ } ++ ++ need_new_bio = false; ++ offset = 0; ++ len -= bytes; ++ page = nth_page(page, 1); ++ } ++ } ++ ++ if (hbio == NULL) { ++ res = -EINVAL; ++ goto out_free_bios; ++ } ++ ++ /* Total length must be aligned on DMA padding alignment */ ++ if ((tot_len & q->dma_pad_mask) && ++ !(rq->cmd_flags & REQ_COPY_USER)) { ++ res = -EINVAL; ++ goto out_free_bios; ++ } ++ ++ if (bw != NULL) ++ atomic_set(&bw->bios_inflight, bios); ++ ++ while (hbio != NULL) { ++ bio = hbio; ++ hbio = hbio->bi_next; ++ bio->bi_next = NULL; ++ ++ blk_queue_bounce(q, &bio); ++ ++ res = blk_rq_append_bio(q, rq, bio); ++ if (unlikely(res != 0)) { ++ bio->bi_next = hbio; ++ hbio = bio; ++ /* We can have one or more bios bounced */ ++ goto out_unmap_bios; ++ } ++ } ++ ++ res = 0; ++ ++ rq->buffer = NULL; ++out: ++ return res; ++ ++out_unmap_bios: ++ blk_rq_unmap_kern_sg(rq, res); ++ ++out_free_bios: ++ while (hbio != NULL) { ++ bio = hbio; ++ hbio = hbio->bi_next; ++ bio_put(bio); ++ } ++ goto out; ++} ++ ++/** ++ * blk_rq_map_kern_sg - map kernel data to a request, for REQ_TYPE_BLOCK_PC ++ * @rq: request to fill ++ * @sgl: area to map ++ * @nents: number of elements in @sgl ++ * @gfp: memory allocation flags ++ * ++ * Description: ++ * Data will be mapped directly if possible. Otherwise a bounce ++ * buffer will be used. ++ */ ++int blk_rq_map_kern_sg(struct request *rq, struct scatterlist *sgl, ++ int nents, gfp_t gfp) ++{ ++ int res; ++ ++ res = __blk_rq_map_kern_sg(rq, sgl, nents, NULL, gfp); ++ if (unlikely(res != 0)) { ++ struct blk_kern_sg_work *bw = NULL; ++ ++ res = blk_rq_copy_kern_sg(rq, sgl, nents, &bw, ++ gfp, rq->q->bounce_gfp | gfp); ++ if (unlikely(res != 0)) ++ goto out; ++ ++ res = __blk_rq_map_kern_sg(rq, bw->sg_table.sgl, ++ bw->sg_table.nents, bw, gfp); ++ if (res != 0) { ++ blk_free_kern_sg_work(bw); ++ goto out; ++ } ++ } ++ ++ rq->buffer = NULL; ++ ++out: ++ return res; ++} ++EXPORT_SYMBOL(blk_rq_map_kern_sg); ++ ++/** ++ * blk_rq_unmap_kern_sg - unmap a request with kernel sg ++ * @rq: request to unmap ++ * @err: non-zero error code ++ * ++ * Description: ++ * Unmap a rq previously mapped by blk_rq_map_kern_sg(). Must be called ++ * only in case of an error! ++ */ ++void blk_rq_unmap_kern_sg(struct request *rq, int err) ++{ ++ struct bio *bio = rq->bio; ++ ++ while (bio) { ++ struct bio *b = bio; ++ bio = bio->bi_next; ++ b->bi_end_io(b, err); ++ } ++ rq->bio = NULL; ++ ++ return; ++} ++EXPORT_SYMBOL(blk_rq_unmap_kern_sg); ++ + /** + * blk_rq_map_kern - map kernel data to a request, for REQ_TYPE_BLOCK_PC usage + * @q: request queue where request should be inserted + +=== modified file 'include/linux/blkdev.h' +--- old/include/linux/blkdev.h 2012-01-10 22:58:17 +0000 ++++ new/include/linux/blkdev.h 2012-01-10 23:01:21 +0000 +@@ -716,6 +718,9 @@ extern int blk_rq_map_kern(struct reques + extern int blk_rq_map_user_iov(struct request_queue *, struct request *, + struct rq_map_data *, struct sg_iovec *, int, + unsigned int, gfp_t); ++extern int blk_rq_map_kern_sg(struct request *rq, struct scatterlist *sgl, ++ int nents, gfp_t gfp); ++extern void blk_rq_unmap_kern_sg(struct request *rq, int err); + extern int blk_execute_rq(struct request_queue *, struct gendisk *, + struct request *, int); + extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *, + +=== modified file 'include/linux/scatterlist.h' +--- old/include/linux/scatterlist.h 2012-01-10 22:58:17 +0000 ++++ new/include/linux/scatterlist.h 2012-01-10 23:01:21 +0000 +@@ -3,6 +3,7 @@ + + #include <asm/types.h> + #include <asm/scatterlist.h> ++#include <asm/kmap_types.h> + #include <linux/mm.h> + #include <linux/string.h> + #include <asm/io.h> +@@ -218,6 +219,10 @@ size_t sg_copy_from_buffer(struct scatte + size_t sg_copy_to_buffer(struct scatterlist *sgl, unsigned int nents, + void *buf, size_t buflen); + ++int sg_copy(struct scatterlist *dst_sg, struct scatterlist *src_sg, ++ int nents_to_copy, size_t copy_len, ++ enum km_type d_km_type, enum km_type s_km_type); ++ + /* + * Maximum number of entries that will be allocated in one piece, if + * a list larger than this is required then chaining will be utilized. + +=== modified file 'lib/scatterlist.c' +--- old/lib/scatterlist.c 2012-01-10 22:58:17 +0000 ++++ new/lib/scatterlist.c 2012-01-10 23:01:21 +0000 +@@ -517,3 +517,132 @@ size_t sg_copy_to_buffer(struct scatterl + return sg_copy_buffer(sgl, nents, buf, buflen, 1); + } + EXPORT_SYMBOL(sg_copy_to_buffer); ++ ++/* ++ * Can switch to the next dst_sg element, so, to copy to strictly only ++ * one dst_sg element, it must be either last in the chain, or ++ * copy_len == dst_sg->length. ++ */ ++static int sg_copy_elem(struct scatterlist **pdst_sg, size_t *pdst_len, ++ size_t *pdst_offs, struct scatterlist *src_sg, ++ size_t copy_len, ++ enum km_type d_km_type, enum km_type s_km_type) ++{ ++ int res = 0; ++ struct scatterlist *dst_sg; ++ size_t src_len, dst_len, src_offs, dst_offs; ++ struct page *src_page, *dst_page; ++ ++ dst_sg = *pdst_sg; ++ dst_len = *pdst_len; ++ dst_offs = *pdst_offs; ++ dst_page = sg_page(dst_sg); ++ ++ src_page = sg_page(src_sg); ++ src_len = src_sg->length; ++ src_offs = src_sg->offset; ++ ++ do { ++ void *saddr, *daddr; ++ size_t n; ++ ++ saddr = kmap_atomic(src_page + ++ (src_offs >> PAGE_SHIFT), s_km_type) + ++ (src_offs & ~PAGE_MASK); ++ daddr = kmap_atomic(dst_page + ++ (dst_offs >> PAGE_SHIFT), d_km_type) + ++ (dst_offs & ~PAGE_MASK); ++ ++ if (((src_offs & ~PAGE_MASK) == 0) && ++ ((dst_offs & ~PAGE_MASK) == 0) && ++ (src_len >= PAGE_SIZE) && (dst_len >= PAGE_SIZE) && ++ (copy_len >= PAGE_SIZE)) { ++ copy_page(daddr, saddr); ++ n = PAGE_SIZE; ++ } else { ++ n = min_t(size_t, PAGE_SIZE - (dst_offs & ~PAGE_MASK), ++ PAGE_SIZE - (src_offs & ~PAGE_MASK)); ++ n = min(n, src_len); ++ n = min(n, dst_len); ++ n = min_t(size_t, n, copy_len); ++ memcpy(daddr, saddr, n); ++ } ++ dst_offs += n; ++ src_offs += n; ++ ++ kunmap_atomic(saddr, s_km_type); ++ kunmap_atomic(daddr, d_km_type); ++ ++ res += n; ++ copy_len -= n; ++ if (copy_len == 0) ++ goto out; ++ ++ src_len -= n; ++ dst_len -= n; ++ if (dst_len == 0) { ++ dst_sg = sg_next(dst_sg); ++ if (dst_sg == NULL) ++ goto out; ++ dst_page = sg_page(dst_sg); ++ dst_len = dst_sg->length; ++ dst_offs = dst_sg->offset; ++ } ++ } while (src_len > 0); ++ ++out: ++ *pdst_sg = dst_sg; ++ *pdst_len = dst_len; ++ *pdst_offs = dst_offs; ++ return res; ++} ++ ++/** ++ * sg_copy - copy one SG vector to another ++ * @dst_sg: destination SG ++ * @src_sg: source SG ++ * @nents_to_copy: maximum number of entries to copy ++ * @copy_len: maximum amount of data to copy. If 0, then copy all. ++ * @d_km_type: kmap_atomic type for the destination SG ++ * @s_km_type: kmap_atomic type for the source SG ++ * ++ * Description: ++ * Data from the source SG vector will be copied to the destination SG ++ * vector. End of the vectors will be determined by sg_next() returning ++ * NULL. Returns number of bytes copied. ++ */ ++int sg_copy(struct scatterlist *dst_sg, struct scatterlist *src_sg, ++ int nents_to_copy, size_t copy_len, ++ enum km_type d_km_type, enum km_type s_km_type) ++{ ++ int res = 0; ++ size_t dst_len, dst_offs; ++ ++ if (copy_len == 0) ++ copy_len = 0x7FFFFFFF; /* copy all */ ++ ++ if (nents_to_copy == 0) ++ nents_to_copy = 0x7FFFFFFF; /* copy all */ ++ ++ dst_len = dst_sg->length; ++ dst_offs = dst_sg->offset; ++ ++ do { ++ int copied = sg_copy_elem(&dst_sg, &dst_len, &dst_offs, ++ src_sg, copy_len, d_km_type, s_km_type); ++ copy_len -= copied; ++ res += copied; ++ if ((copy_len == 0) || (dst_sg == NULL)) ++ goto out; ++ ++ nents_to_copy--; ++ if (nents_to_copy == 0) ++ goto out; ++ ++ src_sg = sg_next(src_sg); ++ } while (src_sg != NULL); ++ ++out: ++ return res; ++} ++EXPORT_SYMBOL(sg_copy); + +=== modified file 'include/linux/mm_types.h' +--- old/include/linux/mm_types.h 2012-01-10 22:58:17 +0000 ++++ new/include/linux/mm_types.h 2012-01-10 23:02:48 +0000 +@@ -149,6 +149,17 @@ struct page { + */ + void *shadow; + #endif ++ ++#if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++ /* ++ * Used to implement support for notification on zero-copy TCP transfer ++ * completion. It might look as not good to have this field here and ++ * it's better to have it in struct sk_buff, but it would make the code ++ * much more complicated and fragile, since all skb then would have to ++ * contain only pages with the same value in this field. ++ */ ++ void *net_priv; ++#endif + } + /* + * If another subsystem starts using the double word pairing for atomic + +=== modified file 'include/linux/net.h' +--- old/include/linux/net.h 2012-01-10 22:58:17 +0000 ++++ new/include/linux/net.h 2012-01-10 23:02:48 +0000 +@@ -61,6 +61,7 @@ typedef enum { + #include <linux/fcntl.h> /* For O_CLOEXEC and O_NONBLOCK */ + #include <linux/kmemcheck.h> + #include <linux/rcupdate.h> ++#include <linux/mm.h> + + struct poll_table_struct; + struct pipe_inode_info; +@@ -289,5 +290,44 @@ extern int kernel_sock_shutdown(struct s + MODULE_ALIAS("net-pf-" __stringify(pf) "-proto-" __stringify(proto) \ + "-type-" __stringify(type)) + ++#if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++/* Support for notification on zero-copy TCP transfer completion */ ++typedef void (*net_get_page_callback_t)(struct page *page); ++typedef void (*net_put_page_callback_t)(struct page *page); ++ ++extern net_get_page_callback_t net_get_page_callback; ++extern net_put_page_callback_t net_put_page_callback; ++ ++extern int net_set_get_put_page_callbacks( ++ net_get_page_callback_t get_callback, ++ net_put_page_callback_t put_callback); ++ ++/* ++ * See comment for net_set_get_put_page_callbacks() why those functions ++ * don't need any protection. ++ */ ++static inline void net_get_page(struct page *page) ++{ ++ if (page->net_priv != 0) ++ net_get_page_callback(page); ++ get_page(page); ++} ++static inline void net_put_page(struct page *page) ++{ ++ if (page->net_priv != 0) ++ net_put_page_callback(page); ++ put_page(page); ++} ++#else ++static inline void net_get_page(struct page *page) ++{ ++ get_page(page); ++} ++static inline void net_put_page(struct page *page) ++{ ++ put_page(page); ++} ++#endif /* CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION */ ++ + #endif /* __KERNEL__ */ + #endif /* _LINUX_NET_H */ + +=== modified file 'include/linux/skbuff.h' +--- old/include/linux/skbuff.h 2012-01-10 22:58:17 +0000 ++++ new/include/linux/skbuff.h 2012-01-10 23:15:31 +0000 +@@ -1712,7 +1712,7 @@ static inline struct page *skb_frag_page + */ + static inline void __skb_frag_ref(skb_frag_t *frag) + { +- get_page(skb_frag_page(frag)); ++ net_get_page(skb_frag_page(frag)); + } + + /** +@@ -1735,7 +1735,7 @@ static inline void skb_frag_ref(struct s + */ + static inline void __skb_frag_unref(skb_frag_t *frag) + { +- put_page(skb_frag_page(frag)); ++ net_put_page(skb_frag_page(frag)); + } + + /** + +=== modified file 'net/Kconfig' +--- old/net/Kconfig 2012-01-10 22:58:17 +0000 ++++ new/net/Kconfig 2012-01-10 23:02:48 +0000 +@@ -72,6 +72,18 @@ config INET + + Short answer: say Y. + ++config TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION ++ bool "TCP/IP zero-copy transfer completion notification" ++ depends on INET ++ default SCST_ISCSI ++ ---help--- ++ Adds support for sending a notification upon completion of a ++ zero-copy TCP/IP transfer. This can speed up certain TCP/IP ++ software. Currently this is only used by the iSCSI target driver ++ iSCSI-SCST. ++ ++ If unsure, say N. ++ + if INET + source "net/ipv4/Kconfig" + source "net/ipv6/Kconfig" + +=== modified file 'net/core/skbuff.c' +--- old/net/core/skbuff.c 2012-01-10 22:58:17 +0000 ++++ new/net/core/skbuff.c 2012-01-10 23:02:48 +0000 +@@ -77,13 +77,13 @@ static struct kmem_cache *skbuff_fclone_ + static void sock_pipe_buf_release(struct pipe_inode_info *pipe, + struct pipe_buffer *buf) + { +- put_page(buf->page); ++ net_put_page(buf->page); + } + + static void sock_pipe_buf_get(struct pipe_inode_info *pipe, + struct pipe_buffer *buf) + { +- get_page(buf->page); ++ net_get_page(buf->page); + } + + static int sock_pipe_buf_steal(struct pipe_inode_info *pipe, +@@ -654,7 +654,7 @@ int skb_copy_ubufs(struct sk_buff *skb, + if (!page) { + while (head) { + struct page *next = (struct page *)head->private; +- put_page(head); ++ net_put_page(head); + head = next; + } + return -ENOMEM; +@@ -1493,7 +1493,7 @@ EXPORT_SYMBOL(skb_copy_bits); + */ + static void sock_spd_release(struct splice_pipe_desc *spd, unsigned int i) + { +- put_page(spd->pages[i]); ++ net_put_page(spd->pages[i]); + } + + static inline struct page *linear_to_page(struct page *page, unsigned int *len, +@@ -1517,7 +1517,7 @@ new_page: + off = sk->sk_sndmsg_off; + mlen = PAGE_SIZE - off; + if (mlen < 64 && mlen < *len) { +- put_page(p); ++ net_put_page(p); + goto new_page; + } + +@@ -1527,7 +1527,7 @@ new_page: + memcpy(page_address(p) + off, page_address(page) + *offset, *len); + sk->sk_sndmsg_off += *len; + *offset = off; +- get_page(p); ++ net_get_page(p); + + return p; + } +@@ -1549,7 +1549,7 @@ static inline int spd_fill_page(struct s + if (!page) + return 1; + } else +- get_page(page); ++ net_get_page(page); + + spd->pages[spd->nr_pages] = page; + spd->partial[spd->nr_pages].len = *len; + +=== modified file 'net/ipv4/Makefile' +--- old/net/ipv4/Makefile 2012-01-10 22:58:17 +0000 ++++ new/net/ipv4/Makefile 2012-01-10 23:02:48 +0000 +@@ -48,6 +48,7 @@ obj-$(CONFIG_TCP_CONG_LP) += tcp_lp.o + obj-$(CONFIG_TCP_CONG_YEAH) += tcp_yeah.o + obj-$(CONFIG_TCP_CONG_ILLINOIS) += tcp_illinois.o + obj-$(CONFIG_NETLABEL) += cipso_ipv4.o ++obj-$(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) += tcp_zero_copy.o + + obj-$(CONFIG_XFRM) += xfrm4_policy.o xfrm4_state.o xfrm4_input.o \ + xfrm4_output.o + +=== modified file 'net/ipv4/ip_output.c' +--- old/net/ipv4/ip_output.c 2012-01-10 22:58:17 +0000 ++++ new/net/ipv4/ip_output.c 2012-01-10 23:02:48 +0000 +@@ -1232,7 +1232,7 @@ ssize_t ip_append_page(struct sock *sk, + if (skb_can_coalesce(skb, i, page, offset)) { + skb_frag_size_add(&skb_shinfo(skb)->frags[i-1], len); + } else if (i < MAX_SKB_FRAGS) { +- get_page(page); ++ net_get_page(page); + skb_fill_page_desc(skb, i, page, offset, len); + } else { + err = -EMSGSIZE; + +=== modified file 'net/ipv4/tcp.c' +--- old/net/ipv4/tcp.c 2012-01-10 22:58:17 +0000 ++++ new/net/ipv4/tcp.c 2012-01-10 23:02:48 +0000 +@@ -815,7 +815,7 @@ new_segment: + if (can_coalesce) { + skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy); + } else { +- get_page(page); ++ net_get_page(page); + skb_fill_page_desc(skb, i, page, offset, copy); + } + +@@ -1022,7 +1022,7 @@ new_segment: + goto new_segment; + } else if (page) { + if (off == PAGE_SIZE) { +- put_page(page); ++ net_put_page(page); + TCP_PAGE(sk) = page = NULL; + off = 0; + } +@@ -1062,9 +1062,9 @@ new_segment: + } else { + skb_fill_page_desc(skb, i, page, off, copy); + if (TCP_PAGE(sk)) { +- get_page(page); ++ net_get_page(page); + } else if (off + copy < PAGE_SIZE) { +- get_page(page); ++ net_get_page(page); + TCP_PAGE(sk) = page; + } + } + +=== added file 'net/ipv4/tcp_zero_copy.c' +--- old/net/ipv4/tcp_zero_copy.c 1970-01-01 00:00:00 +0000 ++++ new/net/ipv4/tcp_zero_copy.c 2012-01-10 23:43:22 +0000 +@@ -0,0 +1,50 @@ ++/* ++ * Support routines for TCP zero copy transmit ++ * ++ * Created by Vladislav Bolkhovitin ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * version 2 as published by the Free Software Foundation. ++ */ ++ ++#include <linux/export.h> ++#include <linux/skbuff.h> ++ ++net_get_page_callback_t net_get_page_callback __read_mostly; ++EXPORT_SYMBOL_GPL(net_get_page_callback); ++ ++net_put_page_callback_t net_put_page_callback __read_mostly; ++EXPORT_SYMBOL_GPL(net_put_page_callback); ++ ++/* ++ * Caller of this function must ensure that at the moment when it's called ++ * there are no pages in the system with net_priv field set to non-zero ++ * value. Hence, this function, as well as net_get_page() and net_put_page(), ++ * don't need any protection. ++ */ ++int net_set_get_put_page_callbacks( ++ net_get_page_callback_t get_callback, ++ net_put_page_callback_t put_callback) ++{ ++ int res = 0; ++ ++ if ((net_get_page_callback != NULL) && (get_callback != NULL) && ++ (net_get_page_callback != get_callback)) { ++ res = -EBUSY; ++ goto out; ++ } ++ ++ if ((net_put_page_callback != NULL) && (put_callback != NULL) && ++ (net_put_page_callback != put_callback)) { ++ res = -EBUSY; ++ goto out; ++ } ++ ++ net_get_page_callback = get_callback; ++ net_put_page_callback = put_callback; ++ ++out: ++ return res; ++} ++EXPORT_SYMBOL_GPL(net_set_get_put_page_callbacks); + +diff --git a/drivers/Kconfig b/drivers/Kconfig +index a2b902f..92e3d67 100644 +--- orig/linux-3.2/drivers/Kconfig ++++ linux-3.2/drivers/Kconfig +@@ -22,6 +22,8 @@ source "drivers/ide/Kconfig" + + source "drivers/scsi/Kconfig" + ++source "drivers/scst/Kconfig" ++ + source "drivers/ata/Kconfig" + + source "drivers/md/Kconfig" +diff --git a/drivers/Makefile b/drivers/Makefile +index b423bb1..f780114 100644 +--- orig/linux-3.2/drivers/Makefile ++++ linux-3.2/drivers/Makefile +@@ -115,5 +115,6 @@ obj-$(CONFIG_VLYNQ) += vlynq/ + obj-$(CONFIG_STAGING) += staging/ + obj-y += platform/ + obj-y += ieee802154/ ++obj-$(CONFIG_SCST) += scst/ + #common clk code + obj-y += clk/ +diff -uprN orig/linux-3.2/drivers/scst/Kconfig linux-3.2/drivers/scst/Kconfig +--- orig/linux-3.2/drivers/scst/Kconfig ++++ linux-3.2/drivers/scst/Kconfig +@@ -0,0 +1,255 @@ ++menu "SCSI target (SCST) support" ++ ++config SCST ++ tristate "SCSI target (SCST) support" ++ depends on SCSI ++ help ++ SCSI target (SCST) is designed to provide unified, consistent ++ interface between SCSI target drivers and Linux kernel and ++ simplify target drivers development as much as possible. Visit ++ http://scst.sourceforge.net for more info about it. ++ ++config SCST_DISK ++ tristate "SCSI target disk support" ++ default SCST ++ depends on SCSI && SCST ++ help ++ SCST pass-through device handler for disk device. ++ ++config SCST_TAPE ++ tristate "SCSI target tape support" ++ default SCST ++ depends on SCSI && SCST ++ help ++ SCST pass-through device handler for tape device. ++ ++config SCST_CDROM ++ tristate "SCSI target CDROM support" ++ default SCST ++ depends on SCSI && SCST ++ help ++ SCST pass-through device handler for CDROM device. ++ ++config SCST_MODISK ++ tristate "SCSI target MO disk support" ++ default SCST ++ depends on SCSI && SCST ++ help ++ SCST pass-through device handler for MO disk device. ++ ++config SCST_CHANGER ++ tristate "SCSI target changer support" ++ default SCST ++ depends on SCSI && SCST ++ help ++ SCST pass-through device handler for changer device. ++ ++config SCST_PROCESSOR ++ tristate "SCSI target processor support" ++ default SCST ++ depends on SCSI && SCST ++ help ++ SCST pass-through device handler for processor device. ++ ++config SCST_RAID ++ tristate "SCSI target storage array controller (RAID) support" ++ default SCST ++ depends on SCSI && SCST ++ help ++ SCST pass-through device handler for raid storage array controller (RAID) device. ++ ++config SCST_VDISK ++ tristate "SCSI target virtual disk and/or CDROM support" ++ default SCST ++ depends on SCSI && SCST ++ help ++ SCST device handler for virtual disk and/or CDROM device. ++ ++config SCST_USER ++ tristate "User-space SCSI target driver support" ++ default SCST ++ depends on SCSI && SCST && !HIGHMEM4G && !HIGHMEM64G ++ help ++ The SCST device handler scst_user allows to implement full-feature ++ SCSI target devices in user space. ++ ++ If unsure, say "N". ++ ++config SCST_STRICT_SERIALIZING ++ bool "Strict serialization" ++ depends on SCST ++ help ++ Enable strict SCSI command serialization. When enabled, SCST sends ++ all SCSI commands to the underlying SCSI device synchronously, one ++ after one. This makes task management more reliable, at the cost of ++ a performance penalty. This is most useful for stateful SCSI devices ++ like tapes, where the result of the execution of a command ++ depends on the device settings configured by previous commands. Disk ++ and RAID devices are stateless in most cases. The current SCSI core ++ in Linux doesn't allow to abort all commands reliably if they have ++ been sent asynchronously to a stateful device. ++ Enable this option if you use stateful device(s) and need as much ++ error recovery reliability as possible. ++ ++ If unsure, say "N". ++ ++config SCST_STRICT_SECURITY ++ bool "Strict security" ++ depends on SCST ++ help ++ Makes SCST clear (zero-fill) allocated data buffers. Note: this has a ++ significant performance penalty. ++ ++ If unsure, say "N". ++ ++config SCST_TEST_IO_IN_SIRQ ++ bool "Allow test I/O from soft-IRQ context" ++ depends on SCST ++ help ++ Allows SCST to submit selected SCSI commands (TUR and ++ READ/WRITE) from soft-IRQ context (tasklets). Enabling it will ++ decrease amount of context switches and slightly improve ++ performance. The goal of this option is to be able to measure ++ overhead of the context switches. See more info about it in ++ README.scst. ++ ++ WARNING! Improperly used, this option can lead you to a kernel crash! ++ ++ If unsure, say "N". ++ ++config SCST_ABORT_CONSIDER_FINISHED_TASKS_AS_NOT_EXISTING ++ bool "Send back UNKNOWN TASK when an already finished task is aborted" ++ depends on SCST ++ help ++ Controls which response is sent by SCST to the initiator in case ++ the initiator attempts to abort (ABORT TASK) an already finished ++ request. If this option is enabled, the response UNKNOWN TASK is ++ sent back to the initiator. However, some initiators, particularly ++ the VMware iSCSI initiator, interpret the UNKNOWN TASK response as ++ if the target got crazy and try to RESET it. Then sometimes the ++ initiator gets crazy itself. ++ ++ If unsure, say "N". ++ ++config SCST_USE_EXPECTED_VALUES ++ bool "Prefer initiator-supplied SCSI command attributes" ++ depends on SCST ++ help ++ When SCST receives a SCSI command from an initiator, such a SCSI ++ command has both data transfer length and direction attributes. ++ There are two possible sources for these attributes: either the ++ values computed by SCST from its internal command translation table ++ or the values supplied by the initiator. The former are used by ++ default because of security reasons. Invalid initiator-supplied ++ attributes can crash the target, especially in pass-through mode. ++ Only consider enabling this option when SCST logs the following ++ message: "Unknown opcode XX for YY. Should you update ++ scst_scsi_op_table?" and when the initiator complains. Please ++ report any unrecognized commands to scst-devel@lists.sourceforge.net. ++ ++ If unsure, say "N". ++ ++config SCST_EXTRACHECKS ++ bool "Extra consistency checks" ++ depends on SCST ++ help ++ Enable additional consistency checks in the SCSI middle level target ++ code. This may be helpful for SCST developers. Enable it if you have ++ any problems. ++ ++ If unsure, say "N". ++ ++config SCST_TRACING ++ bool "Tracing support" ++ depends on SCST ++ default y ++ help ++ Enable SCSI middle level tracing support. Tracing can be controlled ++ dynamically via sysfs interface. The traced information ++ is sent to the kernel log and may be very helpful when analyzing ++ the cause of a communication problem between initiator and target. ++ ++ If unsure, say "Y". ++ ++config SCST_DEBUG ++ bool "Debugging support" ++ depends on SCST ++ select DEBUG_BUGVERBOSE ++ help ++ Enables support for debugging SCST. This may be helpful for SCST ++ developers. ++ ++ If unsure, say "N". ++ ++config SCST_DEBUG_OOM ++ bool "Out-of-memory debugging support" ++ depends on SCST ++ help ++ Let SCST's internal memory allocation function ++ (scst_alloc_sg_entries()) fail about once in every 10000 calls, at ++ least if the flag __GFP_NOFAIL has not been set. This allows SCST ++ developers to test the behavior of SCST in out-of-memory conditions. ++ This may be helpful for SCST developers. ++ ++ If unsure, say "N". ++ ++config SCST_DEBUG_RETRY ++ bool "SCSI command retry debugging support" ++ depends on SCST ++ help ++ Let SCST's internal SCSI command transfer function ++ (scst_rdy_to_xfer()) fail about once in every 100 calls. This allows ++ SCST developers to test the behavior of SCST when SCSI queues fill ++ up. This may be helpful for SCST developers. ++ ++ If unsure, say "N". ++ ++config SCST_DEBUG_SN ++ bool "SCSI sequence number debugging support" ++ depends on SCST ++ help ++ Allows to test SCSI command ordering via sequence numbers by ++ randomly changing the type of SCSI commands into ++ SCST_CMD_QUEUE_ORDERED, SCST_CMD_QUEUE_HEAD_OF_QUEUE or ++ SCST_CMD_QUEUE_SIMPLE for about one in 300 SCSI commands. ++ This may be helpful for SCST developers. ++ ++ If unsure, say "N". ++ ++config SCST_DEBUG_TM ++ bool "Task management debugging support" ++ depends on SCST_DEBUG ++ help ++ Enables support for debugging of SCST's task management functions. ++ When enabled, some of the commands on LUN 0 in the default access ++ control group will be delayed for about 60 seconds. This will ++ cause the remote initiator send SCSI task management functions, ++ e.g. ABORT TASK and TARGET RESET. ++ ++ If unsure, say "N". ++ ++config SCST_TM_DBG_GO_OFFLINE ++ bool "Let devices become completely unresponsive" ++ depends on SCST_DEBUG_TM ++ help ++ Enable this option if you want that the device eventually becomes ++ completely unresponsive. When disabled, the device will receive ++ ABORT and RESET commands. ++ ++config SCST_MEASURE_LATENCY ++ bool "Commands processing latency measurement facility" ++ depends on SCST ++ help ++ This option enables commands processing latency measurement ++ facility in SCST. It will provide in the sysfs interface ++ average commands processing latency statistics. You can clear ++ already measured results by writing 0 in the corresponding sysfs file. ++ Note, you need a non-preemtible kernel to have correct results. ++ ++ If unsure, say "N". ++ ++source "drivers/scst/iscsi-scst/Kconfig" ++source "drivers/scst/scst_local/Kconfig" ++source "drivers/scst/srpt/Kconfig" ++ ++endmenu +diff -uprN orig/linux-3.2/drivers/scst/Makefile linux-3.2/drivers/scst/Makefile +--- orig/linux-3.2/drivers/scst/Makefile ++++ linux-3.2/drivers/scst/Makefile +@@ -0,0 +1,13 @@ ++ccflags-y += -Wno-unused-parameter ++ ++scst-y += scst_main.o ++scst-y += scst_pres.o ++scst-y += scst_targ.o ++scst-y += scst_lib.o ++scst-y += scst_sysfs.o ++scst-y += scst_mem.o ++scst-y += scst_tg.o ++scst-y += scst_debug.o ++ ++obj-$(CONFIG_SCST) += scst.o dev_handlers/ iscsi-scst/ qla2xxx-target/ \ ++ srpt/ scst_local/ +diff -uprN orig/linux-3.2/include/scst/scst.h linux-3.2/include/scst/scst.h +--- orig/linux-3.2/include/scst/scst.h ++++ linux-3.2/include/scst/scst.h +@@ -0,0 +1,3867 @@ ++/* ++ * include/scst.h ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * Copyright (C) 2010 - 2011 Bart Van Assche <bvanassche@acm.org>. ++ * ++ * Main SCSI target mid-level include file. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#ifndef __SCST_H ++#define __SCST_H ++ ++#include <linux/types.h> ++#include <linux/blkdev.h> ++#include <linux/interrupt.h> ++#include <linux/wait.h> ++#include <linux/cpumask.h> ++ ++ ++#include <scsi/scsi_cmnd.h> ++#include <scsi/scsi_device.h> ++#include <scsi/scsi_eh.h> ++#include <scsi/scsi.h> ++ ++#include <scst/scst_const.h> ++ ++#include <scst/scst_sgv.h> ++ ++#define SCST_INTERFACE_VERSION \ ++ SCST_VERSION_STRING "$Revision: 3992 $" SCST_CONST_VERSION ++ ++#define SCST_LOCAL_NAME "scst_local" ++ ++/************************************************************* ++ ** States of command processing state machine. At first, ++ ** "active" states, then - "passive" ones. This is to have ++ ** more efficient generated code of the corresponding ++ ** "switch" statements. ++ *************************************************************/ ++ ++/* Dev handler's parse() is going to be called */ ++#define SCST_CMD_STATE_PARSE 0 ++ ++/* Allocation of the cmd's data buffer */ ++#define SCST_CMD_STATE_PREPARE_SPACE 1 ++ ++/* Calling preprocessing_done() */ ++#define SCST_CMD_STATE_PREPROCESSING_DONE 2 ++ ++/* Target driver's rdy_to_xfer() is going to be called */ ++#define SCST_CMD_STATE_RDY_TO_XFER 3 ++ ++/* Target driver's pre_exec() is going to be called */ ++#define SCST_CMD_STATE_TGT_PRE_EXEC 4 ++ ++/* Cmd is going to be sent for execution */ ++#define SCST_CMD_STATE_SEND_FOR_EXEC 5 ++ ++/* Internal post-exec checks */ ++#define SCST_CMD_STATE_PRE_DEV_DONE 6 ++ ++/* Internal MODE SELECT pages related checks */ ++#define SCST_CMD_STATE_MODE_SELECT_CHECKS 7 ++ ++/* Dev handler's dev_done() is going to be called */ ++#define SCST_CMD_STATE_DEV_DONE 8 ++ ++/* Checks before target driver's xmit_response() is called */ ++#define SCST_CMD_STATE_PRE_XMIT_RESP 9 ++ ++/* Target driver's xmit_response() is going to be called */ ++#define SCST_CMD_STATE_XMIT_RESP 10 ++ ++/* Cmd finished */ ++#define SCST_CMD_STATE_FINISHED 11 ++ ++/* Internal cmd finished */ ++#define SCST_CMD_STATE_FINISHED_INTERNAL 12 ++ ++#define SCST_CMD_STATE_LAST_ACTIVE (SCST_CMD_STATE_FINISHED_INTERNAL+100) ++ ++/* A cmd is created, but scst_cmd_init_done() not called */ ++#define SCST_CMD_STATE_INIT_WAIT (SCST_CMD_STATE_LAST_ACTIVE+1) ++ ++/* LUN translation (cmd->tgt_dev assignment) */ ++#define SCST_CMD_STATE_INIT (SCST_CMD_STATE_LAST_ACTIVE+2) ++ ++/* Waiting for scst_restart_cmd() */ ++#define SCST_CMD_STATE_PREPROCESSING_DONE_CALLED (SCST_CMD_STATE_LAST_ACTIVE+3) ++ ++/* Waiting for data from the initiator (until scst_rx_data() called) */ ++#define SCST_CMD_STATE_DATA_WAIT (SCST_CMD_STATE_LAST_ACTIVE+4) ++ ++/* ++ * Cmd is ready for exec (after check if its device is blocked or should ++ * be blocked) ++ */ ++#define SCST_CMD_STATE_START_EXEC (SCST_CMD_STATE_LAST_ACTIVE+5) ++ ++/* Cmd is being checked if it should be executed locally */ ++#define SCST_CMD_STATE_LOCAL_EXEC (SCST_CMD_STATE_LAST_ACTIVE+6) ++ ++/* Cmd is ready for execution */ ++#define SCST_CMD_STATE_REAL_EXEC (SCST_CMD_STATE_LAST_ACTIVE+7) ++ ++/* Waiting for CDB's execution finish */ ++#define SCST_CMD_STATE_REAL_EXECUTING (SCST_CMD_STATE_LAST_ACTIVE+8) ++ ++/* Waiting for response's transmission finish */ ++#define SCST_CMD_STATE_XMIT_WAIT (SCST_CMD_STATE_LAST_ACTIVE+9) ++ ++/************************************************************* ++ * Can be returned instead of cmd's state by dev handlers' ++ * functions, if the command's state should be set by default ++ *************************************************************/ ++#define SCST_CMD_STATE_DEFAULT 500 ++ ++/************************************************************* ++ * Can be returned instead of cmd's state by dev handlers' ++ * functions, if it is impossible to complete requested ++ * task in atomic context. The cmd will be restarted in thread ++ * context. ++ *************************************************************/ ++#define SCST_CMD_STATE_NEED_THREAD_CTX 1000 ++ ++/************************************************************* ++ * Can be returned instead of cmd's state by dev handlers' ++ * parse function, if the cmd processing should be stopped ++ * for now. The cmd will be restarted by dev handlers itself. ++ *************************************************************/ ++#define SCST_CMD_STATE_STOP 1001 ++ ++/************************************************************* ++ ** States of mgmt command processing state machine ++ *************************************************************/ ++ ++/* LUN translation (mcmd->tgt_dev assignment) */ ++#define SCST_MCMD_STATE_INIT 0 ++ ++/* Mgmt cmd is being processed */ ++#define SCST_MCMD_STATE_EXEC 1 ++ ++/* Waiting for affected commands done */ ++#define SCST_MCMD_STATE_WAITING_AFFECTED_CMDS_DONE 2 ++ ++/* Post actions when affected commands done */ ++#define SCST_MCMD_STATE_AFFECTED_CMDS_DONE 3 ++ ++/* Waiting for affected local commands finished */ ++#define SCST_MCMD_STATE_WAITING_AFFECTED_CMDS_FINISHED 4 ++ ++/* Target driver's task_mgmt_fn_done() is going to be called */ ++#define SCST_MCMD_STATE_DONE 5 ++ ++/* The mcmd finished */ ++#define SCST_MCMD_STATE_FINISHED 6 ++ ++/************************************************************* ++ ** Constants for "atomic" parameter of SCST's functions ++ *************************************************************/ ++#define SCST_NON_ATOMIC 0 ++#define SCST_ATOMIC 1 ++ ++/************************************************************* ++ ** Values for pref_context parameter of scst_cmd_init_done(), ++ ** scst_rx_data(), scst_restart_cmd(), scst_tgt_cmd_done() ++ ** and scst_cmd_done() ++ *************************************************************/ ++ ++enum scst_exec_context { ++ /* ++ * Direct cmd's processing (i.e. regular function calls in the current ++ * context) sleeping is not allowed ++ */ ++ SCST_CONTEXT_DIRECT_ATOMIC, ++ ++ /* ++ * Direct cmd's processing (i.e. regular function calls in the current ++ * context), sleeping is allowed, no restrictions ++ */ ++ SCST_CONTEXT_DIRECT, ++ ++ /* Tasklet or thread context required for cmd's processing */ ++ SCST_CONTEXT_TASKLET, ++ ++ /* Thread context required for cmd's processing */ ++ SCST_CONTEXT_THREAD, ++ ++ /* ++ * Context is the same as it was in previous call of the corresponding ++ * callback. For example, if dev handler's exec() does sync. data ++ * reading this value should be used for scst_cmd_done(). The same is ++ * true if scst_tgt_cmd_done() called directly from target driver's ++ * xmit_response(). Not allowed in scst_cmd_init_done() and ++ * scst_cmd_init_stage1_done(). ++ */ ++ SCST_CONTEXT_SAME ++}; ++ ++/************************************************************* ++ ** Values for status parameter of scst_rx_data() ++ *************************************************************/ ++ ++/* Success */ ++#define SCST_RX_STATUS_SUCCESS 0 ++ ++/* ++ * Data receiving finished with error, so set the sense and ++ * finish the command, including xmit_response() call ++ */ ++#define SCST_RX_STATUS_ERROR 1 ++ ++/* ++ * Data receiving finished with error and the sense is set, ++ * so finish the command, including xmit_response() call ++ */ ++#define SCST_RX_STATUS_ERROR_SENSE_SET 2 ++ ++/* ++ * Data receiving finished with fatal error, so finish the command, ++ * but don't call xmit_response() ++ */ ++#define SCST_RX_STATUS_ERROR_FATAL 3 ++ ++/************************************************************* ++ ** Values for status parameter of scst_restart_cmd() ++ *************************************************************/ ++ ++/* Success */ ++#define SCST_PREPROCESS_STATUS_SUCCESS 0 ++ ++/* ++ * Command's processing finished with error, so set the sense and ++ * finish the command, including xmit_response() call ++ */ ++#define SCST_PREPROCESS_STATUS_ERROR 1 ++ ++/* ++ * Command's processing finished with error and the sense is set, ++ * so finish the command, including xmit_response() call ++ */ ++#define SCST_PREPROCESS_STATUS_ERROR_SENSE_SET 2 ++ ++/* ++ * Command's processing finished with fatal error, so finish the command, ++ * but don't call xmit_response() ++ */ ++#define SCST_PREPROCESS_STATUS_ERROR_FATAL 3 ++ ++/************************************************************* ++ ** Values for AEN functions ++ *************************************************************/ ++ ++/* ++ * SCSI Asynchronous Event. Parameter contains SCSI sense ++ * (Unit Attention). AENs generated only for 2 the following UAs: ++ * CAPACITY DATA HAS CHANGED and REPORTED LUNS DATA HAS CHANGED. ++ * Other UAs reported regularly as CHECK CONDITION status, ++ * because it doesn't look safe to report them using AENs, since ++ * reporting using AENs opens delivery race windows even in case of ++ * untagged commands. ++ */ ++#define SCST_AEN_SCSI 0 ++ ++/* ++ * Notifies that CPU affinity mask on the corresponding session changed ++ */ ++#define SCST_AEN_CPU_MASK_CHANGED 1 ++ ++/************************************************************* ++ ** Allowed return/status codes for report_aen() callback and ++ ** scst_set_aen_delivery_status() function ++ *************************************************************/ ++ ++/* Success */ ++#define SCST_AEN_RES_SUCCESS 0 ++ ++/* Not supported */ ++#define SCST_AEN_RES_NOT_SUPPORTED -1 ++ ++/* Failure */ ++#define SCST_AEN_RES_FAILED -2 ++ ++/************************************************************* ++ ** Allowed return codes for xmit_response(), rdy_to_xfer() ++ *************************************************************/ ++ ++/* Success */ ++#define SCST_TGT_RES_SUCCESS 0 ++ ++/* Internal device queue is full, retry again later */ ++#define SCST_TGT_RES_QUEUE_FULL -1 ++ ++/* ++ * It is impossible to complete requested task in atomic context. ++ * The cmd will be restarted in thread context. ++ */ ++#define SCST_TGT_RES_NEED_THREAD_CTX -2 ++ ++/* ++ * Fatal error, if returned by xmit_response() the cmd will ++ * be destroyed, if by any other function, xmit_response() ++ * will be called with HARDWARE ERROR sense data ++ */ ++#define SCST_TGT_RES_FATAL_ERROR -3 ++ ++/************************************************************* ++ ** Return codes for dev handler's exec() ++ *************************************************************/ ++ ++/* The cmd is done, go to other ones */ ++#define SCST_EXEC_COMPLETED 0 ++ ++/* The cmd should be sent to SCSI mid-level */ ++#define SCST_EXEC_NOT_COMPLETED 1 ++ ++/************************************************************* ++ ** Additional return code for dev handler's task_mgmt_fn() ++ *************************************************************/ ++ ++/* Regular standard actions for the command should be done */ ++#define SCST_DEV_TM_NOT_COMPLETED 1 ++ ++/************************************************************* ++ ** Session initialization phases ++ *************************************************************/ ++ ++/* Set if session is being initialized */ ++#define SCST_SESS_IPH_INITING 0 ++ ++/* Set if the session is successfully initialized */ ++#define SCST_SESS_IPH_SUCCESS 1 ++ ++/* Set if the session initialization failed */ ++#define SCST_SESS_IPH_FAILED 2 ++ ++/* Set if session is initialized and ready */ ++#define SCST_SESS_IPH_READY 3 ++ ++/************************************************************* ++ ** Session shutdown phases ++ *************************************************************/ ++ ++/* Set if session is initialized and ready */ ++#define SCST_SESS_SPH_READY 0 ++ ++/* Set if session is shutting down */ ++#define SCST_SESS_SPH_SHUTDOWN 1 ++ ++/* Set if session is shutting down */ ++#define SCST_SESS_SPH_UNREG_DONE_CALLING 2 ++ ++/************************************************************* ++ ** Session's async (atomic) flags ++ *************************************************************/ ++ ++/* Set if the sess's hw pending work is scheduled */ ++#define SCST_SESS_HW_PENDING_WORK_SCHEDULED 0 ++ ++/************************************************************* ++ ** Cmd's async (atomic) flags ++ *************************************************************/ ++ ++/* Set if the cmd is aborted and ABORTED sense will be sent as the result */ ++#define SCST_CMD_ABORTED 0 ++ ++/* Set if the cmd is aborted by other initiator */ ++#define SCST_CMD_ABORTED_OTHER 1 ++ ++/* Set if no response should be sent to the target about this cmd */ ++#define SCST_CMD_NO_RESP 2 ++ ++/* Set if the cmd is dead and can be destroyed at any time */ ++#define SCST_CMD_CAN_BE_DESTROYED 3 ++ ++/* ++ * Set if the cmd's device has TAS flag set. Used only when aborted by ++ * other initiator. ++ */ ++#define SCST_CMD_DEVICE_TAS 4 ++ ++/************************************************************* ++ ** Tgt_dev's async. flags (tgt_dev_flags) ++ *************************************************************/ ++ ++/* Set if tgt_dev has Unit Attention sense */ ++#define SCST_TGT_DEV_UA_PENDING 0 ++ ++/* Set if tgt_dev is RESERVED by another session */ ++#define SCST_TGT_DEV_RESERVED 1 ++ ++/* Set if the corresponding context should be atomic */ ++#define SCST_TGT_DEV_AFTER_INIT_WR_ATOMIC 5 ++#define SCST_TGT_DEV_AFTER_EXEC_ATOMIC 6 ++ ++#define SCST_TGT_DEV_CLUST_POOL 11 ++ ++/************************************************************* ++ ** I/O grouping types. Changing them don't forget to change ++ ** the corresponding *_STR values in scst_const.h! ++ *************************************************************/ ++ ++/* ++ * All initiators with the same name connected to this group will have ++ * shared IO context, for each name own context. All initiators with ++ * different names will have own IO context. ++ */ ++#define SCST_IO_GROUPING_AUTO 0 ++ ++/* All initiators connected to this group will have shared IO context */ ++#define SCST_IO_GROUPING_THIS_GROUP_ONLY -1 ++ ++/* Each initiator connected to this group will have own IO context */ ++#define SCST_IO_GROUPING_NEVER -2 ++ ++/************************************************************* ++ ** Kernel cache creation helper ++ *************************************************************/ ++ ++/************************************************************* ++ ** Valid_mask constants for scst_analyze_sense() ++ *************************************************************/ ++ ++#define SCST_SENSE_KEY_VALID 1 ++#define SCST_SENSE_ASC_VALID 2 ++#define SCST_SENSE_ASCQ_VALID 4 ++ ++#define SCST_SENSE_ASCx_VALID (SCST_SENSE_ASC_VALID | \ ++ SCST_SENSE_ASCQ_VALID) ++ ++#define SCST_SENSE_ALL_VALID (SCST_SENSE_KEY_VALID | \ ++ SCST_SENSE_ASC_VALID | \ ++ SCST_SENSE_ASCQ_VALID) ++ ++/************************************************************* ++ * TYPES ++ *************************************************************/ ++ ++struct scst_tgt; ++struct scst_session; ++struct scst_cmd; ++struct scst_mgmt_cmd; ++struct scst_device; ++struct scst_tgt_dev; ++struct scst_dev_type; ++struct scst_acg; ++struct scst_acg_dev; ++struct scst_acn; ++struct scst_aen; ++ ++/* ++ * SCST uses 64-bit numbers to represent LUN's internally. The value ++ * NO_SUCH_LUN is guaranteed to be different of every valid LUN. ++ */ ++#define NO_SUCH_LUN ((uint64_t)-1) ++ ++typedef enum dma_data_direction scst_data_direction; ++ ++/* ++ * SCST target template: defines target driver's parameters and callback ++ * functions. ++ * ++ * MUST HAVEs define functions that are expected to be defined in order to ++ * work. OPTIONAL says that there is a choice. ++ */ ++struct scst_tgt_template { ++ /* public: */ ++ ++ /* ++ * SG tablesize allows to check whether scatter/gather can be used ++ * or not. ++ */ ++ int sg_tablesize; ++ ++ /* ++ * True, if this target adapter uses unchecked DMA onto an ISA bus. ++ */ ++ unsigned unchecked_isa_dma:1; ++ ++ /* ++ * True, if this target adapter can benefit from using SG-vector ++ * clustering (i.e. smaller number of segments). ++ */ ++ unsigned use_clustering:1; ++ ++ /* ++ * True, if this target adapter doesn't support SG-vector clustering ++ */ ++ unsigned no_clustering:1; ++ ++ /* ++ * True, if corresponding function supports execution in ++ * the atomic (non-sleeping) context ++ */ ++ unsigned xmit_response_atomic:1; ++ unsigned rdy_to_xfer_atomic:1; ++ ++ /* True, if this target doesn't need "enabled" attribute */ ++ unsigned enabled_attr_not_needed:1; ++ ++ /* ++ * True if SCST should report that it supports ACA although it does ++ * not yet support ACA. Necessary for the IBM virtual SCSI target ++ * driver. ++ */ ++ unsigned fake_aca:1; ++ ++ /* ++ * Preferred SCSI LUN addressing method. ++ */ ++ enum scst_lun_addr_method preferred_addr_method; ++ ++ /* ++ * The maximum time in seconds cmd can stay inside the target ++ * hardware, i.e. after rdy_to_xfer() and xmit_response(), before ++ * on_hw_pending_cmd_timeout() will be called, if defined. ++ * ++ * In the current implementation a cmd will be aborted in time t ++ * max_hw_pending_time <= t < 2*max_hw_pending_time. ++ */ ++ int max_hw_pending_time; ++ ++ /* ++ * This function is equivalent to the SCSI ++ * queuecommand. The target should transmit the response ++ * buffer and the status in the scst_cmd struct. ++ * The expectation is that this executing this command is NON-BLOCKING. ++ * If it is blocking, consider to set threads_num to some none 0 number. ++ * ++ * After the response is actually transmitted, the target ++ * should call the scst_tgt_cmd_done() function of the ++ * mid-level, which will allow it to free up the command. ++ * Returns one of the SCST_TGT_RES_* constants. ++ * ++ * Pay attention to "atomic" attribute of the cmd, which can be get ++ * by scst_cmd_atomic(): it is true if the function called in the ++ * atomic (non-sleeping) context. ++ * ++ * MUST HAVE ++ */ ++ int (*xmit_response) (struct scst_cmd *cmd); ++ ++ /* ++ * This function informs the driver that data ++ * buffer corresponding to the said command have now been ++ * allocated and it is OK to receive data for this command. ++ * This function is necessary because a SCSI target does not ++ * have any control over the commands it receives. Most lower ++ * level protocols have a corresponding function which informs ++ * the initiator that buffers have been allocated e.g., XFER_ ++ * RDY in Fibre Channel. After the data is actually received ++ * the low-level driver needs to call scst_rx_data() in order to ++ * continue processing this command. ++ * Returns one of the SCST_TGT_RES_* constants. ++ * ++ * This command is expected to be NON-BLOCKING. ++ * If it is blocking, consider to set threads_num to some none 0 number. ++ * ++ * Pay attention to "atomic" attribute of the cmd, which can be get ++ * by scst_cmd_atomic(): it is true if the function called in the ++ * atomic (non-sleeping) context. ++ * ++ * OPTIONAL ++ */ ++ int (*rdy_to_xfer) (struct scst_cmd *cmd); ++ ++ /* ++ * Called if cmd stays inside the target hardware, i.e. after ++ * rdy_to_xfer() and xmit_response(), more than max_hw_pending_time ++ * time. The target driver supposed to cleanup this command and ++ * resume cmd's processing. ++ * ++ * OPTIONAL ++ */ ++ void (*on_hw_pending_cmd_timeout) (struct scst_cmd *cmd); ++ ++ /* ++ * Called to notify the driver that the command is about to be freed. ++ * Necessary, because for aborted commands xmit_response() could not ++ * be called. Could be called on IRQ context. ++ * ++ * OPTIONAL ++ */ ++ void (*on_free_cmd) (struct scst_cmd *cmd); ++ ++ /* ++ * This function allows target driver to handle data buffer ++ * allocations on its own. ++ * ++ * Target driver doesn't have to always allocate buffer in this ++ * function, but if it decide to do it, it must check that ++ * scst_cmd_get_data_buff_alloced() returns 0, otherwise to avoid ++ * double buffer allocation and memory leaks alloc_data_buf() shall ++ * fail. ++ * ++ * Shall return 0 in case of success or < 0 (preferably -ENOMEM) ++ * in case of error, or > 0 if the regular SCST allocation should be ++ * done. In case of returning successfully, ++ * scst_cmd->tgt_data_buf_alloced will be set by SCST. ++ * ++ * It is possible that both target driver and dev handler request own ++ * memory allocation. In this case, data will be memcpy() between ++ * buffers, where necessary. ++ * ++ * If allocation in atomic context - cf. scst_cmd_atomic() - is not ++ * desired or fails and consequently < 0 is returned, this function ++ * will be re-called in thread context. ++ * ++ * Please note that the driver will have to handle itself all relevant ++ * details such as scatterlist setup, highmem, freeing the allocated ++ * memory, etc. ++ * ++ * OPTIONAL. ++ */ ++ int (*alloc_data_buf) (struct scst_cmd *cmd); ++ ++ /* ++ * This function informs the driver that data ++ * buffer corresponding to the said command have now been ++ * allocated and other preprocessing tasks have been done. ++ * A target driver could need to do some actions at this stage. ++ * After the target driver done the needed actions, it shall call ++ * scst_restart_cmd() in order to continue processing this command. ++ * In case of preliminary the command completion, this function will ++ * also be called before xmit_response(). ++ * ++ * Called only if the cmd is queued using scst_cmd_init_stage1_done() ++ * instead of scst_cmd_init_done(). ++ * ++ * Returns void, the result is expected to be returned using ++ * scst_restart_cmd(). ++ * ++ * This command is expected to be NON-BLOCKING. ++ * If it is blocking, consider to set threads_num to some none 0 number. ++ * ++ * Pay attention to "atomic" attribute of the cmd, which can be get ++ * by scst_cmd_atomic(): it is true if the function called in the ++ * atomic (non-sleeping) context. ++ * ++ * OPTIONAL. ++ */ ++ void (*preprocessing_done) (struct scst_cmd *cmd); ++ ++ /* ++ * This function informs the driver that the said command is about ++ * to be executed. ++ * ++ * Returns one of the SCST_PREPROCESS_* constants. ++ * ++ * This command is expected to be NON-BLOCKING. ++ * If it is blocking, consider to set threads_num to some none 0 number. ++ * ++ * OPTIONAL ++ */ ++ int (*pre_exec) (struct scst_cmd *cmd); ++ ++ /* ++ * This function informs the driver that all affected by the ++ * corresponding task management function commands have beed completed. ++ * No return value expected. ++ * ++ * This function is expected to be NON-BLOCKING. ++ * ++ * Called without any locks held from a thread context. ++ * ++ * OPTIONAL ++ */ ++ void (*task_mgmt_affected_cmds_done) (struct scst_mgmt_cmd *mgmt_cmd); ++ ++ /* ++ * This function informs the driver that the corresponding task ++ * management function has been completed, i.e. all the corresponding ++ * commands completed and freed. No return value expected. ++ * ++ * This function is expected to be NON-BLOCKING. ++ * ++ * Called without any locks held from a thread context. ++ * ++ * MUST HAVE if the target supports task management. ++ */ ++ void (*task_mgmt_fn_done) (struct scst_mgmt_cmd *mgmt_cmd); ++ ++ /* ++ * Called to notify target driver that the command is being aborted. ++ * If target driver wants to redirect processing to some outside ++ * processing, it should get it using scst_cmd_get(). ++ * ++ * OPTIONAL ++ */ ++ void (*on_abort_cmd) (struct scst_cmd *cmd); ++ ++ /* ++ * This function should detect the target adapters that ++ * are present in the system. The function should return a value ++ * >= 0 to signify the number of detected target adapters. ++ * A negative value should be returned whenever there is ++ * an error. ++ * ++ * MUST HAVE ++ */ ++ int (*detect) (struct scst_tgt_template *tgt_template); ++ ++ /* ++ * This function should free up the resources allocated to the device. ++ * The function should return 0 to indicate successful release ++ * or a negative value if there are some issues with the release. ++ * In the current version the return value is ignored. ++ * ++ * MUST HAVE ++ */ ++ int (*release) (struct scst_tgt *tgt); ++ ++ /* ++ * This function is used for Asynchronous Event Notifications. ++ * ++ * Returns one of the SCST_AEN_RES_* constants. ++ * After AEN is sent, target driver must call scst_aen_done() and, ++ * optionally, scst_set_aen_delivery_status(). ++ * ++ * This function is expected to be NON-BLOCKING, but can sleep. ++ * ++ * This function must be prepared to handle AENs between calls for the ++ * corresponding session of scst_unregister_session() and ++ * unreg_done_fn() callback called or before scst_unregister_session() ++ * returned, if its called in the blocking mode. AENs for such sessions ++ * should be ignored. ++ * ++ * MUST HAVE, if low-level protocol supports AENs. ++ */ ++ int (*report_aen) (struct scst_aen *aen); ++ ++ /* ++ * This function returns in tr_id the corresponding to sess initiator ++ * port TransportID in the form as it's used by PR commands, see ++ * "Transport Identifiers" in SPC. Space for the initiator port ++ * TransportID must be allocated via kmalloc(). Caller supposed to ++ * kfree() it, when it isn't needed anymore. ++ * ++ * If sess is NULL, this function must return TransportID PROTOCOL ++ * IDENTIFIER for the requested target. ++ * ++ * Returns 0 on success or negative error code otherwise. ++ * ++ * SHOULD HAVE, because it's required for Persistent Reservations. ++ */ ++ int (*get_initiator_port_transport_id) (struct scst_tgt *tgt, ++ struct scst_session *sess, uint8_t **transport_id); ++ ++ /* ++ * This function allows to enable or disable particular target. ++ * A disabled target doesn't receive and process any SCSI commands. ++ * ++ * SHOULD HAVE to avoid race when there are connected initiators, ++ * while target not yet completed the initial configuration. In this ++ * case the too early connected initiators would see not those devices, ++ * which they intended to see. ++ * ++ * If you are sure your target driver doesn't need enabling target, ++ * you should set enabled_attr_not_needed in 1. ++ */ ++ int (*enable_target) (struct scst_tgt *tgt, bool enable); ++ ++ /* ++ * This function shows if particular target is enabled or not. ++ * ++ * SHOULD HAVE, see above why. ++ */ ++ bool (*is_target_enabled) (struct scst_tgt *tgt); ++ ++ /* ++ * This function adds a virtual target. ++ * ++ * If both add_target and del_target callbacks defined, then this ++ * target driver supposed to support virtual targets. In this case ++ * an "mgmt" entry will be created in the sysfs root for this driver. ++ * The "mgmt" entry will support 2 commands: "add_target" and ++ * "del_target", for which the corresponding callbacks will be called. ++ * Also target driver can define own commands for the "mgmt" entry, see ++ * mgmt_cmd and mgmt_cmd_help below. ++ * ++ * This approach allows uniform targets management to simplify external ++ * management tools like scstadmin. See README for more details. ++ * ++ * Either both add_target and del_target must be defined, or none. ++ * ++ * MUST HAVE if virtual targets are supported. ++ */ ++ ssize_t (*add_target) (const char *target_name, char *params); ++ ++ /* ++ * This function deletes a virtual target. See comment for add_target ++ * above. ++ * ++ * MUST HAVE if virtual targets are supported. ++ */ ++ ssize_t (*del_target) (const char *target_name); ++ ++ /* ++ * This function called if not "add_target" or "del_target" command is ++ * sent to the mgmt entry (see comment for add_target above). In this ++ * case the command passed to this function as is in a string form. ++ * ++ * OPTIONAL. ++ */ ++ ssize_t (*mgmt_cmd) (char *cmd); ++ ++ /* ++ * Should return physical transport version. Used in the corresponding ++ * INQUIRY version descriptor. See SPC for the list of available codes. ++ * ++ * OPTIONAL ++ */ ++ uint16_t (*get_phys_transport_version) (struct scst_tgt *tgt); ++ ++ /* ++ * Should return SCSI transport version. Used in the corresponding ++ * INQUIRY version descriptor. See SPC for the list of available codes. ++ * ++ * OPTIONAL ++ */ ++ uint16_t (*get_scsi_transport_version) (struct scst_tgt *tgt); ++ ++ /* ++ * Name of the template. Must be unique to identify ++ * the template. MUST HAVE ++ */ ++ const char name[SCST_MAX_NAME]; ++ ++ /* ++ * Number of additional threads to the pool of dedicated threads. ++ * Used if xmit_response() or rdy_to_xfer() is blocking. ++ * It is the target driver's duty to ensure that not more, than that ++ * number of threads, are blocked in those functions at any time. ++ */ ++ int threads_num; ++ ++ /* Optional default log flags */ ++ const unsigned long default_trace_flags; ++ ++ /* Optional pointer to trace flags */ ++ unsigned long *trace_flags; ++ ++ /* Optional local trace table */ ++ struct scst_trace_log *trace_tbl; ++ ++ /* Optional local trace table help string */ ++ const char *trace_tbl_help; ++ ++ /* sysfs attributes, if any */ ++ const struct attribute **tgtt_attrs; ++ ++ /* sysfs target attributes, if any */ ++ const struct attribute **tgt_attrs; ++ ++ /* sysfs session attributes, if any */ ++ const struct attribute **sess_attrs; ++ ++ /* Optional help string for mgmt_cmd commands */ ++ const char *mgmt_cmd_help; ++ ++ /* List of parameters for add_target command, if any */ ++ const char *add_target_parameters; ++ ++ /* ++ * List of optional, i.e. which could be added by add_attribute command ++ * and deleted by del_attribute command, sysfs attributes, if any. ++ * Helpful for scstadmin to work correctly. ++ */ ++ const char *tgtt_optional_attributes; ++ ++ /* ++ * List of optional, i.e. which could be added by add_target_attribute ++ * command and deleted by del_target_attribute command, sysfs ++ * attributes, if any. Helpful for scstadmin to work correctly. ++ */ ++ const char *tgt_optional_attributes; ++ ++ /** Private, must be inited to 0 by memset() **/ ++ ++ /* List of targets per template, protected by scst_mutex */ ++ struct list_head tgt_list; ++ ++ /* List entry of global templates list */ ++ struct list_head scst_template_list_entry; ++ ++ struct kobject tgtt_kobj; /* kobject for this struct */ ++ ++ /* Number of currently active sysfs mgmt works (scst_sysfs_work_item) */ ++ int tgtt_active_sysfs_works_count; ++ ++ /* sysfs release completion */ ++ struct completion *tgtt_kobj_release_cmpl; ++ ++ /* ++ * Optional vendor to be reported via the SCSI inquiry data. If NULL, ++ * an SCST device handler specific default value will be used, e.g. ++ * "SCST_FIO" for scst_vdisk file I/O. ++ */ ++ const char *vendor; ++ ++ /* ++ * Optional method that sets the product ID in [buf, buf+size) based ++ * on the device type (byte 0 of the SCSI inquiry data, which contains ++ * the peripheral qualifier in the highest three bits and the ++ * peripheral device type in the lower five bits). ++ */ ++ void (*get_product_id)(const struct scst_tgt_dev *tgt_dev, ++ char *buf, int size); ++ ++ /* ++ * Optional revision to be reported in the SCSI inquiry response. If ++ * NULL, an SCST device handler specific default value will be used, ++ * e.g. " 220" for scst_vdisk file I/O. ++ */ ++ const char *revision; ++ ++ /* ++ * Optional method that writes the serial number of a target device in ++ * [buf, buf+size) and returns the number of bytes written. ++ * ++ * Note: SCST can be configured such that a device can be accessed ++ * from several different transports at the same time. It is important ++ * that all clients see the same USN for proper operation. Overriding ++ * the serial number can lead to subtle misbehavior. Particularly, ++ * "usn" sysfs attribute of the corresponding devices will still show ++ * the devices generated or assigned serial numbers. ++ */ ++ int (*get_serial)(const struct scst_tgt_dev *tgt_dev, char *buf, ++ int size); ++ ++ /* ++ * Optional method that writes the SCSI inquiry vendor-specific data in ++ * [buf, buf+size) and returns the number of bytes written. ++ */ ++ int (*get_vend_specific)(const struct scst_tgt_dev *tgt_dev, char *buf, ++ int size); ++}; ++ ++/* ++ * Threads pool types. Changing them don't forget to change ++ * the corresponding *_STR values in scst_const.h! ++ */ ++enum scst_dev_type_threads_pool_type { ++ /* Each initiator will have dedicated threads pool. */ ++ SCST_THREADS_POOL_PER_INITIATOR = 0, ++ ++ /* All connected initiators will use shared threads pool */ ++ SCST_THREADS_POOL_SHARED, ++ ++ /* Invalid value for scst_parse_threads_pool_type() */ ++ SCST_THREADS_POOL_TYPE_INVALID, ++}; ++ ++/* ++ * SCST dev handler template: defines dev handler's parameters and callback ++ * functions. ++ * ++ * MUST HAVEs define functions that are expected to be defined in order to ++ * work. OPTIONAL says that there is a choice. ++ */ ++struct scst_dev_type { ++ /* SCSI type of the supported device. MUST HAVE */ ++ int type; ++ ++ /* ++ * True, if corresponding function supports execution in ++ * the atomic (non-sleeping) context ++ */ ++ unsigned parse_atomic:1; ++ unsigned alloc_data_buf_atomic:1; ++ unsigned dev_done_atomic:1; ++ ++ /* ++ * Should be true, if exec() is synchronous. This is a hint to SCST core ++ * to optimize commands order management. ++ */ ++ unsigned exec_sync:1; ++ ++ /* ++ * Should be set if the device wants to receive notification of ++ * Persistent Reservation commands (PR OUT only) ++ * Note: The notification will not be send if the command failed ++ */ ++ unsigned pr_cmds_notifications:1; ++ ++ /* ++ * Called to parse CDB from the cmd and initialize ++ * cmd->bufflen and cmd->data_direction (both - REQUIRED). ++ * ++ * Returns the command's next state or SCST_CMD_STATE_DEFAULT, ++ * if the next default state should be used, or ++ * SCST_CMD_STATE_NEED_THREAD_CTX if the function called in atomic ++ * context, but requires sleeping, or SCST_CMD_STATE_STOP if the ++ * command should not be further processed for now. In the ++ * SCST_CMD_STATE_NEED_THREAD_CTX case the function ++ * will be recalled in the thread context, where sleeping is allowed. ++ * ++ * Pay attention to "atomic" attribute of the cmd, which can be get ++ * by scst_cmd_atomic(): it is true if the function called in the ++ * atomic (non-sleeping) context. ++ * ++ * MUST HAVE ++ */ ++ int (*parse) (struct scst_cmd *cmd); ++ ++ /* ++ * This function allows dev handler to handle data buffer ++ * allocations on its own. ++ * ++ * Returns the command's next state or SCST_CMD_STATE_DEFAULT, ++ * if the next default state should be used, or ++ * SCST_CMD_STATE_NEED_THREAD_CTX if the function called in atomic ++ * context, but requires sleeping, or SCST_CMD_STATE_STOP if the ++ * command should not be further processed for now. In the ++ * SCST_CMD_STATE_NEED_THREAD_CTX case the function ++ * will be recalled in the thread context, where sleeping is allowed. ++ * ++ * Pay attention to "atomic" attribute of the cmd, which can be get ++ * by scst_cmd_atomic(): it is true if the function called in the ++ * atomic (non-sleeping) context. ++ * ++ * OPTIONAL ++ */ ++ int (*alloc_data_buf) (struct scst_cmd *cmd); ++ ++ /* ++ * Called to execute CDB. Useful, for instance, to implement ++ * data caching. The result of CDB execution is reported via ++ * cmd->scst_cmd_done() callback. ++ * Returns: ++ * - SCST_EXEC_COMPLETED - the cmd is done, go to other ones ++ * - SCST_EXEC_NOT_COMPLETED - the cmd should be sent to SCSI ++ * mid-level. ++ * ++ * If this function provides sync execution, you should set ++ * exec_sync flag and consider to setup dedicated threads by ++ * setting threads_num > 0. ++ * ++ * !! If this function is implemented, scst_check_local_events() !! ++ * !! shall be called inside it just before the actual command's !! ++ * !! execution. !! ++ * ++ * OPTIONAL, if not set, the commands will be sent directly to SCSI ++ * device. ++ */ ++ int (*exec) (struct scst_cmd *cmd); ++ ++ /* ++ * Called to notify dev handler about the result of cmd execution ++ * and perform some post processing. Cmd's fields is_send_status and ++ * resp_data_len should be set by this function, but SCST offers good ++ * defaults. ++ * Returns the command's next state or SCST_CMD_STATE_DEFAULT, ++ * if the next default state should be used, or ++ * SCST_CMD_STATE_NEED_THREAD_CTX if the function called in atomic ++ * context, but requires sleeping. In the last case, the function ++ * will be recalled in the thread context, where sleeping is allowed. ++ * ++ * Pay attention to "atomic" attribute of the cmd, which can be get ++ * by scst_cmd_atomic(): it is true if the function called in the ++ * atomic (non-sleeping) context. ++ * ++ * OPTIONAL ++ */ ++ int (*dev_done) (struct scst_cmd *cmd); ++ ++ /* ++ * Called to notify dev hander that the command is about to be freed. ++ * ++ * Could be called on IRQ context. ++ * ++ * OPTIONAL ++ */ ++ void (*on_free_cmd) (struct scst_cmd *cmd); ++ ++ /* ++ * Called to execute a task management command. ++ * Returns: ++ * - SCST_MGMT_STATUS_SUCCESS - the command is done with success, ++ * no further actions required ++ * - The SCST_MGMT_STATUS_* error code if the command is failed and ++ * no further actions required ++ * - SCST_DEV_TM_NOT_COMPLETED - regular standard actions for the ++ * command should be done ++ * ++ * Can be called under many internal SCST locks, including under ++ * disabled IRQs, so dev handler should be careful with locking and, ++ * if necessary, pass processing somewhere outside (in a work, e.g.) ++ * ++ * But at the moment it's called under disabled IRQs only for ++ * SCST_ABORT_TASK, however dev handler using it should add a BUG_ON ++ * trap to catch if it's changed in future. ++ * ++ * OPTIONAL ++ */ ++ int (*task_mgmt_fn) (struct scst_mgmt_cmd *mgmt_cmd, ++ struct scst_tgt_dev *tgt_dev); ++ ++ /* ++ * Called to notify dev handler that its sg_tablesize is too low to ++ * satisfy this command's data transfer requirements. Should return ++ * true if exec() callback will split this command's CDB on smaller ++ * transfers, false otherwise. ++ * ++ * Could be called on SIRQ context. ++ * ++ * MUST HAVE, if dev handler supports CDB splitting. ++ */ ++ bool (*on_sg_tablesize_low) (struct scst_cmd *cmd); ++ ++ /* ++ * Called when new device is attaching to the dev handler ++ * Returns 0 on success, error code otherwise. ++ * ++ * OPTIONAL ++ */ ++ int (*attach) (struct scst_device *dev); ++ ++ /* ++ * Called when a device is detaching from the dev handler. ++ * ++ * OPTIONAL ++ */ ++ void (*detach) (struct scst_device *dev); ++ ++ /* ++ * Called when new tgt_dev (session) is attaching to the dev handler. ++ * Returns 0 on success, error code otherwise. ++ * ++ * OPTIONAL ++ */ ++ int (*attach_tgt) (struct scst_tgt_dev *tgt_dev); ++ ++ /* ++ * Called when tgt_dev (session) is detaching from the dev handler. ++ * ++ * OPTIONAL ++ */ ++ void (*detach_tgt) (struct scst_tgt_dev *tgt_dev); ++ ++ /* ++ * This function adds a virtual device. ++ * ++ * If both add_device and del_device callbacks defined, then this ++ * dev handler supposed to support adding/deleting virtual devices. ++ * In this case an "mgmt" entry will be created in the sysfs root for ++ * this handler. The "mgmt" entry will support 2 commands: "add_device" ++ * and "del_device", for which the corresponding callbacks will be called. ++ * Also dev handler can define own commands for the "mgmt" entry, see ++ * mgmt_cmd and mgmt_cmd_help below. ++ * ++ * This approach allows uniform devices management to simplify external ++ * management tools like scstadmin. See README for more details. ++ * ++ * Either both add_device and del_device must be defined, or none. ++ * ++ * MUST HAVE if virtual devices are supported. ++ */ ++ ssize_t (*add_device) (const char *device_name, char *params); ++ ++ /* ++ * This function deletes a virtual device. See comment for add_device ++ * above. ++ * ++ * MUST HAVE if virtual devices are supported. ++ */ ++ ssize_t (*del_device) (const char *device_name); ++ ++ /* ++ * This function called if not "add_device" or "del_device" command is ++ * sent to the mgmt entry (see comment for add_device above). In this ++ * case the command passed to this function as is in a string form. ++ * ++ * OPTIONAL. ++ */ ++ ssize_t (*mgmt_cmd) (char *cmd); ++ ++ /* ++ * Name of the dev handler. Must be unique. MUST HAVE. ++ * ++ * It's SCST_MAX_NAME + few more bytes to match scst_user expectations. ++ */ ++ char name[SCST_MAX_NAME + 10]; ++ ++ /* ++ * Number of threads in this handler's devices' threads pools. ++ * If 0 - no threads will be created, if <0 - creation of the threads ++ * pools is prohibited. Also pay attention to threads_pool_type below. ++ */ ++ int threads_num; ++ ++ /* Threads pool type. Valid only if threads_num > 0. */ ++ enum scst_dev_type_threads_pool_type threads_pool_type; ++ ++ /* Optional default log flags */ ++ const unsigned long default_trace_flags; ++ ++ /* Optional pointer to trace flags */ ++ unsigned long *trace_flags; ++ ++ /* Optional local trace table */ ++ struct scst_trace_log *trace_tbl; ++ ++ /* Optional local trace table help string */ ++ const char *trace_tbl_help; ++ ++ /* Optional help string for mgmt_cmd commands */ ++ const char *mgmt_cmd_help; ++ ++ /* List of parameters for add_device command, if any */ ++ const char *add_device_parameters; ++ ++ /* ++ * List of optional, i.e. which could be added by add_attribute command ++ * and deleted by del_attribute command, sysfs attributes, if any. ++ * Helpful for scstadmin to work correctly. ++ */ ++ const char *devt_optional_attributes; ++ ++ /* ++ * List of optional, i.e. which could be added by add_device_attribute ++ * command and deleted by del_device_attribute command, sysfs ++ * attributes, if any. Helpful for scstadmin to work correctly. ++ */ ++ const char *dev_optional_attributes; ++ ++ /* sysfs attributes, if any */ ++ const struct attribute **devt_attrs; ++ ++ /* sysfs device attributes, if any */ ++ const struct attribute **dev_attrs; ++ ++ /* Pointer to dev handler's private data */ ++ void *devt_priv; ++ ++ /* Pointer to parent dev type in the sysfs hierarchy */ ++ struct scst_dev_type *parent; ++ ++ struct module *module; ++ ++ /** Private, must be inited to 0 by memset() **/ ++ ++ /* list entry in scst_(virtual_)dev_type_list */ ++ struct list_head dev_type_list_entry; ++ ++ struct kobject devt_kobj; /* main handlers/driver */ ++ ++ /* Number of currently active sysfs mgmt works (scst_sysfs_work_item) */ ++ int devt_active_sysfs_works_count; ++ ++ /* To wait until devt_kobj released */ ++ struct completion *devt_kobj_release_compl; ++}; ++ ++/* ++ * An SCST target, analog of SCSI target port. ++ */ ++struct scst_tgt { ++ /* List of remote sessions per target, protected by scst_mutex */ ++ struct list_head sess_list; ++ ++ /* List entry of targets per template (tgts_list) */ ++ struct list_head tgt_list_entry; ++ ++ struct scst_tgt_template *tgtt; /* corresponding target template */ ++ ++ struct scst_acg *default_acg; /* default acg for this target */ ++ ++ struct list_head tgt_acg_list; /* target ACG groups */ ++ ++ /* ++ * Maximum SG table size. Needed here, since different cards on the ++ * same target template can have different SG table limitations. ++ */ ++ int sg_tablesize; ++ ++ /* Used for storage of target driver private stuff */ ++ void *tgt_priv; ++ ++ /* ++ * The following fields used to store and retry cmds if target's ++ * internal queue is full, so the target is unable to accept ++ * the cmd returning QUEUE FULL. ++ * They protected by tgt_lock, where necessary. ++ */ ++ bool retry_timer_active; ++ struct timer_list retry_timer; ++ atomic_t finished_cmds; ++ int retry_cmds; ++ spinlock_t tgt_lock; ++ struct list_head retry_cmd_list; ++ ++ /* Used to wait until session finished to unregister */ ++ wait_queue_head_t unreg_waitQ; ++ ++ /* Name of the target */ ++ char *tgt_name; ++ ++ /* User comment to it to let easier distinguish targets */ ++ char *tgt_comment; ++ ++ uint16_t rel_tgt_id; ++ ++ /* sysfs release completion */ ++ struct completion *tgt_kobj_release_cmpl; ++ ++ struct kobject tgt_kobj; /* main targets/target kobject */ ++ struct kobject *tgt_sess_kobj; /* target/sessions/ */ ++ struct kobject *tgt_luns_kobj; /* target/luns/ */ ++ struct kobject *tgt_ini_grp_kobj; /* target/ini_groups/ */ ++}; ++ ++#ifdef CONFIG_SCST_MEASURE_LATENCY ++ ++/* Defines extended latency statistics */ ++struct scst_ext_latency_stat { ++ uint64_t scst_time_rd, tgt_time_rd, dev_time_rd; ++ unsigned int processed_cmds_rd; ++ uint64_t min_scst_time_rd, min_tgt_time_rd, min_dev_time_rd; ++ uint64_t max_scst_time_rd, max_tgt_time_rd, max_dev_time_rd; ++ ++ uint64_t scst_time_wr, tgt_time_wr, dev_time_wr; ++ unsigned int processed_cmds_wr; ++ uint64_t min_scst_time_wr, min_tgt_time_wr, min_dev_time_wr; ++ uint64_t max_scst_time_wr, max_tgt_time_wr, max_dev_time_wr; ++}; ++ ++#define SCST_IO_SIZE_THRESHOLD_SMALL (8*1024) ++#define SCST_IO_SIZE_THRESHOLD_MEDIUM (32*1024) ++#define SCST_IO_SIZE_THRESHOLD_LARGE (128*1024) ++#define SCST_IO_SIZE_THRESHOLD_VERY_LARGE (512*1024) ++ ++#define SCST_LATENCY_STAT_INDEX_SMALL 0 ++#define SCST_LATENCY_STAT_INDEX_MEDIUM 1 ++#define SCST_LATENCY_STAT_INDEX_LARGE 2 ++#define SCST_LATENCY_STAT_INDEX_VERY_LARGE 3 ++#define SCST_LATENCY_STAT_INDEX_OTHER 4 ++#define SCST_LATENCY_STATS_NUM (SCST_LATENCY_STAT_INDEX_OTHER + 1) ++ ++#endif /* CONFIG_SCST_MEASURE_LATENCY */ ++ ++struct scst_io_stat_entry { ++ uint64_t cmd_count; ++ uint64_t io_byte_count; ++}; ++ ++/* ++ * SCST session, analog of SCSI I_T nexus ++ */ ++struct scst_session { ++ /* ++ * Initialization phase, one of SCST_SESS_IPH_* constants, protected by ++ * sess_list_lock ++ */ ++ int init_phase; ++ ++ struct scst_tgt *tgt; /* corresponding target */ ++ ++ /* Used for storage of target driver private stuff */ ++ void *tgt_priv; ++ ++ /* session's async flags */ ++ unsigned long sess_aflags; ++ ++ /* ++ * Hash list for tgt_dev's for this session with size and fn. It isn't ++ * hlist_entry, because we need ability to go over the list in the ++ * reverse order. Protected by scst_mutex and suspended activity. ++ */ ++#define SESS_TGT_DEV_LIST_HASH_SIZE (1 << 5) ++#define SESS_TGT_DEV_LIST_HASH_FN(val) ((val) & (SESS_TGT_DEV_LIST_HASH_SIZE - 1)) ++ struct list_head sess_tgt_dev_list[SESS_TGT_DEV_LIST_HASH_SIZE]; ++ ++ /* ++ * List of cmds in this session. Protected by sess_list_lock. ++ * ++ * We must always keep commands in the sess list from the ++ * very beginning, because otherwise they can be missed during ++ * TM processing. ++ */ ++ struct list_head sess_cmd_list; ++ ++ spinlock_t sess_list_lock; /* protects sess_cmd_list, etc */ ++ ++ atomic_t refcnt; /* get/put counter */ ++ ++ /* ++ * Alive commands for this session. ToDo: make it part of the common ++ * IO flow control. ++ */ ++ atomic_t sess_cmd_count; ++ ++ /* Some statistics. Protected by sess_list_lock. */ ++ struct scst_io_stat_entry io_stats[SCST_DATA_DIR_MAX]; ++ ++ /* Access control for this session and list entry there */ ++ struct scst_acg *acg; ++ ++ /* Initiator port transport id */ ++ uint8_t *transport_id; ++ ++ /* List entry for the sessions list inside ACG */ ++ struct list_head acg_sess_list_entry; ++ ++ struct delayed_work hw_pending_work; ++ ++ /* Name of attached initiator */ ++ const char *initiator_name; ++ ++ /* List entry of sessions per target */ ++ struct list_head sess_list_entry; ++ ++ /* List entry for the list that keeps session, waiting for the init */ ++ struct list_head sess_init_list_entry; ++ ++ /* ++ * List entry for the list that keeps session, waiting for the shutdown ++ */ ++ struct list_head sess_shut_list_entry; ++ ++ /* ++ * Lists of deferred during session initialization commands. ++ * Protected by sess_list_lock. ++ */ ++ struct list_head init_deferred_cmd_list; ++ struct list_head init_deferred_mcmd_list; ++ ++ /* ++ * Shutdown phase, one of SCST_SESS_SPH_* constants, unprotected. ++ * Async. relating to init_phase, must be a separate variable, because ++ * session could be unregistered before async. registration is finished. ++ */ ++ unsigned long shut_phase; ++ ++ /* Used if scst_unregister_session() called in wait mode */ ++ struct completion *shutdown_compl; ++ ++ /* sysfs release completion */ ++ struct completion *sess_kobj_release_cmpl; ++ ++ unsigned int sess_kobj_ready:1; ++ ++ struct kobject sess_kobj; /* kobject for this struct */ ++ ++ /* ++ * Functions and data for user callbacks from scst_register_session() ++ * and scst_unregister_session() ++ */ ++ void *reg_sess_data; ++ void (*init_result_fn) (struct scst_session *sess, void *data, ++ int result); ++ void (*unreg_done_fn) (struct scst_session *sess); ++ ++#ifdef CONFIG_SCST_MEASURE_LATENCY ++ /* ++ * Must be the last to allow to work with drivers who don't know ++ * about this config time option. ++ */ ++ spinlock_t lat_lock; ++ uint64_t scst_time, tgt_time, dev_time; ++ unsigned int processed_cmds; ++ uint64_t min_scst_time, min_tgt_time, min_dev_time; ++ uint64_t max_scst_time, max_tgt_time, max_dev_time; ++ struct scst_ext_latency_stat sess_latency_stat[SCST_LATENCY_STATS_NUM]; ++#endif ++}; ++ ++/* ++ * SCST_PR_ABORT_ALL TM function helper structure ++ */ ++struct scst_pr_abort_all_pending_mgmt_cmds_counter { ++ /* ++ * How many there are pending for this cmd SCST_PR_ABORT_ALL TM ++ * commands. ++ */ ++ atomic_t pr_abort_pending_cnt; ++ ++ /* Saved completion routine */ ++ void (*saved_cmd_done) (struct scst_cmd *cmd, int next_state, ++ enum scst_exec_context pref_context); ++ ++ /* ++ * How many there are pending for this cmd SCST_PR_ABORT_ALL TM ++ * commands, which not yet aborted all affected commands and ++ * a completion to signal, when it's done. ++ */ ++ atomic_t pr_aborting_cnt; ++ struct completion pr_aborting_cmpl; ++}; ++ ++/* ++ * Structure to control commands' queuing and threads pool processing the queue ++ */ ++struct scst_cmd_threads { ++ spinlock_t cmd_list_lock; ++ struct list_head active_cmd_list; /* commands queue */ ++ wait_queue_head_t cmd_list_waitQ; ++ ++ struct io_context *io_context; /* IO context of the threads pool */ ++ int io_context_refcnt; ++ ++ bool io_context_ready; ++ ++ /* io_context_mutex protects io_context and io_context_refcnt. */ ++ struct mutex io_context_mutex; ++ ++ int nr_threads; /* number of processing threads */ ++ struct list_head threads_list; /* processing threads */ ++ ++ struct list_head lists_list_entry; ++}; ++ ++/* ++ * Used to execute cmd's in order of arrival, honoring SCSI task attributes ++ */ ++struct scst_order_data { ++ /* ++ * Protected by sn_lock, except expected_sn, which is protected by ++ * itself. Curr_sn must have the same size as expected_sn to ++ * overflow simultaneously. ++ */ ++ int def_cmd_count; ++ spinlock_t sn_lock; ++ unsigned int expected_sn; ++ unsigned int curr_sn; ++ int hq_cmd_count; ++ struct list_head deferred_cmd_list; ++ struct list_head skipped_sn_list; ++ ++ /* ++ * Set if the prev cmd was ORDERED. Size and, hence, alignment must ++ * allow unprotected modifications independently to the neighbour fields. ++ */ ++ unsigned long prev_cmd_ordered; ++ ++ int num_free_sn_slots; /* if it's <0, then all slots are busy */ ++ atomic_t *cur_sn_slot; ++ atomic_t sn_slots[15]; ++}; ++ ++/* ++ * SCST command, analog of I_T_L_Q nexus or task ++ */ ++struct scst_cmd { ++ /* List entry for below *_cmd_threads */ ++ struct list_head cmd_list_entry; ++ ++ /* Pointer to lists of commands with the lock */ ++ struct scst_cmd_threads *cmd_threads; ++ ++ atomic_t cmd_ref; ++ ++ struct scst_session *sess; /* corresponding session */ ++ ++ atomic_t *cpu_cmd_counter; ++ ++ /* Cmd state, one of SCST_CMD_STATE_* constants */ ++ int state; ++ ++ /************************************************************* ++ ** Cmd's flags ++ *************************************************************/ ++ ++ /* ++ * Set if expected_sn should be incremented, i.e. cmd was sent ++ * for execution ++ */ ++ unsigned int sent_for_exec:1; ++ ++ /* Set if the cmd's action is completed */ ++ unsigned int completed:1; ++ ++ /* Set if we should ignore Unit Attention in scst_check_sense() */ ++ unsigned int ua_ignore:1; ++ ++ /* Set if cmd is being processed in atomic context */ ++ unsigned int atomic:1; ++ ++ /* Set if this command was sent in double UA possible state */ ++ unsigned int double_ua_possible:1; ++ ++ /* Set if this command contains status */ ++ unsigned int is_send_status:1; ++ ++ /* Set if cmd is being retried */ ++ unsigned int retry:1; ++ ++ /* Set if cmd is internally generated */ ++ unsigned int internal:1; ++ ++ /* Set if the device was blocked by scst_check_blocked_dev() */ ++ unsigned int unblock_dev:1; ++ ++ /* Set if this cmd incremented dev->pr_readers_count */ ++ unsigned int dec_pr_readers_count_needed:1; ++ ++ /* Set if scst_dec_on_dev_cmd() call is needed on the cmd's finish */ ++ unsigned int dec_on_dev_needed:1; ++ ++ /* Set if cmd is queued as hw pending */ ++ unsigned int cmd_hw_pending:1; ++ ++ /* ++ * Set, if for this cmd required to not have any IO or FS calls on ++ * memory buffers allocations, at least for READ and WRITE commands. ++ * Needed for cases like file systems mounted over scst_local's ++ * devices. ++ */ ++ unsigned noio_mem_alloc:1; ++ ++ /* ++ * Set if the target driver wants to alloc data buffers on its own. ++ * In this case alloc_data_buf() must be provided in the target driver ++ * template. ++ */ ++ unsigned int tgt_need_alloc_data_buf:1; ++ ++ /* ++ * Set by SCST if the custom data buffer allocation by the target driver ++ * succeeded. ++ */ ++ unsigned int tgt_data_buf_alloced:1; ++ ++ /* Set if custom data buffer allocated by dev handler */ ++ unsigned int dh_data_buf_alloced:1; ++ ++ /* Set if the target driver called scst_set_expected() */ ++ unsigned int expected_values_set:1; ++ ++ /* ++ * Set if the SG buffer was modified by scst_adjust_sg() ++ */ ++ unsigned int sg_buff_modified:1; ++ ++ /* ++ * Set if cmd buffer was vmallocated and copied from more ++ * then one sg chunk ++ */ ++ unsigned int sg_buff_vmallocated:1; ++ ++ /* ++ * Set if scst_cmd_init_stage1_done() called and the target ++ * want that preprocessing_done() will be called ++ */ ++ unsigned int preprocessing_only:1; ++ ++ /* Set if cmd's SN was set */ ++ unsigned int sn_set:1; ++ ++ /* Set if hq_cmd_count was incremented */ ++ unsigned int hq_cmd_inced:1; ++ ++ /* ++ * Set if scst_cmd_init_stage1_done() called and the target wants ++ * that the SN for the cmd won't be assigned until scst_restart_cmd() ++ */ ++ unsigned int set_sn_on_restart_cmd:1; ++ ++ /* Set if the cmd's must not use sgv cache for data buffer */ ++ unsigned int no_sgv:1; ++ ++ /* ++ * Set if target driver may need to call dma_sync_sg() or similar ++ * function before transferring cmd' data to the target device ++ * via DMA. ++ */ ++ unsigned int may_need_dma_sync:1; ++ ++ /* Set if the cmd was done or aborted out of its SN */ ++ unsigned int out_of_sn:1; ++ ++ /* Set if increment expected_sn in cmd->scst_cmd_done() */ ++ unsigned int inc_expected_sn_on_done:1; ++ ++ /* Set if tgt_sn field is valid */ ++ unsigned int tgt_sn_set:1; ++ ++ /* Set if any direction residual is possible */ ++ unsigned int resid_possible:1; ++ ++ /* Set if cmd is done */ ++ unsigned int done:1; ++ ++ /* ++ * Set if cmd is finished. Used under sess_list_lock to sync ++ * between scst_finish_cmd() and scst_abort_cmd() ++ */ ++ unsigned int finished:1; ++ ++ /* ++ * Set if scst_check_local_events() can be called more than once. Set by ++ * scst_pre_check_local_events(). ++ */ ++ unsigned int check_local_events_once_done:1; ++ ++#ifdef CONFIG_SCST_DEBUG_TM ++ /* Set if the cmd was delayed by task management debugging code */ ++ unsigned int tm_dbg_delayed:1; ++ ++ /* Set if the cmd must be ignored by task management debugging code */ ++ unsigned int tm_dbg_immut:1; ++#endif ++ ++ /**************************************************************/ ++ ++ /* cmd's async flags */ ++ unsigned long cmd_flags; ++ ++ /* Keeps status of cmd's status/data delivery to remote initiator */ ++ int delivery_status; ++ ++ struct scst_tgt_template *tgtt; /* to save extra dereferences */ ++ struct scst_tgt *tgt; /* to save extra dereferences */ ++ struct scst_device *dev; /* to save extra dereferences */ ++ ++ /* corresponding I_T_L device for this cmd */ ++ struct scst_tgt_dev *tgt_dev; ++ ++ struct scst_order_data *cur_order_data; /* to save extra dereferences */ ++ ++ uint64_t lun; /* LUN for this cmd */ ++ ++ unsigned long start_time; ++ ++ /* List entry for tgt_dev's SN related lists */ ++ struct list_head sn_cmd_list_entry; ++ ++ /* Cmd's serial number, used to execute cmd's in order of arrival */ ++ unsigned int sn; ++ ++ /* The corresponding sn_slot in tgt_dev->sn_slots */ ++ atomic_t *sn_slot; ++ ++ /* List entry for sess's sess_cmd_list */ ++ struct list_head sess_cmd_list_entry; ++ ++ /* ++ * Used to found the cmd by scst_find_cmd_by_tag(). Set by the ++ * target driver on the cmd's initialization time ++ */ ++ uint64_t tag; ++ ++ uint32_t tgt_sn; /* SN set by target driver (for TM purposes) */ ++ ++ uint8_t *cdb; /* Pointer on CDB. Points on cdb_buf for small CDBs. */ ++ unsigned short cdb_len; ++ uint8_t cdb_buf[SCST_MAX_CDB_SIZE]; ++ ++ enum scst_cdb_flags op_flags; ++ const char *op_name; ++ ++ enum scst_cmd_queue_type queue_type; ++ ++ int timeout; /* CDB execution timeout in seconds */ ++ int retries; /* Amount of retries that will be done by SCSI mid-level */ ++ ++ /* SCSI data direction, one of SCST_DATA_* constants */ ++ scst_data_direction data_direction; ++ ++ /* Remote initiator supplied values, if any */ ++ scst_data_direction expected_data_direction; ++ int expected_transfer_len; ++ int expected_out_transfer_len; /* for bidi writes */ ++ ++ /* ++ * Cmd data length. Could be different from bufflen for commands like ++ * VERIFY, which transfer different amount of data (if any), than ++ * processed. ++ */ ++ int data_len; ++ ++ /* Completion routine */ ++ void (*scst_cmd_done) (struct scst_cmd *cmd, int next_state, ++ enum scst_exec_context pref_context); ++ ++ struct sgv_pool_obj *sgv; /* sgv object */ ++ int bufflen; /* cmd buffer length */ ++ struct scatterlist *sg; /* cmd data buffer SG vector */ ++ int sg_cnt; /* SG segments count */ ++ ++ /* ++ * Response data length in data buffer. Must not be set ++ * directly, use scst_set_resp_data_len() for that. ++ */ ++ int resp_data_len; ++ ++ /* ++ * Response data length adjusted on residual, i.e. ++ * min(expected_len, resp_len), if expected len set. ++ */ ++ int adjusted_resp_data_len; ++ ++ /* ++ * Data length to write, i.e. transfer from the initiator. Might be ++ * different from (out_)bufflen, if the initiator asked too big or too ++ * small expected(_out_)transfer_len. ++ */ ++ int write_len; ++ ++ /* ++ * Write sg and sg_cnt to point out either on sg/sg_cnt, or on ++ * out_sg/out_sg_cnt. ++ */ ++ struct scatterlist **write_sg; ++ int *write_sg_cnt; ++ ++ /* scst_get_sg_buf_[first,next]() support */ ++ struct scatterlist *get_sg_buf_cur_sg_entry; ++ int get_sg_buf_entry_num; ++ ++ /* Bidirectional transfers support */ ++ int out_bufflen; /* WRITE buffer length */ ++ struct sgv_pool_obj *out_sgv; /* WRITE sgv object */ ++ struct scatterlist *out_sg; /* WRITE data buffer SG vector */ ++ int out_sg_cnt; /* WRITE SG segments count */ ++ ++ /* ++ * Used if both target driver and dev handler request own memory ++ * allocation. In other cases, both are equal to sg and sg_cnt ++ * correspondingly. ++ * ++ * If target driver requests own memory allocations, it MUST use ++ * functions scst_cmd_get_tgt_sg*() to get sg and sg_cnt! Otherwise, ++ * it may use functions scst_cmd_get_sg*(). ++ */ ++ struct scatterlist *tgt_sg; ++ int tgt_sg_cnt; ++ struct scatterlist *tgt_out_sg; /* bidirectional */ ++ int tgt_out_sg_cnt; /* bidirectional */ ++ ++ /* ++ * The status fields in case of errors must be set using ++ * scst_set_cmd_error_status()! ++ */ ++ uint8_t status; /* status byte from target device */ ++ uint8_t msg_status; /* return status from host adapter itself */ ++ uint8_t host_status; /* set by low-level driver to indicate status */ ++ uint8_t driver_status; /* set by mid-level */ ++ ++ uint8_t *sense; /* pointer to sense buffer */ ++ unsigned short sense_valid_len; /* length of valid sense data */ ++ unsigned short sense_buflen; /* length of the sense buffer, if any */ ++ ++ /* Start time when cmd was sent to rdy_to_xfer() or xmit_response() */ ++ unsigned long hw_pending_start; ++ ++ /* Used for storage of target driver private stuff */ ++ void *tgt_priv; ++ ++ /* Used for storage of dev handler private stuff */ ++ void *dh_priv; ++ ++ /* Used to restore sg if it was modified by scst_adjust_sg() */ ++ struct scatterlist *orig_sg; ++ int *p_orig_sg_cnt; ++ int orig_sg_cnt, orig_sg_entry, orig_entry_len; ++ ++ /* Used to retry commands in case of double UA */ ++ int dbl_ua_orig_resp_data_len, dbl_ua_orig_data_direction; ++ ++ /* ++ * List of the corresponding mgmt cmds, if any. Protected by ++ * sess_list_lock. ++ */ ++ struct list_head mgmt_cmd_list; ++ ++ /* List entry for dev's blocked_cmd_list */ ++ struct list_head blocked_cmd_list_entry; ++ ++ /* Counter of the corresponding SCST_PR_ABORT_ALL TM commands */ ++ struct scst_pr_abort_all_pending_mgmt_cmds_counter *pr_abort_counter; ++ ++ struct scst_cmd *orig_cmd; /* Used to issue REQUEST SENSE */ ++ ++#ifdef CONFIG_SCST_MEASURE_LATENCY ++ /* ++ * Must be the last to allow to work with drivers who don't know ++ * about this config time option. ++ */ ++ uint64_t start, curr_start, parse_time, alloc_buf_time; ++ uint64_t restart_waiting_time, rdy_to_xfer_time; ++ uint64_t pre_exec_time, exec_time, dev_done_time; ++ uint64_t xmit_time, tgt_on_free_time, dev_on_free_time; ++#endif ++}; ++ ++/* ++ * Parameters for SCST management commands ++ */ ++struct scst_rx_mgmt_params { ++ int fn; ++ uint64_t tag; ++ const uint8_t *lun; ++ int lun_len; ++ uint32_t cmd_sn; ++ int atomic; ++ void *tgt_priv; ++ unsigned char tag_set; ++ unsigned char lun_set; ++ unsigned char cmd_sn_set; ++}; ++ ++/* ++ * A stub structure to link an management command and affected regular commands ++ */ ++struct scst_mgmt_cmd_stub { ++ struct scst_mgmt_cmd *mcmd; ++ ++ /* List entry in cmd->mgmt_cmd_list */ ++ struct list_head cmd_mgmt_cmd_list_entry; ++ ++ /* Set if the cmd was counted in mcmd->cmd_done_wait_count */ ++ unsigned int done_counted:1; ++ ++ /* Set if the cmd was counted in mcmd->cmd_finish_wait_count */ ++ unsigned int finish_counted:1; ++}; ++ ++/* ++ * SCST task management structure ++ */ ++struct scst_mgmt_cmd { ++ /* List entry for *_mgmt_cmd_list */ ++ struct list_head mgmt_cmd_list_entry; ++ ++ struct scst_session *sess; ++ ++ atomic_t *cpu_cmd_counter; ++ ++ /* Mgmt cmd state, one of SCST_MCMD_STATE_* constants */ ++ int state; ++ ++ int fn; /* task management function */ ++ ++ /* Set if device(s) should be unblocked after mcmd's finish */ ++ unsigned int needs_unblocking:1; ++ unsigned int lun_set:1; /* set, if lun field is valid */ ++ unsigned int cmd_sn_set:1; /* set, if cmd_sn field is valid */ ++ ++ /* ++ * Number of commands to finish before sending response, ++ * protected by scst_mcmd_lock ++ */ ++ int cmd_finish_wait_count; ++ ++ /* ++ * Number of commands to complete (done) before resetting reservation, ++ * protected by scst_mcmd_lock ++ */ ++ int cmd_done_wait_count; ++ ++ /* Number of completed commands, protected by scst_mcmd_lock */ ++ int completed_cmd_count; ++ ++ uint64_t lun; /* LUN for this mgmt cmd */ ++ /* or (and for iSCSI) */ ++ uint64_t tag; /* tag of the corresponding cmd */ ++ ++ uint32_t cmd_sn; /* affected command's highest SN */ ++ ++ /* corresponding cmd (to be aborted, found by tag) */ ++ struct scst_cmd *cmd_to_abort; ++ ++ /* corresponding device for this mgmt cmd (found by lun) */ ++ struct scst_tgt_dev *mcmd_tgt_dev; ++ ++ /* completion status, one of the SCST_MGMT_STATUS_* constants */ ++ int status; ++ ++ /* Used for storage of target driver private stuff or origin PR cmd */ ++ union { ++ void *tgt_priv; ++ struct scst_cmd *origin_pr_cmd; ++ }; ++}; ++ ++/* ++ * Persistent reservations registrant ++ */ ++struct scst_dev_registrant { ++ uint8_t *transport_id; ++ uint16_t rel_tgt_id; ++ __be64 key; ++ ++ /* tgt_dev (I_T nexus) for this registrant, if any */ ++ struct scst_tgt_dev *tgt_dev; ++ ++ /* List entry for dev_registrants_list */ ++ struct list_head dev_registrants_list_entry; ++ ++ /* 2 auxiliary fields used to rollback changes for errors, etc. */ ++ struct list_head aux_list_entry; ++ __be64 rollback_key; ++}; ++ ++/* ++ * SCST device ++ */ ++struct scst_device { ++ unsigned short type; /* SCSI type of the device */ ++ ++ /************************************************************* ++ ** Dev's flags. Updates serialized by dev_lock or suspended ++ ** activity ++ *************************************************************/ ++ ++ /* Set if dev is RESERVED */ ++ unsigned short dev_reserved:1; ++ ++ /* Set if double reset UA is possible */ ++ unsigned short dev_double_ua_possible:1; ++ ++ /* If set, dev is read only */ ++ unsigned short rd_only:1; ++ ++ /* Set, if a strictly serialized cmd is waiting blocked */ ++ unsigned short strictly_serialized_cmd_waiting:1; ++ ++ /* ++ * Set, if this device is being unregistered. Useful to let sysfs ++ * attributes know when they should exit immediatelly to prevent ++ * possible deadlocks with their device unregistration waiting for ++ * their kobj last put. ++ */ ++ unsigned short dev_unregistering:1; ++ ++ /**************************************************************/ ++ ++ /************************************************************* ++ ** Dev's control mode page related values. Updates serialized ++ ** by scst_block_dev(). Modified independently to the above and ++ ** below fields, hence the alignment. ++ *************************************************************/ ++ ++ unsigned int queue_alg:4 __attribute__((aligned(sizeof(long)))); ++ unsigned int tst:3; ++ unsigned int tas:1; ++ unsigned int swp:1; ++ unsigned int d_sense:1; ++ ++ /* ++ * Set if device implements own ordered commands management. If not set ++ * and queue_alg is SCST_CONTR_MODE_QUEUE_ALG_RESTRICTED_REORDER, ++ * expected_sn will be incremented only after commands finished. ++ */ ++ unsigned int has_own_order_mgmt:1; ++ ++ /**************************************************************/ ++ ++ /* How many cmds alive on this dev */ ++ atomic_t dev_cmd_count; ++ ++ spinlock_t dev_lock; /* device lock */ ++ ++ /* ++ * How many times device was blocked for new cmds execution. ++ * Protected by dev_lock. ++ */ ++ int block_count; ++ ++ /* ++ * How many there are "on_dev" commands, i.e. ones who passed ++ * scst_check_blocked_dev(). Protected by dev_lock. ++ */ ++ int on_dev_cmd_count; ++ ++ /* ++ * How many threads are checking commands for PR allowance. ++ * Protected by dev_lock. ++ */ ++ int pr_readers_count; ++ ++ /* ++ * Set if dev is persistently reserved. Protected by dev_pr_mutex. ++ * Modified independently to the above field, hence the alignment. ++ */ ++ unsigned int pr_is_set:1 __attribute__((aligned(sizeof(long)))); ++ ++ /* ++ * Set if there is a thread changing or going to change PR state(s). ++ * Protected by dev_pr_mutex. ++ */ ++ unsigned int pr_writer_active:1; ++ ++ struct scst_dev_type *handler; /* corresponding dev handler */ ++ ++ /* Used for storage of dev handler private stuff */ ++ void *dh_priv; ++ ++ /* Corresponding real SCSI device, could be NULL for virtual devices */ ++ struct scsi_device *scsi_dev; ++ ++ /* List of commands with lock, if dedicated threads are used */ ++ struct scst_cmd_threads dev_cmd_threads; ++ ++ /* Memory limits for this device */ ++ struct scst_mem_lim dev_mem_lim; ++ ++ /************************************************************* ++ ** Persistent reservation fields. Protected by dev_pr_mutex. ++ *************************************************************/ ++ ++ /* ++ * True if persist through power loss is activated. Modified ++ * independently to the above field, hence the alignment. ++ */ ++ unsigned short pr_aptpl:1 __attribute__((aligned(sizeof(long)))); ++ ++ /* Persistent reservation type */ ++ uint8_t pr_type; ++ ++ /* Persistent reservation scope */ ++ uint8_t pr_scope; ++ ++ /* Mutex to protect PR operations */ ++ struct mutex dev_pr_mutex; ++ ++ /* Persistent reservation generation value */ ++ uint32_t pr_generation; ++ ++ /* Reference to registrant - persistent reservation holder */ ++ struct scst_dev_registrant *pr_holder; ++ ++ /* List of dev's registrants */ ++ struct list_head dev_registrants_list; ++ ++ /* ++ * Count of connected tgt_devs from transports, which don't support ++ * PRs, i.e. don't have get_initiator_port_transport_id(). Protected ++ * by scst_mutex. ++ */ ++ int not_pr_supporting_tgt_devs_num; ++ ++ struct scst_order_data dev_order_data; ++ ++ /* Persist through power loss files */ ++ char *pr_file_name; ++ char *pr_file_name1; ++ ++ /**************************************************************/ ++ ++ /* List of blocked commands, protected by dev_lock. */ ++ struct list_head blocked_cmd_list; ++ ++ /* A list entry used during TM, protected by scst_mutex */ ++ struct list_head tm_dev_list_entry; ++ ++ int virt_id; /* virtual device internal ID */ ++ ++ /* Pointer to virtual device name, for convenience only */ ++ char *virt_name; ++ ++ struct list_head dev_list_entry; /* list entry in global devices list */ ++ ++ /* ++ * List of tgt_dev's, one per session, protected by scst_mutex or ++ * dev_lock for reads and both for writes ++ */ ++ struct list_head dev_tgt_dev_list; ++ ++ /* List of acg_dev's, one per acg, protected by scst_mutex */ ++ struct list_head dev_acg_dev_list; ++ ++ /* Number of threads in the device's threads pools */ ++ int threads_num; ++ ++ /* Threads pool type of the device. Valid only if threads_num > 0. */ ++ enum scst_dev_type_threads_pool_type threads_pool_type; ++ ++ /* sysfs release completion */ ++ struct completion *dev_kobj_release_cmpl; ++ ++ struct kobject dev_kobj; /* kobject for this struct */ ++ struct kobject *dev_exp_kobj; /* exported groups */ ++ ++ /* Export number in the dev's sysfs list. Protected by scst_mutex */ ++ int dev_exported_lun_num; ++}; ++ ++/* ++ * Used to store threads local tgt_dev specific data ++ */ ++struct scst_thr_data_hdr { ++ /* List entry in tgt_dev->thr_data_list */ ++ struct list_head thr_data_list_entry; ++ struct task_struct *owner_thr; /* the owner thread */ ++ atomic_t ref; ++ /* Function that will be called on the tgt_dev destruction */ ++ void (*free_fn) (struct scst_thr_data_hdr *data); ++}; ++ ++/* ++ * Used to clearly dispose async io_context ++ */ ++struct scst_async_io_context_keeper { ++ struct kref aic_keeper_kref; ++ bool aic_ready; ++ struct io_context *aic; ++ struct task_struct *aic_keeper_thr; ++ wait_queue_head_t aic_keeper_waitQ; ++}; ++ ++/* ++ * Used to store per-session specific device information, analog of ++ * SCSI I_T_L nexus. ++ */ ++struct scst_tgt_dev { ++ /* List entry in sess->sess_tgt_dev_list */ ++ struct list_head sess_tgt_dev_list_entry; ++ ++ struct scst_device *dev; /* to save extra dereferences */ ++ uint64_t lun; /* to save extra dereferences */ ++ ++ gfp_t gfp_mask; ++ struct sgv_pool *pool; ++ int max_sg_cnt; ++ ++ /* ++ * Tgt_dev's async flags. Modified independently to the neighbour ++ * fields. ++ */ ++ unsigned long tgt_dev_flags; ++ ++ /* Used for storage of dev handler private stuff */ ++ void *dh_priv; ++ ++ /* How many cmds alive on this dev in this session */ ++ atomic_t tgt_dev_cmd_count; ++ ++ struct scst_order_data *curr_order_data; ++ struct scst_order_data tgt_dev_order_data; ++ ++ /* List of scst_thr_data_hdr and lock */ ++ spinlock_t thr_data_lock; ++ struct list_head thr_data_list; ++ ++ /* Pointer to lists of commands with the lock */ ++ struct scst_cmd_threads *active_cmd_threads; ++ ++ /* Union to save some CPU cache footprint */ ++ union { ++ struct { ++ /* Copy to save fast path dereference */ ++ struct io_context *async_io_context; ++ ++ struct scst_async_io_context_keeper *aic_keeper; ++ }; ++ ++ /* Lists of commands with lock, if dedicated threads are used */ ++ struct scst_cmd_threads tgt_dev_cmd_threads; ++ }; ++ ++ spinlock_t tgt_dev_lock; /* per-session device lock */ ++ ++ /* List of UA's for this device, protected by tgt_dev_lock */ ++ struct list_head UA_list; ++ ++ struct scst_session *sess; /* corresponding session */ ++ struct scst_acg_dev *acg_dev; /* corresponding acg_dev */ ++ ++ /* Reference to registrant to find quicker */ ++ struct scst_dev_registrant *registrant; ++ ++ /* List entry in dev->dev_tgt_dev_list */ ++ struct list_head dev_tgt_dev_list_entry; ++ ++ /* Internal tmp list entry */ ++ struct list_head extra_tgt_dev_list_entry; ++ ++ /* Set if INQUIRY DATA HAS CHANGED UA is needed */ ++ unsigned int inq_changed_ua_needed:1; ++ ++ /* ++ * Stored Unit Attention sense and its length for possible ++ * subsequent REQUEST SENSE. Both protected by tgt_dev_lock. ++ */ ++ unsigned short tgt_dev_valid_sense_len; ++ uint8_t tgt_dev_sense[SCST_SENSE_BUFFERSIZE]; ++ ++ /* sysfs release completion */ ++ struct completion *tgt_dev_kobj_release_cmpl; ++ ++ struct kobject tgt_dev_kobj; /* kobject for this struct */ ++ ++#ifdef CONFIG_SCST_MEASURE_LATENCY ++ /* ++ * Must be the last to allow to work with drivers who don't know ++ * about this config time option. ++ * ++ * Protected by sess->lat_lock. ++ */ ++ uint64_t scst_time, tgt_time, dev_time; ++ unsigned int processed_cmds; ++ struct scst_ext_latency_stat dev_latency_stat[SCST_LATENCY_STATS_NUM]; ++#endif ++}; ++ ++/* ++ * Used to store ACG-specific device information, like LUN ++ */ ++struct scst_acg_dev { ++ struct scst_device *dev; /* corresponding device */ ++ ++ uint64_t lun; /* device's LUN in this acg */ ++ ++ /* If set, the corresponding LU is read only */ ++ unsigned int rd_only:1; ++ ++ struct scst_acg *acg; /* parent acg */ ++ ++ /* List entry in dev->dev_acg_dev_list */ ++ struct list_head dev_acg_dev_list_entry; ++ ++ /* List entry in acg->acg_dev_list */ ++ struct list_head acg_dev_list_entry; ++ ++ /* kobject for this structure */ ++ struct kobject acg_dev_kobj; ++ ++ /* sysfs release completion */ ++ struct completion *acg_dev_kobj_release_cmpl; ++ ++ /* Name of the link to the corresponding LUN */ ++ char acg_dev_link_name[20]; ++}; ++ ++/* ++ * ACG - access control group. Used to store group related ++ * control information. ++ */ ++struct scst_acg { ++ /* Owner target */ ++ struct scst_tgt *tgt; ++ ++ /* List of acg_dev's in this acg, protected by scst_mutex */ ++ struct list_head acg_dev_list; ++ ++ /* List of attached sessions, protected by scst_mutex */ ++ struct list_head acg_sess_list; ++ ++ /* List of attached acn's, protected by scst_mutex */ ++ struct list_head acn_list; ++ ++ /* List entry in acg_lists */ ++ struct list_head acg_list_entry; ++ ++ /* Name of this acg */ ++ const char *acg_name; ++ ++ /* Type of I/O initiators grouping */ ++ int acg_io_grouping_type; ++ ++ /* CPU affinity for threads in this ACG */ ++ cpumask_t acg_cpu_mask; ++ ++ unsigned int tgt_acg:1; ++ ++ /* sysfs release completion */ ++ struct completion *acg_kobj_release_cmpl; ++ ++ /* kobject for this structure */ ++ struct kobject acg_kobj; ++ ++ struct kobject *luns_kobj; ++ struct kobject *initiators_kobj; ++ ++ enum scst_lun_addr_method addr_method; ++}; ++ ++/* ++ * ACN - access control name. Used to store names, by which ++ * incoming sessions will be assigned to appropriate ACG. ++ */ ++struct scst_acn { ++ struct scst_acg *acg; /* owner ACG */ ++ ++ const char *name; /* initiator's name */ ++ ++ /* List entry in acg->acn_list */ ++ struct list_head acn_list_entry; ++ ++ /* sysfs file attributes */ ++ struct kobj_attribute *acn_attr; ++}; ++ ++/** ++ * struct scst_dev_group - A group of SCST devices (struct scst_device). ++ * ++ * Each device is member of zero or one device groups. With each device group ++ * there are zero or more target groups associated. ++ */ ++struct scst_dev_group { ++ char *name; ++ struct list_head entry; ++ struct list_head dev_list; ++ struct list_head tg_list; ++ struct kobject kobj; ++ struct kobject *dev_kobj; ++ struct kobject *tg_kobj; ++}; ++ ++/** ++ * struct scst_dg_dev - A node in scst_dev_group.dev_list. ++ */ ++struct scst_dg_dev { ++ struct list_head entry; ++ struct scst_device *dev; ++}; ++ ++/** ++ * struct scst_target_group - A group of SCSI targets (struct scst_tgt). ++ * ++ * Such a group is either a primary target port group or a secondary ++ * port group. See also SPC-4 for more information. ++ */ ++struct scst_target_group { ++ struct scst_dev_group *dg; ++ char *name; ++ uint16_t group_id; ++ enum scst_tg_state state; ++ bool preferred; ++ struct list_head entry; ++ struct list_head tgt_list; ++ struct kobject kobj; ++}; ++ ++/** ++ * struct scst_tg_tgt - A node in scst_target_group.tgt_list. ++ * ++ * Such a node can either represent a local storage target (struct scst_tgt) ++ * or a storage target on another system running SCST. In the former case tgt ++ * != NULL and rel_tgt_id is ignored. In the latter case tgt == NULL and ++ * rel_tgt_id is relevant. ++ */ ++struct scst_tg_tgt { ++ struct list_head entry; ++ struct scst_target_group *tg; ++ struct kobject kobj; ++ struct scst_tgt *tgt; ++ char *name; ++ uint16_t rel_tgt_id; ++}; ++ ++/* ++ * Used to store per-session UNIT ATTENTIONs ++ */ ++struct scst_tgt_dev_UA { ++ /* List entry in tgt_dev->UA_list */ ++ struct list_head UA_list_entry; ++ ++ /* Set if UA is global for session */ ++ unsigned short global_UA:1; ++ ++ /* Unit Attention valid sense len */ ++ unsigned short UA_valid_sense_len; ++ /* Unit Attention sense buf */ ++ uint8_t UA_sense_buffer[SCST_SENSE_BUFFERSIZE]; ++}; ++ ++/* Used to deliver AENs */ ++struct scst_aen { ++ int event_fn; /* AEN fn */ ++ ++ struct scst_session *sess; /* corresponding session */ ++ __be64 lun; /* corresponding LUN in SCSI form */ ++ ++ union { ++ /* SCSI AEN data */ ++ struct { ++ int aen_sense_len; ++ uint8_t aen_sense[SCST_STANDARD_SENSE_LEN]; ++ }; ++ }; ++ ++ /* Keeps status of AEN's delivery to remote initiator */ ++ int delivery_status; ++}; ++ ++#ifndef smp_mb__after_set_bit ++/* There is no smp_mb__after_set_bit() in the kernel */ ++#define smp_mb__after_set_bit() smp_mb() ++#endif ++ ++/* ++ * Registers target template. ++ * Returns 0 on success or appropriate error code otherwise. ++ */ ++int __scst_register_target_template(struct scst_tgt_template *vtt, ++ const char *version); ++static inline int scst_register_target_template(struct scst_tgt_template *vtt) ++{ ++ return __scst_register_target_template(vtt, SCST_INTERFACE_VERSION); ++} ++ ++/* ++ * Registers target template, non-GPL version. ++ * Returns 0 on success or appropriate error code otherwise. ++ * ++ * Note: *vtt must be static! ++ */ ++int __scst_register_target_template_non_gpl(struct scst_tgt_template *vtt, ++ const char *version); ++static inline int scst_register_target_template_non_gpl( ++ struct scst_tgt_template *vtt) ++{ ++ return __scst_register_target_template_non_gpl(vtt, ++ SCST_INTERFACE_VERSION); ++} ++ ++void scst_unregister_target_template(struct scst_tgt_template *vtt); ++ ++struct scst_tgt *scst_register_target(struct scst_tgt_template *vtt, ++ const char *target_name); ++void scst_unregister_target(struct scst_tgt *tgt); ++ ++struct scst_session *scst_register_session(struct scst_tgt *tgt, int atomic, ++ const char *initiator_name, void *tgt_priv, void *result_fn_data, ++ void (*result_fn) (struct scst_session *sess, void *data, int result)); ++struct scst_session *scst_register_session_non_gpl(struct scst_tgt *tgt, ++ const char *initiator_name, void *tgt_priv); ++void scst_unregister_session(struct scst_session *sess, int wait, ++ void (*unreg_done_fn) (struct scst_session *sess)); ++void scst_unregister_session_non_gpl(struct scst_session *sess); ++ ++int __scst_register_dev_driver(struct scst_dev_type *dev_type, ++ const char *version); ++static inline int scst_register_dev_driver(struct scst_dev_type *dev_type) ++{ ++ return __scst_register_dev_driver(dev_type, SCST_INTERFACE_VERSION); ++} ++void scst_unregister_dev_driver(struct scst_dev_type *dev_type); ++ ++int __scst_register_virtual_dev_driver(struct scst_dev_type *dev_type, ++ const char *version); ++/* ++ * Registers dev handler driver for virtual devices (eg VDISK). ++ * Returns 0 on success or appropriate error code otherwise. ++ */ ++static inline int scst_register_virtual_dev_driver( ++ struct scst_dev_type *dev_type) ++{ ++ return __scst_register_virtual_dev_driver(dev_type, ++ SCST_INTERFACE_VERSION); ++} ++ ++void scst_unregister_virtual_dev_driver(struct scst_dev_type *dev_type); ++ ++bool scst_initiator_has_luns(struct scst_tgt *tgt, const char *initiator_name); ++ ++struct scst_cmd *scst_rx_cmd(struct scst_session *sess, ++ const uint8_t *lun, int lun_len, const uint8_t *cdb, ++ unsigned int cdb_len, int atomic); ++void scst_cmd_init_done(struct scst_cmd *cmd, ++ enum scst_exec_context pref_context); ++ ++/* ++ * Notifies SCST that the driver finished the first stage of the command ++ * initialization, and the command is ready for execution, but after ++ * SCST done the command's preprocessing preprocessing_done() function ++ * should be called. The second argument sets preferred command execution ++ * context. See SCST_CONTEXT_* constants for details. ++ * ++ * See comment for scst_cmd_init_done() for the serialization requirements. ++ */ ++static inline void scst_cmd_init_stage1_done(struct scst_cmd *cmd, ++ enum scst_exec_context pref_context, int set_sn) ++{ ++ cmd->preprocessing_only = 1; ++ cmd->set_sn_on_restart_cmd = !set_sn; ++ scst_cmd_init_done(cmd, pref_context); ++} ++ ++void scst_restart_cmd(struct scst_cmd *cmd, int status, ++ enum scst_exec_context pref_context); ++ ++void scst_rx_data(struct scst_cmd *cmd, int status, ++ enum scst_exec_context pref_context); ++ ++void scst_tgt_cmd_done(struct scst_cmd *cmd, ++ enum scst_exec_context pref_context); ++ ++int scst_rx_mgmt_fn(struct scst_session *sess, ++ const struct scst_rx_mgmt_params *params); ++ ++/* ++ * Creates new management command using tag and sends it for execution. ++ * Can be used for SCST_ABORT_TASK only. ++ * Must not be called in parallel with scst_unregister_session() for the ++ * same sess. Returns 0 for success, error code otherwise. ++ * ++ * Obsolete in favor of scst_rx_mgmt_fn() ++ */ ++static inline int scst_rx_mgmt_fn_tag(struct scst_session *sess, int fn, ++ uint64_t tag, int atomic, void *tgt_priv) ++{ ++ struct scst_rx_mgmt_params params; ++ ++ BUG_ON(fn != SCST_ABORT_TASK); ++ ++ memset(¶ms, 0, sizeof(params)); ++ params.fn = fn; ++ params.tag = tag; ++ params.tag_set = 1; ++ params.atomic = atomic; ++ params.tgt_priv = tgt_priv; ++ return scst_rx_mgmt_fn(sess, ¶ms); ++} ++ ++/* ++ * Creates new management command using LUN and sends it for execution. ++ * Currently can be used for any fn, except SCST_ABORT_TASK. ++ * Must not be called in parallel with scst_unregister_session() for the ++ * same sess. Returns 0 for success, error code otherwise. ++ * ++ * Obsolete in favor of scst_rx_mgmt_fn() ++ */ ++static inline int scst_rx_mgmt_fn_lun(struct scst_session *sess, int fn, ++ const uint8_t *lun, int lun_len, int atomic, void *tgt_priv) ++{ ++ struct scst_rx_mgmt_params params; ++ ++ BUG_ON(fn == SCST_ABORT_TASK); ++ ++ memset(¶ms, 0, sizeof(params)); ++ params.fn = fn; ++ params.lun = lun; ++ params.lun_len = lun_len; ++ params.lun_set = 1; ++ params.atomic = atomic; ++ params.tgt_priv = tgt_priv; ++ return scst_rx_mgmt_fn(sess, ¶ms); ++} ++ ++int scst_get_cdb_info(struct scst_cmd *cmd); ++ ++int scst_set_cmd_error_status(struct scst_cmd *cmd, int status); ++int scst_set_cmd_error(struct scst_cmd *cmd, int key, int asc, int ascq); ++void scst_set_busy(struct scst_cmd *cmd); ++ ++void scst_check_convert_sense(struct scst_cmd *cmd); ++ ++void scst_set_initial_UA(struct scst_session *sess, int key, int asc, int ascq); ++ ++void scst_capacity_data_changed(struct scst_device *dev); ++ ++struct scst_cmd *scst_find_cmd_by_tag(struct scst_session *sess, uint64_t tag); ++struct scst_cmd *scst_find_cmd(struct scst_session *sess, void *data, ++ int (*cmp_fn) (struct scst_cmd *cmd, ++ void *data)); ++ ++enum dma_data_direction scst_to_dma_dir(int scst_dir); ++enum dma_data_direction scst_to_tgt_dma_dir(int scst_dir); ++ ++/* ++ * Returns true, if cmd's CDB is fully locally handled by SCST and false ++ * otherwise. Dev handlers parse() and dev_done() not called for such commands. ++ */ ++static inline bool scst_is_cmd_fully_local(struct scst_cmd *cmd) ++{ ++ return (cmd->op_flags & SCST_FULLY_LOCAL_CMD) != 0; ++} ++ ++/* ++ * Returns true, if cmd's CDB is locally handled by SCST and ++ * false otherwise. ++ */ ++static inline bool scst_is_cmd_local(struct scst_cmd *cmd) ++{ ++ return (cmd->op_flags & SCST_LOCAL_CMD) != 0; ++} ++ ++/* Returns true, if cmd can deliver UA */ ++static inline bool scst_is_ua_command(struct scst_cmd *cmd) ++{ ++ return (cmd->op_flags & SCST_SKIP_UA) == 0; ++} ++ ++int scst_register_virtual_device(struct scst_dev_type *dev_handler, ++ const char *dev_name); ++void scst_unregister_virtual_device(int id); ++ ++/* ++ * Get/Set functions for tgt's sg_tablesize ++ */ ++static inline int scst_tgt_get_sg_tablesize(struct scst_tgt *tgt) ++{ ++ return tgt->sg_tablesize; ++} ++ ++static inline void scst_tgt_set_sg_tablesize(struct scst_tgt *tgt, int val) ++{ ++ tgt->sg_tablesize = val; ++} ++ ++/* ++ * Get/Set functions for tgt's target private data ++ */ ++static inline void *scst_tgt_get_tgt_priv(struct scst_tgt *tgt) ++{ ++ return tgt->tgt_priv; ++} ++ ++static inline void scst_tgt_set_tgt_priv(struct scst_tgt *tgt, void *val) ++{ ++ tgt->tgt_priv = val; ++} ++ ++void scst_update_hw_pending_start(struct scst_cmd *cmd); ++ ++/* ++ * Get/Set functions for session's target private data ++ */ ++static inline void *scst_sess_get_tgt_priv(struct scst_session *sess) ++{ ++ return sess->tgt_priv; ++} ++ ++static inline void scst_sess_set_tgt_priv(struct scst_session *sess, ++ void *val) ++{ ++ sess->tgt_priv = val; ++} ++ ++uint16_t scst_lookup_tg_id(struct scst_device *dev, struct scst_tgt *tgt); ++bool scst_impl_alua_configured(struct scst_device *dev); ++int scst_tg_get_group_info(void **buf, uint32_t *response_length, ++ struct scst_device *dev, uint8_t data_format); ++ ++/** ++ * Returns TRUE if cmd is being executed in atomic context. ++ * ++ * This function must be used outside of spinlocks and preempt/BH/IRQ ++ * disabled sections, because of the EXTRACHECK in it. ++ */ ++static inline bool scst_cmd_atomic(struct scst_cmd *cmd) ++{ ++ int res = cmd->atomic; ++#ifdef CONFIG_SCST_EXTRACHECKS ++ /* ++ * Checkpatch will complain on the use of in_atomic() below. You ++ * can safely ignore this warning since in_atomic() is used here ++ * only for debugging purposes. ++ */ ++ if (unlikely((in_atomic() || in_interrupt() || irqs_disabled()) && ++ !res)) { ++ printk(KERN_ERR "ERROR: atomic context and non-atomic cmd!\n"); ++ dump_stack(); ++ cmd->atomic = 1; ++ res = 1; ++ } ++#endif ++ return res; ++} ++ ++/* ++ * Returns TRUE if cmd has been preliminary completed, i.e. completed or ++ * aborted. ++ */ ++static inline bool scst_cmd_prelim_completed(struct scst_cmd *cmd) ++{ ++ return cmd->completed || test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags); ++} ++ ++static inline enum scst_exec_context __scst_estimate_context(bool atomic) ++{ ++ if (in_irq()) ++ return SCST_CONTEXT_TASKLET; ++/* ++ * We come here from many non reliable places, like the block layer, and don't ++ * have any reliable way to detect if we called under atomic context or not ++ * (in_atomic() isn't reliable), so let's be safe and disable this section ++ * for now to unconditionally return thread context. ++ */ ++#if 0 ++ else if (irqs_disabled()) ++ return SCST_CONTEXT_THREAD; ++ else if (in_atomic()) ++ return SCST_CONTEXT_DIRECT_ATOMIC; ++ else ++ return atomic ? SCST_CONTEXT_DIRECT : ++ SCST_CONTEXT_DIRECT_ATOMIC; ++#else ++ return SCST_CONTEXT_THREAD; ++#endif ++} ++ ++static inline enum scst_exec_context scst_estimate_context(void) ++{ ++ return __scst_estimate_context(false); ++} ++ ++static inline enum scst_exec_context scst_estimate_context_atomic(void) ++{ ++ return __scst_estimate_context(true); ++} ++ ++/* Returns cmd's CDB */ ++static inline const uint8_t *scst_cmd_get_cdb(struct scst_cmd *cmd) ++{ ++ return cmd->cdb; ++} ++ ++/* Returns cmd's CDB length */ ++static inline unsigned int scst_cmd_get_cdb_len(struct scst_cmd *cmd) ++{ ++ return cmd->cdb_len; ++} ++ ++void scst_cmd_set_ext_cdb(struct scst_cmd *cmd, ++ uint8_t *ext_cdb, unsigned int ext_cdb_len, gfp_t gfp_mask); ++ ++/* Returns cmd's session */ ++static inline struct scst_session *scst_cmd_get_session(struct scst_cmd *cmd) ++{ ++ return cmd->sess; ++} ++ ++/* Returns cmd's response data length */ ++static inline int scst_cmd_get_resp_data_len(struct scst_cmd *cmd) ++{ ++ return cmd->resp_data_len; ++} ++ ++/* Returns cmd's adjusted response data length */ ++static inline int scst_cmd_get_adjusted_resp_data_len(struct scst_cmd *cmd) ++{ ++ return cmd->adjusted_resp_data_len; ++} ++ ++/* Returns if status should be sent for cmd */ ++static inline int scst_cmd_get_is_send_status(struct scst_cmd *cmd) ++{ ++ return cmd->is_send_status; ++} ++ ++/* ++ * Returns pointer to cmd's SG data buffer. ++ * ++ * Usage of this function is not recommended, use scst_get_buf_*() ++ * family of functions instead. ++ */ ++static inline struct scatterlist *scst_cmd_get_sg(struct scst_cmd *cmd) ++{ ++ return cmd->sg; ++} ++ ++/* ++ * Returns cmd's sg_cnt. ++ * ++ * Usage of this function is not recommended, use scst_get_buf_*() ++ * family of functions instead. ++ */ ++static inline int scst_cmd_get_sg_cnt(struct scst_cmd *cmd) ++{ ++ return cmd->sg_cnt; ++} ++ ++/* ++ * Returns cmd's data buffer length. ++ * ++ * In case if you need to iterate over data in the buffer, usage of ++ * this function is not recommended, use scst_get_buf_*() ++ * family of functions instead. ++ */ ++static inline unsigned int scst_cmd_get_bufflen(struct scst_cmd *cmd) ++{ ++ return cmd->bufflen; ++} ++ ++/* ++ * Returns pointer to cmd's bidirectional in (WRITE) SG data buffer. ++ * ++ * Usage of this function is not recommended, use scst_get_out_buf_*() ++ * family of functions instead. ++ */ ++static inline struct scatterlist *scst_cmd_get_out_sg(struct scst_cmd *cmd) ++{ ++ return cmd->out_sg; ++} ++ ++/* ++ * Returns cmd's bidirectional in (WRITE) sg_cnt. ++ * ++ * Usage of this function is not recommended, use scst_get_out_buf_*() ++ * family of functions instead. ++ */ ++static inline int scst_cmd_get_out_sg_cnt(struct scst_cmd *cmd) ++{ ++ return cmd->out_sg_cnt; ++} ++ ++void scst_restore_sg_buff(struct scst_cmd *cmd); ++ ++/* Restores modified sg buffer in the original state, if necessary */ ++static inline void scst_check_restore_sg_buff(struct scst_cmd *cmd) ++{ ++ if (unlikely(cmd->sg_buff_modified)) ++ scst_restore_sg_buff(cmd); ++} ++ ++/* ++ * Returns cmd's bidirectional in (WRITE) data buffer length. ++ * ++ * In case if you need to iterate over data in the buffer, usage of ++ * this function is not recommended, use scst_get_out_buf_*() ++ * family of functions instead. ++ */ ++static inline unsigned int scst_cmd_get_out_bufflen(struct scst_cmd *cmd) ++{ ++ return cmd->out_bufflen; ++} ++ ++/* Returns pointer to cmd's target's SG data buffer */ ++static inline struct scatterlist *scst_cmd_get_tgt_sg(struct scst_cmd *cmd) ++{ ++ return cmd->tgt_sg; ++} ++ ++/* Returns cmd's target's sg_cnt */ ++static inline int scst_cmd_get_tgt_sg_cnt(struct scst_cmd *cmd) ++{ ++ return cmd->tgt_sg_cnt; ++} ++ ++/* Sets cmd's target's SG data buffer */ ++static inline void scst_cmd_set_tgt_sg(struct scst_cmd *cmd, ++ struct scatterlist *sg, int sg_cnt) ++{ ++ cmd->tgt_sg = sg; ++ cmd->tgt_sg_cnt = sg_cnt; ++ cmd->tgt_data_buf_alloced = 1; ++} ++ ++/* Returns pointer to cmd's target's OUT SG data buffer */ ++static inline struct scatterlist *scst_cmd_get_out_tgt_sg(struct scst_cmd *cmd) ++{ ++ return cmd->tgt_out_sg; ++} ++ ++/* Returns cmd's target's OUT sg_cnt */ ++static inline int scst_cmd_get_tgt_out_sg_cnt(struct scst_cmd *cmd) ++{ ++ return cmd->tgt_out_sg_cnt; ++} ++ ++/* Sets cmd's target's OUT SG data buffer */ ++static inline void scst_cmd_set_tgt_out_sg(struct scst_cmd *cmd, ++ struct scatterlist *sg, int sg_cnt) ++{ ++ WARN_ON(!cmd->tgt_data_buf_alloced); ++ ++ cmd->tgt_out_sg = sg; ++ cmd->tgt_out_sg_cnt = sg_cnt; ++} ++ ++/* Returns cmd's data direction */ ++static inline scst_data_direction scst_cmd_get_data_direction( ++ struct scst_cmd *cmd) ++{ ++ return cmd->data_direction; ++} ++ ++/* Returns cmd's write len as well as write SG and sg_cnt */ ++static inline int scst_cmd_get_write_fields(struct scst_cmd *cmd, ++ struct scatterlist **sg, int *sg_cnt) ++{ ++ *sg = *cmd->write_sg; ++ *sg_cnt = *cmd->write_sg_cnt; ++ return cmd->write_len; ++} ++ ++void scst_cmd_set_write_not_received_data_len(struct scst_cmd *cmd, ++ int not_received); ++ ++bool __scst_get_resid(struct scst_cmd *cmd, int *resid, int *bidi_out_resid); ++ ++/* ++ * Returns true if cmd has residual(s) and returns them in the corresponding ++ * parameters(s). ++ */ ++static inline bool scst_get_resid(struct scst_cmd *cmd, ++ int *resid, int *bidi_out_resid) ++{ ++ if (likely(!cmd->resid_possible)) ++ return false; ++ return __scst_get_resid(cmd, resid, bidi_out_resid); ++} ++ ++/* Returns cmd's status byte from host device */ ++static inline uint8_t scst_cmd_get_status(struct scst_cmd *cmd) ++{ ++ return cmd->status; ++} ++ ++/* Returns cmd's status from host adapter itself */ ++static inline uint8_t scst_cmd_get_msg_status(struct scst_cmd *cmd) ++{ ++ return cmd->msg_status; ++} ++ ++/* Returns cmd's status set by low-level driver to indicate its status */ ++static inline uint8_t scst_cmd_get_host_status(struct scst_cmd *cmd) ++{ ++ return cmd->host_status; ++} ++ ++/* Returns cmd's status set by SCSI mid-level */ ++static inline uint8_t scst_cmd_get_driver_status(struct scst_cmd *cmd) ++{ ++ return cmd->driver_status; ++} ++ ++/* Returns pointer to cmd's sense buffer */ ++static inline uint8_t *scst_cmd_get_sense_buffer(struct scst_cmd *cmd) ++{ ++ return cmd->sense; ++} ++ ++/* Returns cmd's valid sense length */ ++static inline int scst_cmd_get_sense_buffer_len(struct scst_cmd *cmd) ++{ ++ return cmd->sense_valid_len; ++} ++ ++/* ++ * Get/Set functions for cmd's queue_type ++ */ ++static inline enum scst_cmd_queue_type scst_cmd_get_queue_type( ++ struct scst_cmd *cmd) ++{ ++ return cmd->queue_type; ++} ++ ++static inline void scst_cmd_set_queue_type(struct scst_cmd *cmd, ++ enum scst_cmd_queue_type queue_type) ++{ ++ cmd->queue_type = queue_type; ++} ++ ++/* ++ * Get/Set functions for cmd's target SN ++ */ ++static inline uint64_t scst_cmd_get_tag(struct scst_cmd *cmd) ++{ ++ return cmd->tag; ++} ++ ++static inline void scst_cmd_set_tag(struct scst_cmd *cmd, uint64_t tag) ++{ ++ cmd->tag = tag; ++} ++ ++/* ++ * Get/Set functions for cmd's target private data. ++ * Variant with *_lock must be used if target driver uses ++ * scst_find_cmd() to avoid race with it, except inside scst_find_cmd()'s ++ * callback, where lock is already taken. ++ */ ++static inline void *scst_cmd_get_tgt_priv(struct scst_cmd *cmd) ++{ ++ return cmd->tgt_priv; ++} ++ ++static inline void scst_cmd_set_tgt_priv(struct scst_cmd *cmd, void *val) ++{ ++ cmd->tgt_priv = val; ++} ++ ++/* ++ * Get/Set functions for tgt_need_alloc_data_buf flag ++ */ ++static inline int scst_cmd_get_tgt_need_alloc_data_buf(struct scst_cmd *cmd) ++{ ++ return cmd->tgt_need_alloc_data_buf; ++} ++ ++static inline void scst_cmd_set_tgt_need_alloc_data_buf(struct scst_cmd *cmd) ++{ ++ cmd->tgt_need_alloc_data_buf = 1; ++} ++ ++/* ++ * Get/Set functions for tgt_data_buf_alloced flag ++ */ ++static inline int scst_cmd_get_tgt_data_buff_alloced(struct scst_cmd *cmd) ++{ ++ return cmd->tgt_data_buf_alloced; ++} ++ ++static inline void scst_cmd_set_tgt_data_buff_alloced(struct scst_cmd *cmd) ++{ ++ cmd->tgt_data_buf_alloced = 1; ++} ++ ++/* ++ * Get/Set functions for dh_data_buf_alloced flag ++ */ ++static inline int scst_cmd_get_dh_data_buff_alloced(struct scst_cmd *cmd) ++{ ++ return cmd->dh_data_buf_alloced; ++} ++ ++static inline void scst_cmd_set_dh_data_buff_alloced(struct scst_cmd *cmd) ++{ ++ cmd->dh_data_buf_alloced = 1; ++} ++ ++/* ++ * Get/Set functions for no_sgv flag ++ */ ++static inline int scst_cmd_get_no_sgv(struct scst_cmd *cmd) ++{ ++ return cmd->no_sgv; ++} ++ ++static inline void scst_cmd_set_no_sgv(struct scst_cmd *cmd) ++{ ++ cmd->no_sgv = 1; ++} ++ ++/* ++ * Get/Set functions for tgt_sn ++ */ ++static inline int scst_cmd_get_tgt_sn(struct scst_cmd *cmd) ++{ ++ BUG_ON(!cmd->tgt_sn_set); ++ return cmd->tgt_sn; ++} ++ ++static inline void scst_cmd_set_tgt_sn(struct scst_cmd *cmd, uint32_t tgt_sn) ++{ ++ cmd->tgt_sn_set = 1; ++ cmd->tgt_sn = tgt_sn; ++} ++ ++/* ++ * Get/Set functions for noio_mem_alloc ++ */ ++static inline bool scst_cmd_get_noio_mem_alloc(struct scst_cmd *cmd) ++{ ++ return cmd->noio_mem_alloc; ++} ++ ++static inline void scst_cmd_set_noio_mem_alloc(struct scst_cmd *cmd) ++{ ++ cmd->noio_mem_alloc = 1; ++} ++ ++/* ++ * Returns 1 if the cmd was aborted, so its status is invalid and no ++ * reply shall be sent to the remote initiator. A target driver should ++ * only clear internal resources, associated with cmd. ++ */ ++static inline int scst_cmd_aborted(struct scst_cmd *cmd) ++{ ++ return test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags) && ++ !test_bit(SCST_CMD_ABORTED_OTHER, &cmd->cmd_flags); ++} ++ ++/* Returns sense data format for cmd's dev */ ++static inline bool scst_get_cmd_dev_d_sense(struct scst_cmd *cmd) ++{ ++ return (cmd->dev != NULL) ? cmd->dev->d_sense : 0; ++} ++ ++/* ++ * Get/Set functions for expected data direction, transfer length ++ * and its validity flag ++ */ ++static inline int scst_cmd_is_expected_set(struct scst_cmd *cmd) ++{ ++ return cmd->expected_values_set; ++} ++ ++static inline scst_data_direction scst_cmd_get_expected_data_direction( ++ struct scst_cmd *cmd) ++{ ++ return cmd->expected_data_direction; ++} ++ ++static inline int scst_cmd_get_expected_transfer_len( ++ struct scst_cmd *cmd) ++{ ++ return cmd->expected_transfer_len; ++} ++ ++static inline int scst_cmd_get_expected_out_transfer_len( ++ struct scst_cmd *cmd) ++{ ++ return cmd->expected_out_transfer_len; ++} ++ ++static inline void scst_cmd_set_expected(struct scst_cmd *cmd, ++ scst_data_direction expected_data_direction, ++ int expected_transfer_len) ++{ ++ cmd->expected_data_direction = expected_data_direction; ++ cmd->expected_transfer_len = expected_transfer_len; ++ cmd->expected_values_set = 1; ++} ++ ++static inline void scst_cmd_set_expected_out_transfer_len(struct scst_cmd *cmd, ++ int expected_out_transfer_len) ++{ ++ WARN_ON(!cmd->expected_values_set); ++ cmd->expected_out_transfer_len = expected_out_transfer_len; ++} ++ ++/* ++ * Get/clear functions for cmd's may_need_dma_sync ++ */ ++static inline int scst_get_may_need_dma_sync(struct scst_cmd *cmd) ++{ ++ return cmd->may_need_dma_sync; ++} ++ ++static inline void scst_clear_may_need_dma_sync(struct scst_cmd *cmd) ++{ ++ cmd->may_need_dma_sync = 0; ++} ++ ++/* ++ * Get/set functions for cmd's delivery_status. It is one of ++ * SCST_CMD_DELIVERY_* constants. It specifies the status of the ++ * command's delivery to initiator. ++ */ ++static inline int scst_get_delivery_status(struct scst_cmd *cmd) ++{ ++ return cmd->delivery_status; ++} ++ ++static inline void scst_set_delivery_status(struct scst_cmd *cmd, ++ int delivery_status) ++{ ++ cmd->delivery_status = delivery_status; ++} ++ ++static inline unsigned int scst_get_active_cmd_count(struct scst_cmd *cmd) ++{ ++ if (likely(cmd->tgt_dev != NULL)) ++ return atomic_read(&cmd->tgt_dev->tgt_dev_cmd_count); ++ else ++ return (unsigned int)-1; ++} ++ ++/* ++ * Get/Set function for mgmt cmd's target private data ++ */ ++static inline void *scst_mgmt_cmd_get_tgt_priv(struct scst_mgmt_cmd *mcmd) ++{ ++ return mcmd->tgt_priv; ++} ++ ++static inline void scst_mgmt_cmd_set_tgt_priv(struct scst_mgmt_cmd *mcmd, ++ void *val) ++{ ++ mcmd->tgt_priv = val; ++} ++ ++/* Returns mgmt cmd's completion status (SCST_MGMT_STATUS_* constants) */ ++static inline int scst_mgmt_cmd_get_status(struct scst_mgmt_cmd *mcmd) ++{ ++ return mcmd->status; ++} ++ ++/* Returns mgmt cmd's TM fn */ ++static inline int scst_mgmt_cmd_get_fn(struct scst_mgmt_cmd *mcmd) ++{ ++ return mcmd->fn; ++} ++ ++/* ++ * Called by dev handler's task_mgmt_fn() to notify SCST core that mcmd ++ * is going to complete asynchronously. ++ */ ++void scst_prepare_async_mcmd(struct scst_mgmt_cmd *mcmd); ++ ++/* ++ * Called by dev handler to notify SCST core that async. mcmd is completed ++ * with status "status". ++ */ ++void scst_async_mcmd_completed(struct scst_mgmt_cmd *mcmd, int status); ++ ++/* Returns AEN's fn */ ++static inline int scst_aen_get_event_fn(struct scst_aen *aen) ++{ ++ return aen->event_fn; ++} ++ ++/* Returns AEN's session */ ++static inline struct scst_session *scst_aen_get_sess(struct scst_aen *aen) ++{ ++ return aen->sess; ++} ++ ++/* Returns AEN's LUN */ ++static inline __be64 scst_aen_get_lun(struct scst_aen *aen) ++{ ++ return aen->lun; ++} ++ ++/* Returns SCSI AEN's sense */ ++static inline const uint8_t *scst_aen_get_sense(struct scst_aen *aen) ++{ ++ return aen->aen_sense; ++} ++ ++/* Returns SCSI AEN's sense length */ ++static inline int scst_aen_get_sense_len(struct scst_aen *aen) ++{ ++ return aen->aen_sense_len; ++} ++ ++/* ++ * Get/set functions for AEN's delivery_status. It is one of ++ * SCST_AEN_RES_* constants. It specifies the status of the ++ * command's delivery to initiator. ++ */ ++static inline int scst_get_aen_delivery_status(struct scst_aen *aen) ++{ ++ return aen->delivery_status; ++} ++ ++static inline void scst_set_aen_delivery_status(struct scst_aen *aen, ++ int status) ++{ ++ aen->delivery_status = status; ++} ++ ++void scst_aen_done(struct scst_aen *aen); ++ ++static inline void sg_clear(struct scatterlist *sg) ++{ ++ memset(sg, 0, sizeof(*sg)); ++#ifdef CONFIG_DEBUG_SG ++ sg->sg_magic = SG_MAGIC; ++#endif ++} ++ ++enum scst_sg_copy_dir { ++ SCST_SG_COPY_FROM_TARGET, ++ SCST_SG_COPY_TO_TARGET ++}; ++ ++void scst_copy_sg(struct scst_cmd *cmd, enum scst_sg_copy_dir copy_dir); ++ ++/* ++ * Functions for access to the commands data (SG) buffer. Should be used ++ * instead of direct access. Returns the buffer length for success, 0 for EOD, ++ * negative error code otherwise. ++ * ++ * Never EVER use this function to process only "the first page" of the buffer. ++ * The first SG entry can be as low as few bytes long. Use scst_get_buf_full() ++ * instead for such cases. ++ * ++ * "Buf" argument returns the mapped buffer ++ * ++ * The "put" function unmaps the buffer. ++ */ ++static inline int __scst_get_buf(struct scst_cmd *cmd, int sg_cnt, ++ uint8_t **buf) ++{ ++ int res = 0; ++ struct scatterlist *sg = cmd->get_sg_buf_cur_sg_entry; ++ ++ if (cmd->get_sg_buf_entry_num >= sg_cnt) { ++ *buf = NULL; ++ goto out; ++ } ++ ++ if (unlikely(sg_is_chain(sg))) ++ sg = sg_chain_ptr(sg); ++ ++ *buf = page_address(sg_page(sg)); ++ *buf += sg->offset; ++ ++ res = sg->length; ++ ++ cmd->get_sg_buf_entry_num++; ++ cmd->get_sg_buf_cur_sg_entry = ++sg; ++ ++out: ++ return res; ++} ++ ++static inline int scst_get_buf_first(struct scst_cmd *cmd, uint8_t **buf) ++{ ++ if (unlikely(cmd->sg == NULL)) { ++ *buf = NULL; ++ return 0; ++ } ++ cmd->get_sg_buf_entry_num = 0; ++ cmd->get_sg_buf_cur_sg_entry = cmd->sg; ++ cmd->may_need_dma_sync = 1; ++ return __scst_get_buf(cmd, cmd->sg_cnt, buf); ++} ++ ++static inline int scst_get_buf_next(struct scst_cmd *cmd, uint8_t **buf) ++{ ++ return __scst_get_buf(cmd, cmd->sg_cnt, buf); ++} ++ ++static inline void scst_put_buf(struct scst_cmd *cmd, void *buf) ++{ ++ /* Nothing to do */ ++} ++ ++static inline int scst_get_out_buf_first(struct scst_cmd *cmd, uint8_t **buf) ++{ ++ if (unlikely(cmd->out_sg == NULL)) { ++ *buf = NULL; ++ return 0; ++ } ++ cmd->get_sg_buf_entry_num = 0; ++ cmd->get_sg_buf_cur_sg_entry = cmd->out_sg; ++ cmd->may_need_dma_sync = 1; ++ return __scst_get_buf(cmd, cmd->out_sg_cnt, buf); ++} ++ ++static inline int scst_get_out_buf_next(struct scst_cmd *cmd, uint8_t **buf) ++{ ++ return __scst_get_buf(cmd, cmd->out_sg_cnt, buf); ++} ++ ++static inline void scst_put_out_buf(struct scst_cmd *cmd, void *buf) ++{ ++ /* Nothing to do */ ++} ++ ++static inline int scst_get_sg_buf_first(struct scst_cmd *cmd, uint8_t **buf, ++ struct scatterlist *sg, int sg_cnt) ++{ ++ if (unlikely(sg == NULL)) { ++ *buf = NULL; ++ return 0; ++ } ++ cmd->get_sg_buf_entry_num = 0; ++ cmd->get_sg_buf_cur_sg_entry = cmd->sg; ++ cmd->may_need_dma_sync = 1; ++ return __scst_get_buf(cmd, sg_cnt, buf); ++} ++ ++static inline int scst_get_sg_buf_next(struct scst_cmd *cmd, uint8_t **buf, ++ struct scatterlist *sg, int sg_cnt) ++{ ++ return __scst_get_buf(cmd, sg_cnt, buf); ++} ++ ++static inline void scst_put_sg_buf(struct scst_cmd *cmd, void *buf, ++ struct scatterlist *sg, int sg_cnt) ++{ ++ /* Nothing to do */ ++} ++ ++/* ++ * Functions for access to the commands data (SG) page. Should be used ++ * instead of direct access. Returns the buffer length for success, 0 for EOD, ++ * negative error code otherwise. ++ * ++ * "Page" argument returns the starting page, "offset" - offset in it. ++ * ++ * The "put" function "puts" the buffer. It should be always be used, because ++ * in future may need to do some additional operations. ++ */ ++static inline int __scst_get_sg_page(struct scst_cmd *cmd, int sg_cnt, ++ struct page **page, int *offset) ++{ ++ int res = 0; ++ struct scatterlist *sg = cmd->get_sg_buf_cur_sg_entry; ++ ++ if (cmd->get_sg_buf_entry_num >= sg_cnt) { ++ *page = NULL; ++ *offset = 0; ++ goto out; ++ } ++ ++ if (unlikely(sg_is_chain(sg))) ++ sg = sg_chain_ptr(sg); ++ ++ *page = sg_page(sg); ++ *offset = sg->offset; ++ res = sg->length; ++ ++ cmd->get_sg_buf_entry_num++; ++ cmd->get_sg_buf_cur_sg_entry = ++sg; ++ ++out: ++ return res; ++} ++ ++static inline int scst_get_sg_page_first(struct scst_cmd *cmd, ++ struct page **page, int *offset) ++{ ++ if (unlikely(cmd->sg == NULL)) { ++ *page = NULL; ++ *offset = 0; ++ return 0; ++ } ++ cmd->get_sg_buf_entry_num = 0; ++ cmd->get_sg_buf_cur_sg_entry = cmd->sg; ++ return __scst_get_sg_page(cmd, cmd->sg_cnt, page, offset); ++} ++ ++static inline int scst_get_sg_page_next(struct scst_cmd *cmd, ++ struct page **page, int *offset) ++{ ++ return __scst_get_sg_page(cmd, cmd->sg_cnt, page, offset); ++} ++ ++static inline void scst_put_sg_page(struct scst_cmd *cmd, ++ struct page *page, int offset) ++{ ++ /* Nothing to do */ ++} ++ ++static inline int scst_get_out_sg_page_first(struct scst_cmd *cmd, ++ struct page **page, int *offset) ++{ ++ if (unlikely(cmd->out_sg == NULL)) { ++ *page = NULL; ++ *offset = 0; ++ return 0; ++ } ++ cmd->get_sg_buf_entry_num = 0; ++ cmd->get_sg_buf_cur_sg_entry = cmd->out_sg; ++ return __scst_get_sg_page(cmd, cmd->out_sg_cnt, page, offset); ++} ++ ++static inline int scst_get_out_sg_page_next(struct scst_cmd *cmd, ++ struct page **page, int *offset) ++{ ++ return __scst_get_sg_page(cmd, cmd->out_sg_cnt, page, offset); ++} ++ ++static inline void scst_put_out_sg_page(struct scst_cmd *cmd, ++ struct page *page, int offset) ++{ ++ /* Nothing to do */ ++} ++ ++/* ++ * Returns approximate higher rounded buffers count that ++ * scst_get_buf_[first|next]() return. ++ */ ++static inline int scst_get_buf_count(struct scst_cmd *cmd) ++{ ++ return (cmd->sg_cnt == 0) ? 1 : cmd->sg_cnt; ++} ++ ++/* ++ * Returns approximate higher rounded buffers count that ++ * scst_get_out_buf_[first|next]() return. ++ */ ++static inline int scst_get_out_buf_count(struct scst_cmd *cmd) ++{ ++ return (cmd->out_sg_cnt == 0) ? 1 : cmd->out_sg_cnt; ++} ++ ++int scst_get_buf_full(struct scst_cmd *cmd, uint8_t **buf); ++void scst_put_buf_full(struct scst_cmd *cmd, uint8_t *buf); ++ ++#ifdef CONFIG_DEBUG_LOCK_ALLOC ++extern struct lockdep_map scst_suspend_dep_map; ++#define scst_assert_activity_suspended() \ ++ WARN_ON(debug_locks && !lock_is_held(&scst_suspend_dep_map)); ++#else ++#define scst_assert_activity_suspended() do { } while (0) ++#endif ++int scst_suspend_activity(bool interruptible); ++void scst_resume_activity(void); ++ ++void scst_process_active_cmd(struct scst_cmd *cmd, bool atomic); ++ ++void scst_post_parse(struct scst_cmd *cmd); ++void scst_post_alloc_data_buf(struct scst_cmd *cmd); ++ ++int scst_check_local_events(struct scst_cmd *cmd); ++ ++static inline int scst_pre_check_local_events(struct scst_cmd *cmd) ++{ ++ int res = scst_check_local_events(cmd); ++ cmd->check_local_events_once_done = 1; ++ return res; ++} ++ ++int scst_set_cmd_abnormal_done_state(struct scst_cmd *cmd); ++ ++struct scst_trace_log { ++ unsigned int val; ++ const char *token; ++}; ++ ++extern struct mutex scst_mutex; ++ ++const struct sysfs_ops *scst_sysfs_get_sysfs_ops(void); ++ ++/* ++ * Returns target driver's root sysfs kobject. ++ * The driver can create own files/directories/links here. ++ */ ++static inline struct kobject *scst_sysfs_get_tgtt_kobj( ++ struct scst_tgt_template *tgtt) ++{ ++ return &tgtt->tgtt_kobj; ++} ++ ++/* ++ * Returns target's root sysfs kobject. ++ * The driver can create own files/directories/links here. ++ */ ++static inline struct kobject *scst_sysfs_get_tgt_kobj( ++ struct scst_tgt *tgt) ++{ ++ return &tgt->tgt_kobj; ++} ++ ++/* ++ * Returns device handler's root sysfs kobject. ++ * The driver can create own files/directories/links here. ++ */ ++static inline struct kobject *scst_sysfs_get_devt_kobj( ++ struct scst_dev_type *devt) ++{ ++ return &devt->devt_kobj; ++} ++ ++/* ++ * Returns device's root sysfs kobject. ++ * The driver can create own files/directories/links here. ++ */ ++static inline struct kobject *scst_sysfs_get_dev_kobj( ++ struct scst_device *dev) ++{ ++ return &dev->dev_kobj; ++} ++ ++/* ++ * Returns session's root sysfs kobject. ++ * The driver can create own files/directories/links here. ++ */ ++static inline struct kobject *scst_sysfs_get_sess_kobj( ++ struct scst_session *sess) ++{ ++ return &sess->sess_kobj; ++} ++ ++/* Returns target name */ ++static inline const char *scst_get_tgt_name(const struct scst_tgt *tgt) ++{ ++ return tgt->tgt_name; ++} ++ ++int scst_alloc_sense(struct scst_cmd *cmd, int atomic); ++int scst_alloc_set_sense(struct scst_cmd *cmd, int atomic, ++ const uint8_t *sense, unsigned int len); ++ ++int scst_set_sense(uint8_t *buffer, int len, bool d_sense, ++ int key, int asc, int ascq); ++ ++bool scst_is_ua_sense(const uint8_t *sense, int len); ++ ++bool scst_analyze_sense(const uint8_t *sense, int len, ++ unsigned int valid_mask, int key, int asc, int ascq); ++ ++unsigned long scst_random(void); ++ ++void scst_set_resp_data_len(struct scst_cmd *cmd, int resp_data_len); ++ ++void scst_cmd_get(struct scst_cmd *cmd); ++void scst_cmd_put(struct scst_cmd *cmd); ++ ++struct scatterlist *scst_alloc(int size, gfp_t gfp_mask, int *count); ++void scst_free(struct scatterlist *sg, int count); ++ ++void scst_add_thr_data(struct scst_tgt_dev *tgt_dev, ++ struct scst_thr_data_hdr *data, ++ void (*free_fn) (struct scst_thr_data_hdr *data)); ++void scst_del_all_thr_data(struct scst_tgt_dev *tgt_dev); ++void scst_dev_del_all_thr_data(struct scst_device *dev); ++struct scst_thr_data_hdr *__scst_find_thr_data(struct scst_tgt_dev *tgt_dev, ++ struct task_struct *tsk); ++ ++/* Finds local to the current thread data. Returns NULL, if they not found. */ ++static inline struct scst_thr_data_hdr *scst_find_thr_data( ++ struct scst_tgt_dev *tgt_dev) ++{ ++ return __scst_find_thr_data(tgt_dev, current); ++} ++ ++/* Increase ref counter for the thread data */ ++static inline void scst_thr_data_get(struct scst_thr_data_hdr *data) ++{ ++ atomic_inc(&data->ref); ++} ++ ++/* Decrease ref counter for the thread data */ ++static inline void scst_thr_data_put(struct scst_thr_data_hdr *data) ++{ ++ if (atomic_dec_and_test(&data->ref)) ++ data->free_fn(data); ++} ++ ++int scst_calc_block_shift(int sector_size); ++int scst_sbc_generic_parse(struct scst_cmd *cmd, ++ int (*get_block_shift)(struct scst_cmd *cmd)); ++int scst_cdrom_generic_parse(struct scst_cmd *cmd, ++ int (*get_block_shift)(struct scst_cmd *cmd)); ++int scst_modisk_generic_parse(struct scst_cmd *cmd, ++ int (*get_block_shift)(struct scst_cmd *cmd)); ++int scst_tape_generic_parse(struct scst_cmd *cmd, ++ int (*get_block_size)(struct scst_cmd *cmd)); ++int scst_changer_generic_parse(struct scst_cmd *cmd, ++ int (*nothing)(struct scst_cmd *cmd)); ++int scst_processor_generic_parse(struct scst_cmd *cmd, ++ int (*nothing)(struct scst_cmd *cmd)); ++int scst_raid_generic_parse(struct scst_cmd *cmd, ++ int (*nothing)(struct scst_cmd *cmd)); ++ ++int scst_block_generic_dev_done(struct scst_cmd *cmd, ++ void (*set_block_shift)(struct scst_cmd *cmd, int block_shift)); ++int scst_tape_generic_dev_done(struct scst_cmd *cmd, ++ void (*set_block_size)(struct scst_cmd *cmd, int block_size)); ++ ++int scst_obtain_device_parameters(struct scst_device *dev); ++ ++void scst_reassign_persistent_sess_states(struct scst_session *new_sess, ++ struct scst_session *old_sess); ++ ++int scst_get_max_lun_commands(struct scst_session *sess, uint64_t lun); ++ ++/* ++ * Has to be put here open coded, because Linux doesn't have equivalent, which ++ * allows exclusive wake ups of threads in LIFO order. We need it to let (yet) ++ * unneeded threads sleep and not pollute CPU cache by their stacks. ++ */ ++static inline void add_wait_queue_exclusive_head(wait_queue_head_t *q, ++ wait_queue_t *wait) ++{ ++ unsigned long flags; ++ ++ wait->flags |= WQ_FLAG_EXCLUSIVE; ++ spin_lock_irqsave(&q->lock, flags); ++ __add_wait_queue(q, wait); ++ spin_unlock_irqrestore(&q->lock, flags); ++} ++ ++/* ++ * Structure to match events to user space and replies on them ++ */ ++struct scst_sysfs_user_info { ++ /* Unique cookie to identify request */ ++ uint32_t info_cookie; ++ ++ /* Entry in the global list */ ++ struct list_head info_list_entry; ++ ++ /* Set if reply from the user space is being executed */ ++ unsigned int info_being_executed:1; ++ ++ /* Set if this info is in the info_list */ ++ unsigned int info_in_list:1; ++ ++ /* Completion to wait on for the request completion */ ++ struct completion info_completion; ++ ++ /* Request completion status and optional data */ ++ int info_status; ++ void *data; ++}; ++ ++int scst_sysfs_user_add_info(struct scst_sysfs_user_info **out_info); ++void scst_sysfs_user_del_info(struct scst_sysfs_user_info *info); ++struct scst_sysfs_user_info *scst_sysfs_user_get_info(uint32_t cookie); ++int scst_wait_info_completion(struct scst_sysfs_user_info *info, ++ unsigned long timeout); ++ ++unsigned int scst_get_setup_id(void); ++ ++/* ++ * Needed to avoid potential circular locking dependency between scst_mutex ++ * and internal sysfs locking (s_active). It could be since most sysfs entries ++ * are created and deleted under scst_mutex AND scst_mutex is taken inside ++ * sysfs functions. So, we push from the sysfs functions all the processing ++ * taking scst_mutex. To avoid deadlock, we return from them with EAGAIN ++ * if processing is taking too long. User space then should poll ++ * last_sysfs_mgmt_res until it returns the result of the processing ++ * (something other than EAGAIN). ++ */ ++struct scst_sysfs_work_item { ++ /* ++ * If true, then last_sysfs_mgmt_res will not be updated. This is ++ * needed to allow read only sysfs monitoring during management actions. ++ * All management actions are supposed to be externally serialized, ++ * so then last_sysfs_mgmt_res automatically serialized too. ++ * Otherwise a monitoring action can overwrite value of simultaneous ++ * management action's last_sysfs_mgmt_res. ++ */ ++ bool read_only_action; ++ ++ struct list_head sysfs_work_list_entry; ++ struct kref sysfs_work_kref; ++ int (*sysfs_work_fn)(struct scst_sysfs_work_item *work); ++ struct completion sysfs_work_done; ++ char *buf; ++ ++ union { ++ struct scst_dev_type *devt; ++ struct scst_tgt_template *tgtt; ++ struct { ++ struct scst_tgt *tgt; ++ struct scst_acg *acg; ++ union { ++ bool is_tgt_kobj; ++ int io_grouping_type; ++ bool enable; ++ cpumask_t cpu_mask; ++ }; ++ }; ++ struct { ++ struct scst_device *dev; ++ int new_threads_num; ++ enum scst_dev_type_threads_pool_type new_threads_pool_type; ++ }; ++ struct scst_session *sess; ++ struct { ++ struct scst_tgt *tgt_r; ++ unsigned long rel_tgt_id; ++ }; ++ struct { ++ struct kobject *kobj; ++ }; ++ }; ++ int work_res; ++ char *res_buf; ++}; ++ ++int scst_alloc_sysfs_work(int (*sysfs_work_fn)(struct scst_sysfs_work_item *), ++ bool read_only_action, struct scst_sysfs_work_item **res_work); ++int scst_sysfs_queue_wait_work(struct scst_sysfs_work_item *work); ++void scst_sysfs_work_get(struct scst_sysfs_work_item *work); ++void scst_sysfs_work_put(struct scst_sysfs_work_item *work); ++ ++char *scst_get_next_lexem(char **token_str); ++void scst_restore_token_str(char *prev_lexem, char *token_str); ++char *scst_get_next_token_str(char **input_str); ++ ++void scst_init_threads(struct scst_cmd_threads *cmd_threads); ++void scst_deinit_threads(struct scst_cmd_threads *cmd_threads); ++ ++void scst_pass_through_cmd_done(void *data, char *sense, int result, int resid); ++int scst_scsi_exec_async(struct scst_cmd *cmd, void *data, ++ void (*done)(void *data, char *sense, int result, int resid)); ++ ++#endif /* __SCST_H */ +diff -uprN orig/linux-3.2/include/scst/scst_const.h linux-3.2/include/scst/scst_const.h +--- orig/linux-3.2/include/scst/scst_const.h ++++ linux-3.2/include/scst/scst_const.h +@@ -0,0 +1,487 @@ ++/* ++ * include/scst_const.h ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * Contains common SCST constants. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#ifndef __SCST_CONST_H ++#define __SCST_CONST_H ++ ++#ifndef GENERATING_UPSTREAM_PATCH ++/* ++ * Include <linux/version.h> only when not converting this header file into ++ * a patch for upstream review because only then the symbol LINUX_VERSION_CODE ++ * is needed. ++ */ ++#include <linux/version.h> ++#endif ++#include <scsi/scsi.h> ++ ++/* ++ * Version numbers, the same as for the kernel. ++ * ++ * Changing it don't forget to change SCST_FIO_REV in scst_vdisk.c ++ * and FIO_REV in usr/fileio/common.h as well. ++ */ ++#define SCST_VERSION(a, b, c, d) (((a) << 24) + ((b) << 16) + ((c) << 8) + d) ++#define SCST_VERSION_CODE SCST_VERSION(2, 2, 0, 0) ++#define SCST_VERSION_STRING_SUFFIX ++#define SCST_VERSION_NAME "2.2.0-pre" ++#define SCST_VERSION_STRING SCST_VERSION_NAME SCST_VERSION_STRING_SUFFIX ++ ++#define SCST_CONST_VERSION "$Revision: 3987 $" ++ ++/*** Shared constants between user and kernel spaces ***/ ++ ++/* Max size of CDB */ ++#define SCST_MAX_CDB_SIZE 16 ++ ++/* Max size of long CDB */ ++#define SCST_MAX_LONG_CDB_SIZE 65536 ++ ++/* Max size of various names */ ++#define SCST_MAX_NAME 50 ++ ++/* Max size of external names, like initiator name */ ++#define SCST_MAX_EXTERNAL_NAME 256 ++ ++/* Max LUN. 2 bits are used for addressing method. */ ++#define SCST_MAX_LUN ((1 << (16-2)) - 1) ++ ++/* ++ * Size of sense sufficient to carry standard sense data. ++ * Warning! It's allocated on stack! ++ */ ++#define SCST_STANDARD_SENSE_LEN 18 ++ ++/* Max size of sense */ ++#define SCST_SENSE_BUFFERSIZE 96 ++ ++/************************************************************* ++ ** Allowed delivery statuses for cmd's delivery_status ++ *************************************************************/ ++ ++#define SCST_CMD_DELIVERY_SUCCESS 0 ++#define SCST_CMD_DELIVERY_FAILED -1 ++#define SCST_CMD_DELIVERY_ABORTED -2 ++ ++/************************************************************* ++ ** Values for task management functions ++ *************************************************************/ ++#define SCST_ABORT_TASK 0 ++#define SCST_ABORT_TASK_SET 1 ++#define SCST_CLEAR_ACA 2 ++#define SCST_CLEAR_TASK_SET 3 ++#define SCST_LUN_RESET 4 ++#define SCST_TARGET_RESET 5 ++ ++/** SCST extensions **/ ++ ++/* ++ * Notifies about I_T nexus loss event in the corresponding session. ++ * Aborts all tasks there, resets the reservation, if any, and sets ++ * up the I_T Nexus loss UA. ++ */ ++#define SCST_NEXUS_LOSS_SESS 6 ++ ++/* Aborts all tasks in the corresponding session */ ++#define SCST_ABORT_ALL_TASKS_SESS 7 ++ ++/* ++ * Notifies about I_T nexus loss event. Aborts all tasks in all sessions ++ * of the tgt, resets the reservations, if any, and sets up the I_T Nexus ++ * loss UA. ++ */ ++#define SCST_NEXUS_LOSS 8 ++ ++/* Aborts all tasks in all sessions of the tgt */ ++#define SCST_ABORT_ALL_TASKS 9 ++ ++/* ++ * Internal TM command issued by SCST in scst_unregister_session(). It is the ++ * same as SCST_NEXUS_LOSS_SESS, except: ++ * - it doesn't call task_mgmt_affected_cmds_done() ++ * - it doesn't call task_mgmt_fn_done() ++ * - it doesn't queue NEXUS LOSS UA. ++ * ++ * Target drivers must NEVER use it!! ++ */ ++#define SCST_UNREG_SESS_TM 10 ++ ++/* ++ * Internal TM command issued by SCST in scst_pr_abort_reg(). It aborts all ++ * tasks from mcmd->origin_pr_cmd->tgt_dev, except mcmd->origin_pr_cmd. ++ * Additionally: ++ * - it signals pr_aborting_cmpl completion when all affected ++ * commands marked as aborted. ++ * - it doesn't call task_mgmt_affected_cmds_done() ++ * - it doesn't call task_mgmt_fn_done() ++ * - it calls mcmd->origin_pr_cmd->scst_cmd_done() when all affected ++ * commands aborted. ++ * ++ * Target drivers must NEVER use it!! ++ */ ++#define SCST_PR_ABORT_ALL 11 ++ ++/************************************************************* ++ ** Values for mgmt cmd's status field. Codes taken from iSCSI ++ *************************************************************/ ++#define SCST_MGMT_STATUS_SUCCESS 0 ++#define SCST_MGMT_STATUS_TASK_NOT_EXIST -1 ++#define SCST_MGMT_STATUS_LUN_NOT_EXIST -2 ++#define SCST_MGMT_STATUS_FN_NOT_SUPPORTED -5 ++#define SCST_MGMT_STATUS_REJECTED -255 ++#define SCST_MGMT_STATUS_FAILED -129 ++ ++/************************************************************* ++ ** SCSI LUN addressing methods. See also SAM-2 and the ++ ** section about eight byte LUNs. ++ *************************************************************/ ++enum scst_lun_addr_method { ++ SCST_LUN_ADDR_METHOD_PERIPHERAL = 0, ++ SCST_LUN_ADDR_METHOD_FLAT = 1, ++ SCST_LUN_ADDR_METHOD_LUN = 2, ++ SCST_LUN_ADDR_METHOD_EXTENDED_LUN = 3, ++}; ++ ++/************************************************************* ++ ** SCSI task attribute queue types ++ *************************************************************/ ++enum scst_cmd_queue_type { ++ SCST_CMD_QUEUE_UNTAGGED = 0, ++ SCST_CMD_QUEUE_SIMPLE, ++ SCST_CMD_QUEUE_ORDERED, ++ SCST_CMD_QUEUE_HEAD_OF_QUEUE, ++ SCST_CMD_QUEUE_ACA ++}; ++ ++/************************************************************* ++ ** CDB flags ++ *************************************************************/ ++enum scst_cdb_flags { ++ SCST_TRANSFER_LEN_TYPE_FIXED = 0x0001, ++ SCST_SMALL_TIMEOUT = 0x0002, ++ SCST_LONG_TIMEOUT = 0x0004, ++ SCST_UNKNOWN_LENGTH = 0x0008, ++ SCST_INFO_VALID = 0x0010, /* must be single bit */ ++ SCST_VERIFY_BYTCHK_MISMATCH_ALLOWED = 0x0020, ++ SCST_IMPLICIT_HQ = 0x0040, ++ SCST_SKIP_UA = 0x0080, ++ SCST_WRITE_MEDIUM = 0x0100, ++ SCST_LOCAL_CMD = 0x0200, ++ SCST_FULLY_LOCAL_CMD = 0x0400, ++ SCST_REG_RESERVE_ALLOWED = 0x0800, ++ SCST_WRITE_EXCL_ALLOWED = 0x1000, ++ SCST_EXCL_ACCESS_ALLOWED = 0x2000, ++#ifdef CONFIG_SCST_TEST_IO_IN_SIRQ ++ SCST_TEST_IO_IN_SIRQ_ALLOWED = 0x4000, ++#endif ++ SCST_SERIALIZED = 0x8000, ++ SCST_STRICTLY_SERIALIZED = 0x10000|SCST_SERIALIZED, ++}; ++ ++/************************************************************* ++ ** Data direction aliases. Changing it don't forget to change ++ ** scst_to_tgt_dma_dir and SCST_DATA_DIR_MAX as well!! ++ *************************************************************/ ++#define SCST_DATA_UNKNOWN 0 ++#define SCST_DATA_WRITE 1 ++#define SCST_DATA_READ 2 ++#define SCST_DATA_BIDI (SCST_DATA_WRITE | SCST_DATA_READ) ++#define SCST_DATA_NONE 4 ++ ++#define SCST_DATA_DIR_MAX (SCST_DATA_NONE+1) ++ ++/************************************************************* ++ ** Default suffix for targets with NULL names ++ *************************************************************/ ++#define SCST_DEFAULT_TGT_NAME_SUFFIX "_target_" ++ ++/************************************************************* ++ ** Sense manipulation and examination ++ *************************************************************/ ++#define SCST_LOAD_SENSE(key_asc_ascq) key_asc_ascq ++ ++#define SCST_SENSE_VALID(sense) ((sense != NULL) && \ ++ ((((const uint8_t *)(sense))[0] & 0x70) == 0x70)) ++ ++#define SCST_NO_SENSE(sense) ((sense != NULL) && \ ++ (((const uint8_t *)(sense))[2] == 0)) ++ ++/************************************************************* ++ ** Sense data for the appropriate errors. Can be used with ++ ** scst_set_cmd_error() ++ *************************************************************/ ++#define scst_sense_no_sense NO_SENSE, 0x00, 0 ++#define scst_sense_hardw_error HARDWARE_ERROR, 0x44, 0 ++#define scst_sense_aborted_command ABORTED_COMMAND, 0x00, 0 ++#define scst_sense_invalid_opcode ILLEGAL_REQUEST, 0x20, 0 ++#define scst_sense_invalid_field_in_cdb ILLEGAL_REQUEST, 0x24, 0 ++#define scst_sense_invalid_field_in_parm_list ILLEGAL_REQUEST, 0x26, 0 ++#define scst_sense_parameter_value_invalid ILLEGAL_REQUEST, 0x26, 2 ++#define scst_sense_invalid_release ILLEGAL_REQUEST, 0x26, 4 ++#define scst_sense_parameter_list_length_invalid \ ++ ILLEGAL_REQUEST, 0x1A, 0 ++#define scst_sense_reset_UA UNIT_ATTENTION, 0x29, 0 ++#define scst_sense_nexus_loss_UA UNIT_ATTENTION, 0x29, 0x7 ++#define scst_sense_saving_params_unsup ILLEGAL_REQUEST, 0x39, 0 ++#define scst_sense_lun_not_supported ILLEGAL_REQUEST, 0x25, 0 ++#define scst_sense_data_protect DATA_PROTECT, 0x00, 0 ++#define scst_sense_miscompare_error MISCOMPARE, 0x1D, 0 ++#define scst_sense_block_out_range_error ILLEGAL_REQUEST, 0x21, 0 ++#define scst_sense_medium_changed_UA UNIT_ATTENTION, 0x28, 0 ++#define scst_sense_read_error MEDIUM_ERROR, 0x11, 0 ++#define scst_sense_write_error MEDIUM_ERROR, 0x03, 0 ++#define scst_sense_not_ready NOT_READY, 0x04, 0x10 ++#define scst_sense_invalid_message ILLEGAL_REQUEST, 0x49, 0 ++#define scst_sense_cleared_by_another_ini_UA UNIT_ATTENTION, 0x2F, 0 ++#define scst_sense_capacity_data_changed UNIT_ATTENTION, 0x2A, 0x9 ++#define scst_sense_reservation_preempted UNIT_ATTENTION, 0x2A, 0x03 ++#define scst_sense_reservation_released UNIT_ATTENTION, 0x2A, 0x04 ++#define scst_sense_registrations_preempted UNIT_ATTENTION, 0x2A, 0x05 ++#define scst_sense_asym_access_state_changed UNIT_ATTENTION, 0x2A, 0x06 ++#define scst_sense_reported_luns_data_changed UNIT_ATTENTION, 0x3F, 0xE ++#define scst_sense_inquery_data_changed UNIT_ATTENTION, 0x3F, 0x3 ++ ++/************************************************************* ++ * SCSI opcodes not listed anywhere else ++ *************************************************************/ ++#define INIT_ELEMENT_STATUS 0x07 ++#define INIT_ELEMENT_STATUS_RANGE 0x37 ++#define PREVENT_ALLOW_MEDIUM 0x1E ++#define REQUEST_VOLUME_ADDRESS 0xB5 ++#define WRITE_VERIFY_16 0x8E ++#define VERIFY_6 0x13 ++#ifndef VERIFY_12 ++#define VERIFY_12 0xAF ++#endif ++#ifndef GENERATING_UPSTREAM_PATCH ++/* ++ * The constants below have been defined in the kernel header <scsi/scsi.h> ++ * and hence are not needed when this header file is included in kernel code. ++ * The definitions below are only used when this header file is included during ++ * compilation of SCST's user space components. ++ */ ++#ifndef READ_16 ++#define READ_16 0x88 ++#endif ++#ifndef WRITE_16 ++#define WRITE_16 0x8a ++#endif ++#ifndef VERIFY_16 ++#define VERIFY_16 0x8f ++#endif ++#ifndef SERVICE_ACTION_IN ++#define SERVICE_ACTION_IN 0x9e ++#endif ++#ifndef SAI_READ_CAPACITY_16 ++/* values for service action in */ ++#define SAI_READ_CAPACITY_16 0x10 ++#endif ++#endif ++#ifndef GENERATING_UPSTREAM_PATCH ++#ifndef REPORT_LUNS ++#define REPORT_LUNS 0xa0 ++#endif ++#endif ++ ++ ++/************************************************************* ++ ** SCSI Architecture Model (SAM) Status codes. Taken from SAM-3 draft ++ ** T10/1561-D Revision 4 Draft dated 7th November 2002. ++ *************************************************************/ ++#define SAM_STAT_GOOD 0x00 ++#define SAM_STAT_CHECK_CONDITION 0x02 ++#define SAM_STAT_CONDITION_MET 0x04 ++#define SAM_STAT_BUSY 0x08 ++#define SAM_STAT_INTERMEDIATE 0x10 ++#define SAM_STAT_INTERMEDIATE_CONDITION_MET 0x14 ++#define SAM_STAT_RESERVATION_CONFLICT 0x18 ++#define SAM_STAT_COMMAND_TERMINATED 0x22 /* obsolete in SAM-3 */ ++#define SAM_STAT_TASK_SET_FULL 0x28 ++#define SAM_STAT_ACA_ACTIVE 0x30 ++#define SAM_STAT_TASK_ABORTED 0x40 ++ ++/************************************************************* ++ ** Control byte field in CDB ++ *************************************************************/ ++#define CONTROL_BYTE_LINK_BIT 0x01 ++#define CONTROL_BYTE_NACA_BIT 0x04 ++ ++/************************************************************* ++ ** Byte 1 in INQUIRY CDB ++ *************************************************************/ ++#define SCST_INQ_EVPD 0x01 ++ ++/************************************************************* ++ ** Byte 3 in Standard INQUIRY data ++ *************************************************************/ ++#define SCST_INQ_BYTE3 3 ++ ++#define SCST_INQ_NORMACA_BIT 0x20 ++ ++/************************************************************* ++ ** TPGS field in byte 5 of the INQUIRY response (SPC-4). ++ *************************************************************/ ++enum { ++ SCST_INQ_TPGS_MODE_IMPLICIT = 0x10, ++ SCST_INQ_TPGS_MODE_EXPLICIT = 0x20, ++}; ++ ++/************************************************************* ++ ** Byte 2 in RESERVE_10 CDB ++ *************************************************************/ ++#define SCST_RES_3RDPTY 0x10 ++#define SCST_RES_LONGID 0x02 ++ ++/************************************************************* ++ ** Values for the control mode page TST field ++ *************************************************************/ ++#define SCST_CONTR_MODE_ONE_TASK_SET 0 ++#define SCST_CONTR_MODE_SEP_TASK_SETS 1 ++ ++/******************************************************************* ++ ** Values for the control mode page QUEUE ALGORITHM MODIFIER field ++ *******************************************************************/ ++#define SCST_CONTR_MODE_QUEUE_ALG_RESTRICTED_REORDER 0 ++#define SCST_CONTR_MODE_QUEUE_ALG_UNRESTRICTED_REORDER 1 ++ ++/************************************************************* ++ ** Values for the control mode page D_SENSE field ++ *************************************************************/ ++#define SCST_CONTR_MODE_FIXED_SENSE 0 ++#define SCST_CONTR_MODE_DESCR_SENSE 1 ++ ++/************************************************************* ++ ** TransportID protocol identifiers ++ *************************************************************/ ++ ++#define SCSI_TRANSPORTID_PROTOCOLID_FCP2 0 ++#define SCSI_TRANSPORTID_PROTOCOLID_SPI5 1 ++#define SCSI_TRANSPORTID_PROTOCOLID_SRP 4 ++#define SCSI_TRANSPORTID_PROTOCOLID_ISCSI 5 ++#define SCSI_TRANSPORTID_PROTOCOLID_SAS 6 ++ ++/** ++ * enum scst_tg_state - SCSI target port group asymmetric access state. ++ * ++ * See also the documentation of the REPORT TARGET PORT GROUPS command in SPC-4. ++ */ ++enum scst_tg_state { ++ SCST_TG_STATE_OPTIMIZED = 0x0, ++ SCST_TG_STATE_NONOPTIMIZED = 0x1, ++ SCST_TG_STATE_STANDBY = 0x2, ++ SCST_TG_STATE_UNAVAILABLE = 0x3, ++ SCST_TG_STATE_LBA_DEPENDENT = 0x4, ++ SCST_TG_STATE_OFFLINE = 0xe, ++ SCST_TG_STATE_TRANSITIONING = 0xf, ++}; ++ ++/** ++ * Target port group preferred bit. ++ * ++ * See also the documentation of the REPORT TARGET PORT GROUPS command in SPC-4. ++ */ ++enum { ++ SCST_TG_PREFERRED = 0x80, ++}; ++ ++/** ++ * enum scst_tg_sup - Supported SCSI target port group states. ++ * ++ * See also the documentation of the REPORT TARGET PORT GROUPS command in SPC-4. ++ */ ++enum scst_tg_sup { ++ SCST_TG_SUP_OPTIMIZED = 0x01, ++ SCST_TG_SUP_NONOPTIMIZED = 0x02, ++ SCST_TG_SUP_STANDBY = 0x04, ++ SCST_TG_SUP_UNAVAILABLE = 0x08, ++ SCST_TG_SUP_LBA_DEPENDENT = 0x10, ++ SCST_TG_SUP_OFFLINE = 0x40, ++ SCST_TG_SUP_TRANSITION = 0x80, ++}; ++ ++/************************************************************* ++ ** Misc SCSI constants ++ *************************************************************/ ++#define SCST_SENSE_ASC_UA_RESET 0x29 ++#define BYTCHK 0x02 ++#define POSITION_LEN_SHORT 20 ++#define POSITION_LEN_LONG 32 ++ ++/************************************************************* ++ ** Various timeouts ++ *************************************************************/ ++#define SCST_DEFAULT_TIMEOUT (60 * HZ) ++ ++#define SCST_GENERIC_CHANGER_TIMEOUT (3 * HZ) ++#define SCST_GENERIC_CHANGER_LONG_TIMEOUT (14000 * HZ) ++ ++#define SCST_GENERIC_PROCESSOR_TIMEOUT (3 * HZ) ++#define SCST_GENERIC_PROCESSOR_LONG_TIMEOUT (14000 * HZ) ++ ++#define SCST_GENERIC_TAPE_SMALL_TIMEOUT (3 * HZ) ++#define SCST_GENERIC_TAPE_REG_TIMEOUT (900 * HZ) ++#define SCST_GENERIC_TAPE_LONG_TIMEOUT (14000 * HZ) ++ ++#define SCST_GENERIC_MODISK_SMALL_TIMEOUT (3 * HZ) ++#define SCST_GENERIC_MODISK_REG_TIMEOUT (900 * HZ) ++#define SCST_GENERIC_MODISK_LONG_TIMEOUT (14000 * HZ) ++ ++#define SCST_GENERIC_DISK_SMALL_TIMEOUT (3 * HZ) ++#define SCST_GENERIC_DISK_REG_TIMEOUT (60 * HZ) ++#define SCST_GENERIC_DISK_LONG_TIMEOUT (3600 * HZ) ++ ++#define SCST_GENERIC_RAID_TIMEOUT (3 * HZ) ++#define SCST_GENERIC_RAID_LONG_TIMEOUT (14000 * HZ) ++ ++#define SCST_GENERIC_CDROM_SMALL_TIMEOUT (3 * HZ) ++#define SCST_GENERIC_CDROM_REG_TIMEOUT (900 * HZ) ++#define SCST_GENERIC_CDROM_LONG_TIMEOUT (14000 * HZ) ++ ++#define SCST_MAX_OTHER_TIMEOUT (14000 * HZ) ++ ++/************************************************************* ++ ** I/O grouping attribute string values. Must match constants ++ ** w/o '_STR' suffix! ++ *************************************************************/ ++#define SCST_IO_GROUPING_AUTO_STR "auto" ++#define SCST_IO_GROUPING_THIS_GROUP_ONLY_STR "this_group_only" ++#define SCST_IO_GROUPING_NEVER_STR "never" ++ ++/************************************************************* ++ ** Threads pool type attribute string values. ++ ** Must match scst_dev_type_threads_pool_type! ++ *************************************************************/ ++#define SCST_THREADS_POOL_PER_INITIATOR_STR "per_initiator" ++#define SCST_THREADS_POOL_SHARED_STR "shared" ++ ++/************************************************************* ++ ** Misc constants ++ *************************************************************/ ++#define SCST_SYSFS_BLOCK_SIZE PAGE_SIZE ++ ++#define SCST_PR_DIR "/var/lib/scst/pr" ++ ++#define TID_COMMON_SIZE 24 ++ ++#define SCST_SYSFS_KEY_MARK "[key]" ++ ++#define SCST_MIN_REL_TGT_ID 1 ++#define SCST_MAX_REL_TGT_ID 65535 ++ ++#endif /* __SCST_CONST_H */ +diff -uprN orig/linux-3.2/drivers/scst/scst_main.c linux-3.2/drivers/scst/scst_main.c +--- orig/linux-3.2/drivers/scst/scst_main.c ++++ linux-3.2/drivers/scst/scst_main.c +@@ -0,0 +1,2229 @@ ++/* ++ * scst_main.c ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/module.h> ++ ++#include <linux/init.h> ++#include <linux/kernel.h> ++#include <linux/errno.h> ++#include <linux/list.h> ++#include <linux/spinlock.h> ++#include <linux/slab.h> ++#include <linux/sched.h> ++#include <linux/unistd.h> ++#include <linux/string.h> ++#include <linux/kthread.h> ++#include <linux/delay.h> ++#include <linux/lockdep.h> ++ ++#include <scst/scst.h> ++#include "scst_priv.h" ++#include "scst_mem.h" ++#include "scst_pres.h" ++ ++#if defined(CONFIG_HIGHMEM4G) || defined(CONFIG_HIGHMEM64G) ++#warning HIGHMEM kernel configurations are fully supported, but not \ ++recommended for performance reasons. Consider changing VMSPLIT \ ++option or use a 64-bit configuration instead. See README file for \ ++details. ++#endif ++ ++/** ++ ** SCST global variables. They are all uninitialized to have their layout in ++ ** memory be exactly as specified. Otherwise compiler puts zero-initialized ++ ** variable separately from nonzero-initialized ones. ++ **/ ++ ++/* ++ * Main SCST mutex. All targets, devices and dev_types management is done ++ * under this mutex. ++ * ++ * It must NOT be used in any works (schedule_work(), etc.), because ++ * otherwise a deadlock (double lock, actually) is possible, e.g., with ++ * scst_user detach_tgt(), which is called under scst_mutex and calls ++ * flush_scheduled_work(). ++ */ ++struct mutex scst_mutex; ++EXPORT_SYMBOL_GPL(scst_mutex); ++ ++/* ++ * Secondary level main mutex, inner for scst_mutex. Needed for ++ * __scst_pr_register_all_tg_pt(), since we can't use scst_mutex there, ++ * because of the circular locking dependency with dev_pr_mutex. ++ */ ++struct mutex scst_mutex2; ++ ++/* Both protected by scst_mutex or scst_mutex2 on read and both on write */ ++struct list_head scst_template_list; ++struct list_head scst_dev_list; ++ ++/* Protected by scst_mutex */ ++struct list_head scst_dev_type_list; ++struct list_head scst_virtual_dev_type_list; ++ ++spinlock_t scst_main_lock; ++ ++static struct kmem_cache *scst_mgmt_cachep; ++mempool_t *scst_mgmt_mempool; ++static struct kmem_cache *scst_mgmt_stub_cachep; ++mempool_t *scst_mgmt_stub_mempool; ++static struct kmem_cache *scst_ua_cachep; ++mempool_t *scst_ua_mempool; ++static struct kmem_cache *scst_sense_cachep; ++mempool_t *scst_sense_mempool; ++static struct kmem_cache *scst_aen_cachep; ++mempool_t *scst_aen_mempool; ++struct kmem_cache *scst_tgtd_cachep; ++struct kmem_cache *scst_sess_cachep; ++struct kmem_cache *scst_acgd_cachep; ++ ++unsigned int scst_setup_id; ++ ++spinlock_t scst_init_lock; ++wait_queue_head_t scst_init_cmd_list_waitQ; ++struct list_head scst_init_cmd_list; ++unsigned int scst_init_poll_cnt; ++ ++struct kmem_cache *scst_cmd_cachep; ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++unsigned long scst_trace_flag; ++#endif ++ ++int scst_max_tasklet_cmd = SCST_DEF_MAX_TASKLET_CMD; ++ ++unsigned long scst_flags; ++ ++struct scst_cmd_threads scst_main_cmd_threads; ++ ++struct scst_percpu_info scst_percpu_infos[NR_CPUS]; ++ ++spinlock_t scst_mcmd_lock; ++struct list_head scst_active_mgmt_cmd_list; ++struct list_head scst_delayed_mgmt_cmd_list; ++wait_queue_head_t scst_mgmt_cmd_list_waitQ; ++ ++wait_queue_head_t scst_mgmt_waitQ; ++spinlock_t scst_mgmt_lock; ++struct list_head scst_sess_init_list; ++struct list_head scst_sess_shut_list; ++ ++wait_queue_head_t scst_dev_cmd_waitQ; ++ ++#ifdef CONFIG_LOCKDEP ++static struct lock_class_key scst_suspend_key; ++struct lockdep_map scst_suspend_dep_map = ++ STATIC_LOCKDEP_MAP_INIT("scst_suspend_activity", &scst_suspend_key); ++#endif ++static struct mutex scst_suspend_mutex; ++/* protected by scst_suspend_mutex */ ++static struct list_head scst_cmd_threads_list; ++ ++int scst_threads; ++static struct task_struct *scst_init_cmd_thread; ++static struct task_struct *scst_mgmt_thread; ++static struct task_struct *scst_mgmt_cmd_thread; ++ ++static int suspend_count; ++ ++static int scst_virt_dev_last_id; /* protected by scst_mutex */ ++ ++cpumask_t default_cpu_mask; ++ ++static unsigned int scst_max_cmd_mem; ++unsigned int scst_max_dev_cmd_mem; ++ ++module_param_named(scst_threads, scst_threads, int, 0); ++MODULE_PARM_DESC(scst_threads, "SCSI target threads count"); ++ ++module_param_named(scst_max_cmd_mem, scst_max_cmd_mem, int, S_IRUGO); ++MODULE_PARM_DESC(scst_max_cmd_mem, "Maximum memory allowed to be consumed by " ++ "all SCSI commands of all devices at any given time in MB"); ++ ++module_param_named(scst_max_dev_cmd_mem, scst_max_dev_cmd_mem, int, S_IRUGO); ++MODULE_PARM_DESC(scst_max_dev_cmd_mem, "Maximum memory allowed to be consumed " ++ "by all SCSI commands of a device at any given time in MB"); ++ ++struct scst_dev_type scst_null_devtype = { ++ .name = "none", ++ .threads_num = -1, ++}; ++ ++static void __scst_resume_activity(void); ++ ++/** ++ * __scst_register_target_template() - register target template. ++ * @vtt: target template ++ * @version: SCST_INTERFACE_VERSION version string to ensure that ++ * SCST core and the target driver use the same version of ++ * the SCST interface ++ * ++ * Description: ++ * Registers a target template and returns 0 on success or appropriate ++ * error code otherwise. ++ * ++ * Target drivers supposed to behave sanely and not call register() ++ * and unregister() randomly simultaneously. ++ */ ++int __scst_register_target_template(struct scst_tgt_template *vtt, ++ const char *version) ++{ ++ int res = 0; ++ struct scst_tgt_template *t; ++ ++ TRACE_ENTRY(); ++ ++ INIT_LIST_HEAD(&vtt->tgt_list); ++ ++ if (strcmp(version, SCST_INTERFACE_VERSION) != 0) { ++ PRINT_ERROR("Incorrect version of target %s", vtt->name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (!vtt->detect) { ++ PRINT_ERROR("Target driver %s must have " ++ "detect() method.", vtt->name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (!vtt->release) { ++ PRINT_ERROR("Target driver %s must have " ++ "release() method.", vtt->name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (!vtt->xmit_response) { ++ PRINT_ERROR("Target driver %s must have " ++ "xmit_response() method.", vtt->name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (vtt->get_initiator_port_transport_id == NULL) ++ PRINT_WARNING("Target driver %s doesn't support Persistent " ++ "Reservations", vtt->name); ++ ++ if (vtt->threads_num < 0) { ++ PRINT_ERROR("Wrong threads_num value %d for " ++ "target \"%s\"", vtt->threads_num, ++ vtt->name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if ((!vtt->enable_target || !vtt->is_target_enabled) && ++ !vtt->enabled_attr_not_needed) ++ PRINT_WARNING("Target driver %s doesn't have enable_target() " ++ "and/or is_target_enabled() method(s). This is unsafe " ++ "and can lead that initiators connected on the " ++ "initialization time can see an unexpected set of " ++ "devices or no devices at all!", vtt->name); ++ ++ if (((vtt->add_target != NULL) && (vtt->del_target == NULL)) || ++ ((vtt->add_target == NULL) && (vtt->del_target != NULL))) { ++ PRINT_ERROR("Target driver %s must either define both " ++ "add_target() and del_target(), or none.", vtt->name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (vtt->rdy_to_xfer == NULL) ++ vtt->rdy_to_xfer_atomic = 1; ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res != 0) ++ goto out; ++ list_for_each_entry(t, &scst_template_list, scst_template_list_entry) { ++ if (strcmp(t->name, vtt->name) == 0) { ++ PRINT_ERROR("Target driver %s already registered", ++ vtt->name); ++ mutex_unlock(&scst_mutex); ++ goto out_unlock; ++ } ++ } ++ mutex_unlock(&scst_mutex); ++ ++ res = scst_tgtt_sysfs_create(vtt); ++ if (res != 0) ++ goto out; ++ ++ mutex_lock(&scst_mutex); ++ mutex_lock(&scst_mutex2); ++ list_add_tail(&vtt->scst_template_list_entry, &scst_template_list); ++ mutex_unlock(&scst_mutex2); ++ mutex_unlock(&scst_mutex); ++ ++ TRACE_DBG("%s", "Calling target driver's detect()"); ++ res = vtt->detect(vtt); ++ TRACE_DBG("Target driver's detect() returned %d", res); ++ if (res < 0) { ++ PRINT_ERROR("%s", "The detect() routine failed"); ++ res = -EINVAL; ++ goto out_del; ++ } ++ ++ PRINT_INFO("Target template %s registered successfully", vtt->name); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_del: ++ scst_tgtt_sysfs_del(vtt); ++ ++ mutex_lock(&scst_mutex); ++ ++ mutex_lock(&scst_mutex2); ++ list_del(&vtt->scst_template_list_entry); ++ mutex_unlock(&scst_mutex2); ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ goto out; ++} ++EXPORT_SYMBOL_GPL(__scst_register_target_template); ++ ++static int scst_check_non_gpl_target_template(struct scst_tgt_template *vtt) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ if (vtt->task_mgmt_affected_cmds_done || vtt->threads_num || ++ vtt->on_hw_pending_cmd_timeout) { ++ PRINT_ERROR("Not allowed functionality in non-GPL version for " ++ "target template %s", vtt->name); ++ res = -EPERM; ++ goto out; ++ } ++ ++ res = 0; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/** ++ * __scst_register_target_template_non_gpl() - register target template, ++ * non-GPL version ++ * @vtt: target template ++ * @version: SCST_INTERFACE_VERSION version string to ensure that ++ * SCST core and the target driver use the same version of ++ * the SCST interface ++ * ++ * Description: ++ * Registers a target template and returns 0 on success or appropriate ++ * error code otherwise. ++ * ++ * Note: *vtt must be static! ++ */ ++int __scst_register_target_template_non_gpl(struct scst_tgt_template *vtt, ++ const char *version) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ res = scst_check_non_gpl_target_template(vtt); ++ if (res != 0) ++ goto out; ++ ++ res = __scst_register_target_template(vtt, version); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL(__scst_register_target_template_non_gpl); ++ ++/** ++ * scst_unregister_target_template() - unregister target template ++ * ++ * Target drivers supposed to behave sanely and not call register() ++ * and unregister() randomly simultaneously. Also it is supposed that ++ * no attempts to create new targets for this vtt will be done in a race ++ * with this function. ++ */ ++void scst_unregister_target_template(struct scst_tgt_template *vtt) ++{ ++ struct scst_tgt *tgt; ++ struct scst_tgt_template *t; ++ int found = 0; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_mutex); ++ ++ list_for_each_entry(t, &scst_template_list, scst_template_list_entry) { ++ if (strcmp(t->name, vtt->name) == 0) { ++ found = 1; ++ break; ++ } ++ } ++ if (!found) { ++ PRINT_ERROR("Target driver %s isn't registered", vtt->name); ++ goto out_err_up; ++ } ++ ++ mutex_lock(&scst_mutex2); ++ list_del(&vtt->scst_template_list_entry); ++ mutex_unlock(&scst_mutex2); ++ ++ /* Wait for outstanding sysfs mgmt calls completed */ ++ while (vtt->tgtt_active_sysfs_works_count > 0) { ++ mutex_unlock(&scst_mutex); ++ msleep(100); ++ mutex_lock(&scst_mutex); ++ } ++ ++restart: ++ list_for_each_entry(tgt, &vtt->tgt_list, tgt_list_entry) { ++ mutex_unlock(&scst_mutex); ++ scst_unregister_target(tgt); ++ mutex_lock(&scst_mutex); ++ goto restart; ++ } ++ ++ mutex_unlock(&scst_mutex); ++ ++ scst_tgtt_sysfs_del(vtt); ++ ++ PRINT_INFO("Target template %s unregistered successfully", vtt->name); ++ ++out: ++ TRACE_EXIT(); ++ return; ++ ++out_err_up: ++ mutex_unlock(&scst_mutex); ++ goto out; ++} ++EXPORT_SYMBOL(scst_unregister_target_template); ++ ++/** ++ * scst_register_target() - register target ++ * ++ * Registers a target for template vtt and returns new target structure on ++ * success or NULL otherwise. ++ */ ++struct scst_tgt *scst_register_target(struct scst_tgt_template *vtt, ++ const char *target_name) ++{ ++ struct scst_tgt *tgt, *t; ++ int rc = 0; ++ ++ TRACE_ENTRY(); ++ ++ rc = scst_alloc_tgt(vtt, &tgt); ++ if (rc != 0) ++ goto out; ++ ++ if (target_name != NULL) { ++ ++ tgt->tgt_name = kstrdup(target_name, GFP_KERNEL); ++ if (tgt->tgt_name == NULL) { ++ PRINT_ERROR("Allocation of tgt name %s failed", ++ target_name); ++ rc = -ENOMEM; ++ goto out_free_tgt; ++ } ++ } else { ++ static int tgt_num; /* protected by scst_mutex */ ++ ++ PRINT_WARNING("Usage of autogenerated SCST target names " ++ "is deprecated and will be removed in one of the next " ++ "versions. It is strongly recommended to update target " ++ "driver %s to use hardware related persistent target " ++ "names instead", vtt->name); ++ ++ tgt->tgt_name = kasprintf(GFP_KERNEL, "%s%s%d", vtt->name, ++ SCST_DEFAULT_TGT_NAME_SUFFIX, tgt_num); ++ if (tgt->tgt_name == NULL) { ++ PRINT_ERROR("Allocation of tgt name failed " ++ "(template name %s)", vtt->name); ++ rc = -ENOMEM; ++ goto out_free_tgt; ++ } ++ tgt_num++; ++ } ++ ++ rc = mutex_lock_interruptible(&scst_mutex); ++ if (rc != 0) ++ goto out_free_tgt; ++ ++ list_for_each_entry(t, &vtt->tgt_list, tgt_list_entry) { ++ if (strcmp(t->tgt_name, tgt->tgt_name) == 0) { ++ PRINT_ERROR("target %s already exists", tgt->tgt_name); ++ rc = -EEXIST; ++ goto out_unlock; ++ } ++ } ++ ++ rc = scst_tgt_sysfs_create(tgt); ++ if (rc < 0) ++ goto out_unlock; ++ ++ tgt->default_acg = scst_alloc_add_acg(tgt, tgt->tgt_name, false); ++ if (tgt->default_acg == NULL) ++ goto out_sysfs_del; ++ ++ mutex_lock(&scst_mutex2); ++ list_add_tail(&tgt->tgt_list_entry, &vtt->tgt_list); ++ mutex_unlock(&scst_mutex2); ++ ++ mutex_unlock(&scst_mutex); ++ ++ PRINT_INFO("Target %s for template %s registered successfully", ++ tgt->tgt_name, vtt->name); ++ ++ TRACE_DBG("tgt %p", tgt); ++ ++out: ++ TRACE_EXIT(); ++ return tgt; ++ ++out_sysfs_del: ++ mutex_unlock(&scst_mutex); ++ scst_tgt_sysfs_del(tgt); ++ goto out_free_tgt; ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ ++out_free_tgt: ++ /* In case of error tgt_name will be freed in scst_free_tgt() */ ++ scst_free_tgt(tgt); ++ tgt = NULL; ++ goto out; ++} ++EXPORT_SYMBOL(scst_register_target); ++ ++static inline int test_sess_list(struct scst_tgt *tgt) ++{ ++ int res; ++ mutex_lock(&scst_mutex); ++ res = list_empty(&tgt->sess_list); ++ mutex_unlock(&scst_mutex); ++ return res; ++} ++ ++/** ++ * scst_unregister_target() - unregister target. ++ * ++ * It is supposed that no attempts to create new sessions for this ++ * target will be done in a race with this function. ++ */ ++void scst_unregister_target(struct scst_tgt *tgt) ++{ ++ struct scst_session *sess; ++ struct scst_tgt_template *vtt = tgt->tgtt; ++ struct scst_acg *acg, *acg_tmp; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("%s", "Calling target driver's release()"); ++ tgt->tgtt->release(tgt); ++ TRACE_DBG("%s", "Target driver's release() returned"); ++ ++ mutex_lock(&scst_mutex); ++again: ++ list_for_each_entry(sess, &tgt->sess_list, sess_list_entry) { ++ if (sess->shut_phase == SCST_SESS_SPH_READY) { ++ /* ++ * Sometimes it's hard for target driver to track all ++ * its sessions (see scst_local, eg), so let's help it. ++ */ ++ mutex_unlock(&scst_mutex); ++ scst_unregister_session(sess, 0, NULL); ++ mutex_lock(&scst_mutex); ++ goto again; ++ } ++ } ++ mutex_unlock(&scst_mutex); ++ ++ TRACE_DBG("%s", "Waiting for sessions shutdown"); ++ wait_event(tgt->unreg_waitQ, test_sess_list(tgt)); ++ TRACE_DBG("%s", "wait_event() returned"); ++ ++ scst_suspend_activity(false); ++ mutex_lock(&scst_mutex); ++ ++ mutex_lock(&scst_mutex2); ++ list_del(&tgt->tgt_list_entry); ++ mutex_unlock(&scst_mutex2); ++ ++ del_timer_sync(&tgt->retry_timer); ++ ++ scst_tg_tgt_remove_by_tgt(tgt); ++ ++ scst_del_free_acg(tgt->default_acg); ++ ++ list_for_each_entry_safe(acg, acg_tmp, &tgt->tgt_acg_list, ++ acg_list_entry) { ++ scst_del_free_acg(acg); ++ } ++ ++ mutex_unlock(&scst_mutex); ++ scst_resume_activity(); ++ ++ scst_tgt_sysfs_del(tgt); ++ ++ PRINT_INFO("Target %s for template %s unregistered successfully", ++ tgt->tgt_name, vtt->name); ++ ++ scst_free_tgt(tgt); ++ ++ TRACE_DBG("Unregistering tgt %p finished", tgt); ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL(scst_unregister_target); ++ ++int scst_get_cmd_counter(void) ++{ ++ int i, res = 0; ++ for (i = 0; i < (int)ARRAY_SIZE(scst_percpu_infos); i++) ++ res += atomic_read(&scst_percpu_infos[i].cpu_cmd_count); ++ return res; ++} ++ ++static int scst_susp_wait(bool interruptible) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ if (interruptible) { ++ res = wait_event_interruptible_timeout(scst_dev_cmd_waitQ, ++ (scst_get_cmd_counter() == 0), ++ SCST_SUSPENDING_TIMEOUT); ++ if (res <= 0) { ++ __scst_resume_activity(); ++ if (res == 0) ++ res = -EBUSY; ++ } else ++ res = 0; ++ } else ++ wait_event(scst_dev_cmd_waitQ, scst_get_cmd_counter() == 0); ++ ++ TRACE_MGMT_DBG("wait_event() returned %d", res); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/** ++ * scst_suspend_activity() - globally suspend any activity ++ * ++ * Description: ++ * Globally suspends any activity and doesn't return, until there are any ++ * active commands (state after SCST_CMD_STATE_INIT). If "interruptible" ++ * is true, it returns after SCST_SUSPENDING_TIMEOUT or if it was interrupted ++ * by a signal with the corresponding error status < 0. If "interruptible" ++ * is false, it will wait virtually forever. On success returns 0. ++ * ++ * New arriving commands stay in the suspended state until ++ * scst_resume_activity() is called. ++ */ ++int scst_suspend_activity(bool interruptible) ++{ ++ int res = 0; ++ bool rep = false; ++ ++ TRACE_ENTRY(); ++ ++ rwlock_acquire_read(&scst_suspend_dep_map, 0, 0, _RET_IP_); ++ ++ if (interruptible) { ++ if (mutex_lock_interruptible(&scst_suspend_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ } else ++ mutex_lock(&scst_suspend_mutex); ++ ++ TRACE_MGMT_DBG("suspend_count %d", suspend_count); ++ suspend_count++; ++ if (suspend_count > 1) ++ goto out_up; ++ ++ set_bit(SCST_FLAG_SUSPENDING, &scst_flags); ++ set_bit(SCST_FLAG_SUSPENDED, &scst_flags); ++ /* ++ * Assignment of SCST_FLAG_SUSPENDING and SCST_FLAG_SUSPENDED must be ++ * ordered with cpu_cmd_count in scst_get(). Otherwise lockless logic in ++ * scst_translate_lun() and scst_mgmt_translate_lun() won't work. ++ */ ++ smp_mb__after_set_bit(); ++ ++ /* ++ * See comment in scst_user.c::dev_user_task_mgmt_fn() for more ++ * information about scst_user behavior. ++ * ++ * ToDo: make the global suspending unneeded (switch to per-device ++ * reference counting? That would mean to switch off from lockless ++ * implementation of scst_translate_lun().. ) ++ */ ++ ++ if (scst_get_cmd_counter() != 0) { ++ PRINT_INFO("Waiting for %d active commands to complete... This " ++ "might take few minutes for disks or few hours for " ++ "tapes, if you use long executed commands, like " ++ "REWIND or FORMAT. In case, if you have a hung user " ++ "space device (i.e. made using scst_user module) not " ++ "responding to any commands, if might take virtually " ++ "forever until the corresponding user space " ++ "program recovers and starts responding or gets " ++ "killed.", scst_get_cmd_counter()); ++ rep = true; ++ ++ lock_contended(&scst_suspend_dep_map, _RET_IP_); ++ } ++ ++ res = scst_susp_wait(interruptible); ++ if (res != 0) ++ goto out_clear; ++ ++ clear_bit(SCST_FLAG_SUSPENDING, &scst_flags); ++ /* See comment about smp_mb() above */ ++ smp_mb__after_clear_bit(); ++ ++ TRACE_MGMT_DBG("Waiting for %d active commands finally to complete", ++ scst_get_cmd_counter()); ++ ++ res = scst_susp_wait(interruptible); ++ if (res != 0) ++ goto out_clear; ++ ++ if (rep) ++ PRINT_INFO("%s", "All active commands completed"); ++ ++out_up: ++ mutex_unlock(&scst_suspend_mutex); ++ ++out: ++ if (res == 0) ++ lock_acquired(&scst_suspend_dep_map, _RET_IP_); ++ else ++ rwlock_release(&scst_suspend_dep_map, 1, _RET_IP_); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_clear: ++ clear_bit(SCST_FLAG_SUSPENDING, &scst_flags); ++ /* See comment about smp_mb() above */ ++ smp_mb__after_clear_bit(); ++ goto out_up; ++} ++EXPORT_SYMBOL_GPL(scst_suspend_activity); ++ ++static void __scst_resume_activity(void) ++{ ++ struct scst_cmd_threads *l; ++ ++ TRACE_ENTRY(); ++ ++ suspend_count--; ++ TRACE_MGMT_DBG("suspend_count %d left", suspend_count); ++ if (suspend_count > 0) ++ goto out; ++ ++ clear_bit(SCST_FLAG_SUSPENDED, &scst_flags); ++ /* ++ * The barrier is needed to make sure all woken up threads see the ++ * cleared flag. Not sure if it's really needed, but let's be safe. ++ */ ++ smp_mb__after_clear_bit(); ++ ++ list_for_each_entry(l, &scst_cmd_threads_list, lists_list_entry) { ++ wake_up_all(&l->cmd_list_waitQ); ++ } ++ wake_up_all(&scst_init_cmd_list_waitQ); ++ ++ spin_lock_irq(&scst_mcmd_lock); ++ if (!list_empty(&scst_delayed_mgmt_cmd_list)) { ++ struct scst_mgmt_cmd *m; ++ m = list_entry(scst_delayed_mgmt_cmd_list.next, typeof(*m), ++ mgmt_cmd_list_entry); ++ TRACE_MGMT_DBG("Moving delayed mgmt cmd %p to head of active " ++ "mgmt cmd list", m); ++ list_move(&m->mgmt_cmd_list_entry, &scst_active_mgmt_cmd_list); ++ } ++ spin_unlock_irq(&scst_mcmd_lock); ++ wake_up_all(&scst_mgmt_cmd_list_waitQ); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ * scst_resume_activity() - globally resume all activities ++ * ++ * Resumes suspended by scst_suspend_activity() activities. ++ */ ++void scst_resume_activity(void) ++{ ++ TRACE_ENTRY(); ++ ++ rwlock_release(&scst_suspend_dep_map, 1, _RET_IP_); ++ ++ mutex_lock(&scst_suspend_mutex); ++ __scst_resume_activity(); ++ mutex_unlock(&scst_suspend_mutex); ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL_GPL(scst_resume_activity); ++ ++static int scst_register_device(struct scsi_device *scsidp) ++{ ++ int res; ++ struct scst_device *dev, *d; ++ ++ TRACE_ENTRY(); ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res != 0) ++ goto out; ++ ++ res = scst_alloc_device(GFP_KERNEL, &dev); ++ if (res != 0) ++ goto out_unlock; ++ ++ dev->type = scsidp->type; ++ ++ dev->virt_name = kasprintf(GFP_KERNEL, "%d:%d:%d:%d", ++ scsidp->host->host_no, ++ scsidp->channel, scsidp->id, scsidp->lun); ++ if (dev->virt_name == NULL) { ++ PRINT_ERROR("%s", "Unable to alloc device name"); ++ res = -ENOMEM; ++ goto out_free_dev; ++ } ++ ++ list_for_each_entry(d, &scst_dev_list, dev_list_entry) { ++ if (strcmp(d->virt_name, dev->virt_name) == 0) { ++ PRINT_ERROR("Device %s already exists", dev->virt_name); ++ res = -EEXIST; ++ goto out_free_dev; ++ } ++ } ++ ++ dev->scsi_dev = scsidp; ++ ++ list_add_tail(&dev->dev_list_entry, &scst_dev_list); ++ ++ mutex_unlock(&scst_mutex); ++ ++ res = scst_dev_sysfs_create(dev); ++ if (res != 0) ++ goto out_del; ++ ++ PRINT_INFO("Attached to scsi%d, channel %d, id %d, lun %d, " ++ "type %d", scsidp->host->host_no, scsidp->channel, ++ scsidp->id, scsidp->lun, scsidp->type); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_del: ++ list_del(&dev->dev_list_entry); ++ ++out_free_dev: ++ scst_free_device(dev); ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ goto out; ++} ++ ++static void scst_unregister_device(struct scsi_device *scsidp) ++{ ++ struct scst_device *d, *dev = NULL; ++ struct scst_acg_dev *acg_dev, *aa; ++ ++ TRACE_ENTRY(); ++ ++ scst_suspend_activity(false); ++ mutex_lock(&scst_mutex); ++ ++ list_for_each_entry(d, &scst_dev_list, dev_list_entry) { ++ if (d->scsi_dev == scsidp) { ++ dev = d; ++ TRACE_DBG("Device %p found", dev); ++ break; ++ } ++ } ++ if (dev == NULL) { ++ PRINT_ERROR("SCST device for SCSI device %d:%d:%d:%d not found", ++ scsidp->host->host_no, scsidp->channel, scsidp->id, ++ scsidp->lun); ++ goto out_unlock; ++ } ++ ++ dev->dev_unregistering = 1; ++ ++ list_del(&dev->dev_list_entry); ++ ++ scst_dg_dev_remove_by_dev(dev); ++ ++ scst_assign_dev_handler(dev, &scst_null_devtype); ++ ++ list_for_each_entry_safe(acg_dev, aa, &dev->dev_acg_dev_list, ++ dev_acg_dev_list_entry) { ++ scst_acg_del_lun(acg_dev->acg, acg_dev->lun, true); ++ } ++ ++ mutex_unlock(&scst_mutex); ++ ++ scst_resume_activity(); ++ ++ scst_dev_sysfs_del(dev); ++ ++ PRINT_INFO("Detached from scsi%d, channel %d, id %d, lun %d, type %d", ++ scsidp->host->host_no, scsidp->channel, scsidp->id, ++ scsidp->lun, scsidp->type); ++ ++ scst_free_device(dev); ++ ++out: ++ TRACE_EXIT(); ++ return; ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ scst_resume_activity(); ++ goto out; ++} ++ ++static int scst_dev_handler_check(struct scst_dev_type *dev_handler) ++{ ++ int res = 0; ++ ++ if (dev_handler->parse == NULL) { ++ PRINT_ERROR("scst dev handler %s must have " ++ "parse() method.", dev_handler->name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (((dev_handler->add_device != NULL) && ++ (dev_handler->del_device == NULL)) || ++ ((dev_handler->add_device == NULL) && ++ (dev_handler->del_device != NULL))) { ++ PRINT_ERROR("Dev handler %s must either define both " ++ "add_device() and del_device(), or none.", ++ dev_handler->name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (dev_handler->alloc_data_buf == NULL) ++ dev_handler->alloc_data_buf_atomic = 1; ++ ++ if (dev_handler->dev_done == NULL) ++ dev_handler->dev_done_atomic = 1; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_check_device_name(const char *dev_name) ++{ ++ int res = 0; ++ ++ if (strchr(dev_name, '/') != NULL) { ++ PRINT_ERROR("Dev name %s contains illegal character '/'", ++ dev_name); ++ res = -EINVAL; ++ } ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/** ++ * scst_register_virtual_device() - register a virtual device. ++ * @dev_handler: the device's device handler ++ * @dev_name: the new device name, NULL-terminated string. Must be uniq ++ * among all virtual devices in the system. ++ * ++ * Registers a virtual device and returns ID assigned to the device on ++ * success, or negative value otherwise ++ */ ++int scst_register_virtual_device(struct scst_dev_type *dev_handler, ++ const char *dev_name) ++{ ++ int res; ++ struct scst_device *dev, *d; ++ bool sysfs_del = false; ++ ++ TRACE_ENTRY(); ++ ++ if (dev_handler == NULL) { ++ PRINT_ERROR("%s: valid device handler must be supplied", ++ __func__); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (dev_name == NULL) { ++ PRINT_ERROR("%s: device name must be non-NULL", __func__); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ res = scst_check_device_name(dev_name); ++ if (res != 0) ++ goto out; ++ ++ res = scst_dev_handler_check(dev_handler); ++ if (res != 0) ++ goto out; ++ ++ res = scst_suspend_activity(true); ++ if (res != 0) ++ goto out; ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res != 0) ++ goto out_resume; ++ ++ res = scst_alloc_device(GFP_KERNEL, &dev); ++ if (res != 0) ++ goto out_unlock; ++ ++ dev->type = dev_handler->type; ++ dev->scsi_dev = NULL; ++ dev->virt_name = kstrdup(dev_name, GFP_KERNEL); ++ if (dev->virt_name == NULL) { ++ PRINT_ERROR("Unable to allocate virt_name for dev %s", ++ dev_name); ++ res = -ENOMEM; ++ goto out_free_dev; ++ } ++ ++ while (1) { ++ dev->virt_id = scst_virt_dev_last_id++; ++ if (dev->virt_id > 0) ++ break; ++ scst_virt_dev_last_id = 1; ++ } ++ ++ res = dev->virt_id; ++ ++ res = scst_pr_init_dev(dev); ++ if (res != 0) ++ goto out_free_dev; ++ ++ /* ++ * We can drop scst_mutex, because we have not yet added the dev in ++ * scst_dev_list, so it "doesn't exist" yet. ++ */ ++ mutex_unlock(&scst_mutex); ++ ++ res = scst_dev_sysfs_create(dev); ++ if (res != 0) ++ goto out_lock_pr_clear_dev; ++ ++ mutex_lock(&scst_mutex); ++ ++ list_for_each_entry(d, &scst_dev_list, dev_list_entry) { ++ if (strcmp(d->virt_name, dev_name) == 0) { ++ PRINT_ERROR("Device %s already exists", dev_name); ++ res = -EEXIST; ++ sysfs_del = true; ++ goto out_pr_clear_dev; ++ } ++ } ++ ++ res = scst_assign_dev_handler(dev, dev_handler); ++ if (res != 0) { ++ sysfs_del = true; ++ goto out_pr_clear_dev; ++ } ++ ++ list_add_tail(&dev->dev_list_entry, &scst_dev_list); ++ ++ mutex_unlock(&scst_mutex); ++ scst_resume_activity(); ++ ++ res = dev->virt_id; ++ ++ PRINT_INFO("Attached to virtual device %s (id %d)", dev_name, res); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_lock_pr_clear_dev: ++ mutex_lock(&scst_mutex); ++ ++out_pr_clear_dev: ++ scst_pr_clear_dev(dev); ++ ++out_free_dev: ++ mutex_unlock(&scst_mutex); ++ if (sysfs_del) ++ scst_dev_sysfs_del(dev); ++ scst_free_device(dev); ++ goto out_resume; ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ ++out_resume: ++ scst_resume_activity(); ++ goto out; ++} ++EXPORT_SYMBOL_GPL(scst_register_virtual_device); ++ ++/** ++ * scst_unregister_virtual_device() - unegister a virtual device. ++ * @id: the device's ID, returned by the registration function ++ */ ++void scst_unregister_virtual_device(int id) ++{ ++ struct scst_device *d, *dev = NULL; ++ struct scst_acg_dev *acg_dev, *aa; ++ ++ TRACE_ENTRY(); ++ ++ scst_suspend_activity(false); ++ mutex_lock(&scst_mutex); ++ ++ list_for_each_entry(d, &scst_dev_list, dev_list_entry) { ++ if (d->virt_id == id) { ++ dev = d; ++ TRACE_DBG("Virtual device %p (id %d) found", dev, id); ++ break; ++ } ++ } ++ if (dev == NULL) { ++ PRINT_ERROR("Virtual device (id %d) not found", id); ++ goto out_unlock; ++ } ++ ++ dev->dev_unregistering = 1; ++ ++ list_del(&dev->dev_list_entry); ++ ++ scst_pr_clear_dev(dev); ++ ++ scst_dg_dev_remove_by_dev(dev); ++ ++ scst_assign_dev_handler(dev, &scst_null_devtype); ++ ++ list_for_each_entry_safe(acg_dev, aa, &dev->dev_acg_dev_list, ++ dev_acg_dev_list_entry) { ++ scst_acg_del_lun(acg_dev->acg, acg_dev->lun, true); ++ } ++ ++ mutex_unlock(&scst_mutex); ++ scst_resume_activity(); ++ ++ scst_dev_sysfs_del(dev); ++ ++ PRINT_INFO("Detached from virtual device %s (id %d)", ++ dev->virt_name, dev->virt_id); ++ ++ scst_free_device(dev); ++ ++out: ++ TRACE_EXIT(); ++ return; ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ scst_resume_activity(); ++ goto out; ++} ++EXPORT_SYMBOL_GPL(scst_unregister_virtual_device); ++ ++/** ++ * __scst_register_dev_driver() - register pass-through dev handler driver ++ * @dev_type: dev handler template ++ * @version: SCST_INTERFACE_VERSION version string to ensure that ++ * SCST core and the dev handler use the same version of ++ * the SCST interface ++ * ++ * Description: ++ * Registers a pass-through dev handler driver. Returns 0 on success ++ * or appropriate error code otherwise. ++ */ ++int __scst_register_dev_driver(struct scst_dev_type *dev_type, ++ const char *version) ++{ ++ int res, exist; ++ struct scst_dev_type *dt; ++ ++ TRACE_ENTRY(); ++ ++ res = -EINVAL; ++ if (strcmp(version, SCST_INTERFACE_VERSION) != 0) { ++ PRINT_ERROR("Incorrect version of dev handler %s", ++ dev_type->name); ++ goto out; ++ } ++ ++ res = scst_dev_handler_check(dev_type); ++ if (res != 0) ++ goto out; ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res != 0) ++ goto out; ++ ++ exist = 0; ++ list_for_each_entry(dt, &scst_dev_type_list, dev_type_list_entry) { ++ if (strcmp(dt->name, dev_type->name) == 0) { ++ PRINT_ERROR("Device type handler \"%s\" already " ++ "exists", dt->name); ++ exist = 1; ++ break; ++ } ++ } ++ if (exist) ++ goto out_unlock; ++ ++ list_add_tail(&dev_type->dev_type_list_entry, &scst_dev_type_list); ++ ++ mutex_unlock(&scst_mutex); ++ ++ res = scst_devt_sysfs_create(dev_type); ++ if (res < 0) ++ goto out; ++ ++ PRINT_INFO("Device handler \"%s\" for type %d registered " ++ "successfully", dev_type->name, dev_type->type); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ goto out; ++} ++EXPORT_SYMBOL_GPL(__scst_register_dev_driver); ++ ++/** ++ * scst_unregister_dev_driver() - unregister pass-through dev handler driver ++ */ ++void scst_unregister_dev_driver(struct scst_dev_type *dev_type) ++{ ++ struct scst_device *dev; ++ struct scst_dev_type *dt; ++ int found = 0; ++ ++ TRACE_ENTRY(); ++ ++ scst_suspend_activity(false); ++ mutex_lock(&scst_mutex); ++ ++ list_for_each_entry(dt, &scst_dev_type_list, dev_type_list_entry) { ++ if (strcmp(dt->name, dev_type->name) == 0) { ++ found = 1; ++ break; ++ } ++ } ++ if (!found) { ++ PRINT_ERROR("Dev handler \"%s\" isn't registered", ++ dev_type->name); ++ goto out_up; ++ } ++ ++ list_for_each_entry(dev, &scst_dev_list, dev_list_entry) { ++ if (dev->handler == dev_type) { ++ scst_assign_dev_handler(dev, &scst_null_devtype); ++ TRACE_DBG("Dev handler removed from device %p", dev); ++ } ++ } ++ ++ list_del(&dev_type->dev_type_list_entry); ++ ++ mutex_unlock(&scst_mutex); ++ scst_resume_activity(); ++ ++ scst_devt_sysfs_del(dev_type); ++ ++ PRINT_INFO("Device handler \"%s\" for type %d unloaded", ++ dev_type->name, dev_type->type); ++ ++out: ++ TRACE_EXIT(); ++ return; ++ ++out_up: ++ mutex_unlock(&scst_mutex); ++ scst_resume_activity(); ++ goto out; ++} ++EXPORT_SYMBOL_GPL(scst_unregister_dev_driver); ++ ++/** ++ * __scst_register_virtual_dev_driver() - register virtual dev handler driver ++ * @dev_type: dev handler template ++ * @version: SCST_INTERFACE_VERSION version string to ensure that ++ * SCST core and the dev handler use the same version of ++ * the SCST interface ++ * ++ * Description: ++ * Registers a virtual dev handler driver. Returns 0 on success or ++ * appropriate error code otherwise. ++ */ ++int __scst_register_virtual_dev_driver(struct scst_dev_type *dev_type, ++ const char *version) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ if (strcmp(version, SCST_INTERFACE_VERSION) != 0) { ++ PRINT_ERROR("Incorrect version of virtual dev handler %s", ++ dev_type->name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ res = scst_dev_handler_check(dev_type); ++ if (res != 0) ++ goto out; ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res != 0) ++ goto out; ++ list_add_tail(&dev_type->dev_type_list_entry, &scst_virtual_dev_type_list); ++ mutex_unlock(&scst_mutex); ++ ++ res = scst_devt_sysfs_create(dev_type); ++ if (res < 0) ++ goto out; ++ ++ if (dev_type->type != -1) { ++ PRINT_INFO("Virtual device handler %s for type %d " ++ "registered successfully", dev_type->name, ++ dev_type->type); ++ } else { ++ PRINT_INFO("Virtual device handler \"%s\" registered " ++ "successfully", dev_type->name); ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL_GPL(__scst_register_virtual_dev_driver); ++ ++/** ++ * scst_unregister_virtual_dev_driver() - unregister virtual dev driver ++ */ ++void scst_unregister_virtual_dev_driver(struct scst_dev_type *dev_type) ++{ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_mutex); ++ ++ /* Disable sysfs mgmt calls (e.g. addition of new devices) */ ++ list_del(&dev_type->dev_type_list_entry); ++ ++ /* Wait for outstanding sysfs mgmt calls completed */ ++ while (dev_type->devt_active_sysfs_works_count > 0) { ++ mutex_unlock(&scst_mutex); ++ msleep(100); ++ mutex_lock(&scst_mutex); ++ } ++ ++ mutex_unlock(&scst_mutex); ++ ++ scst_devt_sysfs_del(dev_type); ++ ++ PRINT_INFO("Device handler \"%s\" unloaded", dev_type->name); ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL_GPL(scst_unregister_virtual_dev_driver); ++ ++/* scst_mutex supposed to be held */ ++int scst_add_threads(struct scst_cmd_threads *cmd_threads, ++ struct scst_device *dev, struct scst_tgt_dev *tgt_dev, int num) ++{ ++ int res = 0, i; ++ struct scst_cmd_thread_t *thr; ++ int n = 0, tgt_dev_num = 0; ++ ++ TRACE_ENTRY(); ++ ++ if (num == 0) { ++ res = 0; ++ goto out; ++ } ++ ++ list_for_each_entry(thr, &cmd_threads->threads_list, thread_list_entry) { ++ n++; ++ } ++ ++ TRACE_DBG("cmd_threads %p, dev %s, tgt_dev %p, num %d, n %d", ++ cmd_threads, dev ? dev->virt_name : NULL, tgt_dev, num, n); ++ ++ if (tgt_dev != NULL) { ++ struct scst_tgt_dev *t; ++ list_for_each_entry(t, &tgt_dev->dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ if (t == tgt_dev) ++ break; ++ tgt_dev_num++; ++ } ++ } ++ ++ for (i = 0; i < num; i++) { ++ thr = kmalloc(sizeof(*thr), GFP_KERNEL); ++ if (!thr) { ++ res = -ENOMEM; ++ PRINT_ERROR("Fail to allocate thr %d", res); ++ goto out_wait; ++ } ++ ++ if (dev != NULL) { ++ thr->cmd_thread = kthread_create(scst_cmd_thread, ++ cmd_threads, "%.13s%d", dev->virt_name, n++); ++ } else if (tgt_dev != NULL) { ++ thr->cmd_thread = kthread_create(scst_cmd_thread, ++ cmd_threads, "%.10s%d_%d", ++ tgt_dev->dev->virt_name, tgt_dev_num, n++); ++ } else ++ thr->cmd_thread = kthread_create(scst_cmd_thread, ++ cmd_threads, "scstd%d", n++); ++ ++ if (IS_ERR(thr->cmd_thread)) { ++ res = PTR_ERR(thr->cmd_thread); ++ PRINT_ERROR("kthread_create() failed: %d", res); ++ kfree(thr); ++ goto out_wait; ++ } ++ ++ if (tgt_dev != NULL) { ++ int rc; ++ /* ++ * sess->acg can be NULL here, if called from ++ * scst_check_reassign_sess()! ++ */ ++ rc = set_cpus_allowed_ptr(thr->cmd_thread, ++ &tgt_dev->acg_dev->acg->acg_cpu_mask); ++ if (rc != 0) ++ PRINT_ERROR("Setting CPU affinity failed: " ++ "%d", rc); ++ } ++ ++ list_add(&thr->thread_list_entry, &cmd_threads->threads_list); ++ cmd_threads->nr_threads++; ++ ++ TRACE_DBG("Added thr %p to threads list (nr_threads %d, n %d)", ++ thr, cmd_threads->nr_threads, n); ++ ++ wake_up_process(thr->cmd_thread); ++ } ++ ++out_wait: ++ if (i > 0 && cmd_threads != &scst_main_cmd_threads) { ++ /* ++ * Wait for io_context gets initialized to avoid possible races ++ * for it from the sharing it tgt_devs. ++ */ ++ while (!*(volatile bool*)&cmd_threads->io_context_ready) { ++ TRACE_DBG("Waiting for io_context for cmd_threads %p " ++ "initialized", cmd_threads); ++ msleep(50); ++ } ++ smp_rmb(); ++ } ++ ++ if (res != 0) ++ scst_del_threads(cmd_threads, i); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* scst_mutex supposed to be held */ ++void scst_del_threads(struct scst_cmd_threads *cmd_threads, int num) ++{ ++ struct scst_cmd_thread_t *ct, *tmp; ++ ++ TRACE_ENTRY(); ++ ++ if (num == 0) ++ goto out; ++ ++ list_for_each_entry_safe_reverse(ct, tmp, &cmd_threads->threads_list, ++ thread_list_entry) { ++ int rc; ++ struct scst_device *dev; ++ ++ rc = kthread_stop(ct->cmd_thread); ++ if (rc != 0 && rc != -EINTR) ++ TRACE_MGMT_DBG("kthread_stop() failed: %d", rc); ++ ++ list_del(&ct->thread_list_entry); ++ ++ list_for_each_entry(dev, &scst_dev_list, dev_list_entry) { ++ struct scst_tgt_dev *tgt_dev; ++ list_for_each_entry(tgt_dev, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ scst_del_thr_data(tgt_dev, ct->cmd_thread); ++ } ++ } ++ ++ kfree(ct); ++ ++ cmd_threads->nr_threads--; ++ ++ --num; ++ if (num == 0) ++ break; ++ } ++ ++ EXTRACHECKS_BUG_ON((cmd_threads->nr_threads == 0) && ++ (cmd_threads->io_context != NULL)); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++void scst_stop_dev_threads(struct scst_device *dev) ++{ ++ struct scst_tgt_dev *tgt_dev; ++ ++ TRACE_ENTRY(); ++ ++ list_for_each_entry(tgt_dev, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ scst_tgt_dev_stop_threads(tgt_dev); ++ } ++ ++ if ((dev->threads_num > 0) && ++ (dev->threads_pool_type == SCST_THREADS_POOL_SHARED)) ++ scst_del_threads(&dev->dev_cmd_threads, -1); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++int scst_create_dev_threads(struct scst_device *dev) ++{ ++ int res = 0; ++ struct scst_tgt_dev *tgt_dev; ++ ++ TRACE_ENTRY(); ++ ++ list_for_each_entry(tgt_dev, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ res = scst_tgt_dev_setup_threads(tgt_dev); ++ if (res != 0) ++ goto out_err; ++ } ++ ++ if ((dev->threads_num > 0) && ++ (dev->threads_pool_type == SCST_THREADS_POOL_SHARED)) { ++ res = scst_add_threads(&dev->dev_cmd_threads, dev, NULL, ++ dev->threads_num); ++ if (res != 0) ++ goto out_err; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_err: ++ scst_stop_dev_threads(dev); ++ goto out; ++} ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++int scst_assign_dev_handler(struct scst_device *dev, ++ struct scst_dev_type *handler) ++{ ++ int res = 0; ++ struct scst_tgt_dev *tgt_dev; ++ LIST_HEAD(attached_tgt_devs); ++ ++ TRACE_ENTRY(); ++ ++ BUG_ON(handler == NULL); ++ ++ if (dev->handler == handler) ++ goto out; ++ ++ if (dev->handler == NULL) ++ goto assign; ++ ++ if (dev->handler->detach_tgt) { ++ list_for_each_entry(tgt_dev, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ TRACE_DBG("Calling dev handler's detach_tgt(%p)", ++ tgt_dev); ++ dev->handler->detach_tgt(tgt_dev); ++ TRACE_DBG("%s", "Dev handler's detach_tgt() returned"); ++ } ++ } ++ ++ /* ++ * devt_dev sysfs must be created AFTER attach() and deleted BEFORE ++ * detach() to avoid calls from sysfs for not yet ready or already dead ++ * objects. ++ */ ++ scst_devt_dev_sysfs_del(dev); ++ ++ if (dev->handler->detach) { ++ TRACE_DBG("%s", "Calling dev handler's detach()"); ++ dev->handler->detach(dev); ++ TRACE_DBG("%s", "Old handler's detach() returned"); ++ } ++ ++ scst_stop_dev_threads(dev); ++ ++assign: ++ dev->handler = handler; ++ ++ if (handler == NULL) ++ goto out; ++ ++ dev->threads_num = handler->threads_num; ++ dev->threads_pool_type = handler->threads_pool_type; ++ ++ if (handler->attach) { ++ TRACE_DBG("Calling new dev handler's attach(%p)", dev); ++ res = handler->attach(dev); ++ TRACE_DBG("New dev handler's attach() returned %d", res); ++ if (res != 0) { ++ PRINT_ERROR("New device handler's %s attach() " ++ "failed: %d", handler->name, res); ++ goto out; ++ } ++ } ++ ++ res = scst_devt_dev_sysfs_create(dev); ++ if (res != 0) ++ goto out_detach; ++ ++ if (handler->attach_tgt) { ++ list_for_each_entry(tgt_dev, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ TRACE_DBG("Calling dev handler's attach_tgt(%p)", ++ tgt_dev); ++ res = handler->attach_tgt(tgt_dev); ++ TRACE_DBG("%s", "Dev handler's attach_tgt() returned"); ++ if (res != 0) { ++ PRINT_ERROR("Device handler's %s attach_tgt() " ++ "failed: %d", handler->name, res); ++ goto out_err_remove_sysfs; ++ } ++ list_add_tail(&tgt_dev->extra_tgt_dev_list_entry, ++ &attached_tgt_devs); ++ } ++ } ++ ++ res = scst_create_dev_threads(dev); ++ if (res != 0) ++ goto out_err_detach_tgt; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_err_detach_tgt: ++ if (handler && handler->detach_tgt) { ++ list_for_each_entry(tgt_dev, &attached_tgt_devs, ++ extra_tgt_dev_list_entry) { ++ TRACE_DBG("Calling handler's detach_tgt(%p)", ++ tgt_dev); ++ handler->detach_tgt(tgt_dev); ++ TRACE_DBG("%s", "Handler's detach_tgt() returned"); ++ } ++ } ++ ++out_err_remove_sysfs: ++ scst_devt_dev_sysfs_del(dev); ++ ++out_detach: ++ if (handler && handler->detach) { ++ TRACE_DBG("%s", "Calling handler's detach()"); ++ handler->detach(dev); ++ TRACE_DBG("%s", "Handler's detach() returned"); ++ } ++ ++ dev->handler = &scst_null_devtype; ++ dev->threads_num = scst_null_devtype.threads_num; ++ dev->threads_pool_type = scst_null_devtype.threads_pool_type; ++ goto out; ++} ++ ++/** ++ * scst_init_threads() - initialize SCST processing threads pool ++ * ++ * Initializes scst_cmd_threads structure ++ */ ++void scst_init_threads(struct scst_cmd_threads *cmd_threads) ++{ ++ TRACE_ENTRY(); ++ ++ spin_lock_init(&cmd_threads->cmd_list_lock); ++ INIT_LIST_HEAD(&cmd_threads->active_cmd_list); ++ init_waitqueue_head(&cmd_threads->cmd_list_waitQ); ++ INIT_LIST_HEAD(&cmd_threads->threads_list); ++ mutex_init(&cmd_threads->io_context_mutex); ++ ++ mutex_lock(&scst_suspend_mutex); ++ list_add_tail(&cmd_threads->lists_list_entry, ++ &scst_cmd_threads_list); ++ mutex_unlock(&scst_suspend_mutex); ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL_GPL(scst_init_threads); ++ ++/** ++ * scst_deinit_threads() - deinitialize SCST processing threads pool ++ * ++ * Deinitializes scst_cmd_threads structure ++ */ ++void scst_deinit_threads(struct scst_cmd_threads *cmd_threads) ++{ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_suspend_mutex); ++ list_del(&cmd_threads->lists_list_entry); ++ mutex_unlock(&scst_suspend_mutex); ++ ++ BUG_ON(cmd_threads->io_context); ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL_GPL(scst_deinit_threads); ++ ++static void scst_stop_global_threads(void) ++{ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_mutex); ++ ++ scst_del_threads(&scst_main_cmd_threads, -1); ++ ++ if (scst_mgmt_cmd_thread) ++ kthread_stop(scst_mgmt_cmd_thread); ++ if (scst_mgmt_thread) ++ kthread_stop(scst_mgmt_thread); ++ if (scst_init_cmd_thread) ++ kthread_stop(scst_init_cmd_thread); ++ ++ mutex_unlock(&scst_mutex); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* It does NOT stop ran threads on error! */ ++static int scst_start_global_threads(int num) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_mutex); ++ ++ res = scst_add_threads(&scst_main_cmd_threads, NULL, NULL, num); ++ if (res < 0) ++ goto out_unlock; ++ ++ scst_init_cmd_thread = kthread_run(scst_init_thread, ++ NULL, "scst_initd"); ++ if (IS_ERR(scst_init_cmd_thread)) { ++ res = PTR_ERR(scst_init_cmd_thread); ++ PRINT_ERROR("kthread_create() for init cmd failed: %d", res); ++ scst_init_cmd_thread = NULL; ++ goto out_unlock; ++ } ++ ++ scst_mgmt_cmd_thread = kthread_run(scst_tm_thread, ++ NULL, "scsi_tm"); ++ if (IS_ERR(scst_mgmt_cmd_thread)) { ++ res = PTR_ERR(scst_mgmt_cmd_thread); ++ PRINT_ERROR("kthread_create() for TM failed: %d", res); ++ scst_mgmt_cmd_thread = NULL; ++ goto out_unlock; ++ } ++ ++ scst_mgmt_thread = kthread_run(scst_global_mgmt_thread, ++ NULL, "scst_mgmtd"); ++ if (IS_ERR(scst_mgmt_thread)) { ++ res = PTR_ERR(scst_mgmt_thread); ++ PRINT_ERROR("kthread_create() for mgmt failed: %d", res); ++ scst_mgmt_thread = NULL; ++ goto out_unlock; ++ } ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/** ++ * scst_get_setup_id() - return SCST setup ID ++ * ++ * Returns SCST setup ID. This ID can be used for multiple ++ * setups with the same configuration. ++ */ ++unsigned int scst_get_setup_id(void) ++{ ++ return scst_setup_id; ++} ++EXPORT_SYMBOL_GPL(scst_get_setup_id); ++ ++static int scst_add(struct device *cdev, struct class_interface *intf) ++{ ++ struct scsi_device *scsidp; ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ scsidp = to_scsi_device(cdev->parent); ++ ++ if ((scsidp->host->hostt->name == NULL) || ++ (strcmp(scsidp->host->hostt->name, SCST_LOCAL_NAME) != 0)) ++ res = scst_register_device(scsidp); ++ ++ TRACE_EXIT(); ++ return res; ++} ++ ++static void scst_remove(struct device *cdev, struct class_interface *intf) ++{ ++ struct scsi_device *scsidp; ++ ++ TRACE_ENTRY(); ++ ++ scsidp = to_scsi_device(cdev->parent); ++ ++ if ((scsidp->host->hostt->name == NULL) || ++ (strcmp(scsidp->host->hostt->name, SCST_LOCAL_NAME) != 0)) ++ scst_unregister_device(scsidp); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static struct class_interface scst_interface = { ++ .add_dev = scst_add, ++ .remove_dev = scst_remove, ++}; ++ ++static void __init scst_print_config(void) ++{ ++ char buf[128]; ++ int i, j; ++ ++ i = snprintf(buf, sizeof(buf), "Enabled features: "); ++ j = i; ++ ++#ifdef CONFIG_SCST_STRICT_SERIALIZING ++ i += snprintf(&buf[i], sizeof(buf) - i, "STRICT_SERIALIZING"); ++#endif ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ i += snprintf(&buf[i], sizeof(buf) - i, "%sEXTRACHECKS", ++ (j == i) ? "" : ", "); ++#endif ++ ++#ifdef CONFIG_SCST_TRACING ++ i += snprintf(&buf[i], sizeof(buf) - i, "%sTRACING", ++ (j == i) ? "" : ", "); ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG ++ i += snprintf(&buf[i], sizeof(buf) - i, "%sDEBUG", ++ (j == i) ? "" : ", "); ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG_TM ++ i += snprintf(&buf[i], sizeof(buf) - i, "%sDEBUG_TM", ++ (j == i) ? "" : ", "); ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG_RETRY ++ i += snprintf(&buf[i], sizeof(buf) - i, "%sDEBUG_RETRY", ++ (j == i) ? "" : ", "); ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG_OOM ++ i += snprintf(&buf[i], sizeof(buf) - i, "%sDEBUG_OOM", ++ (j == i) ? "" : ", "); ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG_SN ++ i += snprintf(&buf[i], sizeof(buf) - i, "%sDEBUG_SN", ++ (j == i) ? "" : ", "); ++#endif ++ ++#ifdef CONFIG_SCST_USE_EXPECTED_VALUES ++ i += snprintf(&buf[i], sizeof(buf) - i, "%sUSE_EXPECTED_VALUES", ++ (j == i) ? "" : ", "); ++#endif ++ ++#ifdef CONFIG_SCST_TEST_IO_IN_SIRQ ++ i += snprintf(&buf[i], sizeof(buf) - i, ++ "%sTEST_IO_IN_SIRQ", ++ (j == i) ? "" : ", "); ++#endif ++ ++#ifdef CONFIG_SCST_STRICT_SECURITY ++ i += snprintf(&buf[i], sizeof(buf) - i, "%sSTRICT_SECURITY", ++ (j == i) ? "" : ", "); ++#endif ++ ++ if (j != i) ++ PRINT_INFO("%s", buf); ++} ++ ++static int __init init_scst(void) ++{ ++ int res, i; ++ int scst_num_cpus; ++ ++ TRACE_ENTRY(); ++ ++ { ++ struct scsi_sense_hdr *shdr; ++ struct scst_order_data *o; ++ struct scst_cmd *c; ++ BUILD_BUG_ON(SCST_SENSE_BUFFERSIZE < sizeof(*shdr)); ++ BUILD_BUG_ON(sizeof(o->curr_sn) != sizeof(o->expected_sn)); ++ BUILD_BUG_ON(sizeof(c->sn) != sizeof(o->expected_sn)); ++ } ++ ++ mutex_init(&scst_mutex); ++ mutex_init(&scst_mutex2); ++ INIT_LIST_HEAD(&scst_template_list); ++ INIT_LIST_HEAD(&scst_dev_list); ++ INIT_LIST_HEAD(&scst_dev_type_list); ++ INIT_LIST_HEAD(&scst_virtual_dev_type_list); ++ spin_lock_init(&scst_main_lock); ++ spin_lock_init(&scst_init_lock); ++ init_waitqueue_head(&scst_init_cmd_list_waitQ); ++ INIT_LIST_HEAD(&scst_init_cmd_list); ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ scst_trace_flag = SCST_DEFAULT_LOG_FLAGS; ++#endif ++ spin_lock_init(&scst_mcmd_lock); ++ INIT_LIST_HEAD(&scst_active_mgmt_cmd_list); ++ INIT_LIST_HEAD(&scst_delayed_mgmt_cmd_list); ++ init_waitqueue_head(&scst_mgmt_cmd_list_waitQ); ++ init_waitqueue_head(&scst_mgmt_waitQ); ++ spin_lock_init(&scst_mgmt_lock); ++ INIT_LIST_HEAD(&scst_sess_init_list); ++ INIT_LIST_HEAD(&scst_sess_shut_list); ++ init_waitqueue_head(&scst_dev_cmd_waitQ); ++ mutex_init(&scst_suspend_mutex); ++ INIT_LIST_HEAD(&scst_cmd_threads_list); ++ cpus_setall(default_cpu_mask); ++ ++ scst_init_threads(&scst_main_cmd_threads); ++ ++ res = scst_lib_init(); ++ if (res != 0) ++ goto out_deinit_threads; ++ ++ scst_num_cpus = num_online_cpus(); ++ ++ /* ToDo: register_cpu_notifier() */ ++ ++ if (scst_threads == 0) ++ scst_threads = scst_num_cpus; ++ ++ if (scst_threads < 1) { ++ PRINT_ERROR("%s", "scst_threads can not be less than 1"); ++ scst_threads = scst_num_cpus; ++ } ++ ++#define INIT_CACHEP(p, s, o) do { \ ++ p = KMEM_CACHE(s, SCST_SLAB_FLAGS); \ ++ TRACE_MEM("Slab create: %s at %p size %zd", #s, p, \ ++ sizeof(struct s)); \ ++ if (p == NULL) { \ ++ res = -ENOMEM; \ ++ goto o; \ ++ } \ ++ } while (0) ++ ++ INIT_CACHEP(scst_mgmt_cachep, scst_mgmt_cmd, out_lib_exit); ++ INIT_CACHEP(scst_mgmt_stub_cachep, scst_mgmt_cmd_stub, ++ out_destroy_mgmt_cache); ++ INIT_CACHEP(scst_ua_cachep, scst_tgt_dev_UA, ++ out_destroy_mgmt_stub_cache); ++ { ++ struct scst_sense { uint8_t s[SCST_SENSE_BUFFERSIZE]; }; ++ INIT_CACHEP(scst_sense_cachep, scst_sense, ++ out_destroy_ua_cache); ++ } ++ INIT_CACHEP(scst_aen_cachep, scst_aen, out_destroy_sense_cache); ++ INIT_CACHEP(scst_cmd_cachep, scst_cmd, out_destroy_aen_cache); ++ INIT_CACHEP(scst_sess_cachep, scst_session, out_destroy_cmd_cache); ++ INIT_CACHEP(scst_tgtd_cachep, scst_tgt_dev, out_destroy_sess_cache); ++ INIT_CACHEP(scst_acgd_cachep, scst_acg_dev, out_destroy_tgt_cache); ++ ++ scst_mgmt_mempool = mempool_create(64, mempool_alloc_slab, ++ mempool_free_slab, scst_mgmt_cachep); ++ if (scst_mgmt_mempool == NULL) { ++ res = -ENOMEM; ++ goto out_destroy_acg_cache; ++ } ++ ++ /* ++ * All mgmt stubs, UAs and sense buffers are bursty and loosing them ++ * may have fatal consequences, so let's have big pools for them. ++ */ ++ ++ scst_mgmt_stub_mempool = mempool_create(1024, mempool_alloc_slab, ++ mempool_free_slab, scst_mgmt_stub_cachep); ++ if (scst_mgmt_stub_mempool == NULL) { ++ res = -ENOMEM; ++ goto out_destroy_mgmt_mempool; ++ } ++ ++ scst_ua_mempool = mempool_create(512, mempool_alloc_slab, ++ mempool_free_slab, scst_ua_cachep); ++ if (scst_ua_mempool == NULL) { ++ res = -ENOMEM; ++ goto out_destroy_mgmt_stub_mempool; ++ } ++ ++ scst_sense_mempool = mempool_create(1024, mempool_alloc_slab, ++ mempool_free_slab, scst_sense_cachep); ++ if (scst_sense_mempool == NULL) { ++ res = -ENOMEM; ++ goto out_destroy_ua_mempool; ++ } ++ ++ scst_aen_mempool = mempool_create(100, mempool_alloc_slab, ++ mempool_free_slab, scst_aen_cachep); ++ if (scst_aen_mempool == NULL) { ++ res = -ENOMEM; ++ goto out_destroy_sense_mempool; ++ } ++ ++ res = scst_sysfs_init(); ++ if (res != 0) ++ goto out_destroy_aen_mempool; ++ ++ scst_tg_init(); ++ ++ if (scst_max_cmd_mem == 0) { ++ struct sysinfo si; ++ si_meminfo(&si); ++#if BITS_PER_LONG == 32 ++ scst_max_cmd_mem = min( ++ (((uint64_t)(si.totalram - si.totalhigh) << PAGE_SHIFT) ++ >> 20) >> 2, (uint64_t)1 << 30); ++#else ++ scst_max_cmd_mem = (((si.totalram - si.totalhigh) << PAGE_SHIFT) ++ >> 20) >> 2; ++#endif ++ } ++ ++ if (scst_max_dev_cmd_mem != 0) { ++ if (scst_max_dev_cmd_mem > scst_max_cmd_mem) { ++ PRINT_ERROR("scst_max_dev_cmd_mem (%d) > " ++ "scst_max_cmd_mem (%d)", ++ scst_max_dev_cmd_mem, ++ scst_max_cmd_mem); ++ scst_max_dev_cmd_mem = scst_max_cmd_mem; ++ } ++ } else ++ scst_max_dev_cmd_mem = scst_max_cmd_mem * 2 / 5; ++ ++ res = scst_sgv_pools_init( ++ ((uint64_t)scst_max_cmd_mem << 10) >> (PAGE_SHIFT - 10), 0); ++ if (res != 0) ++ goto out_sysfs_cleanup; ++ ++ res = scsi_register_interface(&scst_interface); ++ if (res != 0) ++ goto out_destroy_sgv_pool; ++ ++ for (i = 0; i < (int)ARRAY_SIZE(scst_percpu_infos); i++) { ++ atomic_set(&scst_percpu_infos[i].cpu_cmd_count, 0); ++ spin_lock_init(&scst_percpu_infos[i].tasklet_lock); ++ INIT_LIST_HEAD(&scst_percpu_infos[i].tasklet_cmd_list); ++ tasklet_init(&scst_percpu_infos[i].tasklet, ++ (void *)scst_cmd_tasklet, ++ (unsigned long)&scst_percpu_infos[i]); ++ } ++ ++ TRACE_DBG("%d CPUs found, starting %d threads", scst_num_cpus, ++ scst_threads); ++ ++ res = scst_start_global_threads(scst_threads); ++ if (res < 0) ++ goto out_thread_free; ++ ++ PRINT_INFO("SCST version %s loaded successfully (max mem for " ++ "commands %dMB, per device %dMB)", SCST_VERSION_STRING, ++ scst_max_cmd_mem, scst_max_dev_cmd_mem); ++ ++ scst_print_config(); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_thread_free: ++ scst_stop_global_threads(); ++ ++ scsi_unregister_interface(&scst_interface); ++ ++out_destroy_sgv_pool: ++ scst_sgv_pools_deinit(); ++ scst_tg_cleanup(); ++ ++out_sysfs_cleanup: ++ scst_sysfs_cleanup(); ++ ++out_destroy_aen_mempool: ++ mempool_destroy(scst_aen_mempool); ++ ++out_destroy_sense_mempool: ++ mempool_destroy(scst_sense_mempool); ++ ++out_destroy_ua_mempool: ++ mempool_destroy(scst_ua_mempool); ++ ++out_destroy_mgmt_stub_mempool: ++ mempool_destroy(scst_mgmt_stub_mempool); ++ ++out_destroy_mgmt_mempool: ++ mempool_destroy(scst_mgmt_mempool); ++ ++out_destroy_acg_cache: ++ kmem_cache_destroy(scst_acgd_cachep); ++ ++out_destroy_tgt_cache: ++ kmem_cache_destroy(scst_tgtd_cachep); ++ ++out_destroy_sess_cache: ++ kmem_cache_destroy(scst_sess_cachep); ++ ++out_destroy_cmd_cache: ++ kmem_cache_destroy(scst_cmd_cachep); ++ ++out_destroy_aen_cache: ++ kmem_cache_destroy(scst_aen_cachep); ++ ++out_destroy_sense_cache: ++ kmem_cache_destroy(scst_sense_cachep); ++ ++out_destroy_ua_cache: ++ kmem_cache_destroy(scst_ua_cachep); ++ ++out_destroy_mgmt_stub_cache: ++ kmem_cache_destroy(scst_mgmt_stub_cachep); ++ ++out_destroy_mgmt_cache: ++ kmem_cache_destroy(scst_mgmt_cachep); ++ ++out_lib_exit: ++ scst_lib_exit(); ++ ++out_deinit_threads: ++ scst_deinit_threads(&scst_main_cmd_threads); ++ goto out; ++} ++ ++static void __exit exit_scst(void) ++{ ++ TRACE_ENTRY(); ++ ++ /* ToDo: unregister_cpu_notifier() */ ++ ++ scst_stop_global_threads(); ++ ++ scst_deinit_threads(&scst_main_cmd_threads); ++ ++ scsi_unregister_interface(&scst_interface); ++ ++ scst_sgv_pools_deinit(); ++ ++ scst_tg_cleanup(); ++ ++ scst_sysfs_cleanup(); ++ ++#define DEINIT_CACHEP(p) do { \ ++ kmem_cache_destroy(p); \ ++ p = NULL; \ ++ } while (0) ++ ++ mempool_destroy(scst_mgmt_mempool); ++ mempool_destroy(scst_mgmt_stub_mempool); ++ mempool_destroy(scst_ua_mempool); ++ mempool_destroy(scst_sense_mempool); ++ mempool_destroy(scst_aen_mempool); ++ ++ DEINIT_CACHEP(scst_mgmt_cachep); ++ DEINIT_CACHEP(scst_mgmt_stub_cachep); ++ DEINIT_CACHEP(scst_ua_cachep); ++ DEINIT_CACHEP(scst_sense_cachep); ++ DEINIT_CACHEP(scst_aen_cachep); ++ DEINIT_CACHEP(scst_cmd_cachep); ++ DEINIT_CACHEP(scst_sess_cachep); ++ DEINIT_CACHEP(scst_tgtd_cachep); ++ DEINIT_CACHEP(scst_acgd_cachep); ++ ++ scst_lib_exit(); ++ ++ PRINT_INFO("%s", "SCST unloaded"); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++module_init(init_scst); ++module_exit(exit_scst); ++ ++MODULE_AUTHOR("Vladislav Bolkhovitin"); ++MODULE_LICENSE("GPL"); ++MODULE_DESCRIPTION("SCSI target core"); ++MODULE_VERSION(SCST_VERSION_STRING); +diff -uprN orig/linux-3.2/drivers/scst/scst_module.c linux-3.2/drivers/scst/scst_module.c +--- orig/linux-3.2/drivers/scst/scst_module.c ++++ linux-3.2/drivers/scst/scst_module.c +@@ -0,0 +1,70 @@ ++/* ++ * scst_module.c ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * Support for loading target modules. The usage is similar to scsi_module.c ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/module.h> ++#include <linux/init.h> ++ ++#include <scst.h> ++ ++static int __init init_this_scst_driver(void) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ res = scst_register_target_template(&driver_target_template); ++ TRACE_DBG("scst_register_target_template() returned %d", res); ++ if (res < 0) ++ goto out; ++ ++#ifdef SCST_REGISTER_INITIATOR_DRIVER ++ driver_template.module = THIS_MODULE; ++ scsi_register_module(MODULE_SCSI_HA, &driver_template); ++ TRACE_DBG("driver_template.present=%d", ++ driver_template.present); ++ if (driver_template.present == 0) { ++ res = -ENODEV; ++ MOD_DEC_USE_COUNT; ++ goto out; ++ } ++#endif ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void __exit exit_this_scst_driver(void) ++{ ++ TRACE_ENTRY(); ++ ++#ifdef SCST_REGISTER_INITIATOR_DRIVER ++ scsi_unregister_module(MODULE_SCSI_HA, &driver_template); ++#endif ++ ++ scst_unregister_target_template(&driver_target_template); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++module_init(init_this_scst_driver); ++module_exit(exit_this_scst_driver); +diff -uprN orig/linux-3.2/drivers/scst/scst_priv.h linux-3.2/drivers/scst/scst_priv.h +--- orig/linux-3.2/drivers/scst/scst_priv.h ++++ linux-3.2/drivers/scst/scst_priv.h +@@ -0,0 +1,646 @@ ++/* ++ * scst_priv.h ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#ifndef __SCST_PRIV_H ++#define __SCST_PRIV_H ++ ++#include <linux/types.h> ++#include <linux/slab.h> ++#include <linux/export.h> ++#include <scsi/scsi.h> ++#include <scsi/scsi_cmnd.h> ++#include <scsi/scsi_driver.h> ++#include <scsi/scsi_device.h> ++#include <scsi/scsi_host.h> ++ ++#define LOG_PREFIX "scst" ++ ++#include <scst/scst_debug.h> ++ ++#define TRACE_RTRY 0x80000000 ++#define TRACE_SCSI_SERIALIZING 0x40000000 ++/** top being the edge away from the interrupt */ ++#define TRACE_SND_TOP 0x20000000 ++#define TRACE_RCV_TOP 0x01000000 ++/** bottom being the edge toward the interrupt */ ++#define TRACE_SND_BOT 0x08000000 ++#define TRACE_RCV_BOT 0x04000000 ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++#define trace_flag scst_trace_flag ++extern unsigned long scst_trace_flag; ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG ++ ++#define SCST_DEFAULT_LOG_FLAGS (TRACE_OUT_OF_MEM | TRACE_MINOR | TRACE_PID | \ ++ TRACE_LINE | TRACE_FUNCTION | TRACE_SPECIAL | TRACE_MGMT | \ ++ TRACE_MGMT_DEBUG | TRACE_RTRY) ++ ++#define TRACE_RETRY(args...) TRACE_DBG_FLAG(TRACE_RTRY, args) ++#define TRACE_SN(args...) TRACE_DBG_FLAG(TRACE_SCSI_SERIALIZING, args) ++#define TRACE_SEND_TOP(args...) TRACE_DBG_FLAG(TRACE_SND_TOP, args) ++#define TRACE_RECV_TOP(args...) TRACE_DBG_FLAG(TRACE_RCV_TOP, args) ++#define TRACE_SEND_BOT(args...) TRACE_DBG_FLAG(TRACE_SND_BOT, args) ++#define TRACE_RECV_BOT(args...) TRACE_DBG_FLAG(TRACE_RCV_BOT, args) ++ ++#else /* CONFIG_SCST_DEBUG */ ++ ++# ifdef CONFIG_SCST_TRACING ++#define SCST_DEFAULT_LOG_FLAGS (TRACE_OUT_OF_MEM | TRACE_MGMT | \ ++ TRACE_SPECIAL) ++# else ++#define SCST_DEFAULT_LOG_FLAGS 0 ++# endif ++ ++#define TRACE_RETRY(args...) ++#define TRACE_SN(args...) ++#define TRACE_SEND_TOP(args...) ++#define TRACE_RECV_TOP(args...) ++#define TRACE_SEND_BOT(args...) ++#define TRACE_RECV_BOT(args...) ++ ++#endif ++ ++/** ++ ** Bits for scst_flags ++ **/ ++ ++/* ++ * Set if new commands initialization is being suspended for a while. ++ * Used to let TM commands execute while preparing the suspend, since ++ * RESET or ABORT could be necessary to free SCSI commands. ++ */ ++#define SCST_FLAG_SUSPENDING 0 ++ ++/* Set if new commands initialization is suspended for a while */ ++#define SCST_FLAG_SUSPENDED 1 ++ ++/** ++ ** Return codes for cmd state process functions. Codes are the same as ++ ** for SCST_EXEC_* to avoid translation to them and, hence, have better code. ++ **/ ++#define SCST_CMD_STATE_RES_CONT_NEXT SCST_EXEC_COMPLETED ++#define SCST_CMD_STATE_RES_CONT_SAME SCST_EXEC_NOT_COMPLETED ++#define SCST_CMD_STATE_RES_NEED_THREAD (SCST_EXEC_NOT_COMPLETED+1) ++ ++/** ++ ** Maximum count of uncompleted commands that an initiator could ++ ** queue on any device. Then it will start getting TASK QUEUE FULL status. ++ **/ ++#define SCST_MAX_TGT_DEV_COMMANDS 48 ++ ++/** ++ ** Maximum count of uncompleted commands that could be queued on any device. ++ ** Then initiators sending commands to this device will start getting ++ ** TASK QUEUE FULL status. ++ **/ ++#define SCST_MAX_DEV_COMMANDS 256 ++ ++#define SCST_TGT_RETRY_TIMEOUT (3/2*HZ) ++ ++/* Activities suspending timeout */ ++#define SCST_SUSPENDING_TIMEOUT (90 * HZ) ++ ++extern struct mutex scst_mutex2; ++ ++extern int scst_threads; ++ ++extern unsigned int scst_max_dev_cmd_mem; ++ ++extern mempool_t *scst_mgmt_mempool; ++extern mempool_t *scst_mgmt_stub_mempool; ++extern mempool_t *scst_ua_mempool; ++extern mempool_t *scst_sense_mempool; ++extern mempool_t *scst_aen_mempool; ++ ++extern struct kmem_cache *scst_cmd_cachep; ++extern struct kmem_cache *scst_sess_cachep; ++extern struct kmem_cache *scst_tgtd_cachep; ++extern struct kmem_cache *scst_acgd_cachep; ++ ++extern spinlock_t scst_main_lock; ++ ++extern unsigned long scst_flags; ++extern struct list_head scst_template_list; ++extern struct list_head scst_dev_list; ++extern struct list_head scst_dev_type_list; ++extern struct list_head scst_virtual_dev_type_list; ++extern wait_queue_head_t scst_dev_cmd_waitQ; ++ ++extern unsigned int scst_setup_id; ++ ++#define SCST_DEF_MAX_TASKLET_CMD 10 ++extern int scst_max_tasklet_cmd; ++ ++extern spinlock_t scst_init_lock; ++extern struct list_head scst_init_cmd_list; ++extern wait_queue_head_t scst_init_cmd_list_waitQ; ++extern unsigned int scst_init_poll_cnt; ++ ++extern struct scst_cmd_threads scst_main_cmd_threads; ++ ++extern spinlock_t scst_mcmd_lock; ++/* The following lists protected by scst_mcmd_lock */ ++extern struct list_head scst_active_mgmt_cmd_list; ++extern struct list_head scst_delayed_mgmt_cmd_list; ++extern wait_queue_head_t scst_mgmt_cmd_list_waitQ; ++ ++struct scst_percpu_info { ++ atomic_t cpu_cmd_count; ++ spinlock_t tasklet_lock; ++ struct list_head tasklet_cmd_list; ++ struct tasklet_struct tasklet; ++} ____cacheline_aligned_in_smp; ++extern struct scst_percpu_info scst_percpu_infos[NR_CPUS]; ++ ++extern wait_queue_head_t scst_mgmt_waitQ; ++extern spinlock_t scst_mgmt_lock; ++extern struct list_head scst_sess_init_list; ++extern struct list_head scst_sess_shut_list; ++ ++extern cpumask_t default_cpu_mask; ++ ++struct scst_cmd_thread_t { ++ struct task_struct *cmd_thread; ++ struct list_head thread_list_entry; ++}; ++ ++static inline bool scst_set_io_context(struct scst_cmd *cmd, ++ struct io_context **old) ++{ ++ bool res; ++ ++#ifdef CONFIG_SCST_TEST_IO_IN_SIRQ ++ return false; ++#endif ++ ++ if (cmd->cmd_threads == &scst_main_cmd_threads) { ++ EXTRACHECKS_BUG_ON(in_interrupt()); ++ /* ++ * No need for any ref counting action, because io_context ++ * supposed to be cleared in the end of the caller function. ++ */ ++ current->io_context = cmd->tgt_dev->async_io_context; ++ res = true; ++ TRACE_DBG("io_context %p (tgt_dev %p)", current->io_context, ++ cmd->tgt_dev); ++ EXTRACHECKS_BUG_ON(current->io_context == NULL); ++ } else ++ res = false; ++ ++ return res; ++} ++ ++static inline void scst_reset_io_context(struct scst_tgt_dev *tgt_dev, ++ struct io_context *old) ++{ ++ current->io_context = old; ++ TRACE_DBG("io_context %p reset", current->io_context); ++ return; ++} ++ ++/* ++ * Converts string presentation of threads pool type to enum. ++ * Returns SCST_THREADS_POOL_TYPE_INVALID if the string is invalid. ++ */ ++extern enum scst_dev_type_threads_pool_type scst_parse_threads_pool_type( ++ const char *p, int len); ++ ++extern int scst_add_threads(struct scst_cmd_threads *cmd_threads, ++ struct scst_device *dev, struct scst_tgt_dev *tgt_dev, int num); ++extern void scst_del_threads(struct scst_cmd_threads *cmd_threads, int num); ++ ++extern int scst_create_dev_threads(struct scst_device *dev); ++extern void scst_stop_dev_threads(struct scst_device *dev); ++ ++extern int scst_tgt_dev_setup_threads(struct scst_tgt_dev *tgt_dev); ++extern void scst_tgt_dev_stop_threads(struct scst_tgt_dev *tgt_dev); ++ ++extern bool scst_del_thr_data(struct scst_tgt_dev *tgt_dev, ++ struct task_struct *tsk); ++ ++extern struct scst_dev_type scst_null_devtype; ++ ++extern struct scst_cmd *__scst_check_deferred_commands( ++ struct scst_order_data *order_data); ++ ++/* Used to save the function call on the fast path */ ++static inline struct scst_cmd *scst_check_deferred_commands( ++ struct scst_order_data *order_data) ++{ ++ if (order_data->def_cmd_count == 0) ++ return NULL; ++ else ++ return __scst_check_deferred_commands(order_data); ++} ++ ++static inline void scst_make_deferred_commands_active( ++ struct scst_order_data *order_data) ++{ ++ struct scst_cmd *c; ++ ++ c = __scst_check_deferred_commands(order_data); ++ if (c != NULL) { ++ TRACE_SN("Adding cmd %p to active cmd list", c); ++ spin_lock_irq(&c->cmd_threads->cmd_list_lock); ++ list_add_tail(&c->cmd_list_entry, ++ &c->cmd_threads->active_cmd_list); ++ wake_up(&c->cmd_threads->cmd_list_waitQ); ++ spin_unlock_irq(&c->cmd_threads->cmd_list_lock); ++ } ++ ++ return; ++} ++ ++void scst_inc_expected_sn(struct scst_order_data *order_data, atomic_t *slot); ++int scst_check_hq_cmd(struct scst_cmd *cmd); ++ ++void scst_unblock_deferred(struct scst_order_data *order_data, ++ struct scst_cmd *cmd_sn); ++ ++void scst_on_hq_cmd_response(struct scst_cmd *cmd); ++void scst_xmit_process_aborted_cmd(struct scst_cmd *cmd); ++ ++int scst_pre_parse(struct scst_cmd *cmd); ++ ++int scst_cmd_thread(void *arg); ++void scst_cmd_tasklet(long p); ++int scst_init_thread(void *arg); ++int scst_tm_thread(void *arg); ++int scst_global_mgmt_thread(void *arg); ++ ++void scst_zero_write_rest(struct scst_cmd *cmd); ++void scst_limit_sg_write_len(struct scst_cmd *cmd); ++void scst_adjust_resp_data_len(struct scst_cmd *cmd); ++ ++int scst_queue_retry_cmd(struct scst_cmd *cmd, int finished_cmds); ++ ++int scst_alloc_tgt(struct scst_tgt_template *tgtt, struct scst_tgt **tgt); ++void scst_free_tgt(struct scst_tgt *tgt); ++ ++int scst_alloc_device(gfp_t gfp_mask, struct scst_device **out_dev); ++void scst_free_device(struct scst_device *dev); ++ ++struct scst_acg *scst_alloc_add_acg(struct scst_tgt *tgt, ++ const char *acg_name, bool tgt_acg); ++void scst_del_free_acg(struct scst_acg *acg); ++ ++struct scst_acg *scst_tgt_find_acg(struct scst_tgt *tgt, const char *name); ++struct scst_acg *scst_find_acg(const struct scst_session *sess); ++ ++void scst_check_reassign_sessions(void); ++ ++int scst_sess_alloc_tgt_devs(struct scst_session *sess); ++void scst_sess_free_tgt_devs(struct scst_session *sess); ++void scst_nexus_loss(struct scst_tgt_dev *tgt_dev, bool queue_UA); ++ ++int scst_acg_add_lun(struct scst_acg *acg, struct kobject *parent, ++ struct scst_device *dev, uint64_t lun, int read_only, ++ bool gen_scst_report_luns_changed, struct scst_acg_dev **out_acg_dev); ++int scst_acg_del_lun(struct scst_acg *acg, uint64_t lun, ++ bool gen_scst_report_luns_changed); ++ ++int scst_acg_add_acn(struct scst_acg *acg, const char *name); ++void scst_del_free_acn(struct scst_acn *acn, bool reassign); ++struct scst_acn *scst_find_acn(struct scst_acg *acg, const char *name); ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++static inline bool scst_acg_sess_is_empty(struct scst_acg *acg) ++{ ++ return list_empty(&acg->acg_sess_list); ++} ++ ++int scst_prepare_request_sense(struct scst_cmd *orig_cmd); ++int scst_finish_internal_cmd(struct scst_cmd *cmd); ++ ++void scst_store_sense(struct scst_cmd *cmd); ++ ++int scst_assign_dev_handler(struct scst_device *dev, ++ struct scst_dev_type *handler); ++ ++struct scst_session *scst_alloc_session(struct scst_tgt *tgt, gfp_t gfp_mask, ++ const char *initiator_name); ++void scst_free_session(struct scst_session *sess); ++void scst_free_session_callback(struct scst_session *sess); ++ ++struct scst_cmd *scst_alloc_cmd(const uint8_t *cdb, ++ unsigned int cdb_len, gfp_t gfp_mask); ++void scst_free_cmd(struct scst_cmd *cmd); ++static inline void scst_destroy_cmd(struct scst_cmd *cmd) ++{ ++ kmem_cache_free(scst_cmd_cachep, cmd); ++ return; ++} ++ ++void scst_check_retries(struct scst_tgt *tgt); ++ ++int scst_alloc_space(struct scst_cmd *cmd); ++ ++int scst_lib_init(void); ++void scst_lib_exit(void); ++ ++__be64 scst_pack_lun(const uint64_t lun, enum scst_lun_addr_method addr_method); ++uint64_t scst_unpack_lun(const uint8_t *lun, int len); ++ ++struct scst_mgmt_cmd *scst_alloc_mgmt_cmd(gfp_t gfp_mask); ++void scst_free_mgmt_cmd(struct scst_mgmt_cmd *mcmd); ++void scst_done_cmd_mgmt(struct scst_cmd *cmd); ++ ++static inline void scst_devt_cleanup(struct scst_dev_type *devt) { } ++ ++void scst_tg_init(void); ++void scst_tg_cleanup(void); ++int scst_dg_add(struct kobject *parent, const char *name); ++int scst_dg_remove(const char *name); ++struct scst_dev_group *scst_lookup_dg_by_kobj(struct kobject *kobj); ++int scst_dg_dev_add(struct scst_dev_group *dg, const char *name); ++int scst_dg_dev_remove_by_name(struct scst_dev_group *dg, const char *name); ++int scst_dg_dev_remove_by_dev(struct scst_device *dev); ++int scst_tg_add(struct scst_dev_group *dg, const char *name); ++int scst_tg_remove_by_name(struct scst_dev_group *dg, const char *name); ++int scst_tg_set_state(struct scst_target_group *tg, enum scst_tg_state state); ++int scst_tg_tgt_add(struct scst_target_group *tg, const char *name); ++int scst_tg_tgt_remove_by_name(struct scst_target_group *tg, const char *name); ++void scst_tg_tgt_remove_by_tgt(struct scst_tgt *tgt); ++int scst_dg_sysfs_add(struct kobject *parent, struct scst_dev_group *dg); ++void scst_dg_sysfs_del(struct scst_dev_group *dg); ++int scst_dg_dev_sysfs_add(struct scst_dev_group *dg, struct scst_dg_dev *dgdev); ++void scst_dg_dev_sysfs_del(struct scst_dev_group *dg, ++ struct scst_dg_dev *dgdev); ++int scst_tg_sysfs_add(struct scst_dev_group *dg, ++ struct scst_target_group *tg); ++void scst_tg_sysfs_del(struct scst_target_group *tg); ++int scst_tg_tgt_sysfs_add(struct scst_target_group *tg, ++ struct scst_tg_tgt *tg_tgt); ++void scst_tg_tgt_sysfs_del(struct scst_target_group *tg, ++ struct scst_tg_tgt *tg_tgt); ++ ++extern const struct sysfs_ops scst_sysfs_ops; ++int scst_sysfs_init(void); ++void scst_sysfs_cleanup(void); ++int scst_tgtt_sysfs_create(struct scst_tgt_template *tgtt); ++void scst_tgtt_sysfs_del(struct scst_tgt_template *tgtt); ++int scst_tgt_sysfs_create(struct scst_tgt *tgt); ++void scst_tgt_sysfs_prepare_put(struct scst_tgt *tgt); ++void scst_tgt_sysfs_del(struct scst_tgt *tgt); ++int scst_sess_sysfs_create(struct scst_session *sess); ++void scst_sess_sysfs_del(struct scst_session *sess); ++int scst_recreate_sess_luns_link(struct scst_session *sess); ++int scst_add_sgv_kobj(struct kobject *parent, const char *name); ++void scst_del_put_sgv_kobj(void); ++int scst_devt_sysfs_create(struct scst_dev_type *devt); ++void scst_devt_sysfs_del(struct scst_dev_type *devt); ++int scst_dev_sysfs_create(struct scst_device *dev); ++void scst_dev_sysfs_del(struct scst_device *dev); ++int scst_tgt_dev_sysfs_create(struct scst_tgt_dev *tgt_dev); ++void scst_tgt_dev_sysfs_del(struct scst_tgt_dev *tgt_dev); ++int scst_devt_dev_sysfs_create(struct scst_device *dev); ++void scst_devt_dev_sysfs_del(struct scst_device *dev); ++int scst_acg_sysfs_create(struct scst_tgt *tgt, ++ struct scst_acg *acg); ++void scst_acg_sysfs_del(struct scst_acg *acg); ++int scst_acg_dev_sysfs_create(struct scst_acg_dev *acg_dev, ++ struct kobject *parent); ++void scst_acg_dev_sysfs_del(struct scst_acg_dev *acg_dev); ++int scst_acn_sysfs_create(struct scst_acn *acn); ++void scst_acn_sysfs_del(struct scst_acn *acn); ++ ++void __scst_dev_check_set_UA(struct scst_device *dev, struct scst_cmd *exclude, ++ const uint8_t *sense, int sense_len); ++void scst_tgt_dev_del_free_UA(struct scst_tgt_dev *tgt_dev, ++ struct scst_tgt_dev_UA *ua); ++static inline void scst_dev_check_set_UA(struct scst_device *dev, ++ struct scst_cmd *exclude, const uint8_t *sense, int sense_len) ++{ ++ spin_lock_bh(&dev->dev_lock); ++ __scst_dev_check_set_UA(dev, exclude, sense, sense_len); ++ spin_unlock_bh(&dev->dev_lock); ++ return; ++} ++void scst_dev_check_set_local_UA(struct scst_device *dev, ++ struct scst_cmd *exclude, const uint8_t *sense, int sense_len); ++ ++#define SCST_SET_UA_FLAG_AT_HEAD 1 ++#define SCST_SET_UA_FLAG_GLOBAL 2 ++ ++void scst_check_set_UA(struct scst_tgt_dev *tgt_dev, ++ const uint8_t *sense, int sense_len, int flags); ++int scst_set_pending_UA(struct scst_cmd *cmd); ++ ++void scst_report_luns_changed(struct scst_acg *acg); ++ ++void scst_abort_cmd(struct scst_cmd *cmd, struct scst_mgmt_cmd *mcmd, ++ bool other_ini, bool call_dev_task_mgmt_fn); ++void scst_process_reset(struct scst_device *dev, ++ struct scst_session *originator, struct scst_cmd *exclude_cmd, ++ struct scst_mgmt_cmd *mcmd, bool setUA); ++ ++bool scst_is_ua_global(const uint8_t *sense, int len); ++void scst_requeue_ua(struct scst_cmd *cmd); ++ ++struct scst_aen *scst_alloc_aen(struct scst_session *sess, ++ uint64_t unpacked_lun); ++void scst_free_aen(struct scst_aen *aen); ++ ++void scst_gen_aen_or_ua(struct scst_tgt_dev *tgt_dev, ++ int key, int asc, int ascq); ++ ++static inline bool scst_is_implicit_hq_cmd(struct scst_cmd *cmd) ++{ ++ return (cmd->op_flags & SCST_IMPLICIT_HQ) != 0; ++} ++ ++static inline bool scst_is_serialized_cmd(struct scst_cmd *cmd) ++{ ++ return (cmd->op_flags & SCST_SERIALIZED) != 0; ++} ++ ++static inline bool scst_is_strictly_serialized_cmd(struct scst_cmd *cmd) ++{ ++ return (cmd->op_flags & SCST_STRICTLY_SERIALIZED) == SCST_STRICTLY_SERIALIZED; ++} ++ ++/* ++ * Some notes on devices "blocking". Blocking means that no ++ * commands will go from SCST to underlying SCSI device until it ++ * is unblocked. But, except for strictly serialized commands, ++ * we don't care about all commands that already on the device. ++ */ ++ ++extern void scst_block_dev(struct scst_device *dev); ++extern void scst_unblock_dev(struct scst_device *dev); ++ ++bool __scst_check_blocked_dev(struct scst_cmd *cmd); ++ ++/* ++ * Increases global SCST ref counters which prevent from entering into suspended ++ * activities stage, so protects from any global management operations. ++ */ ++static inline atomic_t *scst_get(void) ++{ ++ atomic_t *a; ++ /* ++ * We don't mind if we because of preemption inc counter from another ++ * CPU as soon in the majority cases we will the correct one. So, let's ++ * have preempt_disable/enable only in the debug build to avoid warning. ++ */ ++#ifdef CONFIG_DEBUG_PREEMPT ++ preempt_disable(); ++#endif ++ a = &scst_percpu_infos[smp_processor_id()].cpu_cmd_count; ++ atomic_inc(a); ++#ifdef CONFIG_DEBUG_PREEMPT ++ preempt_enable(); ++#endif ++ TRACE_DBG("Incrementing cpu_cmd_count %p (new value %d)", ++ a, atomic_read(a)); ++ /* See comment about smp_mb() in scst_suspend_activity() */ ++ smp_mb__after_atomic_inc(); ++ ++ return a; ++} ++ ++/* ++ * Decreases global SCST ref counters which prevent from entering into suspended ++ * activities stage, so protects from any global management operations. On ++ * all them zero, if suspending activities is waiting, it will be proceed. ++ */ ++static inline void scst_put(atomic_t *a) ++{ ++ int f; ++ f = atomic_dec_and_test(a); ++ /* See comment about smp_mb() in scst_suspend_activity() */ ++ if (unlikely(test_bit(SCST_FLAG_SUSPENDED, &scst_flags)) && f) { ++ TRACE_MGMT_DBG("%s", "Waking up scst_dev_cmd_waitQ"); ++ wake_up_all(&scst_dev_cmd_waitQ); ++ } ++ TRACE_DBG("Decrementing cpu_cmd_count %p (new value %d)", ++ a, atomic_read(a)); ++} ++ ++int scst_get_cmd_counter(void); ++ ++void scst_sched_session_free(struct scst_session *sess); ++ ++static inline void scst_sess_get(struct scst_session *sess) ++{ ++ atomic_inc(&sess->refcnt); ++ TRACE_DBG("Incrementing sess %p refcnt (new value %d)", ++ sess, atomic_read(&sess->refcnt)); ++} ++ ++static inline void scst_sess_put(struct scst_session *sess) ++{ ++ TRACE_DBG("Decrementing sess %p refcnt (new value %d)", ++ sess, atomic_read(&sess->refcnt)-1); ++ if (atomic_dec_and_test(&sess->refcnt)) ++ scst_sched_session_free(sess); ++} ++ ++static inline void __scst_cmd_get(struct scst_cmd *cmd) ++{ ++ atomic_inc(&cmd->cmd_ref); ++ TRACE_DBG("Incrementing cmd %p ref (new value %d)", ++ cmd, atomic_read(&cmd->cmd_ref)); ++} ++ ++static inline void __scst_cmd_put(struct scst_cmd *cmd) ++{ ++ TRACE_DBG("Decrementing cmd %p ref (new value %d)", ++ cmd, atomic_read(&cmd->cmd_ref)-1); ++ if (atomic_dec_and_test(&cmd->cmd_ref)) ++ scst_free_cmd(cmd); ++} ++ ++extern void scst_throttle_cmd(struct scst_cmd *cmd); ++extern void scst_unthrottle_cmd(struct scst_cmd *cmd); ++ ++#ifdef CONFIG_SCST_DEBUG_TM ++extern void tm_dbg_check_released_cmds(void); ++extern int tm_dbg_check_cmd(struct scst_cmd *cmd); ++extern void tm_dbg_release_cmd(struct scst_cmd *cmd); ++extern void tm_dbg_task_mgmt(struct scst_device *dev, const char *fn, ++ int force); ++extern int tm_dbg_is_release(void); ++#else ++static inline void tm_dbg_check_released_cmds(void) {} ++static inline int tm_dbg_check_cmd(struct scst_cmd *cmd) ++{ ++ return 0; ++} ++static inline void tm_dbg_release_cmd(struct scst_cmd *cmd) {} ++static inline void tm_dbg_task_mgmt(struct scst_device *dev, const char *fn, ++ int force) {} ++static inline int tm_dbg_is_release(void) ++{ ++ return 0; ++} ++#endif /* CONFIG_SCST_DEBUG_TM */ ++ ++#ifdef CONFIG_SCST_DEBUG_SN ++void scst_check_debug_sn(struct scst_cmd *cmd); ++#else ++static inline void scst_check_debug_sn(struct scst_cmd *cmd) {} ++#endif ++ ++static inline int scst_sn_before(uint32_t seq1, uint32_t seq2) ++{ ++ return (int32_t)(seq1-seq2) < 0; ++} ++ ++int gen_relative_target_port_id(uint16_t *id); ++bool scst_is_relative_target_port_id_unique(uint16_t id, ++ const struct scst_tgt *t); ++ ++#ifdef CONFIG_SCST_MEASURE_LATENCY ++ ++void scst_set_start_time(struct scst_cmd *cmd); ++void scst_set_cur_start(struct scst_cmd *cmd); ++void scst_set_parse_time(struct scst_cmd *cmd); ++void scst_set_alloc_buf_time(struct scst_cmd *cmd); ++void scst_set_restart_waiting_time(struct scst_cmd *cmd); ++void scst_set_rdy_to_xfer_time(struct scst_cmd *cmd); ++void scst_set_pre_exec_time(struct scst_cmd *cmd); ++void scst_set_exec_time(struct scst_cmd *cmd); ++void scst_set_dev_done_time(struct scst_cmd *cmd); ++void scst_set_xmit_time(struct scst_cmd *cmd); ++void scst_set_tgt_on_free_time(struct scst_cmd *cmd); ++void scst_set_dev_on_free_time(struct scst_cmd *cmd); ++void scst_update_lat_stats(struct scst_cmd *cmd); ++ ++#else ++ ++static inline void scst_set_start_time(struct scst_cmd *cmd) {} ++static inline void scst_set_cur_start(struct scst_cmd *cmd) {} ++static inline void scst_set_parse_time(struct scst_cmd *cmd) {} ++static inline void scst_set_alloc_buf_time(struct scst_cmd *cmd) {} ++static inline void scst_set_restart_waiting_time(struct scst_cmd *cmd) {} ++static inline void scst_set_rdy_to_xfer_time(struct scst_cmd *cmd) {} ++static inline void scst_set_pre_exec_time(struct scst_cmd *cmd) {} ++static inline void scst_set_exec_time(struct scst_cmd *cmd) {} ++static inline void scst_set_dev_done_time(struct scst_cmd *cmd) {} ++static inline void scst_set_xmit_time(struct scst_cmd *cmd) {} ++static inline void scst_set_tgt_on_free_time(struct scst_cmd *cmd) {} ++static inline void scst_set_dev_on_free_time(struct scst_cmd *cmd) {} ++static inline void scst_update_lat_stats(struct scst_cmd *cmd) {} ++ ++#endif /* CONFIG_SCST_MEASURE_LATENCY */ ++ ++#endif /* __SCST_PRIV_H */ +diff -uprN orig/linux-3.2/drivers/scst/scst_targ.c linux-3.2/drivers/scst/scst_targ.c +--- orig/linux-3.2/drivers/scst/scst_targ.c ++++ linux-3.2/drivers/scst/scst_targ.c +@@ -0,0 +1,6705 @@ ++/* ++ * scst_targ.c ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/init.h> ++#include <linux/kernel.h> ++#include <linux/errno.h> ++#include <linux/list.h> ++#include <linux/spinlock.h> ++#include <linux/slab.h> ++#include <linux/sched.h> ++#include <linux/unistd.h> ++#include <linux/string.h> ++#include <linux/kthread.h> ++#include <linux/delay.h> ++#include <linux/ktime.h> ++ ++#include <scst/scst.h> ++#include "scst_priv.h" ++#include "scst_pres.h" ++ ++#if 0 /* Let's disable it for now to see if users will complain about it */ ++/* Deleting it don't forget to delete dev_cmd_count */ ++#define CONFIG_SCST_PER_DEVICE_CMD_COUNT_LIMIT ++#endif ++ ++static void scst_cmd_set_sn(struct scst_cmd *cmd); ++static int __scst_init_cmd(struct scst_cmd *cmd); ++static void scst_finish_cmd_mgmt(struct scst_cmd *cmd); ++static struct scst_cmd *__scst_find_cmd_by_tag(struct scst_session *sess, ++ uint64_t tag, bool to_abort); ++static void scst_process_redirect_cmd(struct scst_cmd *cmd, ++ enum scst_exec_context context, int check_retries); ++ ++/** ++ * scst_post_parse() - do post parse actions ++ * ++ * This function must be called by dev handler after its parse() callback ++ * returned SCST_CMD_STATE_STOP before calling scst_process_active_cmd(). ++ */ ++void scst_post_parse(struct scst_cmd *cmd) ++{ ++ scst_set_parse_time(cmd); ++} ++EXPORT_SYMBOL_GPL(scst_post_parse); ++ ++/** ++ * scst_post_alloc_data_buf() - do post alloc_data_buf actions ++ * ++ * This function must be called by dev handler after its alloc_data_buf() ++ * callback returned SCST_CMD_STATE_STOP before calling ++ * scst_process_active_cmd(). ++ */ ++void scst_post_alloc_data_buf(struct scst_cmd *cmd) ++{ ++ scst_set_alloc_buf_time(cmd); ++} ++EXPORT_SYMBOL_GPL(scst_post_alloc_data_buf); ++ ++static inline void scst_schedule_tasklet(struct scst_cmd *cmd) ++{ ++ struct scst_percpu_info *i = &scst_percpu_infos[smp_processor_id()]; ++ unsigned long flags; ++ ++ if (atomic_read(&i->cpu_cmd_count) <= scst_max_tasklet_cmd) { ++ spin_lock_irqsave(&i->tasklet_lock, flags); ++ TRACE_DBG("Adding cmd %p to tasklet %d cmd list", cmd, ++ smp_processor_id()); ++ list_add_tail(&cmd->cmd_list_entry, &i->tasklet_cmd_list); ++ spin_unlock_irqrestore(&i->tasklet_lock, flags); ++ ++ tasklet_schedule(&i->tasklet); ++ } else { ++ spin_lock_irqsave(&cmd->cmd_threads->cmd_list_lock, flags); ++ TRACE_DBG("Too many tasklet commands (%d), adding cmd %p to " ++ "active cmd list", atomic_read(&i->cpu_cmd_count), cmd); ++ list_add_tail(&cmd->cmd_list_entry, ++ &cmd->cmd_threads->active_cmd_list); ++ wake_up(&cmd->cmd_threads->cmd_list_waitQ); ++ spin_unlock_irqrestore(&cmd->cmd_threads->cmd_list_lock, flags); ++ } ++ return; ++} ++ ++/* No locks */ ++static bool scst_check_blocked_dev(struct scst_cmd *cmd) ++{ ++ bool res; ++ struct scst_device *dev = cmd->dev; ++ ++ spin_lock_bh(&dev->dev_lock); ++ ++ dev->on_dev_cmd_count++; ++ cmd->dec_on_dev_needed = 1; ++ TRACE_DBG("New inc on_dev_count %d (cmd %p)", dev->on_dev_cmd_count, ++ cmd); ++ ++ scst_inc_pr_readers_count(cmd, true); ++ ++ if (unlikely(dev->block_count > 0) || ++ unlikely(dev->dev_double_ua_possible) || ++ unlikely(scst_is_serialized_cmd(cmd))) ++ res = __scst_check_blocked_dev(cmd); ++ else ++ res = false; ++ ++ if (unlikely(res)) { ++ /* Undo increments */ ++ dev->on_dev_cmd_count--; ++ cmd->dec_on_dev_needed = 0; ++ TRACE_DBG("New dec on_dev_count %d (cmd %p)", ++ dev->on_dev_cmd_count, cmd); ++ ++ scst_dec_pr_readers_count(cmd, true); ++ } ++ ++ spin_unlock_bh(&dev->dev_lock); ++ ++ return res; ++} ++ ++/* No locks */ ++static void scst_check_unblock_dev(struct scst_cmd *cmd) ++{ ++ struct scst_device *dev = cmd->dev; ++ ++ spin_lock_bh(&dev->dev_lock); ++ ++ if (likely(cmd->dec_on_dev_needed)) { ++ dev->on_dev_cmd_count--; ++ cmd->dec_on_dev_needed = 0; ++ TRACE_DBG("New dec on_dev_count %d (cmd %p)", ++ dev->on_dev_cmd_count, cmd); ++ } ++ ++ if (unlikely(cmd->dec_pr_readers_count_needed)) ++ scst_dec_pr_readers_count(cmd, true); ++ ++ if (unlikely(cmd->unblock_dev)) { ++ TRACE_MGMT_DBG("cmd %p (tag %llu): unblocking dev %s", cmd, ++ (long long unsigned int)cmd->tag, dev->virt_name); ++ cmd->unblock_dev = 0; ++ scst_unblock_dev(dev); ++ } else if (unlikely(dev->strictly_serialized_cmd_waiting)) { ++ if (dev->on_dev_cmd_count == 0) { ++ TRACE_MGMT_DBG("Strictly serialized cmd waiting: " ++ "unblocking dev %s", dev->virt_name); ++ scst_unblock_dev(dev); ++ } ++ } ++ ++ spin_unlock_bh(&dev->dev_lock); ++ return; ++} ++ ++/** ++ * scst_rx_cmd() - create new command ++ * @sess: SCST session ++ * @lun: LUN for the command ++ * @lun_len: length of the LUN in bytes ++ * @cdb: CDB of the command ++ * @cdb_len: length of the CDB in bytes ++ * @atomic: true, if current context is atomic ++ * ++ * Description: ++ * Creates new SCST command. Returns new command on success or ++ * NULL otherwise. ++ * ++ * Must not be called in parallel with scst_unregister_session() for the ++ * same session. ++ */ ++struct scst_cmd *scst_rx_cmd(struct scst_session *sess, ++ const uint8_t *lun, int lun_len, const uint8_t *cdb, ++ unsigned int cdb_len, int atomic) ++{ ++ struct scst_cmd *cmd; ++ ++ TRACE_ENTRY(); ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ if (unlikely(sess->shut_phase != SCST_SESS_SPH_READY)) { ++ PRINT_CRIT_ERROR("%s", ++ "New cmd while shutting down the session"); ++ BUG(); ++ } ++#endif ++ ++ cmd = scst_alloc_cmd(cdb, cdb_len, atomic ? GFP_ATOMIC : GFP_KERNEL); ++ if (unlikely(cmd == NULL)) ++ goto out; ++ ++ cmd->sess = sess; ++ cmd->tgt = sess->tgt; ++ cmd->tgtt = sess->tgt->tgtt; ++ ++ cmd->lun = scst_unpack_lun(lun, lun_len); ++ if (unlikely(cmd->lun == NO_SUCH_LUN)) ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_lun_not_supported)); ++ ++ TRACE_DBG("cmd %p, sess %p", cmd, sess); ++ scst_sess_get(sess); ++ ++out: ++ TRACE_EXIT(); ++ return cmd; ++} ++EXPORT_SYMBOL(scst_rx_cmd); ++ ++/* ++ * No locks, but might be on IRQ. Returns 0 on success, <0 if processing of ++ * this command should be stopped. ++ */ ++static int scst_init_cmd(struct scst_cmd *cmd, enum scst_exec_context *context) ++{ ++ int rc, res = 0; ++ ++ TRACE_ENTRY(); ++ ++ /* See the comment in scst_do_job_init() */ ++ if (unlikely(!list_empty(&scst_init_cmd_list))) { ++ TRACE_MGMT_DBG("%s", "init cmd list busy"); ++ goto out_redirect; ++ } ++ /* ++ * Memory barrier isn't necessary here, because CPU appears to ++ * be self-consistent and we don't care about the race, described ++ * in comment in scst_do_job_init(). ++ */ ++ ++ rc = __scst_init_cmd(cmd); ++ if (unlikely(rc > 0)) ++ goto out_redirect; ++ else if (unlikely(rc != 0)) { ++ res = 1; ++ goto out; ++ } ++ ++ EXTRACHECKS_BUG_ON(*context == SCST_CONTEXT_SAME); ++ ++#ifdef CONFIG_SCST_TEST_IO_IN_SIRQ ++ if (cmd->op_flags & SCST_TEST_IO_IN_SIRQ_ALLOWED) ++ goto out; ++#endif ++ ++ /* Small context optimization */ ++ if ((*context == SCST_CONTEXT_TASKLET) || ++ (*context == SCST_CONTEXT_DIRECT_ATOMIC)) { ++ /* ++ * If any data_direction not set, it's SCST_DATA_UNKNOWN, ++ * which is 0, so we can safely | them ++ */ ++ BUILD_BUG_ON(SCST_DATA_UNKNOWN != 0); ++ if ((cmd->data_direction | cmd->expected_data_direction) & SCST_DATA_WRITE) { ++ if (!test_bit(SCST_TGT_DEV_AFTER_INIT_WR_ATOMIC, ++ &cmd->tgt_dev->tgt_dev_flags)) ++ *context = SCST_CONTEXT_THREAD; ++ } else ++ *context = SCST_CONTEXT_THREAD; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_redirect: ++ if (cmd->preprocessing_only) { ++ /* ++ * Poor man solution for single threaded targets, where ++ * blocking receiver at least sometimes means blocking all. ++ * For instance, iSCSI target won't be able to receive ++ * Data-Out PDUs. ++ */ ++ BUG_ON(*context != SCST_CONTEXT_DIRECT); ++ scst_set_busy(cmd); ++ scst_set_cmd_abnormal_done_state(cmd); ++ res = 1; ++ /* Keep initiator away from too many BUSY commands */ ++ msleep(50); ++ } else { ++ unsigned long flags; ++ spin_lock_irqsave(&scst_init_lock, flags); ++ TRACE_MGMT_DBG("Adding cmd %p to init cmd list)", cmd); ++ list_add_tail(&cmd->cmd_list_entry, &scst_init_cmd_list); ++ if (test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags)) ++ scst_init_poll_cnt++; ++ spin_unlock_irqrestore(&scst_init_lock, flags); ++ wake_up(&scst_init_cmd_list_waitQ); ++ res = -1; ++ } ++ goto out; ++} ++ ++/** ++ * scst_cmd_init_done() - the command's initialization done ++ * @cmd: SCST command ++ * @pref_context: preferred command execution context ++ * ++ * Description: ++ * Notifies SCST that the driver finished its part of the command ++ * initialization, and the command is ready for execution. ++ * The second argument sets preferred command execution context. ++ * See SCST_CONTEXT_* constants for details. ++ * ++ * !!IMPORTANT!! ++ * ++ * If cmd->set_sn_on_restart_cmd not set, this function, as well as ++ * scst_cmd_init_stage1_done() and scst_restart_cmd(), must not be ++ * called simultaneously for the same session (more precisely, ++ * for the same session/LUN, i.e. tgt_dev), i.e. they must be ++ * somehow externally serialized. This is needed to have lock free fast ++ * path in scst_cmd_set_sn(). For majority of targets those functions are ++ * naturally serialized by the single source of commands. Only iSCSI ++ * immediate commands with multiple connections per session seems to be an ++ * exception. For it, some mutex/lock shall be used for the serialization. ++ */ ++void scst_cmd_init_done(struct scst_cmd *cmd, ++ enum scst_exec_context pref_context) ++{ ++ unsigned long flags; ++ struct scst_session *sess = cmd->sess; ++ int rc; ++ ++ TRACE_ENTRY(); ++ ++ scst_set_start_time(cmd); ++ ++ TRACE_DBG("Preferred context: %d (cmd %p)", pref_context, cmd); ++ TRACE(TRACE_SCSI, "tag=%llu, lun=%lld, CDB len=%d, queue_type=%x " ++ "(cmd %p, sess %p)", (long long unsigned int)cmd->tag, ++ (long long unsigned int)cmd->lun, cmd->cdb_len, ++ cmd->queue_type, cmd, sess); ++ PRINT_BUFF_FLAG(TRACE_SCSI|TRACE_RCV_BOT, "Receiving CDB", ++ cmd->cdb, cmd->cdb_len); ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ if (unlikely((in_irq() || irqs_disabled())) && ++ ((pref_context == SCST_CONTEXT_DIRECT) || ++ (pref_context == SCST_CONTEXT_DIRECT_ATOMIC))) { ++ PRINT_ERROR("Wrong context %d in IRQ from target %s, use " ++ "SCST_CONTEXT_THREAD instead", pref_context, ++ cmd->tgtt->name); ++ dump_stack(); ++ pref_context = SCST_CONTEXT_THREAD; ++ } ++#endif ++ ++ atomic_inc(&sess->sess_cmd_count); ++ ++ spin_lock_irqsave(&sess->sess_list_lock, flags); ++ ++ if (unlikely(sess->init_phase != SCST_SESS_IPH_READY)) { ++ /* ++ * We must always keep commands in the sess list from the ++ * very beginning, because otherwise they can be missed during ++ * TM processing. This check is needed because there might be ++ * old, i.e. deferred, commands and new, i.e. just coming, ones. ++ */ ++ if (cmd->sess_cmd_list_entry.next == NULL) ++ list_add_tail(&cmd->sess_cmd_list_entry, ++ &sess->sess_cmd_list); ++ switch (sess->init_phase) { ++ case SCST_SESS_IPH_SUCCESS: ++ break; ++ case SCST_SESS_IPH_INITING: ++ TRACE_DBG("Adding cmd %p to init deferred cmd list", ++ cmd); ++ list_add_tail(&cmd->cmd_list_entry, ++ &sess->init_deferred_cmd_list); ++ spin_unlock_irqrestore(&sess->sess_list_lock, flags); ++ goto out; ++ case SCST_SESS_IPH_FAILED: ++ spin_unlock_irqrestore(&sess->sess_list_lock, flags); ++ scst_set_busy(cmd); ++ goto set_state; ++ default: ++ BUG(); ++ } ++ } else ++ list_add_tail(&cmd->sess_cmd_list_entry, ++ &sess->sess_cmd_list); ++ ++ spin_unlock_irqrestore(&sess->sess_list_lock, flags); ++ ++ if (unlikely(cmd->queue_type >= SCST_CMD_QUEUE_ACA)) { ++ PRINT_ERROR("Unsupported queue type %d", cmd->queue_type); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_message)); ++ } ++ ++set_state: ++ if (unlikely(cmd->status != SAM_STAT_GOOD)) { ++ scst_set_cmd_abnormal_done_state(cmd); ++ goto active; ++ } ++ ++ /* ++ * Cmd must be inited here to preserve the order. In case if cmd ++ * already preliminary completed by target driver we need to init ++ * cmd anyway to find out in which format we should return sense. ++ */ ++ cmd->state = SCST_CMD_STATE_INIT; ++ rc = scst_init_cmd(cmd, &pref_context); ++ if (unlikely(rc < 0)) ++ goto out; ++ ++active: ++ /* Here cmd must not be in any cmd list, no locks */ ++ switch (pref_context) { ++ case SCST_CONTEXT_TASKLET: ++ scst_schedule_tasklet(cmd); ++ break; ++ ++ default: ++ PRINT_ERROR("Context %x is undefined, using the thread one", ++ pref_context); ++ /* go through */ ++ case SCST_CONTEXT_THREAD: ++ spin_lock_irqsave(&cmd->cmd_threads->cmd_list_lock, flags); ++ TRACE_DBG("Adding cmd %p to active cmd list", cmd); ++ if (unlikely(cmd->queue_type == SCST_CMD_QUEUE_HEAD_OF_QUEUE)) ++ list_add(&cmd->cmd_list_entry, ++ &cmd->cmd_threads->active_cmd_list); ++ else ++ list_add_tail(&cmd->cmd_list_entry, ++ &cmd->cmd_threads->active_cmd_list); ++ wake_up(&cmd->cmd_threads->cmd_list_waitQ); ++ spin_unlock_irqrestore(&cmd->cmd_threads->cmd_list_lock, flags); ++ break; ++ ++ case SCST_CONTEXT_DIRECT: ++ scst_process_active_cmd(cmd, false); ++ break; ++ ++ case SCST_CONTEXT_DIRECT_ATOMIC: ++ scst_process_active_cmd(cmd, true); ++ break; ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL(scst_cmd_init_done); ++ ++int scst_pre_parse(struct scst_cmd *cmd) ++{ ++ int res; ++ struct scst_device *dev = cmd->dev; ++ int rc; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * Expected transfer data supplied by the SCSI transport via the ++ * target driver are untrusted, so we prefer to fetch them from CDB. ++ * Additionally, not all transports support supplying the expected ++ * transfer data. ++ */ ++ ++ rc = scst_get_cdb_info(cmd); ++ if (unlikely(rc != 0)) { ++ if (rc > 0) { ++ PRINT_BUFFER("Failed CDB", cmd->cdb, cmd->cdb_len); ++ goto out_err; ++ } ++ ++ EXTRACHECKS_BUG_ON(cmd->op_flags & SCST_INFO_VALID); ++ ++ TRACE(TRACE_MINOR, "Unknown opcode 0x%02x for %s. " ++ "Should you update scst_scsi_op_table?", ++ cmd->cdb[0], dev->handler->name); ++ PRINT_BUFF_FLAG(TRACE_MINOR, "Failed CDB", cmd->cdb, ++ cmd->cdb_len); ++ } else ++ EXTRACHECKS_BUG_ON(!(cmd->op_flags & SCST_INFO_VALID)); ++ ++#ifdef CONFIG_SCST_STRICT_SERIALIZING ++ cmd->inc_expected_sn_on_done = 1; ++#else ++ cmd->inc_expected_sn_on_done = dev->handler->exec_sync || ++ (!dev->has_own_order_mgmt && ++ (dev->queue_alg == SCST_CONTR_MODE_QUEUE_ALG_RESTRICTED_REORDER || ++ cmd->queue_type == SCST_CMD_QUEUE_ORDERED)); ++#endif ++ ++ TRACE_DBG("op_name <%s> (cmd %p), direction=%d " ++ "(expected %d, set %s), bufflen=%d, out_bufflen=%d (expected " ++ "len %d, out expected len %d), flags=0x%x", cmd->op_name, cmd, ++ cmd->data_direction, cmd->expected_data_direction, ++ scst_cmd_is_expected_set(cmd) ? "yes" : "no", ++ cmd->bufflen, cmd->out_bufflen, cmd->expected_transfer_len, ++ cmd->expected_out_transfer_len, cmd->op_flags); ++ ++ res = 0; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_err: ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ scst_set_cmd_abnormal_done_state(cmd); ++ res = -1; ++ goto out; ++} ++ ++#ifndef CONFIG_SCST_USE_EXPECTED_VALUES ++static bool scst_is_allowed_to_mismatch_cmd(struct scst_cmd *cmd) ++{ ++ bool res = false; ++ ++ /* VERIFY commands with BYTCHK unset shouldn't fail here */ ++ if ((cmd->op_flags & SCST_VERIFY_BYTCHK_MISMATCH_ALLOWED) && ++ (cmd->cdb[1] & BYTCHK) == 0) { ++ res = true; ++ goto out; ++ } ++ ++ switch (cmd->cdb[0]) { ++ case TEST_UNIT_READY: ++ /* Crazy VMware people sometimes do TUR with READ direction */ ++ if ((cmd->expected_data_direction == SCST_DATA_READ) || ++ (cmd->expected_data_direction == SCST_DATA_NONE)) ++ res = true; ++ break; ++ } ++ ++out: ++ return res; ++} ++#endif ++ ++static int scst_parse_cmd(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_RES_CONT_SAME; ++ int state; ++ struct scst_device *dev = cmd->dev; ++ int orig_bufflen = cmd->bufflen; ++ ++ TRACE_ENTRY(); ++ ++ if (likely(!scst_is_cmd_fully_local(cmd))) { ++ if (unlikely(!dev->handler->parse_atomic && ++ scst_cmd_atomic(cmd))) { ++ /* ++ * It shouldn't be because of the SCST_TGT_DEV_AFTER_* ++ * optimization. ++ */ ++ TRACE_MGMT_DBG("Dev handler %s parse() needs thread " ++ "context, rescheduling", dev->handler->name); ++ res = SCST_CMD_STATE_RES_NEED_THREAD; ++ goto out; ++ } ++ ++ TRACE_DBG("Calling dev handler %s parse(%p)", ++ dev->handler->name, cmd); ++ TRACE_BUFF_FLAG(TRACE_SND_BOT, "Parsing: ", ++ cmd->cdb, cmd->cdb_len); ++ scst_set_cur_start(cmd); ++ state = dev->handler->parse(cmd); ++ /* Caution: cmd can be already dead here */ ++ TRACE_DBG("Dev handler %s parse() returned %d", ++ dev->handler->name, state); ++ ++ switch (state) { ++ case SCST_CMD_STATE_NEED_THREAD_CTX: ++ scst_set_parse_time(cmd); ++ TRACE_DBG("Dev handler %s parse() requested thread " ++ "context, rescheduling", dev->handler->name); ++ res = SCST_CMD_STATE_RES_NEED_THREAD; ++ goto out; ++ ++ case SCST_CMD_STATE_STOP: ++ TRACE_DBG("Dev handler %s parse() requested stop " ++ "processing", dev->handler->name); ++ res = SCST_CMD_STATE_RES_CONT_NEXT; ++ goto out; ++ } ++ ++ scst_set_parse_time(cmd); ++ ++ if (state == SCST_CMD_STATE_DEFAULT) ++ state = SCST_CMD_STATE_PREPARE_SPACE; ++ } else ++ state = SCST_CMD_STATE_PREPARE_SPACE; ++ ++ if (unlikely(state == SCST_CMD_STATE_PRE_XMIT_RESP)) ++ goto set_res; ++ ++ if (unlikely(!(cmd->op_flags & SCST_INFO_VALID))) { ++#ifdef CONFIG_SCST_USE_EXPECTED_VALUES ++ if (scst_cmd_is_expected_set(cmd)) { ++ TRACE(TRACE_MINOR, "Using initiator supplied values: " ++ "direction %d, transfer_len %d/%d", ++ cmd->expected_data_direction, ++ cmd->expected_transfer_len, ++ cmd->expected_out_transfer_len); ++ cmd->data_direction = cmd->expected_data_direction; ++ cmd->bufflen = cmd->expected_transfer_len; ++ cmd->out_bufflen = cmd->expected_out_transfer_len; ++ } else { ++ PRINT_ERROR("Unknown opcode 0x%02x for %s and " ++ "target %s not supplied expected values", ++ cmd->cdb[0], dev->handler->name, cmd->tgtt->name); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_opcode)); ++ goto out_done; ++ } ++#else ++ /* ++ * Let's ignore reporting T10/04-262r7 16-byte and 12-byte ATA ++ * pass-thru commands to not pollute logs (udev(?) checks them ++ * for some reason). If somebody has their description, please, ++ * update scst_scsi_op_table. ++ */ ++ if ((cmd->cdb[0] != 0x85) && (cmd->cdb[0] != 0xa1)) ++ PRINT_ERROR("Refusing unknown opcode %x", cmd->cdb[0]); ++ else ++ TRACE(TRACE_MINOR, "Refusing unknown opcode %x", ++ cmd->cdb[0]); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_opcode)); ++ goto out_done; ++#endif ++ } ++ ++ if (unlikely(cmd->cdb_len == 0)) { ++ PRINT_ERROR("Unable to get CDB length for " ++ "opcode 0x%02x. Returning INVALID " ++ "OPCODE", cmd->cdb[0]); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_opcode)); ++ goto out_done; ++ } ++ ++ EXTRACHECKS_BUG_ON(cmd->cdb_len == 0); ++ ++ TRACE(TRACE_SCSI, "op_name <%s> (cmd %p), direction=%d " ++ "(expected %d, set %s), bufflen=%d, out_bufflen=%d, (expected " ++ "len %d, out expected len %d), flags=%x", cmd->op_name, cmd, ++ cmd->data_direction, cmd->expected_data_direction, ++ scst_cmd_is_expected_set(cmd) ? "yes" : "no", ++ cmd->bufflen, cmd->out_bufflen, cmd->expected_transfer_len, ++ cmd->expected_out_transfer_len, cmd->op_flags); ++ ++ if (unlikely((cmd->op_flags & SCST_UNKNOWN_LENGTH) != 0)) { ++ if (scst_cmd_is_expected_set(cmd)) { ++ /* ++ * Command data length can't be easily ++ * determined from the CDB. ToDo, all such ++ * commands processing should be fixed. Until ++ * it's done, get the length from the supplied ++ * expected value, but limit it to some ++ * reasonable value (15MB). ++ */ ++ cmd->bufflen = min(cmd->expected_transfer_len, ++ 15*1024*1024); ++ if (cmd->data_direction == SCST_DATA_BIDI) ++ cmd->out_bufflen = min(cmd->expected_out_transfer_len, ++ 15*1024*1024); ++ cmd->op_flags &= ~SCST_UNKNOWN_LENGTH; ++ } else { ++ PRINT_ERROR("Unknown data transfer length for opcode " ++ "0x%x (handler %s, target %s)", cmd->cdb[0], ++ dev->handler->name, cmd->tgtt->name); ++ PRINT_BUFFER("Failed CDB", cmd->cdb, cmd->cdb_len); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_message)); ++ goto out_done; ++ } ++ } ++ ++ if (unlikely(cmd->cdb[cmd->cdb_len - 1] & CONTROL_BYTE_NACA_BIT)) { ++ PRINT_ERROR("NACA bit in control byte CDB is not supported " ++ "(opcode 0x%02x)", cmd->cdb[0]); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out_done; ++ } ++ ++ if (unlikely(cmd->cdb[cmd->cdb_len - 1] & CONTROL_BYTE_LINK_BIT)) { ++ PRINT_ERROR("Linked commands are not supported " ++ "(opcode 0x%02x)", cmd->cdb[0]); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out_done; ++ } ++ ++ if (cmd->dh_data_buf_alloced && ++ unlikely((orig_bufflen > cmd->bufflen))) { ++ PRINT_ERROR("Dev handler supplied data buffer (size %d), " ++ "is less, than required (size %d)", cmd->bufflen, ++ orig_bufflen); ++ PRINT_BUFFER("Failed CDB", cmd->cdb, cmd->cdb_len); ++ goto out_hw_error; ++ } ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ if ((cmd->bufflen != 0) && ++ ((cmd->data_direction == SCST_DATA_NONE) || ++ ((cmd->sg == NULL) && (state > SCST_CMD_STATE_PREPARE_SPACE)))) { ++ PRINT_ERROR("Dev handler %s parse() returned " ++ "invalid cmd data_direction %d, bufflen %d, state %d " ++ "or sg %p (opcode 0x%x)", dev->handler->name, ++ cmd->data_direction, cmd->bufflen, state, cmd->sg, ++ cmd->cdb[0]); ++ PRINT_BUFFER("Failed CDB", cmd->cdb, cmd->cdb_len); ++ goto out_hw_error; ++ } ++#endif ++ ++ if (scst_cmd_is_expected_set(cmd)) { ++#ifdef CONFIG_SCST_USE_EXPECTED_VALUES ++ if (unlikely((cmd->data_direction != cmd->expected_data_direction) || ++ (cmd->bufflen != cmd->expected_transfer_len) || ++ (cmd->out_bufflen != cmd->expected_out_transfer_len))) { ++ TRACE(TRACE_MINOR, "Expected values don't match " ++ "decoded ones: data_direction %d, " ++ "expected_data_direction %d, " ++ "bufflen %d, expected_transfer_len %d, " ++ "out_bufflen %d, expected_out_transfer_len %d", ++ cmd->data_direction, ++ cmd->expected_data_direction, ++ cmd->bufflen, cmd->expected_transfer_len, ++ cmd->out_bufflen, cmd->expected_out_transfer_len); ++ PRINT_BUFF_FLAG(TRACE_MINOR, "Suspicious CDB", ++ cmd->cdb, cmd->cdb_len); ++ cmd->data_direction = cmd->expected_data_direction; ++ cmd->bufflen = cmd->expected_transfer_len; ++ cmd->out_bufflen = cmd->expected_out_transfer_len; ++ cmd->resid_possible = 1; ++ } ++#else ++ if (unlikely(cmd->data_direction != ++ cmd->expected_data_direction)) { ++ if (((cmd->expected_data_direction != SCST_DATA_NONE) || ++ (cmd->bufflen != 0)) && ++ !scst_is_allowed_to_mismatch_cmd(cmd)) { ++ PRINT_ERROR("Expected data direction %d for " ++ "opcode 0x%02x (handler %s, target %s) " ++ "doesn't match decoded value %d", ++ cmd->expected_data_direction, ++ cmd->cdb[0], dev->handler->name, ++ cmd->tgtt->name, cmd->data_direction); ++ PRINT_BUFFER("Failed CDB", cmd->cdb, ++ cmd->cdb_len); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_message)); ++ goto out_done; ++ } ++ } ++ if (unlikely(cmd->bufflen != cmd->expected_transfer_len)) { ++ TRACE(TRACE_MINOR, "Warning: expected " ++ "transfer length %d for opcode 0x%02x " ++ "(handler %s, target %s) doesn't match " ++ "decoded value %d", ++ cmd->expected_transfer_len, cmd->cdb[0], ++ dev->handler->name, cmd->tgtt->name, ++ cmd->bufflen); ++ PRINT_BUFF_FLAG(TRACE_MINOR, "Suspicious CDB", ++ cmd->cdb, cmd->cdb_len); ++ if ((cmd->data_direction & SCST_DATA_READ) || ++ (cmd->data_direction & SCST_DATA_WRITE)) ++ cmd->resid_possible = 1; ++ } ++ if (unlikely(cmd->out_bufflen != cmd->expected_out_transfer_len)) { ++ TRACE(TRACE_MINOR, "Warning: expected bidirectional OUT " ++ "transfer length %d for opcode 0x%02x " ++ "(handler %s, target %s) doesn't match " ++ "decoded value %d", ++ cmd->expected_out_transfer_len, cmd->cdb[0], ++ dev->handler->name, cmd->tgtt->name, ++ cmd->out_bufflen); ++ PRINT_BUFF_FLAG(TRACE_MINOR, "Suspicious CDB", ++ cmd->cdb, cmd->cdb_len); ++ cmd->resid_possible = 1; ++ } ++#endif ++ } ++ ++ if (unlikely(cmd->data_direction == SCST_DATA_UNKNOWN)) { ++ PRINT_ERROR("Unknown data direction. Opcode 0x%x, handler %s, " ++ "target %s", cmd->cdb[0], dev->handler->name, ++ cmd->tgtt->name); ++ PRINT_BUFFER("Failed CDB", cmd->cdb, cmd->cdb_len); ++ goto out_hw_error; ++ } ++ ++set_res: ++ if (cmd->data_len == -1) ++ cmd->data_len = cmd->bufflen; ++ ++ if (cmd->bufflen == 0) { ++ /* ++ * According to SPC bufflen 0 for data transfer commands isn't ++ * an error, so we need to fix the transfer direction. ++ */ ++ cmd->data_direction = SCST_DATA_NONE; ++ } ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ switch (state) { ++ case SCST_CMD_STATE_PREPARE_SPACE: ++ case SCST_CMD_STATE_PARSE: ++ case SCST_CMD_STATE_RDY_TO_XFER: ++ case SCST_CMD_STATE_TGT_PRE_EXEC: ++ case SCST_CMD_STATE_SEND_FOR_EXEC: ++ case SCST_CMD_STATE_START_EXEC: ++ case SCST_CMD_STATE_LOCAL_EXEC: ++ case SCST_CMD_STATE_REAL_EXEC: ++ case SCST_CMD_STATE_PRE_DEV_DONE: ++ case SCST_CMD_STATE_DEV_DONE: ++ case SCST_CMD_STATE_PRE_XMIT_RESP: ++ case SCST_CMD_STATE_XMIT_RESP: ++ case SCST_CMD_STATE_FINISHED: ++ case SCST_CMD_STATE_FINISHED_INTERNAL: ++#endif ++ cmd->state = state; ++ res = SCST_CMD_STATE_RES_CONT_SAME; ++#ifdef CONFIG_SCST_EXTRACHECKS ++ break; ++ ++ default: ++ if (state >= 0) { ++ PRINT_ERROR("Dev handler %s parse() returned " ++ "invalid cmd state %d (opcode %d)", ++ dev->handler->name, state, cmd->cdb[0]); ++ } else { ++ PRINT_ERROR("Dev handler %s parse() returned " ++ "error %d (opcode %d)", dev->handler->name, ++ state, cmd->cdb[0]); ++ } ++ goto out_hw_error; ++ } ++#endif ++ ++ if (cmd->resp_data_len == -1) { ++ if (cmd->data_direction & SCST_DATA_READ) ++ cmd->resp_data_len = cmd->bufflen; ++ else ++ cmd->resp_data_len = 0; ++ } ++ ++ /* We already completed (with an error) */ ++ if (unlikely(cmd->completed)) ++ goto out_done; ++ ++#ifndef CONFIG_SCST_TEST_IO_IN_SIRQ ++ /* ++ * We can't allow atomic command on the exec stages. It shouldn't ++ * be because of the SCST_TGT_DEV_AFTER_* optimization, but during ++ * parsing data_direction can change, so we need to recheck. ++ */ ++ if (unlikely(scst_cmd_atomic(cmd) && ++ !(cmd->data_direction & SCST_DATA_WRITE))) { ++ TRACE_DBG_FLAG(TRACE_DEBUG|TRACE_MINOR, "Atomic context and " ++ "non-WRITE data direction, rescheduling (cmd %p)", cmd); ++ res = SCST_CMD_STATE_RES_NEED_THREAD; ++ goto out; ++ } ++#endif ++ ++out: ++ TRACE_EXIT_HRES(res); ++ return res; ++ ++out_hw_error: ++ /* dev_done() will be called as part of the regular cmd's finish */ ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ ++out_done: ++ scst_set_cmd_abnormal_done_state(cmd); ++ res = SCST_CMD_STATE_RES_CONT_SAME; ++ goto out; ++} ++ ++static void scst_set_write_len(struct scst_cmd *cmd) ++{ ++ TRACE_ENTRY(); ++ ++ EXTRACHECKS_BUG_ON(!(cmd->data_direction & SCST_DATA_WRITE)); ++ ++ if (cmd->data_direction & SCST_DATA_READ) { ++ cmd->write_len = cmd->out_bufflen; ++ cmd->write_sg = &cmd->out_sg; ++ cmd->write_sg_cnt = &cmd->out_sg_cnt; ++ } else { ++ cmd->write_len = cmd->bufflen; ++ /* write_sg and write_sg_cnt already initialized correctly */ ++ } ++ ++ TRACE_MEM("cmd %p, write_len %d, write_sg %p, write_sg_cnt %d, " ++ "resid_possible %d", cmd, cmd->write_len, *cmd->write_sg, ++ *cmd->write_sg_cnt, cmd->resid_possible); ++ ++ if (unlikely(cmd->resid_possible)) { ++ if (cmd->data_direction & SCST_DATA_READ) { ++ cmd->write_len = min(cmd->out_bufflen, ++ cmd->expected_out_transfer_len); ++ if (cmd->write_len == cmd->out_bufflen) ++ goto out; ++ } else { ++ cmd->write_len = min(cmd->bufflen, ++ cmd->expected_transfer_len); ++ if (cmd->write_len == cmd->bufflen) ++ goto out; ++ } ++ scst_limit_sg_write_len(cmd); ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static int scst_prepare_space(struct scst_cmd *cmd) ++{ ++ int r = 0, res = SCST_CMD_STATE_RES_CONT_SAME; ++ struct scst_device *dev = cmd->dev; ++ ++ TRACE_ENTRY(); ++ ++ if (cmd->data_direction == SCST_DATA_NONE) ++ goto done; ++ ++ if (likely(!scst_is_cmd_fully_local(cmd)) && ++ (dev->handler->alloc_data_buf != NULL)) { ++ int state; ++ ++ if (unlikely(!dev->handler->alloc_data_buf_atomic && ++ scst_cmd_atomic(cmd))) { ++ /* ++ * It shouldn't be because of the SCST_TGT_DEV_AFTER_* ++ * optimization. ++ */ ++ TRACE_MGMT_DBG("Dev handler %s alloc_data_buf() needs " ++ "thread context, rescheduling", ++ dev->handler->name); ++ res = SCST_CMD_STATE_RES_NEED_THREAD; ++ goto out; ++ } ++ ++ TRACE_DBG("Calling dev handler %s alloc_data_buf(%p)", ++ dev->handler->name, cmd); ++ scst_set_cur_start(cmd); ++ state = dev->handler->alloc_data_buf(cmd); ++ /* Caution: cmd can be already dead here */ ++ TRACE_DBG("Dev handler %s alloc_data_buf() returned %d", ++ dev->handler->name, state); ++ ++ switch (state) { ++ case SCST_CMD_STATE_NEED_THREAD_CTX: ++ scst_set_alloc_buf_time(cmd); ++ TRACE_DBG("Dev handler %s alloc_data_buf() requested " ++ "thread context, rescheduling", ++ dev->handler->name); ++ res = SCST_CMD_STATE_RES_NEED_THREAD; ++ goto out; ++ ++ case SCST_CMD_STATE_STOP: ++ TRACE_DBG("Dev handler %s alloc_data_buf() requested " ++ "stop processing", dev->handler->name); ++ res = SCST_CMD_STATE_RES_CONT_NEXT; ++ goto out; ++ } ++ ++ scst_set_alloc_buf_time(cmd); ++ ++ if (unlikely(state != SCST_CMD_STATE_DEFAULT)) { ++ cmd->state = state; ++ goto out; ++ } ++ } ++ ++ if (cmd->tgt_need_alloc_data_buf) { ++ int orig_bufflen = cmd->bufflen; ++ ++ TRACE_MEM("Custom tgt data buf allocation requested (cmd %p)", ++ cmd); ++ ++ scst_set_cur_start(cmd); ++ r = cmd->tgtt->alloc_data_buf(cmd); ++ scst_set_alloc_buf_time(cmd); ++ ++ if (r > 0) ++ goto alloc; ++ else if (r == 0) { ++ if (unlikely(cmd->bufflen == 0)) { ++ /* See comment in scst_alloc_space() */ ++ if (cmd->sg == NULL) ++ goto alloc; ++ } ++ ++ cmd->tgt_data_buf_alloced = 1; ++ ++ if (unlikely(orig_bufflen < cmd->bufflen)) { ++ PRINT_ERROR("Target driver allocated data " ++ "buffer (size %d), is less, than " ++ "required (size %d)", orig_bufflen, ++ cmd->bufflen); ++ goto out_error; ++ } ++ TRACE_MEM("tgt_data_buf_alloced (cmd %p)", cmd); ++ } else ++ goto check; ++ } ++ ++alloc: ++ if (!cmd->tgt_data_buf_alloced && !cmd->dh_data_buf_alloced) { ++ r = scst_alloc_space(cmd); ++ } else if (cmd->dh_data_buf_alloced && !cmd->tgt_data_buf_alloced) { ++ TRACE_MEM("dh_data_buf_alloced set (cmd %p)", cmd); ++ r = 0; ++ } else if (cmd->tgt_data_buf_alloced && !cmd->dh_data_buf_alloced) { ++ TRACE_MEM("tgt_data_buf_alloced set (cmd %p)", cmd); ++ cmd->sg = cmd->tgt_sg; ++ cmd->sg_cnt = cmd->tgt_sg_cnt; ++ cmd->out_sg = cmd->tgt_out_sg; ++ cmd->out_sg_cnt = cmd->tgt_out_sg_cnt; ++ r = 0; ++ } else { ++ TRACE_MEM("Both *_data_buf_alloced set (cmd %p, sg %p, " ++ "sg_cnt %d, tgt_sg %p, tgt_sg_cnt %d)", cmd, cmd->sg, ++ cmd->sg_cnt, cmd->tgt_sg, cmd->tgt_sg_cnt); ++ r = 0; ++ } ++ ++check: ++ if (r != 0) { ++ if (scst_cmd_atomic(cmd)) { ++ TRACE_MEM("%s", "Atomic memory allocation failed, " ++ "rescheduling to the thread"); ++ res = SCST_CMD_STATE_RES_NEED_THREAD; ++ goto out; ++ } else ++ goto out_no_space; ++ } ++ ++done: ++ if (cmd->preprocessing_only) { ++ cmd->state = SCST_CMD_STATE_PREPROCESSING_DONE; ++ if (cmd->data_direction & SCST_DATA_WRITE) ++ scst_set_write_len(cmd); ++ } else if (cmd->data_direction & SCST_DATA_WRITE) { ++ cmd->state = SCST_CMD_STATE_RDY_TO_XFER; ++ scst_set_write_len(cmd); ++ } else ++ cmd->state = SCST_CMD_STATE_TGT_PRE_EXEC; ++ ++out: ++ TRACE_EXIT_HRES(res); ++ return res; ++ ++out_no_space: ++ TRACE(TRACE_OUT_OF_MEM, "Unable to allocate or build requested buffer " ++ "(size %d), sending BUSY or QUEUE FULL status", cmd->bufflen); ++ scst_set_busy(cmd); ++ scst_set_cmd_abnormal_done_state(cmd); ++ res = SCST_CMD_STATE_RES_CONT_SAME; ++ goto out; ++ ++out_error: ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ scst_set_cmd_abnormal_done_state(cmd); ++ res = SCST_CMD_STATE_RES_CONT_SAME; ++ goto out; ++} ++ ++static int scst_preprocessing_done(struct scst_cmd *cmd) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ EXTRACHECKS_BUG_ON(!cmd->preprocessing_only); ++ ++ cmd->preprocessing_only = 0; ++ ++ res = SCST_CMD_STATE_RES_CONT_NEXT; ++ cmd->state = SCST_CMD_STATE_PREPROCESSING_DONE_CALLED; ++ ++ TRACE_DBG("Calling preprocessing_done(cmd %p)", cmd); ++ scst_set_cur_start(cmd); ++ cmd->tgtt->preprocessing_done(cmd); ++ TRACE_DBG("%s", "preprocessing_done() returned"); ++ ++ TRACE_EXIT_HRES(res); ++ return res; ++} ++ ++/** ++ * scst_restart_cmd() - restart execution of the command ++ * @cmd: SCST commands ++ * @status: completion status ++ * @pref_context: preferred command execution context ++ * ++ * Description: ++ * Notifies SCST that the driver finished its part of the command's ++ * preprocessing and it is ready for further processing. ++ * ++ * The second argument sets completion status ++ * (see SCST_PREPROCESS_STATUS_* constants for details) ++ * ++ * See also comment for scst_cmd_init_done() for the serialization ++ * requirements. ++ */ ++void scst_restart_cmd(struct scst_cmd *cmd, int status, ++ enum scst_exec_context pref_context) ++{ ++ TRACE_ENTRY(); ++ ++ scst_set_restart_waiting_time(cmd); ++ ++ TRACE_DBG("Preferred context: %d", pref_context); ++ TRACE_DBG("tag=%llu, status=%#x", ++ (long long unsigned int)scst_cmd_get_tag(cmd), ++ status); ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ if ((in_irq() || irqs_disabled()) && ++ ((pref_context == SCST_CONTEXT_DIRECT) || ++ (pref_context == SCST_CONTEXT_DIRECT_ATOMIC))) { ++ PRINT_ERROR("Wrong context %d in IRQ from target %s, use " ++ "SCST_CONTEXT_THREAD instead", pref_context, ++ cmd->tgtt->name); ++ dump_stack(); ++ pref_context = SCST_CONTEXT_THREAD; ++ } ++#endif ++ ++ switch (status) { ++ case SCST_PREPROCESS_STATUS_SUCCESS: ++ if (cmd->data_direction & SCST_DATA_WRITE) ++ cmd->state = SCST_CMD_STATE_RDY_TO_XFER; ++ else ++ cmd->state = SCST_CMD_STATE_TGT_PRE_EXEC; ++ if (cmd->set_sn_on_restart_cmd) ++ scst_cmd_set_sn(cmd); ++#ifdef CONFIG_SCST_TEST_IO_IN_SIRQ ++ if (cmd->op_flags & SCST_TEST_IO_IN_SIRQ_ALLOWED) ++ break; ++#endif ++ /* Small context optimization */ ++ if ((pref_context == SCST_CONTEXT_TASKLET) || ++ (pref_context == SCST_CONTEXT_DIRECT_ATOMIC) || ++ ((pref_context == SCST_CONTEXT_SAME) && ++ scst_cmd_atomic(cmd))) ++ pref_context = SCST_CONTEXT_THREAD; ++ break; ++ ++ case SCST_PREPROCESS_STATUS_ERROR_SENSE_SET: ++ scst_set_cmd_abnormal_done_state(cmd); ++ pref_context = SCST_CONTEXT_THREAD; ++ break; ++ ++ case SCST_PREPROCESS_STATUS_ERROR_FATAL: ++ set_bit(SCST_CMD_NO_RESP, &cmd->cmd_flags); ++ /* go through */ ++ case SCST_PREPROCESS_STATUS_ERROR: ++ if (cmd->sense != NULL) ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ scst_set_cmd_abnormal_done_state(cmd); ++ pref_context = SCST_CONTEXT_THREAD; ++ break; ++ ++ default: ++ PRINT_ERROR("%s() received unknown status %x", __func__, ++ status); ++ scst_set_cmd_abnormal_done_state(cmd); ++ pref_context = SCST_CONTEXT_THREAD; ++ break; ++ } ++ ++ scst_process_redirect_cmd(cmd, pref_context, 1); ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL(scst_restart_cmd); ++ ++static int scst_rdy_to_xfer(struct scst_cmd *cmd) ++{ ++ int res, rc; ++ struct scst_tgt_template *tgtt = cmd->tgtt; ++ ++ TRACE_ENTRY(); ++ ++ if (unlikely(test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags))) { ++ TRACE_MGMT_DBG("ABORTED set, aborting cmd %p", cmd); ++ goto out_dev_done; ++ } ++ ++ if ((tgtt->rdy_to_xfer == NULL) || unlikely(cmd->internal)) { ++ cmd->state = SCST_CMD_STATE_TGT_PRE_EXEC; ++#ifndef CONFIG_SCST_TEST_IO_IN_SIRQ ++ /* We can't allow atomic command on the exec stages */ ++ if (scst_cmd_atomic(cmd)) { ++ TRACE_DBG("NULL rdy_to_xfer() and atomic context, " ++ "rescheduling (cmd %p)", cmd); ++ res = SCST_CMD_STATE_RES_NEED_THREAD; ++ } else ++#endif ++ res = SCST_CMD_STATE_RES_CONT_SAME; ++ goto out; ++ } ++ ++ if (unlikely(!tgtt->rdy_to_xfer_atomic && scst_cmd_atomic(cmd))) { ++ /* ++ * It shouldn't be because of the SCST_TGT_DEV_AFTER_* ++ * optimization. ++ */ ++ TRACE_MGMT_DBG("Target driver %s rdy_to_xfer() needs thread " ++ "context, rescheduling", tgtt->name); ++ res = SCST_CMD_STATE_RES_NEED_THREAD; ++ goto out; ++ } ++ ++ while (1) { ++ int finished_cmds = atomic_read(&cmd->tgt->finished_cmds); ++ ++ res = SCST_CMD_STATE_RES_CONT_NEXT; ++ cmd->state = SCST_CMD_STATE_DATA_WAIT; ++ ++ if (tgtt->on_hw_pending_cmd_timeout != NULL) { ++ struct scst_session *sess = cmd->sess; ++ cmd->hw_pending_start = jiffies; ++ cmd->cmd_hw_pending = 1; ++ if (!test_bit(SCST_SESS_HW_PENDING_WORK_SCHEDULED, &sess->sess_aflags)) { ++ TRACE_DBG("Sched HW pending work for sess %p " ++ "(max time %d)", sess, ++ tgtt->max_hw_pending_time); ++ set_bit(SCST_SESS_HW_PENDING_WORK_SCHEDULED, ++ &sess->sess_aflags); ++ schedule_delayed_work(&sess->hw_pending_work, ++ tgtt->max_hw_pending_time * HZ); ++ } ++ } ++ ++ scst_set_cur_start(cmd); ++ ++ TRACE_DBG("Calling rdy_to_xfer(%p)", cmd); ++#ifdef CONFIG_SCST_DEBUG_RETRY ++ if (((scst_random() % 100) == 75)) ++ rc = SCST_TGT_RES_QUEUE_FULL; ++ else ++#endif ++ rc = tgtt->rdy_to_xfer(cmd); ++ TRACE_DBG("rdy_to_xfer() returned %d", rc); ++ ++ if (likely(rc == SCST_TGT_RES_SUCCESS)) ++ goto out; ++ ++ scst_set_rdy_to_xfer_time(cmd); ++ ++ cmd->cmd_hw_pending = 0; ++ ++ /* Restore the previous state */ ++ cmd->state = SCST_CMD_STATE_RDY_TO_XFER; ++ ++ switch (rc) { ++ case SCST_TGT_RES_QUEUE_FULL: ++ if (scst_queue_retry_cmd(cmd, finished_cmds) == 0) ++ break; ++ else ++ continue; ++ ++ case SCST_TGT_RES_NEED_THREAD_CTX: ++ TRACE_DBG("Target driver %s " ++ "rdy_to_xfer() requested thread " ++ "context, rescheduling", tgtt->name); ++ res = SCST_CMD_STATE_RES_NEED_THREAD; ++ goto out; ++ ++ default: ++ goto out_error_rc; ++ } ++ break; ++ } ++ ++out: ++ TRACE_EXIT_HRES(res); ++ return res; ++ ++out_error_rc: ++ if (rc == SCST_TGT_RES_FATAL_ERROR) { ++ PRINT_ERROR("Target driver %s rdy_to_xfer() returned " ++ "fatal error", tgtt->name); ++ } else { ++ PRINT_ERROR("Target driver %s rdy_to_xfer() returned invalid " ++ "value %d", tgtt->name, rc); ++ } ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ ++out_dev_done: ++ scst_set_cmd_abnormal_done_state(cmd); ++ res = SCST_CMD_STATE_RES_CONT_SAME; ++ goto out; ++} ++ ++/* No locks, but might be in IRQ */ ++static void scst_process_redirect_cmd(struct scst_cmd *cmd, ++ enum scst_exec_context context, int check_retries) ++{ ++ struct scst_tgt *tgt = cmd->tgt; ++ unsigned long flags; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Context: %x", context); ++ ++ if (check_retries) ++ scst_check_retries(tgt); ++ ++ if (context == SCST_CONTEXT_SAME) ++ context = scst_cmd_atomic(cmd) ? SCST_CONTEXT_DIRECT_ATOMIC : ++ SCST_CONTEXT_DIRECT; ++ ++ switch (context) { ++ case SCST_CONTEXT_DIRECT_ATOMIC: ++ scst_process_active_cmd(cmd, true); ++ break; ++ ++ case SCST_CONTEXT_DIRECT: ++ scst_process_active_cmd(cmd, false); ++ break; ++ ++ case SCST_CONTEXT_TASKLET: ++ scst_schedule_tasklet(cmd); ++ break; ++ ++ default: ++ PRINT_ERROR("Context %x is unknown, using the thread one", ++ context); ++ /* go through */ ++ case SCST_CONTEXT_THREAD: ++ spin_lock_irqsave(&cmd->cmd_threads->cmd_list_lock, flags); ++ TRACE_DBG("Adding cmd %p to active cmd list", cmd); ++ if (unlikely(cmd->queue_type == SCST_CMD_QUEUE_HEAD_OF_QUEUE)) ++ list_add(&cmd->cmd_list_entry, ++ &cmd->cmd_threads->active_cmd_list); ++ else ++ list_add_tail(&cmd->cmd_list_entry, ++ &cmd->cmd_threads->active_cmd_list); ++ wake_up(&cmd->cmd_threads->cmd_list_waitQ); ++ spin_unlock_irqrestore(&cmd->cmd_threads->cmd_list_lock, flags); ++ break; ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ * scst_rx_data() - the command's data received ++ * @cmd: SCST commands ++ * @status: data receiving completion status ++ * @pref_context: preferred command execution context ++ * ++ * Description: ++ * Notifies SCST that the driver received all the necessary data ++ * and the command is ready for further processing. ++ * ++ * The second argument sets data receiving completion status ++ * (see SCST_RX_STATUS_* constants for details) ++ */ ++void scst_rx_data(struct scst_cmd *cmd, int status, ++ enum scst_exec_context pref_context) ++{ ++ TRACE_ENTRY(); ++ ++ scst_set_rdy_to_xfer_time(cmd); ++ ++ TRACE_DBG("Preferred context: %d", pref_context); ++ TRACE(TRACE_SCSI, "cmd %p, status %#x", cmd, status); ++ ++ cmd->cmd_hw_pending = 0; ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ if ((in_irq() || irqs_disabled()) && ++ ((pref_context == SCST_CONTEXT_DIRECT) || ++ (pref_context == SCST_CONTEXT_DIRECT_ATOMIC))) { ++ PRINT_ERROR("Wrong context %d in IRQ from target %s, use " ++ "SCST_CONTEXT_THREAD instead", pref_context, ++ cmd->tgtt->name); ++ dump_stack(); ++ pref_context = SCST_CONTEXT_THREAD; ++ } ++#endif ++ ++ switch (status) { ++ case SCST_RX_STATUS_SUCCESS: ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ if (trace_flag & TRACE_RCV_BOT) { ++ int i, j; ++ struct scatterlist *sg; ++ if (cmd->out_sg != NULL) ++ sg = cmd->out_sg; ++ else if (cmd->tgt_out_sg != NULL) ++ sg = cmd->tgt_out_sg; ++ else if (cmd->tgt_sg != NULL) ++ sg = cmd->tgt_sg; ++ else ++ sg = cmd->sg; ++ if (sg != NULL) { ++ TRACE_RECV_BOT("RX data for cmd %p " ++ "(sg_cnt %d, sg %p, sg[0].page %p)", ++ cmd, cmd->tgt_sg_cnt, sg, ++ (void *)sg_page(&sg[0])); ++ for (i = 0, j = 0; i < cmd->tgt_sg_cnt; ++i, ++j) { ++ if (unlikely(sg_is_chain(&sg[j]))) { ++ sg = sg_chain_ptr(&sg[j]); ++ j = 0; ++ } ++ PRINT_BUFF_FLAG(TRACE_RCV_BOT, "RX sg", ++ sg_virt(&sg[j]), sg[j].length); ++ } ++ } ++ } ++#endif ++ cmd->state = SCST_CMD_STATE_TGT_PRE_EXEC; ++ ++#ifdef CONFIG_SCST_TEST_IO_IN_SIRQ ++ if (cmd->op_flags & SCST_TEST_IO_IN_SIRQ_ALLOWED) ++ break; ++#endif ++ ++ /* Small context optimization */ ++ if ((pref_context == SCST_CONTEXT_TASKLET) || ++ (pref_context == SCST_CONTEXT_DIRECT_ATOMIC) || ++ ((pref_context == SCST_CONTEXT_SAME) && ++ scst_cmd_atomic(cmd))) ++ pref_context = SCST_CONTEXT_THREAD; ++ break; ++ ++ case SCST_RX_STATUS_ERROR_SENSE_SET: ++ scst_set_cmd_abnormal_done_state(cmd); ++ pref_context = SCST_CONTEXT_THREAD; ++ break; ++ ++ case SCST_RX_STATUS_ERROR_FATAL: ++ set_bit(SCST_CMD_NO_RESP, &cmd->cmd_flags); ++ /* go through */ ++ case SCST_RX_STATUS_ERROR: ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ scst_set_cmd_abnormal_done_state(cmd); ++ pref_context = SCST_CONTEXT_THREAD; ++ break; ++ ++ default: ++ PRINT_ERROR("scst_rx_data() received unknown status %x", ++ status); ++ scst_set_cmd_abnormal_done_state(cmd); ++ pref_context = SCST_CONTEXT_THREAD; ++ break; ++ } ++ ++ scst_process_redirect_cmd(cmd, pref_context, 1); ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL(scst_rx_data); ++ ++static int scst_tgt_pre_exec(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_RES_CONT_SAME, rc; ++ ++ TRACE_ENTRY(); ++ ++ if (unlikely(cmd->resid_possible)) { ++ if (cmd->data_direction & SCST_DATA_WRITE) { ++ bool do_zero = false; ++ if (cmd->data_direction & SCST_DATA_READ) { ++ if (cmd->write_len != cmd->out_bufflen) ++ do_zero = true; ++ } else { ++ if (cmd->write_len != cmd->bufflen) ++ do_zero = true; ++ } ++ if (do_zero) { ++ scst_check_restore_sg_buff(cmd); ++ scst_zero_write_rest(cmd); ++ } ++ } ++ } ++ ++ cmd->state = SCST_CMD_STATE_SEND_FOR_EXEC; ++ ++ if ((cmd->tgtt->pre_exec == NULL) || unlikely(cmd->internal)) ++ goto out; ++ ++ TRACE_DBG("Calling pre_exec(%p)", cmd); ++ scst_set_cur_start(cmd); ++ rc = cmd->tgtt->pre_exec(cmd); ++ scst_set_pre_exec_time(cmd); ++ TRACE_DBG("pre_exec() returned %d", rc); ++ ++ if (unlikely(rc != SCST_PREPROCESS_STATUS_SUCCESS)) { ++ switch (rc) { ++ case SCST_PREPROCESS_STATUS_ERROR_SENSE_SET: ++ scst_set_cmd_abnormal_done_state(cmd); ++ break; ++ case SCST_PREPROCESS_STATUS_ERROR_FATAL: ++ set_bit(SCST_CMD_NO_RESP, &cmd->cmd_flags); ++ /* go through */ ++ case SCST_PREPROCESS_STATUS_ERROR: ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ scst_set_cmd_abnormal_done_state(cmd); ++ break; ++ default: ++ BUG(); ++ break; ++ } ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void scst_do_cmd_done(struct scst_cmd *cmd, int result, ++ const uint8_t *rq_sense, int rq_sense_len, int resid) ++{ ++ TRACE_ENTRY(); ++ ++ scst_set_exec_time(cmd); ++ ++ cmd->status = result & 0xff; ++ cmd->msg_status = msg_byte(result); ++ cmd->host_status = host_byte(result); ++ cmd->driver_status = driver_byte(result); ++ if (unlikely(resid != 0)) { ++ if ((cmd->data_direction & SCST_DATA_READ) && ++ (resid > 0) && (resid < cmd->resp_data_len)) ++ scst_set_resp_data_len(cmd, cmd->resp_data_len - resid); ++ /* ++ * We ignore write direction residue, because from the ++ * initiator's POV we already transferred all the data. ++ */ ++ } ++ ++ if (unlikely(cmd->status == SAM_STAT_CHECK_CONDITION)) { ++ /* We might have double reset UA here */ ++ cmd->dbl_ua_orig_resp_data_len = cmd->resp_data_len; ++ cmd->dbl_ua_orig_data_direction = cmd->data_direction; ++ ++ scst_alloc_set_sense(cmd, 1, rq_sense, rq_sense_len); ++ } ++ ++ TRACE(TRACE_SCSI, "cmd %p, result %x, cmd->status %x, resid %d, " ++ "cmd->msg_status %x, cmd->host_status %x, " ++ "cmd->driver_status %x", cmd, result, cmd->status, resid, ++ cmd->msg_status, cmd->host_status, cmd->driver_status); ++ ++ cmd->completed = 1; ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* For small context optimization */ ++static inline enum scst_exec_context scst_optimize_post_exec_context( ++ struct scst_cmd *cmd, enum scst_exec_context context) ++{ ++ if (((context == SCST_CONTEXT_SAME) && scst_cmd_atomic(cmd)) || ++ (context == SCST_CONTEXT_TASKLET) || ++ (context == SCST_CONTEXT_DIRECT_ATOMIC)) { ++ if (!test_bit(SCST_TGT_DEV_AFTER_EXEC_ATOMIC, ++ &cmd->tgt_dev->tgt_dev_flags)) ++ context = SCST_CONTEXT_THREAD; ++ } ++ return context; ++} ++ ++/** ++ * scst_pass_through_cmd_done - done callback for pass-through commands ++ * @data: private opaque data ++ * @sense: pointer to the sense data, if any ++ * @result: command's execution result ++ * @resid: residual, if any ++ */ ++void scst_pass_through_cmd_done(void *data, char *sense, int result, int resid) ++{ ++ struct scst_cmd *cmd; ++ ++ TRACE_ENTRY(); ++ ++ cmd = (struct scst_cmd *)data; ++ if (cmd == NULL) ++ goto out; ++ ++ scst_do_cmd_done(cmd, result, sense, SCSI_SENSE_BUFFERSIZE, resid); ++ ++ cmd->state = SCST_CMD_STATE_PRE_DEV_DONE; ++ ++ scst_process_redirect_cmd(cmd, ++ scst_optimize_post_exec_context(cmd, scst_estimate_context()), 0); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL_GPL(scst_pass_through_cmd_done); ++ ++static void scst_cmd_done_local(struct scst_cmd *cmd, int next_state, ++ enum scst_exec_context pref_context) ++{ ++ TRACE_ENTRY(); ++ ++ EXTRACHECKS_BUG_ON(cmd->pr_abort_counter != NULL); ++ ++ scst_set_exec_time(cmd); ++ ++ TRACE(TRACE_SCSI, "cmd %p, status %x, msg_status %x, host_status %x, " ++ "driver_status %x, resp_data_len %d", cmd, cmd->status, ++ cmd->msg_status, cmd->host_status, cmd->driver_status, ++ cmd->resp_data_len); ++ ++ if (next_state == SCST_CMD_STATE_DEFAULT) ++ next_state = SCST_CMD_STATE_PRE_DEV_DONE; ++ ++#if defined(CONFIG_SCST_DEBUG) ++ if (next_state == SCST_CMD_STATE_PRE_DEV_DONE) { ++ if ((trace_flag & TRACE_RCV_TOP) && (cmd->sg != NULL)) { ++ int i, j; ++ struct scatterlist *sg = cmd->sg; ++ TRACE_RECV_TOP("Exec'd %d S/G(s) at %p sg[0].page at " ++ "%p", cmd->sg_cnt, sg, (void *)sg_page(&sg[0])); ++ for (i = 0, j = 0; i < cmd->sg_cnt; ++i, ++j) { ++ if (unlikely(sg_is_chain(&sg[j]))) { ++ sg = sg_chain_ptr(&sg[j]); ++ j = 0; ++ } ++ TRACE_BUFF_FLAG(TRACE_RCV_TOP, ++ "Exec'd sg", sg_virt(&sg[j]), ++ sg[j].length); ++ } ++ } ++ } ++#endif ++ ++ cmd->state = next_state; ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ if ((next_state != SCST_CMD_STATE_PRE_DEV_DONE) && ++ (next_state != SCST_CMD_STATE_PRE_XMIT_RESP) && ++ (next_state != SCST_CMD_STATE_FINISHED) && ++ (next_state != SCST_CMD_STATE_FINISHED_INTERNAL)) { ++ PRINT_ERROR("%s() received invalid cmd state %d (opcode %d)", ++ __func__, next_state, cmd->cdb[0]); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ scst_set_cmd_abnormal_done_state(cmd); ++ } ++#endif ++ pref_context = scst_optimize_post_exec_context(cmd, pref_context); ++ scst_process_redirect_cmd(cmd, pref_context, 0); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int scst_report_luns_local(struct scst_cmd *cmd) ++{ ++ int res = SCST_EXEC_COMPLETED, rc; ++ int dev_cnt = 0; ++ int buffer_size; ++ int i; ++ struct scst_tgt_dev *tgt_dev = NULL; ++ uint8_t *buffer; ++ int offs, overflow = 0; ++ ++ TRACE_ENTRY(); ++ ++ rc = scst_check_local_events(cmd); ++ if (unlikely(rc != 0)) ++ goto out_done; ++ ++ cmd->status = 0; ++ cmd->msg_status = 0; ++ cmd->host_status = DID_OK; ++ cmd->driver_status = 0; ++ ++ if ((cmd->cdb[2] != 0) && (cmd->cdb[2] != 2)) { ++ PRINT_ERROR("Unsupported SELECT REPORT value %x in REPORT " ++ "LUNS command", cmd->cdb[2]); ++ goto out_err; ++ } ++ ++ buffer_size = scst_get_buf_full(cmd, &buffer); ++ if (unlikely(buffer_size == 0)) ++ goto out_compl; ++ else if (unlikely(buffer_size < 0)) ++ goto out_hw_err; ++ ++ if (buffer_size < 16) ++ goto out_put_err; ++ ++ memset(buffer, 0, buffer_size); ++ offs = 8; ++ ++ /* ++ * cmd won't allow to suspend activities, so we can access ++ * sess->sess_tgt_dev_list without any additional protection. ++ */ ++ for (i = 0; i < SESS_TGT_DEV_LIST_HASH_SIZE; i++) { ++ struct list_head *head = &cmd->sess->sess_tgt_dev_list[i]; ++ list_for_each_entry(tgt_dev, head, sess_tgt_dev_list_entry) { ++ if (!overflow) { ++ if ((buffer_size - offs) < 8) { ++ overflow = 1; ++ goto inc_dev_cnt; ++ } ++ *(__force __be64 *)&buffer[offs] ++ = scst_pack_lun(tgt_dev->lun, ++ cmd->sess->acg->addr_method); ++ offs += 8; ++ } ++inc_dev_cnt: ++ dev_cnt++; ++ } ++ } ++ ++ /* Set the response header */ ++ dev_cnt *= 8; ++ buffer[0] = (dev_cnt >> 24) & 0xff; ++ buffer[1] = (dev_cnt >> 16) & 0xff; ++ buffer[2] = (dev_cnt >> 8) & 0xff; ++ buffer[3] = dev_cnt & 0xff; ++ ++ scst_put_buf_full(cmd, buffer); ++ ++ dev_cnt += 8; ++ if (dev_cnt < cmd->resp_data_len) ++ scst_set_resp_data_len(cmd, dev_cnt); ++ ++out_compl: ++ cmd->completed = 1; ++ ++ /* Clear left sense_reported_luns_data_changed UA, if any. */ ++ ++ /* ++ * cmd won't allow to suspend activities, so we can access ++ * sess->sess_tgt_dev_list without any additional protection. ++ */ ++ for (i = 0; i < SESS_TGT_DEV_LIST_HASH_SIZE; i++) { ++ struct list_head *head = &cmd->sess->sess_tgt_dev_list[i]; ++ ++ list_for_each_entry(tgt_dev, head, sess_tgt_dev_list_entry) { ++ struct scst_tgt_dev_UA *ua; ++ ++ spin_lock_bh(&tgt_dev->tgt_dev_lock); ++ list_for_each_entry(ua, &tgt_dev->UA_list, ++ UA_list_entry) { ++ if (scst_analyze_sense(ua->UA_sense_buffer, ++ ua->UA_valid_sense_len, ++ SCST_SENSE_ALL_VALID, ++ SCST_LOAD_SENSE(scst_sense_reported_luns_data_changed))) { ++ TRACE_MGMT_DBG("Freeing not needed " ++ "REPORTED LUNS DATA CHANGED UA " ++ "%p", ua); ++ scst_tgt_dev_del_free_UA(tgt_dev, ua); ++ break; ++ } ++ } ++ spin_unlock_bh(&tgt_dev->tgt_dev_lock); ++ } ++ } ++ ++out_done: ++ /* Report the result */ ++ cmd->scst_cmd_done(cmd, SCST_CMD_STATE_DEFAULT, SCST_CONTEXT_SAME); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_put_err: ++ scst_put_buf_full(cmd, buffer); ++ ++out_err: ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out_compl; ++ ++out_hw_err: ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out_compl; ++} ++ ++static int scst_request_sense_local(struct scst_cmd *cmd) ++{ ++ int res = SCST_EXEC_COMPLETED, rc; ++ struct scst_tgt_dev *tgt_dev = cmd->tgt_dev; ++ uint8_t *buffer; ++ int buffer_size = 0, sl = 0; ++ ++ TRACE_ENTRY(); ++ ++ rc = scst_check_local_events(cmd); ++ if (unlikely(rc != 0)) ++ goto out_done; ++ ++ cmd->status = 0; ++ cmd->msg_status = 0; ++ cmd->host_status = DID_OK; ++ cmd->driver_status = 0; ++ ++ spin_lock_bh(&tgt_dev->tgt_dev_lock); ++ ++ if (tgt_dev->tgt_dev_valid_sense_len == 0) ++ goto out_unlock_not_completed; ++ ++ TRACE(TRACE_SCSI, "%s: Returning stored sense", cmd->op_name); ++ ++ buffer_size = scst_get_buf_full(cmd, &buffer); ++ if (unlikely(buffer_size == 0)) ++ goto out_unlock_compl; ++ else if (unlikely(buffer_size < 0)) ++ goto out_unlock_hw_err; ++ ++ memset(buffer, 0, buffer_size); ++ ++ if (((tgt_dev->tgt_dev_sense[0] == 0x70) || ++ (tgt_dev->tgt_dev_sense[0] == 0x71)) && (cmd->cdb[1] & 1)) { ++ PRINT_WARNING("%s: Fixed format of the saved sense, but " ++ "descriptor format requested. Conversion will " ++ "truncated data", cmd->op_name); ++ PRINT_BUFFER("Original sense", tgt_dev->tgt_dev_sense, ++ tgt_dev->tgt_dev_valid_sense_len); ++ ++ buffer_size = min(SCST_STANDARD_SENSE_LEN, buffer_size); ++ sl = scst_set_sense(buffer, buffer_size, true, ++ tgt_dev->tgt_dev_sense[2], tgt_dev->tgt_dev_sense[12], ++ tgt_dev->tgt_dev_sense[13]); ++ } else if (((tgt_dev->tgt_dev_sense[0] == 0x72) || ++ (tgt_dev->tgt_dev_sense[0] == 0x73)) && !(cmd->cdb[1] & 1)) { ++ PRINT_WARNING("%s: Descriptor format of the " ++ "saved sense, but fixed format requested. Conversion " ++ "will truncated data", cmd->op_name); ++ PRINT_BUFFER("Original sense", tgt_dev->tgt_dev_sense, ++ tgt_dev->tgt_dev_valid_sense_len); ++ ++ buffer_size = min(SCST_STANDARD_SENSE_LEN, buffer_size); ++ sl = scst_set_sense(buffer, buffer_size, false, ++ tgt_dev->tgt_dev_sense[1], tgt_dev->tgt_dev_sense[2], ++ tgt_dev->tgt_dev_sense[3]); ++ } else { ++ if (buffer_size >= tgt_dev->tgt_dev_valid_sense_len) ++ sl = tgt_dev->tgt_dev_valid_sense_len; ++ else { ++ sl = buffer_size; ++ TRACE(TRACE_MINOR, "%s: Being returned sense truncated " ++ "to size %d (needed %d)", cmd->op_name, ++ buffer_size, tgt_dev->tgt_dev_valid_sense_len); ++ } ++ memcpy(buffer, tgt_dev->tgt_dev_sense, sl); ++ } ++ ++ scst_put_buf_full(cmd, buffer); ++ ++ tgt_dev->tgt_dev_valid_sense_len = 0; ++ ++ spin_unlock_bh(&tgt_dev->tgt_dev_lock); ++ ++ scst_set_resp_data_len(cmd, sl); ++ ++out_compl: ++ cmd->completed = 1; ++ ++out_done: ++ /* Report the result */ ++ cmd->scst_cmd_done(cmd, SCST_CMD_STATE_DEFAULT, SCST_CONTEXT_SAME); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_unlock_hw_err: ++ spin_unlock_bh(&tgt_dev->tgt_dev_lock); ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out_compl; ++ ++out_unlock_not_completed: ++ spin_unlock_bh(&tgt_dev->tgt_dev_lock); ++ res = SCST_EXEC_NOT_COMPLETED; ++ goto out; ++ ++out_unlock_compl: ++ spin_unlock_bh(&tgt_dev->tgt_dev_lock); ++ goto out_compl; ++} ++ ++static int scst_reserve_local(struct scst_cmd *cmd) ++{ ++ int res = SCST_EXEC_NOT_COMPLETED, rc; ++ struct scst_device *dev; ++ struct scst_tgt_dev *tgt_dev_tmp; ++ ++ TRACE_ENTRY(); ++ ++ if ((cmd->cdb[0] == RESERVE_10) && (cmd->cdb[2] & SCST_RES_3RDPTY)) { ++ PRINT_ERROR("RESERVE_10: 3rdPty RESERVE not implemented " ++ "(lun=%lld)", (long long unsigned int)cmd->lun); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out_done; ++ } ++ ++ dev = cmd->dev; ++ ++ /* ++ * There's no need to block this device, even for ++ * SCST_CONTR_MODE_ONE_TASK_SET, or anyhow else protect reservations ++ * changes, because: ++ * ++ * 1. The reservation changes are (rather) atomic, i.e., in contrast ++ * to persistent reservations, don't have any invalid intermediate ++ * states during being changed. ++ * ++ * 2. It's a duty of initiators to ensure order of regular commands ++ * around the reservation command either by ORDERED attribute, or by ++ * queue draining, or etc. For case of SCST_CONTR_MODE_ONE_TASK_SET ++ * there are no target drivers which can ensure even for ORDERED ++ * commands order of their delivery, so, because initiators know ++ * it, also there's no point to do any extra protection actions. ++ */ ++ ++ rc = scst_pre_check_local_events(cmd); ++ if (unlikely(rc != 0)) ++ goto out_done; ++ ++ if (!list_empty(&dev->dev_registrants_list)) { ++ if (scst_pr_crh_case(cmd)) ++ goto out_completed; ++ else { ++ scst_set_cmd_error_status(cmd, ++ SAM_STAT_RESERVATION_CONFLICT); ++ goto out_done; ++ } ++ } ++ ++ spin_lock_bh(&dev->dev_lock); ++ ++ if (test_bit(SCST_TGT_DEV_RESERVED, &cmd->tgt_dev->tgt_dev_flags)) { ++ spin_unlock_bh(&dev->dev_lock); ++ scst_set_cmd_error_status(cmd, SAM_STAT_RESERVATION_CONFLICT); ++ goto out_done; ++ } ++ ++ list_for_each_entry(tgt_dev_tmp, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ if (cmd->tgt_dev != tgt_dev_tmp) ++ set_bit(SCST_TGT_DEV_RESERVED, ++ &tgt_dev_tmp->tgt_dev_flags); ++ } ++ dev->dev_reserved = 1; ++ ++ spin_unlock_bh(&dev->dev_lock); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_completed: ++ cmd->completed = 1; ++ ++out_done: ++ /* Report the result */ ++ cmd->scst_cmd_done(cmd, SCST_CMD_STATE_DEFAULT, SCST_CONTEXT_SAME); ++ res = SCST_EXEC_COMPLETED; ++ goto out; ++} ++ ++static int scst_release_local(struct scst_cmd *cmd) ++{ ++ int res = SCST_EXEC_NOT_COMPLETED, rc; ++ struct scst_tgt_dev *tgt_dev_tmp; ++ struct scst_device *dev; ++ ++ TRACE_ENTRY(); ++ ++ dev = cmd->dev; ++ ++ /* ++ * See comment in scst_reserve_local() why no dev blocking or any ++ * other protection is needed here. ++ */ ++ ++ rc = scst_pre_check_local_events(cmd); ++ if (unlikely(rc != 0)) ++ goto out_done; ++ ++ if (!list_empty(&dev->dev_registrants_list)) { ++ if (scst_pr_crh_case(cmd)) ++ goto out_completed; ++ else { ++ scst_set_cmd_error_status(cmd, ++ SAM_STAT_RESERVATION_CONFLICT); ++ goto out_done; ++ } ++ } ++ ++ spin_lock_bh(&dev->dev_lock); ++ ++ /* ++ * The device could be RELEASED behind us, if RESERVING session ++ * is closed (see scst_free_tgt_dev()), but this actually doesn't ++ * matter, so use lock and no retest for DEV_RESERVED bits again ++ */ ++ if (test_bit(SCST_TGT_DEV_RESERVED, &cmd->tgt_dev->tgt_dev_flags)) { ++ res = SCST_EXEC_COMPLETED; ++ cmd->status = 0; ++ cmd->msg_status = 0; ++ cmd->host_status = DID_OK; ++ cmd->driver_status = 0; ++ cmd->completed = 1; ++ } else { ++ list_for_each_entry(tgt_dev_tmp, ++ &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ clear_bit(SCST_TGT_DEV_RESERVED, ++ &tgt_dev_tmp->tgt_dev_flags); ++ } ++ dev->dev_reserved = 0; ++ } ++ ++ spin_unlock_bh(&dev->dev_lock); ++ ++ if (res == SCST_EXEC_COMPLETED) ++ goto out_done; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_completed: ++ cmd->completed = 1; ++ ++out_done: ++ res = SCST_EXEC_COMPLETED; ++ /* Report the result */ ++ cmd->scst_cmd_done(cmd, SCST_CMD_STATE_DEFAULT, SCST_CONTEXT_SAME); ++ goto out; ++} ++ ++/* No locks, no IRQ or IRQ-disabled context allowed */ ++static int scst_persistent_reserve_in_local(struct scst_cmd *cmd) ++{ ++ int rc; ++ struct scst_device *dev; ++ struct scst_tgt_dev *tgt_dev; ++ struct scst_session *session; ++ int action; ++ uint8_t *buffer; ++ int buffer_size; ++ ++ TRACE_ENTRY(); ++ ++ EXTRACHECKS_BUG_ON(scst_cmd_atomic(cmd)); ++ ++ dev = cmd->dev; ++ tgt_dev = cmd->tgt_dev; ++ session = cmd->sess; ++ ++ rc = scst_check_local_events(cmd); ++ if (unlikely(rc != 0)) ++ goto out_done; ++ ++ if (unlikely(dev->not_pr_supporting_tgt_devs_num != 0)) { ++ PRINT_WARNING("Persistent Reservation command %x refused for " ++ "device %s, because the device has not supporting PR " ++ "transports connected", cmd->cdb[0], dev->virt_name); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_opcode)); ++ goto out_done; ++ } ++ ++ if (dev->dev_reserved) { ++ TRACE_PR("PR command rejected, because device %s holds regular " ++ "reservation", dev->virt_name); ++ scst_set_cmd_error_status(cmd, SAM_STAT_RESERVATION_CONFLICT); ++ goto out_done; ++ } ++ ++ if (dev->scsi_dev != NULL) { ++ PRINT_WARNING("PR commands for pass-through devices not " ++ "supported (device %s)", dev->virt_name); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_opcode)); ++ goto out_done; ++ } ++ ++ buffer_size = scst_get_buf_full(cmd, &buffer); ++ if (unlikely(buffer_size <= 0)) { ++ if (buffer_size < 0) ++ scst_set_busy(cmd); ++ goto out_done; ++ } ++ ++ scst_pr_write_lock(dev); ++ ++ /* We can be aborted by another PR command while waiting for the lock */ ++ if (unlikely(test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags))) { ++ TRACE_MGMT_DBG("ABORTED set, aborting cmd %p", cmd); ++ goto out_unlock; ++ } ++ ++ action = cmd->cdb[1] & 0x1f; ++ ++ TRACE(TRACE_SCSI, "PR action %x for '%s' (LUN %llx) from '%s'", action, ++ dev->virt_name, tgt_dev->lun, session->initiator_name); ++ ++ switch (action) { ++ case PR_READ_KEYS: ++ scst_pr_read_keys(cmd, buffer, buffer_size); ++ break; ++ case PR_READ_RESERVATION: ++ scst_pr_read_reservation(cmd, buffer, buffer_size); ++ break; ++ case PR_REPORT_CAPS: ++ scst_pr_report_caps(cmd, buffer, buffer_size); ++ break; ++ case PR_READ_FULL_STATUS: ++ scst_pr_read_full_status(cmd, buffer, buffer_size); ++ break; ++ default: ++ PRINT_ERROR("Unsupported action %x", action); ++ scst_pr_write_unlock(dev); ++ goto out_err; ++ } ++ ++out_complete: ++ cmd->completed = 1; ++ ++out_unlock: ++ scst_pr_write_unlock(dev); ++ ++ scst_put_buf_full(cmd, buffer); ++ ++out_done: ++ cmd->scst_cmd_done(cmd, SCST_CMD_STATE_DEFAULT, SCST_CONTEXT_SAME); ++ ++ TRACE_EXIT_RES(SCST_EXEC_COMPLETED); ++ return SCST_EXEC_COMPLETED; ++ ++out_err: ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out_complete; ++} ++ ++/* No locks, no IRQ or IRQ-disabled context allowed */ ++static int scst_persistent_reserve_out_local(struct scst_cmd *cmd) ++{ ++ int res = SCST_EXEC_COMPLETED; ++ int rc; ++ struct scst_device *dev; ++ struct scst_tgt_dev *tgt_dev; ++ struct scst_session *session; ++ int action; ++ uint8_t *buffer; ++ int buffer_size; ++ bool aborted = false; ++ ++ TRACE_ENTRY(); ++ ++ EXTRACHECKS_BUG_ON(scst_cmd_atomic(cmd)); ++ ++ dev = cmd->dev; ++ tgt_dev = cmd->tgt_dev; ++ session = cmd->sess; ++ ++ rc = scst_check_local_events(cmd); ++ if (unlikely(rc != 0)) ++ goto out_done; ++ ++ if (unlikely(dev->not_pr_supporting_tgt_devs_num != 0)) { ++ PRINT_WARNING("Persistent Reservation command %x refused for " ++ "device %s, because the device has not supporting PR " ++ "transports connected", cmd->cdb[0], dev->virt_name); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_opcode)); ++ goto out_done; ++ } ++ ++ action = cmd->cdb[1] & 0x1f; ++ ++ TRACE(TRACE_SCSI, "PR action %x for '%s' (LUN %llx) from '%s'", action, ++ dev->virt_name, tgt_dev->lun, session->initiator_name); ++ ++ if (dev->dev_reserved) { ++ TRACE_PR("PR command rejected, because device %s holds regular " ++ "reservation", dev->virt_name); ++ scst_set_cmd_error_status(cmd, SAM_STAT_RESERVATION_CONFLICT); ++ goto out_done; ++ } ++ ++ /* ++ * Check if tgt_dev already registered. Also by this check we make ++ * sure that table "PERSISTENT RESERVE OUT service actions that are ++ * allowed in the presence of various reservations" is honored. ++ * REGISTER AND MOVE and RESERVE will be additionally checked for ++ * conflicts later. ++ */ ++ if ((action != PR_REGISTER) && (action != PR_REGISTER_AND_IGNORE) && ++ (tgt_dev->registrant == NULL)) { ++ TRACE_PR("'%s' not registered", cmd->sess->initiator_name); ++ scst_set_cmd_error_status(cmd, SAM_STAT_RESERVATION_CONFLICT); ++ goto out_done; ++ } ++ ++ buffer_size = scst_get_buf_full(cmd, &buffer); ++ if (unlikely(buffer_size <= 0)) { ++ if (buffer_size < 0) ++ scst_set_busy(cmd); ++ goto out_done; ++ } ++ ++ /* Check scope */ ++ if ((action != PR_REGISTER) && (action != PR_REGISTER_AND_IGNORE) && ++ (action != PR_CLEAR) && ((cmd->cdb[2] & 0x0f) >> 4) != SCOPE_LU) { ++ TRACE_PR("Scope must be SCOPE_LU for action %x", action); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out_put_buf_full; ++ } ++ ++ /* Check SPEC_I_PT (PR_REGISTER_AND_MOVE has another format) */ ++ if ((action != PR_REGISTER) && (action != PR_REGISTER_AND_MOVE) && ++ ((buffer[20] >> 3) & 0x01)) { ++ TRACE_PR("SPEC_I_PT must be zero for action %x", action); ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE( ++ scst_sense_invalid_field_in_cdb)); ++ goto out_put_buf_full; ++ } ++ ++ /* Check ALL_TG_PT (PR_REGISTER_AND_MOVE has another format) */ ++ if ((action != PR_REGISTER) && (action != PR_REGISTER_AND_IGNORE) && ++ (action != PR_REGISTER_AND_MOVE) && ((buffer[20] >> 2) & 0x01)) { ++ TRACE_PR("ALL_TG_PT must be zero for action %x", action); ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE( ++ scst_sense_invalid_field_in_cdb)); ++ goto out_put_buf_full; ++ } ++ ++ scst_pr_write_lock(dev); ++ ++ /* We can be aborted by another PR command while waiting for the lock */ ++ aborted = test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags); ++ if (unlikely(aborted)) { ++ TRACE_MGMT_DBG("ABORTED set, aborting cmd %p", cmd); ++ goto out_unlock; ++ } ++ ++ switch (action) { ++ case PR_REGISTER: ++ scst_pr_register(cmd, buffer, buffer_size); ++ break; ++ case PR_RESERVE: ++ scst_pr_reserve(cmd, buffer, buffer_size); ++ break; ++ case PR_RELEASE: ++ scst_pr_release(cmd, buffer, buffer_size); ++ break; ++ case PR_CLEAR: ++ scst_pr_clear(cmd, buffer, buffer_size); ++ break; ++ case PR_PREEMPT: ++ scst_pr_preempt(cmd, buffer, buffer_size); ++ break; ++ case PR_PREEMPT_AND_ABORT: ++ scst_pr_preempt_and_abort(cmd, buffer, buffer_size); ++ break; ++ case PR_REGISTER_AND_IGNORE: ++ scst_pr_register_and_ignore(cmd, buffer, buffer_size); ++ break; ++ case PR_REGISTER_AND_MOVE: ++ scst_pr_register_and_move(cmd, buffer, buffer_size); ++ break; ++ default: ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out_unlock; ++ } ++ ++ if (cmd->status == SAM_STAT_GOOD) ++ scst_pr_sync_device_file(tgt_dev, cmd); ++ ++ if ((dev->handler->pr_cmds_notifications) && ++ (cmd->status == SAM_STAT_GOOD)) /* sync file may change status */ ++ res = SCST_EXEC_NOT_COMPLETED; ++ ++out_unlock: ++ scst_pr_write_unlock(dev); ++ ++out_put_buf_full: ++ scst_put_buf_full(cmd, buffer); ++ ++out_done: ++ if (SCST_EXEC_COMPLETED == res) { ++ if (!aborted) ++ cmd->completed = 1; ++ cmd->scst_cmd_done(cmd, SCST_CMD_STATE_DEFAULT, ++ SCST_CONTEXT_SAME); ++ } ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/** ++ * scst_check_local_events() - check if there are any local SCSI events ++ * ++ * Description: ++ * Checks if the command can be executed or there are local events, ++ * like reservations, pending UAs, etc. Returns < 0 if command must be ++ * aborted, > 0 if there is an event and command should be immediately ++ * completed, or 0 otherwise. ++ * ++ * !! 1.Dev handlers implementing exec() callback must call this function there ++ * !! just before the actual command's execution! ++ * !! ++ * !! 2. If this function can be called more than once on the processing path ++ * !! scst_pre_check_local_events() should be used for the first call! ++ * ++ * On call no locks, no IRQ or IRQ-disabled context allowed. ++ */ ++int scst_check_local_events(struct scst_cmd *cmd) ++{ ++ int res, rc; ++ struct scst_tgt_dev *tgt_dev = cmd->tgt_dev; ++ struct scst_device *dev = cmd->dev; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * There's no race here, because we need to trace commands sent ++ * *after* dev_double_ua_possible flag was set. ++ */ ++ if (unlikely(dev->dev_double_ua_possible)) ++ cmd->double_ua_possible = 1; ++ ++ /* Reserve check before Unit Attention */ ++ if (unlikely(test_bit(SCST_TGT_DEV_RESERVED, ++ &tgt_dev->tgt_dev_flags))) { ++ if ((cmd->op_flags & SCST_REG_RESERVE_ALLOWED) == 0) { ++ scst_set_cmd_error_status(cmd, ++ SAM_STAT_RESERVATION_CONFLICT); ++ goto out_dec_pr_readers_count; ++ } ++ } ++ ++ if (likely(!cmd->check_local_events_once_done)) { ++ if (dev->pr_is_set) { ++ if (unlikely(!scst_pr_is_cmd_allowed(cmd))) { ++ scst_set_cmd_error_status(cmd, ++ SAM_STAT_RESERVATION_CONFLICT); ++ goto out_complete; ++ } ++ } else ++ scst_dec_pr_readers_count(cmd, false); ++ } ++ ++ /* ++ * Let's check for ABORTED after scst_pr_is_cmd_allowed(), because ++ * we might sleep for a while there. ++ */ ++ if (unlikely(test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags))) { ++ TRACE_MGMT_DBG("ABORTED set, aborting cmd %p", cmd); ++ goto out_uncomplete; ++ } ++ ++ /* If we had internal bus reset, set the command error unit attention */ ++ if ((dev->scsi_dev != NULL) && ++ unlikely(dev->scsi_dev->was_reset)) { ++ if (scst_is_ua_command(cmd)) { ++ int done = 0; ++ /* ++ * Prevent more than 1 cmd to be triggered by was_reset ++ */ ++ spin_lock_bh(&dev->dev_lock); ++ if (dev->scsi_dev->was_reset) { ++ TRACE(TRACE_MGMT, "was_reset is %d", 1); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_reset_UA)); ++ /* ++ * It looks like it is safe to clear was_reset ++ * here ++ */ ++ dev->scsi_dev->was_reset = 0; ++ done = 1; ++ } ++ spin_unlock_bh(&dev->dev_lock); ++ ++ if (done) ++ goto out_complete; ++ } ++ } ++ ++ if (unlikely(test_bit(SCST_TGT_DEV_UA_PENDING, ++ &cmd->tgt_dev->tgt_dev_flags))) { ++ if (scst_is_ua_command(cmd)) { ++ rc = scst_set_pending_UA(cmd); ++ if (rc == 0) ++ goto out_complete; ++ } ++ } ++ ++ res = 0; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_dec_pr_readers_count: ++ if (cmd->dec_pr_readers_count_needed) ++ scst_dec_pr_readers_count(cmd, false); ++ ++out_complete: ++ res = 1; ++ BUG_ON(!cmd->completed); ++ goto out; ++ ++out_uncomplete: ++ res = -1; ++ goto out; ++} ++EXPORT_SYMBOL_GPL(scst_check_local_events); ++ ++/* No locks */ ++void scst_inc_expected_sn(struct scst_order_data *order_data, atomic_t *slot) ++{ ++ if (slot == NULL) ++ goto inc; ++ ++ /* Optimized for lockless fast path */ ++ ++ TRACE_SN("Slot %zd, *cur_sn_slot %d", slot - order_data->sn_slots, ++ atomic_read(slot)); ++ ++ if (!atomic_dec_and_test(slot)) ++ goto out; ++ ++ TRACE_SN("Slot is 0 (num_free_sn_slots=%d)", ++ order_data->num_free_sn_slots); ++ if (order_data->num_free_sn_slots < (int)ARRAY_SIZE(order_data->sn_slots)-1) { ++ spin_lock_irq(&order_data->sn_lock); ++ if (likely(order_data->num_free_sn_slots < (int)ARRAY_SIZE(order_data->sn_slots)-1)) { ++ if (order_data->num_free_sn_slots < 0) ++ order_data->cur_sn_slot = slot; ++ /* To be in-sync with SIMPLE case in scst_cmd_set_sn() */ ++ smp_mb(); ++ order_data->num_free_sn_slots++; ++ TRACE_SN("Incremented num_free_sn_slots (%d)", ++ order_data->num_free_sn_slots); ++ ++ } ++ spin_unlock_irq(&order_data->sn_lock); ++ } ++ ++inc: ++ /* ++ * No protection of expected_sn is needed, because only one thread ++ * at time can be here (serialized by sn). Also it is supposed that ++ * there could not be half-incremented halves. ++ */ ++ order_data->expected_sn++; ++ /* ++ * Write must be before def_cmd_count read to be in sync. with ++ * scst_post_exec_sn(). See comment in scst_send_for_exec(). ++ */ ++ smp_mb(); ++ TRACE_SN("Next expected_sn: %d", order_data->expected_sn); ++ ++out: ++ return; ++} ++ ++/* No locks */ ++static struct scst_cmd *scst_post_exec_sn(struct scst_cmd *cmd, ++ bool make_active) ++{ ++ /* For HQ commands SN is not set */ ++ bool inc_expected_sn = !cmd->inc_expected_sn_on_done && ++ cmd->sn_set && !cmd->retry; ++ struct scst_order_data *order_data = cmd->cur_order_data; ++ struct scst_cmd *res; ++ ++ TRACE_ENTRY(); ++ ++ if (inc_expected_sn) ++ scst_inc_expected_sn(order_data, cmd->sn_slot); ++ ++ if (make_active) { ++ scst_make_deferred_commands_active(order_data); ++ res = NULL; ++ } else ++ res = scst_check_deferred_commands(order_data); ++ ++ TRACE_EXIT_HRES(res); ++ return res; ++} ++ ++/* cmd must be additionally referenced to not die inside */ ++static int scst_do_real_exec(struct scst_cmd *cmd) ++{ ++ int res = SCST_EXEC_NOT_COMPLETED; ++ int rc; ++ struct scst_device *dev = cmd->dev; ++ struct scst_dev_type *handler = dev->handler; ++ struct io_context *old_ctx = NULL; ++ bool ctx_changed = false; ++ struct scsi_device *scsi_dev; ++ ++ TRACE_ENTRY(); ++ ++ ctx_changed = scst_set_io_context(cmd, &old_ctx); ++ ++ cmd->state = SCST_CMD_STATE_REAL_EXECUTING; ++ ++ if (handler->exec) { ++ TRACE_DBG("Calling dev handler %s exec(%p)", ++ handler->name, cmd); ++ TRACE_BUFF_FLAG(TRACE_SND_TOP, "Execing: ", cmd->cdb, ++ cmd->cdb_len); ++ scst_set_cur_start(cmd); ++ res = handler->exec(cmd); ++ TRACE_DBG("Dev handler %s exec() returned %d", ++ handler->name, res); ++ ++ if (res == SCST_EXEC_COMPLETED) ++ goto out_complete; ++ ++ scst_set_exec_time(cmd); ++ ++ BUG_ON(res != SCST_EXEC_NOT_COMPLETED); ++ } ++ ++ TRACE_DBG("Sending cmd %p to SCSI mid-level", cmd); ++ ++ scsi_dev = dev->scsi_dev; ++ ++ if (unlikely(scsi_dev == NULL)) { ++ PRINT_ERROR("Command for virtual device must be " ++ "processed by device handler (LUN %lld)!", ++ (long long unsigned int)cmd->lun); ++ goto out_error; ++ } ++ ++ res = scst_check_local_events(cmd); ++ if (unlikely(res != 0)) ++ goto out_done; ++ ++ scst_set_cur_start(cmd); ++ ++ rc = scst_scsi_exec_async(cmd, cmd, scst_pass_through_cmd_done); ++ if (unlikely(rc != 0)) { ++ PRINT_ERROR("scst pass-through exec failed: %x", rc); ++ if (((int)rc == -EINVAL) && ++ (cmd->bufflen > queue_max_hw_sectors(scsi_dev->request_queue))) ++ PRINT_ERROR("Too low max_hw_sectors %d sectors on %s " ++ "to serve command %x with bufflen %db." ++ "See README for more details.", ++ queue_max_hw_sectors(scsi_dev->request_queue), ++ dev->virt_name, cmd->cdb[0], cmd->bufflen); ++ goto out_error; ++ } ++ ++out_complete: ++ res = SCST_EXEC_COMPLETED; ++ ++ if (ctx_changed) ++ scst_reset_io_context(cmd->tgt_dev, old_ctx); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_error: ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out_done; ++ ++out_done: ++ res = SCST_EXEC_COMPLETED; ++ /* Report the result */ ++ cmd->scst_cmd_done(cmd, SCST_CMD_STATE_DEFAULT, SCST_CONTEXT_SAME); ++ goto out_complete; ++} ++ ++static inline int scst_real_exec(struct scst_cmd *cmd) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ BUILD_BUG_ON(SCST_CMD_STATE_RES_CONT_SAME != SCST_EXEC_NOT_COMPLETED); ++ BUILD_BUG_ON(SCST_CMD_STATE_RES_CONT_NEXT != SCST_EXEC_COMPLETED); ++ ++ __scst_cmd_get(cmd); ++ ++ res = scst_do_real_exec(cmd); ++ if (likely(res == SCST_EXEC_COMPLETED)) { ++ scst_post_exec_sn(cmd, true); ++ } else ++ BUG(); ++ ++ __scst_cmd_put(cmd); ++ ++ /* SCST_EXEC_* match SCST_CMD_STATE_RES_* */ ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_do_local_exec(struct scst_cmd *cmd) ++{ ++ int res; ++ struct scst_tgt_dev *tgt_dev = cmd->tgt_dev; ++ ++ TRACE_ENTRY(); ++ ++ /* Check READ_ONLY device status */ ++ if ((cmd->op_flags & SCST_WRITE_MEDIUM) && ++ (tgt_dev->acg_dev->rd_only || cmd->dev->swp || ++ cmd->dev->rd_only)) { ++ PRINT_WARNING("Attempt of write access to read-only device: " ++ "initiator %s, LUN %lld, op %x", ++ cmd->sess->initiator_name, cmd->lun, cmd->cdb[0]); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_data_protect)); ++ goto out_done; ++ } ++ ++ if (!scst_is_cmd_local(cmd)) { ++ res = SCST_EXEC_NOT_COMPLETED; ++ goto out; ++ } ++ ++ switch (cmd->cdb[0]) { ++ case RESERVE: ++ case RESERVE_10: ++ res = scst_reserve_local(cmd); ++ break; ++ case RELEASE: ++ case RELEASE_10: ++ res = scst_release_local(cmd); ++ break; ++ case PERSISTENT_RESERVE_IN: ++ res = scst_persistent_reserve_in_local(cmd); ++ break; ++ case PERSISTENT_RESERVE_OUT: ++ res = scst_persistent_reserve_out_local(cmd); ++ break; ++ case REPORT_LUNS: ++ res = scst_report_luns_local(cmd); ++ break; ++ case REQUEST_SENSE: ++ res = scst_request_sense_local(cmd); ++ break; ++ default: ++ res = SCST_EXEC_NOT_COMPLETED; ++ break; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_done: ++ /* Report the result */ ++ cmd->scst_cmd_done(cmd, SCST_CMD_STATE_DEFAULT, SCST_CONTEXT_SAME); ++ res = SCST_EXEC_COMPLETED; ++ goto out; ++} ++ ++static int scst_local_exec(struct scst_cmd *cmd) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ BUILD_BUG_ON(SCST_CMD_STATE_RES_CONT_SAME != SCST_EXEC_NOT_COMPLETED); ++ BUILD_BUG_ON(SCST_CMD_STATE_RES_CONT_NEXT != SCST_EXEC_COMPLETED); ++ ++ __scst_cmd_get(cmd); ++ ++ res = scst_do_local_exec(cmd); ++ if (likely(res == SCST_EXEC_NOT_COMPLETED)) ++ cmd->state = SCST_CMD_STATE_REAL_EXEC; ++ else if (res == SCST_EXEC_COMPLETED) ++ scst_post_exec_sn(cmd, true); ++ else ++ BUG(); ++ ++ __scst_cmd_put(cmd); ++ ++ /* SCST_EXEC_* match SCST_CMD_STATE_RES_* */ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_exec(struct scst_cmd **active_cmd) ++{ ++ struct scst_cmd *cmd = *active_cmd; ++ struct scst_cmd *ref_cmd; ++ int res = SCST_CMD_STATE_RES_CONT_NEXT, count = 0; ++ ++ TRACE_ENTRY(); ++ ++ cmd->state = SCST_CMD_STATE_START_EXEC; ++ ++ if (unlikely(scst_check_blocked_dev(cmd))) ++ goto out; ++ ++ /* To protect tgt_dev */ ++ ref_cmd = cmd; ++ __scst_cmd_get(ref_cmd); ++ ++ while (1) { ++ int rc; ++ ++ cmd->sent_for_exec = 1; ++ /* ++ * To sync with scst_abort_cmd(). The above assignment must ++ * be before SCST_CMD_ABORTED test, done later in ++ * scst_check_local_events(). It's far from here, so the order ++ * is virtually guaranteed, but let's have it just in case. ++ */ ++ smp_mb(); ++ ++ cmd->scst_cmd_done = scst_cmd_done_local; ++ cmd->state = SCST_CMD_STATE_LOCAL_EXEC; ++ ++ rc = scst_do_local_exec(cmd); ++ if (likely(rc == SCST_EXEC_NOT_COMPLETED)) ++ /* Nothing to do */; ++ else { ++ BUG_ON(rc != SCST_EXEC_COMPLETED); ++ goto done; ++ } ++ ++ cmd->state = SCST_CMD_STATE_REAL_EXEC; ++ ++ rc = scst_do_real_exec(cmd); ++ BUG_ON(rc != SCST_EXEC_COMPLETED); ++ ++done: ++ count++; ++ ++ cmd = scst_post_exec_sn(cmd, false); ++ if (cmd == NULL) ++ break; ++ ++ cmd->state = SCST_CMD_STATE_START_EXEC; ++ ++ if (unlikely(scst_check_blocked_dev(cmd))) ++ break; ++ ++ __scst_cmd_put(ref_cmd); ++ ref_cmd = cmd; ++ __scst_cmd_get(ref_cmd); ++ ++ } ++ ++ *active_cmd = cmd; ++ ++ if (count == 0) ++ goto out_put; ++ ++out_put: ++ __scst_cmd_put(ref_cmd); ++ /* !! At this point sess, dev and tgt_dev can be already freed !! */ ++ ++out: ++ EXTRACHECKS_BUG_ON(res == SCST_CMD_STATE_RES_NEED_THREAD); ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_send_for_exec(struct scst_cmd **active_cmd) ++{ ++ int res; ++ struct scst_cmd *cmd = *active_cmd; ++ struct scst_order_data *order_data = cmd->cur_order_data; ++ typeof(order_data->expected_sn) expected_sn; ++ ++ TRACE_ENTRY(); ++ ++ if (unlikely(cmd->internal)) ++ goto exec; ++ ++ if (unlikely(cmd->queue_type == SCST_CMD_QUEUE_HEAD_OF_QUEUE)) ++ goto exec; ++ ++ BUG_ON(!cmd->sn_set); ++ ++ expected_sn = order_data->expected_sn; ++ /* Optimized for lockless fast path */ ++ if ((cmd->sn != expected_sn) || (order_data->hq_cmd_count > 0)) { ++ spin_lock_irq(&order_data->sn_lock); ++ ++ order_data->def_cmd_count++; ++ /* ++ * Memory barrier is needed here to implement lockless fast ++ * path. We need the exact order of read and write between ++ * def_cmd_count and expected_sn. Otherwise, we can miss case, ++ * when expected_sn was changed to be equal to cmd->sn while ++ * we are queueing cmd the deferred list after the expected_sn ++ * below. It will lead to a forever stuck command. But with ++ * the barrier in such case __scst_check_deferred_commands() ++ * will be called and it will take sn_lock, so we will be ++ * synchronized. ++ */ ++ smp_mb(); ++ ++ expected_sn = order_data->expected_sn; ++ if ((cmd->sn != expected_sn) || (order_data->hq_cmd_count > 0)) { ++ if (unlikely(test_bit(SCST_CMD_ABORTED, ++ &cmd->cmd_flags))) { ++ /* Necessary to allow aborting out of sn cmds */ ++ TRACE_MGMT_DBG("Aborting out of sn cmd %p " ++ "(tag %llu, sn %u)", cmd, ++ (long long unsigned)cmd->tag, cmd->sn); ++ order_data->def_cmd_count--; ++ scst_set_cmd_abnormal_done_state(cmd); ++ res = SCST_CMD_STATE_RES_CONT_SAME; ++ } else { ++ TRACE_SN("Deferring cmd %p (sn=%d, set %d, " ++ "expected_sn=%d)", cmd, cmd->sn, ++ cmd->sn_set, expected_sn); ++ list_add_tail(&cmd->sn_cmd_list_entry, ++ &order_data->deferred_cmd_list); ++ res = SCST_CMD_STATE_RES_CONT_NEXT; ++ } ++ spin_unlock_irq(&order_data->sn_lock); ++ goto out; ++ } else { ++ TRACE_SN("Somebody incremented expected_sn %d, " ++ "continuing", expected_sn); ++ order_data->def_cmd_count--; ++ spin_unlock_irq(&order_data->sn_lock); ++ } ++ } ++ ++exec: ++ res = scst_exec(active_cmd); ++ ++out: ++ TRACE_EXIT_HRES(res); ++ return res; ++} ++ ++/* No locks supposed to be held */ ++static int scst_check_sense(struct scst_cmd *cmd) ++{ ++ int res = 0; ++ struct scst_device *dev = cmd->dev; ++ ++ TRACE_ENTRY(); ++ ++ if (unlikely(cmd->ua_ignore)) ++ goto out; ++ ++ /* If we had internal bus reset behind us, set the command error UA */ ++ if ((dev->scsi_dev != NULL) && ++ unlikely(cmd->host_status == DID_RESET) && ++ scst_is_ua_command(cmd)) { ++ TRACE(TRACE_MGMT, "DID_RESET: was_reset=%d host_status=%x", ++ dev->scsi_dev->was_reset, cmd->host_status); ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_reset_UA)); ++ /* It looks like it is safe to clear was_reset here */ ++ dev->scsi_dev->was_reset = 0; ++ } ++ ++ if (unlikely(cmd->status == SAM_STAT_CHECK_CONDITION) && ++ SCST_SENSE_VALID(cmd->sense)) { ++ PRINT_BUFF_FLAG(TRACE_SCSI, "Sense", cmd->sense, ++ cmd->sense_valid_len); ++ ++ /* Check Unit Attention Sense Key */ ++ if (scst_is_ua_sense(cmd->sense, cmd->sense_valid_len)) { ++ if (scst_analyze_sense(cmd->sense, cmd->sense_valid_len, ++ SCST_SENSE_ASC_VALID, ++ 0, SCST_SENSE_ASC_UA_RESET, 0)) { ++ if (cmd->double_ua_possible) { ++ TRACE_MGMT_DBG("Double UA " ++ "detected for device %p", dev); ++ TRACE_MGMT_DBG("Retrying cmd" ++ " %p (tag %llu)", cmd, ++ (long long unsigned)cmd->tag); ++ ++ cmd->status = 0; ++ cmd->msg_status = 0; ++ cmd->host_status = DID_OK; ++ cmd->driver_status = 0; ++ cmd->completed = 0; ++ ++ mempool_free(cmd->sense, ++ scst_sense_mempool); ++ cmd->sense = NULL; ++ ++ scst_check_restore_sg_buff(cmd); ++ ++ BUG_ON(cmd->dbl_ua_orig_resp_data_len < 0); ++ cmd->data_direction = ++ cmd->dbl_ua_orig_data_direction; ++ cmd->resp_data_len = ++ cmd->dbl_ua_orig_resp_data_len; ++ ++ cmd->state = SCST_CMD_STATE_REAL_EXEC; ++ cmd->retry = 1; ++ scst_reset_requeued_cmd(cmd); ++ res = 1; ++ goto out; ++ } ++ } ++ scst_dev_check_set_UA(dev, cmd, cmd->sense, ++ cmd->sense_valid_len); ++ } ++ } ++ ++ if (unlikely(cmd->double_ua_possible)) { ++ if (scst_is_ua_command(cmd)) { ++ TRACE_MGMT_DBG("Clearing dbl_ua_possible flag (dev %p, " ++ "cmd %p)", dev, cmd); ++ /* ++ * Lock used to protect other flags in the bitfield ++ * (just in case, actually). Those flags can't be ++ * changed in parallel, because the device is ++ * serialized. ++ */ ++ spin_lock_bh(&dev->dev_lock); ++ dev->dev_double_ua_possible = 0; ++ spin_unlock_bh(&dev->dev_lock); ++ } ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_check_auto_sense(struct scst_cmd *cmd) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ if (unlikely(cmd->status == SAM_STAT_CHECK_CONDITION) && ++ (!SCST_SENSE_VALID(cmd->sense) || ++ SCST_NO_SENSE(cmd->sense))) { ++ TRACE(TRACE_SCSI|TRACE_MINOR_AND_MGMT_DBG, "CHECK_CONDITION, " ++ "but no sense: cmd->status=%x, cmd->msg_status=%x, " ++ "cmd->host_status=%x, cmd->driver_status=%x (cmd %p)", ++ cmd->status, cmd->msg_status, cmd->host_status, ++ cmd->driver_status, cmd); ++ res = 1; ++ } else if (unlikely(cmd->host_status)) { ++ if ((cmd->host_status == DID_REQUEUE) || ++ (cmd->host_status == DID_IMM_RETRY) || ++ (cmd->host_status == DID_SOFT_ERROR) || ++ (cmd->host_status == DID_ABORT)) { ++ scst_set_busy(cmd); ++ } else { ++ TRACE(TRACE_SCSI|TRACE_MINOR_AND_MGMT_DBG, "Host " ++ "status %x received, returning HARDWARE ERROR " ++ "instead (cmd %p)", cmd->host_status, cmd); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ } ++ } ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_pre_dev_done(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_RES_CONT_SAME, rc; ++ ++ TRACE_ENTRY(); ++ ++ if (unlikely(scst_check_auto_sense(cmd))) { ++ PRINT_INFO("Command finished with CHECK CONDITION, but " ++ "without sense data (opcode 0x%x), issuing " ++ "REQUEST SENSE", cmd->cdb[0]); ++ rc = scst_prepare_request_sense(cmd); ++ if (rc == 0) ++ res = SCST_CMD_STATE_RES_CONT_NEXT; ++ else { ++ PRINT_ERROR("%s", "Unable to issue REQUEST SENSE, " ++ "returning HARDWARE ERROR"); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ } ++ goto out; ++ } else if (unlikely(scst_check_sense(cmd))) { ++ /* ++ * We can't allow atomic command on the exec stages, so ++ * restart to the thread ++ */ ++ res = SCST_CMD_STATE_RES_NEED_THREAD; ++ goto out; ++ } ++ ++ if (likely(scsi_status_is_good(cmd->status))) { ++ unsigned char type = cmd->dev->type; ++ if (unlikely((cmd->cdb[0] == MODE_SENSE || ++ cmd->cdb[0] == MODE_SENSE_10)) && ++ (cmd->tgt_dev->acg_dev->rd_only || cmd->dev->swp || ++ cmd->dev->rd_only) && ++ (type == TYPE_DISK || ++ type == TYPE_WORM || ++ type == TYPE_MOD || ++ type == TYPE_TAPE)) { ++ int32_t length; ++ uint8_t *address; ++ bool err = false; ++ ++ length = scst_get_buf_full(cmd, &address); ++ if (length < 0) { ++ PRINT_ERROR("%s", "Unable to get " ++ "MODE_SENSE buffer"); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE( ++ scst_sense_hardw_error)); ++ err = true; ++ } else if (length > 2 && cmd->cdb[0] == MODE_SENSE) ++ address[2] |= 0x80; /* Write Protect*/ ++ else if (length > 3 && cmd->cdb[0] == MODE_SENSE_10) ++ address[3] |= 0x80; /* Write Protect*/ ++ scst_put_buf_full(cmd, address); ++ ++ if (err) ++ goto out; ++ } ++ ++ /* ++ * Check and clear NormACA option for the device, if necessary, ++ * since we don't support ACA ++ */ ++ if (unlikely((cmd->cdb[0] == INQUIRY)) && ++ /* Std INQUIRY data (no EVPD) */ ++ !(cmd->cdb[1] & SCST_INQ_EVPD) && ++ (cmd->resp_data_len > SCST_INQ_BYTE3)) { ++ uint8_t *buffer; ++ int buflen; ++ bool err = false; ++ ++ buflen = scst_get_buf_full(cmd, &buffer); ++ if (buflen > SCST_INQ_BYTE3 && !cmd->tgtt->fake_aca) { ++#ifdef CONFIG_SCST_EXTRACHECKS ++ if (buffer[SCST_INQ_BYTE3] & SCST_INQ_NORMACA_BIT) { ++ PRINT_INFO("NormACA set for device: " ++ "lun=%lld, type 0x%02x. Clear it, " ++ "since it's unsupported.", ++ (long long unsigned int)cmd->lun, ++ buffer[0]); ++ } ++#endif ++ buffer[SCST_INQ_BYTE3] &= ~SCST_INQ_NORMACA_BIT; ++ } else if (buflen <= SCST_INQ_BYTE3 && buflen != 0) { ++ PRINT_ERROR("%s", "Unable to get INQUIRY " ++ "buffer"); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ err = true; ++ } ++ if (buflen > 0) ++ scst_put_buf_full(cmd, buffer); ++ ++ if (err) ++ goto out; ++ } ++ ++ if (unlikely((cmd->cdb[0] == MODE_SELECT) || ++ (cmd->cdb[0] == MODE_SELECT_10) || ++ (cmd->cdb[0] == LOG_SELECT))) { ++ TRACE(TRACE_SCSI, ++ "MODE/LOG SELECT succeeded (LUN %lld)", ++ (long long unsigned int)cmd->lun); ++ cmd->state = SCST_CMD_STATE_MODE_SELECT_CHECKS; ++ goto out; ++ } ++ } else { ++ TRACE(TRACE_SCSI, "cmd %p not succeeded with status %x", ++ cmd, cmd->status); ++ ++ if ((cmd->cdb[0] == RESERVE) || (cmd->cdb[0] == RESERVE_10)) { ++ if (!test_bit(SCST_TGT_DEV_RESERVED, ++ &cmd->tgt_dev->tgt_dev_flags)) { ++ struct scst_tgt_dev *tgt_dev_tmp; ++ struct scst_device *dev = cmd->dev; ++ ++ TRACE(TRACE_SCSI, "RESERVE failed lun=%lld, " ++ "status=%x", ++ (long long unsigned int)cmd->lun, ++ cmd->status); ++ PRINT_BUFF_FLAG(TRACE_SCSI, "Sense", cmd->sense, ++ cmd->sense_valid_len); ++ ++ /* Clearing the reservation */ ++ spin_lock_bh(&dev->dev_lock); ++ list_for_each_entry(tgt_dev_tmp, ++ &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ clear_bit(SCST_TGT_DEV_RESERVED, ++ &tgt_dev_tmp->tgt_dev_flags); ++ } ++ dev->dev_reserved = 0; ++ spin_unlock_bh(&dev->dev_lock); ++ } ++ } ++ ++ /* Check for MODE PARAMETERS CHANGED UA */ ++ if ((cmd->dev->scsi_dev != NULL) && ++ (cmd->status == SAM_STAT_CHECK_CONDITION) && ++ scst_is_ua_sense(cmd->sense, cmd->sense_valid_len) && ++ scst_analyze_sense(cmd->sense, cmd->sense_valid_len, ++ SCST_SENSE_ASCx_VALID, ++ 0, 0x2a, 0x01)) { ++ TRACE(TRACE_SCSI, "MODE PARAMETERS CHANGED UA (lun " ++ "%lld)", (long long unsigned int)cmd->lun); ++ cmd->state = SCST_CMD_STATE_MODE_SELECT_CHECKS; ++ goto out; ++ } ++ } ++ ++ cmd->state = SCST_CMD_STATE_DEV_DONE; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_mode_select_checks(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_RES_CONT_SAME; ++ ++ TRACE_ENTRY(); ++ ++ if (likely(scsi_status_is_good(cmd->status))) { ++ int atomic = scst_cmd_atomic(cmd); ++ if (unlikely((cmd->cdb[0] == MODE_SELECT) || ++ (cmd->cdb[0] == MODE_SELECT_10) || ++ (cmd->cdb[0] == LOG_SELECT))) { ++ struct scst_device *dev = cmd->dev; ++ int sl; ++ uint8_t sense_buffer[SCST_STANDARD_SENSE_LEN]; ++ ++ if (atomic && (dev->scsi_dev != NULL)) { ++ TRACE_DBG("%s", "MODE/LOG SELECT: thread " ++ "context required"); ++ res = SCST_CMD_STATE_RES_NEED_THREAD; ++ goto out; ++ } ++ ++ TRACE(TRACE_SCSI, "MODE/LOG SELECT succeeded, " ++ "setting the SELECT UA (lun=%lld)", ++ (long long unsigned int)cmd->lun); ++ ++ spin_lock_bh(&dev->dev_lock); ++ if (cmd->cdb[0] == LOG_SELECT) { ++ sl = scst_set_sense(sense_buffer, ++ sizeof(sense_buffer), ++ dev->d_sense, ++ UNIT_ATTENTION, 0x2a, 0x02); ++ } else { ++ sl = scst_set_sense(sense_buffer, ++ sizeof(sense_buffer), ++ dev->d_sense, ++ UNIT_ATTENTION, 0x2a, 0x01); ++ } ++ scst_dev_check_set_local_UA(dev, cmd, sense_buffer, sl); ++ spin_unlock_bh(&dev->dev_lock); ++ ++ if (dev->scsi_dev != NULL) ++ scst_obtain_device_parameters(dev); ++ } ++ } else if ((cmd->status == SAM_STAT_CHECK_CONDITION) && ++ scst_is_ua_sense(cmd->sense, cmd->sense_valid_len) && ++ /* mode parameters changed */ ++ (scst_analyze_sense(cmd->sense, cmd->sense_valid_len, ++ SCST_SENSE_ASCx_VALID, ++ 0, 0x2a, 0x01) || ++ scst_analyze_sense(cmd->sense, cmd->sense_valid_len, ++ SCST_SENSE_ASC_VALID, ++ 0, 0x29, 0) /* reset */ || ++ scst_analyze_sense(cmd->sense, cmd->sense_valid_len, ++ SCST_SENSE_ASC_VALID, ++ 0, 0x28, 0) /* medium changed */ || ++ /* cleared by another ini (just in case) */ ++ scst_analyze_sense(cmd->sense, cmd->sense_valid_len, ++ SCST_SENSE_ASC_VALID, ++ 0, 0x2F, 0))) { ++ int atomic = scst_cmd_atomic(cmd); ++ if (atomic) { ++ TRACE_DBG("Possible parameters changed UA %x: " ++ "thread context required", cmd->sense[12]); ++ res = SCST_CMD_STATE_RES_NEED_THREAD; ++ goto out; ++ } ++ ++ TRACE(TRACE_SCSI, "Possible parameters changed UA %x " ++ "(LUN %lld): getting new parameters", cmd->sense[12], ++ (long long unsigned int)cmd->lun); ++ ++ scst_obtain_device_parameters(cmd->dev); ++ } else ++ BUG(); ++ ++ cmd->state = SCST_CMD_STATE_DEV_DONE; ++ ++out: ++ TRACE_EXIT_HRES(res); ++ return res; ++} ++ ++static void scst_inc_check_expected_sn(struct scst_cmd *cmd) ++{ ++ if (likely(cmd->sn_set)) ++ scst_inc_expected_sn(cmd->cur_order_data, cmd->sn_slot); ++ ++ scst_make_deferred_commands_active(cmd->cur_order_data); ++} ++ ++static int scst_dev_done(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_RES_CONT_SAME; ++ int state; ++ struct scst_device *dev = cmd->dev; ++ ++ TRACE_ENTRY(); ++ ++ state = SCST_CMD_STATE_PRE_XMIT_RESP; ++ ++ if (likely(!scst_is_cmd_fully_local(cmd)) && ++ likely(dev->handler->dev_done != NULL)) { ++ int rc; ++ ++ if (unlikely(!dev->handler->dev_done_atomic && ++ scst_cmd_atomic(cmd))) { ++ /* ++ * It shouldn't be because of the SCST_TGT_DEV_AFTER_* ++ * optimization. ++ */ ++ TRACE_MGMT_DBG("Dev handler %s dev_done() needs thread " ++ "context, rescheduling", dev->handler->name); ++ res = SCST_CMD_STATE_RES_NEED_THREAD; ++ goto out; ++ } ++ ++ TRACE_DBG("Calling dev handler %s dev_done(%p)", ++ dev->handler->name, cmd); ++ scst_set_cur_start(cmd); ++ rc = dev->handler->dev_done(cmd); ++ scst_set_dev_done_time(cmd); ++ TRACE_DBG("Dev handler %s dev_done() returned %d", ++ dev->handler->name, rc); ++ if (rc != SCST_CMD_STATE_DEFAULT) ++ state = rc; ++ } ++ ++ switch (state) { ++#ifdef CONFIG_SCST_EXTRACHECKS ++ case SCST_CMD_STATE_PRE_XMIT_RESP: ++ case SCST_CMD_STATE_PARSE: ++ case SCST_CMD_STATE_PREPARE_SPACE: ++ case SCST_CMD_STATE_RDY_TO_XFER: ++ case SCST_CMD_STATE_TGT_PRE_EXEC: ++ case SCST_CMD_STATE_SEND_FOR_EXEC: ++ case SCST_CMD_STATE_START_EXEC: ++ case SCST_CMD_STATE_LOCAL_EXEC: ++ case SCST_CMD_STATE_REAL_EXEC: ++ case SCST_CMD_STATE_PRE_DEV_DONE: ++ case SCST_CMD_STATE_MODE_SELECT_CHECKS: ++ case SCST_CMD_STATE_DEV_DONE: ++ case SCST_CMD_STATE_XMIT_RESP: ++ case SCST_CMD_STATE_FINISHED: ++ case SCST_CMD_STATE_FINISHED_INTERNAL: ++#else ++ default: ++#endif ++ cmd->state = state; ++ break; ++ case SCST_CMD_STATE_NEED_THREAD_CTX: ++ TRACE_DBG("Dev handler %s dev_done() requested " ++ "thread context, rescheduling", ++ dev->handler->name); ++ res = SCST_CMD_STATE_RES_NEED_THREAD; ++ goto out; ++#ifdef CONFIG_SCST_EXTRACHECKS ++ default: ++ if (state >= 0) { ++ PRINT_ERROR("Dev handler %s dev_done() returned " ++ "invalid cmd state %d", ++ dev->handler->name, state); ++ } else { ++ PRINT_ERROR("Dev handler %s dev_done() returned " ++ "error %d", dev->handler->name, ++ state); ++ } ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ scst_set_cmd_abnormal_done_state(cmd); ++ break; ++#endif ++ } ++ ++ scst_check_unblock_dev(cmd); ++ ++ if (cmd->inc_expected_sn_on_done && cmd->sent_for_exec) ++ scst_inc_check_expected_sn(cmd); ++ ++ if (unlikely(cmd->internal)) ++ cmd->state = SCST_CMD_STATE_FINISHED_INTERNAL; ++ ++#ifndef CONFIG_SCST_TEST_IO_IN_SIRQ ++ if (cmd->state != SCST_CMD_STATE_PRE_XMIT_RESP) { ++ /* We can't allow atomic command on the exec stages */ ++ if (scst_cmd_atomic(cmd)) { ++ switch (state) { ++ case SCST_CMD_STATE_TGT_PRE_EXEC: ++ case SCST_CMD_STATE_SEND_FOR_EXEC: ++ case SCST_CMD_STATE_START_EXEC: ++ case SCST_CMD_STATE_LOCAL_EXEC: ++ case SCST_CMD_STATE_REAL_EXEC: ++ TRACE_DBG("Atomic context and redirect, " ++ "rescheduling (cmd %p)", cmd); ++ res = SCST_CMD_STATE_RES_NEED_THREAD; ++ break; ++ } ++ } ++ } ++#endif ++ ++out: ++ TRACE_EXIT_HRES(res); ++ return res; ++} ++ ++static int scst_pre_xmit_response(struct scst_cmd *cmd) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ EXTRACHECKS_BUG_ON(cmd->internal); ++ ++#ifdef CONFIG_SCST_DEBUG_TM ++ if (cmd->tm_dbg_delayed && ++ !test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags)) { ++ if (scst_cmd_atomic(cmd)) { ++ TRACE_MGMT_DBG("%s", ++ "DEBUG_TM delayed cmd needs a thread"); ++ res = SCST_CMD_STATE_RES_NEED_THREAD; ++ return res; ++ } ++ TRACE_MGMT_DBG("Delaying cmd %p (tag %llu) for 1 second", ++ cmd, cmd->tag); ++ schedule_timeout_uninterruptible(HZ); ++ } ++#endif ++ ++ if (likely(cmd->tgt_dev != NULL)) { ++ /* ++ * Those counters protect from not getting too long processing ++ * latency, so we should decrement them after cmd completed. ++ */ ++ atomic_dec(&cmd->tgt_dev->tgt_dev_cmd_count); ++#ifdef CONFIG_SCST_PER_DEVICE_CMD_COUNT_LIMIT ++ atomic_dec(&cmd->dev->dev_cmd_count); ++#endif ++ if (unlikely(cmd->queue_type == SCST_CMD_QUEUE_HEAD_OF_QUEUE)) ++ scst_on_hq_cmd_response(cmd); ++ ++ if (unlikely(!cmd->sent_for_exec)) { ++ TRACE_SN("cmd %p was not sent to mid-lev" ++ " (sn %d, set %d)", ++ cmd, cmd->sn, cmd->sn_set); ++ scst_unblock_deferred(cmd->cur_order_data, cmd); ++ cmd->sent_for_exec = 1; ++ } ++ } ++ ++ cmd->done = 1; ++ smp_mb(); /* to sync with scst_abort_cmd() */ ++ ++ if (unlikely(test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags))) ++ scst_xmit_process_aborted_cmd(cmd); ++ else if (unlikely(cmd->status == SAM_STAT_CHECK_CONDITION)) ++ scst_store_sense(cmd); ++ ++ if (unlikely(test_bit(SCST_CMD_NO_RESP, &cmd->cmd_flags))) { ++ TRACE_MGMT_DBG("Flag NO_RESP set for cmd %p (tag %llu), " ++ "skipping", cmd, (long long unsigned int)cmd->tag); ++ cmd->state = SCST_CMD_STATE_FINISHED; ++ res = SCST_CMD_STATE_RES_CONT_SAME; ++ goto out; ++ } ++ ++ if (unlikely(cmd->resid_possible)) ++ scst_adjust_resp_data_len(cmd); ++ else ++ cmd->adjusted_resp_data_len = cmd->resp_data_len; ++ ++ cmd->state = SCST_CMD_STATE_XMIT_RESP; ++ res = SCST_CMD_STATE_RES_CONT_SAME; ++ ++out: ++ TRACE_EXIT_HRES(res); ++ return res; ++} ++ ++static int scst_xmit_response(struct scst_cmd *cmd) ++{ ++ struct scst_tgt_template *tgtt = cmd->tgtt; ++ int res, rc; ++ ++ TRACE_ENTRY(); ++ ++ EXTRACHECKS_BUG_ON(cmd->internal); ++ ++ if (unlikely(!tgtt->xmit_response_atomic && ++ scst_cmd_atomic(cmd))) { ++ /* ++ * It shouldn't be because of the SCST_TGT_DEV_AFTER_* ++ * optimization. ++ */ ++ TRACE_MGMT_DBG("Target driver %s xmit_response() needs thread " ++ "context, rescheduling", tgtt->name); ++ res = SCST_CMD_STATE_RES_NEED_THREAD; ++ goto out; ++ } ++ ++ while (1) { ++ int finished_cmds = atomic_read(&cmd->tgt->finished_cmds); ++ ++ res = SCST_CMD_STATE_RES_CONT_NEXT; ++ cmd->state = SCST_CMD_STATE_XMIT_WAIT; ++ ++ TRACE_DBG("Calling xmit_response(%p)", cmd); ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ if (trace_flag & TRACE_SND_BOT) { ++ int i, j; ++ struct scatterlist *sg; ++ if (cmd->tgt_sg != NULL) ++ sg = cmd->tgt_sg; ++ else ++ sg = cmd->sg; ++ if (sg != NULL) { ++ TRACE(TRACE_SND_BOT, "Xmitting data for cmd %p " ++ "(sg_cnt %d, sg %p, sg[0].page %p, buf %p, " ++ "resp len %d)", cmd, cmd->tgt_sg_cnt, ++ sg, (void *)sg_page(&sg[0]), sg_virt(sg), ++ cmd->resp_data_len); ++ for (i = 0, j = 0; i < cmd->tgt_sg_cnt; ++i, ++j) { ++ if (unlikely(sg_is_chain(&sg[j]))) { ++ sg = sg_chain_ptr(&sg[j]); ++ j = 0; ++ } ++ TRACE(TRACE_SND_BOT, "sg %d", j); ++ PRINT_BUFF_FLAG(TRACE_SND_BOT, ++ "Xmitting sg", sg_virt(&sg[j]), ++ sg[j].length); ++ } ++ } ++ } ++#endif ++ ++ if (tgtt->on_hw_pending_cmd_timeout != NULL) { ++ struct scst_session *sess = cmd->sess; ++ cmd->hw_pending_start = jiffies; ++ cmd->cmd_hw_pending = 1; ++ if (!test_bit(SCST_SESS_HW_PENDING_WORK_SCHEDULED, &sess->sess_aflags)) { ++ TRACE_DBG("Sched HW pending work for sess %p " ++ "(max time %d)", sess, ++ tgtt->max_hw_pending_time); ++ set_bit(SCST_SESS_HW_PENDING_WORK_SCHEDULED, ++ &sess->sess_aflags); ++ schedule_delayed_work(&sess->hw_pending_work, ++ tgtt->max_hw_pending_time * HZ); ++ } ++ } ++ ++ scst_set_cur_start(cmd); ++ ++#ifdef CONFIG_SCST_DEBUG_RETRY ++ if (((scst_random() % 100) == 77)) ++ rc = SCST_TGT_RES_QUEUE_FULL; ++ else ++#endif ++ rc = tgtt->xmit_response(cmd); ++ TRACE_DBG("xmit_response() returned %d", rc); ++ ++ if (likely(rc == SCST_TGT_RES_SUCCESS)) ++ goto out; ++ ++ scst_set_xmit_time(cmd); ++ ++ cmd->cmd_hw_pending = 0; ++ ++ /* Restore the previous state */ ++ cmd->state = SCST_CMD_STATE_XMIT_RESP; ++ ++ switch (rc) { ++ case SCST_TGT_RES_QUEUE_FULL: ++ if (scst_queue_retry_cmd(cmd, finished_cmds) == 0) ++ break; ++ else ++ continue; ++ ++ case SCST_TGT_RES_NEED_THREAD_CTX: ++ TRACE_DBG("Target driver %s xmit_response() " ++ "requested thread context, rescheduling", ++ tgtt->name); ++ res = SCST_CMD_STATE_RES_NEED_THREAD; ++ goto out; ++ ++ default: ++ goto out_error; ++ } ++ break; ++ } ++ ++out: ++ /* Caution: cmd can be already dead here */ ++ TRACE_EXIT_HRES(res); ++ return res; ++ ++out_error: ++ if (rc == SCST_TGT_RES_FATAL_ERROR) { ++ PRINT_ERROR("Target driver %s xmit_response() returned " ++ "fatal error", tgtt->name); ++ } else { ++ PRINT_ERROR("Target driver %s xmit_response() returned " ++ "invalid value %d", tgtt->name, rc); ++ } ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ cmd->state = SCST_CMD_STATE_FINISHED; ++ res = SCST_CMD_STATE_RES_CONT_SAME; ++ goto out; ++} ++ ++/** ++ * scst_tgt_cmd_done() - the command's processing done ++ * @cmd: SCST command ++ * @pref_context: preferred command execution context ++ * ++ * Description: ++ * Notifies SCST that the driver sent the response and the command ++ * can be freed now. Don't forget to set the delivery status, if it ++ * isn't success, using scst_set_delivery_status() before calling ++ * this function. The third argument sets preferred command execution ++ * context (see SCST_CONTEXT_* constants for details) ++ */ ++void scst_tgt_cmd_done(struct scst_cmd *cmd, ++ enum scst_exec_context pref_context) ++{ ++ TRACE_ENTRY(); ++ ++ BUG_ON(cmd->state != SCST_CMD_STATE_XMIT_WAIT); ++ ++ scst_set_xmit_time(cmd); ++ ++ cmd->cmd_hw_pending = 0; ++ ++ if (unlikely(cmd->tgt_dev == NULL)) ++ pref_context = SCST_CONTEXT_THREAD; ++ ++ cmd->state = SCST_CMD_STATE_FINISHED; ++ ++ scst_process_redirect_cmd(cmd, pref_context, 1); ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL(scst_tgt_cmd_done); ++ ++static int scst_finish_cmd(struct scst_cmd *cmd) ++{ ++ int res; ++ struct scst_session *sess = cmd->sess; ++ struct scst_io_stat_entry *stat; ++ ++ TRACE_ENTRY(); ++ ++ scst_update_lat_stats(cmd); ++ ++ if (unlikely(cmd->delivery_status != SCST_CMD_DELIVERY_SUCCESS)) { ++ if ((cmd->tgt_dev != NULL) && ++ scst_is_ua_sense(cmd->sense, cmd->sense_valid_len)) { ++ /* This UA delivery failed, so we need to requeue it */ ++ if (scst_cmd_atomic(cmd) && ++ scst_is_ua_global(cmd->sense, cmd->sense_valid_len)) { ++ TRACE_MGMT_DBG("Requeuing of global UA for " ++ "failed cmd %p needs a thread", cmd); ++ res = SCST_CMD_STATE_RES_NEED_THREAD; ++ goto out; ++ } ++ scst_requeue_ua(cmd); ++ } ++ } ++ ++ atomic_dec(&sess->sess_cmd_count); ++ ++ spin_lock_irq(&sess->sess_list_lock); ++ ++ stat = &sess->io_stats[cmd->data_direction]; ++ stat->cmd_count++; ++ stat->io_byte_count += cmd->bufflen + cmd->out_bufflen; ++ ++ list_del(&cmd->sess_cmd_list_entry); ++ ++ /* ++ * Done under sess_list_lock to sync with scst_abort_cmd() without ++ * using extra barrier. ++ */ ++ cmd->finished = 1; ++ ++ spin_unlock_irq(&sess->sess_list_lock); ++ ++ if (unlikely(test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags))) { ++ TRACE_MGMT_DBG("Aborted cmd %p finished (cmd_ref %d)", ++ cmd, atomic_read(&cmd->cmd_ref)); ++ ++ scst_finish_cmd_mgmt(cmd); ++ } ++ ++ __scst_cmd_put(cmd); ++ ++ res = SCST_CMD_STATE_RES_CONT_NEXT; ++ ++out: ++ TRACE_EXIT_HRES(res); ++ return res; ++} ++ ++/* ++ * No locks, but it must be externally serialized (see comment for ++ * scst_cmd_init_done() in scst.h) ++ */ ++static void scst_cmd_set_sn(struct scst_cmd *cmd) ++{ ++ struct scst_order_data *order_data = cmd->cur_order_data; ++ unsigned long flags; ++ ++ TRACE_ENTRY(); ++ ++ if (scst_is_implicit_hq_cmd(cmd) && ++ likely(cmd->queue_type == SCST_CMD_QUEUE_SIMPLE)) { ++ TRACE_SN("Implicit HQ cmd %p", cmd); ++ cmd->queue_type = SCST_CMD_QUEUE_HEAD_OF_QUEUE; ++ } ++ ++ EXTRACHECKS_BUG_ON(cmd->sn_set || cmd->hq_cmd_inced); ++ ++ /* Optimized for lockless fast path */ ++ ++ scst_check_debug_sn(cmd); ++ ++#ifdef CONFIG_SCST_STRICT_SERIALIZING ++ cmd->queue_type = SCST_CMD_QUEUE_ORDERED; ++#endif ++ ++ if (cmd->dev->queue_alg == SCST_CONTR_MODE_QUEUE_ALG_RESTRICTED_REORDER) { ++ /* ++ * Not the best way, but good enough until there is a ++ * possibility to specify queue type during pass-through ++ * commands submission. ++ */ ++ cmd->queue_type = SCST_CMD_QUEUE_ORDERED; ++ } ++ ++ switch (cmd->queue_type) { ++ case SCST_CMD_QUEUE_SIMPLE: ++ case SCST_CMD_QUEUE_UNTAGGED: ++ if (likely(order_data->num_free_sn_slots >= 0)) { ++ /* ++ * atomic_inc_return() implies memory barrier to sync ++ * with scst_inc_expected_sn() ++ */ ++ if (atomic_inc_return(order_data->cur_sn_slot) == 1) { ++ order_data->curr_sn++; ++ TRACE_SN("Incremented curr_sn %d", ++ order_data->curr_sn); ++ } ++ cmd->sn_slot = order_data->cur_sn_slot; ++ cmd->sn = order_data->curr_sn; ++ ++ order_data->prev_cmd_ordered = 0; ++ } else { ++ TRACE(TRACE_MINOR, "***WARNING*** Not enough SN slots " ++ "%zd", ARRAY_SIZE(order_data->sn_slots)); ++ goto ordered; ++ } ++ break; ++ ++ case SCST_CMD_QUEUE_ORDERED: ++ TRACE_SN("ORDERED cmd %p (op %x)", cmd, cmd->cdb[0]); ++ordered: ++ if (!order_data->prev_cmd_ordered) { ++ spin_lock_irqsave(&order_data->sn_lock, flags); ++ if (order_data->num_free_sn_slots >= 0) { ++ order_data->num_free_sn_slots--; ++ if (order_data->num_free_sn_slots >= 0) { ++ int i = 0; ++ /* Commands can finish in any order, so ++ * we don't know which slot is empty. ++ */ ++ while (1) { ++ order_data->cur_sn_slot++; ++ if (order_data->cur_sn_slot == ++ order_data->sn_slots + ARRAY_SIZE(order_data->sn_slots)) ++ order_data->cur_sn_slot = order_data->sn_slots; ++ ++ if (atomic_read(order_data->cur_sn_slot) == 0) ++ break; ++ ++ i++; ++ BUG_ON(i == ARRAY_SIZE(order_data->sn_slots)); ++ } ++ TRACE_SN("New cur SN slot %zd", ++ order_data->cur_sn_slot - ++ order_data->sn_slots); ++ } ++ } ++ spin_unlock_irqrestore(&order_data->sn_lock, flags); ++ } ++ order_data->prev_cmd_ordered = 1; ++ order_data->curr_sn++; ++ cmd->sn = order_data->curr_sn; ++ break; ++ ++ case SCST_CMD_QUEUE_HEAD_OF_QUEUE: ++ TRACE_SN("HQ cmd %p (op %x)", cmd, cmd->cdb[0]); ++ spin_lock_irqsave(&order_data->sn_lock, flags); ++ order_data->hq_cmd_count++; ++ spin_unlock_irqrestore(&order_data->sn_lock, flags); ++ cmd->hq_cmd_inced = 1; ++ goto out; ++ ++ default: ++ BUG(); ++ } ++ ++ TRACE_SN("cmd(%p)->sn: %d (order_data %p, *cur_sn_slot %d, " ++ "num_free_sn_slots %d, prev_cmd_ordered %ld, " ++ "cur_sn_slot %zd)", cmd, cmd->sn, order_data, ++ atomic_read(order_data->cur_sn_slot), ++ order_data->num_free_sn_slots, order_data->prev_cmd_ordered, ++ order_data->cur_sn_slot - order_data->sn_slots); ++ ++ cmd->sn_set = 1; ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * Returns 0 on success, > 0 when we need to wait for unblock, ++ * < 0 if there is no device (lun) or device type handler. ++ * ++ * No locks, but might be on IRQ, protection is done by the ++ * suspended activity. ++ */ ++static int scst_translate_lun(struct scst_cmd *cmd) ++{ ++ struct scst_tgt_dev *tgt_dev = NULL; ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ cmd->cpu_cmd_counter = scst_get(); ++ ++ if (likely(!test_bit(SCST_FLAG_SUSPENDED, &scst_flags))) { ++ struct list_head *head = ++ &cmd->sess->sess_tgt_dev_list[SESS_TGT_DEV_LIST_HASH_FN(cmd->lun)]; ++ TRACE_DBG("Finding tgt_dev for cmd %p (lun %lld)", cmd, ++ (long long unsigned int)cmd->lun); ++ res = -1; ++ list_for_each_entry(tgt_dev, head, sess_tgt_dev_list_entry) { ++ if (tgt_dev->lun == cmd->lun) { ++ TRACE_DBG("tgt_dev %p found", tgt_dev); ++ ++ if (unlikely(tgt_dev->dev->handler == ++ &scst_null_devtype)) { ++ PRINT_INFO("Dev handler for device " ++ "%lld is NULL, the device will not " ++ "be visible remotely", ++ (long long unsigned int)cmd->lun); ++ break; ++ } ++ ++ cmd->cmd_threads = tgt_dev->active_cmd_threads; ++ cmd->tgt_dev = tgt_dev; ++ cmd->cur_order_data = tgt_dev->curr_order_data; ++ cmd->dev = tgt_dev->dev; ++ ++ res = 0; ++ break; ++ } ++ } ++ if (res != 0) { ++ TRACE(TRACE_MINOR, ++ "tgt_dev for LUN %lld not found, command to " ++ "unexisting LU (initiator %s, target %s)?", ++ (long long unsigned int)cmd->lun, ++ cmd->sess->initiator_name, cmd->tgt->tgt_name); ++ scst_put(cmd->cpu_cmd_counter); ++ } ++ } else { ++ TRACE_MGMT_DBG("%s", "FLAG SUSPENDED set, skipping"); ++ scst_put(cmd->cpu_cmd_counter); ++ res = 1; ++ } ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* ++ * No locks, but might be on IRQ. ++ * ++ * Returns 0 on success, > 0 when we need to wait for unblock, ++ * < 0 if there is no device (lun) or device type handler. ++ */ ++static int __scst_init_cmd(struct scst_cmd *cmd) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ res = scst_translate_lun(cmd); ++ if (likely(res == 0)) { ++ int cnt; ++ bool failure = false; ++ ++ cmd->state = SCST_CMD_STATE_PARSE; ++ ++ cnt = atomic_inc_return(&cmd->tgt_dev->tgt_dev_cmd_count); ++ if (unlikely(cnt > SCST_MAX_TGT_DEV_COMMANDS)) { ++ TRACE(TRACE_FLOW_CONTROL, ++ "Too many pending commands (%d) in " ++ "session, returning BUSY to initiator \"%s\"", ++ cnt, (cmd->sess->initiator_name[0] == '\0') ? ++ "Anonymous" : cmd->sess->initiator_name); ++ failure = true; ++ } ++ ++#ifdef CONFIG_SCST_PER_DEVICE_CMD_COUNT_LIMIT ++ cnt = atomic_inc_return(&cmd->dev->dev_cmd_count); ++ if (unlikely(cnt > SCST_MAX_DEV_COMMANDS)) { ++ if (!failure) { ++ TRACE(TRACE_FLOW_CONTROL, ++ "Too many pending device " ++ "commands (%d), returning BUSY to " ++ "initiator \"%s\"", cnt, ++ (cmd->sess->initiator_name[0] == '\0') ? ++ "Anonymous" : ++ cmd->sess->initiator_name); ++ failure = true; ++ } ++ } ++#endif ++ ++ if (unlikely(failure)) ++ goto out_busy; ++ ++ /* ++ * SCST_IMPLICIT_HQ for unknown commands not implemented for ++ * case when set_sn_on_restart_cmd not set, because custom parse ++ * can reorder commands due to multithreaded processing. To ++ * implement it we need to implement all unknown commands as ++ * ORDERED in the beginning and post parse reprocess of ++ * queue_type to change it if needed. ToDo. ++ */ ++ scst_pre_parse(cmd); ++ ++ if (!cmd->set_sn_on_restart_cmd) ++ scst_cmd_set_sn(cmd); ++ } else if (res < 0) { ++ TRACE_DBG("Finishing cmd %p", cmd); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_lun_not_supported)); ++ scst_set_cmd_abnormal_done_state(cmd); ++ } else ++ goto out; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_busy: ++ scst_set_busy(cmd); ++ scst_set_cmd_abnormal_done_state(cmd); ++ goto out; ++} ++ ++/* Called under scst_init_lock and IRQs disabled */ ++static void scst_do_job_init(void) ++ __releases(&scst_init_lock) ++ __acquires(&scst_init_lock) ++{ ++ struct scst_cmd *cmd; ++ int susp; ++ ++ TRACE_ENTRY(); ++ ++restart: ++ /* ++ * There is no need for read barrier here, because we don't care where ++ * this check will be done. ++ */ ++ susp = test_bit(SCST_FLAG_SUSPENDED, &scst_flags); ++ if (scst_init_poll_cnt > 0) ++ scst_init_poll_cnt--; ++ ++ list_for_each_entry(cmd, &scst_init_cmd_list, cmd_list_entry) { ++ int rc; ++ if (susp && !test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags)) ++ continue; ++ if (!test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags)) { ++ spin_unlock_irq(&scst_init_lock); ++ rc = __scst_init_cmd(cmd); ++ spin_lock_irq(&scst_init_lock); ++ if (rc > 0) { ++ TRACE_MGMT_DBG("%s", ++ "FLAG SUSPENDED set, restarting"); ++ goto restart; ++ } ++ } else { ++ TRACE_MGMT_DBG("Aborting not inited cmd %p (tag %llu)", ++ cmd, (long long unsigned int)cmd->tag); ++ scst_set_cmd_abnormal_done_state(cmd); ++ } ++ ++ /* ++ * Deleting cmd from init cmd list after __scst_init_cmd() ++ * is necessary to keep the check in scst_init_cmd() correct ++ * to preserve the commands order. ++ * ++ * We don't care about the race, when init cmd list is empty ++ * and one command detected that it just was not empty, so ++ * it's inserting to it, but another command at the same time ++ * seeing init cmd list empty and goes directly, because it ++ * could affect only commands from the same initiator to the ++ * same tgt_dev, but scst_cmd_init_done*() doesn't guarantee ++ * the order in case of simultaneous such calls anyway. ++ */ ++ TRACE_MGMT_DBG("Deleting cmd %p from init cmd list", cmd); ++ smp_wmb(); /* enforce the required order */ ++ list_del(&cmd->cmd_list_entry); ++ spin_unlock(&scst_init_lock); ++ ++ spin_lock(&cmd->cmd_threads->cmd_list_lock); ++ TRACE_MGMT_DBG("Adding cmd %p to active cmd list", cmd); ++ if (unlikely(cmd->queue_type == SCST_CMD_QUEUE_HEAD_OF_QUEUE)) ++ list_add(&cmd->cmd_list_entry, ++ &cmd->cmd_threads->active_cmd_list); ++ else ++ list_add_tail(&cmd->cmd_list_entry, ++ &cmd->cmd_threads->active_cmd_list); ++ wake_up(&cmd->cmd_threads->cmd_list_waitQ); ++ spin_unlock(&cmd->cmd_threads->cmd_list_lock); ++ ++ spin_lock(&scst_init_lock); ++ goto restart; ++ } ++ ++ /* It isn't really needed, but let's keep it */ ++ if (susp != test_bit(SCST_FLAG_SUSPENDED, &scst_flags)) ++ goto restart; ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static inline int test_init_cmd_list(void) ++{ ++ int res = (!list_empty(&scst_init_cmd_list) && ++ !test_bit(SCST_FLAG_SUSPENDED, &scst_flags)) || ++ unlikely(kthread_should_stop()) || ++ (scst_init_poll_cnt > 0); ++ return res; ++} ++ ++int scst_init_thread(void *arg) ++{ ++ TRACE_ENTRY(); ++ ++ PRINT_INFO("Init thread started, PID %d", current->pid); ++ ++ current->flags |= PF_NOFREEZE; ++ ++ set_user_nice(current, -10); ++ ++ spin_lock_irq(&scst_init_lock); ++ while (!kthread_should_stop()) { ++ wait_queue_t wait; ++ init_waitqueue_entry(&wait, current); ++ ++ if (!test_init_cmd_list()) { ++ add_wait_queue_exclusive(&scst_init_cmd_list_waitQ, ++ &wait); ++ for (;;) { ++ set_current_state(TASK_INTERRUPTIBLE); ++ if (test_init_cmd_list()) ++ break; ++ spin_unlock_irq(&scst_init_lock); ++ schedule(); ++ spin_lock_irq(&scst_init_lock); ++ } ++ set_current_state(TASK_RUNNING); ++ remove_wait_queue(&scst_init_cmd_list_waitQ, &wait); ++ } ++ scst_do_job_init(); ++ } ++ spin_unlock_irq(&scst_init_lock); ++ ++ /* ++ * If kthread_should_stop() is true, we are guaranteed to be ++ * on the module unload, so scst_init_cmd_list must be empty. ++ */ ++ BUG_ON(!list_empty(&scst_init_cmd_list)); ++ ++ PRINT_INFO("Init thread PID %d finished", current->pid); ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++/** ++ * scst_process_active_cmd() - process active command ++ * ++ * Description: ++ * Main SCST commands processing routing. Must be used only by dev handlers. ++ * ++ * Argument atomic is true, if function called in atomic context. ++ * ++ * Must be called with no locks held. ++ */ ++void scst_process_active_cmd(struct scst_cmd *cmd, bool atomic) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * Checkpatch will complain on the use of in_atomic() below. You ++ * can safely ignore this warning since in_atomic() is used here only ++ * for debugging purposes. ++ */ ++ EXTRACHECKS_BUG_ON(in_irq() || irqs_disabled()); ++ EXTRACHECKS_WARN_ON((in_atomic() || in_interrupt()) && !atomic); ++ ++ cmd->atomic = atomic; ++ ++ TRACE_DBG("cmd %p, atomic %d", cmd, atomic); ++ ++ do { ++ switch (cmd->state) { ++ case SCST_CMD_STATE_PARSE: ++ res = scst_parse_cmd(cmd); ++ break; ++ ++ case SCST_CMD_STATE_PREPARE_SPACE: ++ res = scst_prepare_space(cmd); ++ break; ++ ++ case SCST_CMD_STATE_PREPROCESSING_DONE: ++ res = scst_preprocessing_done(cmd); ++ break; ++ ++ case SCST_CMD_STATE_RDY_TO_XFER: ++ res = scst_rdy_to_xfer(cmd); ++ break; ++ ++ case SCST_CMD_STATE_TGT_PRE_EXEC: ++ res = scst_tgt_pre_exec(cmd); ++ break; ++ ++ case SCST_CMD_STATE_SEND_FOR_EXEC: ++ if (tm_dbg_check_cmd(cmd) != 0) { ++ res = SCST_CMD_STATE_RES_CONT_NEXT; ++ TRACE_MGMT_DBG("Skipping cmd %p (tag %llu), " ++ "because of TM DBG delay", cmd, ++ (long long unsigned int)cmd->tag); ++ break; ++ } ++ res = scst_send_for_exec(&cmd); ++ EXTRACHECKS_BUG_ON(res == SCST_CMD_STATE_RES_NEED_THREAD); ++ /* ++ * !! At this point cmd, sess & tgt_dev can already be ++ * freed !! ++ */ ++ break; ++ ++ case SCST_CMD_STATE_START_EXEC: ++ res = scst_exec(&cmd); ++ EXTRACHECKS_BUG_ON(res == SCST_CMD_STATE_RES_NEED_THREAD); ++ /* ++ * !! At this point cmd, sess & tgt_dev can already be ++ * freed !! ++ */ ++ break; ++ ++ case SCST_CMD_STATE_LOCAL_EXEC: ++ res = scst_local_exec(cmd); ++ EXTRACHECKS_BUG_ON(res == SCST_CMD_STATE_RES_NEED_THREAD); ++ /* ++ * !! At this point cmd, sess & tgt_dev can already be ++ * freed !! ++ */ ++ break; ++ ++ case SCST_CMD_STATE_REAL_EXEC: ++ res = scst_real_exec(cmd); ++ EXTRACHECKS_BUG_ON(res == SCST_CMD_STATE_RES_NEED_THREAD); ++ /* ++ * !! At this point cmd, sess & tgt_dev can already be ++ * freed !! ++ */ ++ break; ++ ++ case SCST_CMD_STATE_PRE_DEV_DONE: ++ res = scst_pre_dev_done(cmd); ++ EXTRACHECKS_BUG_ON((res == SCST_CMD_STATE_RES_NEED_THREAD) && ++ (cmd->state == SCST_CMD_STATE_PRE_DEV_DONE)); ++ break; ++ ++ case SCST_CMD_STATE_MODE_SELECT_CHECKS: ++ res = scst_mode_select_checks(cmd); ++ break; ++ ++ case SCST_CMD_STATE_DEV_DONE: ++ res = scst_dev_done(cmd); ++ break; ++ ++ case SCST_CMD_STATE_PRE_XMIT_RESP: ++ res = scst_pre_xmit_response(cmd); ++ EXTRACHECKS_BUG_ON(res == ++ SCST_CMD_STATE_RES_NEED_THREAD); ++ break; ++ ++ case SCST_CMD_STATE_XMIT_RESP: ++ res = scst_xmit_response(cmd); ++ break; ++ ++ case SCST_CMD_STATE_FINISHED: ++ res = scst_finish_cmd(cmd); ++ break; ++ ++ case SCST_CMD_STATE_FINISHED_INTERNAL: ++ res = scst_finish_internal_cmd(cmd); ++ EXTRACHECKS_BUG_ON(res == ++ SCST_CMD_STATE_RES_NEED_THREAD); ++ break; ++ ++ default: ++ PRINT_CRIT_ERROR("cmd (%p) in state %d, but shouldn't " ++ "be", cmd, cmd->state); ++ BUG(); ++ res = SCST_CMD_STATE_RES_CONT_NEXT; ++ break; ++ } ++ } while (res == SCST_CMD_STATE_RES_CONT_SAME); ++ ++ if (res == SCST_CMD_STATE_RES_CONT_NEXT) { ++ /* None */ ++ } else if (res == SCST_CMD_STATE_RES_NEED_THREAD) { ++ spin_lock_irq(&cmd->cmd_threads->cmd_list_lock); ++#ifdef CONFIG_SCST_EXTRACHECKS ++ switch (cmd->state) { ++ case SCST_CMD_STATE_PARSE: ++ case SCST_CMD_STATE_PREPARE_SPACE: ++ case SCST_CMD_STATE_RDY_TO_XFER: ++ case SCST_CMD_STATE_TGT_PRE_EXEC: ++ case SCST_CMD_STATE_SEND_FOR_EXEC: ++ case SCST_CMD_STATE_START_EXEC: ++ case SCST_CMD_STATE_LOCAL_EXEC: ++ case SCST_CMD_STATE_REAL_EXEC: ++ case SCST_CMD_STATE_DEV_DONE: ++ case SCST_CMD_STATE_XMIT_RESP: ++#endif ++ TRACE_DBG("Adding cmd %p to head of active cmd list", ++ cmd); ++ list_add(&cmd->cmd_list_entry, ++ &cmd->cmd_threads->active_cmd_list); ++#ifdef CONFIG_SCST_EXTRACHECKS ++ break; ++ default: ++ PRINT_CRIT_ERROR("cmd %p is in invalid state %d)", cmd, ++ cmd->state); ++ spin_unlock_irq(&cmd->cmd_threads->cmd_list_lock); ++ BUG(); ++ spin_lock_irq(&cmd->cmd_threads->cmd_list_lock); ++ break; ++ } ++#endif ++ wake_up(&cmd->cmd_threads->cmd_list_waitQ); ++ spin_unlock_irq(&cmd->cmd_threads->cmd_list_lock); ++ } else ++ BUG(); ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL_GPL(scst_process_active_cmd); ++ ++/* Called under cmd_list_lock and IRQs disabled */ ++static void scst_do_job_active(struct list_head *cmd_list, ++ spinlock_t *cmd_list_lock, bool atomic) ++ __releases(cmd_list_lock) ++ __acquires(cmd_list_lock) ++{ ++ TRACE_ENTRY(); ++ ++ while (!list_empty(cmd_list)) { ++ struct scst_cmd *cmd = list_entry(cmd_list->next, typeof(*cmd), ++ cmd_list_entry); ++ TRACE_DBG("Deleting cmd %p from active cmd list", cmd); ++ list_del(&cmd->cmd_list_entry); ++ spin_unlock_irq(cmd_list_lock); ++ scst_process_active_cmd(cmd, atomic); ++ spin_lock_irq(cmd_list_lock); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static inline int test_cmd_threads(struct scst_cmd_threads *p_cmd_threads) ++{ ++ int res = !list_empty(&p_cmd_threads->active_cmd_list) || ++ unlikely(kthread_should_stop()) || ++ tm_dbg_is_release(); ++ return res; ++} ++ ++int scst_cmd_thread(void *arg) ++{ ++ struct scst_cmd_threads *p_cmd_threads = arg; ++ ++ TRACE_ENTRY(); ++ ++ PRINT_INFO("Processing thread %s (PID %d) started", current->comm, ++ current->pid); ++ ++#if 0 ++ set_user_nice(current, 10); ++#endif ++ current->flags |= PF_NOFREEZE; ++ ++ mutex_lock(&p_cmd_threads->io_context_mutex); ++ ++ WARN_ON(current->io_context); ++ ++ if (p_cmd_threads != &scst_main_cmd_threads) { ++ /* ++ * For linked IO contexts io_context might be not NULL while ++ * io_context 0. ++ */ ++ if (p_cmd_threads->io_context == NULL) { ++ p_cmd_threads->io_context = get_io_context(GFP_KERNEL, -1); ++ TRACE_MGMT_DBG("Alloced new IO context %p " ++ "(p_cmd_threads %p)", ++ p_cmd_threads->io_context, ++ p_cmd_threads); ++ /* ++ * Put the extra reference created by get_io_context() ++ * because we don't need it. ++ */ ++ put_io_context(p_cmd_threads->io_context); ++ } else { ++ current->io_context = ioc_task_link(p_cmd_threads->io_context); ++ TRACE_MGMT_DBG("Linked IO context %p " ++ "(p_cmd_threads %p)", p_cmd_threads->io_context, ++ p_cmd_threads); ++ } ++ p_cmd_threads->io_context_refcnt++; ++ } ++ ++ mutex_unlock(&p_cmd_threads->io_context_mutex); ++ ++ smp_wmb(); ++ p_cmd_threads->io_context_ready = true; ++ ++ spin_lock_irq(&p_cmd_threads->cmd_list_lock); ++ while (!kthread_should_stop()) { ++ wait_queue_t wait; ++ init_waitqueue_entry(&wait, current); ++ ++ if (!test_cmd_threads(p_cmd_threads)) { ++ add_wait_queue_exclusive_head( ++ &p_cmd_threads->cmd_list_waitQ, ++ &wait); ++ for (;;) { ++ set_current_state(TASK_INTERRUPTIBLE); ++ if (test_cmd_threads(p_cmd_threads)) ++ break; ++ spin_unlock_irq(&p_cmd_threads->cmd_list_lock); ++ schedule(); ++ spin_lock_irq(&p_cmd_threads->cmd_list_lock); ++ } ++ set_current_state(TASK_RUNNING); ++ remove_wait_queue(&p_cmd_threads->cmd_list_waitQ, &wait); ++ } ++ ++ if (tm_dbg_is_release()) { ++ spin_unlock_irq(&p_cmd_threads->cmd_list_lock); ++ tm_dbg_check_released_cmds(); ++ spin_lock_irq(&p_cmd_threads->cmd_list_lock); ++ } ++ ++ scst_do_job_active(&p_cmd_threads->active_cmd_list, ++ &p_cmd_threads->cmd_list_lock, false); ++ } ++ spin_unlock_irq(&p_cmd_threads->cmd_list_lock); ++ ++ if (p_cmd_threads != &scst_main_cmd_threads) { ++ mutex_lock(&p_cmd_threads->io_context_mutex); ++ if (--p_cmd_threads->io_context_refcnt == 0) ++ p_cmd_threads->io_context = NULL; ++ mutex_unlock(&p_cmd_threads->io_context_mutex); ++ } ++ ++ PRINT_INFO("Processing thread %s (PID %d) finished", current->comm, ++ current->pid); ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++void scst_cmd_tasklet(long p) ++{ ++ struct scst_percpu_info *i = (struct scst_percpu_info *)p; ++ ++ TRACE_ENTRY(); ++ ++ spin_lock_irq(&i->tasklet_lock); ++ scst_do_job_active(&i->tasklet_cmd_list, &i->tasklet_lock, true); ++ spin_unlock_irq(&i->tasklet_lock); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * Returns 0 on success, < 0 if there is no device handler or ++ * > 0 if SCST_FLAG_SUSPENDED set and SCST_FLAG_SUSPENDING - not. ++ * No locks, protection is done by the suspended activity. ++ */ ++static int scst_mgmt_translate_lun(struct scst_mgmt_cmd *mcmd) ++{ ++ struct scst_tgt_dev *tgt_dev = NULL; ++ struct list_head *head; ++ int res = -1; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Finding tgt_dev for mgmt cmd %p (lun %lld)", mcmd, ++ (long long unsigned int)mcmd->lun); ++ ++ mcmd->cpu_cmd_counter = scst_get(); ++ ++ if (unlikely(test_bit(SCST_FLAG_SUSPENDED, &scst_flags) && ++ !test_bit(SCST_FLAG_SUSPENDING, &scst_flags))) { ++ TRACE_MGMT_DBG("%s", "FLAG SUSPENDED set, skipping"); ++ scst_put(mcmd->cpu_cmd_counter); ++ res = 1; ++ goto out; ++ } ++ ++ head = &mcmd->sess->sess_tgt_dev_list[SESS_TGT_DEV_LIST_HASH_FN(mcmd->lun)]; ++ list_for_each_entry(tgt_dev, head, sess_tgt_dev_list_entry) { ++ if (tgt_dev->lun == mcmd->lun) { ++ TRACE_DBG("tgt_dev %p found", tgt_dev); ++ mcmd->mcmd_tgt_dev = tgt_dev; ++ res = 0; ++ break; ++ } ++ } ++ if (mcmd->mcmd_tgt_dev == NULL) ++ scst_put(mcmd->cpu_cmd_counter); ++ ++out: ++ TRACE_EXIT_HRES(res); ++ return res; ++} ++ ++/* No locks */ ++void scst_done_cmd_mgmt(struct scst_cmd *cmd) ++{ ++ struct scst_mgmt_cmd_stub *mstb, *t; ++ bool wake = 0; ++ unsigned long flags; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("cmd %p done (tag %llu)", ++ cmd, (long long unsigned int)cmd->tag); ++ ++ spin_lock_irqsave(&scst_mcmd_lock, flags); ++ ++ list_for_each_entry_safe(mstb, t, &cmd->mgmt_cmd_list, ++ cmd_mgmt_cmd_list_entry) { ++ struct scst_mgmt_cmd *mcmd; ++ ++ if (!mstb->done_counted) ++ continue; ++ ++ mcmd = mstb->mcmd; ++ TRACE_MGMT_DBG("mcmd %p, mcmd->cmd_done_wait_count %d", ++ mcmd, mcmd->cmd_done_wait_count); ++ ++ mcmd->cmd_done_wait_count--; ++ ++ BUG_ON(mcmd->cmd_done_wait_count < 0); ++ ++ if (mcmd->cmd_done_wait_count > 0) { ++ TRACE_MGMT_DBG("cmd_done_wait_count(%d) not 0, " ++ "skipping", mcmd->cmd_done_wait_count); ++ goto check_free; ++ } ++ ++ if (mcmd->state == SCST_MCMD_STATE_WAITING_AFFECTED_CMDS_DONE) { ++ mcmd->state = SCST_MCMD_STATE_AFFECTED_CMDS_DONE; ++ TRACE_MGMT_DBG("Adding mgmt cmd %p to active mgmt cmd " ++ "list", mcmd); ++ list_add_tail(&mcmd->mgmt_cmd_list_entry, ++ &scst_active_mgmt_cmd_list); ++ wake = 1; ++ } ++ ++check_free: ++ if (!mstb->finish_counted) { ++ TRACE_DBG("Releasing mstb %p", mstb); ++ list_del(&mstb->cmd_mgmt_cmd_list_entry); ++ mempool_free(mstb, scst_mgmt_stub_mempool); ++ } ++ } ++ ++ spin_unlock_irqrestore(&scst_mcmd_lock, flags); ++ ++ if (wake) ++ wake_up(&scst_mgmt_cmd_list_waitQ); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Called under scst_mcmd_lock and IRQs disabled */ ++static void __scst_dec_finish_wait_count(struct scst_mgmt_cmd *mcmd, bool *wake) ++{ ++ TRACE_ENTRY(); ++ ++ mcmd->cmd_finish_wait_count--; ++ ++ BUG_ON(mcmd->cmd_finish_wait_count < 0); ++ ++ if (mcmd->cmd_finish_wait_count > 0) { ++ TRACE_MGMT_DBG("cmd_finish_wait_count(%d) not 0, " ++ "skipping", mcmd->cmd_finish_wait_count); ++ goto out; ++ } ++ ++ if (mcmd->cmd_done_wait_count > 0) { ++ TRACE_MGMT_DBG("cmd_done_wait_count(%d) not 0, " ++ "skipping", mcmd->cmd_done_wait_count); ++ goto out; ++ } ++ ++ if (mcmd->state == SCST_MCMD_STATE_WAITING_AFFECTED_CMDS_FINISHED) { ++ mcmd->state = SCST_MCMD_STATE_DONE; ++ TRACE_MGMT_DBG("Adding mgmt cmd %p to active mgmt cmd " ++ "list", mcmd); ++ list_add_tail(&mcmd->mgmt_cmd_list_entry, ++ &scst_active_mgmt_cmd_list); ++ *wake = true; ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ * scst_prepare_async_mcmd() - prepare async management command ++ * ++ * Notifies SCST that management command is going to be async, i.e. ++ * will be completed in another context. ++ * ++ * No SCST locks supposed to be held on entrance. ++ */ ++void scst_prepare_async_mcmd(struct scst_mgmt_cmd *mcmd) ++{ ++ unsigned long flags; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Preparing mcmd %p for async execution " ++ "(cmd_finish_wait_count %d)", mcmd, ++ mcmd->cmd_finish_wait_count); ++ ++ spin_lock_irqsave(&scst_mcmd_lock, flags); ++ mcmd->cmd_finish_wait_count++; ++ spin_unlock_irqrestore(&scst_mcmd_lock, flags); ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL_GPL(scst_prepare_async_mcmd); ++ ++/** ++ * scst_async_mcmd_completed() - async management command completed ++ * ++ * Notifies SCST that async management command, prepared by ++ * scst_prepare_async_mcmd(), completed. ++ * ++ * No SCST locks supposed to be held on entrance. ++ */ ++void scst_async_mcmd_completed(struct scst_mgmt_cmd *mcmd, int status) ++{ ++ unsigned long flags; ++ bool wake = false; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Async mcmd %p completed (status %d)", mcmd, status); ++ ++ spin_lock_irqsave(&scst_mcmd_lock, flags); ++ ++ if (status != SCST_MGMT_STATUS_SUCCESS) ++ mcmd->status = status; ++ ++ __scst_dec_finish_wait_count(mcmd, &wake); ++ ++ spin_unlock_irqrestore(&scst_mcmd_lock, flags); ++ ++ if (wake) ++ wake_up(&scst_mgmt_cmd_list_waitQ); ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL_GPL(scst_async_mcmd_completed); ++ ++/* No locks */ ++static void scst_finish_cmd_mgmt(struct scst_cmd *cmd) ++{ ++ struct scst_mgmt_cmd_stub *mstb, *t; ++ bool wake = false; ++ unsigned long flags; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("cmd %p finished (tag %llu)", ++ cmd, (long long unsigned int)cmd->tag); ++ ++ spin_lock_irqsave(&scst_mcmd_lock, flags); ++ ++ list_for_each_entry_safe(mstb, t, &cmd->mgmt_cmd_list, ++ cmd_mgmt_cmd_list_entry) { ++ struct scst_mgmt_cmd *mcmd = mstb->mcmd; ++ ++ TRACE_MGMT_DBG("mcmd %p, mcmd->cmd_finish_wait_count %d", mcmd, ++ mcmd->cmd_finish_wait_count); ++ ++ BUG_ON(!mstb->finish_counted); ++ ++ if (cmd->completed) ++ mcmd->completed_cmd_count++; ++ ++ __scst_dec_finish_wait_count(mcmd, &wake); ++ ++ TRACE_DBG("Releasing mstb %p", mstb); ++ list_del(&mstb->cmd_mgmt_cmd_list_entry); ++ mempool_free(mstb, scst_mgmt_stub_mempool); ++ } ++ ++ spin_unlock_irqrestore(&scst_mcmd_lock, flags); ++ ++ if (wake) ++ wake_up(&scst_mgmt_cmd_list_waitQ); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int scst_call_dev_task_mgmt_fn(struct scst_mgmt_cmd *mcmd, ++ struct scst_tgt_dev *tgt_dev, int set_status) ++{ ++ int res = SCST_DEV_TM_NOT_COMPLETED; ++ struct scst_dev_type *h = tgt_dev->dev->handler; ++ ++ if (h->task_mgmt_fn) { ++ TRACE_MGMT_DBG("Calling dev handler %s task_mgmt_fn(fn=%d)", ++ h->name, mcmd->fn); ++ res = h->task_mgmt_fn(mcmd, tgt_dev); ++ TRACE_MGMT_DBG("Dev handler %s task_mgmt_fn() returned %d", ++ h->name, res); ++ if (set_status && (res != SCST_DEV_TM_NOT_COMPLETED)) ++ mcmd->status = res; ++ } ++ return res; ++} ++ ++static inline int scst_is_strict_mgmt_fn(int mgmt_fn) ++{ ++ switch (mgmt_fn) { ++#ifdef CONFIG_SCST_ABORT_CONSIDER_FINISHED_TASKS_AS_NOT_EXISTING ++ case SCST_ABORT_TASK: ++#endif ++#if 0 ++ case SCST_ABORT_TASK_SET: ++ case SCST_CLEAR_TASK_SET: ++#endif ++ return 1; ++ default: ++ return 0; ++ } ++} ++ ++/* ++ * Must be called under sess_list_lock to sync with finished flag assignment in ++ * scst_finish_cmd() ++ */ ++void scst_abort_cmd(struct scst_cmd *cmd, struct scst_mgmt_cmd *mcmd, ++ bool other_ini, bool call_dev_task_mgmt_fn) ++{ ++ unsigned long flags; ++ static DEFINE_SPINLOCK(other_ini_lock); ++ ++ TRACE_ENTRY(); ++ ++ TRACE(TRACE_SCSI|TRACE_MGMT_DEBUG, "Aborting cmd %p (tag %llu, op %x)", ++ cmd, (long long unsigned int)cmd->tag, cmd->cdb[0]); ++ ++ /* To protect from concurrent aborts */ ++ spin_lock_irqsave(&other_ini_lock, flags); ++ ++ if (other_ini) { ++ struct scst_device *dev = NULL; ++ ++ /* Might be necessary if command aborted several times */ ++ if (!test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags)) ++ set_bit(SCST_CMD_ABORTED_OTHER, &cmd->cmd_flags); ++ ++ /* Necessary for scst_xmit_process_aborted_cmd */ ++ if (cmd->dev != NULL) ++ dev = cmd->dev; ++ else if ((mcmd != NULL) && (mcmd->mcmd_tgt_dev != NULL)) ++ dev = mcmd->mcmd_tgt_dev->dev; ++ ++ if (dev != NULL) { ++ if (dev->tas) ++ set_bit(SCST_CMD_DEVICE_TAS, &cmd->cmd_flags); ++ } else ++ PRINT_WARNING("Abort cmd %p from other initiator, but " ++ "neither cmd, nor mcmd %p have tgt_dev set, so " ++ "TAS information can be lost", cmd, mcmd); ++ } else { ++ /* Might be necessary if command aborted several times */ ++ clear_bit(SCST_CMD_ABORTED_OTHER, &cmd->cmd_flags); ++ } ++ ++ set_bit(SCST_CMD_ABORTED, &cmd->cmd_flags); ++ ++ spin_unlock_irqrestore(&other_ini_lock, flags); ++ ++ /* ++ * To sync with setting cmd->done in scst_pre_xmit_response() (with ++ * scst_finish_cmd() we synced by using sess_list_lock) and with ++ * setting UA for aborted cmd in scst_set_pending_UA(). ++ */ ++ smp_mb__after_set_bit(); ++ ++ if (cmd->tgt_dev == NULL) { ++ spin_lock_irqsave(&scst_init_lock, flags); ++ scst_init_poll_cnt++; ++ spin_unlock_irqrestore(&scst_init_lock, flags); ++ wake_up(&scst_init_cmd_list_waitQ); ++ } ++ ++ if (!cmd->finished && call_dev_task_mgmt_fn && (cmd->tgt_dev != NULL)) ++ scst_call_dev_task_mgmt_fn(mcmd, cmd->tgt_dev, 1); ++ ++ spin_lock_irqsave(&scst_mcmd_lock, flags); ++ if ((mcmd != NULL) && !cmd->finished) { ++ struct scst_mgmt_cmd_stub *mstb; ++ ++ mstb = mempool_alloc(scst_mgmt_stub_mempool, GFP_ATOMIC); ++ if (mstb == NULL) { ++ PRINT_CRIT_ERROR("Allocation of management command " ++ "stub failed (mcmd %p, cmd %p)", mcmd, cmd); ++ goto unlock; ++ } ++ memset(mstb, 0, sizeof(*mstb)); ++ ++ TRACE_DBG("mstb %p, mcmd %p", mstb, mcmd); ++ ++ mstb->mcmd = mcmd; ++ ++ /* ++ * Delay the response until the command's finish in order to ++ * guarantee that "no further responses from the task are sent ++ * to the SCSI initiator port" after response from the TM ++ * function is sent (SAM). Plus, we must wait here to be sure ++ * that we won't receive double commands with the same tag. ++ * Moreover, if we don't wait here, we might have a possibility ++ * for data corruption, when aborted and reported as completed ++ * command actually gets executed *after* new commands sent ++ * after this TM command completed. ++ */ ++ ++ if (cmd->sent_for_exec && !cmd->done) { ++ TRACE_MGMT_DBG("cmd %p (tag %llu) is being executed", ++ cmd, (long long unsigned int)cmd->tag); ++ mstb->done_counted = 1; ++ mcmd->cmd_done_wait_count++; ++ } ++ ++ /* ++ * We don't have to wait the command's status delivery finish ++ * to other initiators + it can affect MPIO failover. ++ */ ++ if (!other_ini) { ++ mstb->finish_counted = 1; ++ mcmd->cmd_finish_wait_count++; ++ } ++ ++ if (mstb->done_counted || mstb->finish_counted) { ++ TRACE(TRACE_SCSI|TRACE_MGMT_DEBUG, "cmd %p (tag %llu, " ++ "sn %u) being executed/xmitted (state %d, " ++ "op %x, proc time %ld sec., timeout %d sec.), " ++ "deferring ABORT (cmd_done_wait_count %d, " ++ "cmd_finish_wait_count %d)", cmd, ++ (long long unsigned int)cmd->tag, ++ cmd->sn, cmd->state, cmd->cdb[0], ++ (long)(jiffies - cmd->start_time) / HZ, ++ cmd->timeout / HZ, mcmd->cmd_done_wait_count, ++ mcmd->cmd_finish_wait_count); ++ /* ++ * cmd can't die here or sess_list_lock already taken ++ * and cmd is in the sess list ++ */ ++ list_add_tail(&mstb->cmd_mgmt_cmd_list_entry, ++ &cmd->mgmt_cmd_list); ++ } else { ++ /* We don't need to wait for this cmd */ ++ mempool_free(mstb, scst_mgmt_stub_mempool); ++ } ++ ++ if (cmd->tgtt->on_abort_cmd) ++ cmd->tgtt->on_abort_cmd(cmd); ++ } ++ ++unlock: ++ spin_unlock_irqrestore(&scst_mcmd_lock, flags); ++ ++ tm_dbg_release_cmd(cmd); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* No locks. Returns 0, if mcmd should be processed further. */ ++static int scst_set_mcmd_next_state(struct scst_mgmt_cmd *mcmd) ++{ ++ int res; ++ ++ spin_lock_irq(&scst_mcmd_lock); ++ ++ switch (mcmd->state) { ++ case SCST_MCMD_STATE_INIT: ++ case SCST_MCMD_STATE_EXEC: ++ if (mcmd->cmd_done_wait_count == 0) { ++ mcmd->state = SCST_MCMD_STATE_AFFECTED_CMDS_DONE; ++ res = 0; ++ } else { ++ TRACE(TRACE_SCSI|TRACE_MGMT_DEBUG, ++ "cmd_done_wait_count(%d) not 0, " ++ "preparing to wait", mcmd->cmd_done_wait_count); ++ mcmd->state = SCST_MCMD_STATE_WAITING_AFFECTED_CMDS_DONE; ++ res = -1; ++ } ++ break; ++ ++ case SCST_MCMD_STATE_AFFECTED_CMDS_DONE: ++ if (mcmd->cmd_finish_wait_count == 0) { ++ mcmd->state = SCST_MCMD_STATE_DONE; ++ res = 0; ++ } else { ++ TRACE(TRACE_SCSI|TRACE_MGMT_DEBUG, ++ "cmd_finish_wait_count(%d) not 0, " ++ "preparing to wait", ++ mcmd->cmd_finish_wait_count); ++ mcmd->state = SCST_MCMD_STATE_WAITING_AFFECTED_CMDS_FINISHED; ++ res = -1; ++ } ++ break; ++ ++ case SCST_MCMD_STATE_DONE: ++ mcmd->state = SCST_MCMD_STATE_FINISHED; ++ res = 0; ++ break; ++ ++ default: ++ PRINT_CRIT_ERROR("Wrong mcmd %p state %d (fn %d, " ++ "cmd_finish_wait_count %d, cmd_done_wait_count %d)", ++ mcmd, mcmd->state, mcmd->fn, ++ mcmd->cmd_finish_wait_count, mcmd->cmd_done_wait_count); ++ spin_unlock_irq(&scst_mcmd_lock); ++ res = -1; ++ BUG(); ++ goto out; ++ } ++ ++ spin_unlock_irq(&scst_mcmd_lock); ++ ++out: ++ return res; ++} ++ ++/* IRQs supposed to be disabled */ ++static bool __scst_check_unblock_aborted_cmd(struct scst_cmd *cmd, ++ struct list_head *list_entry) ++{ ++ bool res; ++ if (test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags)) { ++ list_del(list_entry); ++ spin_lock(&cmd->cmd_threads->cmd_list_lock); ++ list_add_tail(&cmd->cmd_list_entry, ++ &cmd->cmd_threads->active_cmd_list); ++ wake_up(&cmd->cmd_threads->cmd_list_waitQ); ++ spin_unlock(&cmd->cmd_threads->cmd_list_lock); ++ res = 1; ++ } else ++ res = 0; ++ return res; ++} ++ ++static void scst_unblock_aborted_cmds(int scst_mutex_held) ++{ ++ struct scst_device *dev; ++ ++ TRACE_ENTRY(); ++ ++ if (!scst_mutex_held) ++ mutex_lock(&scst_mutex); ++ ++ list_for_each_entry(dev, &scst_dev_list, dev_list_entry) { ++ struct scst_cmd *cmd, *tcmd; ++ struct scst_tgt_dev *tgt_dev; ++ spin_lock_bh(&dev->dev_lock); ++ local_irq_disable(); ++ list_for_each_entry_safe(cmd, tcmd, &dev->blocked_cmd_list, ++ blocked_cmd_list_entry) { ++ if (__scst_check_unblock_aborted_cmd(cmd, ++ &cmd->blocked_cmd_list_entry)) { ++ TRACE_MGMT_DBG("Unblock aborted blocked cmd %p", ++ cmd); ++ } ++ } ++ local_irq_enable(); ++ spin_unlock_bh(&dev->dev_lock); ++ ++ local_irq_disable(); ++ list_for_each_entry(tgt_dev, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ struct scst_order_data *order_data = tgt_dev->curr_order_data; ++ spin_lock(&order_data->sn_lock); ++ list_for_each_entry_safe(cmd, tcmd, ++ &order_data->deferred_cmd_list, ++ sn_cmd_list_entry) { ++ if (__scst_check_unblock_aborted_cmd(cmd, ++ &cmd->sn_cmd_list_entry)) { ++ TRACE_MGMT_DBG("Unblocked aborted SN " ++ "cmd %p (sn %u)", ++ cmd, cmd->sn); ++ order_data->def_cmd_count--; ++ } ++ } ++ spin_unlock(&order_data->sn_lock); ++ } ++ local_irq_enable(); ++ } ++ ++ if (!scst_mutex_held) ++ mutex_unlock(&scst_mutex); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void __scst_abort_task_set(struct scst_mgmt_cmd *mcmd, ++ struct scst_tgt_dev *tgt_dev) ++{ ++ struct scst_cmd *cmd; ++ struct scst_session *sess = tgt_dev->sess; ++ bool other_ini; ++ ++ TRACE_ENTRY(); ++ ++ if ((mcmd->fn == SCST_PR_ABORT_ALL) && ++ (mcmd->origin_pr_cmd->sess != sess)) ++ other_ini = true; ++ else ++ other_ini = false; ++ ++ spin_lock_irq(&sess->sess_list_lock); ++ ++ TRACE_DBG("Searching in sess cmd list (sess=%p)", sess); ++ list_for_each_entry(cmd, &sess->sess_cmd_list, ++ sess_cmd_list_entry) { ++ if ((mcmd->fn == SCST_PR_ABORT_ALL) && ++ (mcmd->origin_pr_cmd == cmd)) ++ continue; ++ if ((cmd->tgt_dev == tgt_dev) || ++ ((cmd->tgt_dev == NULL) && ++ (cmd->lun == tgt_dev->lun))) { ++ if (mcmd->cmd_sn_set) { ++ BUG_ON(!cmd->tgt_sn_set); ++ if (scst_sn_before(mcmd->cmd_sn, cmd->tgt_sn) || ++ (mcmd->cmd_sn == cmd->tgt_sn)) ++ continue; ++ } ++ scst_abort_cmd(cmd, mcmd, other_ini, 0); ++ } ++ } ++ spin_unlock_irq(&sess->sess_list_lock); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Returns 0 if the command processing should be continued, <0 otherwise */ ++static int scst_abort_task_set(struct scst_mgmt_cmd *mcmd) ++{ ++ int res; ++ struct scst_tgt_dev *tgt_dev = mcmd->mcmd_tgt_dev; ++ ++ TRACE(TRACE_MGMT, "Aborting task set (lun=%lld, mcmd=%p)", ++ (long long unsigned int)tgt_dev->lun, mcmd); ++ ++ __scst_abort_task_set(mcmd, tgt_dev); ++ ++ if (mcmd->fn == SCST_PR_ABORT_ALL) { ++ struct scst_pr_abort_all_pending_mgmt_cmds_counter *pr_cnt = ++ mcmd->origin_pr_cmd->pr_abort_counter; ++ if (atomic_dec_and_test(&pr_cnt->pr_aborting_cnt)) ++ complete_all(&pr_cnt->pr_aborting_cmpl); ++ } ++ ++ tm_dbg_task_mgmt(mcmd->mcmd_tgt_dev->dev, "ABORT TASK SET/PR ABORT", 0); ++ ++ scst_unblock_aborted_cmds(0); ++ ++ scst_call_dev_task_mgmt_fn(mcmd, tgt_dev, 0); ++ ++ res = scst_set_mcmd_next_state(mcmd); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_is_cmd_belongs_to_dev(struct scst_cmd *cmd, ++ struct scst_device *dev) ++{ ++ struct scst_tgt_dev *tgt_dev = NULL; ++ struct list_head *head; ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Finding match for dev %s and cmd %p (lun %lld)", dev->virt_name, ++ cmd, (long long unsigned int)cmd->lun); ++ ++ head = &cmd->sess->sess_tgt_dev_list[SESS_TGT_DEV_LIST_HASH_FN(cmd->lun)]; ++ list_for_each_entry(tgt_dev, head, sess_tgt_dev_list_entry) { ++ if (tgt_dev->lun == cmd->lun) { ++ TRACE_DBG("dev %s found", tgt_dev->dev->virt_name); ++ res = (tgt_dev->dev == dev); ++ goto out; ++ } ++ } ++ ++out: ++ TRACE_EXIT_HRES(res); ++ return res; ++} ++ ++/* Returns 0 if the command processing should be continued, <0 otherwise */ ++static int scst_clear_task_set(struct scst_mgmt_cmd *mcmd) ++{ ++ int res; ++ struct scst_device *dev = mcmd->mcmd_tgt_dev->dev; ++ struct scst_tgt_dev *tgt_dev; ++ LIST_HEAD(UA_tgt_devs); ++ ++ TRACE_ENTRY(); ++ ++ TRACE(TRACE_MGMT, "Clearing task set (lun=%lld, mcmd=%p)", ++ (long long unsigned int)mcmd->lun, mcmd); ++ ++#if 0 /* we are SAM-3 */ ++ /* ++ * When a logical unit is aborting one or more tasks from a SCSI ++ * initiator port with the TASK ABORTED status it should complete all ++ * of those tasks before entering additional tasks from that SCSI ++ * initiator port into the task set - SAM2 ++ */ ++ mcmd->needs_unblocking = 1; ++ spin_lock_bh(&dev->dev_lock); ++ scst_block_dev(dev); ++ spin_unlock_bh(&dev->dev_lock); ++#endif ++ ++ __scst_abort_task_set(mcmd, mcmd->mcmd_tgt_dev); ++ ++ mutex_lock(&scst_mutex); ++ ++ list_for_each_entry(tgt_dev, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ struct scst_session *sess = tgt_dev->sess; ++ struct scst_cmd *cmd; ++ int aborted = 0; ++ ++ if (tgt_dev == mcmd->mcmd_tgt_dev) ++ continue; ++ ++ spin_lock_irq(&sess->sess_list_lock); ++ ++ TRACE_DBG("Searching in sess cmd list (sess=%p)", sess); ++ list_for_each_entry(cmd, &sess->sess_cmd_list, ++ sess_cmd_list_entry) { ++ if ((cmd->dev == dev) || ++ ((cmd->dev == NULL) && ++ scst_is_cmd_belongs_to_dev(cmd, dev))) { ++ scst_abort_cmd(cmd, mcmd, 1, 0); ++ aborted = 1; ++ } ++ } ++ spin_unlock_irq(&sess->sess_list_lock); ++ ++ if (aborted) ++ list_add_tail(&tgt_dev->extra_tgt_dev_list_entry, ++ &UA_tgt_devs); ++ } ++ ++ tm_dbg_task_mgmt(mcmd->mcmd_tgt_dev->dev, "CLEAR TASK SET", 0); ++ ++ scst_unblock_aborted_cmds(1); ++ ++ mutex_unlock(&scst_mutex); ++ ++ if (!dev->tas) { ++ uint8_t sense_buffer[SCST_STANDARD_SENSE_LEN]; ++ int sl; ++ ++ sl = scst_set_sense(sense_buffer, sizeof(sense_buffer), ++ dev->d_sense, ++ SCST_LOAD_SENSE(scst_sense_cleared_by_another_ini_UA)); ++ ++ list_for_each_entry(tgt_dev, &UA_tgt_devs, ++ extra_tgt_dev_list_entry) { ++ scst_check_set_UA(tgt_dev, sense_buffer, sl, 0); ++ } ++ } ++ ++ scst_call_dev_task_mgmt_fn(mcmd, mcmd->mcmd_tgt_dev, 0); ++ ++ res = scst_set_mcmd_next_state(mcmd); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* Returns 0 if the command processing should be continued, ++ * >0, if it should be requeued, <0 otherwise */ ++static int scst_mgmt_cmd_init(struct scst_mgmt_cmd *mcmd) ++{ ++ int res = 0, rc; ++ ++ TRACE_ENTRY(); ++ ++ switch (mcmd->fn) { ++ case SCST_ABORT_TASK: ++ { ++ struct scst_session *sess = mcmd->sess; ++ struct scst_cmd *cmd; ++ ++ spin_lock_irq(&sess->sess_list_lock); ++ cmd = __scst_find_cmd_by_tag(sess, mcmd->tag, true); ++ if (cmd == NULL) { ++ TRACE_MGMT_DBG("ABORT TASK: command " ++ "for tag %llu not found", ++ (long long unsigned int)mcmd->tag); ++ mcmd->status = SCST_MGMT_STATUS_TASK_NOT_EXIST; ++ spin_unlock_irq(&sess->sess_list_lock); ++ res = scst_set_mcmd_next_state(mcmd); ++ goto out; ++ } ++ __scst_cmd_get(cmd); ++ spin_unlock_irq(&sess->sess_list_lock); ++ TRACE_DBG("Cmd to abort %p for tag %llu found", ++ cmd, (long long unsigned int)mcmd->tag); ++ mcmd->cmd_to_abort = cmd; ++ mcmd->state = SCST_MCMD_STATE_EXEC; ++ break; ++ } ++ ++ case SCST_TARGET_RESET: ++ case SCST_NEXUS_LOSS_SESS: ++ case SCST_ABORT_ALL_TASKS_SESS: ++ case SCST_NEXUS_LOSS: ++ case SCST_ABORT_ALL_TASKS: ++ case SCST_UNREG_SESS_TM: ++ mcmd->state = SCST_MCMD_STATE_EXEC; ++ break; ++ ++ case SCST_ABORT_TASK_SET: ++ case SCST_CLEAR_ACA: ++ case SCST_CLEAR_TASK_SET: ++ case SCST_LUN_RESET: ++ case SCST_PR_ABORT_ALL: ++ rc = scst_mgmt_translate_lun(mcmd); ++ if (rc == 0) ++ mcmd->state = SCST_MCMD_STATE_EXEC; ++ else if (rc < 0) { ++ PRINT_ERROR("Corresponding device for LUN %lld not " ++ "found", (long long unsigned int)mcmd->lun); ++ mcmd->status = SCST_MGMT_STATUS_LUN_NOT_EXIST; ++ res = scst_set_mcmd_next_state(mcmd); ++ } else ++ res = rc; ++ break; ++ ++ default: ++ BUG(); ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* Returns 0 if the command processing should be continued, <0 otherwise */ ++static int scst_target_reset(struct scst_mgmt_cmd *mcmd) ++{ ++ int res, rc; ++ struct scst_device *dev; ++ struct scst_acg *acg = mcmd->sess->acg; ++ struct scst_acg_dev *acg_dev; ++ int cont, c; ++ LIST_HEAD(host_devs); ++ ++ TRACE_ENTRY(); ++ ++ TRACE(TRACE_MGMT, "Target reset (mcmd %p, cmd count %d)", ++ mcmd, atomic_read(&mcmd->sess->sess_cmd_count)); ++ ++ mcmd->needs_unblocking = 1; ++ ++ mutex_lock(&scst_mutex); ++ ++ list_for_each_entry(acg_dev, &acg->acg_dev_list, acg_dev_list_entry) { ++ struct scst_device *d; ++ struct scst_tgt_dev *tgt_dev; ++ int found = 0; ++ ++ dev = acg_dev->dev; ++ ++ spin_lock_bh(&dev->dev_lock); ++ scst_block_dev(dev); ++ scst_process_reset(dev, mcmd->sess, NULL, mcmd, true); ++ spin_unlock_bh(&dev->dev_lock); ++ ++ cont = 0; ++ c = 0; ++ list_for_each_entry(tgt_dev, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ cont = 1; ++ if (mcmd->sess == tgt_dev->sess) { ++ rc = scst_call_dev_task_mgmt_fn(mcmd, ++ tgt_dev, 0); ++ if (rc == SCST_DEV_TM_NOT_COMPLETED) ++ c = 1; ++ else if ((rc < 0) && ++ (mcmd->status == SCST_MGMT_STATUS_SUCCESS)) ++ mcmd->status = rc; ++ break; ++ } ++ } ++ if (cont && !c) ++ continue; ++ ++ if (dev->scsi_dev == NULL) ++ continue; ++ ++ list_for_each_entry(d, &host_devs, tm_dev_list_entry) { ++ if (dev->scsi_dev->host->host_no == ++ d->scsi_dev->host->host_no) { ++ found = 1; ++ break; ++ } ++ } ++ if (!found) ++ list_add_tail(&dev->tm_dev_list_entry, &host_devs); ++ ++ tm_dbg_task_mgmt(dev, "TARGET RESET", 0); ++ } ++ ++ scst_unblock_aborted_cmds(1); ++ ++ /* ++ * We suppose here that for all commands that already on devices ++ * on/after scsi_reset_provider() completion callbacks will be called. ++ */ ++ ++ list_for_each_entry(dev, &host_devs, tm_dev_list_entry) { ++ /* dev->scsi_dev must be non-NULL here */ ++ TRACE(TRACE_MGMT, "Resetting host %d bus ", ++ dev->scsi_dev->host->host_no); ++ rc = scsi_reset_provider(dev->scsi_dev, SCSI_TRY_RESET_TARGET); ++ TRACE(TRACE_MGMT, "Result of host %d target reset: %s", ++ dev->scsi_dev->host->host_no, ++ (rc == SUCCESS) ? "SUCCESS" : "FAILED"); ++#if 0 ++ if ((rc != SUCCESS) && ++ (mcmd->status == SCST_MGMT_STATUS_SUCCESS)) { ++ /* ++ * SCSI_TRY_RESET_BUS is also done by ++ * scsi_reset_provider() ++ */ ++ mcmd->status = SCST_MGMT_STATUS_FAILED; ++ } ++#else ++ /* ++ * scsi_reset_provider() returns very weird status, so let's ++ * always succeed ++ */ ++#endif ++ } ++ ++ list_for_each_entry(acg_dev, &acg->acg_dev_list, acg_dev_list_entry) { ++ dev = acg_dev->dev; ++ if (dev->scsi_dev != NULL) ++ dev->scsi_dev->was_reset = 0; ++ } ++ ++ mutex_unlock(&scst_mutex); ++ ++ res = scst_set_mcmd_next_state(mcmd); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* Returns 0 if the command processing should be continued, <0 otherwise */ ++static int scst_lun_reset(struct scst_mgmt_cmd *mcmd) ++{ ++ int res, rc; ++ struct scst_tgt_dev *tgt_dev = mcmd->mcmd_tgt_dev; ++ struct scst_device *dev = tgt_dev->dev; ++ ++ TRACE_ENTRY(); ++ ++ TRACE(TRACE_MGMT, "Resetting LUN %lld (mcmd %p)", ++ (long long unsigned int)tgt_dev->lun, mcmd); ++ ++ mcmd->needs_unblocking = 1; ++ ++ spin_lock_bh(&dev->dev_lock); ++ scst_block_dev(dev); ++ scst_process_reset(dev, mcmd->sess, NULL, mcmd, true); ++ spin_unlock_bh(&dev->dev_lock); ++ ++ rc = scst_call_dev_task_mgmt_fn(mcmd, tgt_dev, 1); ++ if (rc != SCST_DEV_TM_NOT_COMPLETED) ++ goto out_tm_dbg; ++ ++ if (dev->scsi_dev != NULL) { ++ TRACE(TRACE_MGMT, "Resetting host %d bus ", ++ dev->scsi_dev->host->host_no); ++ rc = scsi_reset_provider(dev->scsi_dev, SCSI_TRY_RESET_DEVICE); ++#if 0 ++ if (rc != SUCCESS && mcmd->status == SCST_MGMT_STATUS_SUCCESS) ++ mcmd->status = SCST_MGMT_STATUS_FAILED; ++#else ++ /* ++ * scsi_reset_provider() returns very weird status, so let's ++ * always succeed ++ */ ++#endif ++ dev->scsi_dev->was_reset = 0; ++ } ++ ++ scst_unblock_aborted_cmds(0); ++ ++out_tm_dbg: ++ tm_dbg_task_mgmt(mcmd->mcmd_tgt_dev->dev, "LUN RESET", 0); ++ ++ res = scst_set_mcmd_next_state(mcmd); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* scst_mutex supposed to be held */ ++static void scst_do_nexus_loss_sess(struct scst_mgmt_cmd *mcmd) ++{ ++ int i; ++ struct scst_session *sess = mcmd->sess; ++ struct scst_tgt_dev *tgt_dev; ++ ++ TRACE_ENTRY(); ++ ++ for (i = 0; i < SESS_TGT_DEV_LIST_HASH_SIZE; i++) { ++ struct list_head *head = &sess->sess_tgt_dev_list[i]; ++ list_for_each_entry(tgt_dev, head, sess_tgt_dev_list_entry) { ++ scst_nexus_loss(tgt_dev, ++ (mcmd->fn != SCST_UNREG_SESS_TM)); ++ } ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Returns 0 if the command processing should be continued, <0 otherwise */ ++static int scst_abort_all_nexus_loss_sess(struct scst_mgmt_cmd *mcmd, ++ int nexus_loss) ++{ ++ int res; ++ int i; ++ struct scst_session *sess = mcmd->sess; ++ struct scst_tgt_dev *tgt_dev; ++ ++ TRACE_ENTRY(); ++ ++ if (nexus_loss) { ++ TRACE_MGMT_DBG("Nexus loss for sess %p (mcmd %p)", ++ sess, mcmd); ++ } else { ++ TRACE_MGMT_DBG("Aborting all from sess %p (mcmd %p)", ++ sess, mcmd); ++ } ++ ++ mutex_lock(&scst_mutex); ++ ++ for (i = 0; i < SESS_TGT_DEV_LIST_HASH_SIZE; i++) { ++ struct list_head *head = &sess->sess_tgt_dev_list[i]; ++ list_for_each_entry(tgt_dev, head, sess_tgt_dev_list_entry) { ++ int rc; ++ ++ __scst_abort_task_set(mcmd, tgt_dev); ++ ++ rc = scst_call_dev_task_mgmt_fn(mcmd, tgt_dev, 0); ++ if (rc < 0 && mcmd->status == SCST_MGMT_STATUS_SUCCESS) ++ mcmd->status = rc; ++ ++ tm_dbg_task_mgmt(tgt_dev->dev, "NEXUS LOSS SESS or " ++ "ABORT ALL SESS or UNREG SESS", ++ (mcmd->fn == SCST_UNREG_SESS_TM)); ++ } ++ } ++ ++ scst_unblock_aborted_cmds(1); ++ ++ mutex_unlock(&scst_mutex); ++ ++ res = scst_set_mcmd_next_state(mcmd); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* scst_mutex supposed to be held */ ++static void scst_do_nexus_loss_tgt(struct scst_mgmt_cmd *mcmd) ++{ ++ int i; ++ struct scst_tgt *tgt = mcmd->sess->tgt; ++ struct scst_session *sess; ++ ++ TRACE_ENTRY(); ++ ++ list_for_each_entry(sess, &tgt->sess_list, sess_list_entry) { ++ for (i = 0; i < SESS_TGT_DEV_LIST_HASH_SIZE; i++) { ++ struct list_head *head = &sess->sess_tgt_dev_list[i]; ++ struct scst_tgt_dev *tgt_dev; ++ list_for_each_entry(tgt_dev, head, ++ sess_tgt_dev_list_entry) { ++ scst_nexus_loss(tgt_dev, true); ++ } ++ } ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int scst_abort_all_nexus_loss_tgt(struct scst_mgmt_cmd *mcmd, ++ int nexus_loss) ++{ ++ int res; ++ int i; ++ struct scst_tgt *tgt = mcmd->sess->tgt; ++ struct scst_session *sess; ++ ++ TRACE_ENTRY(); ++ ++ if (nexus_loss) { ++ TRACE_MGMT_DBG("I_T Nexus loss (tgt %p, mcmd %p)", ++ tgt, mcmd); ++ } else { ++ TRACE_MGMT_DBG("Aborting all from tgt %p (mcmd %p)", ++ tgt, mcmd); ++ } ++ ++ mutex_lock(&scst_mutex); ++ ++ list_for_each_entry(sess, &tgt->sess_list, sess_list_entry) { ++ for (i = 0; i < SESS_TGT_DEV_LIST_HASH_SIZE; i++) { ++ struct list_head *head = &sess->sess_tgt_dev_list[i]; ++ struct scst_tgt_dev *tgt_dev; ++ list_for_each_entry(tgt_dev, head, ++ sess_tgt_dev_list_entry) { ++ int rc; ++ ++ __scst_abort_task_set(mcmd, tgt_dev); ++ ++ if (mcmd->sess == tgt_dev->sess) { ++ rc = scst_call_dev_task_mgmt_fn( ++ mcmd, tgt_dev, 0); ++ if ((rc < 0) && ++ (mcmd->status == SCST_MGMT_STATUS_SUCCESS)) ++ mcmd->status = rc; ++ } ++ ++ tm_dbg_task_mgmt(tgt_dev->dev, "NEXUS LOSS or " ++ "ABORT ALL", 0); ++ } ++ } ++ } ++ ++ scst_unblock_aborted_cmds(1); ++ ++ mutex_unlock(&scst_mutex); ++ ++ res = scst_set_mcmd_next_state(mcmd); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_abort_task(struct scst_mgmt_cmd *mcmd) ++{ ++ int res; ++ struct scst_cmd *cmd = mcmd->cmd_to_abort; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Aborting task (cmd %p, sn %d, set %d, tag %llu, " ++ "queue_type %x)", cmd, cmd->sn, cmd->sn_set, ++ (long long unsigned int)mcmd->tag, cmd->queue_type); ++ ++ if (mcmd->lun_set && (mcmd->lun != cmd->lun)) { ++ PRINT_ERROR("ABORT TASK: LUN mismatch: mcmd LUN %llx, " ++ "cmd LUN %llx, cmd tag %llu", ++ (long long unsigned int)mcmd->lun, ++ (long long unsigned int)cmd->lun, ++ (long long unsigned int)mcmd->tag); ++ mcmd->status = SCST_MGMT_STATUS_REJECTED; ++ } else if (mcmd->cmd_sn_set && ++ (scst_sn_before(mcmd->cmd_sn, cmd->tgt_sn) || ++ (mcmd->cmd_sn == cmd->tgt_sn))) { ++ PRINT_ERROR("ABORT TASK: SN mismatch: mcmd SN %x, " ++ "cmd SN %x, cmd tag %llu", mcmd->cmd_sn, ++ cmd->tgt_sn, (long long unsigned int)mcmd->tag); ++ mcmd->status = SCST_MGMT_STATUS_REJECTED; ++ } else { ++ spin_lock_irq(&cmd->sess->sess_list_lock); ++ scst_abort_cmd(cmd, mcmd, 0, 1); ++ spin_unlock_irq(&cmd->sess->sess_list_lock); ++ ++ scst_unblock_aborted_cmds(0); ++ } ++ ++ res = scst_set_mcmd_next_state(mcmd); ++ ++ mcmd->cmd_to_abort = NULL; /* just in case */ ++ ++ __scst_cmd_put(cmd); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* Returns 0 if the command processing should be continued, <0 otherwise */ ++static int scst_mgmt_cmd_exec(struct scst_mgmt_cmd *mcmd) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ mcmd->status = SCST_MGMT_STATUS_SUCCESS; ++ ++ switch (mcmd->fn) { ++ case SCST_ABORT_TASK: ++ res = scst_abort_task(mcmd); ++ break; ++ ++ case SCST_ABORT_TASK_SET: ++ case SCST_PR_ABORT_ALL: ++ res = scst_abort_task_set(mcmd); ++ break; ++ ++ case SCST_CLEAR_TASK_SET: ++ if (mcmd->mcmd_tgt_dev->dev->tst == ++ SCST_CONTR_MODE_SEP_TASK_SETS) ++ res = scst_abort_task_set(mcmd); ++ else ++ res = scst_clear_task_set(mcmd); ++ break; ++ ++ case SCST_LUN_RESET: ++ res = scst_lun_reset(mcmd); ++ break; ++ ++ case SCST_TARGET_RESET: ++ res = scst_target_reset(mcmd); ++ break; ++ ++ case SCST_ABORT_ALL_TASKS_SESS: ++ res = scst_abort_all_nexus_loss_sess(mcmd, 0); ++ break; ++ ++ case SCST_NEXUS_LOSS_SESS: ++ case SCST_UNREG_SESS_TM: ++ res = scst_abort_all_nexus_loss_sess(mcmd, 1); ++ break; ++ ++ case SCST_ABORT_ALL_TASKS: ++ res = scst_abort_all_nexus_loss_tgt(mcmd, 0); ++ break; ++ ++ case SCST_NEXUS_LOSS: ++ res = scst_abort_all_nexus_loss_tgt(mcmd, 1); ++ break; ++ ++ case SCST_CLEAR_ACA: ++ if (scst_call_dev_task_mgmt_fn(mcmd, mcmd->mcmd_tgt_dev, 1) == ++ SCST_DEV_TM_NOT_COMPLETED) { ++ mcmd->status = SCST_MGMT_STATUS_FN_NOT_SUPPORTED; ++ /* Nothing to do (yet) */ ++ } ++ goto out_done; ++ ++ default: ++ PRINT_ERROR("Unknown task management function %d", mcmd->fn); ++ mcmd->status = SCST_MGMT_STATUS_REJECTED; ++ goto out_done; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_done: ++ res = scst_set_mcmd_next_state(mcmd); ++ goto out; ++} ++ ++static void scst_call_task_mgmt_affected_cmds_done(struct scst_mgmt_cmd *mcmd) ++{ ++ struct scst_session *sess = mcmd->sess; ++ ++ if ((sess->tgt->tgtt->task_mgmt_affected_cmds_done != NULL) && ++ (mcmd->fn != SCST_UNREG_SESS_TM) && ++ (mcmd->fn != SCST_PR_ABORT_ALL)) { ++ TRACE_DBG("Calling target %s task_mgmt_affected_cmds_done(%p)", ++ sess->tgt->tgtt->name, sess); ++ sess->tgt->tgtt->task_mgmt_affected_cmds_done(mcmd); ++ TRACE_MGMT_DBG("Target's %s task_mgmt_affected_cmds_done() " ++ "returned", sess->tgt->tgtt->name); ++ } ++ return; ++} ++ ++static int scst_mgmt_affected_cmds_done(struct scst_mgmt_cmd *mcmd) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_mutex); ++ ++ switch (mcmd->fn) { ++ case SCST_NEXUS_LOSS_SESS: ++ case SCST_UNREG_SESS_TM: ++ scst_do_nexus_loss_sess(mcmd); ++ break; ++ ++ case SCST_NEXUS_LOSS: ++ scst_do_nexus_loss_tgt(mcmd); ++ break; ++ } ++ ++ mutex_unlock(&scst_mutex); ++ ++ scst_call_task_mgmt_affected_cmds_done(mcmd); ++ ++ res = scst_set_mcmd_next_state(mcmd); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void scst_mgmt_cmd_send_done(struct scst_mgmt_cmd *mcmd) ++{ ++ struct scst_device *dev; ++ struct scst_session *sess = mcmd->sess; ++ ++ TRACE_ENTRY(); ++ ++ mcmd->state = SCST_MCMD_STATE_FINISHED; ++ if (scst_is_strict_mgmt_fn(mcmd->fn) && (mcmd->completed_cmd_count > 0)) ++ mcmd->status = SCST_MGMT_STATUS_TASK_NOT_EXIST; ++ ++ if (mcmd->fn < SCST_UNREG_SESS_TM) ++ TRACE(TRACE_MGMT, "TM fn %d (%p) finished, " ++ "status %d", mcmd->fn, mcmd, mcmd->status); ++ else ++ TRACE_MGMT_DBG("TM fn %d (%p) finished, " ++ "status %d", mcmd->fn, mcmd, mcmd->status); ++ ++ if (mcmd->fn == SCST_PR_ABORT_ALL) { ++ mcmd->origin_pr_cmd->scst_cmd_done(mcmd->origin_pr_cmd, ++ SCST_CMD_STATE_DEFAULT, ++ SCST_CONTEXT_THREAD); ++ } else if ((sess->tgt->tgtt->task_mgmt_fn_done != NULL) && ++ (mcmd->fn != SCST_UNREG_SESS_TM)) { ++ TRACE_DBG("Calling target %s task_mgmt_fn_done(%p)", ++ sess->tgt->tgtt->name, sess); ++ sess->tgt->tgtt->task_mgmt_fn_done(mcmd); ++ TRACE_MGMT_DBG("Target's %s task_mgmt_fn_done() " ++ "returned", sess->tgt->tgtt->name); ++ } ++ ++ if (mcmd->needs_unblocking) { ++ switch (mcmd->fn) { ++ case SCST_LUN_RESET: ++ case SCST_CLEAR_TASK_SET: ++ dev = mcmd->mcmd_tgt_dev->dev; ++ spin_lock_bh(&dev->dev_lock); ++ scst_unblock_dev(dev); ++ spin_unlock_bh(&dev->dev_lock); ++ break; ++ ++ case SCST_TARGET_RESET: ++ { ++ struct scst_acg *acg = mcmd->sess->acg; ++ struct scst_acg_dev *acg_dev; ++ ++ mutex_lock(&scst_mutex); ++ list_for_each_entry(acg_dev, &acg->acg_dev_list, ++ acg_dev_list_entry) { ++ dev = acg_dev->dev; ++ spin_lock_bh(&dev->dev_lock); ++ scst_unblock_dev(dev); ++ spin_unlock_bh(&dev->dev_lock); ++ } ++ mutex_unlock(&scst_mutex); ++ break; ++ } ++ ++ default: ++ BUG(); ++ break; ++ } ++ } ++ ++ mcmd->tgt_priv = NULL; ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Returns >0, if cmd should be requeued */ ++static int scst_process_mgmt_cmd(struct scst_mgmt_cmd *mcmd) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * We are in the TM thread and mcmd->state guaranteed to not be ++ * changed behind us. ++ */ ++ ++ TRACE_DBG("mcmd %p, state %d", mcmd, mcmd->state); ++ ++ while (1) { ++ switch (mcmd->state) { ++ case SCST_MCMD_STATE_INIT: ++ res = scst_mgmt_cmd_init(mcmd); ++ if (res != 0) ++ goto out; ++ break; ++ ++ case SCST_MCMD_STATE_EXEC: ++ if (scst_mgmt_cmd_exec(mcmd)) ++ goto out; ++ break; ++ ++ case SCST_MCMD_STATE_AFFECTED_CMDS_DONE: ++ if (scst_mgmt_affected_cmds_done(mcmd)) ++ goto out; ++ break; ++ ++ case SCST_MCMD_STATE_DONE: ++ scst_mgmt_cmd_send_done(mcmd); ++ break; ++ ++ case SCST_MCMD_STATE_FINISHED: ++ scst_free_mgmt_cmd(mcmd); ++ /* mcmd is dead */ ++ goto out; ++ ++ default: ++ PRINT_CRIT_ERROR("Wrong mcmd %p state %d (fn %d, " ++ "cmd_finish_wait_count %d, cmd_done_wait_count " ++ "%d)", mcmd, mcmd->state, mcmd->fn, ++ mcmd->cmd_finish_wait_count, ++ mcmd->cmd_done_wait_count); ++ BUG(); ++ res = -1; ++ goto out; ++ } ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static inline int test_mgmt_cmd_list(void) ++{ ++ int res = !list_empty(&scst_active_mgmt_cmd_list) || ++ unlikely(kthread_should_stop()); ++ return res; ++} ++ ++int scst_tm_thread(void *arg) ++{ ++ TRACE_ENTRY(); ++ ++ PRINT_INFO("Task management thread started, PID %d", current->pid); ++ ++ current->flags |= PF_NOFREEZE; ++ ++ set_user_nice(current, -10); ++ ++ spin_lock_irq(&scst_mcmd_lock); ++ while (!kthread_should_stop()) { ++ wait_queue_t wait; ++ init_waitqueue_entry(&wait, current); ++ ++ if (!test_mgmt_cmd_list()) { ++ add_wait_queue_exclusive(&scst_mgmt_cmd_list_waitQ, ++ &wait); ++ for (;;) { ++ set_current_state(TASK_INTERRUPTIBLE); ++ if (test_mgmt_cmd_list()) ++ break; ++ spin_unlock_irq(&scst_mcmd_lock); ++ schedule(); ++ spin_lock_irq(&scst_mcmd_lock); ++ } ++ set_current_state(TASK_RUNNING); ++ remove_wait_queue(&scst_mgmt_cmd_list_waitQ, &wait); ++ } ++ ++ while (!list_empty(&scst_active_mgmt_cmd_list)) { ++ int rc; ++ struct scst_mgmt_cmd *mcmd; ++ mcmd = list_entry(scst_active_mgmt_cmd_list.next, ++ typeof(*mcmd), mgmt_cmd_list_entry); ++ TRACE_MGMT_DBG("Deleting mgmt cmd %p from active cmd " ++ "list", mcmd); ++ list_del(&mcmd->mgmt_cmd_list_entry); ++ spin_unlock_irq(&scst_mcmd_lock); ++ rc = scst_process_mgmt_cmd(mcmd); ++ spin_lock_irq(&scst_mcmd_lock); ++ if (rc > 0) { ++ if (test_bit(SCST_FLAG_SUSPENDED, &scst_flags) && ++ !test_bit(SCST_FLAG_SUSPENDING, ++ &scst_flags)) { ++ TRACE_MGMT_DBG("Adding mgmt cmd %p to " ++ "head of delayed mgmt cmd list", ++ mcmd); ++ list_add(&mcmd->mgmt_cmd_list_entry, ++ &scst_delayed_mgmt_cmd_list); ++ } else { ++ TRACE_MGMT_DBG("Adding mgmt cmd %p to " ++ "head of active mgmt cmd list", ++ mcmd); ++ list_add(&mcmd->mgmt_cmd_list_entry, ++ &scst_active_mgmt_cmd_list); ++ } ++ } ++ } ++ } ++ spin_unlock_irq(&scst_mcmd_lock); ++ ++ /* ++ * If kthread_should_stop() is true, we are guaranteed to be ++ * on the module unload, so scst_active_mgmt_cmd_list must be empty. ++ */ ++ BUG_ON(!list_empty(&scst_active_mgmt_cmd_list)); ++ ++ PRINT_INFO("Task management thread PID %d finished", current->pid); ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++static struct scst_mgmt_cmd *scst_pre_rx_mgmt_cmd(struct scst_session ++ *sess, int fn, int atomic, void *tgt_priv) ++{ ++ struct scst_mgmt_cmd *mcmd = NULL; ++ ++ TRACE_ENTRY(); ++ ++ if (unlikely(sess->tgt->tgtt->task_mgmt_fn_done == NULL)) { ++ PRINT_ERROR("New mgmt cmd, but task_mgmt_fn_done() is NULL " ++ "(target %s)", sess->tgt->tgtt->name); ++ goto out; ++ } ++ ++ mcmd = scst_alloc_mgmt_cmd(atomic ? GFP_ATOMIC : GFP_KERNEL); ++ if (mcmd == NULL) { ++ PRINT_CRIT_ERROR("Lost TM fn %d, initiator %s", fn, ++ sess->initiator_name); ++ goto out; ++ } ++ ++ mcmd->sess = sess; ++ mcmd->fn = fn; ++ mcmd->state = SCST_MCMD_STATE_INIT; ++ mcmd->tgt_priv = tgt_priv; ++ ++ if (fn == SCST_PR_ABORT_ALL) { ++ atomic_inc(&mcmd->origin_pr_cmd->pr_abort_counter->pr_abort_pending_cnt); ++ atomic_inc(&mcmd->origin_pr_cmd->pr_abort_counter->pr_aborting_cnt); ++ } ++ ++out: ++ TRACE_EXIT(); ++ return mcmd; ++} ++ ++static int scst_post_rx_mgmt_cmd(struct scst_session *sess, ++ struct scst_mgmt_cmd *mcmd) ++{ ++ unsigned long flags; ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ scst_sess_get(sess); ++ ++ if (unlikely(sess->shut_phase != SCST_SESS_SPH_READY)) { ++ PRINT_CRIT_ERROR("New mgmt cmd while shutting down the " ++ "session %p shut_phase %ld", sess, sess->shut_phase); ++ BUG(); ++ } ++ ++ local_irq_save(flags); ++ ++ spin_lock(&sess->sess_list_lock); ++ atomic_inc(&sess->sess_cmd_count); ++ ++ if (unlikely(sess->init_phase != SCST_SESS_IPH_READY)) { ++ switch (sess->init_phase) { ++ case SCST_SESS_IPH_INITING: ++ TRACE_DBG("Adding mcmd %p to init deferred mcmd list", ++ mcmd); ++ list_add_tail(&mcmd->mgmt_cmd_list_entry, ++ &sess->init_deferred_mcmd_list); ++ goto out_unlock; ++ case SCST_SESS_IPH_SUCCESS: ++ break; ++ case SCST_SESS_IPH_FAILED: ++ res = -1; ++ goto out_unlock; ++ default: ++ BUG(); ++ } ++ } ++ ++ spin_unlock(&sess->sess_list_lock); ++ ++ TRACE_MGMT_DBG("Adding mgmt cmd %p to active mgmt cmd list", mcmd); ++ spin_lock(&scst_mcmd_lock); ++ list_add_tail(&mcmd->mgmt_cmd_list_entry, &scst_active_mgmt_cmd_list); ++ spin_unlock(&scst_mcmd_lock); ++ ++ local_irq_restore(flags); ++ ++ wake_up(&scst_mgmt_cmd_list_waitQ); ++ ++out: ++ TRACE_EXIT(); ++ return res; ++ ++out_unlock: ++ spin_unlock(&sess->sess_list_lock); ++ local_irq_restore(flags); ++ goto out; ++} ++ ++/** ++ * scst_rx_mgmt_fn() - create new management command and send it for execution ++ * ++ * Description: ++ * Creates new management command and sends it for execution. ++ * ++ * Returns 0 for success, error code otherwise. ++ * ++ * Must not be called in parallel with scst_unregister_session() for the ++ * same sess. ++ */ ++int scst_rx_mgmt_fn(struct scst_session *sess, ++ const struct scst_rx_mgmt_params *params) ++{ ++ int res = -EFAULT; ++ struct scst_mgmt_cmd *mcmd = NULL; ++ ++ TRACE_ENTRY(); ++ ++ switch (params->fn) { ++ case SCST_ABORT_TASK: ++ BUG_ON(!params->tag_set); ++ break; ++ case SCST_TARGET_RESET: ++ case SCST_ABORT_ALL_TASKS: ++ case SCST_NEXUS_LOSS: ++ break; ++ default: ++ BUG_ON(!params->lun_set); ++ } ++ ++ mcmd = scst_pre_rx_mgmt_cmd(sess, params->fn, params->atomic, ++ params->tgt_priv); ++ if (mcmd == NULL) ++ goto out; ++ ++ if (params->lun_set) { ++ mcmd->lun = scst_unpack_lun(params->lun, params->lun_len); ++ if (mcmd->lun == NO_SUCH_LUN) ++ goto out_free; ++ mcmd->lun_set = 1; ++ } ++ ++ if (params->tag_set) ++ mcmd->tag = params->tag; ++ ++ mcmd->cmd_sn_set = params->cmd_sn_set; ++ mcmd->cmd_sn = params->cmd_sn; ++ ++ if (params->fn < SCST_UNREG_SESS_TM) ++ TRACE(TRACE_MGMT, "TM fn %d (%p)", params->fn, mcmd); ++ else ++ TRACE_MGMT_DBG("TM fn %d (%p)", params->fn, mcmd); ++ ++ TRACE_MGMT_DBG("sess=%p, tag_set %d, tag %lld, lun_set %d, " ++ "lun=%lld, cmd_sn_set %d, cmd_sn %d, priv %p", sess, ++ params->tag_set, ++ (long long unsigned int)params->tag, ++ params->lun_set, ++ (long long unsigned int)mcmd->lun, ++ params->cmd_sn_set, ++ params->cmd_sn, ++ params->tgt_priv); ++ ++ if (scst_post_rx_mgmt_cmd(sess, mcmd) != 0) ++ goto out_free; ++ ++ res = 0; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free: ++ scst_free_mgmt_cmd(mcmd); ++ mcmd = NULL; ++ goto out; ++} ++EXPORT_SYMBOL(scst_rx_mgmt_fn); ++ ++/* ++ * Written by Jack Handy - jakkhandy@hotmail.com ++ * Taken by Gennadiy Nerubayev <parakie@gmail.com> from ++ * http://www.codeproject.com/KB/string/wildcmp.aspx. No license attached ++ * to it, and it's posted on a free site; assumed to be free for use. ++ * ++ * Added the negative sign support - VLNB ++ * ++ * Also see comment for wildcmp(). ++ * ++ * User space part of iSCSI-SCST also has a copy of this code, so fixing a bug ++ * here, don't forget to fix the copy too! ++ */ ++static bool __wildcmp(const char *wild, const char *string, int recursion_level) ++{ ++ const char *cp = NULL, *mp = NULL; ++ ++ while ((*string) && (*wild != '*')) { ++ if ((*wild == '!') && (recursion_level == 0)) ++ return !__wildcmp(++wild, string, ++recursion_level); ++ ++ if ((*wild != *string) && (*wild != '?')) ++ return false; ++ ++ wild++; ++ string++; ++ } ++ ++ while (*string) { ++ if ((*wild == '!') && (recursion_level == 0)) ++ return !__wildcmp(++wild, string, ++recursion_level); ++ ++ if (*wild == '*') { ++ if (!*++wild) ++ return true; ++ ++ mp = wild; ++ cp = string+1; ++ } else if ((*wild == *string) || (*wild == '?')) { ++ wild++; ++ string++; ++ } else { ++ wild = mp; ++ string = cp++; ++ } ++ } ++ ++ while (*wild == '*') ++ wild++; ++ ++ return !*wild; ++} ++ ++/* ++ * Returns true if string "string" matches pattern "wild", false otherwise. ++ * Pattern is a regular DOS-type pattern, containing '*' and '?' symbols. ++ * '*' means match all any symbols, '?' means match only any single symbol. ++ * ++ * For instance: ++ * if (wildcmp("bl?h.*", "blah.jpg")) { ++ * // match ++ * } else { ++ * // no match ++ * } ++ * ++ * Also it supports boolean inversion sign '!', which does boolean inversion of ++ * the value of the rest of the string. Only one '!' allowed in the pattern, ++ * other '!' are treated as regular symbols. For instance: ++ * if (wildcmp("bl!?h.*", "blah.jpg")) { ++ * // no match ++ * } else { ++ * // match ++ * } ++ * ++ * Also see comment for __wildcmp(). ++ */ ++static bool wildcmp(const char *wild, const char *string) ++{ ++ return __wildcmp(wild, string, 0); ++} ++ ++/* scst_mutex supposed to be held */ ++static struct scst_acg *scst_find_tgt_acg_by_name_wild(struct scst_tgt *tgt, ++ const char *initiator_name) ++{ ++ struct scst_acg *acg, *res = NULL; ++ struct scst_acn *n; ++ ++ TRACE_ENTRY(); ++ ++ if (initiator_name == NULL) ++ goto out; ++ ++ list_for_each_entry(acg, &tgt->tgt_acg_list, acg_list_entry) { ++ list_for_each_entry(n, &acg->acn_list, acn_list_entry) { ++ if (wildcmp(n->name, initiator_name)) { ++ TRACE_DBG("Access control group %s found", ++ acg->acg_name); ++ res = acg; ++ goto out; ++ } ++ } ++ } ++ ++out: ++ TRACE_EXIT_HRES(res); ++ return res; ++} ++ ++/* Must be called under scst_mutex */ ++static struct scst_acg *__scst_find_acg(struct scst_tgt *tgt, ++ const char *initiator_name) ++{ ++ struct scst_acg *acg = NULL; ++ ++ TRACE_ENTRY(); ++ ++ acg = scst_find_tgt_acg_by_name_wild(tgt, initiator_name); ++ if (acg == NULL) ++ acg = tgt->default_acg; ++ ++ TRACE_EXIT_HRES((unsigned long)acg); ++ return acg; ++} ++ ++/* Must be called under scst_mutex */ ++struct scst_acg *scst_find_acg(const struct scst_session *sess) ++{ ++ return __scst_find_acg(sess->tgt, sess->initiator_name); ++} ++ ++/** ++ * scst_initiator_has_luns() - check if this initiator will see any LUNs ++ * ++ * Checks if this initiator will see any LUNs upon connect to this target. ++ * Returns true if yes and false otherwise. ++ */ ++bool scst_initiator_has_luns(struct scst_tgt *tgt, const char *initiator_name) ++{ ++ bool res; ++ struct scst_acg *acg; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_mutex); ++ ++ acg = __scst_find_acg(tgt, initiator_name); ++ ++ res = !list_empty(&acg->acg_dev_list); ++ ++ mutex_unlock(&scst_mutex); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL_GPL(scst_initiator_has_luns); ++ ++static int scst_init_session(struct scst_session *sess) ++{ ++ int res = 0; ++ struct scst_cmd *cmd; ++ struct scst_mgmt_cmd *mcmd, *tm; ++ int mwake = 0; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_mutex); ++ ++ sess->acg = scst_find_acg(sess); ++ ++ PRINT_INFO("Using security group \"%s\" for initiator \"%s\" " ++ "(target %s)", sess->acg->acg_name, sess->initiator_name, ++ sess->tgt->tgt_name); ++ ++ list_add_tail(&sess->acg_sess_list_entry, &sess->acg->acg_sess_list); ++ ++ TRACE_DBG("Adding sess %p to tgt->sess_list", sess); ++ list_add_tail(&sess->sess_list_entry, &sess->tgt->sess_list); ++ ++ if (sess->tgt->tgtt->get_initiator_port_transport_id != NULL) { ++ res = sess->tgt->tgtt->get_initiator_port_transport_id( ++ sess->tgt, sess, &sess->transport_id); ++ if (res != 0) { ++ PRINT_ERROR("Unable to make initiator %s port " ++ "transport id", sess->initiator_name); ++ goto failed; ++ } ++ TRACE_PR("sess %p (ini %s), transport id %s/%d", sess, ++ sess->initiator_name, ++ debug_transport_id_to_initiator_name( ++ sess->transport_id), sess->tgt->rel_tgt_id); ++ } ++ ++ res = scst_sess_sysfs_create(sess); ++ if (res != 0) ++ goto failed; ++ ++ /* ++ * scst_sess_alloc_tgt_devs() must be called after session added in the ++ * sess_list to not race with scst_check_reassign_sess()! ++ */ ++ res = scst_sess_alloc_tgt_devs(sess); ++ ++failed: ++ mutex_unlock(&scst_mutex); ++ ++ if (sess->init_result_fn) { ++ TRACE_DBG("Calling init_result_fn(%p)", sess); ++ sess->init_result_fn(sess, sess->reg_sess_data, res); ++ TRACE_DBG("%s", "init_result_fn() returned"); ++ } ++ ++ spin_lock_irq(&sess->sess_list_lock); ++ ++ if (res == 0) ++ sess->init_phase = SCST_SESS_IPH_SUCCESS; ++ else ++ sess->init_phase = SCST_SESS_IPH_FAILED; ++ ++restart: ++ list_for_each_entry(cmd, &sess->init_deferred_cmd_list, ++ cmd_list_entry) { ++ TRACE_DBG("Deleting cmd %p from init deferred cmd list", cmd); ++ list_del(&cmd->cmd_list_entry); ++ atomic_dec(&sess->sess_cmd_count); ++ spin_unlock_irq(&sess->sess_list_lock); ++ scst_cmd_init_done(cmd, SCST_CONTEXT_THREAD); ++ spin_lock_irq(&sess->sess_list_lock); ++ goto restart; ++ } ++ ++ spin_lock(&scst_mcmd_lock); ++ list_for_each_entry_safe(mcmd, tm, &sess->init_deferred_mcmd_list, ++ mgmt_cmd_list_entry) { ++ TRACE_DBG("Moving mgmt command %p from init deferred mcmd list", ++ mcmd); ++ list_move_tail(&mcmd->mgmt_cmd_list_entry, ++ &scst_active_mgmt_cmd_list); ++ mwake = 1; ++ } ++ ++ spin_unlock(&scst_mcmd_lock); ++ /* ++ * In case of an error at this point the caller target driver supposed ++ * to already call this sess's unregistration. ++ */ ++ sess->init_phase = SCST_SESS_IPH_READY; ++ spin_unlock_irq(&sess->sess_list_lock); ++ ++ if (mwake) ++ wake_up(&scst_mgmt_cmd_list_waitQ); ++ ++ scst_sess_put(sess); ++ ++ TRACE_EXIT(); ++ return res; ++} ++ ++/** ++ * scst_register_session() - register session ++ * @tgt: target ++ * @atomic: true, if the function called in the atomic context. If false, ++ * this function will block until the session registration is ++ * completed. ++ * @initiator_name: remote initiator's name, any NULL-terminated string, ++ * e.g. iSCSI name, which used as the key to found appropriate ++ * access control group. Could be NULL, then the default ++ * target's LUNs are used. ++ * @tgt_priv: pointer to target driver's private data ++ * @result_fn_data: any target driver supplied data ++ * @result_fn: pointer to the function that will be asynchronously called ++ * when session initialization finishes. ++ * Can be NULL. Parameters: ++ * - sess - session ++ * - data - target driver supplied to scst_register_session() ++ * data ++ * - result - session initialization result, 0 on success or ++ * appropriate error code otherwise ++ * ++ * Description: ++ * Registers new session. Returns new session on success or NULL otherwise. ++ * ++ * Note: A session creation and initialization is a complex task, ++ * which requires sleeping state, so it can't be fully done ++ * in interrupt context. Therefore the "bottom half" of it, if ++ * scst_register_session() is called from atomic context, will be ++ * done in SCST thread context. In this case scst_register_session() ++ * will return not completely initialized session, but the target ++ * driver can supply commands to this session via scst_rx_cmd(). ++ * Those commands processing will be delayed inside SCST until ++ * the session initialization is finished, then their processing ++ * will be restarted. The target driver will be notified about ++ * finish of the session initialization by function result_fn(). ++ * On success the target driver could do nothing, but if the ++ * initialization fails, the target driver must ensure that ++ * no more new commands being sent or will be sent to SCST after ++ * result_fn() returns. All already sent to SCST commands for ++ * failed session will be returned in xmit_response() with BUSY status. ++ * In case of failure the driver shall call scst_unregister_session() ++ * inside result_fn(), it will NOT be called automatically. ++ */ ++struct scst_session *scst_register_session(struct scst_tgt *tgt, int atomic, ++ const char *initiator_name, void *tgt_priv, void *result_fn_data, ++ void (*result_fn) (struct scst_session *sess, void *data, int result)) ++{ ++ struct scst_session *sess; ++ int res; ++ unsigned long flags; ++ ++ TRACE_ENTRY(); ++ ++ sess = scst_alloc_session(tgt, atomic ? GFP_ATOMIC : GFP_KERNEL, ++ initiator_name); ++ if (sess == NULL) ++ goto out; ++ ++ scst_sess_set_tgt_priv(sess, tgt_priv); ++ ++ scst_sess_get(sess); /* one for registered session */ ++ scst_sess_get(sess); /* one held until sess is inited */ ++ ++ if (atomic) { ++ sess->reg_sess_data = result_fn_data; ++ sess->init_result_fn = result_fn; ++ spin_lock_irqsave(&scst_mgmt_lock, flags); ++ TRACE_DBG("Adding sess %p to scst_sess_init_list", sess); ++ list_add_tail(&sess->sess_init_list_entry, ++ &scst_sess_init_list); ++ spin_unlock_irqrestore(&scst_mgmt_lock, flags); ++ wake_up(&scst_mgmt_waitQ); ++ } else { ++ res = scst_init_session(sess); ++ if (res != 0) ++ goto out_free; ++ } ++ ++out: ++ TRACE_EXIT(); ++ return sess; ++ ++out_free: ++ scst_free_session(sess); ++ sess = NULL; ++ goto out; ++} ++EXPORT_SYMBOL_GPL(scst_register_session); ++ ++/** ++ * scst_register_session_non_gpl() - register session (non-GPL version) ++ * @tgt: target ++ * @initiator_name: remote initiator's name, any NULL-terminated string, ++ * e.g. iSCSI name, which used as the key to found appropriate ++ * access control group. Could be NULL, then the default ++ * target's LUNs are used. ++ * @tgt_priv: pointer to target driver's private data ++ * ++ * Description: ++ * Registers new session. Returns new session on success or NULL otherwise. ++ */ ++struct scst_session *scst_register_session_non_gpl(struct scst_tgt *tgt, ++ const char *initiator_name, void *tgt_priv) ++{ ++ return scst_register_session(tgt, 0, initiator_name, tgt_priv, ++ NULL, NULL); ++} ++EXPORT_SYMBOL(scst_register_session_non_gpl); ++ ++/** ++ * scst_unregister_session() - unregister session ++ * @sess: session to be unregistered ++ * @wait: if true, instructs to wait until all commands, which ++ * currently is being executed and belonged to the session, ++ * finished. Otherwise, target driver should be prepared to ++ * receive xmit_response() for the session's command after ++ * scst_unregister_session() returns. ++ * @unreg_done_fn: pointer to the function that will be asynchronously called ++ * when the last session's command finishes and ++ * the session is about to be completely freed. Can be NULL. ++ * Parameter: ++ * - sess - session ++ * ++ * Unregisters session. ++ * ++ * Notes: ++ * - All outstanding commands will be finished regularly. After ++ * scst_unregister_session() returned, no new commands must be sent to ++ * SCST via scst_rx_cmd(). ++ * ++ * - The caller must ensure that no scst_rx_cmd() or scst_rx_mgmt_fn_*() is ++ * called in parallel with scst_unregister_session(). ++ * ++ * - Can be called before result_fn() of scst_register_session() called, ++ * i.e. during the session registration/initialization. ++ * ++ * - It is highly recommended to call scst_unregister_session() as soon as it ++ * gets clear that session will be unregistered and not to wait until all ++ * related commands finished. This function provides the wait functionality, ++ * but it also starts recovering stuck commands, if there are any. ++ * Otherwise, your target driver could wait for those commands forever. ++ */ ++void scst_unregister_session(struct scst_session *sess, int wait, ++ void (*unreg_done_fn) (struct scst_session *sess)) ++{ ++ unsigned long flags; ++ DECLARE_COMPLETION_ONSTACK(c); ++ int rc, lun; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Unregistering session %p (wait %d)", sess, wait); ++ ++ sess->unreg_done_fn = unreg_done_fn; ++ ++ /* Abort all outstanding commands and clear reservation, if necessary */ ++ lun = 0; ++ rc = scst_rx_mgmt_fn_lun(sess, SCST_UNREG_SESS_TM, ++ (uint8_t *)&lun, sizeof(lun), SCST_ATOMIC, NULL); ++ if (rc != 0) { ++ PRINT_ERROR("SCST_UNREG_SESS_TM failed %d (sess %p)", ++ rc, sess); ++ } ++ ++ sess->shut_phase = SCST_SESS_SPH_SHUTDOWN; ++ ++ spin_lock_irqsave(&scst_mgmt_lock, flags); ++ ++ if (wait) ++ sess->shutdown_compl = &c; ++ ++ spin_unlock_irqrestore(&scst_mgmt_lock, flags); ++ ++ scst_sess_put(sess); ++ ++ if (wait) { ++ TRACE_DBG("Waiting for session %p to complete", sess); ++ wait_for_completion(&c); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL_GPL(scst_unregister_session); ++ ++/** ++ * scst_unregister_session_non_gpl() - unregister session, non-GPL version ++ * @sess: session to be unregistered ++ * ++ * Unregisters session. ++ * ++ * See notes for scst_unregister_session() above. ++ */ ++void scst_unregister_session_non_gpl(struct scst_session *sess) ++{ ++ TRACE_ENTRY(); ++ ++ scst_unregister_session(sess, 1, NULL); ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL(scst_unregister_session_non_gpl); ++ ++static inline int test_mgmt_list(void) ++{ ++ int res = !list_empty(&scst_sess_init_list) || ++ !list_empty(&scst_sess_shut_list) || ++ unlikely(kthread_should_stop()); ++ return res; ++} ++ ++int scst_global_mgmt_thread(void *arg) ++{ ++ struct scst_session *sess; ++ ++ TRACE_ENTRY(); ++ ++ PRINT_INFO("Management thread started, PID %d", current->pid); ++ ++ current->flags |= PF_NOFREEZE; ++ ++ set_user_nice(current, -10); ++ ++ spin_lock_irq(&scst_mgmt_lock); ++ while (!kthread_should_stop()) { ++ wait_queue_t wait; ++ init_waitqueue_entry(&wait, current); ++ ++ if (!test_mgmt_list()) { ++ add_wait_queue_exclusive(&scst_mgmt_waitQ, &wait); ++ for (;;) { ++ set_current_state(TASK_INTERRUPTIBLE); ++ if (test_mgmt_list()) ++ break; ++ spin_unlock_irq(&scst_mgmt_lock); ++ schedule(); ++ spin_lock_irq(&scst_mgmt_lock); ++ } ++ set_current_state(TASK_RUNNING); ++ remove_wait_queue(&scst_mgmt_waitQ, &wait); ++ } ++ ++ while (!list_empty(&scst_sess_init_list)) { ++ sess = list_entry(scst_sess_init_list.next, ++ typeof(*sess), sess_init_list_entry); ++ TRACE_DBG("Removing sess %p from scst_sess_init_list", ++ sess); ++ list_del(&sess->sess_init_list_entry); ++ spin_unlock_irq(&scst_mgmt_lock); ++ ++ if (sess->init_phase == SCST_SESS_IPH_INITING) ++ scst_init_session(sess); ++ else { ++ PRINT_CRIT_ERROR("session %p is in " ++ "scst_sess_init_list, but in unknown " ++ "init phase %x", sess, ++ sess->init_phase); ++ BUG(); ++ } ++ ++ spin_lock_irq(&scst_mgmt_lock); ++ } ++ ++ while (!list_empty(&scst_sess_shut_list)) { ++ sess = list_entry(scst_sess_shut_list.next, ++ typeof(*sess), sess_shut_list_entry); ++ TRACE_DBG("Removing sess %p from scst_sess_shut_list", ++ sess); ++ list_del(&sess->sess_shut_list_entry); ++ spin_unlock_irq(&scst_mgmt_lock); ++ ++ switch (sess->shut_phase) { ++ case SCST_SESS_SPH_SHUTDOWN: ++ BUG_ON(atomic_read(&sess->refcnt) != 0); ++ scst_free_session_callback(sess); ++ break; ++ default: ++ PRINT_CRIT_ERROR("session %p is in " ++ "scst_sess_shut_list, but in unknown " ++ "shut phase %lx", sess, ++ sess->shut_phase); ++ BUG(); ++ break; ++ } ++ ++ spin_lock_irq(&scst_mgmt_lock); ++ } ++ } ++ spin_unlock_irq(&scst_mgmt_lock); ++ ++ /* ++ * If kthread_should_stop() is true, we are guaranteed to be ++ * on the module unload, so both lists must be empty. ++ */ ++ BUG_ON(!list_empty(&scst_sess_init_list)); ++ BUG_ON(!list_empty(&scst_sess_shut_list)); ++ ++ PRINT_INFO("Management thread PID %d finished", current->pid); ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++/* Called under sess->sess_list_lock */ ++static struct scst_cmd *__scst_find_cmd_by_tag(struct scst_session *sess, ++ uint64_t tag, bool to_abort) ++{ ++ struct scst_cmd *cmd, *res = NULL; ++ ++ TRACE_ENTRY(); ++ ++ /* ToDo: hash list */ ++ ++ TRACE_DBG("%s (sess=%p, tag=%llu)", "Searching in sess cmd list", ++ sess, (long long unsigned int)tag); ++ ++ list_for_each_entry(cmd, &sess->sess_cmd_list, ++ sess_cmd_list_entry) { ++ if (cmd->tag == tag) { ++ /* ++ * We must not count done commands, because ++ * they were submitted for transmission. ++ * Otherwise we can have a race, when for ++ * some reason cmd's release delayed ++ * after transmission and initiator sends ++ * cmd with the same tag => it can be possible ++ * that a wrong cmd will be returned. ++ */ ++ if (cmd->done) { ++ if (to_abort) { ++ /* ++ * We should return the latest not ++ * aborted cmd with this tag. ++ */ ++ if (res == NULL) ++ res = cmd; ++ else { ++ if (test_bit(SCST_CMD_ABORTED, ++ &res->cmd_flags)) { ++ res = cmd; ++ } else if (!test_bit(SCST_CMD_ABORTED, ++ &cmd->cmd_flags)) ++ res = cmd; ++ } ++ } ++ continue; ++ } else { ++ res = cmd; ++ break; ++ } ++ } ++ } ++ ++ TRACE_EXIT(); ++ return res; ++} ++ ++/** ++ * scst_find_cmd() - find command by custom comparison function ++ * ++ * Finds a command based on user supplied data and comparison ++ * callback function, that should return true, if the command is found. ++ * Returns the command on success or NULL otherwise. ++ */ ++struct scst_cmd *scst_find_cmd(struct scst_session *sess, void *data, ++ int (*cmp_fn) (struct scst_cmd *cmd, ++ void *data)) ++{ ++ struct scst_cmd *cmd = NULL; ++ unsigned long flags = 0; ++ ++ TRACE_ENTRY(); ++ ++ if (cmp_fn == NULL) ++ goto out; ++ ++ spin_lock_irqsave(&sess->sess_list_lock, flags); ++ ++ TRACE_DBG("Searching in sess cmd list (sess=%p)", sess); ++ list_for_each_entry(cmd, &sess->sess_cmd_list, sess_cmd_list_entry) { ++ /* ++ * We must not count done commands, because they were ++ * submitted for transmission. Otherwise we can have a race, ++ * when for some reason cmd's release delayed after ++ * transmission and initiator sends cmd with the same tag => ++ * it can be possible that a wrong cmd will be returned. ++ */ ++ if (cmd->done) ++ continue; ++ if (cmp_fn(cmd, data)) ++ goto out_unlock; ++ } ++ ++ cmd = NULL; ++ ++out_unlock: ++ spin_unlock_irqrestore(&sess->sess_list_lock, flags); ++ ++out: ++ TRACE_EXIT(); ++ return cmd; ++} ++EXPORT_SYMBOL(scst_find_cmd); ++ ++/** ++ * scst_find_cmd_by_tag() - find command by tag ++ * ++ * Finds a command based on the supplied tag comparing it with one ++ * that previously set by scst_cmd_set_tag(). Returns the found command on ++ * success or NULL otherwise. ++ */ ++struct scst_cmd *scst_find_cmd_by_tag(struct scst_session *sess, ++ uint64_t tag) ++{ ++ unsigned long flags; ++ struct scst_cmd *cmd; ++ spin_lock_irqsave(&sess->sess_list_lock, flags); ++ cmd = __scst_find_cmd_by_tag(sess, tag, false); ++ spin_unlock_irqrestore(&sess->sess_list_lock, flags); ++ return cmd; ++} ++EXPORT_SYMBOL(scst_find_cmd_by_tag); +diff -uprN orig/linux-3.2/drivers/scst/scst_lib.c linux-3.2/drivers/scst/scst_lib.c +--- orig/linux-3.2/drivers/scst/scst_lib.c ++++ linux-3.2/drivers/scst/scst_lib.c +@@ -0,0 +1,7480 @@ ++/* ++ * scst_lib.c ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/init.h> ++#include <linux/kernel.h> ++#include <linux/errno.h> ++#include <linux/list.h> ++#include <linux/spinlock.h> ++#include <linux/slab.h> ++#include <linux/sched.h> ++#include <linux/kthread.h> ++#include <linux/cdrom.h> ++#include <linux/unistd.h> ++#include <linux/string.h> ++#include <linux/ctype.h> ++#include <linux/delay.h> ++#include <linux/vmalloc.h> ++#include <asm/kmap_types.h> ++#include <asm/unaligned.h> ++ ++#include <scst/scst.h> ++#include "scst_priv.h" ++#include "scst_mem.h" ++#include "scst_pres.h" ++ ++struct scsi_io_context { ++ void *data; ++ void (*done)(void *data, char *sense, int result, int resid); ++ char sense[SCST_SENSE_BUFFERSIZE]; ++}; ++static struct kmem_cache *scsi_io_context_cache; ++ ++/* get_trans_len_x extract x bytes from cdb as length starting from off */ ++static int get_trans_len_1(struct scst_cmd *cmd, uint8_t off); ++static int get_trans_len_1_256(struct scst_cmd *cmd, uint8_t off); ++static int get_trans_len_2(struct scst_cmd *cmd, uint8_t off); ++static int get_trans_len_3(struct scst_cmd *cmd, uint8_t off); ++static int get_trans_len_4(struct scst_cmd *cmd, uint8_t off); ++ ++static int get_bidi_trans_len_2(struct scst_cmd *cmd, uint8_t off); ++ ++/* for special commands */ ++static int get_trans_len_block_limit(struct scst_cmd *cmd, uint8_t off); ++static int get_trans_len_read_capacity(struct scst_cmd *cmd, uint8_t off); ++static int get_trans_len_serv_act_in(struct scst_cmd *cmd, uint8_t off); ++static int get_trans_len_single(struct scst_cmd *cmd, uint8_t off); ++static int get_trans_len_none(struct scst_cmd *cmd, uint8_t off); ++static int get_trans_len_read_pos(struct scst_cmd *cmd, uint8_t off); ++static int get_trans_cdb_len_10(struct scst_cmd *cmd, uint8_t off); ++static int get_trans_len_prevent_allow_medium_removal(struct scst_cmd *cmd, ++ uint8_t off); ++static int get_trans_len_3_read_elem_stat(struct scst_cmd *cmd, uint8_t off); ++static int get_trans_len_start_stop(struct scst_cmd *cmd, uint8_t off); ++ ++/* +++=====================================-============-======- ++| Command name | Operation | Type | ++| | code | | ++|-------------------------------------+------------+------+ ++ +++=========================================================+ ++|Key: M = command implementation is mandatory. | ++| O = command implementation is optional. | ++| V = Vendor-specific | ++| R = Reserved | ++| ' '= DON'T use for this device | +++=========================================================+ ++*/ ++ ++#define SCST_CDB_MANDATORY 'M' /* mandatory */ ++#define SCST_CDB_OPTIONAL 'O' /* optional */ ++#define SCST_CDB_VENDOR 'V' /* vendor */ ++#define SCST_CDB_RESERVED 'R' /* reserved */ ++#define SCST_CDB_NOTSUPP ' ' /* don't use */ ++ ++struct scst_sdbops { ++ uint8_t ops; /* SCSI-2 op codes */ ++ uint8_t devkey[16]; /* Key for every device type M,O,V,R ++ * type_disk devkey[0] ++ * type_tape devkey[1] ++ * type_printer devkey[2] ++ * type_processor devkey[3] ++ * type_worm devkey[4] ++ * type_cdrom devkey[5] ++ * type_scanner devkey[6] ++ * type_mod devkey[7] ++ * type_changer devkey[8] ++ * type_commdev devkey[9] ++ * type_reserv devkey[A] ++ * type_reserv devkey[B] ++ * type_raid devkey[C] ++ * type_enclosure devkey[D] ++ * type_reserv devkey[E] ++ * type_reserv devkey[F] ++ */ ++ const char *op_name; /* SCSI-2 op codes full name */ ++ uint8_t direction; /* init --> target: SCST_DATA_WRITE ++ * target --> init: SCST_DATA_READ ++ */ ++ uint32_t flags; /* opcode -- various flags */ ++ uint8_t off; /* length offset in cdb */ ++ int (*get_trans_len)(struct scst_cmd *cmd, uint8_t off); ++}; ++ ++static int scst_scsi_op_list[256]; ++ ++#define FLAG_NONE 0 ++ ++static const struct scst_sdbops scst_scsi_op_table[] = { ++ /* ++ * +-------------------> TYPE_IS_DISK (0) ++ * | ++ * |+------------------> TYPE_IS_TAPE (1) ++ * || ++ * || +----------------> TYPE_IS_PROCESSOR (3) ++ * || | ++ * || | +--------------> TYPE_IS_CDROM (5) ++ * || | | ++ * || | | +------------> TYPE_IS_MOD (7) ++ * || | | | ++ * || | | |+-----------> TYPE_IS_CHANGER (8) ++ * || | | || ++ * || | | || +-------> TYPE_IS_RAID (C) ++ * || | | || | ++ * || | | || | ++ * 0123456789ABCDEF ---> TYPE_IS_???? */ ++ ++ /* 6-bytes length CDB */ ++ {0x00, "MMMMMMMMMMMMMMMM", "TEST UNIT READY", ++ /* let's be HQ to don't look dead under high load */ ++ SCST_DATA_NONE, SCST_SMALL_TIMEOUT|SCST_IMPLICIT_HQ| ++ SCST_REG_RESERVE_ALLOWED| ++ SCST_WRITE_EXCL_ALLOWED| ++#ifdef CONFIG_SCST_TEST_IO_IN_SIRQ ++ SCST_TEST_IO_IN_SIRQ_ALLOWED| ++#endif ++ SCST_EXCL_ACCESS_ALLOWED, ++ 0, get_trans_len_none}, ++ {0x01, " M ", "REWIND", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT|SCST_WRITE_EXCL_ALLOWED, ++ 0, get_trans_len_none}, ++ {0x01, "O V OO OO ", "REZERO UNIT", ++ SCST_DATA_NONE, SCST_WRITE_EXCL_ALLOWED, ++ 0, get_trans_len_none}, ++ {0x02, "VVVVVV V ", "REQUEST BLOCK ADDR", ++ SCST_DATA_NONE, SCST_SMALL_TIMEOUT, 0, get_trans_len_none}, ++ {0x03, "MMMMMMMMMMMMMMMM", "REQUEST SENSE", ++ SCST_DATA_READ, SCST_SMALL_TIMEOUT|SCST_SKIP_UA|SCST_LOCAL_CMD| ++ SCST_REG_RESERVE_ALLOWED| ++ SCST_WRITE_EXCL_ALLOWED| ++ SCST_EXCL_ACCESS_ALLOWED, ++ 4, get_trans_len_1}, ++ {0x04, "M O O ", "FORMAT UNIT", ++ SCST_DATA_WRITE, SCST_LONG_TIMEOUT|SCST_UNKNOWN_LENGTH|SCST_WRITE_MEDIUM, ++ 0, get_trans_len_none}, ++ {0x04, " O ", "FORMAT", ++ SCST_DATA_NONE, SCST_WRITE_MEDIUM, 0, get_trans_len_none}, ++ {0x05, "VMVVVV V ", "READ BLOCK LIMITS", ++ SCST_DATA_READ, SCST_SMALL_TIMEOUT| ++ SCST_REG_RESERVE_ALLOWED| ++ SCST_WRITE_EXCL_ALLOWED| ++ SCST_EXCL_ACCESS_ALLOWED, ++ 0, get_trans_len_block_limit}, ++ {0x07, " O ", "INITIALIZE ELEMENT STATUS", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT, 0, get_trans_len_none}, ++ {0x07, "OVV O OV ", "REASSIGN BLOCKS", ++ SCST_DATA_NONE, SCST_WRITE_MEDIUM, 0, get_trans_len_none}, ++ {0x08, "O ", "READ(6)", ++ SCST_DATA_READ, SCST_TRANSFER_LEN_TYPE_FIXED| ++#ifdef CONFIG_SCST_TEST_IO_IN_SIRQ ++ SCST_TEST_IO_IN_SIRQ_ALLOWED| ++#endif ++ SCST_WRITE_EXCL_ALLOWED, ++ 4, get_trans_len_1_256}, ++ {0x08, " MV OO OV ", "READ(6)", ++ SCST_DATA_READ, SCST_TRANSFER_LEN_TYPE_FIXED| ++ SCST_WRITE_EXCL_ALLOWED, ++ 2, get_trans_len_3}, ++ {0x08, " M ", "GET MESSAGE(6)", ++ SCST_DATA_READ, FLAG_NONE, 2, get_trans_len_3}, ++ {0x08, " O ", "RECEIVE", ++ SCST_DATA_READ, FLAG_NONE, 2, get_trans_len_3}, ++ {0x0A, "O ", "WRITE(6)", ++ SCST_DATA_WRITE, SCST_TRANSFER_LEN_TYPE_FIXED| ++#ifdef CONFIG_SCST_TEST_IO_IN_SIRQ ++ SCST_TEST_IO_IN_SIRQ_ALLOWED| ++#endif ++ SCST_WRITE_MEDIUM, ++ 4, get_trans_len_1_256}, ++ {0x0A, " M O OV ", "WRITE(6)", ++ SCST_DATA_WRITE, SCST_TRANSFER_LEN_TYPE_FIXED|SCST_WRITE_MEDIUM, ++ 2, get_trans_len_3}, ++ {0x0A, " M ", "PRINT", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x0A, " M ", "SEND MESSAGE(6)", ++ SCST_DATA_WRITE, FLAG_NONE, 2, get_trans_len_3}, ++ {0x0A, " M ", "SEND(6)", ++ SCST_DATA_WRITE, FLAG_NONE, 2, get_trans_len_3}, ++ {0x0B, "O OO OV ", "SEEK(6)", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x0B, " ", "TRACK SELECT", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x0B, " O ", "SLEW AND PRINT", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x0C, "VVVVVV V ", "SEEK BLOCK", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT, 0, get_trans_len_none}, ++ {0x0D, "VVVVVV V ", "PARTITION", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT|SCST_WRITE_MEDIUM, ++ 0, get_trans_len_none}, ++ {0x0F, "VOVVVV V ", "READ REVERSE", ++ SCST_DATA_READ, SCST_TRANSFER_LEN_TYPE_FIXED| ++ SCST_WRITE_EXCL_ALLOWED, ++ 2, get_trans_len_3}, ++ {0x10, "VM V V ", "WRITE FILEMARKS", ++ SCST_DATA_NONE, SCST_WRITE_MEDIUM, 0, get_trans_len_none}, ++ {0x10, " O O ", "SYNCHRONIZE BUFFER", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x11, "VMVVVV ", "SPACE", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT| ++ SCST_WRITE_EXCL_ALLOWED, ++ 0, get_trans_len_none}, ++ {0x12, "MMMMMMMMMMMMMMMM", "INQUIRY", ++ SCST_DATA_READ, SCST_SMALL_TIMEOUT|SCST_IMPLICIT_HQ|SCST_SKIP_UA| ++ SCST_REG_RESERVE_ALLOWED| ++ SCST_WRITE_EXCL_ALLOWED|SCST_EXCL_ACCESS_ALLOWED, ++ 3, get_trans_len_2}, ++ {0x13, "VOVVVV ", "VERIFY(6)", ++ SCST_DATA_NONE, SCST_TRANSFER_LEN_TYPE_FIXED| ++ SCST_VERIFY_BYTCHK_MISMATCH_ALLOWED| ++ SCST_WRITE_EXCL_ALLOWED, ++ 2, get_trans_len_3}, ++ {0x14, "VOOVVV ", "RECOVER BUFFERED DATA", ++ SCST_DATA_READ, SCST_TRANSFER_LEN_TYPE_FIXED| ++ SCST_WRITE_EXCL_ALLOWED, ++ 2, get_trans_len_3}, ++ {0x15, "OMOOOOOOOOOOOOOO", "MODE SELECT(6)", ++ SCST_DATA_WRITE, SCST_STRICTLY_SERIALIZED, 4, get_trans_len_1}, ++ {0x16, "MMMMMMMMMMMMMMMM", "RESERVE", ++ SCST_DATA_NONE, SCST_SMALL_TIMEOUT|SCST_LOCAL_CMD|SCST_SERIALIZED| ++ SCST_WRITE_EXCL_ALLOWED|SCST_EXCL_ACCESS_ALLOWED, ++ 0, get_trans_len_none}, ++ {0x17, "MMMMMMMMMMMMMMMM", "RELEASE", ++ SCST_DATA_NONE, SCST_SMALL_TIMEOUT|SCST_LOCAL_CMD|SCST_SERIALIZED| ++ SCST_REG_RESERVE_ALLOWED| ++ SCST_WRITE_EXCL_ALLOWED|SCST_EXCL_ACCESS_ALLOWED, ++ 0, get_trans_len_none}, ++ {0x18, "OOOOOOOO ", "COPY", ++ SCST_DATA_WRITE, SCST_LONG_TIMEOUT, 2, get_trans_len_3}, ++ {0x19, "VMVVVV ", "ERASE", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT|SCST_WRITE_MEDIUM, ++ 0, get_trans_len_none}, ++ {0x1A, "OMOOOOOOOOOOOOOO", "MODE SENSE(6)", ++ SCST_DATA_READ, SCST_SMALL_TIMEOUT, 4, get_trans_len_1}, ++ {0x1B, " O ", "SCAN", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x1B, " O ", "LOAD UNLOAD", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT, 0, get_trans_len_none}, ++ {0x1B, " O ", "STOP PRINT", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x1B, "O OO O O ", "START STOP UNIT", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT, 0, get_trans_len_start_stop}, ++ {0x1C, "OOOOOOOOOOOOOOOO", "RECEIVE DIAGNOSTIC RESULTS", ++ SCST_DATA_READ, FLAG_NONE, 3, get_trans_len_2}, ++ {0x1D, "MMMMMMMMMMMMMMMM", "SEND DIAGNOSTIC", ++ SCST_DATA_WRITE, FLAG_NONE, 4, get_trans_len_1}, ++ {0x1E, "OOOOOOOOOOOOOOOO", "PREVENT ALLOW MEDIUM REMOVAL", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT, 0, ++ get_trans_len_prevent_allow_medium_removal}, ++ {0x1F, " O ", "PORT STATUS", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ ++ /* 10-bytes length CDB */ ++ {0x23, "V VV V ", "READ FORMAT CAPACITY", ++ SCST_DATA_READ, FLAG_NONE, 7, get_trans_len_2}, ++ {0x24, "V VVM ", "SET WINDOW", ++ SCST_DATA_WRITE, FLAG_NONE, 6, get_trans_len_3}, ++ {0x25, "M MM M ", "READ CAPACITY", ++ SCST_DATA_READ, SCST_IMPLICIT_HQ| ++ SCST_REG_RESERVE_ALLOWED| ++ SCST_WRITE_EXCL_ALLOWED| ++ SCST_EXCL_ACCESS_ALLOWED, ++ 0, get_trans_len_read_capacity}, ++ {0x25, " O ", "GET WINDOW", ++ SCST_DATA_READ, FLAG_NONE, 6, get_trans_len_3}, ++ {0x28, "M MMMM ", "READ(10)", ++ SCST_DATA_READ, SCST_TRANSFER_LEN_TYPE_FIXED| ++#ifdef CONFIG_SCST_TEST_IO_IN_SIRQ ++ SCST_TEST_IO_IN_SIRQ_ALLOWED| ++#endif ++ SCST_WRITE_EXCL_ALLOWED, ++ 7, get_trans_len_2}, ++ {0x28, " O ", "GET MESSAGE(10)", ++ SCST_DATA_READ, FLAG_NONE, 7, get_trans_len_2}, ++ {0x29, "V VV O ", "READ GENERATION", ++ SCST_DATA_READ, FLAG_NONE, 8, get_trans_len_1}, ++ {0x2A, "O MO M ", "WRITE(10)", ++ SCST_DATA_WRITE, SCST_TRANSFER_LEN_TYPE_FIXED| ++#ifdef CONFIG_SCST_TEST_IO_IN_SIRQ ++ SCST_TEST_IO_IN_SIRQ_ALLOWED| ++#endif ++ SCST_WRITE_MEDIUM, ++ 7, get_trans_len_2}, ++ {0x2A, " O ", "SEND MESSAGE(10)", ++ SCST_DATA_WRITE, FLAG_NONE, 7, get_trans_len_2}, ++ {0x2A, " O ", "SEND(10)", ++ SCST_DATA_WRITE, FLAG_NONE, 7, get_trans_len_2}, ++ {0x2B, " O ", "LOCATE", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT| ++ SCST_WRITE_EXCL_ALLOWED, ++ 0, get_trans_len_none}, ++ {0x2B, " O ", "POSITION TO ELEMENT", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT, 0, get_trans_len_none}, ++ {0x2B, "O OO O ", "SEEK(10)", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x2C, "V O O ", "ERASE(10)", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT|SCST_WRITE_MEDIUM, ++ 0, get_trans_len_none}, ++ {0x2D, "V O O ", "READ UPDATED BLOCK", ++ SCST_DATA_READ, SCST_TRANSFER_LEN_TYPE_FIXED, 0, get_trans_len_single}, ++ {0x2E, "O OO O ", "WRITE AND VERIFY(10)", ++ SCST_DATA_WRITE, SCST_TRANSFER_LEN_TYPE_FIXED|SCST_WRITE_MEDIUM, ++ 7, get_trans_len_2}, ++ {0x2F, "O OO O ", "VERIFY(10)", ++ SCST_DATA_NONE, SCST_TRANSFER_LEN_TYPE_FIXED| ++ SCST_VERIFY_BYTCHK_MISMATCH_ALLOWED| ++ SCST_WRITE_EXCL_ALLOWED, ++ 7, get_trans_len_2}, ++ {0x33, "O OO O ", "SET LIMITS(10)", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x34, " O ", "READ POSITION", ++ SCST_DATA_READ, SCST_SMALL_TIMEOUT| ++ SCST_WRITE_EXCL_ALLOWED, ++ 7, get_trans_len_read_pos}, ++ {0x34, " O ", "GET DATA BUFFER STATUS", ++ SCST_DATA_READ, FLAG_NONE, 7, get_trans_len_2}, ++ {0x34, "O OO O ", "PRE-FETCH", ++ SCST_DATA_NONE, SCST_WRITE_EXCL_ALLOWED, ++ 0, get_trans_len_none}, ++ {0x35, "O OO O ", "SYNCHRONIZE CACHE", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x36, "O OO O ", "LOCK UNLOCK CACHE", ++ SCST_DATA_NONE, SCST_WRITE_EXCL_ALLOWED, ++ 0, get_trans_len_none}, ++ {0x37, "O O ", "READ DEFECT DATA(10)", ++ SCST_DATA_READ, SCST_WRITE_EXCL_ALLOWED, ++ 8, get_trans_len_1}, ++ {0x37, " O ", "INIT ELEMENT STATUS WRANGE", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT, 0, get_trans_len_none}, ++ {0x38, " O O ", "MEDIUM SCAN", ++ SCST_DATA_READ, FLAG_NONE, 8, get_trans_len_1}, ++ {0x39, "OOOOOOOO ", "COMPARE", ++ SCST_DATA_WRITE, FLAG_NONE, 3, get_trans_len_3}, ++ {0x3A, "OOOOOOOO ", "COPY AND VERIFY", ++ SCST_DATA_WRITE, FLAG_NONE, 3, get_trans_len_3}, ++ {0x3B, "OOOOOOOOOOOOOOOO", "WRITE BUFFER", ++ SCST_DATA_WRITE, SCST_SMALL_TIMEOUT, 6, get_trans_len_3}, ++ {0x3C, "OOOOOOOOOOOOOOOO", "READ BUFFER", ++ SCST_DATA_READ, SCST_SMALL_TIMEOUT, 6, get_trans_len_3}, ++ {0x3D, " O O ", "UPDATE BLOCK", ++ SCST_DATA_WRITE, SCST_TRANSFER_LEN_TYPE_FIXED, ++ 0, get_trans_len_single}, ++ {0x3E, "O OO O ", "READ LONG", ++ SCST_DATA_READ, FLAG_NONE, 7, get_trans_len_2}, ++ {0x3F, "O O O ", "WRITE LONG", ++ SCST_DATA_WRITE, SCST_WRITE_MEDIUM, 7, get_trans_len_2}, ++ {0x40, "OOOOOOOOOO ", "CHANGE DEFINITION", ++ SCST_DATA_WRITE, SCST_SMALL_TIMEOUT, 8, get_trans_len_1}, ++ {0x41, "O O ", "WRITE SAME", ++ SCST_DATA_WRITE, SCST_TRANSFER_LEN_TYPE_FIXED|SCST_WRITE_MEDIUM, ++ 0, get_trans_len_single}, ++ {0x42, " O ", "READ SUB-CHANNEL", ++ SCST_DATA_READ, FLAG_NONE, 7, get_trans_len_2}, ++ {0x42, "O ", "UNMAP", ++ SCST_DATA_WRITE, SCST_WRITE_MEDIUM, 7, get_trans_len_2}, ++ {0x43, " O ", "READ TOC/PMA/ATIP", ++ SCST_DATA_READ, FLAG_NONE, 7, get_trans_len_2}, ++ {0x44, " M ", "REPORT DENSITY SUPPORT", ++ SCST_DATA_READ, SCST_REG_RESERVE_ALLOWED| ++ SCST_WRITE_EXCL_ALLOWED| ++ SCST_EXCL_ACCESS_ALLOWED, ++ 7, get_trans_len_2}, ++ {0x44, " O ", "READ HEADER", ++ SCST_DATA_READ, FLAG_NONE, 7, get_trans_len_2}, ++ {0x45, " O ", "PLAY AUDIO(10)", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x46, " O ", "GET CONFIGURATION", ++ SCST_DATA_READ, FLAG_NONE, 7, get_trans_len_2}, ++ {0x47, " O ", "PLAY AUDIO MSF", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x48, " O ", "PLAY AUDIO TRACK INDEX", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x49, " O ", "PLAY TRACK RELATIVE(10)", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x4A, " O ", "GET EVENT STATUS NOTIFICATION", ++ SCST_DATA_READ, FLAG_NONE, 7, get_trans_len_2}, ++ {0x4B, " O ", "PAUSE/RESUME", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x4C, "OOOOOOOOOOOOOOOO", "LOG SELECT", ++ SCST_DATA_WRITE, SCST_STRICTLY_SERIALIZED, 7, get_trans_len_2}, ++ {0x4D, "OOOOOOOOOOOOOOOO", "LOG SENSE", ++ SCST_DATA_READ, SCST_SMALL_TIMEOUT| ++ SCST_REG_RESERVE_ALLOWED| ++ SCST_WRITE_EXCL_ALLOWED| ++ SCST_EXCL_ACCESS_ALLOWED, ++ 7, get_trans_len_2}, ++ {0x4E, " O ", "STOP PLAY/SCAN", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x50, " ", "XDWRITE", ++ SCST_DATA_NONE, SCST_WRITE_MEDIUM, 0, get_trans_len_none}, ++ {0x51, " O ", "READ DISC INFORMATION", ++ SCST_DATA_READ, FLAG_NONE, 7, get_trans_len_2}, ++ {0x51, " ", "XPWRITE", ++ SCST_DATA_NONE, SCST_WRITE_MEDIUM, 0, get_trans_len_none}, ++ {0x52, " O ", "READ TRACK INFORMATION", ++ SCST_DATA_READ, FLAG_NONE, 7, get_trans_len_2}, ++ {0x53, "O ", "XDWRITEREAD(10)", ++ SCST_DATA_READ|SCST_DATA_WRITE, SCST_TRANSFER_LEN_TYPE_FIXED| ++ SCST_WRITE_MEDIUM, ++ 7, get_bidi_trans_len_2}, ++ {0x53, " O ", "RESERVE TRACK", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x54, " O ", "SEND OPC INFORMATION", ++ SCST_DATA_WRITE, FLAG_NONE, 7, get_trans_len_2}, ++ {0x55, "OOOOOOOOOOOOOOOO", "MODE SELECT(10)", ++ SCST_DATA_WRITE, SCST_STRICTLY_SERIALIZED, 7, get_trans_len_2}, ++ {0x56, "OOOOOOOOOOOOOOOO", "RESERVE(10)", ++ SCST_DATA_NONE, SCST_SMALL_TIMEOUT|SCST_LOCAL_CMD|SCST_SERIALIZED| ++ SCST_WRITE_EXCL_ALLOWED|SCST_EXCL_ACCESS_ALLOWED, ++ 0, get_trans_len_none}, ++ {0x57, "OOOOOOOOOOOOOOOO", "RELEASE(10)", ++ SCST_DATA_NONE, SCST_SMALL_TIMEOUT|SCST_LOCAL_CMD|SCST_SERIALIZED| ++ SCST_REG_RESERVE_ALLOWED| ++ SCST_WRITE_EXCL_ALLOWED|SCST_EXCL_ACCESS_ALLOWED, ++ 0, get_trans_len_none}, ++ {0x58, " O ", "REPAIR TRACK", ++ SCST_DATA_NONE, SCST_WRITE_MEDIUM, 0, get_trans_len_none}, ++ {0x5A, "OOOOOOOOOOOOOOOO", "MODE SENSE(10)", ++ SCST_DATA_READ, SCST_SMALL_TIMEOUT, 7, get_trans_len_2}, ++ {0x5B, " O ", "CLOSE TRACK/SESSION", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x5C, " O ", "READ BUFFER CAPACITY", ++ SCST_DATA_READ, FLAG_NONE, 7, get_trans_len_2}, ++ {0x5D, " O ", "SEND CUE SHEET", ++ SCST_DATA_WRITE, FLAG_NONE, 6, get_trans_len_3}, ++ {0x5E, "OOOOO OOOO ", "PERSISTENT RESERVE IN", ++ SCST_DATA_READ, SCST_SMALL_TIMEOUT| ++ SCST_LOCAL_CMD|SCST_SERIALIZED| ++ SCST_WRITE_EXCL_ALLOWED| ++ SCST_EXCL_ACCESS_ALLOWED, ++ 5, get_trans_len_4}, ++ {0x5F, "OOOOO OOOO ", "PERSISTENT RESERVE OUT", ++ SCST_DATA_WRITE, SCST_SMALL_TIMEOUT| ++ SCST_LOCAL_CMD|SCST_SERIALIZED| ++ SCST_WRITE_EXCL_ALLOWED| ++ SCST_EXCL_ACCESS_ALLOWED, ++ 5, get_trans_len_4}, ++ ++ /* 16-bytes length CDB */ ++ {0x80, "O OO O ", "XDWRITE EXTENDED", ++ SCST_DATA_NONE, SCST_WRITE_MEDIUM, 0, get_trans_len_none}, ++ {0x80, " M ", "WRITE FILEMARKS", ++ SCST_DATA_NONE, SCST_WRITE_MEDIUM, 0, get_trans_len_none}, ++ {0x81, "O OO O ", "REBUILD", ++ SCST_DATA_WRITE, SCST_WRITE_MEDIUM, 10, get_trans_len_4}, ++ {0x82, "O OO O ", "REGENERATE", ++ SCST_DATA_WRITE, SCST_WRITE_MEDIUM, 10, get_trans_len_4}, ++ {0x83, "OOOOOOOOOOOOOOOO", "EXTENDED COPY", ++ SCST_DATA_WRITE, SCST_WRITE_MEDIUM, 10, get_trans_len_4}, ++ {0x84, "OOOOOOOOOOOOOOOO", "RECEIVE COPY RESULT", ++ SCST_DATA_WRITE, FLAG_NONE, 10, get_trans_len_4}, ++ {0x86, "OOOOOOOOOO ", "ACCESS CONTROL IN", ++ SCST_DATA_NONE, SCST_REG_RESERVE_ALLOWED| ++ SCST_WRITE_EXCL_ALLOWED| ++ SCST_EXCL_ACCESS_ALLOWED, ++ 0, get_trans_len_none}, ++ {0x87, "OOOOOOOOOO ", "ACCESS CONTROL OUT", ++ SCST_DATA_NONE, SCST_REG_RESERVE_ALLOWED| ++ SCST_WRITE_EXCL_ALLOWED| ++ SCST_EXCL_ACCESS_ALLOWED, ++ 0, get_trans_len_none}, ++ {0x88, "M MMMM ", "READ(16)", ++ SCST_DATA_READ, SCST_TRANSFER_LEN_TYPE_FIXED| ++#ifdef CONFIG_SCST_TEST_IO_IN_SIRQ ++ SCST_TEST_IO_IN_SIRQ_ALLOWED| ++#endif ++ SCST_WRITE_EXCL_ALLOWED, ++ 10, get_trans_len_4}, ++ {0x8A, "O OO O ", "WRITE(16)", ++ SCST_DATA_WRITE, SCST_TRANSFER_LEN_TYPE_FIXED| ++#ifdef CONFIG_SCST_TEST_IO_IN_SIRQ ++ SCST_TEST_IO_IN_SIRQ_ALLOWED| ++#endif ++ SCST_WRITE_MEDIUM, ++ 10, get_trans_len_4}, ++ {0x8C, "OOOOOOOOOO ", "READ ATTRIBUTE", ++ SCST_DATA_READ, FLAG_NONE, 10, get_trans_len_4}, ++ {0x8D, "OOOOOOOOOO ", "WRITE ATTRIBUTE", ++ SCST_DATA_WRITE, SCST_WRITE_MEDIUM, 10, get_trans_len_4}, ++ {0x8E, "O OO O ", "WRITE AND VERIFY(16)", ++ SCST_DATA_WRITE, SCST_TRANSFER_LEN_TYPE_FIXED|SCST_WRITE_MEDIUM, ++ 10, get_trans_len_4}, ++ {0x8F, "O OO O ", "VERIFY(16)", ++ SCST_DATA_NONE, SCST_TRANSFER_LEN_TYPE_FIXED| ++ SCST_VERIFY_BYTCHK_MISMATCH_ALLOWED| ++ SCST_WRITE_EXCL_ALLOWED, ++ 10, get_trans_len_4}, ++ {0x90, "O OO O ", "PRE-FETCH(16)", ++ SCST_DATA_NONE, SCST_WRITE_EXCL_ALLOWED, ++ 0, get_trans_len_none}, ++ {0x91, "O OO O ", "SYNCHRONIZE CACHE(16)", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x91, " M ", "SPACE(16)", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT| ++ SCST_WRITE_EXCL_ALLOWED, ++ 0, get_trans_len_none}, ++ {0x92, "O OO O ", "LOCK UNLOCK CACHE(16)", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0x92, " O ", "LOCATE(16)", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT| ++ SCST_WRITE_EXCL_ALLOWED, ++ 0, get_trans_len_none}, ++ {0x93, "O O ", "WRITE SAME(16)", ++ SCST_DATA_WRITE, SCST_TRANSFER_LEN_TYPE_FIXED|SCST_WRITE_MEDIUM, ++ 10, get_trans_len_4}, ++ {0x93, " M ", "ERASE(16)", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT|SCST_WRITE_MEDIUM, ++ 0, get_trans_len_none}, ++ {0x9E, "O ", "SERVICE ACTION IN", ++ SCST_DATA_READ, FLAG_NONE, 0, get_trans_len_serv_act_in}, ++ ++ /* 12-bytes length CDB */ ++ {0xA0, "VVVVVVVVVV M ", "REPORT LUNS", ++ SCST_DATA_READ, SCST_SMALL_TIMEOUT|SCST_IMPLICIT_HQ|SCST_SKIP_UA| ++ SCST_FULLY_LOCAL_CMD|SCST_LOCAL_CMD| ++ SCST_REG_RESERVE_ALLOWED| ++ SCST_WRITE_EXCL_ALLOWED|SCST_EXCL_ACCESS_ALLOWED, ++ 6, get_trans_len_4}, ++ {0xA1, " O ", "BLANK", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT, 0, get_trans_len_none}, ++ {0xA3, " O ", "SEND KEY", ++ SCST_DATA_WRITE, FLAG_NONE, 8, get_trans_len_2}, ++ {0xA3, "OOOOO OOOO ", "REPORT DEVICE IDENTIDIER", ++ SCST_DATA_READ, SCST_REG_RESERVE_ALLOWED| ++ SCST_WRITE_EXCL_ALLOWED|SCST_EXCL_ACCESS_ALLOWED, ++ 6, get_trans_len_4}, ++ {0xA3, " M ", "MAINTENANCE(IN)", ++ SCST_DATA_READ, FLAG_NONE, 6, get_trans_len_4}, ++ {0xA4, " O ", "REPORT KEY", ++ SCST_DATA_READ, FLAG_NONE, 8, get_trans_len_2}, ++ {0xA4, " O ", "MAINTENANCE(OUT)", ++ SCST_DATA_WRITE, FLAG_NONE, 6, get_trans_len_4}, ++ {0xA5, " M ", "MOVE MEDIUM", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT, 0, get_trans_len_none}, ++ {0xA5, " O ", "PLAY AUDIO(12)", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0xA6, " O O ", "EXCHANGE/LOAD/UNLOAD MEDIUM", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT, 0, get_trans_len_none}, ++ {0xA7, " O ", "SET READ AHEAD", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0xA8, " O ", "GET MESSAGE(12)", ++ SCST_DATA_READ, FLAG_NONE, 6, get_trans_len_4}, ++ {0xA8, "O OO O ", "READ(12)", ++ SCST_DATA_READ, SCST_TRANSFER_LEN_TYPE_FIXED| ++#ifdef CONFIG_SCST_TEST_IO_IN_SIRQ ++ SCST_TEST_IO_IN_SIRQ_ALLOWED| ++#endif ++ SCST_WRITE_EXCL_ALLOWED, ++ 6, get_trans_len_4}, ++ {0xA9, " O ", "PLAY TRACK RELATIVE(12)", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0xAA, "O OO O ", "WRITE(12)", ++ SCST_DATA_WRITE, SCST_TRANSFER_LEN_TYPE_FIXED| ++#ifdef CONFIG_SCST_TEST_IO_IN_SIRQ ++ SCST_TEST_IO_IN_SIRQ_ALLOWED| ++#endif ++ SCST_WRITE_MEDIUM, ++ 6, get_trans_len_4}, ++ {0xAA, " O ", "SEND MESSAGE(12)", ++ SCST_DATA_WRITE, FLAG_NONE, 6, get_trans_len_4}, ++ {0xAC, " O ", "ERASE(12)", ++ SCST_DATA_NONE, SCST_WRITE_MEDIUM, 0, get_trans_len_none}, ++ {0xAC, " M ", "GET PERFORMANCE", ++ SCST_DATA_READ, SCST_UNKNOWN_LENGTH, 0, get_trans_len_none}, ++ {0xAD, " O ", "READ DVD STRUCTURE", ++ SCST_DATA_READ, FLAG_NONE, 8, get_trans_len_2}, ++ {0xAE, "O OO O ", "WRITE AND VERIFY(12)", ++ SCST_DATA_WRITE, SCST_TRANSFER_LEN_TYPE_FIXED|SCST_WRITE_MEDIUM, ++ 6, get_trans_len_4}, ++ {0xAF, "O OO O ", "VERIFY(12)", ++ SCST_DATA_NONE, SCST_TRANSFER_LEN_TYPE_FIXED| ++ SCST_VERIFY_BYTCHK_MISMATCH_ALLOWED| ++ SCST_WRITE_EXCL_ALLOWED, ++ 6, get_trans_len_4}, ++#if 0 /* No need to support at all */ ++ {0xB0, " OO O ", "SEARCH DATA HIGH(12)", ++ SCST_DATA_WRITE, FLAG_NONE, 9, get_trans_len_1}, ++ {0xB1, " OO O ", "SEARCH DATA EQUAL(12)", ++ SCST_DATA_WRITE, FLAG_NONE, 9, get_trans_len_1}, ++ {0xB2, " OO O ", "SEARCH DATA LOW(12)", ++ SCST_DATA_WRITE, FLAG_NONE, 9, get_trans_len_1}, ++#endif ++ {0xB3, " OO O ", "SET LIMITS(12)", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0xB5, " O ", "REQUEST VOLUME ELEMENT ADDRESS", ++ SCST_DATA_READ, FLAG_NONE, 9, get_trans_len_1}, ++ {0xB6, " O ", "SEND VOLUME TAG", ++ SCST_DATA_WRITE, FLAG_NONE, 9, get_trans_len_1}, ++ {0xB6, " M ", "SET STREAMING", ++ SCST_DATA_WRITE, FLAG_NONE, 9, get_trans_len_2}, ++ {0xB7, " O ", "READ DEFECT DATA(12)", ++ SCST_DATA_READ, SCST_WRITE_EXCL_ALLOWED, ++ 9, get_trans_len_1}, ++ {0xB8, " O ", "READ ELEMENT STATUS", ++ SCST_DATA_READ, FLAG_NONE, 7, get_trans_len_3_read_elem_stat}, ++ {0xB9, " O ", "READ CD MSF", ++ SCST_DATA_READ, SCST_UNKNOWN_LENGTH, 0, get_trans_len_none}, ++ {0xBA, " O ", "SCAN", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT, 0, get_trans_len_none}, ++ {0xBA, " O ", "REDUNDANCY GROUP(IN)", ++ SCST_DATA_READ, FLAG_NONE, 6, get_trans_len_4}, ++ {0xBB, " O ", "SET SPEED", ++ SCST_DATA_NONE, FLAG_NONE, 0, get_trans_len_none}, ++ {0xBB, " O ", "REDUNDANCY GROUP(OUT)", ++ SCST_DATA_WRITE, FLAG_NONE, 6, get_trans_len_4}, ++ {0xBC, " O ", "SPARE(IN)", ++ SCST_DATA_READ, FLAG_NONE, 6, get_trans_len_4}, ++ {0xBD, " O ", "MECHANISM STATUS", ++ SCST_DATA_READ, FLAG_NONE, 8, get_trans_len_2}, ++ {0xBD, " O ", "SPARE(OUT)", ++ SCST_DATA_WRITE, FLAG_NONE, 6, get_trans_len_4}, ++ {0xBE, " O ", "READ CD", ++ SCST_DATA_READ, SCST_TRANSFER_LEN_TYPE_FIXED, 6, get_trans_len_3}, ++ {0xBE, " O ", "VOLUME SET(IN)", ++ SCST_DATA_READ, FLAG_NONE, 6, get_trans_len_4}, ++ {0xBF, " O ", "SEND DVD STRUCTUE", ++ SCST_DATA_WRITE, FLAG_NONE, 8, get_trans_len_2}, ++ {0xBF, " O ", "VOLUME SET(OUT)", ++ SCST_DATA_WRITE, FLAG_NONE, 6, get_trans_len_4}, ++ {0xE7, " V ", "INIT ELEMENT STATUS WRANGE", ++ SCST_DATA_NONE, SCST_LONG_TIMEOUT, 0, get_trans_cdb_len_10} ++}; ++ ++#define SCST_CDB_TBL_SIZE ((int)ARRAY_SIZE(scst_scsi_op_table)) ++ ++static void scst_free_tgt_dev(struct scst_tgt_dev *tgt_dev); ++static void scst_check_internal_sense(struct scst_device *dev, int result, ++ uint8_t *sense, int sense_len); ++static void scst_queue_report_luns_changed_UA(struct scst_session *sess, ++ int flags); ++static void __scst_check_set_UA(struct scst_tgt_dev *tgt_dev, ++ const uint8_t *sense, int sense_len, int flags); ++static void scst_alloc_set_UA(struct scst_tgt_dev *tgt_dev, ++ const uint8_t *sense, int sense_len, int flags); ++static void scst_free_all_UA(struct scst_tgt_dev *tgt_dev); ++static void scst_release_space(struct scst_cmd *cmd); ++static void scst_clear_reservation(struct scst_tgt_dev *tgt_dev); ++static int scst_alloc_add_tgt_dev(struct scst_session *sess, ++ struct scst_acg_dev *acg_dev, struct scst_tgt_dev **out_tgt_dev); ++static void scst_tgt_retry_timer_fn(unsigned long arg); ++ ++#ifdef CONFIG_SCST_DEBUG_TM ++static void tm_dbg_init_tgt_dev(struct scst_tgt_dev *tgt_dev); ++static void tm_dbg_deinit_tgt_dev(struct scst_tgt_dev *tgt_dev); ++#else ++static inline void tm_dbg_init_tgt_dev(struct scst_tgt_dev *tgt_dev) {} ++static inline void tm_dbg_deinit_tgt_dev(struct scst_tgt_dev *tgt_dev) {} ++#endif /* CONFIG_SCST_DEBUG_TM */ ++ ++/** ++ * scst_alloc_sense() - allocate sense buffer for command ++ * ++ * Allocates, if necessary, sense buffer for command. Returns 0 on success ++ * and error code otherwise. Parameter "atomic" should be non-0 if the ++ * function called in atomic context. ++ */ ++int scst_alloc_sense(struct scst_cmd *cmd, int atomic) ++{ ++ int res = 0; ++ gfp_t gfp_mask = atomic ? GFP_ATOMIC : (GFP_KERNEL|__GFP_NOFAIL); ++ ++ TRACE_ENTRY(); ++ ++ if (cmd->sense != NULL) ++ goto memzero; ++ ++ cmd->sense = mempool_alloc(scst_sense_mempool, gfp_mask); ++ if (cmd->sense == NULL) { ++ PRINT_CRIT_ERROR("Sense memory allocation failed (op %x). " ++ "The sense data will be lost!!", cmd->cdb[0]); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ cmd->sense_buflen = SCST_SENSE_BUFFERSIZE; ++ ++memzero: ++ cmd->sense_valid_len = 0; ++ memset(cmd->sense, 0, cmd->sense_buflen); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL(scst_alloc_sense); ++ ++/** ++ * scst_alloc_set_sense() - allocate and fill sense buffer for command ++ * ++ * Allocates, if necessary, sense buffer for command and copies in ++ * it data from the supplied sense buffer. Returns 0 on success ++ * and error code otherwise. ++ */ ++int scst_alloc_set_sense(struct scst_cmd *cmd, int atomic, ++ const uint8_t *sense, unsigned int len) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * We don't check here if the existing sense is valid or not, because ++ * we suppose the caller did it based on cmd->status. ++ */ ++ ++ res = scst_alloc_sense(cmd, atomic); ++ if (res != 0) { ++ PRINT_BUFFER("Lost sense", sense, len); ++ goto out; ++ } ++ ++ cmd->sense_valid_len = len; ++ if (cmd->sense_buflen < len) { ++ PRINT_WARNING("Sense truncated (needed %d), shall you increase " ++ "SCST_SENSE_BUFFERSIZE? Op: %x", len, cmd->cdb[0]); ++ cmd->sense_valid_len = cmd->sense_buflen; ++ } ++ ++ memcpy(cmd->sense, sense, cmd->sense_valid_len); ++ TRACE_BUFFER("Sense set", cmd->sense, cmd->sense_valid_len); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL(scst_alloc_set_sense); ++ ++/** ++ * scst_set_cmd_error_status() - set error SCSI status ++ * @cmd: SCST command ++ * @status: SCSI status to set ++ * ++ * Description: ++ * Sets error SCSI status in the command and prepares it for returning it. ++ * Returns 0 on success, error code otherwise. ++ */ ++int scst_set_cmd_error_status(struct scst_cmd *cmd, int status) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ if (status == SAM_STAT_RESERVATION_CONFLICT) { ++ TRACE(TRACE_SCSI|TRACE_MINOR, "Reservation conflict (dev %s, " ++ "initiator %s, tgt_id %d)", ++ cmd->dev ? cmd->dev->virt_name : NULL, ++ cmd->sess->initiator_name, cmd->tgt->rel_tgt_id); ++ } ++ ++ if (cmd->status != 0) { ++ TRACE_MGMT_DBG("cmd %p already has status %x set", cmd, ++ cmd->status); ++ res = -EEXIST; ++ goto out; ++ } ++ ++ cmd->status = status; ++ cmd->host_status = DID_OK; ++ ++ cmd->dbl_ua_orig_resp_data_len = cmd->resp_data_len; ++ cmd->dbl_ua_orig_data_direction = cmd->data_direction; ++ ++ cmd->data_direction = SCST_DATA_NONE; ++ cmd->resp_data_len = 0; ++ cmd->resid_possible = 1; ++ cmd->is_send_status = 1; ++ ++ cmd->completed = 1; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL(scst_set_cmd_error_status); ++ ++static int scst_set_lun_not_supported_request_sense(struct scst_cmd *cmd, ++ int key, int asc, int ascq) ++{ ++ int res; ++ int sense_len, len; ++ struct scatterlist *sg; ++ ++ TRACE_ENTRY(); ++ ++ if (cmd->status != 0) { ++ TRACE_MGMT_DBG("cmd %p already has status %x set", cmd, ++ cmd->status); ++ res = -EEXIST; ++ goto out; ++ } ++ ++ if ((cmd->sg != NULL) && SCST_SENSE_VALID(sg_virt(cmd->sg))) { ++ TRACE_MGMT_DBG("cmd %p already has sense set", cmd); ++ res = -EEXIST; ++ goto out; ++ } ++ ++ if (cmd->sg == NULL) { ++ /* ++ * If target driver preparing data buffer using alloc_data_buf() ++ * callback, it is responsible to copy the sense to its buffer ++ * in xmit_response(). ++ */ ++ if (cmd->tgt_data_buf_alloced && (cmd->tgt_sg != NULL)) { ++ cmd->sg = cmd->tgt_sg; ++ cmd->sg_cnt = cmd->tgt_sg_cnt; ++ TRACE_MEM("Tgt sg used for sense for cmd %p", cmd); ++ goto go; ++ } ++ ++ if (cmd->bufflen == 0) ++ cmd->bufflen = cmd->cdb[4]; ++ ++ cmd->sg = scst_alloc(cmd->bufflen, GFP_ATOMIC, &cmd->sg_cnt); ++ if (cmd->sg == NULL) { ++ PRINT_ERROR("Unable to alloc sg for REQUEST SENSE" ++ "(sense %x/%x/%x)", key, asc, ascq); ++ res = 1; ++ goto out; ++ } ++ ++ TRACE_MEM("sg %p alloced for sense for cmd %p (cnt %d, " ++ "len %d)", cmd->sg, cmd, cmd->sg_cnt, cmd->bufflen); ++ } ++ ++go: ++ sg = cmd->sg; ++ len = sg->length; ++ ++ TRACE_MEM("sg %p (len %d) for sense for cmd %p", sg, len, cmd); ++ ++ sense_len = scst_set_sense(sg_virt(sg), len, cmd->cdb[1] & 1, ++ key, asc, ascq); ++ ++ TRACE_BUFFER("Sense set", sg_virt(sg), sense_len); ++ ++ cmd->data_direction = SCST_DATA_READ; ++ scst_set_resp_data_len(cmd, sense_len); ++ ++ res = 0; ++ cmd->completed = 1; ++ cmd->resid_possible = 1; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_set_lun_not_supported_inquiry(struct scst_cmd *cmd) ++{ ++ int res; ++ uint8_t *buf; ++ struct scatterlist *sg; ++ int len; ++ ++ TRACE_ENTRY(); ++ ++ if (cmd->status != 0) { ++ TRACE_MGMT_DBG("cmd %p already has status %x set", cmd, ++ cmd->status); ++ res = -EEXIST; ++ goto out; ++ } ++ ++ if (cmd->sg == NULL) { ++ /* ++ * If target driver preparing data buffer using alloc_data_buf() ++ * callback, it is responsible to copy the sense to its buffer ++ * in xmit_response(). ++ */ ++ if (cmd->tgt_data_buf_alloced && (cmd->tgt_sg != NULL)) { ++ cmd->sg = cmd->tgt_sg; ++ cmd->sg_cnt = cmd->tgt_sg_cnt; ++ TRACE_MEM("Tgt used for INQUIRY for not supported " ++ "LUN for cmd %p", cmd); ++ goto go; ++ } ++ ++ if (cmd->bufflen == 0) ++ cmd->bufflen = min_t(int, 36, (cmd->cdb[3] << 8) | cmd->cdb[4]); ++ ++ cmd->sg = scst_alloc(cmd->bufflen, GFP_ATOMIC, &cmd->sg_cnt); ++ if (cmd->sg == NULL) { ++ PRINT_ERROR("%s", "Unable to alloc sg for INQUIRY " ++ "for not supported LUN"); ++ res = 1; ++ goto out; ++ } ++ ++ TRACE_MEM("sg %p alloced for INQUIRY for not supported LUN for " ++ "cmd %p (cnt %d, len %d)", cmd->sg, cmd, cmd->sg_cnt, ++ cmd->bufflen); ++ } ++ ++go: ++ sg = cmd->sg; ++ len = sg->length; ++ ++ TRACE_MEM("sg %p (len %d) for INQUIRY for cmd %p", sg, len, cmd); ++ ++ buf = sg_virt(sg); ++ len = min_t(int, 36, len); ++ ++ memset(buf, 0, len); ++ buf[0] = 0x7F; /* Peripheral qualifier 011b, Peripheral device type 1Fh */ ++ buf[4] = len - 4; ++ ++ TRACE_BUFFER("INQUIRY for not supported LUN set", buf, len); ++ ++ cmd->data_direction = SCST_DATA_READ; ++ scst_set_resp_data_len(cmd, len); ++ ++ res = 0; ++ cmd->completed = 1; ++ cmd->resid_possible = 1; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/** ++ * scst_set_cmd_error() - set error in the command and fill the sense buffer. ++ * ++ * Sets error in the command and fill the sense buffer. Returns 0 on success, ++ * error code otherwise. ++ */ ++int scst_set_cmd_error(struct scst_cmd *cmd, int key, int asc, int ascq) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * We need for LOGICAL UNIT NOT SUPPORTED special handling for ++ * REQUEST SENSE and INQUIRY. ++ */ ++ if ((key == ILLEGAL_REQUEST) && (asc == 0x25) && (ascq == 0)) { ++ if (cmd->cdb[0] == REQUEST_SENSE) ++ res = scst_set_lun_not_supported_request_sense(cmd, ++ key, asc, ascq); ++ else if (cmd->cdb[0] == INQUIRY) ++ res = scst_set_lun_not_supported_inquiry(cmd); ++ else ++ goto do_sense; ++ ++ if (res > 0) ++ goto do_sense; ++ else ++ goto out; ++ } ++ ++do_sense: ++ res = scst_set_cmd_error_status(cmd, SAM_STAT_CHECK_CONDITION); ++ if (res != 0) ++ goto out; ++ ++ res = scst_alloc_sense(cmd, 1); ++ if (res != 0) { ++ PRINT_ERROR("Lost sense data (key %x, asc %x, ascq %x)", ++ key, asc, ascq); ++ goto out; ++ } ++ ++ cmd->sense_valid_len = scst_set_sense(cmd->sense, cmd->sense_buflen, ++ scst_get_cmd_dev_d_sense(cmd), key, asc, ascq); ++ TRACE_BUFFER("Sense set", cmd->sense, cmd->sense_valid_len); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL(scst_set_cmd_error); ++ ++/** ++ * scst_set_sense() - set sense from KEY/ASC/ASCQ numbers ++ * ++ * Sets the corresponding fields in the sense buffer taking sense type ++ * into account. Returns resulting sense length. ++ */ ++int scst_set_sense(uint8_t *buffer, int len, bool d_sense, ++ int key, int asc, int ascq) ++{ ++ int res; ++ ++ BUG_ON(len == 0); ++ ++ memset(buffer, 0, len); ++ ++ if (d_sense) { ++ /* Descriptor format */ ++ if (len < 8) { ++ PRINT_ERROR("Length %d of sense buffer too small to " ++ "fit sense %x:%x:%x", len, key, asc, ascq); ++ } ++ ++ buffer[0] = 0x72; /* Response Code */ ++ if (len > 1) ++ buffer[1] = key; /* Sense Key */ ++ if (len > 2) ++ buffer[2] = asc; /* ASC */ ++ if (len > 3) ++ buffer[3] = ascq; /* ASCQ */ ++ res = 8; ++ } else { ++ /* Fixed format */ ++ if (len < 18) { ++ PRINT_ERROR("Length %d of sense buffer too small to " ++ "fit sense %x:%x:%x", len, key, asc, ascq); ++ } ++ ++ buffer[0] = 0x70; /* Response Code */ ++ if (len > 2) ++ buffer[2] = key; /* Sense Key */ ++ if (len > 7) ++ buffer[7] = 0x0a; /* Additional Sense Length */ ++ if (len > 12) ++ buffer[12] = asc; /* ASC */ ++ if (len > 13) ++ buffer[13] = ascq; /* ASCQ */ ++ res = 18; ++ } ++ ++ TRACE_BUFFER("Sense set", buffer, res); ++ return res; ++} ++EXPORT_SYMBOL(scst_set_sense); ++ ++/** ++ * scst_analyze_sense() - analyze sense ++ * ++ * Returns true if sense matches to (key, asc, ascq) and false otherwise. ++ * Valid_mask is one or several SCST_SENSE_*_VALID constants setting valid ++ * (key, asc, ascq) values. ++ */ ++bool scst_analyze_sense(const uint8_t *sense, int len, unsigned int valid_mask, ++ int key, int asc, int ascq) ++{ ++ bool res = false; ++ ++ /* Response Code */ ++ if ((sense[0] == 0x70) || (sense[0] == 0x71)) { ++ /* Fixed format */ ++ ++ /* Sense Key */ ++ if (valid_mask & SCST_SENSE_KEY_VALID) { ++ if (len < 3) ++ goto out; ++ if (sense[2] != key) ++ goto out; ++ } ++ ++ /* ASC */ ++ if (valid_mask & SCST_SENSE_ASC_VALID) { ++ if (len < 13) ++ goto out; ++ if (sense[12] != asc) ++ goto out; ++ } ++ ++ /* ASCQ */ ++ if (valid_mask & SCST_SENSE_ASCQ_VALID) { ++ if (len < 14) ++ goto out; ++ if (sense[13] != ascq) ++ goto out; ++ } ++ } else if ((sense[0] == 0x72) || (sense[0] == 0x73)) { ++ /* Descriptor format */ ++ ++ /* Sense Key */ ++ if (valid_mask & SCST_SENSE_KEY_VALID) { ++ if (len < 2) ++ goto out; ++ if (sense[1] != key) ++ goto out; ++ } ++ ++ /* ASC */ ++ if (valid_mask & SCST_SENSE_ASC_VALID) { ++ if (len < 3) ++ goto out; ++ if (sense[2] != asc) ++ goto out; ++ } ++ ++ /* ASCQ */ ++ if (valid_mask & SCST_SENSE_ASCQ_VALID) { ++ if (len < 4) ++ goto out; ++ if (sense[3] != ascq) ++ goto out; ++ } ++ } else ++ goto out; ++ ++ res = true; ++ ++out: ++ TRACE_EXIT_RES((int)res); ++ return res; ++} ++EXPORT_SYMBOL(scst_analyze_sense); ++ ++/** ++ * scst_is_ua_sense() - determine if the sense is UA sense ++ * ++ * Returns true if the sense is valid and carrying a Unit ++ * Attention or false otherwise. ++ */ ++bool scst_is_ua_sense(const uint8_t *sense, int len) ++{ ++ if (SCST_SENSE_VALID(sense)) ++ return scst_analyze_sense(sense, len, ++ SCST_SENSE_KEY_VALID, UNIT_ATTENTION, 0, 0); ++ else ++ return false; ++} ++EXPORT_SYMBOL(scst_is_ua_sense); ++ ++bool scst_is_ua_global(const uint8_t *sense, int len) ++{ ++ bool res; ++ ++ /* Changing it don't forget to change scst_requeue_ua() as well!! */ ++ ++ if (scst_analyze_sense(sense, len, SCST_SENSE_ALL_VALID, ++ SCST_LOAD_SENSE(scst_sense_reported_luns_data_changed))) ++ res = true; ++ else ++ res = false; ++ ++ return res; ++} ++ ++/** ++ * scst_check_convert_sense() - check sense type and convert it if needed ++ * ++ * Checks if sense in the sense buffer, if any, is in the correct format. ++ * If not, converts it in the correct format. ++ */ ++void scst_check_convert_sense(struct scst_cmd *cmd) ++{ ++ bool d_sense; ++ ++ TRACE_ENTRY(); ++ ++ if ((cmd->sense == NULL) || (cmd->status != SAM_STAT_CHECK_CONDITION)) ++ goto out; ++ ++ d_sense = scst_get_cmd_dev_d_sense(cmd); ++ if (d_sense && ((cmd->sense[0] == 0x70) || (cmd->sense[0] == 0x71))) { ++ TRACE_MGMT_DBG("Converting fixed sense to descriptor (cmd %p)", ++ cmd); ++ if ((cmd->sense_valid_len < 18)) { ++ PRINT_ERROR("Sense too small to convert (%d, " ++ "type: fixed)", cmd->sense_buflen); ++ goto out; ++ } ++ cmd->sense_valid_len = scst_set_sense(cmd->sense, cmd->sense_buflen, ++ d_sense, cmd->sense[2], cmd->sense[12], cmd->sense[13]); ++ } else if (!d_sense && ((cmd->sense[0] == 0x72) || ++ (cmd->sense[0] == 0x73))) { ++ TRACE_MGMT_DBG("Converting descriptor sense to fixed (cmd %p)", ++ cmd); ++ if ((cmd->sense_buflen < 18) || (cmd->sense_valid_len < 8)) { ++ PRINT_ERROR("Sense too small to convert (%d, " ++ "type: descriptor, valid %d)", ++ cmd->sense_buflen, cmd->sense_valid_len); ++ goto out; ++ } ++ cmd->sense_valid_len = scst_set_sense(cmd->sense, ++ cmd->sense_buflen, d_sense, ++ cmd->sense[1], cmd->sense[2], cmd->sense[3]); ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL(scst_check_convert_sense); ++ ++static int scst_set_cmd_error_sense(struct scst_cmd *cmd, uint8_t *sense, ++ unsigned int len) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ res = scst_set_cmd_error_status(cmd, SAM_STAT_CHECK_CONDITION); ++ if (res != 0) ++ goto out; ++ ++ res = scst_alloc_set_sense(cmd, 1, sense, len); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/** ++ * scst_set_busy() - set BUSY or TASK QUEUE FULL status ++ * ++ * Sets BUSY or TASK QUEUE FULL status depending on if this session has other ++ * outstanding commands or not. ++ */ ++void scst_set_busy(struct scst_cmd *cmd) ++{ ++ int c = atomic_read(&cmd->sess->sess_cmd_count); ++ ++ TRACE_ENTRY(); ++ ++ if ((c <= 1) || (cmd->sess->init_phase != SCST_SESS_IPH_READY)) { ++ scst_set_cmd_error_status(cmd, SAM_STAT_BUSY); ++ TRACE(TRACE_FLOW_CONTROL, "Sending BUSY status to initiator %s " ++ "(cmds count %d, queue_type %x, sess->init_phase %d)", ++ cmd->sess->initiator_name, c, ++ cmd->queue_type, cmd->sess->init_phase); ++ } else { ++ scst_set_cmd_error_status(cmd, SAM_STAT_TASK_SET_FULL); ++ TRACE(TRACE_FLOW_CONTROL, "Sending QUEUE_FULL status to " ++ "initiator %s (cmds count %d, queue_type %x, " ++ "sess->init_phase %d)", cmd->sess->initiator_name, c, ++ cmd->queue_type, cmd->sess->init_phase); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL(scst_set_busy); ++ ++/** ++ * scst_set_initial_UA() - set initial Unit Attention ++ * ++ * Sets initial Unit Attention on all devices of the session, ++ * replacing default scst_sense_reset_UA ++ */ ++void scst_set_initial_UA(struct scst_session *sess, int key, int asc, int ascq) ++{ ++ int i; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Setting for sess %p initial UA %x/%x/%x", sess, key, ++ asc, ascq); ++ ++ /* To protect sess_tgt_dev_list */ ++ mutex_lock(&scst_mutex); ++ ++ for (i = 0; i < SESS_TGT_DEV_LIST_HASH_SIZE; i++) { ++ struct list_head *head = &sess->sess_tgt_dev_list[i]; ++ struct scst_tgt_dev *tgt_dev; ++ ++ list_for_each_entry(tgt_dev, head, sess_tgt_dev_list_entry) { ++ spin_lock_bh(&tgt_dev->tgt_dev_lock); ++ if (!list_empty(&tgt_dev->UA_list)) { ++ struct scst_tgt_dev_UA *ua; ++ ++ ua = list_entry(tgt_dev->UA_list.next, ++ typeof(*ua), UA_list_entry); ++ if (scst_analyze_sense(ua->UA_sense_buffer, ++ ua->UA_valid_sense_len, ++ SCST_SENSE_ALL_VALID, ++ SCST_LOAD_SENSE(scst_sense_reset_UA))) { ++ ua->UA_valid_sense_len = scst_set_sense( ++ ua->UA_sense_buffer, ++ sizeof(ua->UA_sense_buffer), ++ tgt_dev->dev->d_sense, ++ key, asc, ascq); ++ } else ++ PRINT_ERROR("%s", ++ "The first UA isn't RESET UA"); ++ } else ++ PRINT_ERROR("%s", "There's no RESET UA to " ++ "replace"); ++ spin_unlock_bh(&tgt_dev->tgt_dev_lock); ++ } ++ } ++ ++ mutex_unlock(&scst_mutex); ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL(scst_set_initial_UA); ++ ++struct scst_aen *scst_alloc_aen(struct scst_session *sess, ++ uint64_t unpacked_lun) ++{ ++ struct scst_aen *aen; ++ ++ TRACE_ENTRY(); ++ ++ aen = mempool_alloc(scst_aen_mempool, GFP_KERNEL); ++ if (aen == NULL) { ++ PRINT_ERROR("AEN memory allocation failed. Corresponding " ++ "event notification will not be performed (initiator " ++ "%s)", sess->initiator_name); ++ goto out; ++ } ++ memset(aen, 0, sizeof(*aen)); ++ ++ aen->sess = sess; ++ scst_sess_get(sess); ++ ++ aen->lun = scst_pack_lun(unpacked_lun, sess->acg->addr_method); ++ ++out: ++ TRACE_EXIT_HRES((unsigned long)aen); ++ return aen; ++} ++ ++void scst_free_aen(struct scst_aen *aen) ++{ ++ TRACE_ENTRY(); ++ ++ scst_sess_put(aen->sess); ++ mempool_free(aen, scst_aen_mempool); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Must be called under scst_mutex */ ++void scst_gen_aen_or_ua(struct scst_tgt_dev *tgt_dev, ++ int key, int asc, int ascq) ++{ ++ struct scst_tgt_template *tgtt = tgt_dev->sess->tgt->tgtt; ++ uint8_t sense_buffer[SCST_STANDARD_SENSE_LEN]; ++ int sl; ++ ++ TRACE_ENTRY(); ++ ++ if ((tgt_dev->sess->init_phase != SCST_SESS_IPH_READY) || ++ (tgt_dev->sess->shut_phase != SCST_SESS_SPH_READY)) ++ goto out; ++ ++ if (tgtt->report_aen != NULL) { ++ struct scst_aen *aen; ++ int rc; ++ ++ aen = scst_alloc_aen(tgt_dev->sess, tgt_dev->lun); ++ if (aen == NULL) ++ goto queue_ua; ++ ++ aen->event_fn = SCST_AEN_SCSI; ++ aen->aen_sense_len = scst_set_sense(aen->aen_sense, ++ sizeof(aen->aen_sense), tgt_dev->dev->d_sense, ++ key, asc, ascq); ++ ++ TRACE_DBG("Calling target's %s report_aen(%p)", ++ tgtt->name, aen); ++ rc = tgtt->report_aen(aen); ++ TRACE_DBG("Target's %s report_aen(%p) returned %d", ++ tgtt->name, aen, rc); ++ if (rc == SCST_AEN_RES_SUCCESS) ++ goto out; ++ ++ scst_free_aen(aen); ++ } ++ ++queue_ua: ++ TRACE_MGMT_DBG("AEN not supported, queueing plain UA (tgt_dev %p)", ++ tgt_dev); ++ sl = scst_set_sense(sense_buffer, sizeof(sense_buffer), ++ tgt_dev->dev->d_sense, key, asc, ascq); ++ scst_check_set_UA(tgt_dev, sense_buffer, sl, 0); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ * scst_capacity_data_changed() - notify SCST about device capacity change ++ * ++ * Notifies SCST core that dev has changed its capacity. Called under no locks. ++ */ ++void scst_capacity_data_changed(struct scst_device *dev) ++{ ++ struct scst_tgt_dev *tgt_dev; ++ ++ TRACE_ENTRY(); ++ ++ if (dev->type != TYPE_DISK) { ++ TRACE_MGMT_DBG("Device type %d isn't for CAPACITY DATA " ++ "CHANGED UA", dev->type); ++ goto out; ++ } ++ ++ TRACE_MGMT_DBG("CAPACITY DATA CHANGED (dev %p)", dev); ++ ++ mutex_lock(&scst_mutex); ++ ++ list_for_each_entry(tgt_dev, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ scst_gen_aen_or_ua(tgt_dev, ++ SCST_LOAD_SENSE(scst_sense_capacity_data_changed)); ++ } ++ ++ mutex_unlock(&scst_mutex); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL_GPL(scst_capacity_data_changed); ++ ++static inline bool scst_is_report_luns_changed_type(int type) ++{ ++ switch (type) { ++ case TYPE_DISK: ++ case TYPE_TAPE: ++ case TYPE_PRINTER: ++ case TYPE_PROCESSOR: ++ case TYPE_WORM: ++ case TYPE_ROM: ++ case TYPE_SCANNER: ++ case TYPE_MOD: ++ case TYPE_MEDIUM_CHANGER: ++ case TYPE_RAID: ++ case TYPE_ENCLOSURE: ++ return true; ++ default: ++ return false; ++ } ++} ++ ++/* scst_mutex supposed to be held */ ++static void scst_queue_report_luns_changed_UA(struct scst_session *sess, ++ int flags) ++{ ++ uint8_t sense_buffer[SCST_STANDARD_SENSE_LEN]; ++ struct list_head *head; ++ struct scst_tgt_dev *tgt_dev; ++ int i; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Queueing REPORTED LUNS DATA CHANGED UA " ++ "(sess %p)", sess); ++ ++ local_bh_disable(); ++ ++ for (i = 0; i < SESS_TGT_DEV_LIST_HASH_SIZE; i++) { ++ head = &sess->sess_tgt_dev_list[i]; ++ ++ list_for_each_entry(tgt_dev, head, ++ sess_tgt_dev_list_entry) { ++ /* Lockdep triggers here a false positive.. */ ++ spin_lock(&tgt_dev->tgt_dev_lock); ++ } ++ } ++ ++ for (i = 0; i < SESS_TGT_DEV_LIST_HASH_SIZE; i++) { ++ head = &sess->sess_tgt_dev_list[i]; ++ ++ list_for_each_entry(tgt_dev, head, sess_tgt_dev_list_entry) { ++ int sl; ++ ++ if (!scst_is_report_luns_changed_type( ++ tgt_dev->dev->type)) ++ continue; ++ ++ sl = scst_set_sense(sense_buffer, sizeof(sense_buffer), ++ tgt_dev->dev->d_sense, ++ SCST_LOAD_SENSE(scst_sense_reported_luns_data_changed)); ++ ++ __scst_check_set_UA(tgt_dev, sense_buffer, ++ sl, flags | SCST_SET_UA_FLAG_GLOBAL); ++ } ++ } ++ ++ for (i = SESS_TGT_DEV_LIST_HASH_SIZE-1; i >= 0; i--) { ++ head = &sess->sess_tgt_dev_list[i]; ++ ++ list_for_each_entry_reverse(tgt_dev, head, ++ sess_tgt_dev_list_entry) { ++ spin_unlock(&tgt_dev->tgt_dev_lock); ++ } ++ } ++ ++ local_bh_enable(); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++static void scst_report_luns_changed_sess(struct scst_session *sess) ++{ ++ int i; ++ struct scst_tgt_template *tgtt = sess->tgt->tgtt; ++ int d_sense = 0; ++ uint64_t lun = 0; ++ ++ TRACE_ENTRY(); ++ ++ if ((sess->init_phase != SCST_SESS_IPH_READY) || ++ (sess->shut_phase != SCST_SESS_SPH_READY)) ++ goto out; ++ ++ TRACE_DBG("REPORTED LUNS DATA CHANGED (sess %p)", sess); ++ ++ for (i = 0; i < SESS_TGT_DEV_LIST_HASH_SIZE; i++) { ++ struct list_head *head; ++ struct scst_tgt_dev *tgt_dev; ++ ++ head = &sess->sess_tgt_dev_list[i]; ++ ++ list_for_each_entry(tgt_dev, head, ++ sess_tgt_dev_list_entry) { ++ if (scst_is_report_luns_changed_type( ++ tgt_dev->dev->type)) { ++ lun = tgt_dev->lun; ++ d_sense = tgt_dev->dev->d_sense; ++ goto found; ++ } ++ } ++ } ++ ++found: ++ if (tgtt->report_aen != NULL) { ++ struct scst_aen *aen; ++ int rc; ++ ++ aen = scst_alloc_aen(sess, lun); ++ if (aen == NULL) ++ goto queue_ua; ++ ++ aen->event_fn = SCST_AEN_SCSI; ++ aen->aen_sense_len = scst_set_sense(aen->aen_sense, ++ sizeof(aen->aen_sense), d_sense, ++ SCST_LOAD_SENSE(scst_sense_reported_luns_data_changed)); ++ ++ TRACE_DBG("Calling target's %s report_aen(%p)", ++ tgtt->name, aen); ++ rc = tgtt->report_aen(aen); ++ TRACE_DBG("Target's %s report_aen(%p) returned %d", ++ tgtt->name, aen, rc); ++ if (rc == SCST_AEN_RES_SUCCESS) ++ goto out; ++ ++ scst_free_aen(aen); ++ } ++ ++queue_ua: ++ scst_queue_report_luns_changed_UA(sess, 0); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++void scst_report_luns_changed(struct scst_acg *acg) ++{ ++ struct scst_session *sess; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("REPORTED LUNS DATA CHANGED (acg %s)", acg->acg_name); ++ ++ list_for_each_entry(sess, &acg->acg_sess_list, acg_sess_list_entry) { ++ scst_report_luns_changed_sess(sess); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ * scst_aen_done() - AEN processing done ++ * ++ * Notifies SCST that the driver has sent the AEN and it ++ * can be freed now. Don't forget to set the delivery status, if it ++ * isn't success, using scst_set_aen_delivery_status() before calling ++ * this function. ++ */ ++void scst_aen_done(struct scst_aen *aen) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("AEN %p (fn %d) done (initiator %s)", aen, ++ aen->event_fn, aen->sess->initiator_name); ++ ++ if (aen->delivery_status == SCST_AEN_RES_SUCCESS) ++ goto out_free; ++ ++ if (aen->event_fn != SCST_AEN_SCSI) ++ goto out_free; ++ ++ TRACE_MGMT_DBG("Delivery of SCSI AEN failed (initiator %s)", ++ aen->sess->initiator_name); ++ ++ if (scst_analyze_sense(aen->aen_sense, aen->aen_sense_len, ++ SCST_SENSE_ALL_VALID, SCST_LOAD_SENSE( ++ scst_sense_reported_luns_data_changed))) { ++ mutex_lock(&scst_mutex); ++ scst_queue_report_luns_changed_UA(aen->sess, ++ SCST_SET_UA_FLAG_AT_HEAD); ++ mutex_unlock(&scst_mutex); ++ } else { ++ struct list_head *head; ++ struct scst_tgt_dev *tgt_dev; ++ uint64_t lun; ++ ++ lun = scst_unpack_lun((uint8_t *)&aen->lun, sizeof(aen->lun)); ++ ++ mutex_lock(&scst_mutex); ++ ++ /* tgt_dev might get dead, so we need to reseek it */ ++ head = &aen->sess->sess_tgt_dev_list[SESS_TGT_DEV_LIST_HASH_FN(lun)]; ++ list_for_each_entry(tgt_dev, head, ++ sess_tgt_dev_list_entry) { ++ if (tgt_dev->lun == lun) { ++ TRACE_MGMT_DBG("Requeuing failed AEN UA for " ++ "tgt_dev %p", tgt_dev); ++ scst_check_set_UA(tgt_dev, aen->aen_sense, ++ aen->aen_sense_len, ++ SCST_SET_UA_FLAG_AT_HEAD); ++ break; ++ } ++ } ++ ++ mutex_unlock(&scst_mutex); ++ } ++ ++out_free: ++ scst_free_aen(aen); ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL(scst_aen_done); ++ ++void scst_requeue_ua(struct scst_cmd *cmd) ++{ ++ TRACE_ENTRY(); ++ ++ if (scst_analyze_sense(cmd->sense, cmd->sense_valid_len, ++ SCST_SENSE_ALL_VALID, ++ SCST_LOAD_SENSE(scst_sense_reported_luns_data_changed))) { ++ TRACE_MGMT_DBG("Requeuing REPORTED LUNS DATA CHANGED UA " ++ "for delivery failed cmd %p", cmd); ++ mutex_lock(&scst_mutex); ++ scst_queue_report_luns_changed_UA(cmd->sess, ++ SCST_SET_UA_FLAG_AT_HEAD); ++ mutex_unlock(&scst_mutex); ++ } else { ++ TRACE_MGMT_DBG("Requeuing UA for delivery failed cmd %p", cmd); ++ scst_check_set_UA(cmd->tgt_dev, cmd->sense, ++ cmd->sense_valid_len, SCST_SET_UA_FLAG_AT_HEAD); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++static void scst_check_reassign_sess(struct scst_session *sess) ++{ ++ struct scst_acg *acg, *old_acg; ++ struct scst_acg_dev *acg_dev; ++ int i, rc; ++ struct list_head *head; ++ struct scst_tgt_dev *tgt_dev; ++ bool luns_changed = false; ++ bool add_failed, something_freed, not_needed_freed = false; ++ ++ TRACE_ENTRY(); ++ ++ if (sess->shut_phase != SCST_SESS_SPH_READY) ++ goto out; ++ ++ TRACE_MGMT_DBG("Checking reassignment for sess %p (initiator %s)", ++ sess, sess->initiator_name); ++ ++ acg = scst_find_acg(sess); ++ if (acg == sess->acg) { ++ TRACE_MGMT_DBG("No reassignment for sess %p", sess); ++ goto out; ++ } ++ ++ TRACE_MGMT_DBG("sess %p will be reassigned from acg %s to acg %s", ++ sess, sess->acg->acg_name, acg->acg_name); ++ ++ old_acg = sess->acg; ++ sess->acg = NULL; /* to catch implicit dependencies earlier */ ++ ++retry_add: ++ add_failed = false; ++ list_for_each_entry(acg_dev, &acg->acg_dev_list, acg_dev_list_entry) { ++ unsigned int inq_changed_ua_needed = 0; ++ ++ for (i = 0; i < SESS_TGT_DEV_LIST_HASH_SIZE; i++) { ++ head = &sess->sess_tgt_dev_list[i]; ++ ++ list_for_each_entry(tgt_dev, head, ++ sess_tgt_dev_list_entry) { ++ if ((tgt_dev->dev == acg_dev->dev) && ++ (tgt_dev->lun == acg_dev->lun) && ++ (tgt_dev->acg_dev->rd_only == acg_dev->rd_only)) { ++ TRACE_MGMT_DBG("sess %p: tgt_dev %p for " ++ "LUN %lld stays the same", ++ sess, tgt_dev, ++ (unsigned long long)tgt_dev->lun); ++ tgt_dev->acg_dev = acg_dev; ++ goto next; ++ } else if (tgt_dev->lun == acg_dev->lun) ++ inq_changed_ua_needed = 1; ++ } ++ } ++ ++ luns_changed = true; ++ ++ TRACE_MGMT_DBG("sess %p: Allocing new tgt_dev for LUN %lld", ++ sess, (unsigned long long)acg_dev->lun); ++ ++ rc = scst_alloc_add_tgt_dev(sess, acg_dev, &tgt_dev); ++ if (rc == -EPERM) ++ continue; ++ else if (rc != 0) { ++ add_failed = true; ++ break; ++ } ++ ++ tgt_dev->inq_changed_ua_needed = inq_changed_ua_needed || ++ not_needed_freed; ++next: ++ continue; ++ } ++ ++ something_freed = false; ++ not_needed_freed = true; ++ for (i = 0; i < SESS_TGT_DEV_LIST_HASH_SIZE; i++) { ++ struct scst_tgt_dev *t; ++ head = &sess->sess_tgt_dev_list[i]; ++ ++ list_for_each_entry_safe(tgt_dev, t, head, ++ sess_tgt_dev_list_entry) { ++ if (tgt_dev->acg_dev->acg != acg) { ++ TRACE_MGMT_DBG("sess %p: Deleting not used " ++ "tgt_dev %p for LUN %lld", ++ sess, tgt_dev, ++ (unsigned long long)tgt_dev->lun); ++ luns_changed = true; ++ something_freed = true; ++ scst_free_tgt_dev(tgt_dev); ++ } ++ } ++ } ++ ++ if (add_failed && something_freed) { ++ TRACE_MGMT_DBG("sess %p: Retrying adding new tgt_devs", sess); ++ goto retry_add; ++ } ++ ++ sess->acg = acg; ++ ++ TRACE_DBG("Moving sess %p from acg %s to acg %s", sess, ++ old_acg->acg_name, acg->acg_name); ++ list_move_tail(&sess->acg_sess_list_entry, &acg->acg_sess_list); ++ ++ scst_recreate_sess_luns_link(sess); ++ /* Ignore possible error, since we can't do anything on it */ ++ ++ if (luns_changed) { ++ scst_report_luns_changed_sess(sess); ++ ++ for (i = 0; i < SESS_TGT_DEV_LIST_HASH_SIZE; i++) { ++ head = &sess->sess_tgt_dev_list[i]; ++ ++ list_for_each_entry(tgt_dev, head, ++ sess_tgt_dev_list_entry) { ++ if (tgt_dev->inq_changed_ua_needed) { ++ TRACE_MGMT_DBG("sess %p: Setting " ++ "INQUIRY DATA HAS CHANGED UA " ++ "(tgt_dev %p)", sess, tgt_dev); ++ ++ tgt_dev->inq_changed_ua_needed = 0; ++ ++ scst_gen_aen_or_ua(tgt_dev, ++ SCST_LOAD_SENSE(scst_sense_inquery_data_changed)); ++ } ++ } ++ } ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++void scst_check_reassign_sessions(void) ++{ ++ struct scst_tgt_template *tgtt; ++ ++ TRACE_ENTRY(); ++ ++ list_for_each_entry(tgtt, &scst_template_list, scst_template_list_entry) { ++ struct scst_tgt *tgt; ++ list_for_each_entry(tgt, &tgtt->tgt_list, tgt_list_entry) { ++ struct scst_session *sess; ++ list_for_each_entry(sess, &tgt->sess_list, ++ sess_list_entry) { ++ scst_check_reassign_sess(sess); ++ } ++ } ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int scst_get_cmd_abnormal_done_state(const struct scst_cmd *cmd) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ switch (cmd->state) { ++ case SCST_CMD_STATE_INIT_WAIT: ++ case SCST_CMD_STATE_INIT: ++ case SCST_CMD_STATE_PARSE: ++ if (cmd->preprocessing_only) { ++ res = SCST_CMD_STATE_PREPROCESSING_DONE; ++ break; ++ } /* else go through */ ++ case SCST_CMD_STATE_DEV_DONE: ++ if (cmd->internal) ++ res = SCST_CMD_STATE_FINISHED_INTERNAL; ++ else ++ res = SCST_CMD_STATE_PRE_XMIT_RESP; ++ break; ++ ++ case SCST_CMD_STATE_PRE_DEV_DONE: ++ case SCST_CMD_STATE_MODE_SELECT_CHECKS: ++ res = SCST_CMD_STATE_DEV_DONE; ++ break; ++ ++ case SCST_CMD_STATE_PRE_XMIT_RESP: ++ res = SCST_CMD_STATE_XMIT_RESP; ++ break; ++ ++ case SCST_CMD_STATE_PREPROCESSING_DONE: ++ case SCST_CMD_STATE_PREPROCESSING_DONE_CALLED: ++ if (cmd->tgt_dev == NULL) ++ res = SCST_CMD_STATE_PRE_XMIT_RESP; ++ else ++ res = SCST_CMD_STATE_PRE_DEV_DONE; ++ break; ++ ++ case SCST_CMD_STATE_PREPARE_SPACE: ++ if (cmd->preprocessing_only) { ++ res = SCST_CMD_STATE_PREPROCESSING_DONE; ++ break; ++ } /* else go through */ ++ case SCST_CMD_STATE_RDY_TO_XFER: ++ case SCST_CMD_STATE_DATA_WAIT: ++ case SCST_CMD_STATE_TGT_PRE_EXEC: ++ case SCST_CMD_STATE_START_EXEC: ++ case SCST_CMD_STATE_SEND_FOR_EXEC: ++ case SCST_CMD_STATE_LOCAL_EXEC: ++ case SCST_CMD_STATE_REAL_EXEC: ++ case SCST_CMD_STATE_REAL_EXECUTING: ++ res = SCST_CMD_STATE_PRE_DEV_DONE; ++ break; ++ ++ default: ++ PRINT_CRIT_ERROR("Wrong cmd state %d (cmd %p, op %x)", ++ cmd->state, cmd, cmd->cdb[0]); ++ BUG(); ++ /* Invalid state to suppress a compiler warning */ ++ res = SCST_CMD_STATE_LAST_ACTIVE; ++ } ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/** ++ * scst_set_cmd_abnormal_done_state() - set command's next abnormal done state ++ * ++ * Sets state of the SCSI target state machine to abnormally complete command ++ * ASAP. ++ * ++ * Returns the new state. ++ */ ++int scst_set_cmd_abnormal_done_state(struct scst_cmd *cmd) ++{ ++ TRACE_ENTRY(); ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ switch (cmd->state) { ++ case SCST_CMD_STATE_XMIT_RESP: ++ case SCST_CMD_STATE_FINISHED: ++ case SCST_CMD_STATE_FINISHED_INTERNAL: ++ case SCST_CMD_STATE_XMIT_WAIT: ++ PRINT_CRIT_ERROR("Wrong cmd state %d (cmd %p, op %x)", ++ cmd->state, cmd, cmd->cdb[0]); ++ BUG(); ++ } ++#endif ++ ++ cmd->state = scst_get_cmd_abnormal_done_state(cmd); ++ ++ switch (cmd->state) { ++ case SCST_CMD_STATE_INIT_WAIT: ++ case SCST_CMD_STATE_INIT: ++ case SCST_CMD_STATE_PARSE: ++ case SCST_CMD_STATE_PREPROCESSING_DONE: ++ case SCST_CMD_STATE_PREPROCESSING_DONE_CALLED: ++ case SCST_CMD_STATE_PREPARE_SPACE: ++ case SCST_CMD_STATE_RDY_TO_XFER: ++ case SCST_CMD_STATE_DATA_WAIT: ++ cmd->write_len = 0; ++ cmd->resid_possible = 1; ++ break; ++ case SCST_CMD_STATE_TGT_PRE_EXEC: ++ case SCST_CMD_STATE_SEND_FOR_EXEC: ++ case SCST_CMD_STATE_START_EXEC: ++ case SCST_CMD_STATE_LOCAL_EXEC: ++ case SCST_CMD_STATE_REAL_EXEC: ++ case SCST_CMD_STATE_REAL_EXECUTING: ++ case SCST_CMD_STATE_DEV_DONE: ++ case SCST_CMD_STATE_PRE_DEV_DONE: ++ case SCST_CMD_STATE_MODE_SELECT_CHECKS: ++ case SCST_CMD_STATE_PRE_XMIT_RESP: ++ case SCST_CMD_STATE_FINISHED_INTERNAL: ++ break; ++ default: ++ PRINT_CRIT_ERROR("Wrong cmd state %d (cmd %p, op %x)", ++ cmd->state, cmd, cmd->cdb[0]); ++ BUG(); ++ break; ++ } ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ if (((cmd->state != SCST_CMD_STATE_PRE_XMIT_RESP) && ++ (cmd->state != SCST_CMD_STATE_PREPROCESSING_DONE)) && ++ (cmd->tgt_dev == NULL) && !cmd->internal) { ++ PRINT_CRIT_ERROR("Wrong not inited cmd state %d (cmd %p, " ++ "op %x)", cmd->state, cmd, cmd->cdb[0]); ++ BUG(); ++ } ++#endif ++ ++ TRACE_EXIT_RES(cmd->state); ++ return cmd->state; ++} ++EXPORT_SYMBOL_GPL(scst_set_cmd_abnormal_done_state); ++ ++void scst_zero_write_rest(struct scst_cmd *cmd) ++{ ++ int len, offs = 0; ++ uint8_t *buf; ++ ++ TRACE_ENTRY(); ++ ++ len = scst_get_sg_buf_first(cmd, &buf, *cmd->write_sg, ++ *cmd->write_sg_cnt); ++ while (len > 0) { ++ int cur_offs; ++ ++ if (offs + len <= cmd->write_len) ++ goto next; ++ else if (offs >= cmd->write_len) ++ cur_offs = 0; ++ else ++ cur_offs = cmd->write_len - offs; ++ ++ memset(&buf[cur_offs], 0, len - cur_offs); ++ ++next: ++ offs += len; ++ scst_put_sg_buf(cmd, buf, *cmd->write_sg, *cmd->write_sg_cnt); ++ len = scst_get_sg_buf_next(cmd, &buf, *cmd->write_sg, ++ *cmd->write_sg_cnt); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void scst_adjust_sg(struct scst_cmd *cmd, struct scatterlist *sg, ++ int *sg_cnt, int adjust_len) ++{ ++ int i, j, l; ++ ++ TRACE_ENTRY(); ++ ++ l = 0; ++ for (i = 0, j = 0; i < *sg_cnt; i++, j++) { ++ TRACE_DBG("i %d, j %d, sg_cnt %d, sg %p, page_link %lx", i, j, ++ *sg_cnt, sg, sg[j].page_link); ++ if (unlikely(sg_is_chain(&sg[j]))) { ++ sg = sg_chain_ptr(&sg[j]); ++ j = 0; ++ } ++ l += sg[j].length; ++ if (l >= adjust_len) { ++ int left = adjust_len - (l - sg[j].length); ++#ifdef CONFIG_SCST_DEBUG ++ TRACE(TRACE_SG_OP|TRACE_MEMORY, "cmd %p (tag %llu), " ++ "sg %p, sg_cnt %d, adjust_len %d, i %d, j %d, " ++ "sg[j].length %d, left %d", ++ cmd, (long long unsigned int)cmd->tag, ++ sg, *sg_cnt, adjust_len, i, j, ++ sg[j].length, left); ++#endif ++ cmd->orig_sg = sg; ++ cmd->p_orig_sg_cnt = sg_cnt; ++ cmd->orig_sg_cnt = *sg_cnt; ++ cmd->orig_sg_entry = j; ++ cmd->orig_entry_len = sg[j].length; ++ *sg_cnt = (left > 0) ? j+1 : j; ++ sg[j].length = left; ++ cmd->sg_buff_modified = 1; ++ break; ++ } ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ * scst_restore_sg_buff() - restores modified sg buffer ++ * ++ * Restores modified sg buffer in the original state. ++ */ ++void scst_restore_sg_buff(struct scst_cmd *cmd) ++{ ++ TRACE_MEM("cmd %p, sg %p, orig_sg_entry %d, " ++ "orig_entry_len %d, orig_sg_cnt %d", cmd, cmd->orig_sg, ++ cmd->orig_sg_entry, cmd->orig_entry_len, ++ cmd->orig_sg_cnt); ++ cmd->orig_sg[cmd->orig_sg_entry].length = cmd->orig_entry_len; ++ *cmd->p_orig_sg_cnt = cmd->orig_sg_cnt; ++ cmd->sg_buff_modified = 0; ++} ++EXPORT_SYMBOL(scst_restore_sg_buff); ++ ++/** ++ * scst_set_resp_data_len() - set response data length ++ * ++ * Sets response data length for cmd and truncates its SG vector accordingly. ++ * ++ * The cmd->resp_data_len must not be set directly, it must be set only ++ * using this function. Value of resp_data_len must be <= cmd->bufflen. ++ */ ++void scst_set_resp_data_len(struct scst_cmd *cmd, int resp_data_len) ++{ ++ TRACE_ENTRY(); ++ ++ scst_check_restore_sg_buff(cmd); ++ cmd->resp_data_len = resp_data_len; ++ ++ if (resp_data_len == cmd->bufflen) ++ goto out; ++ ++ TRACE_DBG("cmd %p, resp_data_len %d", cmd, resp_data_len); ++ ++ scst_adjust_sg(cmd, cmd->sg, &cmd->sg_cnt, resp_data_len); ++ ++ cmd->resid_possible = 1; ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL_GPL(scst_set_resp_data_len); ++ ++void scst_limit_sg_write_len(struct scst_cmd *cmd) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_MEM("Limiting sg write len to %d (cmd %p, sg %p, sg_cnt %d)", ++ cmd->write_len, cmd, *cmd->write_sg, *cmd->write_sg_cnt); ++ ++ scst_check_restore_sg_buff(cmd); ++ scst_adjust_sg(cmd, *cmd->write_sg, cmd->write_sg_cnt, cmd->write_len); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++void scst_adjust_resp_data_len(struct scst_cmd *cmd) ++{ ++ TRACE_ENTRY(); ++ ++ if (!cmd->expected_values_set) { ++ cmd->adjusted_resp_data_len = cmd->resp_data_len; ++ goto out; ++ } ++ ++ cmd->adjusted_resp_data_len = min(cmd->resp_data_len, ++ cmd->expected_transfer_len); ++ ++ if (cmd->adjusted_resp_data_len != cmd->resp_data_len) { ++ TRACE_MEM("Adjusting resp_data_len to %d (cmd %p, sg %p, " ++ "sg_cnt %d)", cmd->adjusted_resp_data_len, cmd, cmd->sg, ++ cmd->sg_cnt); ++ scst_check_restore_sg_buff(cmd); ++ scst_adjust_sg(cmd, cmd->sg, &cmd->sg_cnt, ++ cmd->adjusted_resp_data_len); ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ * scst_cmd_set_write_not_received_data_len() - sets cmd's not received len ++ * ++ * Sets cmd's not received data length. Also automatically sets resid_possible. ++ */ ++void scst_cmd_set_write_not_received_data_len(struct scst_cmd *cmd, ++ int not_received) ++{ ++ TRACE_ENTRY(); ++ ++ if (!cmd->expected_values_set) { ++ /* ++ * No expected values set, so no residuals processing. ++ * It can happen if a command preliminary completed before ++ * target driver had a chance to set expected values. ++ */ ++ TRACE_MGMT_DBG("No expected values set, ignoring (cmd %p)", cmd); ++ goto out; ++ } ++ ++ cmd->resid_possible = 1; ++ ++ if ((cmd->expected_data_direction & SCST_DATA_READ) && ++ (cmd->expected_data_direction & SCST_DATA_WRITE)) { ++ cmd->write_len = cmd->expected_out_transfer_len - not_received; ++ if (cmd->write_len == cmd->out_bufflen) ++ goto out; ++ } else if (cmd->expected_data_direction & SCST_DATA_WRITE) { ++ cmd->write_len = cmd->expected_transfer_len - not_received; ++ if (cmd->write_len == cmd->bufflen) ++ goto out; ++ } ++ ++ /* ++ * Write len now can be bigger cmd->(out_)bufflen, but that's OK, ++ * because it will be used to only calculate write residuals. ++ */ ++ ++ TRACE_DBG("cmd %p, not_received %d, write_len %d", cmd, not_received, ++ cmd->write_len); ++ ++ if (cmd->data_direction & SCST_DATA_WRITE) ++ scst_limit_sg_write_len(cmd); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL(scst_cmd_set_write_not_received_data_len); ++ ++/** ++ * __scst_get_resid() - returns residuals for cmd ++ * ++ * Returns residuals for command. Must not be called directly, use ++ * scst_get_resid() instead. ++ */ ++bool __scst_get_resid(struct scst_cmd *cmd, int *resid, int *bidi_out_resid) ++{ ++ bool res; ++ ++ TRACE_ENTRY(); ++ ++ *resid = 0; ++ if (bidi_out_resid != NULL) ++ *bidi_out_resid = 0; ++ ++ if (!cmd->expected_values_set) { ++ /* ++ * No expected values set, so no residuals processing. ++ * It can happen if a command preliminary completed before ++ * target driver had a chance to set expected values. ++ */ ++ TRACE_MGMT_DBG("No expected values set, returning no residual " ++ "(cmd %p)", cmd); ++ res = false; ++ goto out; ++ } ++ ++ if (cmd->expected_data_direction & SCST_DATA_READ) { ++ *resid = cmd->expected_transfer_len - cmd->resp_data_len; ++ if ((cmd->expected_data_direction & SCST_DATA_WRITE) && bidi_out_resid) { ++ if (cmd->write_len < cmd->expected_out_transfer_len) ++ *bidi_out_resid = cmd->expected_out_transfer_len - ++ cmd->write_len; ++ else ++ *bidi_out_resid = cmd->write_len - cmd->out_bufflen; ++ } ++ } else if (cmd->expected_data_direction & SCST_DATA_WRITE) { ++ if (cmd->write_len < cmd->expected_transfer_len) ++ *resid = cmd->expected_transfer_len - cmd->write_len; ++ else ++ *resid = cmd->write_len - cmd->bufflen; ++ } ++ ++ res = true; ++ ++ TRACE_DBG("cmd %p, resid %d, bidi_out_resid %d (resp_data_len %d, " ++ "expected_data_direction %d, write_len %d, bufflen %d)", cmd, ++ *resid, bidi_out_resid ? *bidi_out_resid : 0, cmd->resp_data_len, ++ cmd->expected_data_direction, cmd->write_len, cmd->bufflen); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL(__scst_get_resid); ++ ++/* No locks */ ++int scst_queue_retry_cmd(struct scst_cmd *cmd, int finished_cmds) ++{ ++ struct scst_tgt *tgt = cmd->tgt; ++ int res = 0; ++ unsigned long flags; ++ ++ TRACE_ENTRY(); ++ ++ spin_lock_irqsave(&tgt->tgt_lock, flags); ++ tgt->retry_cmds++; ++ /* ++ * Memory barrier is needed here, because we need the exact order ++ * between the read and write between retry_cmds and finished_cmds to ++ * not miss the case when a command finished while we queueing it for ++ * retry after the finished_cmds check. ++ */ ++ smp_mb(); ++ TRACE_RETRY("TGT QUEUE FULL: incrementing retry_cmds %d", ++ tgt->retry_cmds); ++ if (finished_cmds != atomic_read(&tgt->finished_cmds)) { ++ /* At least one cmd finished, so try again */ ++ tgt->retry_cmds--; ++ TRACE_RETRY("Some command(s) finished, direct retry " ++ "(finished_cmds=%d, tgt->finished_cmds=%d, " ++ "retry_cmds=%d)", finished_cmds, ++ atomic_read(&tgt->finished_cmds), tgt->retry_cmds); ++ res = -1; ++ goto out_unlock_tgt; ++ } ++ ++ TRACE_RETRY("Adding cmd %p to retry cmd list", cmd); ++ list_add_tail(&cmd->cmd_list_entry, &tgt->retry_cmd_list); ++ ++ if (!tgt->retry_timer_active) { ++ tgt->retry_timer.expires = jiffies + SCST_TGT_RETRY_TIMEOUT; ++ add_timer(&tgt->retry_timer); ++ tgt->retry_timer_active = 1; ++ } ++ ++out_unlock_tgt: ++ spin_unlock_irqrestore(&tgt->tgt_lock, flags); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/** ++ * scst_update_hw_pending_start() - update commands pending start ++ * ++ * Updates the command's hw_pending_start as if it's just started hw pending. ++ * Target drivers should call it if they received reply from this pending ++ * command, but SCST core won't see it. ++ */ ++void scst_update_hw_pending_start(struct scst_cmd *cmd) ++{ ++ unsigned long flags; ++ ++ TRACE_ENTRY(); ++ ++ /* To sync with scst_check_hw_pending_cmd() */ ++ spin_lock_irqsave(&cmd->sess->sess_list_lock, flags); ++ cmd->hw_pending_start = jiffies; ++ TRACE_MGMT_DBG("Updated hw_pending_start to %ld (cmd %p)", ++ cmd->hw_pending_start, cmd); ++ spin_unlock_irqrestore(&cmd->sess->sess_list_lock, flags); ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL_GPL(scst_update_hw_pending_start); ++ ++/* ++ * Supposed to be called under sess_list_lock, but can release/reacquire it. ++ * Returns 0 to continue, >0 to restart, <0 to break. ++ */ ++static int scst_check_hw_pending_cmd(struct scst_cmd *cmd, ++ unsigned long cur_time, unsigned long max_time, ++ struct scst_session *sess, unsigned long *flags, ++ struct scst_tgt_template *tgtt) ++{ ++ int res = -1; /* break */ ++ ++ TRACE_DBG("cmd %p, hw_pending %d, proc time %ld, " ++ "pending time %ld", cmd, cmd->cmd_hw_pending, ++ (long)(cur_time - cmd->start_time) / HZ, ++ (long)(cur_time - cmd->hw_pending_start) / HZ); ++ ++ if (time_before(cur_time, cmd->start_time + max_time)) { ++ /* Cmds are ordered, so no need to check more */ ++ goto out; ++ } ++ ++ if (!cmd->cmd_hw_pending) { ++ res = 0; /* continue */ ++ goto out; ++ } ++ ++ if (time_before(cur_time, cmd->hw_pending_start + max_time)) { ++ res = 0; /* continue */ ++ goto out; ++ } ++ ++ TRACE_MGMT_DBG("Cmd %p HW pending for too long %ld (state %x)", ++ cmd, (cur_time - cmd->hw_pending_start) / HZ, ++ cmd->state); ++ ++ cmd->cmd_hw_pending = 0; ++ ++ spin_unlock_irqrestore(&sess->sess_list_lock, *flags); ++ tgtt->on_hw_pending_cmd_timeout(cmd); ++ spin_lock_irqsave(&sess->sess_list_lock, *flags); ++ ++ res = 1; /* restart */ ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void scst_hw_pending_work_fn(struct delayed_work *work) ++{ ++ struct scst_session *sess = container_of(work, struct scst_session, ++ hw_pending_work); ++ struct scst_tgt_template *tgtt = sess->tgt->tgtt; ++ struct scst_cmd *cmd; ++ unsigned long cur_time = jiffies; ++ unsigned long flags; ++ unsigned long max_time = tgtt->max_hw_pending_time * HZ; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("HW pending work (sess %p, max time %ld)", sess, max_time/HZ); ++ ++ clear_bit(SCST_SESS_HW_PENDING_WORK_SCHEDULED, &sess->sess_aflags); ++ ++ spin_lock_irqsave(&sess->sess_list_lock, flags); ++ ++restart: ++ list_for_each_entry(cmd, &sess->sess_cmd_list, sess_cmd_list_entry) { ++ int rc; ++ ++ rc = scst_check_hw_pending_cmd(cmd, cur_time, max_time, sess, ++ &flags, tgtt); ++ if (rc < 0) ++ break; ++ else if (rc == 0) ++ continue; ++ else ++ goto restart; ++ } ++ ++ if (!list_empty(&sess->sess_cmd_list)) { ++ /* ++ * For stuck cmds if there is no activity we might need to have ++ * one more run to release them, so reschedule once again. ++ */ ++ TRACE_DBG("Sched HW pending work for sess %p (max time %d)", ++ sess, tgtt->max_hw_pending_time); ++ set_bit(SCST_SESS_HW_PENDING_WORK_SCHEDULED, &sess->sess_aflags); ++ schedule_delayed_work(&sess->hw_pending_work, ++ tgtt->max_hw_pending_time * HZ); ++ } ++ ++ spin_unlock_irqrestore(&sess->sess_list_lock, flags); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static bool __scst_is_relative_target_port_id_unique(uint16_t id, ++ const struct scst_tgt *t) ++{ ++ bool res = true; ++ struct scst_tgt_template *tgtt; ++ ++ TRACE_ENTRY(); ++ ++ list_for_each_entry(tgtt, &scst_template_list, ++ scst_template_list_entry) { ++ struct scst_tgt *tgt; ++ list_for_each_entry(tgt, &tgtt->tgt_list, tgt_list_entry) { ++ if (tgt == t) ++ continue; ++ if ((tgt->tgtt->is_target_enabled != NULL) && ++ !tgt->tgtt->is_target_enabled(tgt)) ++ continue; ++ if (id == tgt->rel_tgt_id) { ++ res = false; ++ break; ++ } ++ } ++ } ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* scst_mutex supposed to be locked */ ++bool scst_is_relative_target_port_id_unique(uint16_t id, ++ const struct scst_tgt *t) ++{ ++ bool res; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_mutex); ++ res = __scst_is_relative_target_port_id_unique(id, t); ++ mutex_unlock(&scst_mutex); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++int gen_relative_target_port_id(uint16_t *id) ++{ ++ int res = -EOVERFLOW; ++ static unsigned long rti = SCST_MIN_REL_TGT_ID, rti_prev; ++ ++ TRACE_ENTRY(); ++ ++ if (mutex_lock_interruptible(&scst_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ ++ rti_prev = rti; ++ do { ++ if (__scst_is_relative_target_port_id_unique(rti, NULL)) { ++ *id = (uint16_t)rti++; ++ res = 0; ++ goto out_unlock; ++ } ++ rti++; ++ if (rti > SCST_MAX_REL_TGT_ID) ++ rti = SCST_MIN_REL_TGT_ID; ++ } while (rti != rti_prev); ++ ++ PRINT_ERROR("%s", "Unable to create unique relative target port id"); ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* No locks */ ++int scst_alloc_tgt(struct scst_tgt_template *tgtt, struct scst_tgt **tgt) ++{ ++ struct scst_tgt *t; ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ t = kzalloc(sizeof(*t), GFP_KERNEL); ++ if (t == NULL) { ++ PRINT_ERROR("%s", "Allocation of tgt failed"); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ INIT_LIST_HEAD(&t->sess_list); ++ init_waitqueue_head(&t->unreg_waitQ); ++ t->tgtt = tgtt; ++ t->sg_tablesize = tgtt->sg_tablesize; ++ spin_lock_init(&t->tgt_lock); ++ INIT_LIST_HEAD(&t->retry_cmd_list); ++ atomic_set(&t->finished_cmds, 0); ++ init_timer(&t->retry_timer); ++ t->retry_timer.data = (unsigned long)t; ++ t->retry_timer.function = scst_tgt_retry_timer_fn; ++ ++ INIT_LIST_HEAD(&t->tgt_acg_list); ++ ++ *tgt = t; ++ ++out: ++ TRACE_EXIT_HRES(res); ++ return res; ++} ++ ++/* No locks */ ++void scst_free_tgt(struct scst_tgt *tgt) ++{ ++ TRACE_ENTRY(); ++ ++ kfree(tgt->tgt_name); ++ kfree(tgt->tgt_comment); ++ ++ kfree(tgt); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void scst_init_order_data(struct scst_order_data *order_data) ++{ ++ int i; ++ spin_lock_init(&order_data->sn_lock); ++ INIT_LIST_HEAD(&order_data->deferred_cmd_list); ++ INIT_LIST_HEAD(&order_data->skipped_sn_list); ++ order_data->curr_sn = (typeof(order_data->curr_sn))(-300); ++ order_data->expected_sn = order_data->curr_sn + 1; ++ order_data->num_free_sn_slots = ARRAY_SIZE(order_data->sn_slots)-1; ++ order_data->cur_sn_slot = &order_data->sn_slots[0]; ++ for (i = 0; i < (int)ARRAY_SIZE(order_data->sn_slots); i++) ++ atomic_set(&order_data->sn_slots[i], 0); ++ return; ++} ++ ++/* Called under scst_mutex and suspended activity */ ++int scst_alloc_device(gfp_t gfp_mask, struct scst_device **out_dev) ++{ ++ struct scst_device *dev; ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ dev = kzalloc(sizeof(*dev), gfp_mask); ++ if (dev == NULL) { ++ PRINT_ERROR("%s", "Allocation of scst_device failed"); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ dev->handler = &scst_null_devtype; ++ atomic_set(&dev->dev_cmd_count, 0); ++ scst_init_mem_lim(&dev->dev_mem_lim); ++ spin_lock_init(&dev->dev_lock); ++ INIT_LIST_HEAD(&dev->blocked_cmd_list); ++ INIT_LIST_HEAD(&dev->dev_tgt_dev_list); ++ INIT_LIST_HEAD(&dev->dev_acg_dev_list); ++ dev->dev_double_ua_possible = 1; ++ dev->queue_alg = SCST_CONTR_MODE_QUEUE_ALG_UNRESTRICTED_REORDER; ++ ++ mutex_init(&dev->dev_pr_mutex); ++ dev->pr_generation = 0; ++ dev->pr_is_set = 0; ++ dev->pr_holder = NULL; ++ dev->pr_scope = SCOPE_LU; ++ dev->pr_type = TYPE_UNSPECIFIED; ++ INIT_LIST_HEAD(&dev->dev_registrants_list); ++ ++ scst_init_order_data(&dev->dev_order_data); ++ ++ scst_init_threads(&dev->dev_cmd_threads); ++ ++ *out_dev = dev; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++void scst_free_device(struct scst_device *dev) ++{ ++ TRACE_ENTRY(); ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ if (!list_empty(&dev->dev_tgt_dev_list) || ++ !list_empty(&dev->dev_acg_dev_list)) { ++ PRINT_CRIT_ERROR("%s: dev_tgt_dev_list or dev_acg_dev_list " ++ "is not empty!", __func__); ++ BUG(); ++ } ++#endif ++ ++ scst_deinit_threads(&dev->dev_cmd_threads); ++ ++ kfree(dev->virt_name); ++ kfree(dev); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ * scst_init_mem_lim - initialize memory limits structure ++ * ++ * Initializes memory limits structure mem_lim according to ++ * the current system configuration. This structure should be latter used ++ * to track and limit allocated by one or more SGV pools memory. ++ */ ++void scst_init_mem_lim(struct scst_mem_lim *mem_lim) ++{ ++ atomic_set(&mem_lim->alloced_pages, 0); ++ mem_lim->max_allowed_pages = ++ ((uint64_t)scst_max_dev_cmd_mem << 10) >> (PAGE_SHIFT - 10); ++} ++EXPORT_SYMBOL_GPL(scst_init_mem_lim); ++ ++static struct scst_acg_dev *scst_alloc_acg_dev(struct scst_acg *acg, ++ struct scst_device *dev, uint64_t lun) ++{ ++ struct scst_acg_dev *res; ++ ++ TRACE_ENTRY(); ++ ++ res = kmem_cache_zalloc(scst_acgd_cachep, GFP_KERNEL); ++ if (res == NULL) { ++ PRINT_ERROR("%s", "Allocation of scst_acg_dev failed"); ++ goto out; ++ } ++ ++ res->dev = dev; ++ res->acg = acg; ++ res->lun = lun; ++ ++out: ++ TRACE_EXIT_HRES(res); ++ return res; ++} ++ ++/* ++ * The activity supposed to be suspended and scst_mutex held or the ++ * corresponding target supposed to be stopped. ++ */ ++static void scst_del_free_acg_dev(struct scst_acg_dev *acg_dev, bool del_sysfs) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Removing acg_dev %p from acg_dev_list and dev_acg_dev_list", ++ acg_dev); ++ list_del(&acg_dev->acg_dev_list_entry); ++ list_del(&acg_dev->dev_acg_dev_list_entry); ++ ++ if (del_sysfs) ++ scst_acg_dev_sysfs_del(acg_dev); ++ ++ kmem_cache_free(scst_acgd_cachep, acg_dev); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++int scst_acg_add_lun(struct scst_acg *acg, struct kobject *parent, ++ struct scst_device *dev, uint64_t lun, int read_only, ++ bool gen_scst_report_luns_changed, struct scst_acg_dev **out_acg_dev) ++{ ++ int res = 0; ++ struct scst_acg_dev *acg_dev; ++ struct scst_tgt_dev *tgt_dev; ++ struct scst_session *sess; ++ LIST_HEAD(tmp_tgt_dev_list); ++ ++ TRACE_ENTRY(); ++ ++ INIT_LIST_HEAD(&tmp_tgt_dev_list); ++ ++ acg_dev = scst_alloc_acg_dev(acg, dev, lun); ++ if (acg_dev == NULL) { ++ res = -ENOMEM; ++ goto out; ++ } ++ acg_dev->rd_only = read_only; ++ ++ TRACE_DBG("Adding acg_dev %p to acg_dev_list and dev_acg_dev_list", ++ acg_dev); ++ list_add_tail(&acg_dev->acg_dev_list_entry, &acg->acg_dev_list); ++ list_add_tail(&acg_dev->dev_acg_dev_list_entry, &dev->dev_acg_dev_list); ++ ++ list_for_each_entry(sess, &acg->acg_sess_list, acg_sess_list_entry) { ++ res = scst_alloc_add_tgt_dev(sess, acg_dev, &tgt_dev); ++ if (res == -EPERM) ++ continue; ++ else if (res != 0) ++ goto out_free; ++ ++ list_add_tail(&tgt_dev->extra_tgt_dev_list_entry, ++ &tmp_tgt_dev_list); ++ } ++ ++ res = scst_acg_dev_sysfs_create(acg_dev, parent); ++ if (res != 0) ++ goto out_free; ++ ++ if (gen_scst_report_luns_changed) ++ scst_report_luns_changed(acg); ++ ++ PRINT_INFO("Added device %s to group %s (LUN %lld, " ++ "rd_only %d)", dev->virt_name, acg->acg_name, ++ (long long unsigned int)lun, read_only); ++ ++ if (out_acg_dev != NULL) ++ *out_acg_dev = acg_dev; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free: ++ list_for_each_entry(tgt_dev, &tmp_tgt_dev_list, ++ extra_tgt_dev_list_entry) { ++ scst_free_tgt_dev(tgt_dev); ++ } ++ scst_del_free_acg_dev(acg_dev, false); ++ goto out; ++} ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++int scst_acg_del_lun(struct scst_acg *acg, uint64_t lun, ++ bool gen_scst_report_luns_changed) ++{ ++ int res = 0; ++ struct scst_acg_dev *acg_dev = NULL, *a; ++ struct scst_tgt_dev *tgt_dev, *tt; ++ ++ TRACE_ENTRY(); ++ ++ list_for_each_entry(a, &acg->acg_dev_list, acg_dev_list_entry) { ++ if (a->lun == lun) { ++ acg_dev = a; ++ break; ++ } ++ } ++ if (acg_dev == NULL) { ++ PRINT_ERROR("Device is not found in group %s", acg->acg_name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ list_for_each_entry_safe(tgt_dev, tt, &acg_dev->dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ if (tgt_dev->acg_dev == acg_dev) ++ scst_free_tgt_dev(tgt_dev); ++ } ++ ++ scst_del_free_acg_dev(acg_dev, true); ++ ++ if (gen_scst_report_luns_changed) ++ scst_report_luns_changed(acg); ++ ++ PRINT_INFO("Removed LUN %lld from group %s", (unsigned long long)lun, ++ acg->acg_name); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++struct scst_acg *scst_alloc_add_acg(struct scst_tgt *tgt, ++ const char *acg_name, bool tgt_acg) ++{ ++ struct scst_acg *acg; ++ ++ TRACE_ENTRY(); ++ ++ acg = kzalloc(sizeof(*acg), GFP_KERNEL); ++ if (acg == NULL) { ++ PRINT_ERROR("%s", "Allocation of acg failed"); ++ goto out; ++ } ++ ++ acg->tgt = tgt; ++ INIT_LIST_HEAD(&acg->acg_dev_list); ++ INIT_LIST_HEAD(&acg->acg_sess_list); ++ INIT_LIST_HEAD(&acg->acn_list); ++ cpumask_copy(&acg->acg_cpu_mask, &default_cpu_mask); ++ acg->acg_name = kstrdup(acg_name, GFP_KERNEL); ++ if (acg->acg_name == NULL) { ++ PRINT_ERROR("%s", "Allocation of acg_name failed"); ++ goto out_free; ++ } ++ ++ acg->addr_method = tgt->tgtt->preferred_addr_method; ++ ++ if (tgt_acg) { ++ int rc; ++ ++ TRACE_DBG("Adding acg '%s' to device '%s' acg_list", acg_name, ++ tgt->tgt_name); ++ list_add_tail(&acg->acg_list_entry, &tgt->tgt_acg_list); ++ acg->tgt_acg = 1; ++ ++ rc = scst_acg_sysfs_create(tgt, acg); ++ if (rc != 0) ++ goto out_del; ++ } ++ ++out: ++ TRACE_EXIT_HRES(acg); ++ return acg; ++ ++out_del: ++ list_del(&acg->acg_list_entry); ++ ++out_free: ++ kfree(acg); ++ acg = NULL; ++ goto out; ++} ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++void scst_del_free_acg(struct scst_acg *acg) ++{ ++ struct scst_acn *acn, *acnt; ++ struct scst_acg_dev *acg_dev, *acg_dev_tmp; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Clearing acg %s from list", acg->acg_name); ++ ++ BUG_ON(!list_empty(&acg->acg_sess_list)); ++ ++ /* Freeing acg_devs */ ++ list_for_each_entry_safe(acg_dev, acg_dev_tmp, &acg->acg_dev_list, ++ acg_dev_list_entry) { ++ struct scst_tgt_dev *tgt_dev, *tt; ++ list_for_each_entry_safe(tgt_dev, tt, ++ &acg_dev->dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ if (tgt_dev->acg_dev == acg_dev) ++ scst_free_tgt_dev(tgt_dev); ++ } ++ scst_del_free_acg_dev(acg_dev, true); ++ } ++ ++ /* Freeing names */ ++ list_for_each_entry_safe(acn, acnt, &acg->acn_list, acn_list_entry) { ++ scst_del_free_acn(acn, ++ list_is_last(&acn->acn_list_entry, &acg->acn_list)); ++ } ++ INIT_LIST_HEAD(&acg->acn_list); ++ ++ if (acg->tgt_acg) { ++ TRACE_DBG("Removing acg %s from list", acg->acg_name); ++ list_del(&acg->acg_list_entry); ++ ++ scst_acg_sysfs_del(acg); ++ } else ++ acg->tgt->default_acg = NULL; ++ ++ BUG_ON(!list_empty(&acg->acg_sess_list)); ++ BUG_ON(!list_empty(&acg->acg_dev_list)); ++ BUG_ON(!list_empty(&acg->acn_list)); ++ ++ kfree(acg->acg_name); ++ kfree(acg); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++struct scst_acg *scst_tgt_find_acg(struct scst_tgt *tgt, const char *name) ++{ ++ struct scst_acg *acg, *acg_ret = NULL; ++ ++ TRACE_ENTRY(); ++ ++ list_for_each_entry(acg, &tgt->tgt_acg_list, acg_list_entry) { ++ if (strcmp(acg->acg_name, name) == 0) { ++ acg_ret = acg; ++ break; ++ } ++ } ++ ++ TRACE_EXIT(); ++ return acg_ret; ++} ++ ++/* scst_mutex supposed to be held */ ++static struct scst_tgt_dev *scst_find_shared_io_tgt_dev( ++ struct scst_tgt_dev *tgt_dev) ++{ ++ struct scst_tgt_dev *res = NULL; ++ struct scst_acg *acg = tgt_dev->acg_dev->acg; ++ struct scst_tgt_dev *t; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("tgt_dev %s (acg %p, io_grouping_type %d)", ++ tgt_dev->sess->initiator_name, acg, acg->acg_io_grouping_type); ++ ++ switch (acg->acg_io_grouping_type) { ++ case SCST_IO_GROUPING_AUTO: ++ if (tgt_dev->sess->initiator_name == NULL) ++ goto out; ++ ++ list_for_each_entry(t, &tgt_dev->dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ if ((t == tgt_dev) || ++ (t->sess->initiator_name == NULL) || ++ (t->active_cmd_threads == NULL)) ++ continue; ++ ++ TRACE_DBG("t %s", t->sess->initiator_name); ++ ++ /* We check other ACG's as well */ ++ ++ if (strcmp(t->sess->initiator_name, ++ tgt_dev->sess->initiator_name) == 0) ++ goto found; ++ } ++ break; ++ ++ case SCST_IO_GROUPING_THIS_GROUP_ONLY: ++ list_for_each_entry(t, &tgt_dev->dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ if ((t == tgt_dev) || (t->active_cmd_threads == NULL)) ++ continue; ++ ++ TRACE_DBG("t %s (acg %p)", t->sess->initiator_name, ++ t->acg_dev->acg); ++ ++ if (t->acg_dev->acg == acg) ++ goto found; ++ } ++ break; ++ ++ case SCST_IO_GROUPING_NEVER: ++ goto out; ++ ++ default: ++ list_for_each_entry(t, &tgt_dev->dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ if ((t == tgt_dev) || (t->active_cmd_threads == NULL)) ++ continue; ++ ++ TRACE_DBG("t %s (acg %p, io_grouping_type %d)", ++ t->sess->initiator_name, t->acg_dev->acg, ++ t->acg_dev->acg->acg_io_grouping_type); ++ ++ if (t->acg_dev->acg->acg_io_grouping_type == ++ acg->acg_io_grouping_type) ++ goto found; ++ } ++ break; ++ } ++ ++out: ++ TRACE_EXIT_HRES((unsigned long)res); ++ return res; ++ ++found: ++ if (t->active_cmd_threads == &scst_main_cmd_threads) { ++ res = t; ++ TRACE_MGMT_DBG("Going to share async IO context %p (res %p, " ++ "ini %s, dev %s, grouping type %d)", ++ t->aic_keeper->aic, res, t->sess->initiator_name, ++ t->dev->virt_name, ++ t->acg_dev->acg->acg_io_grouping_type); ++ } else { ++ res = t; ++ if (!*(volatile bool*)&res->active_cmd_threads->io_context_ready) { ++ TRACE_MGMT_DBG("IO context for t %p not yet " ++ "initialized, waiting...", t); ++ msleep(100); ++ goto found; ++ } ++ smp_rmb(); ++ TRACE_MGMT_DBG("Going to share IO context %p (res %p, ini %s, " ++ "dev %s, cmd_threads %p, grouping type %d)", ++ res->active_cmd_threads->io_context, res, ++ t->sess->initiator_name, t->dev->virt_name, ++ t->active_cmd_threads, ++ t->acg_dev->acg->acg_io_grouping_type); ++ } ++ goto out; ++} ++ ++enum scst_dev_type_threads_pool_type scst_parse_threads_pool_type(const char *p, ++ int len) ++{ ++ enum scst_dev_type_threads_pool_type res; ++ ++ if (strncasecmp(p, SCST_THREADS_POOL_PER_INITIATOR_STR, ++ min_t(int, strlen(SCST_THREADS_POOL_PER_INITIATOR_STR), ++ len)) == 0) ++ res = SCST_THREADS_POOL_PER_INITIATOR; ++ else if (strncasecmp(p, SCST_THREADS_POOL_SHARED_STR, ++ min_t(int, strlen(SCST_THREADS_POOL_SHARED_STR), ++ len)) == 0) ++ res = SCST_THREADS_POOL_SHARED; ++ else { ++ PRINT_ERROR("Unknown threads pool type %s", p); ++ res = SCST_THREADS_POOL_TYPE_INVALID; ++ } ++ ++ return res; ++} ++ ++static int scst_ioc_keeper_thread(void *arg) ++{ ++ struct scst_async_io_context_keeper *aic_keeper = ++ (struct scst_async_io_context_keeper *)arg; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("AIC %p keeper thread %s (PID %d) started", aic_keeper, ++ current->comm, current->pid); ++ ++ current->flags |= PF_NOFREEZE; ++ ++ BUG_ON(aic_keeper->aic != NULL); ++ ++ aic_keeper->aic = get_io_context(GFP_KERNEL, -1); ++ TRACE_MGMT_DBG("Alloced new async IO context %p (aic %p)", ++ aic_keeper->aic, aic_keeper); ++ ++ /* We have our own ref counting */ ++ put_io_context(aic_keeper->aic); ++ ++ /* We are ready */ ++ aic_keeper->aic_ready = true; ++ wake_up_all(&aic_keeper->aic_keeper_waitQ); ++ ++ wait_event_interruptible(aic_keeper->aic_keeper_waitQ, ++ kthread_should_stop()); ++ ++ TRACE_MGMT_DBG("AIC %p keeper thread %s (PID %d) finished", aic_keeper, ++ current->comm, current->pid); ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++/* scst_mutex supposed to be held */ ++int scst_tgt_dev_setup_threads(struct scst_tgt_dev *tgt_dev) ++{ ++ int res = 0; ++ struct scst_device *dev = tgt_dev->dev; ++ struct scst_async_io_context_keeper *aic_keeper; ++ ++ TRACE_ENTRY(); ++ ++ if (dev->threads_num < 0) ++ goto out; ++ ++ if (dev->threads_num == 0) { ++ struct scst_tgt_dev *shared_io_tgt_dev; ++ tgt_dev->active_cmd_threads = &scst_main_cmd_threads; ++ ++ shared_io_tgt_dev = scst_find_shared_io_tgt_dev(tgt_dev); ++ if (shared_io_tgt_dev != NULL) { ++ aic_keeper = shared_io_tgt_dev->aic_keeper; ++ kref_get(&aic_keeper->aic_keeper_kref); ++ ++ TRACE_MGMT_DBG("Linking async io context %p " ++ "for shared tgt_dev %p (dev %s)", ++ aic_keeper->aic, tgt_dev, ++ tgt_dev->dev->virt_name); ++ } else { ++ /* Create new context */ ++ aic_keeper = kzalloc(sizeof(*aic_keeper), GFP_KERNEL); ++ if (aic_keeper == NULL) { ++ PRINT_ERROR("Unable to alloc aic_keeper " ++ "(size %zd)", sizeof(*aic_keeper)); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ kref_init(&aic_keeper->aic_keeper_kref); ++ init_waitqueue_head(&aic_keeper->aic_keeper_waitQ); ++ ++ aic_keeper->aic_keeper_thr = ++ kthread_run(scst_ioc_keeper_thread, ++ aic_keeper, "aic_keeper"); ++ if (IS_ERR(aic_keeper->aic_keeper_thr)) { ++ PRINT_ERROR("Error running ioc_keeper " ++ "thread (tgt_dev %p)", tgt_dev); ++ res = PTR_ERR(aic_keeper->aic_keeper_thr); ++ goto out_free_keeper; ++ } ++ ++ wait_event(aic_keeper->aic_keeper_waitQ, ++ aic_keeper->aic_ready); ++ ++ TRACE_MGMT_DBG("Created async io context %p " ++ "for not shared tgt_dev %p (dev %s)", ++ aic_keeper->aic, tgt_dev, ++ tgt_dev->dev->virt_name); ++ } ++ ++ tgt_dev->async_io_context = aic_keeper->aic; ++ tgt_dev->aic_keeper = aic_keeper; ++ ++ res = scst_add_threads(tgt_dev->active_cmd_threads, NULL, NULL, ++ tgt_dev->sess->tgt->tgtt->threads_num); ++ goto out; ++ } ++ ++ switch (dev->threads_pool_type) { ++ case SCST_THREADS_POOL_PER_INITIATOR: ++ { ++ struct scst_tgt_dev *shared_io_tgt_dev; ++ ++ scst_init_threads(&tgt_dev->tgt_dev_cmd_threads); ++ ++ tgt_dev->active_cmd_threads = &tgt_dev->tgt_dev_cmd_threads; ++ ++ shared_io_tgt_dev = scst_find_shared_io_tgt_dev(tgt_dev); ++ if (shared_io_tgt_dev != NULL) { ++ TRACE_MGMT_DBG("Linking io context %p for " ++ "shared tgt_dev %p (cmd_threads %p)", ++ shared_io_tgt_dev->active_cmd_threads->io_context, ++ tgt_dev, tgt_dev->active_cmd_threads); ++ /* It's ref counted via threads */ ++ tgt_dev->active_cmd_threads->io_context = ++ shared_io_tgt_dev->active_cmd_threads->io_context; ++ } ++ ++ res = scst_add_threads(tgt_dev->active_cmd_threads, NULL, ++ tgt_dev, ++ dev->threads_num + tgt_dev->sess->tgt->tgtt->threads_num); ++ if (res != 0) { ++ /* Let's clear here, because no threads could be run */ ++ tgt_dev->active_cmd_threads->io_context = NULL; ++ } ++ break; ++ } ++ case SCST_THREADS_POOL_SHARED: ++ { ++ tgt_dev->active_cmd_threads = &dev->dev_cmd_threads; ++ ++ res = scst_add_threads(tgt_dev->active_cmd_threads, dev, NULL, ++ tgt_dev->sess->tgt->tgtt->threads_num); ++ break; ++ } ++ default: ++ PRINT_CRIT_ERROR("Unknown threads pool type %d (dev %s)", ++ dev->threads_pool_type, dev->virt_name); ++ BUG(); ++ break; ++ } ++ ++out: ++ if (res == 0) ++ tm_dbg_init_tgt_dev(tgt_dev); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free_keeper: ++ kfree(aic_keeper); ++ goto out; ++} ++ ++static void scst_aic_keeper_release(struct kref *kref) ++{ ++ struct scst_async_io_context_keeper *aic_keeper; ++ ++ TRACE_ENTRY(); ++ ++ aic_keeper = container_of(kref, struct scst_async_io_context_keeper, ++ aic_keeper_kref); ++ ++ kthread_stop(aic_keeper->aic_keeper_thr); ++ ++ kfree(aic_keeper); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* scst_mutex supposed to be held */ ++void scst_tgt_dev_stop_threads(struct scst_tgt_dev *tgt_dev) ++{ ++ TRACE_ENTRY(); ++ ++ if (tgt_dev->dev->threads_num < 0) ++ goto out_deinit; ++ ++ if (tgt_dev->active_cmd_threads == &scst_main_cmd_threads) { ++ /* Global async threads */ ++ kref_put(&tgt_dev->aic_keeper->aic_keeper_kref, ++ scst_aic_keeper_release); ++ tgt_dev->async_io_context = NULL; ++ tgt_dev->aic_keeper = NULL; ++ } else if (tgt_dev->active_cmd_threads == &tgt_dev->dev->dev_cmd_threads) { ++ /* Per device shared threads */ ++ scst_del_threads(tgt_dev->active_cmd_threads, ++ tgt_dev->sess->tgt->tgtt->threads_num); ++ } else if (tgt_dev->active_cmd_threads == &tgt_dev->tgt_dev_cmd_threads) { ++ /* Per tgt_dev threads */ ++ scst_del_threads(tgt_dev->active_cmd_threads, -1); ++ scst_deinit_threads(&tgt_dev->tgt_dev_cmd_threads); ++ } /* else no threads (not yet initialized, e.g.) */ ++ ++out_deinit: ++ tm_dbg_deinit_tgt_dev(tgt_dev); ++ tgt_dev->active_cmd_threads = NULL; ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * scst_mutex supposed to be held, there must not be parallel activity in this ++ * session. ++ */ ++static int scst_alloc_add_tgt_dev(struct scst_session *sess, ++ struct scst_acg_dev *acg_dev, struct scst_tgt_dev **out_tgt_dev) ++{ ++ int res = 0; ++ int ini_sg, ini_unchecked_isa_dma, ini_use_clustering; ++ struct scst_tgt_dev *tgt_dev; ++ struct scst_device *dev = acg_dev->dev; ++ struct list_head *head; ++ int sl; ++ uint8_t sense_buffer[SCST_STANDARD_SENSE_LEN]; ++ ++ TRACE_ENTRY(); ++ ++ tgt_dev = kmem_cache_zalloc(scst_tgtd_cachep, GFP_KERNEL); ++ if (tgt_dev == NULL) { ++ PRINT_ERROR("%s", "Allocation of scst_tgt_dev failed"); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ tgt_dev->dev = dev; ++ tgt_dev->lun = acg_dev->lun; ++ tgt_dev->acg_dev = acg_dev; ++ tgt_dev->sess = sess; ++ atomic_set(&tgt_dev->tgt_dev_cmd_count, 0); ++ ++ scst_sgv_pool_use_norm(tgt_dev); ++ ++ if (dev->scsi_dev != NULL) { ++ ini_sg = dev->scsi_dev->host->sg_tablesize; ++ ini_unchecked_isa_dma = dev->scsi_dev->host->unchecked_isa_dma; ++ ini_use_clustering = (dev->scsi_dev->host->use_clustering == ++ ENABLE_CLUSTERING); ++ } else { ++ ini_sg = (1 << 15) /* infinite */; ++ ini_unchecked_isa_dma = 0; ++ ini_use_clustering = 0; ++ } ++ tgt_dev->max_sg_cnt = min(ini_sg, sess->tgt->sg_tablesize); ++ ++ if ((sess->tgt->tgtt->use_clustering || ini_use_clustering) && ++ !sess->tgt->tgtt->no_clustering) ++ scst_sgv_pool_use_norm_clust(tgt_dev); ++ ++ if (sess->tgt->tgtt->unchecked_isa_dma || ini_unchecked_isa_dma) ++ scst_sgv_pool_use_dma(tgt_dev); ++ ++ TRACE_MGMT_DBG("Device %s on SCST lun=%lld", ++ dev->virt_name, (long long unsigned int)tgt_dev->lun); ++ ++ spin_lock_init(&tgt_dev->tgt_dev_lock); ++ INIT_LIST_HEAD(&tgt_dev->UA_list); ++ spin_lock_init(&tgt_dev->thr_data_lock); ++ INIT_LIST_HEAD(&tgt_dev->thr_data_list); ++ ++ scst_init_order_data(&tgt_dev->tgt_dev_order_data); ++ if (dev->tst == SCST_CONTR_MODE_SEP_TASK_SETS) ++ tgt_dev->curr_order_data = &tgt_dev->tgt_dev_order_data; ++ else ++ tgt_dev->curr_order_data = &dev->dev_order_data; ++ ++ if (dev->handler->parse_atomic && ++ dev->handler->alloc_data_buf_atomic && ++ (sess->tgt->tgtt->preprocessing_done == NULL)) { ++ if (sess->tgt->tgtt->rdy_to_xfer_atomic) ++ __set_bit(SCST_TGT_DEV_AFTER_INIT_WR_ATOMIC, ++ &tgt_dev->tgt_dev_flags); ++ } ++ if (dev->handler->dev_done_atomic && ++ sess->tgt->tgtt->xmit_response_atomic) { ++ __set_bit(SCST_TGT_DEV_AFTER_EXEC_ATOMIC, ++ &tgt_dev->tgt_dev_flags); ++ } ++ ++ sl = scst_set_sense(sense_buffer, sizeof(sense_buffer), ++ dev->d_sense, SCST_LOAD_SENSE(scst_sense_reset_UA)); ++ scst_alloc_set_UA(tgt_dev, sense_buffer, sl, 0); ++ ++ if (sess->tgt->tgtt->get_initiator_port_transport_id == NULL) { ++ if (!list_empty(&dev->dev_registrants_list)) { ++ PRINT_WARNING("Initiators from target %s can't connect " ++ "to device %s, because the device has PR " ++ "registrants and the target doesn't support " ++ "Persistent Reservations", sess->tgt->tgtt->name, ++ dev->virt_name); ++ res = -EPERM; ++ goto out_free; ++ } ++ dev->not_pr_supporting_tgt_devs_num++; ++ } ++ ++ res = scst_pr_init_tgt_dev(tgt_dev); ++ if (res != 0) ++ goto out_dec_free; ++ ++ res = scst_tgt_dev_setup_threads(tgt_dev); ++ if (res != 0) ++ goto out_pr_clear; ++ ++ if (dev->handler && dev->handler->attach_tgt) { ++ TRACE_DBG("Calling dev handler's attach_tgt(%p)", tgt_dev); ++ res = dev->handler->attach_tgt(tgt_dev); ++ TRACE_DBG("%s", "Dev handler's attach_tgt() returned"); ++ if (res != 0) { ++ PRINT_ERROR("Device handler's %s attach_tgt() " ++ "failed: %d", dev->handler->name, res); ++ goto out_stop_threads; ++ } ++ } ++ ++ res = scst_tgt_dev_sysfs_create(tgt_dev); ++ if (res != 0) ++ goto out_detach; ++ ++ spin_lock_bh(&dev->dev_lock); ++ list_add_tail(&tgt_dev->dev_tgt_dev_list_entry, &dev->dev_tgt_dev_list); ++ if (dev->dev_reserved) ++ __set_bit(SCST_TGT_DEV_RESERVED, &tgt_dev->tgt_dev_flags); ++ spin_unlock_bh(&dev->dev_lock); ++ ++ head = &sess->sess_tgt_dev_list[SESS_TGT_DEV_LIST_HASH_FN(tgt_dev->lun)]; ++ list_add_tail(&tgt_dev->sess_tgt_dev_list_entry, head); ++ ++ *out_tgt_dev = tgt_dev; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_detach: ++ if (dev->handler && dev->handler->detach_tgt) { ++ TRACE_DBG("Calling dev handler's detach_tgt(%p)", ++ tgt_dev); ++ dev->handler->detach_tgt(tgt_dev); ++ TRACE_DBG("%s", "Dev handler's detach_tgt() returned"); ++ } ++ ++out_stop_threads: ++ scst_tgt_dev_stop_threads(tgt_dev); ++ ++out_pr_clear: ++ scst_pr_clear_tgt_dev(tgt_dev); ++ ++out_dec_free: ++ if (tgt_dev->sess->tgt->tgtt->get_initiator_port_transport_id == NULL) ++ dev->not_pr_supporting_tgt_devs_num--; ++ ++out_free: ++ scst_free_all_UA(tgt_dev); ++ kmem_cache_free(scst_tgtd_cachep, tgt_dev); ++ goto out; ++} ++ ++/* No locks supposed to be held, scst_mutex - held */ ++void scst_nexus_loss(struct scst_tgt_dev *tgt_dev, bool queue_UA) ++{ ++ TRACE_ENTRY(); ++ ++ scst_clear_reservation(tgt_dev); ++ ++#if 0 /* Clearing UAs and last sense isn't required by SAM and it looks to be ++ * better to not clear them to not loose important events, so let's ++ * disable it. ++ */ ++ /* With activity suspended the lock isn't needed, but let's be safe */ ++ spin_lock_bh(&tgt_dev->tgt_dev_lock); ++ scst_free_all_UA(tgt_dev); ++ memset(tgt_dev->tgt_dev_sense, 0, sizeof(tgt_dev->tgt_dev_sense)); ++ spin_unlock_bh(&tgt_dev->tgt_dev_lock); ++#endif ++ ++ if (queue_UA) { ++ uint8_t sense_buffer[SCST_STANDARD_SENSE_LEN]; ++ int sl = scst_set_sense(sense_buffer, sizeof(sense_buffer), ++ tgt_dev->dev->d_sense, ++ SCST_LOAD_SENSE(scst_sense_nexus_loss_UA)); ++ scst_check_set_UA(tgt_dev, sense_buffer, sl, 0); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * scst_mutex supposed to be held, there must not be parallel activity in this ++ * session. ++ */ ++static void scst_free_tgt_dev(struct scst_tgt_dev *tgt_dev) ++{ ++ struct scst_device *dev = tgt_dev->dev; ++ ++ TRACE_ENTRY(); ++ ++ spin_lock_bh(&dev->dev_lock); ++ list_del(&tgt_dev->dev_tgt_dev_list_entry); ++ spin_unlock_bh(&dev->dev_lock); ++ ++ list_del(&tgt_dev->sess_tgt_dev_list_entry); ++ ++ scst_tgt_dev_sysfs_del(tgt_dev); ++ ++ if (tgt_dev->sess->tgt->tgtt->get_initiator_port_transport_id == NULL) ++ dev->not_pr_supporting_tgt_devs_num--; ++ ++ scst_clear_reservation(tgt_dev); ++ scst_pr_clear_tgt_dev(tgt_dev); ++ scst_free_all_UA(tgt_dev); ++ ++ if (dev->handler && dev->handler->detach_tgt) { ++ TRACE_DBG("Calling dev handler's detach_tgt(%p)", ++ tgt_dev); ++ dev->handler->detach_tgt(tgt_dev); ++ TRACE_DBG("%s", "Dev handler's detach_tgt() returned"); ++ } ++ ++ scst_tgt_dev_stop_threads(tgt_dev); ++ ++ BUG_ON(!list_empty(&tgt_dev->thr_data_list)); ++ ++ kmem_cache_free(scst_tgtd_cachep, tgt_dev); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* scst_mutex supposed to be held */ ++int scst_sess_alloc_tgt_devs(struct scst_session *sess) ++{ ++ int res = 0; ++ struct scst_acg_dev *acg_dev; ++ struct scst_tgt_dev *tgt_dev; ++ ++ TRACE_ENTRY(); ++ ++ list_for_each_entry(acg_dev, &sess->acg->acg_dev_list, ++ acg_dev_list_entry) { ++ res = scst_alloc_add_tgt_dev(sess, acg_dev, &tgt_dev); ++ if (res == -EPERM) ++ continue; ++ else if (res != 0) ++ goto out_free; ++ } ++ ++out: ++ TRACE_EXIT(); ++ return res; ++ ++out_free: ++ scst_sess_free_tgt_devs(sess); ++ goto out; ++} ++ ++/* ++ * scst_mutex supposed to be held, there must not be parallel activity in this ++ * session. ++ */ ++void scst_sess_free_tgt_devs(struct scst_session *sess) ++{ ++ int i; ++ struct scst_tgt_dev *tgt_dev, *t; ++ ++ TRACE_ENTRY(); ++ ++ /* The session is going down, no users, so no locks */ ++ for (i = 0; i < SESS_TGT_DEV_LIST_HASH_SIZE; i++) { ++ struct list_head *head = &sess->sess_tgt_dev_list[i]; ++ list_for_each_entry_safe(tgt_dev, t, head, ++ sess_tgt_dev_list_entry) { ++ scst_free_tgt_dev(tgt_dev); ++ } ++ INIT_LIST_HEAD(head); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++int scst_acg_add_acn(struct scst_acg *acg, const char *name) ++{ ++ int res = 0; ++ struct scst_acn *acn; ++ char *nm; ++ ++ TRACE_ENTRY(); ++ ++ list_for_each_entry(acn, &acg->acn_list, acn_list_entry) { ++ if (strcmp(acn->name, name) == 0) { ++ PRINT_ERROR("Name %s already exists in group %s", ++ name, acg->acg_name); ++ res = -EEXIST; ++ goto out; ++ } ++ } ++ ++ acn = kzalloc(sizeof(*acn), GFP_KERNEL); ++ if (acn == NULL) { ++ PRINT_ERROR("%s", "Unable to allocate scst_acn"); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ acn->acg = acg; ++ ++ nm = kstrdup(name, GFP_KERNEL); ++ if (nm == NULL) { ++ PRINT_ERROR("%s", "Unable to allocate scst_acn->name"); ++ res = -ENOMEM; ++ goto out_free; ++ } ++ acn->name = nm; ++ ++ res = scst_acn_sysfs_create(acn); ++ if (res != 0) ++ goto out_free_nm; ++ ++ list_add_tail(&acn->acn_list_entry, &acg->acn_list); ++ ++out: ++ if (res == 0) { ++ PRINT_INFO("Added name %s to group %s", name, acg->acg_name); ++ scst_check_reassign_sessions(); ++ } ++ ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free_nm: ++ kfree(nm); ++ ++out_free: ++ kfree(acn); ++ goto out; ++} ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++void scst_del_free_acn(struct scst_acn *acn, bool reassign) ++{ ++ TRACE_ENTRY(); ++ ++ list_del(&acn->acn_list_entry); ++ ++ scst_acn_sysfs_del(acn); ++ ++ kfree(acn->name); ++ kfree(acn); ++ ++ if (reassign) ++ scst_check_reassign_sessions(); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++struct scst_acn *scst_find_acn(struct scst_acg *acg, const char *name) ++{ ++ struct scst_acn *acn; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Trying to find name '%s'", name); ++ ++ list_for_each_entry(acn, &acg->acn_list, acn_list_entry) { ++ if (strcmp(acn->name, name) == 0) { ++ TRACE_DBG("%s", "Found"); ++ goto out; ++ } ++ } ++ acn = NULL; ++out: ++ TRACE_EXIT(); ++ return acn; ++} ++ ++static struct scst_cmd *scst_create_prepare_internal_cmd( ++ struct scst_cmd *orig_cmd, const uint8_t *cdb, ++ unsigned int cdb_len, int bufsize) ++{ ++ struct scst_cmd *res; ++ int rc; ++ gfp_t gfp_mask = scst_cmd_atomic(orig_cmd) ? GFP_ATOMIC : GFP_KERNEL; ++ ++ TRACE_ENTRY(); ++ ++ res = scst_alloc_cmd(cdb, cdb_len, gfp_mask); ++ if (res == NULL) ++ goto out; ++ ++ res->cmd_threads = orig_cmd->cmd_threads; ++ res->sess = orig_cmd->sess; ++ res->atomic = scst_cmd_atomic(orig_cmd); ++ res->internal = 1; ++ res->tgtt = orig_cmd->tgtt; ++ res->tgt = orig_cmd->tgt; ++ res->dev = orig_cmd->dev; ++ res->tgt_dev = orig_cmd->tgt_dev; ++ res->cur_order_data = orig_cmd->tgt_dev->curr_order_data; ++ res->lun = orig_cmd->lun; ++ res->queue_type = SCST_CMD_QUEUE_HEAD_OF_QUEUE; ++ res->data_direction = SCST_DATA_UNKNOWN; ++ res->orig_cmd = orig_cmd; ++ res->bufflen = bufsize; ++ ++ scst_sess_get(res->sess); ++ if (res->tgt_dev != NULL) ++ res->cpu_cmd_counter = scst_get(); ++ ++ rc = scst_pre_parse(res); ++ BUG_ON(rc != 0); ++ ++ res->state = SCST_CMD_STATE_PARSE; ++ ++out: ++ TRACE_EXIT_HRES((unsigned long)res); ++ return res; ++} ++ ++int scst_prepare_request_sense(struct scst_cmd *orig_cmd) ++{ ++ int res = 0; ++ static const uint8_t request_sense[6] = { ++ REQUEST_SENSE, 0, 0, 0, SCST_SENSE_BUFFERSIZE, 0 ++ }; ++ struct scst_cmd *rs_cmd; ++ ++ TRACE_ENTRY(); ++ ++ if (orig_cmd->sense != NULL) { ++ TRACE_MEM("Releasing sense %p (orig_cmd %p)", ++ orig_cmd->sense, orig_cmd); ++ mempool_free(orig_cmd->sense, scst_sense_mempool); ++ orig_cmd->sense = NULL; ++ } ++ ++ rs_cmd = scst_create_prepare_internal_cmd(orig_cmd, ++ request_sense, sizeof(request_sense), ++ SCST_SENSE_BUFFERSIZE); ++ if (rs_cmd == NULL) ++ goto out_error; ++ ++ rs_cmd->cdb[1] |= scst_get_cmd_dev_d_sense(orig_cmd); ++ rs_cmd->data_direction = SCST_DATA_READ; ++ rs_cmd->expected_data_direction = rs_cmd->data_direction; ++ rs_cmd->expected_transfer_len = SCST_SENSE_BUFFERSIZE; ++ rs_cmd->expected_values_set = 1; ++ ++ TRACE_MGMT_DBG("Adding REQUEST SENSE cmd %p to head of active " ++ "cmd list", rs_cmd); ++ spin_lock_irq(&rs_cmd->cmd_threads->cmd_list_lock); ++ list_add(&rs_cmd->cmd_list_entry, &rs_cmd->cmd_threads->active_cmd_list); ++ wake_up(&rs_cmd->cmd_threads->cmd_list_waitQ); ++ spin_unlock_irq(&rs_cmd->cmd_threads->cmd_list_lock); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_error: ++ res = -1; ++ goto out; ++} ++ ++static void scst_complete_request_sense(struct scst_cmd *req_cmd) ++{ ++ struct scst_cmd *orig_cmd = req_cmd->orig_cmd; ++ uint8_t *buf; ++ int len; ++ ++ TRACE_ENTRY(); ++ ++ BUG_ON(orig_cmd == NULL); ++ ++ len = scst_get_buf_full(req_cmd, &buf); ++ ++ if (scsi_status_is_good(req_cmd->status) && (len > 0) && ++ SCST_SENSE_VALID(buf) && (!SCST_NO_SENSE(buf))) { ++ PRINT_BUFF_FLAG(TRACE_SCSI, "REQUEST SENSE returned", ++ buf, len); ++ scst_alloc_set_sense(orig_cmd, scst_cmd_atomic(req_cmd), buf, ++ len); ++ } else { ++ PRINT_ERROR("%s", "Unable to get the sense via " ++ "REQUEST SENSE, returning HARDWARE ERROR"); ++ scst_set_cmd_error(orig_cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ } ++ ++ if (len > 0) ++ scst_put_buf_full(req_cmd, buf); ++ ++ TRACE_MGMT_DBG("Adding orig cmd %p to head of active " ++ "cmd list", orig_cmd); ++ spin_lock_irq(&orig_cmd->cmd_threads->cmd_list_lock); ++ list_add(&orig_cmd->cmd_list_entry, &orig_cmd->cmd_threads->active_cmd_list); ++ wake_up(&orig_cmd->cmd_threads->cmd_list_waitQ); ++ spin_unlock_irq(&orig_cmd->cmd_threads->cmd_list_lock); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++int scst_finish_internal_cmd(struct scst_cmd *cmd) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ BUG_ON(!cmd->internal); ++ ++ if (cmd->cdb[0] == REQUEST_SENSE) ++ scst_complete_request_sense(cmd); ++ ++ __scst_cmd_put(cmd); ++ ++ res = SCST_CMD_STATE_RES_CONT_NEXT; ++ ++ TRACE_EXIT_HRES(res); ++ return res; ++} ++ ++static void scst_send_release(struct scst_device *dev) ++{ ++ struct scsi_device *scsi_dev; ++ unsigned char cdb[6]; ++ uint8_t sense[SCSI_SENSE_BUFFERSIZE]; ++ int rc, i; ++ ++ TRACE_ENTRY(); ++ ++ if (dev->scsi_dev == NULL) ++ goto out; ++ ++ scsi_dev = dev->scsi_dev; ++ ++ for (i = 0; i < 5; i++) { ++ memset(cdb, 0, sizeof(cdb)); ++ cdb[0] = RELEASE; ++ cdb[1] = (scsi_dev->scsi_level <= SCSI_2) ? ++ ((scsi_dev->lun << 5) & 0xe0) : 0; ++ ++ memset(sense, 0, sizeof(sense)); ++ ++ TRACE(TRACE_DEBUG | TRACE_SCSI, "%s", "Sending RELEASE req to " ++ "SCSI mid-level"); ++ rc = scsi_execute(scsi_dev, cdb, SCST_DATA_NONE, NULL, 0, ++ sense, 15, 0, 0 ++ , NULL ++ ); ++ TRACE_DBG("MODE_SENSE done: %x", rc); ++ ++ if (scsi_status_is_good(rc)) { ++ break; ++ } else { ++ PRINT_ERROR("RELEASE failed: %d", rc); ++ PRINT_BUFFER("RELEASE sense", sense, sizeof(sense)); ++ scst_check_internal_sense(dev, rc, sense, ++ sizeof(sense)); ++ } ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* scst_mutex supposed to be held */ ++static void scst_clear_reservation(struct scst_tgt_dev *tgt_dev) ++{ ++ struct scst_device *dev = tgt_dev->dev; ++ int release = 0; ++ ++ TRACE_ENTRY(); ++ ++ spin_lock_bh(&dev->dev_lock); ++ if (dev->dev_reserved && ++ !test_bit(SCST_TGT_DEV_RESERVED, &tgt_dev->tgt_dev_flags)) { ++ /* This is one who holds the reservation */ ++ struct scst_tgt_dev *tgt_dev_tmp; ++ list_for_each_entry(tgt_dev_tmp, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ clear_bit(SCST_TGT_DEV_RESERVED, ++ &tgt_dev_tmp->tgt_dev_flags); ++ } ++ dev->dev_reserved = 0; ++ release = 1; ++ } ++ spin_unlock_bh(&dev->dev_lock); ++ ++ if (release) ++ scst_send_release(dev); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++struct scst_session *scst_alloc_session(struct scst_tgt *tgt, gfp_t gfp_mask, ++ const char *initiator_name) ++{ ++ struct scst_session *sess; ++ int i; ++ ++ TRACE_ENTRY(); ++ ++ sess = kmem_cache_zalloc(scst_sess_cachep, gfp_mask); ++ if (sess == NULL) { ++ PRINT_ERROR("%s", "Allocation of scst_session failed"); ++ goto out; ++ } ++ ++ sess->init_phase = SCST_SESS_IPH_INITING; ++ sess->shut_phase = SCST_SESS_SPH_READY; ++ atomic_set(&sess->refcnt, 0); ++ for (i = 0; i < SESS_TGT_DEV_LIST_HASH_SIZE; i++) { ++ struct list_head *head = &sess->sess_tgt_dev_list[i]; ++ INIT_LIST_HEAD(head); ++ } ++ spin_lock_init(&sess->sess_list_lock); ++ INIT_LIST_HEAD(&sess->sess_cmd_list); ++ sess->tgt = tgt; ++ INIT_LIST_HEAD(&sess->init_deferred_cmd_list); ++ INIT_LIST_HEAD(&sess->init_deferred_mcmd_list); ++ INIT_DELAYED_WORK(&sess->hw_pending_work, ++ (void (*)(struct work_struct *))scst_hw_pending_work_fn); ++ ++#ifdef CONFIG_SCST_MEASURE_LATENCY ++ spin_lock_init(&sess->lat_lock); ++#endif ++ ++ sess->initiator_name = kstrdup(initiator_name, gfp_mask); ++ if (sess->initiator_name == NULL) { ++ PRINT_ERROR("%s", "Unable to dup sess->initiator_name"); ++ goto out_free; ++ } ++ ++out: ++ TRACE_EXIT(); ++ return sess; ++ ++out_free: ++ kmem_cache_free(scst_sess_cachep, sess); ++ sess = NULL; ++ goto out; ++} ++ ++void scst_free_session(struct scst_session *sess) ++{ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_mutex); ++ ++ scst_sess_free_tgt_devs(sess); ++ ++ mutex_unlock(&scst_mutex); ++ ++ scst_sess_sysfs_del(sess); ++ if (sess->unreg_done_fn) { ++ TRACE_DBG("Calling unreg_done_fn(%p)", sess); ++ sess->unreg_done_fn(sess); ++ TRACE_DBG("%s", "unreg_done_fn() returned"); ++ } ++ ++ mutex_lock(&scst_mutex); ++ ++ /* ++ * The lists delete must be after sysfs del. Otherwise it would break ++ * logic in scst_sess_sysfs_create() to avoid duplicate sysfs names. ++ */ ++ ++ TRACE_DBG("Removing sess %p from the list", sess); ++ list_del(&sess->sess_list_entry); ++ TRACE_DBG("Removing session %p from acg %s", sess, sess->acg->acg_name); ++ list_del(&sess->acg_sess_list_entry); ++ ++ /* Called under lock to protect from too early tgt release */ ++ wake_up_all(&sess->tgt->unreg_waitQ); ++ ++ /* ++ * NOTE: do not dereference the sess->tgt pointer after scst_mutex ++ * has been unlocked, because it can be already dead!! ++ */ ++ mutex_unlock(&scst_mutex); ++ ++ kfree(sess->transport_id); ++ kfree(sess->initiator_name); ++ ++ kmem_cache_free(scst_sess_cachep, sess); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++void scst_free_session_callback(struct scst_session *sess) ++{ ++ struct completion *c; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Freeing session %p", sess); ++ ++ cancel_delayed_work_sync(&sess->hw_pending_work); ++ ++ c = sess->shutdown_compl; ++ ++ mutex_lock(&scst_mutex); ++ /* ++ * Necessary to sync with other threads trying to queue AEN, which ++ * the target driver will not be able to serve and crash, because after ++ * unreg_done_fn() called its internal session data will be destroyed. ++ */ ++ sess->shut_phase = SCST_SESS_SPH_UNREG_DONE_CALLING; ++ mutex_unlock(&scst_mutex); ++ ++ scst_free_session(sess); ++ ++ if (c) ++ complete_all(c); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++void scst_sched_session_free(struct scst_session *sess) ++{ ++ unsigned long flags; ++ ++ TRACE_ENTRY(); ++ ++ if (sess->shut_phase != SCST_SESS_SPH_SHUTDOWN) { ++ PRINT_CRIT_ERROR("session %p is going to shutdown with unknown " ++ "shut phase %lx", sess, sess->shut_phase); ++ BUG(); ++ } ++ ++ spin_lock_irqsave(&scst_mgmt_lock, flags); ++ TRACE_DBG("Adding sess %p to scst_sess_shut_list", sess); ++ list_add_tail(&sess->sess_shut_list_entry, &scst_sess_shut_list); ++ spin_unlock_irqrestore(&scst_mgmt_lock, flags); ++ ++ wake_up(&scst_mgmt_waitQ); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ * scst_cmd_get() - increase command's reference counter ++ */ ++void scst_cmd_get(struct scst_cmd *cmd) ++{ ++ __scst_cmd_get(cmd); ++} ++EXPORT_SYMBOL(scst_cmd_get); ++ ++/** ++ * scst_cmd_put() - decrease command's reference counter ++ */ ++void scst_cmd_put(struct scst_cmd *cmd) ++{ ++ __scst_cmd_put(cmd); ++} ++EXPORT_SYMBOL(scst_cmd_put); ++ ++/** ++ * scst_cmd_set_ext_cdb() - sets cmd's extended CDB and its length ++ */ ++void scst_cmd_set_ext_cdb(struct scst_cmd *cmd, ++ uint8_t *ext_cdb, unsigned int ext_cdb_len, ++ gfp_t gfp_mask) ++{ ++ unsigned int len = cmd->cdb_len + ext_cdb_len; ++ ++ TRACE_ENTRY(); ++ ++ if (len <= sizeof(cmd->cdb_buf)) ++ goto copy; ++ ++ if (unlikely(len > SCST_MAX_LONG_CDB_SIZE)) { ++ PRINT_ERROR("Too big CDB (%d)", len); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out; ++ } ++ ++ cmd->cdb = kmalloc(len, gfp_mask); ++ if (unlikely(cmd->cdb == NULL)) { ++ PRINT_ERROR("Unable to alloc extended CDB (size %d)", len); ++ goto out_err; ++ } ++ ++ memcpy(cmd->cdb, cmd->cdb_buf, cmd->cdb_len); ++ ++copy: ++ memcpy(&cmd->cdb[cmd->cdb_len], ext_cdb, ext_cdb_len); ++ ++ cmd->cdb_len = cmd->cdb_len + ext_cdb_len; ++ ++out: ++ TRACE_EXIT(); ++ return; ++ ++out_err: ++ cmd->cdb = cmd->cdb_buf; ++ scst_set_busy(cmd); ++ goto out; ++} ++EXPORT_SYMBOL(scst_cmd_set_ext_cdb); ++ ++struct scst_cmd *scst_alloc_cmd(const uint8_t *cdb, ++ unsigned int cdb_len, gfp_t gfp_mask) ++{ ++ struct scst_cmd *cmd; ++ ++ TRACE_ENTRY(); ++ ++ cmd = kmem_cache_zalloc(scst_cmd_cachep, gfp_mask); ++ if (cmd == NULL) { ++ TRACE(TRACE_OUT_OF_MEM, "%s", "Allocation of scst_cmd failed"); ++ goto out; ++ } ++ ++ cmd->state = SCST_CMD_STATE_INIT_WAIT; ++ cmd->start_time = jiffies; ++ atomic_set(&cmd->cmd_ref, 1); ++ cmd->cmd_threads = &scst_main_cmd_threads; ++ INIT_LIST_HEAD(&cmd->mgmt_cmd_list); ++ cmd->cdb = cmd->cdb_buf; ++ cmd->queue_type = SCST_CMD_QUEUE_SIMPLE; ++ cmd->timeout = SCST_DEFAULT_TIMEOUT; ++ cmd->retries = 0; ++ cmd->data_len = -1; ++ cmd->is_send_status = 1; ++ cmd->resp_data_len = -1; ++ cmd->write_sg = &cmd->sg; ++ cmd->write_sg_cnt = &cmd->sg_cnt; ++ ++ cmd->dbl_ua_orig_data_direction = SCST_DATA_UNKNOWN; ++ cmd->dbl_ua_orig_resp_data_len = -1; ++ ++ if (unlikely(cdb_len == 0)) { ++ PRINT_ERROR("%s", "Wrong CDB len 0, finishing cmd"); ++ goto out_free; ++ } else if (cdb_len <= SCST_MAX_CDB_SIZE) { ++ /* Duplicate memcpy to save a branch on the most common path */ ++ memcpy(cmd->cdb, cdb, cdb_len); ++ } else { ++ if (unlikely(cdb_len > SCST_MAX_LONG_CDB_SIZE)) { ++ PRINT_ERROR("Too big CDB (%d), finishing cmd", cdb_len); ++ goto out_free; ++ } ++ cmd->cdb = kmalloc(cdb_len, gfp_mask); ++ if (unlikely(cmd->cdb == NULL)) { ++ PRINT_ERROR("Unable to alloc extended CDB (size %d)", ++ cdb_len); ++ goto out_free; ++ } ++ memcpy(cmd->cdb, cdb, cdb_len); ++ } ++ ++ cmd->cdb_len = cdb_len; ++ ++out: ++ TRACE_EXIT(); ++ return cmd; ++ ++out_free: ++ kmem_cache_free(scst_cmd_cachep, cmd); ++ cmd = NULL; ++ goto out; ++} ++ ++static void scst_destroy_put_cmd(struct scst_cmd *cmd) ++{ ++ scst_sess_put(cmd->sess); ++ ++ /* ++ * At this point tgt_dev can be dead, but the pointer remains non-NULL ++ */ ++ if (likely(cmd->tgt_dev != NULL)) ++ scst_put(cmd->cpu_cmd_counter); ++ ++ scst_destroy_cmd(cmd); ++ return; ++} ++ ++/* No locks supposed to be held */ ++void scst_free_cmd(struct scst_cmd *cmd) ++{ ++ int destroy = 1; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Freeing cmd %p (tag %llu)", ++ cmd, (long long unsigned int)cmd->tag); ++ ++ if (unlikely(test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags))) ++ TRACE_MGMT_DBG("Freeing aborted cmd %p", cmd); ++ ++ EXTRACHECKS_BUG_ON(cmd->unblock_dev || cmd->dec_on_dev_needed || ++ cmd->dec_pr_readers_count_needed); ++ ++ /* ++ * Target driver can already free sg buffer before calling ++ * scst_tgt_cmd_done(). E.g., scst_local has to do that. ++ */ ++ if (!cmd->tgt_data_buf_alloced) ++ scst_check_restore_sg_buff(cmd); ++ ++ if ((cmd->tgtt->on_free_cmd != NULL) && likely(!cmd->internal)) { ++ TRACE_DBG("Calling target's on_free_cmd(%p)", cmd); ++ scst_set_cur_start(cmd); ++ cmd->tgtt->on_free_cmd(cmd); ++ scst_set_tgt_on_free_time(cmd); ++ TRACE_DBG("%s", "Target's on_free_cmd() returned"); ++ } ++ ++ if (likely(cmd->dev != NULL)) { ++ struct scst_dev_type *handler = cmd->dev->handler; ++ if (handler->on_free_cmd != NULL) { ++ TRACE_DBG("Calling dev handler %s on_free_cmd(%p)", ++ handler->name, cmd); ++ scst_set_cur_start(cmd); ++ handler->on_free_cmd(cmd); ++ scst_set_dev_on_free_time(cmd); ++ TRACE_DBG("Dev handler %s on_free_cmd() returned", ++ handler->name); ++ } ++ } ++ ++ scst_release_space(cmd); ++ ++ if (unlikely(cmd->sense != NULL)) { ++ TRACE_MEM("Releasing sense %p (cmd %p)", cmd->sense, cmd); ++ mempool_free(cmd->sense, scst_sense_mempool); ++ cmd->sense = NULL; ++ } ++ ++ if (likely(cmd->tgt_dev != NULL)) { ++#ifdef CONFIG_SCST_EXTRACHECKS ++ if (unlikely(!cmd->sent_for_exec) && !cmd->internal) { ++ PRINT_ERROR("Finishing not executed cmd %p (opcode " ++ "%d, target %s, LUN %lld, sn %d, expected_sn %d)", ++ cmd, cmd->cdb[0], cmd->tgtt->name, ++ (long long unsigned int)cmd->lun, ++ cmd->sn, cmd->cur_order_data->expected_sn); ++ scst_unblock_deferred(cmd->cur_order_data, cmd); ++ } ++#endif ++ ++ if (unlikely(cmd->out_of_sn)) { ++ TRACE_SN("Out of SN cmd %p (tag %llu, sn %d), " ++ "destroy=%d", cmd, ++ (long long unsigned int)cmd->tag, ++ cmd->sn, destroy); ++ destroy = test_and_set_bit(SCST_CMD_CAN_BE_DESTROYED, ++ &cmd->cmd_flags); ++ } ++ } ++ ++ if (cmd->cdb != cmd->cdb_buf) ++ kfree(cmd->cdb); ++ ++ if (likely(destroy)) ++ scst_destroy_put_cmd(cmd); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* No locks supposed to be held. */ ++void scst_check_retries(struct scst_tgt *tgt) ++{ ++ int need_wake_up = 0; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * We don't worry about overflow of finished_cmds, because we check ++ * only for its change. ++ */ ++ atomic_inc(&tgt->finished_cmds); ++ /* See comment in scst_queue_retry_cmd() */ ++ smp_mb__after_atomic_inc(); ++ if (unlikely(tgt->retry_cmds > 0)) { ++ struct scst_cmd *c, *tc; ++ unsigned long flags; ++ ++ TRACE_RETRY("Checking retry cmd list (retry_cmds %d)", ++ tgt->retry_cmds); ++ ++ spin_lock_irqsave(&tgt->tgt_lock, flags); ++ list_for_each_entry_safe(c, tc, &tgt->retry_cmd_list, ++ cmd_list_entry) { ++ tgt->retry_cmds--; ++ ++ TRACE_RETRY("Moving retry cmd %p to head of active " ++ "cmd list (retry_cmds left %d)", ++ c, tgt->retry_cmds); ++ spin_lock(&c->cmd_threads->cmd_list_lock); ++ list_move(&c->cmd_list_entry, ++ &c->cmd_threads->active_cmd_list); ++ wake_up(&c->cmd_threads->cmd_list_waitQ); ++ spin_unlock(&c->cmd_threads->cmd_list_lock); ++ ++ need_wake_up++; ++ if (need_wake_up >= 2) /* "slow start" */ ++ break; ++ } ++ spin_unlock_irqrestore(&tgt->tgt_lock, flags); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void scst_tgt_retry_timer_fn(unsigned long arg) ++{ ++ struct scst_tgt *tgt = (struct scst_tgt *)arg; ++ unsigned long flags; ++ ++ TRACE_RETRY("Retry timer expired (retry_cmds %d)", tgt->retry_cmds); ++ ++ spin_lock_irqsave(&tgt->tgt_lock, flags); ++ tgt->retry_timer_active = 0; ++ spin_unlock_irqrestore(&tgt->tgt_lock, flags); ++ ++ scst_check_retries(tgt); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++struct scst_mgmt_cmd *scst_alloc_mgmt_cmd(gfp_t gfp_mask) ++{ ++ struct scst_mgmt_cmd *mcmd; ++ ++ TRACE_ENTRY(); ++ ++ mcmd = mempool_alloc(scst_mgmt_mempool, gfp_mask); ++ if (mcmd == NULL) { ++ PRINT_CRIT_ERROR("%s", "Allocation of management command " ++ "failed, some commands and their data could leak"); ++ goto out; ++ } ++ memset(mcmd, 0, sizeof(*mcmd)); ++ ++out: ++ TRACE_EXIT(); ++ return mcmd; ++} ++ ++void scst_free_mgmt_cmd(struct scst_mgmt_cmd *mcmd) ++{ ++ unsigned long flags; ++ ++ TRACE_ENTRY(); ++ ++ spin_lock_irqsave(&mcmd->sess->sess_list_lock, flags); ++ atomic_dec(&mcmd->sess->sess_cmd_count); ++ spin_unlock_irqrestore(&mcmd->sess->sess_list_lock, flags); ++ ++ scst_sess_put(mcmd->sess); ++ ++ if (mcmd->mcmd_tgt_dev != NULL) ++ scst_put(mcmd->cpu_cmd_counter); ++ ++ mempool_free(mcmd, scst_mgmt_mempool); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static bool scst_on_sg_tablesize_low(struct scst_cmd *cmd, bool out) ++{ ++ bool res; ++ int sg_cnt = out ? cmd->out_sg_cnt : cmd->sg_cnt; ++ static int ll; ++ struct scst_tgt_dev *tgt_dev = cmd->tgt_dev; ++ ++ TRACE_ENTRY(); ++ ++ if (sg_cnt > cmd->tgt->sg_tablesize) { ++ /* It's the target's side business */ ++ goto failed; ++ } ++ ++ if (tgt_dev->dev->handler->on_sg_tablesize_low == NULL) ++ goto failed; ++ ++ res = tgt_dev->dev->handler->on_sg_tablesize_low(cmd); ++ ++ TRACE_DBG("on_sg_tablesize_low(%p) returned %d", cmd, res); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++failed: ++ res = false; ++ if ((ll < 10) || TRACING_MINOR()) { ++ PRINT_INFO("Unable to complete command due to SG IO count " ++ "limitation (%srequested %d, available %d, tgt lim %d)", ++ out ? "OUT buffer, " : "", cmd->sg_cnt, ++ tgt_dev->max_sg_cnt, cmd->tgt->sg_tablesize); ++ ll++; ++ } ++ goto out; ++} ++ ++int scst_alloc_space(struct scst_cmd *cmd) ++{ ++ gfp_t gfp_mask; ++ int res = -ENOMEM; ++ int atomic = scst_cmd_atomic(cmd); ++ int flags; ++ struct scst_tgt_dev *tgt_dev = cmd->tgt_dev; ++ ++ TRACE_ENTRY(); ++ ++ gfp_mask = tgt_dev->gfp_mask | (atomic ? GFP_ATOMIC : GFP_KERNEL); ++ ++ flags = atomic ? SGV_POOL_NO_ALLOC_ON_CACHE_MISS : 0; ++ if (cmd->no_sgv) ++ flags |= SGV_POOL_ALLOC_NO_CACHED; ++ ++ cmd->sg = sgv_pool_alloc(tgt_dev->pool, cmd->bufflen, gfp_mask, flags, ++ &cmd->sg_cnt, &cmd->sgv, &cmd->dev->dev_mem_lim, NULL); ++ if (cmd->sg == NULL) ++ goto out; ++ ++ if (unlikely(cmd->sg_cnt > tgt_dev->max_sg_cnt)) ++ if (!scst_on_sg_tablesize_low(cmd, false)) ++ goto out_sg_free; ++ ++ if (cmd->data_direction != SCST_DATA_BIDI) ++ goto success; ++ ++ cmd->out_sg = sgv_pool_alloc(tgt_dev->pool, cmd->out_bufflen, gfp_mask, ++ flags, &cmd->out_sg_cnt, &cmd->out_sgv, ++ &cmd->dev->dev_mem_lim, NULL); ++ if (cmd->out_sg == NULL) ++ goto out_sg_free; ++ ++ if (unlikely(cmd->out_sg_cnt > tgt_dev->max_sg_cnt)) ++ if (!scst_on_sg_tablesize_low(cmd, true)) ++ goto out_out_sg_free; ++ ++success: ++ res = 0; ++ ++out: ++ TRACE_EXIT(); ++ return res; ++ ++out_out_sg_free: ++ sgv_pool_free(cmd->out_sgv, &cmd->dev->dev_mem_lim); ++ cmd->out_sgv = NULL; ++ cmd->out_sg = NULL; ++ cmd->out_sg_cnt = 0; ++ ++out_sg_free: ++ sgv_pool_free(cmd->sgv, &cmd->dev->dev_mem_lim); ++ cmd->sgv = NULL; ++ cmd->sg = NULL; ++ cmd->sg_cnt = 0; ++ goto out; ++} ++ ++static void scst_release_space(struct scst_cmd *cmd) ++{ ++ TRACE_ENTRY(); ++ ++ if (cmd->sgv == NULL) { ++ if ((cmd->sg != NULL) && ++ !(cmd->tgt_data_buf_alloced || cmd->dh_data_buf_alloced)) { ++ TRACE_MEM("Freeing sg %p for cmd %p (cnt %d)", cmd->sg, ++ cmd, cmd->sg_cnt); ++ scst_free(cmd->sg, cmd->sg_cnt); ++ goto out_zero; ++ } else ++ goto out; ++ } ++ ++ if (cmd->tgt_data_buf_alloced || cmd->dh_data_buf_alloced) { ++ TRACE_MEM("%s", "*data_buf_alloced set, returning"); ++ goto out; ++ } ++ ++ if (cmd->out_sgv != NULL) { ++ sgv_pool_free(cmd->out_sgv, &cmd->dev->dev_mem_lim); ++ cmd->out_sgv = NULL; ++ cmd->out_sg_cnt = 0; ++ cmd->out_sg = NULL; ++ cmd->out_bufflen = 0; ++ } ++ ++ sgv_pool_free(cmd->sgv, &cmd->dev->dev_mem_lim); ++ ++out_zero: ++ cmd->sgv = NULL; ++ cmd->sg_cnt = 0; ++ cmd->sg = NULL; ++ cmd->bufflen = 0; ++ cmd->data_len = 0; ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static void scsi_end_async(struct request *req, int error) ++{ ++ struct scsi_io_context *sioc = req->end_io_data; ++ ++ TRACE_DBG("sioc %p, cmd %p", sioc, sioc->data); ++ ++ if (sioc->done) ++ sioc->done(sioc->data, sioc->sense, req->errors, req->resid_len); ++ ++ kmem_cache_free(scsi_io_context_cache, sioc); ++ ++ __blk_put_request(req->q, req); ++ return; ++} ++ ++/** ++ * scst_scsi_exec_async - executes a SCSI command in pass-through mode ++ * @cmd: scst command ++ * @data: pointer passed to done() as "data" ++ * @done: callback function when done ++ */ ++int scst_scsi_exec_async(struct scst_cmd *cmd, void *data, ++ void (*done)(void *data, char *sense, int result, int resid)) ++{ ++ int res = 0; ++ struct request_queue *q = cmd->dev->scsi_dev->request_queue; ++ struct request *rq; ++ struct scsi_io_context *sioc; ++ int write = (cmd->data_direction & SCST_DATA_WRITE) ? WRITE : READ; ++ gfp_t gfp = cmd->noio_mem_alloc ? GFP_NOIO : GFP_KERNEL; ++ int cmd_len = cmd->cdb_len; ++ ++ sioc = kmem_cache_zalloc(scsi_io_context_cache, gfp); ++ if (sioc == NULL) { ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ rq = blk_get_request(q, write, gfp); ++ if (rq == NULL) { ++ res = -ENOMEM; ++ goto out_free_sioc; ++ } ++ ++ rq->cmd_type = REQ_TYPE_BLOCK_PC; ++ rq->cmd_flags |= REQ_QUIET; ++ ++ if (cmd->sg == NULL) ++ goto done; ++ ++ if (cmd->data_direction == SCST_DATA_BIDI) { ++ struct request *next_rq; ++ ++ if (!test_bit(QUEUE_FLAG_BIDI, &q->queue_flags)) { ++ res = -EOPNOTSUPP; ++ goto out_free_rq; ++ } ++ ++ res = blk_rq_map_kern_sg(rq, cmd->out_sg, cmd->out_sg_cnt, gfp); ++ if (res != 0) { ++ TRACE_DBG("blk_rq_map_kern_sg() failed: %d", res); ++ goto out_free_rq; ++ } ++ ++ next_rq = blk_get_request(q, READ, gfp); ++ if (next_rq == NULL) { ++ res = -ENOMEM; ++ goto out_free_unmap; ++ } ++ rq->next_rq = next_rq; ++ next_rq->cmd_type = rq->cmd_type; ++ ++ res = blk_rq_map_kern_sg(next_rq, cmd->sg, cmd->sg_cnt, gfp); ++ if (res != 0) { ++ TRACE_DBG("blk_rq_map_kern_sg() failed: %d", res); ++ goto out_free_unmap; ++ } ++ } else { ++ res = blk_rq_map_kern_sg(rq, cmd->sg, cmd->sg_cnt, gfp); ++ if (res != 0) { ++ TRACE_DBG("blk_rq_map_kern_sg() failed: %d", res); ++ goto out_free_rq; ++ } ++ } ++ ++done: ++ TRACE_DBG("sioc %p, cmd %p", sioc, cmd); ++ ++ sioc->data = data; ++ sioc->done = done; ++ ++ rq->cmd_len = cmd_len; ++ if (rq->cmd_len <= BLK_MAX_CDB) { ++ memset(rq->cmd, 0, BLK_MAX_CDB); /* ATAPI hates garbage after CDB */ ++ memcpy(rq->cmd, cmd->cdb, cmd->cdb_len); ++ } else ++ rq->cmd = cmd->cdb; ++ ++ rq->sense = sioc->sense; ++ rq->sense_len = sizeof(sioc->sense); ++ rq->timeout = cmd->timeout; ++ rq->retries = cmd->retries; ++ rq->end_io_data = sioc; ++ ++ blk_execute_rq_nowait(rq->q, NULL, rq, ++ (cmd->queue_type == SCST_CMD_QUEUE_HEAD_OF_QUEUE), scsi_end_async); ++out: ++ return res; ++ ++out_free_unmap: ++ if (rq->next_rq != NULL) { ++ blk_put_request(rq->next_rq); ++ rq->next_rq = NULL; ++ } ++ blk_rq_unmap_kern_sg(rq, res); ++ ++out_free_rq: ++ blk_put_request(rq); ++ ++out_free_sioc: ++ kmem_cache_free(scsi_io_context_cache, sioc); ++ goto out; ++} ++EXPORT_SYMBOL(scst_scsi_exec_async); ++ ++/** ++ * scst_copy_sg() - copy data between the command's SGs ++ * ++ * Copies data between cmd->tgt_sg and cmd->sg in direction defined by ++ * copy_dir parameter. ++ */ ++void scst_copy_sg(struct scst_cmd *cmd, enum scst_sg_copy_dir copy_dir) ++{ ++ struct scatterlist *src_sg, *dst_sg; ++ unsigned int to_copy; ++ int atomic = scst_cmd_atomic(cmd); ++ ++ TRACE_ENTRY(); ++ ++ if (copy_dir == SCST_SG_COPY_FROM_TARGET) { ++ if (cmd->data_direction != SCST_DATA_BIDI) { ++ src_sg = cmd->tgt_sg; ++ dst_sg = cmd->sg; ++ to_copy = cmd->bufflen; ++ } else { ++ TRACE_MEM("BIDI cmd %p", cmd); ++ src_sg = cmd->tgt_out_sg; ++ dst_sg = cmd->out_sg; ++ to_copy = cmd->out_bufflen; ++ } ++ } else { ++ src_sg = cmd->sg; ++ dst_sg = cmd->tgt_sg; ++ to_copy = cmd->resp_data_len; ++ } ++ ++ TRACE_MEM("cmd %p, copy_dir %d, src_sg %p, dst_sg %p, to_copy %lld", ++ cmd, copy_dir, src_sg, dst_sg, (long long)to_copy); ++ ++ if (unlikely(src_sg == NULL) || unlikely(dst_sg == NULL)) { ++ /* ++ * It can happened, e.g., with scst_user for cmd with delay ++ * alloc, which failed with Check Condition. ++ */ ++ goto out; ++ } ++ ++ sg_copy(dst_sg, src_sg, 0, to_copy, ++ atomic ? KM_SOFTIRQ0 : KM_USER0, ++ atomic ? KM_SOFTIRQ1 : KM_USER1); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL_GPL(scst_copy_sg); ++ ++/** ++ * scst_get_buf_full - return linear buffer for command ++ * @cmd: scst command ++ * @buf: pointer on the resulting pointer ++ * ++ * If the command's buffer >single page, it vmalloc() the needed area ++ * and copies the buffer there. Returns length of the buffer or negative ++ * error code otherwise. ++ */ ++int scst_get_buf_full(struct scst_cmd *cmd, uint8_t **buf) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ EXTRACHECKS_BUG_ON(cmd->sg_buff_vmallocated); ++ ++ if (scst_get_buf_count(cmd) > 1) { ++ int len; ++ uint8_t *tmp_buf; ++ int full_size; ++ ++ full_size = 0; ++ len = scst_get_buf_first(cmd, &tmp_buf); ++ while (len > 0) { ++ full_size += len; ++ scst_put_buf(cmd, tmp_buf); ++ len = scst_get_buf_next(cmd, &tmp_buf); ++ } ++ ++ *buf = vmalloc(full_size); ++ if (*buf == NULL) { ++ TRACE(TRACE_OUT_OF_MEM, "vmalloc() failed for opcode " ++ "%x", cmd->cdb[0]); ++ res = -ENOMEM; ++ goto out; ++ } ++ cmd->sg_buff_vmallocated = 1; ++ ++ if (scst_cmd_get_data_direction(cmd) == SCST_DATA_WRITE) { ++ uint8_t *buf_ptr; ++ ++ buf_ptr = *buf; ++ ++ len = scst_get_buf_first(cmd, &tmp_buf); ++ while (len > 0) { ++ memcpy(buf_ptr, tmp_buf, len); ++ buf_ptr += len; ++ ++ scst_put_buf(cmd, tmp_buf); ++ len = scst_get_buf_next(cmd, &tmp_buf); ++ } ++ } ++ res = full_size; ++ } else ++ res = scst_get_buf_first(cmd, buf); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL(scst_get_buf_full); ++ ++/** ++ * scst_put_buf_full - unmaps linear buffer for command ++ * @cmd: scst command ++ * @buf: pointer on the buffer to unmap ++ * ++ * Reverse operation for scst_get_buf_full. If the buffer was vmalloced(), ++ * it vfree() the buffer. ++ */ ++void scst_put_buf_full(struct scst_cmd *cmd, uint8_t *buf) ++{ ++ TRACE_ENTRY(); ++ ++ if (buf == NULL) ++ goto out; ++ ++ if (cmd->sg_buff_vmallocated) { ++ if (scst_cmd_get_data_direction(cmd) == SCST_DATA_READ) { ++ int len; ++ uint8_t *tmp_buf, *buf_p; ++ ++ buf_p = buf; ++ ++ len = scst_get_buf_first(cmd, &tmp_buf); ++ while (len > 0) { ++ memcpy(tmp_buf, buf_p, len); ++ buf_p += len; ++ ++ scst_put_buf(cmd, tmp_buf); ++ len = scst_get_buf_next(cmd, &tmp_buf); ++ } ++ ++ } ++ ++ cmd->sg_buff_vmallocated = 0; ++ ++ vfree(buf); ++ } else ++ scst_put_buf(cmd, buf); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL(scst_put_buf_full); ++ ++static const int SCST_CDB_LENGTH[8] = { 6, 10, 10, 0, 16, 12, 0, 0 }; ++ ++#define SCST_CDB_GROUP(opcode) ((opcode >> 5) & 0x7) ++#define SCST_GET_CDB_LEN(opcode) SCST_CDB_LENGTH[SCST_CDB_GROUP(opcode)] ++ ++/* get_trans_len_x extract x bytes from cdb as length starting from off */ ++ ++static int get_trans_cdb_len_10(struct scst_cmd *cmd, uint8_t off) ++{ ++ cmd->cdb_len = 10; ++ cmd->bufflen = 0; ++ return 0; ++} ++ ++static int get_trans_len_block_limit(struct scst_cmd *cmd, uint8_t off) ++{ ++ cmd->bufflen = 6; ++ return 0; ++} ++ ++static int get_trans_len_read_capacity(struct scst_cmd *cmd, uint8_t off) ++{ ++ cmd->bufflen = 8; ++ return 0; ++} ++ ++static int get_trans_len_serv_act_in(struct scst_cmd *cmd, uint8_t off) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ if ((cmd->cdb[1] & 0x1f) == SAI_READ_CAPACITY_16) { ++ cmd->op_name = "READ CAPACITY(16)"; ++ cmd->bufflen = be32_to_cpu(get_unaligned((__be32 *)&cmd->cdb[10])); ++ cmd->op_flags |= SCST_IMPLICIT_HQ | SCST_REG_RESERVE_ALLOWED | ++ SCST_WRITE_EXCL_ALLOWED | SCST_EXCL_ACCESS_ALLOWED; ++ } else ++ cmd->op_flags |= SCST_UNKNOWN_LENGTH; ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int get_trans_len_single(struct scst_cmd *cmd, uint8_t off) ++{ ++ cmd->bufflen = 1; ++ return 0; ++} ++ ++static int get_trans_len_read_pos(struct scst_cmd *cmd, uint8_t off) ++{ ++ uint8_t *p = (uint8_t *)cmd->cdb + off; ++ int res = 0; ++ ++ cmd->bufflen = 0; ++ cmd->bufflen |= ((u32)p[0]) << 8; ++ cmd->bufflen |= ((u32)p[1]); ++ ++ switch (cmd->cdb[1] & 0x1f) { ++ case 0: ++ case 1: ++ case 6: ++ if (cmd->bufflen != 0) { ++ PRINT_ERROR("READ POSITION: Invalid non-zero (%d) " ++ "allocation length for service action %x", ++ cmd->bufflen, cmd->cdb[1] & 0x1f); ++ goto out_inval; ++ } ++ break; ++ } ++ ++ switch (cmd->cdb[1] & 0x1f) { ++ case 0: ++ case 1: ++ cmd->bufflen = 20; ++ break; ++ case 6: ++ cmd->bufflen = 32; ++ break; ++ case 8: ++ cmd->bufflen = max(28, cmd->bufflen); ++ break; ++ default: ++ PRINT_ERROR("READ POSITION: Invalid service action %x", ++ cmd->cdb[1] & 0x1f); ++ goto out_inval; ++ } ++ ++out: ++ return res; ++ ++out_inval: ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ res = 1; ++ goto out; ++} ++ ++static int get_trans_len_prevent_allow_medium_removal(struct scst_cmd *cmd, ++ uint8_t off) ++{ ++ if ((cmd->cdb[4] & 3) == 0) ++ cmd->op_flags |= SCST_REG_RESERVE_ALLOWED | ++ SCST_WRITE_EXCL_ALLOWED | SCST_EXCL_ACCESS_ALLOWED; ++ return 0; ++} ++ ++static int get_trans_len_start_stop(struct scst_cmd *cmd, uint8_t off) ++{ ++ if ((cmd->cdb[4] & 0xF1) == 0x1) ++ cmd->op_flags |= SCST_REG_RESERVE_ALLOWED | ++ SCST_WRITE_EXCL_ALLOWED | SCST_EXCL_ACCESS_ALLOWED; ++ return 0; ++} ++ ++static int get_trans_len_3_read_elem_stat(struct scst_cmd *cmd, uint8_t off) ++{ ++ const uint8_t *p = cmd->cdb + off; ++ ++ cmd->bufflen = 0; ++ cmd->bufflen |= ((u32)p[0]) << 16; ++ cmd->bufflen |= ((u32)p[1]) << 8; ++ cmd->bufflen |= ((u32)p[2]); ++ ++ if ((cmd->cdb[6] & 0x2) == 0x2) ++ cmd->op_flags |= SCST_REG_RESERVE_ALLOWED | ++ SCST_WRITE_EXCL_ALLOWED | SCST_EXCL_ACCESS_ALLOWED; ++ return 0; ++} ++ ++static int get_trans_len_1(struct scst_cmd *cmd, uint8_t off) ++{ ++ cmd->bufflen = (u32)cmd->cdb[off]; ++ return 0; ++} ++ ++static int get_trans_len_1_256(struct scst_cmd *cmd, uint8_t off) ++{ ++ cmd->bufflen = (u32)cmd->cdb[off]; ++ if (cmd->bufflen == 0) ++ cmd->bufflen = 256; ++ return 0; ++} ++ ++static int get_trans_len_2(struct scst_cmd *cmd, uint8_t off) ++{ ++ const uint8_t *p = cmd->cdb + off; ++ ++ cmd->bufflen = 0; ++ cmd->bufflen |= ((u32)p[0]) << 8; ++ cmd->bufflen |= ((u32)p[1]); ++ ++ return 0; ++} ++ ++static int get_trans_len_3(struct scst_cmd *cmd, uint8_t off) ++{ ++ const uint8_t *p = cmd->cdb + off; ++ ++ cmd->bufflen = 0; ++ cmd->bufflen |= ((u32)p[0]) << 16; ++ cmd->bufflen |= ((u32)p[1]) << 8; ++ cmd->bufflen |= ((u32)p[2]); ++ ++ return 0; ++} ++ ++static int get_trans_len_4(struct scst_cmd *cmd, uint8_t off) ++{ ++ const uint8_t *p = cmd->cdb + off; ++ ++ cmd->bufflen = 0; ++ cmd->bufflen |= ((u32)p[0]) << 24; ++ cmd->bufflen |= ((u32)p[1]) << 16; ++ cmd->bufflen |= ((u32)p[2]) << 8; ++ cmd->bufflen |= ((u32)p[3]); ++ ++ return 0; ++} ++ ++static int get_trans_len_none(struct scst_cmd *cmd, uint8_t off) ++{ ++ cmd->bufflen = 0; ++ return 0; ++} ++ ++static int get_bidi_trans_len_2(struct scst_cmd *cmd, uint8_t off) ++{ ++ const uint8_t *p = cmd->cdb + off; ++ ++ cmd->bufflen = 0; ++ cmd->bufflen |= ((u32)p[0]) << 8; ++ cmd->bufflen |= ((u32)p[1]); ++ ++ cmd->out_bufflen = cmd->bufflen; ++ ++ return 0; ++} ++ ++/** ++ * scst_get_cdb_info() - fill various info about the command's CDB ++ * ++ * Description: ++ * Fills various info about the command's CDB in the corresponding fields ++ * in the command. ++ * ++ * Returns: 0 on success, <0 if command is unknown, >0 if command ++ * is invalid. ++ */ ++int scst_get_cdb_info(struct scst_cmd *cmd) ++{ ++ int dev_type = cmd->dev->type; ++ int i, res = 0; ++ uint8_t op; ++ const struct scst_sdbops *ptr = NULL; ++ ++ TRACE_ENTRY(); ++ ++ op = cmd->cdb[0]; /* get clear opcode */ ++ ++ TRACE_DBG("opcode=%02x, cdblen=%d bytes, tblsize=%d, " ++ "dev_type=%d", op, SCST_GET_CDB_LEN(op), SCST_CDB_TBL_SIZE, ++ dev_type); ++ ++ i = scst_scsi_op_list[op]; ++ while (i < SCST_CDB_TBL_SIZE && scst_scsi_op_table[i].ops == op) { ++ if (scst_scsi_op_table[i].devkey[dev_type] != SCST_CDB_NOTSUPP) { ++ ptr = &scst_scsi_op_table[i]; ++ TRACE_DBG("op = 0x%02x+'%c%c%c%c%c%c%c%c%c%c'+<%s>", ++ ptr->ops, ptr->devkey[0], /* disk */ ++ ptr->devkey[1], /* tape */ ++ ptr->devkey[2], /* printer */ ++ ptr->devkey[3], /* cpu */ ++ ptr->devkey[4], /* cdr */ ++ ptr->devkey[5], /* cdrom */ ++ ptr->devkey[6], /* scanner */ ++ ptr->devkey[7], /* worm */ ++ ptr->devkey[8], /* changer */ ++ ptr->devkey[9], /* commdev */ ++ ptr->op_name); ++ TRACE_DBG("direction=%d flags=%d off=%d", ++ ptr->direction, ++ ptr->flags, ++ ptr->off); ++ break; ++ } ++ i++; ++ } ++ ++ if (unlikely(ptr == NULL)) { ++ /* opcode not found or now not used */ ++ TRACE(TRACE_MINOR, "Unknown opcode 0x%x for type %d", op, ++ dev_type); ++ res = -1; ++ goto out; ++ } ++ ++ cmd->cdb_len = SCST_GET_CDB_LEN(op); ++ cmd->op_name = ptr->op_name; ++ cmd->data_direction = ptr->direction; ++ cmd->op_flags = ptr->flags | SCST_INFO_VALID; ++ res = (*ptr->get_trans_len)(cmd, ptr->off); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL_GPL(scst_get_cdb_info); ++ ++/* Packs SCST LUN back to SCSI form */ ++__be64 scst_pack_lun(const uint64_t lun, enum scst_lun_addr_method addr_method) ++{ ++ uint64_t res = 0; ++ ++ if (lun) { ++ res = (addr_method << 14) | (lun & 0x3fff); ++ res = res << 48; ++ } ++ ++ TRACE_EXIT_HRES(res >> 48); ++ return cpu_to_be64(res); ++} ++ ++/* ++ * Function to extract a LUN number from an 8-byte LUN structure in network byte ++ * order (big endian). Supports three LUN addressing methods: peripheral, flat ++ * and logical unit. See also SAM-2, section 4.9.4 (page 40). ++ */ ++uint64_t scst_unpack_lun(const uint8_t *lun, int len) ++{ ++ uint64_t res = NO_SUCH_LUN; ++ int address_method; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_BUFF_FLAG(TRACE_DEBUG, "Raw LUN", lun, len); ++ ++ if (unlikely(len < 2)) { ++ PRINT_ERROR("Illegal lun length %d, expected 2 bytes or " ++ "more", len); ++ goto out; ++ } ++ ++ if (len > 2) { ++ switch (len) { ++ case 8: ++ if ((*((__be64 *)lun) & ++ __constant_cpu_to_be64(0x0000FFFFFFFFFFFFLL)) != 0) ++ goto out_err; ++ break; ++ case 4: ++ if (*((__be16 *)&lun[2]) != 0) ++ goto out_err; ++ break; ++ case 6: ++ if (*((__be32 *)&lun[2]) != 0) ++ goto out_err; ++ break; ++ default: ++ goto out_err; ++ } ++ } ++ ++ address_method = (*lun) >> 6; /* high 2 bits of byte 0 */ ++ switch (address_method) { ++ case SCST_LUN_ADDR_METHOD_PERIPHERAL: ++ case SCST_LUN_ADDR_METHOD_FLAT: ++ case SCST_LUN_ADDR_METHOD_LUN: ++ res = *(lun + 1) | (((*lun) & 0x3f) << 8); ++ break; ++ ++ case SCST_LUN_ADDR_METHOD_EXTENDED_LUN: ++ default: ++ PRINT_ERROR("Unimplemented LUN addressing method %u", ++ address_method); ++ break; ++ } ++ ++out: ++ TRACE_EXIT_RES((int)res); ++ return res; ++ ++out_err: ++ PRINT_ERROR("%s", "Multi-level LUN unimplemented"); ++ goto out; ++} ++ ++/** ++ ** Generic parse() support routines. ++ ** Done via pointer on functions to avoid unneeded dereferences on ++ ** the fast path. ++ **/ ++ ++/** ++ * scst_calc_block_shift() - calculate block shift ++ * ++ * Calculates and returns block shift for the given sector size ++ */ ++int scst_calc_block_shift(int sector_size) ++{ ++ int block_shift = 0; ++ int t; ++ ++ if (sector_size == 0) ++ sector_size = 512; ++ ++ t = sector_size; ++ while (1) { ++ if ((t & 1) != 0) ++ break; ++ t >>= 1; ++ block_shift++; ++ } ++ if (block_shift < 9) { ++ PRINT_ERROR("Wrong sector size %d", sector_size); ++ block_shift = -1; ++ } ++ ++ TRACE_EXIT_RES(block_shift); ++ return block_shift; ++} ++EXPORT_SYMBOL_GPL(scst_calc_block_shift); ++ ++/** ++ * scst_sbc_generic_parse() - generic SBC parsing ++ * ++ * Generic parse() for SBC (disk) devices ++ */ ++int scst_sbc_generic_parse(struct scst_cmd *cmd, ++ int (*get_block_shift)(struct scst_cmd *cmd)) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * SCST sets good defaults for cmd->data_direction and cmd->bufflen, ++ * therefore change them only if necessary ++ */ ++ ++ TRACE_DBG("op_name <%s> direct %d flags %d transfer_len %d", ++ cmd->op_name, cmd->data_direction, cmd->op_flags, cmd->bufflen); ++ ++ switch (cmd->cdb[0]) { ++ case VERIFY_6: ++ case VERIFY: ++ case VERIFY_12: ++ case VERIFY_16: ++ if ((cmd->cdb[1] & BYTCHK) == 0) { ++ cmd->data_len = cmd->bufflen << get_block_shift(cmd); ++ cmd->bufflen = 0; ++ goto set_timeout; ++ } else ++ cmd->data_len = 0; ++ break; ++ default: ++ /* It's all good */ ++ break; ++ } ++ ++ if (cmd->op_flags & SCST_TRANSFER_LEN_TYPE_FIXED) { ++ int block_shift = get_block_shift(cmd); ++ /* ++ * No need for locks here, since *_detach() can not be ++ * called, when there are existing commands. ++ */ ++ cmd->bufflen = cmd->bufflen << block_shift; ++ cmd->out_bufflen = cmd->out_bufflen << block_shift; ++ } ++ ++set_timeout: ++ if ((cmd->op_flags & (SCST_SMALL_TIMEOUT | SCST_LONG_TIMEOUT)) == 0) ++ cmd->timeout = SCST_GENERIC_DISK_REG_TIMEOUT; ++ else if (cmd->op_flags & SCST_SMALL_TIMEOUT) ++ cmd->timeout = SCST_GENERIC_DISK_SMALL_TIMEOUT; ++ else if (cmd->op_flags & SCST_LONG_TIMEOUT) ++ cmd->timeout = SCST_GENERIC_DISK_LONG_TIMEOUT; ++ ++ TRACE_DBG("res %d, bufflen %d, data_len %d, direct %d", ++ res, cmd->bufflen, cmd->data_len, cmd->data_direction); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL_GPL(scst_sbc_generic_parse); ++ ++/** ++ * scst_cdrom_generic_parse() - generic MMC parse ++ * ++ * Generic parse() for MMC (cdrom) devices ++ */ ++int scst_cdrom_generic_parse(struct scst_cmd *cmd, ++ int (*get_block_shift)(struct scst_cmd *cmd)) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * SCST sets good defaults for cmd->data_direction and cmd->bufflen, ++ * therefore change them only if necessary ++ */ ++ ++ TRACE_DBG("op_name <%s> direct %d flags %d transfer_len %d", ++ cmd->op_name, cmd->data_direction, cmd->op_flags, cmd->bufflen); ++ ++ cmd->cdb[1] &= 0x1f; ++ ++ switch (cmd->cdb[0]) { ++ case VERIFY_6: ++ case VERIFY: ++ case VERIFY_12: ++ case VERIFY_16: ++ if ((cmd->cdb[1] & BYTCHK) == 0) { ++ cmd->data_len = cmd->bufflen << get_block_shift(cmd); ++ cmd->bufflen = 0; ++ goto set_timeout; ++ } ++ break; ++ default: ++ /* It's all good */ ++ break; ++ } ++ ++ if (cmd->op_flags & SCST_TRANSFER_LEN_TYPE_FIXED) { ++ int block_shift = get_block_shift(cmd); ++ cmd->bufflen = cmd->bufflen << block_shift; ++ cmd->out_bufflen = cmd->out_bufflen << block_shift; ++ } ++ ++set_timeout: ++ if ((cmd->op_flags & (SCST_SMALL_TIMEOUT | SCST_LONG_TIMEOUT)) == 0) ++ cmd->timeout = SCST_GENERIC_CDROM_REG_TIMEOUT; ++ else if (cmd->op_flags & SCST_SMALL_TIMEOUT) ++ cmd->timeout = SCST_GENERIC_CDROM_SMALL_TIMEOUT; ++ else if (cmd->op_flags & SCST_LONG_TIMEOUT) ++ cmd->timeout = SCST_GENERIC_CDROM_LONG_TIMEOUT; ++ ++ TRACE_DBG("res=%d, bufflen=%d, direct=%d", res, cmd->bufflen, ++ cmd->data_direction); ++ ++ TRACE_EXIT(); ++ return res; ++} ++EXPORT_SYMBOL_GPL(scst_cdrom_generic_parse); ++ ++/** ++ * scst_modisk_generic_parse() - generic MO parse ++ * ++ * Generic parse() for MO disk devices ++ */ ++int scst_modisk_generic_parse(struct scst_cmd *cmd, ++ int (*get_block_shift)(struct scst_cmd *cmd)) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * SCST sets good defaults for cmd->data_direction and cmd->bufflen, ++ * therefore change them only if necessary ++ */ ++ ++ TRACE_DBG("op_name <%s> direct %d flags %d transfer_len %d", ++ cmd->op_name, cmd->data_direction, cmd->op_flags, cmd->bufflen); ++ ++ cmd->cdb[1] &= 0x1f; ++ ++ switch (cmd->cdb[0]) { ++ case VERIFY_6: ++ case VERIFY: ++ case VERIFY_12: ++ case VERIFY_16: ++ if ((cmd->cdb[1] & BYTCHK) == 0) { ++ cmd->data_len = cmd->bufflen << get_block_shift(cmd); ++ cmd->bufflen = 0; ++ goto set_timeout; ++ } ++ break; ++ default: ++ /* It's all good */ ++ break; ++ } ++ ++ if (cmd->op_flags & SCST_TRANSFER_LEN_TYPE_FIXED) { ++ int block_shift = get_block_shift(cmd); ++ cmd->bufflen = cmd->bufflen << block_shift; ++ cmd->out_bufflen = cmd->out_bufflen << block_shift; ++ } ++ ++set_timeout: ++ if ((cmd->op_flags & (SCST_SMALL_TIMEOUT | SCST_LONG_TIMEOUT)) == 0) ++ cmd->timeout = SCST_GENERIC_MODISK_REG_TIMEOUT; ++ else if (cmd->op_flags & SCST_SMALL_TIMEOUT) ++ cmd->timeout = SCST_GENERIC_MODISK_SMALL_TIMEOUT; ++ else if (cmd->op_flags & SCST_LONG_TIMEOUT) ++ cmd->timeout = SCST_GENERIC_MODISK_LONG_TIMEOUT; ++ ++ TRACE_DBG("res=%d, bufflen=%d, direct=%d", res, cmd->bufflen, ++ cmd->data_direction); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL_GPL(scst_modisk_generic_parse); ++ ++/** ++ * scst_tape_generic_parse() - generic tape parse ++ * ++ * Generic parse() for tape devices ++ */ ++int scst_tape_generic_parse(struct scst_cmd *cmd, ++ int (*get_block_size)(struct scst_cmd *cmd)) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * SCST sets good defaults for cmd->data_direction and cmd->bufflen, ++ * therefore change them only if necessary ++ */ ++ ++ TRACE_DBG("op_name <%s> direct %d flags %d transfer_len %d", ++ cmd->op_name, cmd->data_direction, cmd->op_flags, cmd->bufflen); ++ ++ if (cmd->cdb[0] == READ_POSITION) { ++ int tclp = cmd->cdb[1] & 4; ++ int long_bit = cmd->cdb[1] & 2; ++ int bt = cmd->cdb[1] & 1; ++ ++ if ((tclp == long_bit) && (!bt || !long_bit)) { ++ cmd->bufflen = ++ tclp ? POSITION_LEN_LONG : POSITION_LEN_SHORT; ++ cmd->data_direction = SCST_DATA_READ; ++ } else { ++ cmd->bufflen = 0; ++ cmd->data_direction = SCST_DATA_NONE; ++ } ++ } ++ ++ if (cmd->op_flags & SCST_TRANSFER_LEN_TYPE_FIXED & cmd->cdb[1]) { ++ int block_size = get_block_size(cmd); ++ cmd->bufflen = cmd->bufflen * block_size; ++ cmd->out_bufflen = cmd->out_bufflen * block_size; ++ } ++ ++ if ((cmd->op_flags & (SCST_SMALL_TIMEOUT | SCST_LONG_TIMEOUT)) == 0) ++ cmd->timeout = SCST_GENERIC_TAPE_REG_TIMEOUT; ++ else if (cmd->op_flags & SCST_SMALL_TIMEOUT) ++ cmd->timeout = SCST_GENERIC_TAPE_SMALL_TIMEOUT; ++ else if (cmd->op_flags & SCST_LONG_TIMEOUT) ++ cmd->timeout = SCST_GENERIC_TAPE_LONG_TIMEOUT; ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL_GPL(scst_tape_generic_parse); ++ ++static int scst_null_parse(struct scst_cmd *cmd) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * SCST sets good defaults for cmd->data_direction and cmd->bufflen, ++ * therefore change them only if necessary ++ */ ++ ++ TRACE_DBG("op_name <%s> direct %d flags %d transfer_len %d", ++ cmd->op_name, cmd->data_direction, cmd->op_flags, cmd->bufflen); ++#if 0 ++ switch (cmd->cdb[0]) { ++ default: ++ /* It's all good */ ++ break; ++ } ++#endif ++ TRACE_DBG("res %d bufflen %d direct %d", ++ res, cmd->bufflen, cmd->data_direction); ++ ++ TRACE_EXIT(); ++ return res; ++} ++ ++/** ++ * scst_changer_generic_parse() - generic changer parse ++ * ++ * Generic parse() for changer devices ++ */ ++int scst_changer_generic_parse(struct scst_cmd *cmd, ++ int (*nothing)(struct scst_cmd *cmd)) ++{ ++ int res = scst_null_parse(cmd); ++ ++ if (cmd->op_flags & SCST_LONG_TIMEOUT) ++ cmd->timeout = SCST_GENERIC_CHANGER_LONG_TIMEOUT; ++ else ++ cmd->timeout = SCST_GENERIC_CHANGER_TIMEOUT; ++ ++ return res; ++} ++EXPORT_SYMBOL_GPL(scst_changer_generic_parse); ++ ++/** ++ * scst_processor_generic_parse - generic SCSI processor parse ++ * ++ * Generic parse() for SCSI processor devices ++ */ ++int scst_processor_generic_parse(struct scst_cmd *cmd, ++ int (*nothing)(struct scst_cmd *cmd)) ++{ ++ int res = scst_null_parse(cmd); ++ ++ if (cmd->op_flags & SCST_LONG_TIMEOUT) ++ cmd->timeout = SCST_GENERIC_PROCESSOR_LONG_TIMEOUT; ++ else ++ cmd->timeout = SCST_GENERIC_PROCESSOR_TIMEOUT; ++ ++ return res; ++} ++EXPORT_SYMBOL_GPL(scst_processor_generic_parse); ++ ++/** ++ * scst_raid_generic_parse() - generic RAID parse ++ * ++ * Generic parse() for RAID devices ++ */ ++int scst_raid_generic_parse(struct scst_cmd *cmd, ++ int (*nothing)(struct scst_cmd *cmd)) ++{ ++ int res = scst_null_parse(cmd); ++ ++ if (cmd->op_flags & SCST_LONG_TIMEOUT) ++ cmd->timeout = SCST_GENERIC_RAID_LONG_TIMEOUT; ++ else ++ cmd->timeout = SCST_GENERIC_RAID_TIMEOUT; ++ ++ return res; ++} ++EXPORT_SYMBOL_GPL(scst_raid_generic_parse); ++ ++/** ++ ** Generic dev_done() support routines. ++ ** Done via pointer on functions to avoid unneeded dereferences on ++ ** the fast path. ++ **/ ++ ++/** ++ * scst_block_generic_dev_done() - generic SBC dev_done ++ * ++ * Generic dev_done() for block (SBC) devices ++ */ ++int scst_block_generic_dev_done(struct scst_cmd *cmd, ++ void (*set_block_shift)(struct scst_cmd *cmd, int block_shift)) ++{ ++ int opcode = cmd->cdb[0]; ++ int status = cmd->status; ++ int res = SCST_CMD_STATE_DEFAULT; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * SCST sets good defaults for cmd->is_send_status and ++ * cmd->resp_data_len based on cmd->status and cmd->data_direction, ++ * therefore change them only if necessary ++ */ ++ ++ if ((status == SAM_STAT_GOOD) || (status == SAM_STAT_CONDITION_MET)) { ++ switch (opcode) { ++ case READ_CAPACITY: ++ { ++ /* Always keep track of disk capacity */ ++ int buffer_size, sector_size, sh; ++ uint8_t *buffer; ++ ++ buffer_size = scst_get_buf_full(cmd, &buffer); ++ if (unlikely(buffer_size <= 0)) { ++ if (buffer_size < 0) { ++ PRINT_ERROR("%s: Unable to get the" ++ " buffer (%d)", __func__, buffer_size); ++ } ++ goto out; ++ } ++ ++ sector_size = ++ ((buffer[4] << 24) | (buffer[5] << 16) | ++ (buffer[6] << 8) | (buffer[7] << 0)); ++ scst_put_buf_full(cmd, buffer); ++ if (sector_size != 0) ++ sh = scst_calc_block_shift(sector_size); ++ else ++ sh = 0; ++ set_block_shift(cmd, sh); ++ TRACE_DBG("block_shift %d", sh); ++ break; ++ } ++ default: ++ /* It's all good */ ++ break; ++ } ++ } ++ ++ TRACE_DBG("cmd->is_send_status=%x, cmd->resp_data_len=%d, " ++ "res=%d", cmd->is_send_status, cmd->resp_data_len, res); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL_GPL(scst_block_generic_dev_done); ++ ++/** ++ * scst_tape_generic_dev_done() - generic tape dev done ++ * ++ * Generic dev_done() for tape devices ++ */ ++int scst_tape_generic_dev_done(struct scst_cmd *cmd, ++ void (*set_block_size)(struct scst_cmd *cmd, int block_shift)) ++{ ++ int opcode = cmd->cdb[0]; ++ int res = SCST_CMD_STATE_DEFAULT; ++ int buffer_size, bs; ++ uint8_t *buffer = NULL; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * SCST sets good defaults for cmd->is_send_status and ++ * cmd->resp_data_len based on cmd->status and cmd->data_direction, ++ * therefore change them only if necessary ++ */ ++ ++ if (cmd->status != SAM_STAT_GOOD) ++ goto out; ++ ++ switch (opcode) { ++ case MODE_SENSE: ++ case MODE_SELECT: ++ buffer_size = scst_get_buf_full(cmd, &buffer); ++ if (unlikely(buffer_size <= 0)) { ++ if (buffer_size < 0) { ++ PRINT_ERROR("%s: Unable to get the buffer (%d)", ++ __func__, buffer_size); ++ } ++ goto out; ++ } ++ break; ++ } ++ ++ switch (opcode) { ++ case MODE_SENSE: ++ TRACE_DBG("%s", "MODE_SENSE"); ++ if ((cmd->cdb[2] & 0xC0) == 0) { ++ if (buffer[3] == 8) { ++ bs = (buffer[9] << 16) | ++ (buffer[10] << 8) | buffer[11]; ++ set_block_size(cmd, bs); ++ } ++ } ++ break; ++ case MODE_SELECT: ++ TRACE_DBG("%s", "MODE_SELECT"); ++ if (buffer[3] == 8) { ++ bs = (buffer[9] << 16) | (buffer[10] << 8) | ++ (buffer[11]); ++ set_block_size(cmd, bs); ++ } ++ break; ++ default: ++ /* It's all good */ ++ break; ++ } ++ ++ switch (opcode) { ++ case MODE_SENSE: ++ case MODE_SELECT: ++ scst_put_buf_full(cmd, buffer); ++ break; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL_GPL(scst_tape_generic_dev_done); ++ ++static void scst_check_internal_sense(struct scst_device *dev, int result, ++ uint8_t *sense, int sense_len) ++{ ++ TRACE_ENTRY(); ++ ++ if (host_byte(result) == DID_RESET) { ++ int sl; ++ TRACE(TRACE_MGMT, "DID_RESET received for device %s, " ++ "triggering reset UA", dev->virt_name); ++ sl = scst_set_sense(sense, sense_len, dev->d_sense, ++ SCST_LOAD_SENSE(scst_sense_reset_UA)); ++ scst_dev_check_set_UA(dev, NULL, sense, sl); ++ } else if ((status_byte(result) == CHECK_CONDITION) && ++ scst_is_ua_sense(sense, sense_len)) ++ scst_dev_check_set_UA(dev, NULL, sense, sense_len); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ * scst_to_dma_dir() - translate SCST's data direction to DMA direction ++ * ++ * Translates SCST's data direction to DMA one from backend storage ++ * perspective. ++ */ ++enum dma_data_direction scst_to_dma_dir(int scst_dir) ++{ ++ static const enum dma_data_direction tr_tbl[] = { DMA_NONE, ++ DMA_TO_DEVICE, DMA_FROM_DEVICE, DMA_BIDIRECTIONAL, DMA_NONE }; ++ ++ return tr_tbl[scst_dir]; ++} ++EXPORT_SYMBOL(scst_to_dma_dir); ++ ++/* ++ * scst_to_tgt_dma_dir() - translate SCST data direction to DMA direction ++ * ++ * Translates SCST data direction to DMA data direction from the perspective ++ * of a target. ++ */ ++enum dma_data_direction scst_to_tgt_dma_dir(int scst_dir) ++{ ++ static const enum dma_data_direction tr_tbl[] = { DMA_NONE, ++ DMA_FROM_DEVICE, DMA_TO_DEVICE, DMA_BIDIRECTIONAL, DMA_NONE }; ++ ++ return tr_tbl[scst_dir]; ++} ++EXPORT_SYMBOL(scst_to_tgt_dma_dir); ++ ++/** ++ * scst_obtain_device_parameters() - obtain device control parameters ++ * ++ * Issues a MODE SENSE for control mode page data and sets the corresponding ++ * dev's parameter from it. Returns 0 on success and not 0 otherwise. ++ */ ++int scst_obtain_device_parameters(struct scst_device *dev) ++{ ++ int rc, i; ++ uint8_t cmd[16]; ++ uint8_t buffer[4+0x0A]; ++ uint8_t sense_buffer[SCSI_SENSE_BUFFERSIZE]; ++ ++ TRACE_ENTRY(); ++ ++ EXTRACHECKS_BUG_ON(dev->scsi_dev == NULL); ++ ++ for (i = 0; i < 5; i++) { ++ /* Get control mode page */ ++ memset(cmd, 0, sizeof(cmd)); ++#if 0 ++ cmd[0] = MODE_SENSE_10; ++ cmd[1] = 0; ++ cmd[2] = 0x0A; ++ cmd[8] = sizeof(buffer); /* it's < 256 */ ++#else ++ cmd[0] = MODE_SENSE; ++ cmd[1] = 8; /* DBD */ ++ cmd[2] = 0x0A; ++ cmd[4] = sizeof(buffer); ++#endif ++ ++ memset(buffer, 0, sizeof(buffer)); ++ memset(sense_buffer, 0, sizeof(sense_buffer)); ++ ++ TRACE(TRACE_SCSI, "%s", "Doing internal MODE_SENSE"); ++ rc = scsi_execute(dev->scsi_dev, cmd, SCST_DATA_READ, buffer, ++ sizeof(buffer), sense_buffer, 15, 0, 0 ++ , NULL ++ ); ++ ++ TRACE_DBG("MODE_SENSE done: %x", rc); ++ ++ if (scsi_status_is_good(rc)) { ++ int q; ++ ++ PRINT_BUFF_FLAG(TRACE_SCSI, "Returned control mode " ++ "page data", buffer, sizeof(buffer)); ++ ++ dev->tst = buffer[4+2] >> 5; ++ q = buffer[4+3] >> 4; ++ if (q > SCST_CONTR_MODE_QUEUE_ALG_UNRESTRICTED_REORDER) { ++ PRINT_ERROR("Too big QUEUE ALG %x, dev %s", ++ dev->queue_alg, dev->virt_name); ++ } ++ dev->queue_alg = q; ++ dev->swp = (buffer[4+4] & 0x8) >> 3; ++ dev->tas = (buffer[4+5] & 0x40) >> 6; ++ dev->d_sense = (buffer[4+2] & 0x4) >> 2; ++ ++ /* ++ * Unfortunately, SCSI ML doesn't provide a way to ++ * specify commands task attribute, so we can rely on ++ * device's restricted reordering only. Linux I/O ++ * subsystem doesn't reorder pass-through (PC) requests. ++ */ ++ dev->has_own_order_mgmt = !dev->queue_alg; ++ ++ PRINT_INFO("Device %s: TST %x, QUEUE ALG %x, SWP %x, " ++ "TAS %x, D_SENSE %d, has_own_order_mgmt %d", ++ dev->virt_name, dev->tst, dev->queue_alg, ++ dev->swp, dev->tas, dev->d_sense, ++ dev->has_own_order_mgmt); ++ ++ goto out; ++ } else { ++ scst_check_internal_sense(dev, rc, sense_buffer, ++ sizeof(sense_buffer)); ++#if 0 ++ if ((status_byte(rc) == CHECK_CONDITION) && ++ SCST_SENSE_VALID(sense_buffer)) { ++#else ++ /* ++ * 3ware controller is buggy and returns CONDITION_GOOD ++ * instead of CHECK_CONDITION ++ */ ++ if (SCST_SENSE_VALID(sense_buffer)) { ++#endif ++ PRINT_BUFF_FLAG(TRACE_SCSI, "Returned sense " ++ "data", sense_buffer, ++ sizeof(sense_buffer)); ++ if (scst_analyze_sense(sense_buffer, ++ sizeof(sense_buffer), ++ SCST_SENSE_KEY_VALID, ++ ILLEGAL_REQUEST, 0, 0)) { ++ PRINT_INFO("Device %s doesn't support " ++ "MODE SENSE", dev->virt_name); ++ break; ++ } else if (scst_analyze_sense(sense_buffer, ++ sizeof(sense_buffer), ++ SCST_SENSE_KEY_VALID, ++ NOT_READY, 0, 0)) { ++ PRINT_ERROR("Device %s not ready", ++ dev->virt_name); ++ break; ++ } ++ } else { ++ PRINT_INFO("Internal MODE SENSE to " ++ "device %s failed: %x", ++ dev->virt_name, rc); ++ PRINT_BUFF_FLAG(TRACE_SCSI, "MODE SENSE sense", ++ sense_buffer, sizeof(sense_buffer)); ++ switch (host_byte(rc)) { ++ case DID_RESET: ++ case DID_ABORT: ++ case DID_SOFT_ERROR: ++ break; ++ default: ++ goto brk; ++ } ++ switch (driver_byte(rc)) { ++ case DRIVER_BUSY: ++ case DRIVER_SOFT: ++ break; ++ default: ++ goto brk; ++ } ++ } ++ } ++ } ++brk: ++ PRINT_WARNING("Unable to get device's %s control mode page, using " ++ "existing values/defaults: TST %x, QUEUE ALG %x, SWP %x, " ++ "TAS %x, D_SENSE %d, has_own_order_mgmt %d", dev->virt_name, ++ dev->tst, dev->queue_alg, dev->swp, dev->tas, dev->d_sense, ++ dev->has_own_order_mgmt); ++ ++out: ++ TRACE_EXIT(); ++ return 0; ++} ++EXPORT_SYMBOL_GPL(scst_obtain_device_parameters); ++ ++/* Called under dev_lock and BH off */ ++void scst_process_reset(struct scst_device *dev, ++ struct scst_session *originator, struct scst_cmd *exclude_cmd, ++ struct scst_mgmt_cmd *mcmd, bool setUA) ++{ ++ struct scst_tgt_dev *tgt_dev; ++ struct scst_cmd *cmd, *tcmd; ++ ++ TRACE_ENTRY(); ++ ++ /* Clear RESERVE'ation, if necessary */ ++ if (dev->dev_reserved) { ++ list_for_each_entry(tgt_dev, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ TRACE_MGMT_DBG("Clearing RESERVE'ation for " ++ "tgt_dev LUN %lld", ++ (long long unsigned int)tgt_dev->lun); ++ clear_bit(SCST_TGT_DEV_RESERVED, ++ &tgt_dev->tgt_dev_flags); ++ } ++ dev->dev_reserved = 0; ++ /* ++ * There is no need to send RELEASE, since the device is going ++ * to be reset. Actually, since we can be in RESET TM ++ * function, it might be dangerous. ++ */ ++ } ++ ++ dev->dev_double_ua_possible = 1; ++ ++ list_for_each_entry(tgt_dev, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ struct scst_session *sess = tgt_dev->sess; ++ ++#if 0 /* Clearing UAs and last sense isn't required by SAM and it ++ * looks to be better to not clear them to not loose important ++ * events, so let's disable it. ++ */ ++ spin_lock_bh(&tgt_dev->tgt_dev_lock); ++ scst_free_all_UA(tgt_dev); ++ memset(tgt_dev->tgt_dev_sense, 0, ++ sizeof(tgt_dev->tgt_dev_sense)); ++ spin_unlock_bh(&tgt_dev->tgt_dev_lock); ++#endif ++ ++ spin_lock_irq(&sess->sess_list_lock); ++ ++ TRACE_DBG("Searching in sess cmd list (sess=%p)", sess); ++ list_for_each_entry(cmd, &sess->sess_cmd_list, ++ sess_cmd_list_entry) { ++ if (cmd == exclude_cmd) ++ continue; ++ if ((cmd->tgt_dev == tgt_dev) || ++ ((cmd->tgt_dev == NULL) && ++ (cmd->lun == tgt_dev->lun))) { ++ scst_abort_cmd(cmd, mcmd, ++ (tgt_dev->sess != originator), 0); ++ } ++ } ++ spin_unlock_irq(&sess->sess_list_lock); ++ } ++ ++ list_for_each_entry_safe(cmd, tcmd, &dev->blocked_cmd_list, ++ blocked_cmd_list_entry) { ++ if (test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags)) { ++ list_del(&cmd->blocked_cmd_list_entry); ++ TRACE_MGMT_DBG("Adding aborted blocked cmd %p " ++ "to active cmd list", cmd); ++ spin_lock_irq(&cmd->cmd_threads->cmd_list_lock); ++ list_add_tail(&cmd->cmd_list_entry, ++ &cmd->cmd_threads->active_cmd_list); ++ wake_up(&cmd->cmd_threads->cmd_list_waitQ); ++ spin_unlock_irq(&cmd->cmd_threads->cmd_list_lock); ++ } ++ } ++ ++ if (setUA) { ++ uint8_t sense_buffer[SCST_STANDARD_SENSE_LEN]; ++ int sl = scst_set_sense(sense_buffer, sizeof(sense_buffer), ++ dev->d_sense, SCST_LOAD_SENSE(scst_sense_reset_UA)); ++ scst_dev_check_set_local_UA(dev, exclude_cmd, sense_buffer, sl); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Caller must hold tgt_dev->tgt_dev_lock. */ ++void scst_tgt_dev_del_free_UA(struct scst_tgt_dev *tgt_dev, ++ struct scst_tgt_dev_UA *ua) ++{ ++ list_del(&ua->UA_list_entry); ++ if (list_empty(&tgt_dev->UA_list)) ++ clear_bit(SCST_TGT_DEV_UA_PENDING, &tgt_dev->tgt_dev_flags); ++ mempool_free(ua, scst_ua_mempool); ++} ++ ++/* No locks, no IRQ or IRQ-disabled context allowed */ ++int scst_set_pending_UA(struct scst_cmd *cmd) ++{ ++ int res = 0, i; ++ struct scst_tgt_dev_UA *UA_entry; ++ bool first = true, global_unlock = false; ++ struct scst_session *sess = cmd->sess; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * RMB and recheck to sync with setting SCST_CMD_ABORTED in ++ * scst_abort_cmd() to not set UA for the being aborted cmd, hence ++ * possibly miss its delivery by a legitimate command while the UA is ++ * being requeued. ++ */ ++ smp_rmb(); ++ if (test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags)) { ++ TRACE_MGMT_DBG("Not set pending UA for aborted cmd %p", cmd); ++ res = -1; ++ goto out; ++ } ++ ++ TRACE_MGMT_DBG("Setting pending UA cmd %p", cmd); ++ ++ spin_lock_bh(&cmd->tgt_dev->tgt_dev_lock); ++ ++again: ++ /* UA list could be cleared behind us, so retest */ ++ if (list_empty(&cmd->tgt_dev->UA_list)) { ++ TRACE_DBG("%s", ++ "SCST_TGT_DEV_UA_PENDING set, but UA_list empty"); ++ res = -1; ++ goto out_unlock; ++ } ++ ++ UA_entry = list_entry(cmd->tgt_dev->UA_list.next, typeof(*UA_entry), ++ UA_list_entry); ++ ++ TRACE_DBG("next %p UA_entry %p", ++ cmd->tgt_dev->UA_list.next, UA_entry); ++ ++ if (UA_entry->global_UA && first) { ++ TRACE_MGMT_DBG("Global UA %p detected", UA_entry); ++ ++ spin_unlock_bh(&cmd->tgt_dev->tgt_dev_lock); ++ ++ /* ++ * cmd won't allow to suspend activities, so we can access ++ * sess->sess_tgt_dev_list without any additional ++ * protection. ++ */ ++ ++ local_bh_disable(); ++ ++ for (i = 0; i < SESS_TGT_DEV_LIST_HASH_SIZE; i++) { ++ struct list_head *head = &sess->sess_tgt_dev_list[i]; ++ struct scst_tgt_dev *tgt_dev; ++ list_for_each_entry(tgt_dev, head, ++ sess_tgt_dev_list_entry) { ++ /* Lockdep triggers here a false positive.. */ ++ spin_lock(&tgt_dev->tgt_dev_lock); ++ } ++ } ++ ++ first = false; ++ global_unlock = true; ++ goto again; ++ } ++ ++ if (scst_set_cmd_error_sense(cmd, UA_entry->UA_sense_buffer, ++ UA_entry->UA_valid_sense_len) != 0) ++ goto out_unlock; ++ ++ cmd->ua_ignore = 1; ++ ++ list_del(&UA_entry->UA_list_entry); ++ ++ if (UA_entry->global_UA) { ++ for (i = 0; i < SESS_TGT_DEV_LIST_HASH_SIZE; i++) { ++ struct list_head *head = &sess->sess_tgt_dev_list[i]; ++ struct scst_tgt_dev *tgt_dev; ++ ++ list_for_each_entry(tgt_dev, head, ++ sess_tgt_dev_list_entry) { ++ struct scst_tgt_dev_UA *ua; ++ list_for_each_entry(ua, &tgt_dev->UA_list, ++ UA_list_entry) { ++ if (ua->global_UA && ++ memcmp(ua->UA_sense_buffer, ++ UA_entry->UA_sense_buffer, ++ sizeof(ua->UA_sense_buffer)) == 0) { ++ TRACE_MGMT_DBG("Freeing not " ++ "needed global UA %p", ++ ua); ++ scst_tgt_dev_del_free_UA(tgt_dev, ++ ua); ++ break; ++ } ++ } ++ } ++ } ++ } ++ ++ mempool_free(UA_entry, scst_ua_mempool); ++ ++ if (list_empty(&cmd->tgt_dev->UA_list)) { ++ clear_bit(SCST_TGT_DEV_UA_PENDING, ++ &cmd->tgt_dev->tgt_dev_flags); ++ } ++ ++out_unlock: ++ if (global_unlock) { ++ for (i = SESS_TGT_DEV_LIST_HASH_SIZE-1; i >= 0; i--) { ++ struct list_head *head = &sess->sess_tgt_dev_list[i]; ++ struct scst_tgt_dev *tgt_dev; ++ list_for_each_entry_reverse(tgt_dev, head, ++ sess_tgt_dev_list_entry) { ++ spin_unlock(&tgt_dev->tgt_dev_lock); ++ } ++ } ++ ++ local_bh_enable(); ++ spin_lock_bh(&cmd->tgt_dev->tgt_dev_lock); ++ } ++ ++ spin_unlock_bh(&cmd->tgt_dev->tgt_dev_lock); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* Called under tgt_dev_lock and BH off */ ++static void scst_alloc_set_UA(struct scst_tgt_dev *tgt_dev, ++ const uint8_t *sense, int sense_len, int flags) ++{ ++ struct scst_tgt_dev_UA *UA_entry = NULL; ++ ++ TRACE_ENTRY(); ++ ++ UA_entry = mempool_alloc(scst_ua_mempool, GFP_ATOMIC); ++ if (UA_entry == NULL) { ++ PRINT_CRIT_ERROR("%s", "UNIT ATTENTION memory " ++ "allocation failed. The UNIT ATTENTION " ++ "on some sessions will be missed"); ++ PRINT_BUFFER("Lost UA", sense, sense_len); ++ goto out; ++ } ++ memset(UA_entry, 0, sizeof(*UA_entry)); ++ ++ UA_entry->global_UA = (flags & SCST_SET_UA_FLAG_GLOBAL) != 0; ++ if (UA_entry->global_UA) ++ TRACE_MGMT_DBG("Queueing global UA %p", UA_entry); ++ ++ if (sense_len > (int)sizeof(UA_entry->UA_sense_buffer)) { ++ PRINT_WARNING("Sense truncated (needed %d), shall you increase " ++ "SCST_SENSE_BUFFERSIZE?", sense_len); ++ sense_len = sizeof(UA_entry->UA_sense_buffer); ++ } ++ memcpy(UA_entry->UA_sense_buffer, sense, sense_len); ++ UA_entry->UA_valid_sense_len = sense_len; ++ ++ set_bit(SCST_TGT_DEV_UA_PENDING, &tgt_dev->tgt_dev_flags); ++ ++ TRACE_MGMT_DBG("Adding new UA to tgt_dev %p", tgt_dev); ++ ++ if (flags & SCST_SET_UA_FLAG_AT_HEAD) ++ list_add(&UA_entry->UA_list_entry, &tgt_dev->UA_list); ++ else ++ list_add_tail(&UA_entry->UA_list_entry, &tgt_dev->UA_list); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* tgt_dev_lock supposed to be held and BH off */ ++static void __scst_check_set_UA(struct scst_tgt_dev *tgt_dev, ++ const uint8_t *sense, int sense_len, int flags) ++{ ++ int skip_UA = 0; ++ struct scst_tgt_dev_UA *UA_entry_tmp; ++ int len = min_t(int, sizeof(UA_entry_tmp->UA_sense_buffer), sense_len); ++ ++ TRACE_ENTRY(); ++ ++ list_for_each_entry(UA_entry_tmp, &tgt_dev->UA_list, ++ UA_list_entry) { ++ if (memcmp(sense, UA_entry_tmp->UA_sense_buffer, len) == 0) { ++ TRACE_MGMT_DBG("%s", "UA already exists"); ++ skip_UA = 1; ++ break; ++ } ++ } ++ ++ if (skip_UA == 0) ++ scst_alloc_set_UA(tgt_dev, sense, len, flags); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++void scst_check_set_UA(struct scst_tgt_dev *tgt_dev, ++ const uint8_t *sense, int sense_len, int flags) ++{ ++ TRACE_ENTRY(); ++ ++ spin_lock_bh(&tgt_dev->tgt_dev_lock); ++ __scst_check_set_UA(tgt_dev, sense, sense_len, flags); ++ spin_unlock_bh(&tgt_dev->tgt_dev_lock); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Called under dev_lock and BH off */ ++void scst_dev_check_set_local_UA(struct scst_device *dev, ++ struct scst_cmd *exclude, const uint8_t *sense, int sense_len) ++{ ++ struct scst_tgt_dev *tgt_dev, *exclude_tgt_dev = NULL; ++ ++ TRACE_ENTRY(); ++ ++ if (exclude != NULL) ++ exclude_tgt_dev = exclude->tgt_dev; ++ ++ list_for_each_entry(tgt_dev, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ if (tgt_dev != exclude_tgt_dev) ++ scst_check_set_UA(tgt_dev, sense, sense_len, 0); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Called under dev_lock and BH off */ ++void __scst_dev_check_set_UA(struct scst_device *dev, ++ struct scst_cmd *exclude, const uint8_t *sense, int sense_len) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Processing UA dev %s", dev->virt_name); ++ ++ /* Check for reset UA */ ++ if (scst_analyze_sense(sense, sense_len, SCST_SENSE_ASC_VALID, ++ 0, SCST_SENSE_ASC_UA_RESET, 0)) ++ scst_process_reset(dev, ++ (exclude != NULL) ? exclude->sess : NULL, ++ exclude, NULL, false); ++ ++ scst_dev_check_set_local_UA(dev, exclude, sense, sense_len); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Called under tgt_dev_lock or when tgt_dev is unused */ ++static void scst_free_all_UA(struct scst_tgt_dev *tgt_dev) ++{ ++ struct scst_tgt_dev_UA *UA_entry, *t; ++ ++ TRACE_ENTRY(); ++ ++ list_for_each_entry_safe(UA_entry, t, ++ &tgt_dev->UA_list, UA_list_entry) { ++ TRACE_MGMT_DBG("Clearing UA for tgt_dev LUN %lld", ++ (long long unsigned int)tgt_dev->lun); ++ list_del(&UA_entry->UA_list_entry); ++ mempool_free(UA_entry, scst_ua_mempool); ++ } ++ INIT_LIST_HEAD(&tgt_dev->UA_list); ++ clear_bit(SCST_TGT_DEV_UA_PENDING, &tgt_dev->tgt_dev_flags); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* No locks */ ++struct scst_cmd *__scst_check_deferred_commands(struct scst_order_data *order_data) ++{ ++ struct scst_cmd *res = NULL, *cmd, *t; ++ typeof(order_data->expected_sn) expected_sn = order_data->expected_sn; ++ ++ spin_lock_irq(&order_data->sn_lock); ++ ++ if (unlikely(order_data->hq_cmd_count != 0)) ++ goto out_unlock; ++ ++restart: ++ list_for_each_entry_safe(cmd, t, &order_data->deferred_cmd_list, ++ sn_cmd_list_entry) { ++ EXTRACHECKS_BUG_ON(cmd->queue_type == ++ SCST_CMD_QUEUE_HEAD_OF_QUEUE); ++ if (cmd->sn == expected_sn) { ++ TRACE_SN("Deferred command %p (sn %d, set %d) found", ++ cmd, cmd->sn, cmd->sn_set); ++ order_data->def_cmd_count--; ++ list_del(&cmd->sn_cmd_list_entry); ++ if (res == NULL) ++ res = cmd; ++ else { ++ spin_lock(&cmd->cmd_threads->cmd_list_lock); ++ TRACE_SN("Adding cmd %p to active cmd list", ++ cmd); ++ list_add_tail(&cmd->cmd_list_entry, ++ &cmd->cmd_threads->active_cmd_list); ++ wake_up(&cmd->cmd_threads->cmd_list_waitQ); ++ spin_unlock(&cmd->cmd_threads->cmd_list_lock); ++ } ++ } ++ } ++ if (res != NULL) ++ goto out_unlock; ++ ++ list_for_each_entry(cmd, &order_data->skipped_sn_list, ++ sn_cmd_list_entry) { ++ EXTRACHECKS_BUG_ON(cmd->queue_type == ++ SCST_CMD_QUEUE_HEAD_OF_QUEUE); ++ if (cmd->sn == expected_sn) { ++ atomic_t *slot = cmd->sn_slot; ++ /* ++ * !! At this point any pointer in cmd, except !! ++ * !! sn_slot and sn_cmd_list_entry, could be !! ++ * !! already destroyed !! ++ */ ++ TRACE_SN("cmd %p (tag %llu) with skipped sn %d found", ++ cmd, ++ (long long unsigned int)cmd->tag, ++ cmd->sn); ++ order_data->def_cmd_count--; ++ list_del(&cmd->sn_cmd_list_entry); ++ spin_unlock_irq(&order_data->sn_lock); ++ if (test_and_set_bit(SCST_CMD_CAN_BE_DESTROYED, ++ &cmd->cmd_flags)) ++ scst_destroy_put_cmd(cmd); ++ scst_inc_expected_sn(order_data, slot); ++ expected_sn = order_data->expected_sn; ++ spin_lock_irq(&order_data->sn_lock); ++ goto restart; ++ } ++ } ++ ++out_unlock: ++ spin_unlock_irq(&order_data->sn_lock); ++ return res; ++} ++ ++/***************************************************************** ++ ** The following thr_data functions are necessary, because the ++ ** kernel doesn't provide a better way to have threads local ++ ** storage ++ *****************************************************************/ ++ ++/** ++ * scst_add_thr_data() - add the current thread's local data ++ * ++ * Adds local to the current thread data to tgt_dev ++ * (they will be local for the tgt_dev and current thread). ++ */ ++void scst_add_thr_data(struct scst_tgt_dev *tgt_dev, ++ struct scst_thr_data_hdr *data, ++ void (*free_fn) (struct scst_thr_data_hdr *data)) ++{ ++ data->owner_thr = current; ++ atomic_set(&data->ref, 1); ++ EXTRACHECKS_BUG_ON(free_fn == NULL); ++ data->free_fn = free_fn; ++ spin_lock(&tgt_dev->thr_data_lock); ++ list_add_tail(&data->thr_data_list_entry, &tgt_dev->thr_data_list); ++ spin_unlock(&tgt_dev->thr_data_lock); ++} ++EXPORT_SYMBOL_GPL(scst_add_thr_data); ++ ++/** ++ * scst_del_all_thr_data() - delete all thread's local data ++ * ++ * Deletes all local to threads data from tgt_dev ++ */ ++void scst_del_all_thr_data(struct scst_tgt_dev *tgt_dev) ++{ ++ spin_lock(&tgt_dev->thr_data_lock); ++ while (!list_empty(&tgt_dev->thr_data_list)) { ++ struct scst_thr_data_hdr *d = list_entry( ++ tgt_dev->thr_data_list.next, typeof(*d), ++ thr_data_list_entry); ++ list_del(&d->thr_data_list_entry); ++ spin_unlock(&tgt_dev->thr_data_lock); ++ scst_thr_data_put(d); ++ spin_lock(&tgt_dev->thr_data_lock); ++ } ++ spin_unlock(&tgt_dev->thr_data_lock); ++ return; ++} ++EXPORT_SYMBOL_GPL(scst_del_all_thr_data); ++ ++/** ++ * scst_dev_del_all_thr_data() - delete all thread's local data from device ++ * ++ * Deletes all local to threads data from all tgt_dev's of the device ++ */ ++void scst_dev_del_all_thr_data(struct scst_device *dev) ++{ ++ struct scst_tgt_dev *tgt_dev; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_mutex); ++ ++ list_for_each_entry(tgt_dev, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ scst_del_all_thr_data(tgt_dev); ++ } ++ ++ mutex_unlock(&scst_mutex); ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL_GPL(scst_dev_del_all_thr_data); ++ ++/* thr_data_lock supposed to be held */ ++static struct scst_thr_data_hdr *__scst_find_thr_data_locked( ++ struct scst_tgt_dev *tgt_dev, struct task_struct *tsk) ++{ ++ struct scst_thr_data_hdr *res = NULL, *d; ++ ++ list_for_each_entry(d, &tgt_dev->thr_data_list, thr_data_list_entry) { ++ if (d->owner_thr == tsk) { ++ res = d; ++ scst_thr_data_get(res); ++ break; ++ } ++ } ++ return res; ++} ++ ++/** ++ * __scst_find_thr_data() - find local to the thread data ++ * ++ * Finds local to the thread data. Returns NULL, if they not found. ++ */ ++struct scst_thr_data_hdr *__scst_find_thr_data(struct scst_tgt_dev *tgt_dev, ++ struct task_struct *tsk) ++{ ++ struct scst_thr_data_hdr *res; ++ ++ spin_lock(&tgt_dev->thr_data_lock); ++ res = __scst_find_thr_data_locked(tgt_dev, tsk); ++ spin_unlock(&tgt_dev->thr_data_lock); ++ ++ return res; ++} ++EXPORT_SYMBOL_GPL(__scst_find_thr_data); ++ ++bool scst_del_thr_data(struct scst_tgt_dev *tgt_dev, struct task_struct *tsk) ++{ ++ bool res; ++ struct scst_thr_data_hdr *td; ++ ++ spin_lock(&tgt_dev->thr_data_lock); ++ ++ td = __scst_find_thr_data_locked(tgt_dev, tsk); ++ if (td != NULL) { ++ list_del(&td->thr_data_list_entry); ++ res = true; ++ } else ++ res = false; ++ ++ spin_unlock(&tgt_dev->thr_data_lock); ++ ++ if (td != NULL) { ++ /* the find() fn also gets it */ ++ scst_thr_data_put(td); ++ scst_thr_data_put(td); ++ } ++ ++ return res; ++} ++ ++static void __scst_unblock_deferred(struct scst_order_data *order_data, ++ struct scst_cmd *out_of_sn_cmd) ++{ ++ EXTRACHECKS_BUG_ON(!out_of_sn_cmd->sn_set); ++ ++ if (out_of_sn_cmd->sn == order_data->expected_sn) { ++ scst_inc_expected_sn(order_data, out_of_sn_cmd->sn_slot); ++ scst_make_deferred_commands_active(order_data); ++ } else { ++ out_of_sn_cmd->out_of_sn = 1; ++ spin_lock_irq(&order_data->sn_lock); ++ order_data->def_cmd_count++; ++ list_add_tail(&out_of_sn_cmd->sn_cmd_list_entry, ++ &order_data->skipped_sn_list); ++ TRACE_SN("out_of_sn_cmd %p with sn %d added to skipped_sn_list" ++ " (expected_sn %d)", out_of_sn_cmd, out_of_sn_cmd->sn, ++ order_data->expected_sn); ++ spin_unlock_irq(&order_data->sn_lock); ++ } ++ ++ return; ++} ++ ++void scst_unblock_deferred(struct scst_order_data *order_data, ++ struct scst_cmd *out_of_sn_cmd) ++{ ++ TRACE_ENTRY(); ++ ++ if (!out_of_sn_cmd->sn_set) { ++ TRACE_SN("cmd %p without sn", out_of_sn_cmd); ++ goto out; ++ } ++ ++ __scst_unblock_deferred(order_data, out_of_sn_cmd); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* dev_lock supposed to be held and BH disabled */ ++void scst_block_dev(struct scst_device *dev) ++{ ++ dev->block_count++; ++ TRACE_MGMT_DBG("Device BLOCK (new count %d), dev %s", dev->block_count, ++ dev->virt_name); ++} ++ ++/* dev_lock supposed to be held and BH disabled */ ++bool __scst_check_blocked_dev(struct scst_cmd *cmd) ++{ ++ int res = false; ++ struct scst_device *dev = cmd->dev; ++ ++ TRACE_ENTRY(); ++ ++ EXTRACHECKS_BUG_ON(cmd->unblock_dev); ++ ++ if (unlikely(cmd->internal) && (cmd->cdb[0] == REQUEST_SENSE)) { ++ /* ++ * The original command can already block the device, so ++ * REQUEST SENSE command should always pass. ++ */ ++ goto out; ++ } ++ ++ if (unlikely(test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags))) ++ goto out; ++ ++ if (dev->block_count > 0) { ++ TRACE_MGMT_DBG("Delaying cmd %p due to blocking " ++ "(tag %llu, op %x, dev %s)", cmd, ++ (long long unsigned int)cmd->tag, cmd->cdb[0], ++ dev->virt_name); ++ goto out_block; ++ } else if (scst_is_strictly_serialized_cmd(cmd)) { ++ TRACE_MGMT_DBG("cmd %p (tag %llu, op %x): blocking further " ++ "cmds on dev %s due to strict serialization", cmd, ++ (long long unsigned int)cmd->tag, cmd->cdb[0], ++ dev->virt_name); ++ scst_block_dev(dev); ++ if (dev->on_dev_cmd_count > 1) { ++ TRACE_MGMT_DBG("Delaying strictly serialized cmd %p " ++ "(dev %s, on_dev_cmds to wait %d)", cmd, ++ dev->virt_name, dev->on_dev_cmd_count-1); ++ EXTRACHECKS_BUG_ON(dev->strictly_serialized_cmd_waiting); ++ dev->strictly_serialized_cmd_waiting = 1; ++ goto out_block; ++ } else ++ cmd->unblock_dev = 1; ++ } else if ((dev->dev_double_ua_possible) || scst_is_serialized_cmd(cmd)) { ++ TRACE_MGMT_DBG("cmd %p (tag %llu, op %x): blocking further cmds " ++ "on dev %s due to %s", cmd, (long long unsigned int)cmd->tag, ++ cmd->cdb[0], dev->virt_name, ++ dev->dev_double_ua_possible ? "possible double reset UA" : ++ "serialized cmd"); ++ scst_block_dev(dev); ++ cmd->unblock_dev = 1; ++ } else ++ TRACE_MGMT_DBG("No blocks for device %s", dev->virt_name); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_block: ++ if (cmd->queue_type == SCST_CMD_QUEUE_HEAD_OF_QUEUE) ++ list_add(&cmd->blocked_cmd_list_entry, ++ &dev->blocked_cmd_list); ++ else ++ list_add_tail(&cmd->blocked_cmd_list_entry, ++ &dev->blocked_cmd_list); ++ res = true; ++ goto out; ++} ++ ++/* dev_lock supposed to be held and BH disabled */ ++void scst_unblock_dev(struct scst_device *dev) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Device UNBLOCK(new %d), dev %s", ++ dev->block_count-1, dev->virt_name); ++ ++#ifdef CONFIG_SMP ++ EXTRACHECKS_BUG_ON(!spin_is_locked(&dev->dev_lock)); ++#endif ++ ++ if (--dev->block_count == 0) { ++ struct scst_cmd *cmd, *tcmd; ++ unsigned long flags; ++ ++ local_irq_save(flags); ++ list_for_each_entry_safe(cmd, tcmd, &dev->blocked_cmd_list, ++ blocked_cmd_list_entry) { ++ bool strictly_serialized; ++ list_del(&cmd->blocked_cmd_list_entry); ++ TRACE_MGMT_DBG("Adding blocked cmd %p to active cmd " ++ "list", cmd); ++ spin_lock(&cmd->cmd_threads->cmd_list_lock); ++ if (cmd->queue_type == SCST_CMD_QUEUE_HEAD_OF_QUEUE) ++ list_add(&cmd->cmd_list_entry, ++ &cmd->cmd_threads->active_cmd_list); ++ else ++ list_add_tail(&cmd->cmd_list_entry, ++ &cmd->cmd_threads->active_cmd_list); ++ strictly_serialized = scst_is_strictly_serialized_cmd(cmd); ++ wake_up(&cmd->cmd_threads->cmd_list_waitQ); ++ spin_unlock(&cmd->cmd_threads->cmd_list_lock); ++ if (dev->strictly_serialized_cmd_waiting && strictly_serialized) ++ break; ++ } ++ local_irq_restore(flags); ++ ++ dev->strictly_serialized_cmd_waiting = 0; ++ } ++ ++ BUG_ON(dev->block_count < 0); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++void scst_on_hq_cmd_response(struct scst_cmd *cmd) ++{ ++ struct scst_order_data *order_data = cmd->cur_order_data; ++ ++ TRACE_ENTRY(); ++ ++ if (!cmd->hq_cmd_inced) ++ goto out; ++ ++ spin_lock_irq(&order_data->sn_lock); ++ order_data->hq_cmd_count--; ++ spin_unlock_irq(&order_data->sn_lock); ++ ++ EXTRACHECKS_BUG_ON(order_data->hq_cmd_count < 0); ++ ++ /* ++ * There is no problem in checking hq_cmd_count in the ++ * non-locked state. In the worst case we will only have ++ * unneeded run of the deferred commands. ++ */ ++ if (order_data->hq_cmd_count == 0) ++ scst_make_deferred_commands_active(order_data); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++void scst_store_sense(struct scst_cmd *cmd) ++{ ++ TRACE_ENTRY(); ++ ++ if (SCST_SENSE_VALID(cmd->sense) && ++ !test_bit(SCST_CMD_NO_RESP, &cmd->cmd_flags) && ++ (cmd->tgt_dev != NULL)) { ++ struct scst_tgt_dev *tgt_dev = cmd->tgt_dev; ++ ++ TRACE_DBG("Storing sense (cmd %p)", cmd); ++ ++ spin_lock_bh(&tgt_dev->tgt_dev_lock); ++ ++ if (cmd->sense_valid_len <= sizeof(tgt_dev->tgt_dev_sense)) ++ tgt_dev->tgt_dev_valid_sense_len = cmd->sense_valid_len; ++ else { ++ tgt_dev->tgt_dev_valid_sense_len = sizeof(tgt_dev->tgt_dev_sense); ++ PRINT_ERROR("Stored sense truncated to size %d " ++ "(needed %d)", tgt_dev->tgt_dev_valid_sense_len, ++ cmd->sense_valid_len); ++ } ++ memcpy(tgt_dev->tgt_dev_sense, cmd->sense, ++ tgt_dev->tgt_dev_valid_sense_len); ++ ++ spin_unlock_bh(&tgt_dev->tgt_dev_lock); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++void scst_xmit_process_aborted_cmd(struct scst_cmd *cmd) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Aborted cmd %p done (cmd_ref %d)", cmd, ++ atomic_read(&cmd->cmd_ref)); ++ ++ scst_done_cmd_mgmt(cmd); ++ ++ if (test_bit(SCST_CMD_ABORTED_OTHER, &cmd->cmd_flags)) { ++ if (cmd->completed) { ++ /* It's completed and it's OK to return its result */ ++ goto out; ++ } ++ ++ /* For not yet inited commands cmd->dev can be NULL here */ ++ if (test_bit(SCST_CMD_DEVICE_TAS, &cmd->cmd_flags)) { ++ TRACE_MGMT_DBG("Flag ABORTED OTHER set for cmd %p " ++ "(tag %llu), returning TASK ABORTED ", cmd, ++ (long long unsigned int)cmd->tag); ++ scst_set_cmd_error_status(cmd, SAM_STAT_TASK_ABORTED); ++ } else { ++ TRACE_MGMT_DBG("Flag ABORTED OTHER set for cmd %p " ++ "(tag %llu), aborting without delivery or " ++ "notification", ++ cmd, (long long unsigned int)cmd->tag); ++ /* ++ * There is no need to check/requeue possible UA, ++ * because, if it exists, it will be delivered ++ * by the "completed" branch above. ++ */ ++ clear_bit(SCST_CMD_ABORTED_OTHER, &cmd->cmd_flags); ++ } ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ * scst_get_max_lun_commands() - return maximum supported commands count ++ * ++ * Returns maximum commands count which can be queued to this LUN in this ++ * session. ++ * ++ * If lun is NO_SUCH_LUN, returns minimum of maximum commands count which ++ * can be queued to any LUN in this session. ++ * ++ * If sess is NULL, returns minimum of maximum commands count which can be ++ * queued to any SCST device. ++ */ ++int scst_get_max_lun_commands(struct scst_session *sess, uint64_t lun) ++{ ++ return SCST_MAX_TGT_DEV_COMMANDS; ++} ++EXPORT_SYMBOL(scst_get_max_lun_commands); ++ ++/** ++ * scst_reassign_persistent_sess_states() - reassigns persistent states ++ * ++ * Reassigns persistent states from old_sess to new_sess. ++ */ ++void scst_reassign_persistent_sess_states(struct scst_session *new_sess, ++ struct scst_session *old_sess) ++{ ++ struct scst_device *dev; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_PR("Reassigning persistent states from old_sess %p to " ++ "new_sess %p", old_sess, new_sess); ++ ++ if ((new_sess == NULL) || (old_sess == NULL)) { ++ TRACE_DBG("%s", "new_sess or old_sess is NULL"); ++ goto out; ++ } ++ ++ if (new_sess == old_sess) { ++ TRACE_DBG("%s", "new_sess or old_sess are the same"); ++ goto out; ++ } ++ ++ if ((new_sess->transport_id == NULL) || ++ (old_sess->transport_id == NULL)) { ++ TRACE_DBG("%s", "new_sess or old_sess doesn't support PRs"); ++ goto out; ++ } ++ ++ mutex_lock(&scst_mutex); ++ ++ list_for_each_entry(dev, &scst_dev_list, dev_list_entry) { ++ struct scst_tgt_dev *tgt_dev; ++ struct scst_tgt_dev *new_tgt_dev = NULL, *old_tgt_dev = NULL; ++ ++ TRACE_DBG("Processing dev %s", dev->virt_name); ++ ++ list_for_each_entry(tgt_dev, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ if (tgt_dev->sess == new_sess) { ++ new_tgt_dev = tgt_dev; ++ if (old_tgt_dev != NULL) ++ break; ++ } ++ if (tgt_dev->sess == old_sess) { ++ old_tgt_dev = tgt_dev; ++ if (new_tgt_dev != NULL) ++ break; ++ } ++ } ++ ++ if ((new_tgt_dev == NULL) || (old_tgt_dev == NULL)) { ++ TRACE_DBG("new_tgt_dev %p or old_sess %p is NULL, " ++ "skipping (dev %s)", new_tgt_dev, old_tgt_dev, ++ dev->virt_name); ++ continue; ++ } ++ ++ scst_pr_write_lock(dev); ++ ++ if (old_tgt_dev->registrant != NULL) { ++ TRACE_PR("Reassigning reg %p from tgt_dev %p to %p", ++ old_tgt_dev->registrant, old_tgt_dev, ++ new_tgt_dev); ++ ++ if (new_tgt_dev->registrant != NULL) ++ new_tgt_dev->registrant->tgt_dev = NULL; ++ ++ new_tgt_dev->registrant = old_tgt_dev->registrant; ++ new_tgt_dev->registrant->tgt_dev = new_tgt_dev; ++ ++ old_tgt_dev->registrant = NULL; ++ } ++ ++ scst_pr_write_unlock(dev); ++ } ++ ++ mutex_unlock(&scst_mutex); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL(scst_reassign_persistent_sess_states); ++ ++/** ++ * scst_get_next_lexem() - parse and return next lexem in the string ++ * ++ * Returns pointer to the next lexem from token_str skipping ++ * spaces and '=' character and using them then as a delimeter. Content ++ * of token_str is modified by setting '\0' at the delimeter's position. ++ */ ++char *scst_get_next_lexem(char **token_str) ++{ ++ char *p = *token_str; ++ char *q; ++ static const char blank = '\0'; ++ ++ if ((token_str == NULL) || (*token_str == NULL)) ++ return (char *)␣ ++ ++ for (p = *token_str; (*p != '\0') && (isspace(*p) || (*p == '=')); p++) ++ ; ++ ++ for (q = p; (*q != '\0') && !isspace(*q) && (*q != '='); q++) ++ ; ++ ++ if (*q != '\0') ++ *q++ = '\0'; ++ ++ *token_str = q; ++ return p; ++} ++EXPORT_SYMBOL_GPL(scst_get_next_lexem); ++ ++/** ++ * scst_restore_token_str() - restore string modified by scst_get_next_lexem() ++ * ++ * Restores token_str modified by scst_get_next_lexem() to the ++ * previous value before scst_get_next_lexem() was called. Prev_lexem is ++ * a pointer to lexem returned by scst_get_next_lexem(). ++ */ ++void scst_restore_token_str(char *prev_lexem, char *token_str) ++{ ++ if (&prev_lexem[strlen(prev_lexem)] != token_str) ++ prev_lexem[strlen(prev_lexem)] = ' '; ++ return; ++} ++EXPORT_SYMBOL_GPL(scst_restore_token_str); ++ ++/** ++ * scst_get_next_token_str() - parse and return next token ++ * ++ * This function returns pointer to the next token strings from input_str ++ * using '\n', ';' and '\0' as a delimeter. Content of input_str is ++ * modified by setting '\0' at the delimeter's position. ++ */ ++char *scst_get_next_token_str(char **input_str) ++{ ++ char *p = *input_str; ++ int i = 0; ++ ++ while ((p[i] != '\n') && (p[i] != ';') && (p[i] != '\0')) ++ i++; ++ ++ if (i == 0) ++ return NULL; ++ ++ if (p[i] == '\0') ++ *input_str = &p[i]; ++ else ++ *input_str = &p[i+1]; ++ ++ p[i] = '\0'; ++ ++ return p; ++} ++EXPORT_SYMBOL_GPL(scst_get_next_token_str); ++ ++static void __init scst_scsi_op_list_init(void) ++{ ++ int i; ++ uint8_t op = 0xff; ++ ++ TRACE_ENTRY(); ++ ++ for (i = 0; i < 256; i++) ++ scst_scsi_op_list[i] = SCST_CDB_TBL_SIZE; ++ ++ for (i = 0; i < SCST_CDB_TBL_SIZE; i++) { ++ if (scst_scsi_op_table[i].ops != op) { ++ op = scst_scsi_op_table[i].ops; ++ scst_scsi_op_list[op] = i; ++ } ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++int __init scst_lib_init(void) ++{ ++ int res = 0; ++ ++ scst_scsi_op_list_init(); ++ ++ scsi_io_context_cache = kmem_cache_create("scst_scsi_io_context", ++ sizeof(struct scsi_io_context), ++ 0, 0, NULL); ++ if (!scsi_io_context_cache) { ++ PRINT_ERROR("%s", "Can't init scsi io context cache"); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++void scst_lib_exit(void) ++{ ++ BUILD_BUG_ON(SCST_MAX_CDB_SIZE != BLK_MAX_CDB); ++ BUILD_BUG_ON(SCST_SENSE_BUFFERSIZE < SCSI_SENSE_BUFFERSIZE); ++ ++ kmem_cache_destroy(scsi_io_context_cache); ++} ++ ++#ifdef CONFIG_SCST_DEBUG ++ ++/** ++ * scst_random() - return a pseudo-random number for debugging purposes. ++ * ++ * Returns a pseudo-random number for debugging purposes. Available only in ++ * the DEBUG build. ++ * ++ * Original taken from the XFS code ++ */ ++unsigned long scst_random(void) ++{ ++ static int Inited; ++ static unsigned long RandomValue; ++ static DEFINE_SPINLOCK(lock); ++ /* cycles pseudo-randomly through all values between 1 and 2^31 - 2 */ ++ register long rv; ++ register long lo; ++ register long hi; ++ unsigned long flags; ++ ++ spin_lock_irqsave(&lock, flags); ++ if (!Inited) { ++ RandomValue = jiffies; ++ Inited = 1; ++ } ++ rv = RandomValue; ++ hi = rv / 127773; ++ lo = rv % 127773; ++ rv = 16807 * lo - 2836 * hi; ++ if (rv <= 0) ++ rv += 2147483647; ++ RandomValue = rv; ++ spin_unlock_irqrestore(&lock, flags); ++ return rv; ++} ++EXPORT_SYMBOL_GPL(scst_random); ++#endif /* CONFIG_SCST_DEBUG */ ++ ++#ifdef CONFIG_SCST_DEBUG_TM ++ ++#define TM_DBG_STATE_ABORT 0 ++#define TM_DBG_STATE_RESET 1 ++#define TM_DBG_STATE_OFFLINE 2 ++ ++#define INIT_TM_DBG_STATE TM_DBG_STATE_ABORT ++ ++static void tm_dbg_timer_fn(unsigned long arg); ++ ++static DEFINE_SPINLOCK(scst_tm_dbg_lock); ++/* All serialized by scst_tm_dbg_lock */ ++static struct { ++ unsigned int tm_dbg_release:1; ++ unsigned int tm_dbg_blocked:1; ++} tm_dbg_flags; ++static LIST_HEAD(tm_dbg_delayed_cmd_list); ++static int tm_dbg_delayed_cmds_count; ++static int tm_dbg_passed_cmds_count; ++static int tm_dbg_state; ++static int tm_dbg_on_state_passes; ++static DEFINE_TIMER(tm_dbg_timer, tm_dbg_timer_fn, 0, 0); ++static struct scst_tgt_dev *tm_dbg_tgt_dev; ++ ++static const int tm_dbg_on_state_num_passes[] = { 5, 1, 0x7ffffff }; ++ ++static void tm_dbg_init_tgt_dev(struct scst_tgt_dev *tgt_dev) ++{ ++ if (tgt_dev->lun == 6) { ++ unsigned long flags; ++ ++ if (tm_dbg_tgt_dev != NULL) ++ tm_dbg_deinit_tgt_dev(tm_dbg_tgt_dev); ++ ++ spin_lock_irqsave(&scst_tm_dbg_lock, flags); ++ tm_dbg_state = INIT_TM_DBG_STATE; ++ tm_dbg_on_state_passes = ++ tm_dbg_on_state_num_passes[tm_dbg_state]; ++ tm_dbg_tgt_dev = tgt_dev; ++ PRINT_INFO("LUN %lld connected from initiator %s is under " ++ "TM debugging (tgt_dev %p)", ++ (unsigned long long)tgt_dev->lun, ++ tgt_dev->sess->initiator_name, tgt_dev); ++ spin_unlock_irqrestore(&scst_tm_dbg_lock, flags); ++ } ++ return; ++} ++ ++static void tm_dbg_deinit_tgt_dev(struct scst_tgt_dev *tgt_dev) ++{ ++ if (tm_dbg_tgt_dev == tgt_dev) { ++ unsigned long flags; ++ TRACE_MGMT_DBG("Deinit TM debugging tgt_dev %p", tgt_dev); ++ del_timer_sync(&tm_dbg_timer); ++ spin_lock_irqsave(&scst_tm_dbg_lock, flags); ++ tm_dbg_tgt_dev = NULL; ++ spin_unlock_irqrestore(&scst_tm_dbg_lock, flags); ++ } ++ return; ++} ++ ++static void tm_dbg_timer_fn(unsigned long arg) ++{ ++ TRACE_MGMT_DBG("%s", "delayed cmd timer expired"); ++ tm_dbg_flags.tm_dbg_release = 1; ++ /* Used to make sure that all woken up threads see the new value */ ++ smp_wmb(); ++ wake_up_all(&tm_dbg_tgt_dev->active_cmd_threads->cmd_list_waitQ); ++ return; ++} ++ ++/* Called under scst_tm_dbg_lock and IRQs off */ ++static void tm_dbg_delay_cmd(struct scst_cmd *cmd) ++{ ++ switch (tm_dbg_state) { ++ case TM_DBG_STATE_ABORT: ++ if (tm_dbg_delayed_cmds_count == 0) { ++ unsigned long d = 58*HZ + (scst_random() % (4*HZ)); ++ TRACE_MGMT_DBG("STATE ABORT: delaying cmd %p (tag %llu)" ++ " for %ld.%ld seconds (%ld HZ), " ++ "tm_dbg_on_state_passes=%d", cmd, cmd->tag, ++ d/HZ, (d%HZ)*100/HZ, d, tm_dbg_on_state_passes); ++ mod_timer(&tm_dbg_timer, jiffies + d); ++#if 0 ++ tm_dbg_flags.tm_dbg_blocked = 1; ++#endif ++ } else { ++ TRACE_MGMT_DBG("Delaying another timed cmd %p " ++ "(tag %llu), delayed_cmds_count=%d, " ++ "tm_dbg_on_state_passes=%d", cmd, cmd->tag, ++ tm_dbg_delayed_cmds_count, ++ tm_dbg_on_state_passes); ++ if (tm_dbg_delayed_cmds_count == 2) ++ tm_dbg_flags.tm_dbg_blocked = 0; ++ } ++ break; ++ ++ case TM_DBG_STATE_RESET: ++ case TM_DBG_STATE_OFFLINE: ++ TRACE_MGMT_DBG("STATE RESET/OFFLINE: delaying cmd %p " ++ "(tag %llu), delayed_cmds_count=%d, " ++ "tm_dbg_on_state_passes=%d", cmd, cmd->tag, ++ tm_dbg_delayed_cmds_count, tm_dbg_on_state_passes); ++ tm_dbg_flags.tm_dbg_blocked = 1; ++ break; ++ ++ default: ++ BUG(); ++ } ++ /* IRQs already off */ ++ spin_lock(&cmd->cmd_threads->cmd_list_lock); ++ list_add_tail(&cmd->cmd_list_entry, &tm_dbg_delayed_cmd_list); ++ spin_unlock(&cmd->cmd_threads->cmd_list_lock); ++ cmd->tm_dbg_delayed = 1; ++ tm_dbg_delayed_cmds_count++; ++ return; ++} ++ ++/* No locks */ ++void tm_dbg_check_released_cmds(void) ++{ ++ if (tm_dbg_flags.tm_dbg_release) { ++ struct scst_cmd *cmd, *tc; ++ spin_lock_irq(&scst_tm_dbg_lock); ++ list_for_each_entry_safe_reverse(cmd, tc, ++ &tm_dbg_delayed_cmd_list, cmd_list_entry) { ++ TRACE_MGMT_DBG("Releasing timed cmd %p (tag %llu), " ++ "delayed_cmds_count=%d", cmd, cmd->tag, ++ tm_dbg_delayed_cmds_count); ++ spin_lock(&cmd->cmd_threads->cmd_list_lock); ++ list_move(&cmd->cmd_list_entry, ++ &cmd->cmd_threads->active_cmd_list); ++ spin_unlock(&cmd->cmd_threads->cmd_list_lock); ++ } ++ tm_dbg_flags.tm_dbg_release = 0; ++ spin_unlock_irq(&scst_tm_dbg_lock); ++ } ++} ++ ++/* Called under scst_tm_dbg_lock */ ++static void tm_dbg_change_state(void) ++{ ++ tm_dbg_flags.tm_dbg_blocked = 0; ++ if (--tm_dbg_on_state_passes == 0) { ++ switch (tm_dbg_state) { ++ case TM_DBG_STATE_ABORT: ++ TRACE_MGMT_DBG("%s", "Changing " ++ "tm_dbg_state to RESET"); ++ tm_dbg_state = TM_DBG_STATE_RESET; ++ tm_dbg_flags.tm_dbg_blocked = 0; ++ break; ++ case TM_DBG_STATE_RESET: ++ case TM_DBG_STATE_OFFLINE: ++#ifdef CONFIG_SCST_TM_DBG_GO_OFFLINE ++ TRACE_MGMT_DBG("%s", "Changing " ++ "tm_dbg_state to OFFLINE"); ++ tm_dbg_state = TM_DBG_STATE_OFFLINE; ++#else ++ TRACE_MGMT_DBG("%s", "Changing " ++ "tm_dbg_state to ABORT"); ++ tm_dbg_state = TM_DBG_STATE_ABORT; ++#endif ++ break; ++ default: ++ BUG(); ++ } ++ tm_dbg_on_state_passes = ++ tm_dbg_on_state_num_passes[tm_dbg_state]; ++ } ++ ++ TRACE_MGMT_DBG("%s", "Deleting timer"); ++ del_timer_sync(&tm_dbg_timer); ++ return; ++} ++ ++/* No locks */ ++int tm_dbg_check_cmd(struct scst_cmd *cmd) ++{ ++ int res = 0; ++ unsigned long flags; ++ ++ if (cmd->tm_dbg_immut) ++ goto out; ++ ++ if (cmd->tm_dbg_delayed) { ++ spin_lock_irqsave(&scst_tm_dbg_lock, flags); ++ TRACE_MGMT_DBG("Processing delayed cmd %p (tag %llu), " ++ "delayed_cmds_count=%d", cmd, cmd->tag, ++ tm_dbg_delayed_cmds_count); ++ ++ cmd->tm_dbg_immut = 1; ++ tm_dbg_delayed_cmds_count--; ++ if ((tm_dbg_delayed_cmds_count == 0) && ++ (tm_dbg_state == TM_DBG_STATE_ABORT)) ++ tm_dbg_change_state(); ++ spin_unlock_irqrestore(&scst_tm_dbg_lock, flags); ++ } else if (cmd->tgt_dev && (tm_dbg_tgt_dev == cmd->tgt_dev)) { ++ /* Delay 50th command */ ++ spin_lock_irqsave(&scst_tm_dbg_lock, flags); ++ if (tm_dbg_flags.tm_dbg_blocked || ++ (++tm_dbg_passed_cmds_count % 50) == 0) { ++ tm_dbg_delay_cmd(cmd); ++ res = 1; ++ } else ++ cmd->tm_dbg_immut = 1; ++ spin_unlock_irqrestore(&scst_tm_dbg_lock, flags); ++ } ++ ++out: ++ return res; ++} ++ ++/* No locks */ ++void tm_dbg_release_cmd(struct scst_cmd *cmd) ++{ ++ struct scst_cmd *c; ++ unsigned long flags; ++ ++ spin_lock_irqsave(&scst_tm_dbg_lock, flags); ++ list_for_each_entry(c, &tm_dbg_delayed_cmd_list, ++ cmd_list_entry) { ++ if (c == cmd) { ++ TRACE_MGMT_DBG("Abort request for " ++ "delayed cmd %p (tag=%llu), moving it to " ++ "active cmd list (delayed_cmds_count=%d)", ++ c, c->tag, tm_dbg_delayed_cmds_count); ++ ++ if (!test_bit(SCST_CMD_ABORTED_OTHER, ++ &cmd->cmd_flags)) { ++ /* Test how completed commands handled */ ++ if (((scst_random() % 10) == 5)) { ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE( ++ scst_sense_hardw_error)); ++ /* It's completed now */ ++ } ++ } ++ ++ spin_lock(&cmd->cmd_threads->cmd_list_lock); ++ list_move(&c->cmd_list_entry, ++ &c->cmd_threads->active_cmd_list); ++ wake_up(&c->cmd_threads->cmd_list_waitQ); ++ spin_unlock(&cmd->cmd_threads->cmd_list_lock); ++ break; ++ } ++ } ++ spin_unlock_irqrestore(&scst_tm_dbg_lock, flags); ++ return; ++} ++ ++/* Might be called under scst_mutex */ ++void tm_dbg_task_mgmt(struct scst_device *dev, const char *fn, int force) ++{ ++ unsigned long flags; ++ ++ if (dev != NULL) { ++ if (tm_dbg_tgt_dev == NULL) ++ goto out; ++ ++ if (tm_dbg_tgt_dev->dev != dev) ++ goto out; ++ } ++ ++ spin_lock_irqsave(&scst_tm_dbg_lock, flags); ++ if ((tm_dbg_state != TM_DBG_STATE_OFFLINE) || force) { ++ TRACE_MGMT_DBG("%s: freeing %d delayed cmds", fn, ++ tm_dbg_delayed_cmds_count); ++ tm_dbg_change_state(); ++ tm_dbg_flags.tm_dbg_release = 1; ++ /* ++ * Used to make sure that all woken up threads see the new ++ * value. ++ */ ++ smp_wmb(); ++ if (tm_dbg_tgt_dev != NULL) ++ wake_up_all(&tm_dbg_tgt_dev->active_cmd_threads->cmd_list_waitQ); ++ } else { ++ TRACE_MGMT_DBG("%s: while OFFLINE state, doing nothing", fn); ++ } ++ spin_unlock_irqrestore(&scst_tm_dbg_lock, flags); ++ ++out: ++ return; ++} ++ ++int tm_dbg_is_release(void) ++{ ++ return tm_dbg_flags.tm_dbg_release; ++} ++#endif /* CONFIG_SCST_DEBUG_TM */ ++ ++#ifdef CONFIG_SCST_DEBUG_SN ++void scst_check_debug_sn(struct scst_cmd *cmd) ++{ ++ static DEFINE_SPINLOCK(lock); ++ static int type; ++ static int cnt; ++ unsigned long flags; ++ int old = cmd->queue_type; ++ ++ spin_lock_irqsave(&lock, flags); ++ ++ if (cnt == 0) { ++ if ((scst_random() % 1000) == 500) { ++ if ((scst_random() % 3) == 1) ++ type = SCST_CMD_QUEUE_HEAD_OF_QUEUE; ++ else ++ type = SCST_CMD_QUEUE_ORDERED; ++ do { ++ cnt = scst_random() % 10; ++ } while (cnt == 0); ++ } else ++ goto out_unlock; ++ } ++ ++ cmd->queue_type = type; ++ cnt--; ++ ++ if (((scst_random() % 1000) == 750)) ++ cmd->queue_type = SCST_CMD_QUEUE_ORDERED; ++ else if (((scst_random() % 1000) == 751)) ++ cmd->queue_type = SCST_CMD_QUEUE_HEAD_OF_QUEUE; ++ else if (((scst_random() % 1000) == 752)) ++ cmd->queue_type = SCST_CMD_QUEUE_SIMPLE; ++ ++ TRACE_SN("DbgSN changed cmd %p: %d/%d (cnt %d)", cmd, old, ++ cmd->queue_type, cnt); ++ ++out_unlock: ++ spin_unlock_irqrestore(&lock, flags); ++ return; ++} ++#endif /* CONFIG_SCST_DEBUG_SN */ ++ ++#ifdef CONFIG_SCST_MEASURE_LATENCY ++ ++static uint64_t scst_get_nsec(void) ++{ ++ struct timespec ts; ++ ktime_get_ts(&ts); ++ return (uint64_t)ts.tv_sec * 1000000000 + ts.tv_nsec; ++} ++ ++void scst_set_start_time(struct scst_cmd *cmd) ++{ ++ cmd->start = scst_get_nsec(); ++ TRACE_DBG("cmd %p: start %lld", cmd, cmd->start); ++} ++ ++void scst_set_cur_start(struct scst_cmd *cmd) ++{ ++ cmd->curr_start = scst_get_nsec(); ++ TRACE_DBG("cmd %p: cur_start %lld", cmd, cmd->curr_start); ++} ++ ++void scst_set_parse_time(struct scst_cmd *cmd) ++{ ++ cmd->parse_time += scst_get_nsec() - cmd->curr_start; ++ TRACE_DBG("cmd %p: parse_time %lld", cmd, cmd->parse_time); ++} ++ ++void scst_set_alloc_buf_time(struct scst_cmd *cmd) ++{ ++ cmd->alloc_buf_time += scst_get_nsec() - cmd->curr_start; ++ TRACE_DBG("cmd %p: alloc_buf_time %lld", cmd, cmd->alloc_buf_time); ++} ++ ++void scst_set_restart_waiting_time(struct scst_cmd *cmd) ++{ ++ cmd->restart_waiting_time += scst_get_nsec() - cmd->curr_start; ++ TRACE_DBG("cmd %p: restart_waiting_time %lld", cmd, ++ cmd->restart_waiting_time); ++} ++ ++void scst_set_rdy_to_xfer_time(struct scst_cmd *cmd) ++{ ++ cmd->rdy_to_xfer_time += scst_get_nsec() - cmd->curr_start; ++ TRACE_DBG("cmd %p: rdy_to_xfer_time %lld", cmd, cmd->rdy_to_xfer_time); ++} ++ ++void scst_set_pre_exec_time(struct scst_cmd *cmd) ++{ ++ cmd->pre_exec_time += scst_get_nsec() - cmd->curr_start; ++ TRACE_DBG("cmd %p: pre_exec_time %lld", cmd, cmd->pre_exec_time); ++} ++ ++void scst_set_exec_time(struct scst_cmd *cmd) ++{ ++ cmd->exec_time += scst_get_nsec() - cmd->curr_start; ++ TRACE_DBG("cmd %p: exec_time %lld", cmd, cmd->exec_time); ++} ++ ++void scst_set_dev_done_time(struct scst_cmd *cmd) ++{ ++ cmd->dev_done_time += scst_get_nsec() - cmd->curr_start; ++ TRACE_DBG("cmd %p: dev_done_time %lld", cmd, cmd->dev_done_time); ++} ++ ++void scst_set_xmit_time(struct scst_cmd *cmd) ++{ ++ cmd->xmit_time += scst_get_nsec() - cmd->curr_start; ++ TRACE_DBG("cmd %p: xmit_time %lld", cmd, cmd->xmit_time); ++} ++ ++void scst_set_tgt_on_free_time(struct scst_cmd *cmd) ++{ ++ cmd->tgt_on_free_time += scst_get_nsec() - cmd->curr_start; ++ TRACE_DBG("cmd %p: tgt_on_free_time %lld", cmd, cmd->tgt_on_free_time); ++} ++ ++void scst_set_dev_on_free_time(struct scst_cmd *cmd) ++{ ++ cmd->dev_on_free_time += scst_get_nsec() - cmd->curr_start; ++ TRACE_DBG("cmd %p: dev_on_free_time %lld", cmd, cmd->dev_on_free_time); ++} ++ ++void scst_update_lat_stats(struct scst_cmd *cmd) ++{ ++ uint64_t finish, scst_time, tgt_time, dev_time; ++ struct scst_session *sess = cmd->sess; ++ int data_len; ++ int i; ++ struct scst_ext_latency_stat *latency_stat, *dev_latency_stat; ++ ++ finish = scst_get_nsec(); ++ ++ /* Determine the IO size for extended latency statistics */ ++ data_len = cmd->bufflen; ++ i = SCST_LATENCY_STAT_INDEX_OTHER; ++ if (data_len <= SCST_IO_SIZE_THRESHOLD_SMALL) ++ i = SCST_LATENCY_STAT_INDEX_SMALL; ++ else if (data_len <= SCST_IO_SIZE_THRESHOLD_MEDIUM) ++ i = SCST_LATENCY_STAT_INDEX_MEDIUM; ++ else if (data_len <= SCST_IO_SIZE_THRESHOLD_LARGE) ++ i = SCST_LATENCY_STAT_INDEX_LARGE; ++ else if (data_len <= SCST_IO_SIZE_THRESHOLD_VERY_LARGE) ++ i = SCST_LATENCY_STAT_INDEX_VERY_LARGE; ++ latency_stat = &sess->sess_latency_stat[i]; ++ if (cmd->tgt_dev != NULL) ++ dev_latency_stat = &cmd->tgt_dev->dev_latency_stat[i]; ++ else ++ dev_latency_stat = NULL; ++ ++ /* Calculate the latencies */ ++ scst_time = finish - cmd->start - (cmd->parse_time + ++ cmd->alloc_buf_time + cmd->restart_waiting_time + ++ cmd->rdy_to_xfer_time + cmd->pre_exec_time + ++ cmd->exec_time + cmd->dev_done_time + cmd->xmit_time + ++ cmd->tgt_on_free_time + cmd->dev_on_free_time); ++ tgt_time = cmd->alloc_buf_time + cmd->restart_waiting_time + ++ cmd->rdy_to_xfer_time + cmd->pre_exec_time + ++ cmd->xmit_time + cmd->tgt_on_free_time; ++ dev_time = cmd->parse_time + cmd->exec_time + cmd->dev_done_time + ++ cmd->dev_on_free_time; ++ ++ spin_lock_bh(&sess->lat_lock); ++ ++ /* Save the basic latency information */ ++ sess->scst_time += scst_time; ++ sess->tgt_time += tgt_time; ++ sess->dev_time += dev_time; ++ sess->processed_cmds++; ++ ++ if ((sess->min_scst_time == 0) || ++ (sess->min_scst_time > scst_time)) ++ sess->min_scst_time = scst_time; ++ if ((sess->min_tgt_time == 0) || ++ (sess->min_tgt_time > tgt_time)) ++ sess->min_tgt_time = tgt_time; ++ if ((sess->min_dev_time == 0) || ++ (sess->min_dev_time > dev_time)) ++ sess->min_dev_time = dev_time; ++ ++ if (sess->max_scst_time < scst_time) ++ sess->max_scst_time = scst_time; ++ if (sess->max_tgt_time < tgt_time) ++ sess->max_tgt_time = tgt_time; ++ if (sess->max_dev_time < dev_time) ++ sess->max_dev_time = dev_time; ++ ++ /* Save the extended latency information */ ++ if (cmd->data_direction & SCST_DATA_READ) { ++ latency_stat->scst_time_rd += scst_time; ++ latency_stat->tgt_time_rd += tgt_time; ++ latency_stat->dev_time_rd += dev_time; ++ latency_stat->processed_cmds_rd++; ++ ++ if ((latency_stat->min_scst_time_rd == 0) || ++ (latency_stat->min_scst_time_rd > scst_time)) ++ latency_stat->min_scst_time_rd = scst_time; ++ if ((latency_stat->min_tgt_time_rd == 0) || ++ (latency_stat->min_tgt_time_rd > tgt_time)) ++ latency_stat->min_tgt_time_rd = tgt_time; ++ if ((latency_stat->min_dev_time_rd == 0) || ++ (latency_stat->min_dev_time_rd > dev_time)) ++ latency_stat->min_dev_time_rd = dev_time; ++ ++ if (latency_stat->max_scst_time_rd < scst_time) ++ latency_stat->max_scst_time_rd = scst_time; ++ if (latency_stat->max_tgt_time_rd < tgt_time) ++ latency_stat->max_tgt_time_rd = tgt_time; ++ if (latency_stat->max_dev_time_rd < dev_time) ++ latency_stat->max_dev_time_rd = dev_time; ++ ++ if (dev_latency_stat != NULL) { ++ dev_latency_stat->scst_time_rd += scst_time; ++ dev_latency_stat->tgt_time_rd += tgt_time; ++ dev_latency_stat->dev_time_rd += dev_time; ++ dev_latency_stat->processed_cmds_rd++; ++ ++ if ((dev_latency_stat->min_scst_time_rd == 0) || ++ (dev_latency_stat->min_scst_time_rd > scst_time)) ++ dev_latency_stat->min_scst_time_rd = scst_time; ++ if ((dev_latency_stat->min_tgt_time_rd == 0) || ++ (dev_latency_stat->min_tgt_time_rd > tgt_time)) ++ dev_latency_stat->min_tgt_time_rd = tgt_time; ++ if ((dev_latency_stat->min_dev_time_rd == 0) || ++ (dev_latency_stat->min_dev_time_rd > dev_time)) ++ dev_latency_stat->min_dev_time_rd = dev_time; ++ ++ if (dev_latency_stat->max_scst_time_rd < scst_time) ++ dev_latency_stat->max_scst_time_rd = scst_time; ++ if (dev_latency_stat->max_tgt_time_rd < tgt_time) ++ dev_latency_stat->max_tgt_time_rd = tgt_time; ++ if (dev_latency_stat->max_dev_time_rd < dev_time) ++ dev_latency_stat->max_dev_time_rd = dev_time; ++ } ++ } else if (cmd->data_direction & SCST_DATA_WRITE) { ++ latency_stat->scst_time_wr += scst_time; ++ latency_stat->tgt_time_wr += tgt_time; ++ latency_stat->dev_time_wr += dev_time; ++ latency_stat->processed_cmds_wr++; ++ ++ if ((latency_stat->min_scst_time_wr == 0) || ++ (latency_stat->min_scst_time_wr > scst_time)) ++ latency_stat->min_scst_time_wr = scst_time; ++ if ((latency_stat->min_tgt_time_wr == 0) || ++ (latency_stat->min_tgt_time_wr > tgt_time)) ++ latency_stat->min_tgt_time_wr = tgt_time; ++ if ((latency_stat->min_dev_time_wr == 0) || ++ (latency_stat->min_dev_time_wr > dev_time)) ++ latency_stat->min_dev_time_wr = dev_time; ++ ++ if (latency_stat->max_scst_time_wr < scst_time) ++ latency_stat->max_scst_time_wr = scst_time; ++ if (latency_stat->max_tgt_time_wr < tgt_time) ++ latency_stat->max_tgt_time_wr = tgt_time; ++ if (latency_stat->max_dev_time_wr < dev_time) ++ latency_stat->max_dev_time_wr = dev_time; ++ ++ if (dev_latency_stat != NULL) { ++ dev_latency_stat->scst_time_wr += scst_time; ++ dev_latency_stat->tgt_time_wr += tgt_time; ++ dev_latency_stat->dev_time_wr += dev_time; ++ dev_latency_stat->processed_cmds_wr++; ++ ++ if ((dev_latency_stat->min_scst_time_wr == 0) || ++ (dev_latency_stat->min_scst_time_wr > scst_time)) ++ dev_latency_stat->min_scst_time_wr = scst_time; ++ if ((dev_latency_stat->min_tgt_time_wr == 0) || ++ (dev_latency_stat->min_tgt_time_wr > tgt_time)) ++ dev_latency_stat->min_tgt_time_wr = tgt_time; ++ if ((dev_latency_stat->min_dev_time_wr == 0) || ++ (dev_latency_stat->min_dev_time_wr > dev_time)) ++ dev_latency_stat->min_dev_time_wr = dev_time; ++ ++ if (dev_latency_stat->max_scst_time_wr < scst_time) ++ dev_latency_stat->max_scst_time_wr = scst_time; ++ if (dev_latency_stat->max_tgt_time_wr < tgt_time) ++ dev_latency_stat->max_tgt_time_wr = tgt_time; ++ if (dev_latency_stat->max_dev_time_wr < dev_time) ++ dev_latency_stat->max_dev_time_wr = dev_time; ++ } ++ } ++ ++ spin_unlock_bh(&sess->lat_lock); ++ ++ TRACE_DBG("cmd %p: finish %lld, scst_time %lld, " ++ "tgt_time %lld, dev_time %lld", cmd, finish, scst_time, ++ tgt_time, dev_time); ++ return; ++} ++ ++#endif /* CONFIG_SCST_MEASURE_LATENCY */ +diff -uprN orig/linux-3.2/drivers/scst/scst_pres.h linux-3.2/drivers/scst/scst_pres.h +--- orig/linux-3.2/drivers/scst/scst_pres.h ++++ linux-3.2/drivers/scst/scst_pres.h +@@ -0,0 +1,234 @@ ++/* ++ * scst_pres.c ++ * ++ * Copyright (C) 2009 - 2010 Alexey Obitotskiy <alexeyo1@open-e.com> ++ * Copyright (C) 2009 - 2010 Open-E, Inc. ++ * Copyright (C) 2009 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#ifndef SCST_PRES_H_ ++#define SCST_PRES_H_ ++ ++#include <linux/delay.h> ++ ++#define PR_REGISTER 0x00 ++#define PR_RESERVE 0x01 ++#define PR_RELEASE 0x02 ++#define PR_CLEAR 0x03 ++#define PR_PREEMPT 0x04 ++#define PR_PREEMPT_AND_ABORT 0x05 ++#define PR_REGISTER_AND_IGNORE 0x06 ++#define PR_REGISTER_AND_MOVE 0x07 ++ ++#define PR_READ_KEYS 0x00 ++#define PR_READ_RESERVATION 0x01 ++#define PR_REPORT_CAPS 0x02 ++#define PR_READ_FULL_STATUS 0x03 ++ ++#define TYPE_UNSPECIFIED (-1) ++#define TYPE_WRITE_EXCLUSIVE 0x01 ++#define TYPE_EXCLUSIVE_ACCESS 0x03 ++#define TYPE_WRITE_EXCLUSIVE_REGONLY 0x05 ++#define TYPE_EXCLUSIVE_ACCESS_REGONLY 0x06 ++#define TYPE_WRITE_EXCLUSIVE_ALL_REG 0x07 ++#define TYPE_EXCLUSIVE_ACCESS_ALL_REG 0x08 ++ ++#define SCOPE_LU 0x00 ++ ++static inline void scst_inc_pr_readers_count(struct scst_cmd *cmd, ++ bool locked) ++{ ++ struct scst_device *dev = cmd->dev; ++ ++ EXTRACHECKS_BUG_ON(cmd->dec_pr_readers_count_needed); ++ ++ if (!locked) ++ spin_lock_bh(&dev->dev_lock); ++ ++#ifdef CONFIG_SMP ++ EXTRACHECKS_BUG_ON(!spin_is_locked(&dev->dev_lock)); ++#endif ++ ++ dev->pr_readers_count++; ++ cmd->dec_pr_readers_count_needed = 1; ++ TRACE_DBG("New inc pr_readers_count %d (cmd %p)", dev->pr_readers_count, ++ cmd); ++ ++ if (!locked) ++ spin_unlock_bh(&dev->dev_lock); ++ return; ++} ++ ++static inline void scst_dec_pr_readers_count(struct scst_cmd *cmd, ++ bool locked) ++{ ++ struct scst_device *dev = cmd->dev; ++ ++ if (unlikely(!cmd->dec_pr_readers_count_needed)) { ++ PRINT_ERROR("scst_check_local_events() should not be called " ++ "twice (cmd %p, op %x)! Use " ++ "scst_pre_check_local_events() instead.", cmd, ++ cmd->cdb[0]); ++ WARN_ON(1); ++ goto out; ++ } ++ ++ if (!locked) ++ spin_lock_bh(&dev->dev_lock); ++ ++#ifdef CONFIG_SMP ++ EXTRACHECKS_BUG_ON(!spin_is_locked(&dev->dev_lock)); ++#endif ++ ++ dev->pr_readers_count--; ++ cmd->dec_pr_readers_count_needed = 0; ++ TRACE_DBG("New dec pr_readers_count %d (cmd %p)", dev->pr_readers_count, ++ cmd); ++ ++ if (!locked) ++ spin_unlock_bh(&dev->dev_lock); ++ ++out: ++ EXTRACHECKS_BUG_ON(dev->pr_readers_count < 0); ++ return; ++} ++ ++static inline void scst_reset_requeued_cmd(struct scst_cmd *cmd) ++{ ++ TRACE_DBG("Reset requeued cmd %p (op %x)", cmd, cmd->cdb[0]); ++ scst_inc_pr_readers_count(cmd, false); ++ cmd->check_local_events_once_done = 0; ++ return; ++} ++ ++static inline bool scst_pr_type_valid(uint8_t type) ++{ ++ switch (type) { ++ case TYPE_WRITE_EXCLUSIVE: ++ case TYPE_EXCLUSIVE_ACCESS: ++ case TYPE_WRITE_EXCLUSIVE_REGONLY: ++ case TYPE_EXCLUSIVE_ACCESS_REGONLY: ++ case TYPE_WRITE_EXCLUSIVE_ALL_REG: ++ case TYPE_EXCLUSIVE_ACCESS_ALL_REG: ++ return true; ++ default: ++ return false; ++ } ++} ++ ++static inline bool scst_pr_read_lock(struct scst_cmd *cmd) ++{ ++ struct scst_device *dev = cmd->dev; ++ bool unlock = false; ++ ++ TRACE_ENTRY(); ++ ++ smp_mb(); /* to sync with scst_pr_write_lock() */ ++ if (unlikely(dev->pr_writer_active)) { ++ unlock = true; ++ scst_dec_pr_readers_count(cmd, false); ++ mutex_lock(&dev->dev_pr_mutex); ++ } ++ ++ TRACE_EXIT_RES(unlock); ++ return unlock; ++} ++ ++static inline void scst_pr_read_unlock(struct scst_cmd *cmd, bool unlock) ++{ ++ struct scst_device *dev = cmd->dev; ++ ++ TRACE_ENTRY(); ++ ++ if (unlikely(unlock)) ++ mutex_unlock(&dev->dev_pr_mutex); ++ else ++ scst_dec_pr_readers_count(cmd, false); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static inline void scst_pr_write_lock(struct scst_device *dev) ++{ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&dev->dev_pr_mutex); ++ ++ dev->pr_writer_active = 1; ++ /* to sync with scst_pr_read_lock() and unlock() */ ++ smp_mb(); ++ ++ while (true) { ++ int readers; ++ spin_lock_bh(&dev->dev_lock); ++ readers = dev->pr_readers_count; ++ spin_unlock_bh(&dev->dev_lock); ++ if (readers == 0) ++ break; ++ TRACE_DBG("Waiting for %d readers (dev %p)", readers, dev); ++ msleep(1); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static inline void scst_pr_write_unlock(struct scst_device *dev) ++{ ++ TRACE_ENTRY(); ++ ++ dev->pr_writer_active = 0; ++ mutex_unlock(&dev->dev_pr_mutex); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++int scst_pr_init_dev(struct scst_device *dev); ++void scst_pr_clear_dev(struct scst_device *dev); ++ ++int scst_pr_init_tgt_dev(struct scst_tgt_dev *tgt_dev); ++void scst_pr_clear_tgt_dev(struct scst_tgt_dev *tgt_dev); ++ ++bool scst_pr_crh_case(struct scst_cmd *cmd); ++bool scst_pr_is_cmd_allowed(struct scst_cmd *cmd); ++ ++void scst_pr_register(struct scst_cmd *cmd, uint8_t *buffer, int buffer_size); ++void scst_pr_register_and_ignore(struct scst_cmd *cmd, uint8_t *buffer, ++ int buffer_size); ++void scst_pr_register_and_move(struct scst_cmd *cmd, uint8_t *buffer, ++ int buffer_size); ++void scst_pr_reserve(struct scst_cmd *cmd, uint8_t *buffer, int buffer_size); ++void scst_pr_release(struct scst_cmd *cmd, uint8_t *buffer, int buffer_size); ++void scst_pr_clear(struct scst_cmd *cmd, uint8_t *buffer, int buffer_size); ++void scst_pr_preempt(struct scst_cmd *cmd, uint8_t *buffer, int buffer_size); ++void scst_pr_preempt_and_abort(struct scst_cmd *cmd, uint8_t *buffer, ++ int buffer_size); ++ ++void scst_pr_read_keys(struct scst_cmd *cmd, uint8_t *buffer, int buffer_size); ++void scst_pr_read_reservation(struct scst_cmd *cmd, uint8_t *buffer, ++ int buffer_size); ++void scst_pr_report_caps(struct scst_cmd *cmd, uint8_t *buffer, int buffer_size); ++void scst_pr_read_full_status(struct scst_cmd *cmd, uint8_t *buffer, ++ int buffer_size); ++ ++void scst_pr_sync_device_file(struct scst_tgt_dev *tgt_dev, struct scst_cmd *cmd); ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++void scst_pr_dump_prs(struct scst_device *dev, bool force); ++#else ++static inline void scst_pr_dump_prs(struct scst_device *dev, bool force) {} ++#endif ++ ++#endif /* SCST_PRES_H_ */ +diff -uprN orig/linux-3.2/drivers/scst/scst_pres.c linux-3.2/drivers/scst/scst_pres.c +--- orig/linux-3.2/drivers/scst/scst_pres.c ++++ linux-3.2/drivers/scst/scst_pres.c +@@ -0,0 +1,2636 @@ ++/* ++ * scst_pres.c ++ * ++ * Copyright (C) 2009 - 2010 Alexey Obitotskiy <alexeyo1@open-e.com> ++ * Copyright (C) 2009 - 2010 Open-E, Inc. ++ * Copyright (C) 2009 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/init.h> ++#include <linux/kernel.h> ++#include <linux/errno.h> ++#include <linux/list.h> ++#include <linux/spinlock.h> ++#include <linux/slab.h> ++#include <linux/sched.h> ++#include <linux/unistd.h> ++#include <linux/string.h> ++#include <linux/kthread.h> ++#include <linux/delay.h> ++#include <linux/time.h> ++#include <linux/ctype.h> ++#include <asm/byteorder.h> ++#include <linux/syscalls.h> ++#include <linux/file.h> ++#include <linux/fs.h> ++#include <linux/fcntl.h> ++#include <linux/uaccess.h> ++#include <linux/namei.h> ++#include <linux/vmalloc.h> ++#include <asm/unaligned.h> ++ ++#include <scst/scst.h> ++#include <scst/scst_const.h> ++#include "scst_priv.h" ++#include "scst_pres.h" ++ ++#define SCST_PR_ROOT_ENTRY "pr" ++#define SCST_PR_FILE_SIGN 0xBBEEEEAAEEBBDD77LLU ++#define SCST_PR_FILE_VERSION 1LLU ++ ++#define FILE_BUFFER_SIZE 512 ++ ++#ifndef isblank ++#define isblank(c) ((c) == ' ' || (c) == '\t') ++#endif ++ ++static inline int tid_size(const uint8_t *tid) ++{ ++ BUG_ON(tid == NULL); ++ ++ if ((tid[0] & 0x0f) == SCSI_TRANSPORTID_PROTOCOLID_ISCSI) ++ return be16_to_cpu(get_unaligned((__be16 *)&tid[2])) + 4; ++ else ++ return TID_COMMON_SIZE; ++} ++ ++/* Secures tid by setting 0 in the last byte of NULL-terminated tid's */ ++static inline void tid_secure(uint8_t *tid) ++{ ++ if ((tid[0] & 0x0f) == SCSI_TRANSPORTID_PROTOCOLID_ISCSI) { ++ int size = tid_size(tid); ++ tid[size - 1] = '\0'; ++ } ++ ++ return; ++} ++ ++/* Returns false if tid's are not equal, true otherwise */ ++static bool tid_equal(const uint8_t *tid_a, const uint8_t *tid_b) ++{ ++ int len; ++ ++ if (tid_a == NULL || tid_b == NULL) ++ return false; ++ ++ if ((tid_a[0] & 0x0f) != (tid_b[0] & 0x0f)) { ++ TRACE_DBG("%s", "Different protocol IDs"); ++ return false; ++ } ++ ++ if ((tid_a[0] & 0x0f) == SCSI_TRANSPORTID_PROTOCOLID_ISCSI) { ++ const uint8_t tid_a_fmt = tid_a[0] & 0xc0; ++ const uint8_t tid_b_fmt = tid_b[0] & 0xc0; ++ int tid_a_len, tid_a_max = tid_size(tid_a) - 4; ++ int tid_b_len, tid_b_max = tid_size(tid_b) - 4; ++ int i; ++ ++ tid_a += 4; ++ tid_b += 4; ++ ++ if (tid_a_fmt == 0x00) ++ tid_a_len = strnlen(tid_a, tid_a_max); ++ else if (tid_a_fmt == 0x40) { ++ if (tid_a_fmt != tid_b_fmt) { ++ uint8_t *p = strnchr(tid_a, tid_a_max, ','); ++ if (p == NULL) ++ goto out_error; ++ tid_a_len = p - tid_a; ++ ++ BUG_ON(tid_a_len > tid_a_max); ++ BUG_ON(tid_a_len < 0); ++ } else ++ tid_a_len = strnlen(tid_a, tid_a_max); ++ } else ++ goto out_error; ++ ++ if (tid_b_fmt == 0x00) ++ tid_b_len = strnlen(tid_b, tid_b_max); ++ else if (tid_b_fmt == 0x40) { ++ if (tid_a_fmt != tid_b_fmt) { ++ uint8_t *p = strnchr(tid_b, tid_b_max, ','); ++ if (p == NULL) ++ goto out_error; ++ tid_b_len = p - tid_b; ++ ++ BUG_ON(tid_b_len > tid_b_max); ++ BUG_ON(tid_b_len < 0); ++ } else ++ tid_b_len = strnlen(tid_b, tid_b_max); ++ } else ++ goto out_error; ++ ++ if (tid_a_len != tid_b_len) ++ return false; ++ ++ len = tid_a_len; ++ ++ /* ISCSI names are case insensitive */ ++ for (i = 0; i < len; i++) ++ if (tolower(tid_a[i]) != tolower(tid_b[i])) ++ return false; ++ return true; ++ } else ++ len = TID_COMMON_SIZE; ++ ++ return memcmp(tid_a, tid_b, len) == 0; ++ ++out_error: ++ PRINT_ERROR("%s", "Invalid initiator port transport id"); ++ return false; ++} ++ ++/* Must be called under dev_pr_mutex */ ++static inline void scst_pr_set_holder(struct scst_device *dev, ++ struct scst_dev_registrant *holder, uint8_t scope, uint8_t type) ++{ ++ dev->pr_is_set = 1; ++ dev->pr_scope = scope; ++ dev->pr_type = type; ++ if (dev->pr_type != TYPE_EXCLUSIVE_ACCESS_ALL_REG && ++ dev->pr_type != TYPE_WRITE_EXCLUSIVE_ALL_REG) ++ dev->pr_holder = holder; ++} ++ ++/* Must be called under dev_pr_mutex */ ++static bool scst_pr_is_holder(struct scst_device *dev, ++ struct scst_dev_registrant *reg) ++{ ++ bool res = false; ++ ++ TRACE_ENTRY(); ++ ++ if (!dev->pr_is_set) ++ goto out; ++ ++ if (dev->pr_type == TYPE_EXCLUSIVE_ACCESS_ALL_REG || ++ dev->pr_type == TYPE_WRITE_EXCLUSIVE_ALL_REG) { ++ res = (reg != NULL); ++ } else ++ res = (dev->pr_holder == reg); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ ++/* Must be called under dev_pr_mutex */ ++void scst_pr_dump_prs(struct scst_device *dev, bool force) ++{ ++ if (!force) { ++#if defined(CONFIG_SCST_DEBUG) ++ if ((trace_flag & TRACE_PRES) == 0) ++#endif ++ goto out; ++ } ++ ++ PRINT_INFO("Persistent reservations for device %s:", dev->virt_name); ++ ++ if (list_empty(&dev->dev_registrants_list)) ++ PRINT_INFO("%s", " No registrants"); ++ else { ++ struct scst_dev_registrant *reg; ++ int i = 0; ++ list_for_each_entry(reg, &dev->dev_registrants_list, ++ dev_registrants_list_entry) { ++ PRINT_INFO(" [%d] registrant %s/%d, key %016llx " ++ "(reg %p, tgt_dev %p)", i++, ++ debug_transport_id_to_initiator_name( ++ reg->transport_id), ++ reg->rel_tgt_id, reg->key, reg, reg->tgt_dev); ++ } ++ } ++ ++ if (dev->pr_is_set) { ++ struct scst_dev_registrant *holder = dev->pr_holder; ++ if (holder != NULL) ++ PRINT_INFO("Reservation holder is %s/%d (key %016llx, " ++ "scope %x, type %x, reg %p, tgt_dev %p)", ++ debug_transport_id_to_initiator_name( ++ holder->transport_id), ++ holder->rel_tgt_id, holder->key, dev->pr_scope, ++ dev->pr_type, holder, holder->tgt_dev); ++ else ++ PRINT_INFO("All registrants are reservation holders " ++ "(scope %x, type %x)", dev->pr_scope, ++ dev->pr_type); ++ } else ++ PRINT_INFO("%s", "Not reserved"); ++ ++out: ++ return; ++} ++ ++#endif /* defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) */ ++ ++/* dev_pr_mutex must be locked */ ++static void scst_pr_find_registrants_list_all(struct scst_device *dev, ++ struct scst_dev_registrant *exclude_reg, struct list_head *list) ++{ ++ struct scst_dev_registrant *reg; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_PR("Finding all registered records for device '%s' " ++ "with exclude reg key %016llx", ++ dev->virt_name, exclude_reg->key); ++ ++ list_for_each_entry(reg, &dev->dev_registrants_list, ++ dev_registrants_list_entry) { ++ if (reg == exclude_reg) ++ continue; ++ TRACE_PR("Adding registrant %s/%d (%p) to find list (key %016llx)", ++ debug_transport_id_to_initiator_name(reg->transport_id), ++ reg->rel_tgt_id, reg, reg->key); ++ list_add_tail(®->aux_list_entry, list); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* dev_pr_mutex must be locked */ ++static void scst_pr_find_registrants_list_key(struct scst_device *dev, ++ __be64 key, struct list_head *list) ++{ ++ struct scst_dev_registrant *reg; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_PR("Finding registrants for device '%s' with key %016llx", ++ dev->virt_name, key); ++ ++ list_for_each_entry(reg, &dev->dev_registrants_list, ++ dev_registrants_list_entry) { ++ if (reg->key == key) { ++ TRACE_PR("Adding registrant %s/%d (%p) to the find " ++ "list (key %016llx)", ++ debug_transport_id_to_initiator_name( ++ reg->transport_id), ++ reg->rel_tgt_id, reg->tgt_dev, key); ++ list_add_tail(®->aux_list_entry, list); ++ } ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* dev_pr_mutex must be locked */ ++static struct scst_dev_registrant *scst_pr_find_reg( ++ struct scst_device *dev, const uint8_t *transport_id, ++ const uint16_t rel_tgt_id) ++{ ++ struct scst_dev_registrant *reg, *res = NULL; ++ ++ TRACE_ENTRY(); ++ ++ list_for_each_entry(reg, &dev->dev_registrants_list, ++ dev_registrants_list_entry) { ++ if ((reg->rel_tgt_id == rel_tgt_id) && ++ tid_equal(reg->transport_id, transport_id)) { ++ res = reg; ++ break; ++ } ++ } ++ ++ TRACE_EXIT_HRES(res); ++ return res; ++} ++ ++/* Must be called under dev_pr_mutex */ ++static void scst_pr_clear_reservation(struct scst_device *dev) ++{ ++ TRACE_ENTRY(); ++ ++ WARN_ON(!dev->pr_is_set); ++ ++ dev->pr_is_set = 0; ++ dev->pr_scope = SCOPE_LU; ++ dev->pr_type = TYPE_UNSPECIFIED; ++ ++ dev->pr_holder = NULL; ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Must be called under dev_pr_mutex */ ++static void scst_pr_clear_holder(struct scst_device *dev) ++{ ++ TRACE_ENTRY(); ++ ++ WARN_ON(!dev->pr_is_set); ++ ++ if (dev->pr_type == TYPE_WRITE_EXCLUSIVE_ALL_REG || ++ dev->pr_type == TYPE_EXCLUSIVE_ACCESS_ALL_REG) { ++ if (list_empty(&dev->dev_registrants_list)) ++ scst_pr_clear_reservation(dev); ++ } else ++ scst_pr_clear_reservation(dev); ++ ++ dev->pr_holder = NULL; ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Must be called under dev_pr_mutex */ ++static struct scst_dev_registrant *scst_pr_add_registrant( ++ struct scst_device *dev, const uint8_t *transport_id, ++ const uint16_t rel_tgt_id, __be64 key, ++ bool dev_lock_locked) ++{ ++ struct scst_dev_registrant *reg; ++ struct scst_tgt_dev *t; ++ gfp_t gfp_flags = dev_lock_locked ? GFP_ATOMIC : GFP_KERNEL; ++ ++ TRACE_ENTRY(); ++ ++ BUG_ON(dev == NULL); ++ BUG_ON(transport_id == NULL); ++ ++ TRACE_PR("Registering %s/%d (dev %s)", ++ debug_transport_id_to_initiator_name(transport_id), ++ rel_tgt_id, dev->virt_name); ++ ++ reg = scst_pr_find_reg(dev, transport_id, rel_tgt_id); ++ if (reg != NULL) { ++ /* ++ * It might happen when a target driver would make >1 session ++ * from the same initiator to the same target. ++ */ ++ PRINT_ERROR("Registrant %p/%d (dev %s) already exists!", reg, ++ rel_tgt_id, dev->virt_name); ++ PRINT_BUFFER("TransportID", transport_id, 24); ++ WARN_ON(1); ++ reg = NULL; ++ goto out; ++ } ++ ++ reg = kzalloc(sizeof(*reg), gfp_flags); ++ if (reg == NULL) { ++ PRINT_ERROR("%s", "Unable to allocate registration record"); ++ goto out; ++ } ++ ++ reg->transport_id = kmalloc(tid_size(transport_id), gfp_flags); ++ if (reg->transport_id == NULL) { ++ PRINT_ERROR("%s", "Unable to allocate initiator port " ++ "transport id"); ++ goto out_free; ++ } ++ memcpy(reg->transport_id, transport_id, tid_size(transport_id)); ++ ++ reg->rel_tgt_id = rel_tgt_id; ++ reg->key = key; ++ ++ /* ++ * We can't use scst_mutex here, because of the circular ++ * locking dependency with dev_pr_mutex. ++ */ ++ if (!dev_lock_locked) ++ spin_lock_bh(&dev->dev_lock); ++ list_for_each_entry(t, &dev->dev_tgt_dev_list, dev_tgt_dev_list_entry) { ++ if (tid_equal(t->sess->transport_id, transport_id) && ++ (t->sess->tgt->rel_tgt_id == rel_tgt_id) && ++ (t->registrant == NULL)) { ++ /* ++ * We must assign here, because t can die ++ * immediately after we release dev_lock. ++ */ ++ TRACE_PR("Found tgt_dev %p", t); ++ reg->tgt_dev = t; ++ t->registrant = reg; ++ break; ++ } ++ } ++ if (!dev_lock_locked) ++ spin_unlock_bh(&dev->dev_lock); ++ ++ list_add_tail(®->dev_registrants_list_entry, ++ &dev->dev_registrants_list); ++ ++ TRACE_PR("Reg %p registered (dev %s, tgt_dev %p)", reg, ++ dev->virt_name, reg->tgt_dev); ++ ++out: ++ TRACE_EXIT_HRES((unsigned long)reg); ++ return reg; ++ ++out_free: ++ kfree(reg); ++ reg = NULL; ++ goto out; ++} ++ ++/* Must be called under dev_pr_mutex */ ++static void scst_pr_remove_registrant(struct scst_device *dev, ++ struct scst_dev_registrant *reg) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_PR("Removing registrant %s/%d (reg %p, tgt_dev %p, key %016llx, " ++ "dev %s)", debug_transport_id_to_initiator_name(reg->transport_id), ++ reg->rel_tgt_id, reg, reg->tgt_dev, reg->key, dev->virt_name); ++ ++ list_del(®->dev_registrants_list_entry); ++ ++ if (scst_pr_is_holder(dev, reg)) ++ scst_pr_clear_holder(dev); ++ ++ if (reg->tgt_dev) ++ reg->tgt_dev->registrant = NULL; ++ ++ kfree(reg->transport_id); ++ kfree(reg); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Must be called under dev_pr_mutex */ ++static void scst_pr_send_ua_reg(struct scst_device *dev, ++ struct scst_dev_registrant *reg, ++ int key, int asc, int ascq) ++{ ++ static uint8_t ua[SCST_STANDARD_SENSE_LEN]; ++ ++ TRACE_ENTRY(); ++ ++ scst_set_sense(ua, sizeof(ua), dev->d_sense, key, asc, ascq); ++ ++ TRACE_PR("Queueing UA [%x %x %x]: registrant %s/%d (%p), tgt_dev %p, " ++ "key %016llx", ua[2], ua[12], ua[13], ++ debug_transport_id_to_initiator_name(reg->transport_id), ++ reg->rel_tgt_id, reg, reg->tgt_dev, reg->key); ++ ++ if (reg->tgt_dev) ++ scst_check_set_UA(reg->tgt_dev, ua, sizeof(ua), 0); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Must be called under dev_pr_mutex */ ++static void scst_pr_send_ua_all(struct scst_device *dev, ++ struct scst_dev_registrant *exclude_reg, ++ int key, int asc, int ascq) ++{ ++ struct scst_dev_registrant *reg; ++ ++ TRACE_ENTRY(); ++ ++ list_for_each_entry(reg, &dev->dev_registrants_list, ++ dev_registrants_list_entry) { ++ if (reg != exclude_reg) ++ scst_pr_send_ua_reg(dev, reg, key, asc, ascq); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Must be called under dev_pr_mutex */ ++static void scst_pr_abort_reg(struct scst_device *dev, ++ struct scst_cmd *pr_cmd, struct scst_dev_registrant *reg) ++{ ++ struct scst_session *sess; ++ __be64 packed_lun; ++ int rc; ++ ++ TRACE_ENTRY(); ++ ++ if (reg->tgt_dev == NULL) { ++ TRACE_PR("Registrant %s/%d (%p, key 0x%016llx) has no session", ++ debug_transport_id_to_initiator_name(reg->transport_id), ++ reg->rel_tgt_id, reg, reg->key); ++ goto out; ++ } ++ ++ sess = reg->tgt_dev->sess; ++ ++ TRACE_PR("Aborting %d commands for %s/%d (reg %p, key 0x%016llx, " ++ "tgt_dev %p, sess %p)", ++ atomic_read(®->tgt_dev->tgt_dev_cmd_count), ++ debug_transport_id_to_initiator_name(reg->transport_id), ++ reg->rel_tgt_id, reg, reg->key, reg->tgt_dev, sess); ++ ++ packed_lun = scst_pack_lun(reg->tgt_dev->lun, sess->acg->addr_method); ++ ++ rc = scst_rx_mgmt_fn_lun(sess, SCST_PR_ABORT_ALL, ++ (uint8_t *)&packed_lun, sizeof(packed_lun), SCST_NON_ATOMIC, ++ pr_cmd); ++ if (rc != 0) { ++ /* ++ * There's nothing more we can do here... Hopefully, it would ++ * never happen. ++ */ ++ PRINT_ERROR("SCST_PR_ABORT_ALL failed %d (sess %p)", ++ rc, sess); ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Abstract vfs_unlink() for different kernel versions (as possible) */ ++static inline void scst_pr_vfs_unlink_and_put(struct path *path) ++{ ++ vfs_unlink(path->dentry->d_parent->d_inode, path->dentry); ++ path_put(path); ++} ++ ++/* Called under scst_mutex */ ++static int scst_pr_do_load_device_file(struct scst_device *dev, ++ const char *file_name) ++{ ++ int res = 0, rc; ++ struct file *file = NULL; ++ struct inode *inode; ++ char *buf = NULL; ++ loff_t file_size, pos, data_size; ++ uint64_t sign, version; ++ mm_segment_t old_fs; ++ uint8_t pr_is_set, aptpl; ++ __be64 key; ++ uint16_t rel_tgt_id; ++ ++ TRACE_ENTRY(); ++ ++ old_fs = get_fs(); ++ set_fs(KERNEL_DS); ++ ++ TRACE_PR("Loading persistent file '%s'", file_name); ++ ++ file = filp_open(file_name, O_RDONLY, 0); ++ if (IS_ERR(file)) { ++ res = PTR_ERR(file); ++ TRACE_PR("Unable to open file '%s' - error %d", file_name, res); ++ goto out; ++ } ++ ++ inode = file->f_dentry->d_inode; ++ ++ if (S_ISREG(inode->i_mode)) ++ /* Nothing to do */; ++ else if (S_ISBLK(inode->i_mode)) ++ inode = inode->i_bdev->bd_inode; ++ else { ++ PRINT_ERROR("Invalid file mode 0x%x", inode->i_mode); ++ goto out_close; ++ } ++ ++ file_size = inode->i_size; ++ ++ /* Let's limit the file size by some reasonable number */ ++ if ((file_size == 0) || (file_size >= 15*1024*1024)) { ++ PRINT_ERROR("Invalid PR file size %d", (int)file_size); ++ res = -EINVAL; ++ goto out_close; ++ } ++ ++ buf = vmalloc(file_size); ++ if (buf == NULL) { ++ res = -ENOMEM; ++ PRINT_ERROR("%s", "Unable to allocate buffer"); ++ goto out_close; ++ } ++ ++ pos = 0; ++ rc = vfs_read(file, (void __force __user *)buf, file_size, &pos); ++ if (rc != file_size) { ++ PRINT_ERROR("Unable to read file '%s' - error %d", file_name, ++ rc); ++ res = rc; ++ goto out_close; ++ } ++ ++ data_size = 0; ++ data_size += sizeof(sign); ++ data_size += sizeof(version); ++ data_size += sizeof(aptpl); ++ data_size += sizeof(pr_is_set); ++ data_size += sizeof(dev->pr_type); ++ data_size += sizeof(dev->pr_scope); ++ ++ if (file_size < data_size) { ++ res = -EINVAL; ++ PRINT_ERROR("Invalid file '%s' - size too small", file_name); ++ goto out_close; ++ } ++ ++ pos = 0; ++ ++ sign = get_unaligned((uint64_t *)&buf[pos]); ++ if (sign != SCST_PR_FILE_SIGN) { ++ res = -EINVAL; ++ PRINT_ERROR("Invalid persistent file signature %016llx " ++ "(expected %016llx)", sign, SCST_PR_FILE_SIGN); ++ goto out_close; ++ } ++ pos += sizeof(sign); ++ ++ version = get_unaligned((uint64_t *)&buf[pos]); ++ if (version != SCST_PR_FILE_VERSION) { ++ res = -EINVAL; ++ PRINT_ERROR("Invalid persistent file version %016llx " ++ "(expected %016llx)", version, SCST_PR_FILE_VERSION); ++ goto out_close; ++ } ++ pos += sizeof(version); ++ ++ while (data_size < file_size) { ++ uint8_t *tid; ++ ++ data_size++; ++ tid = &buf[data_size]; ++ data_size += tid_size(tid); ++ data_size += sizeof(key); ++ data_size += sizeof(rel_tgt_id); ++ ++ if (data_size > file_size) { ++ res = -EINVAL; ++ PRINT_ERROR("Invalid file '%s' - size mismatch have " ++ "%lld expected %lld", file_name, file_size, ++ data_size); ++ goto out_close; ++ } ++ } ++ ++ aptpl = buf[pos]; ++ dev->pr_aptpl = aptpl ? 1 : 0; ++ pos += sizeof(aptpl); ++ ++ pr_is_set = buf[pos]; ++ dev->pr_is_set = pr_is_set ? 1 : 0; ++ pos += sizeof(pr_is_set); ++ ++ dev->pr_type = buf[pos]; ++ pos += sizeof(dev->pr_type); ++ ++ dev->pr_scope = buf[pos]; ++ pos += sizeof(dev->pr_scope); ++ ++ while (pos < file_size) { ++ uint8_t is_holder; ++ uint8_t *tid; ++ struct scst_dev_registrant *reg = NULL; ++ ++ is_holder = buf[pos++]; ++ ++ tid = &buf[pos]; ++ pos += tid_size(tid); ++ ++ key = get_unaligned((__be64 *)&buf[pos]); ++ pos += sizeof(key); ++ ++ rel_tgt_id = get_unaligned((uint16_t *)&buf[pos]); ++ pos += sizeof(rel_tgt_id); ++ ++ reg = scst_pr_add_registrant(dev, tid, rel_tgt_id, key, false); ++ if (reg == NULL) { ++ res = -ENOMEM; ++ goto out_close; ++ } ++ ++ if (is_holder) ++ dev->pr_holder = reg; ++ } ++ ++out_close: ++ filp_close(file, NULL); ++ ++out: ++ if (buf != NULL) ++ vfree(buf); ++ ++ set_fs(old_fs); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_pr_load_device_file(struct scst_device *dev) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ if (dev->pr_file_name == NULL || dev->pr_file_name1 == NULL) { ++ PRINT_ERROR("Invalid file paths for '%s'", dev->virt_name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ res = scst_pr_do_load_device_file(dev, dev->pr_file_name); ++ if (res == 0) ++ goto out; ++ else if (res == -ENOMEM) ++ goto out; ++ ++ res = scst_pr_do_load_device_file(dev, dev->pr_file_name1); ++ ++ scst_pr_dump_prs(dev, false); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_pr_copy_file(const char *src, const char *dest) ++{ ++ int res = 0; ++ struct inode *inode; ++ loff_t file_size, pos; ++ uint8_t *buf = NULL; ++ struct file *file_src = NULL, *file_dest = NULL; ++ mm_segment_t old_fs = get_fs(); ++ ++ TRACE_ENTRY(); ++ ++ if (src == NULL || dest == NULL) { ++ res = -EINVAL; ++ PRINT_ERROR("%s", "Invalid persistent files path - backup " ++ "skipped"); ++ goto out; ++ } ++ ++ TRACE_PR("Copying '%s' into '%s'", src, dest); ++ ++ set_fs(KERNEL_DS); ++ ++ file_src = filp_open(src, O_RDONLY, 0); ++ if (IS_ERR(file_src)) { ++ res = PTR_ERR(file_src); ++ TRACE_PR("Unable to open file '%s' - error %d", src, ++ res); ++ goto out_free; ++ } ++ ++ file_dest = filp_open(dest, O_WRONLY | O_CREAT | O_TRUNC, 0644); ++ if (IS_ERR(file_dest)) { ++ res = PTR_ERR(file_dest); ++ TRACE_PR("Unable to open backup file '%s' - error %d", dest, ++ res); ++ goto out_close; ++ } ++ ++ inode = file_src->f_dentry->d_inode; ++ ++ if (S_ISREG(inode->i_mode)) ++ /* Nothing to do */; ++ else if (S_ISBLK(inode->i_mode)) ++ inode = inode->i_bdev->bd_inode; ++ else { ++ PRINT_ERROR("Invalid file mode 0x%x", inode->i_mode); ++ res = -EINVAL; ++ set_fs(old_fs); ++ goto out_skip; ++ } ++ ++ file_size = inode->i_size; ++ ++ buf = vmalloc(file_size); ++ if (buf == NULL) { ++ res = -ENOMEM; ++ PRINT_ERROR("%s", "Unable to allocate temporary buffer"); ++ goto out_skip; ++ } ++ ++ pos = 0; ++ res = vfs_read(file_src, (void __force __user *)buf, file_size, &pos); ++ if (res != file_size) { ++ PRINT_ERROR("Unable to read file '%s' - error %d", src, res); ++ goto out_skip; ++ } ++ ++ pos = 0; ++ res = vfs_write(file_dest, (void __force __user *)buf, file_size, &pos); ++ if (res != file_size) { ++ PRINT_ERROR("Unable to write to '%s' - error %d", dest, res); ++ goto out_skip; ++ } ++ ++ res = vfs_fsync(file_dest, 0); ++ if (res != 0) { ++ PRINT_ERROR("fsync() of the backup PR file failed: %d", res); ++ goto out_skip; ++ } ++ ++out_skip: ++ filp_close(file_dest, NULL); ++ ++out_close: ++ filp_close(file_src, NULL); ++ ++out_free: ++ if (buf != NULL) ++ vfree(buf); ++ ++ set_fs(old_fs); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void scst_pr_remove_device_files(struct scst_tgt_dev *tgt_dev) ++{ ++ int res = 0; ++ struct scst_device *dev = tgt_dev->dev; ++ struct path path; ++ mm_segment_t old_fs = get_fs(); ++ ++ TRACE_ENTRY(); ++ ++ set_fs(KERNEL_DS); ++ ++ res = dev->pr_file_name ? kern_path(dev->pr_file_name, 0, &path) : ++ -ENOENT; ++ if (!res) ++ scst_pr_vfs_unlink_and_put(&path); ++ else ++ TRACE_DBG("Unable to lookup file '%s' - error %d", ++ dev->pr_file_name, res); ++ ++ res = dev->pr_file_name1 ? kern_path(dev->pr_file_name1, 0, &path) : ++ -ENOENT; ++ if (!res) ++ scst_pr_vfs_unlink_and_put(&path); ++ else ++ TRACE_DBG("Unable to lookup file '%s' - error %d", ++ dev->pr_file_name1, res); ++ ++ set_fs(old_fs); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Must be called under dev_pr_mutex */ ++void scst_pr_sync_device_file(struct scst_tgt_dev *tgt_dev, struct scst_cmd *cmd) ++{ ++ int res = 0; ++ struct scst_device *dev = tgt_dev->dev; ++ struct file *file; ++ mm_segment_t old_fs = get_fs(); ++ loff_t pos = 0; ++ uint64_t sign; ++ uint64_t version; ++ uint8_t pr_is_set, aptpl; ++ ++ TRACE_ENTRY(); ++ ++ if ((dev->pr_aptpl == 0) || list_empty(&dev->dev_registrants_list)) { ++ scst_pr_remove_device_files(tgt_dev); ++ goto out; ++ } ++ ++ scst_pr_copy_file(dev->pr_file_name, dev->pr_file_name1); ++ ++ set_fs(KERNEL_DS); ++ ++ file = filp_open(dev->pr_file_name, O_WRONLY | O_CREAT | O_TRUNC, 0644); ++ if (IS_ERR(file)) { ++ res = PTR_ERR(file); ++ PRINT_ERROR("Unable to (re)create PR file '%s' - error %d", ++ dev->pr_file_name, res); ++ goto out_set_fs; ++ } ++ ++ TRACE_PR("Updating pr file '%s'", dev->pr_file_name); ++ ++ /* ++ * signature ++ */ ++ sign = 0; ++ pos = 0; ++ res = vfs_write(file, (void __force __user *)&sign, sizeof(sign), &pos); ++ if (res != sizeof(sign)) ++ goto write_error; ++ ++ /* ++ * version ++ */ ++ version = SCST_PR_FILE_VERSION; ++ res = vfs_write(file, (void __force __user *)&version, sizeof(version), &pos); ++ if (res != sizeof(version)) ++ goto write_error; ++ ++ /* ++ * APTPL ++ */ ++ aptpl = dev->pr_aptpl; ++ res = vfs_write(file, (void __force __user *)&aptpl, sizeof(aptpl), &pos); ++ if (res != sizeof(aptpl)) ++ goto write_error; ++ ++ /* ++ * reservation ++ */ ++ pr_is_set = dev->pr_is_set; ++ res = vfs_write(file, (void __force __user *)&pr_is_set, sizeof(pr_is_set), &pos); ++ if (res != sizeof(pr_is_set)) ++ goto write_error; ++ ++ res = vfs_write(file, (void __force __user *)&dev->pr_type, sizeof(dev->pr_type), &pos); ++ if (res != sizeof(dev->pr_type)) ++ goto write_error; ++ ++ res = vfs_write(file, (void __force __user *)&dev->pr_scope, sizeof(dev->pr_scope), &pos); ++ if (res != sizeof(dev->pr_scope)) ++ goto write_error; ++ ++ /* ++ * registration records ++ */ ++ if (!list_empty(&dev->dev_registrants_list)) { ++ struct scst_dev_registrant *reg; ++ ++ list_for_each_entry(reg, &dev->dev_registrants_list, ++ dev_registrants_list_entry) { ++ uint8_t is_holder = 0; ++ int size; ++ ++ is_holder = (dev->pr_holder == reg); ++ ++ res = vfs_write(file, (void __force __user *)&is_holder, sizeof(is_holder), ++ &pos); ++ if (res != sizeof(is_holder)) ++ goto write_error; ++ ++ size = tid_size(reg->transport_id); ++ res = vfs_write(file, (void __force __user *)reg->transport_id, size, &pos); ++ if (res != size) ++ goto write_error; ++ ++ res = vfs_write(file, (void __force __user *)®->key, ++ sizeof(reg->key), &pos); ++ if (res != sizeof(reg->key)) ++ goto write_error; ++ ++ res = vfs_write(file, (void __force __user *)®->rel_tgt_id, ++ sizeof(reg->rel_tgt_id), &pos); ++ if (res != sizeof(reg->rel_tgt_id)) ++ goto write_error; ++ } ++ } ++ ++ res = vfs_fsync(file, 0); ++ if (res != 0) { ++ PRINT_ERROR("fsync() of the PR file failed: %d", res); ++ goto write_error_close; ++ } ++ ++ sign = SCST_PR_FILE_SIGN; ++ pos = 0; ++ res = vfs_write(file, (void __force __user *)&sign, sizeof(sign), &pos); ++ if (res != sizeof(sign)) ++ goto write_error; ++ ++ res = vfs_fsync(file, 0); ++ if (res != 0) { ++ PRINT_ERROR("fsync() of the PR file failed: %d", res); ++ goto write_error_close; ++ } ++ ++ res = 0; ++ ++ filp_close(file, NULL); ++ ++out_set_fs: ++ set_fs(old_fs); ++ ++out: ++ if (res != 0) { ++ PRINT_CRIT_ERROR("Unable to save persistent information " ++ "(target %s, initiator %s, device %s)", ++ tgt_dev->sess->tgt->tgt_name, ++ tgt_dev->sess->initiator_name, dev->virt_name); ++#if 0 /* ++ * Looks like it's safer to return SUCCESS and expect operator's ++ * intervention to be able to save the PR's state next time, than ++ * to return HARDWARE ERROR and screw up all the interaction with ++ * the affected initiator. ++ */ ++ if (cmd != NULL) ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_hardw_error)); ++#endif ++ } ++ ++ TRACE_EXIT_RES(res); ++ return; ++ ++write_error: ++ PRINT_ERROR("Error writing to '%s' - error %d", dev->pr_file_name, res); ++ ++write_error_close: ++ filp_close(file, NULL); ++ { ++ struct path path; ++ int rc; ++ ++ rc = kern_path(dev->pr_file_name, 0, &path); ++ if (!rc) ++ scst_pr_vfs_unlink_and_put(&path); ++ else ++ TRACE_PR("Unable to lookup '%s' - error %d", ++ dev->pr_file_name, rc); ++ } ++ goto out_set_fs; ++} ++ ++static int scst_pr_check_pr_path(void) ++{ ++ int res; ++ struct path path; ++ ++ mm_segment_t old_fs = get_fs(); ++ ++ TRACE_ENTRY(); ++ ++ set_fs(KERNEL_DS); ++ ++ res = kern_path(SCST_PR_DIR, 0, &path); ++ if (res == 0) ++ path_put(&path); ++ if (res != 0) { ++ PRINT_ERROR("Unable to find %s (err %d), you should create " ++ "this directory manually or reinstall SCST", ++ SCST_PR_DIR, res); ++ goto out_setfs; ++ } ++ ++out_setfs: ++ set_fs(old_fs); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* Called under scst_mutex */ ++int scst_pr_init_dev(struct scst_device *dev) ++{ ++ int res = 0; ++ uint8_t q; ++ int name_len; ++ ++ TRACE_ENTRY(); ++ ++ name_len = snprintf(&q, sizeof(q), "%s/%s", SCST_PR_DIR, dev->virt_name) + 1; ++ dev->pr_file_name = kmalloc(name_len, GFP_KERNEL); ++ if (dev->pr_file_name == NULL) { ++ PRINT_ERROR("Allocation of device '%s' file path failed", ++ dev->virt_name); ++ res = -ENOMEM; ++ goto out; ++ } else ++ snprintf(dev->pr_file_name, name_len, "%s/%s", SCST_PR_DIR, ++ dev->virt_name); ++ ++ name_len = snprintf(&q, sizeof(q), "%s/%s.1", SCST_PR_DIR, dev->virt_name) + 1; ++ dev->pr_file_name1 = kmalloc(name_len, GFP_KERNEL); ++ if (dev->pr_file_name1 == NULL) { ++ PRINT_ERROR("Allocation of device '%s' backup file path failed", ++ dev->virt_name); ++ res = -ENOMEM; ++ goto out_free_name; ++ } else ++ snprintf(dev->pr_file_name1, name_len, "%s/%s.1", SCST_PR_DIR, ++ dev->virt_name); ++ ++ res = scst_pr_check_pr_path(); ++ if (res == 0) { ++ res = scst_pr_load_device_file(dev); ++ if (res == -ENOENT) ++ res = 0; ++ } ++ ++ if (res != 0) ++ goto out_free_name1; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free_name1: ++ kfree(dev->pr_file_name1); ++ dev->pr_file_name1 = NULL; ++ ++out_free_name: ++ kfree(dev->pr_file_name); ++ dev->pr_file_name = NULL; ++ goto out; ++} ++ ++/* Called under scst_mutex */ ++void scst_pr_clear_dev(struct scst_device *dev) ++{ ++ struct scst_dev_registrant *reg, *tmp_reg; ++ ++ TRACE_ENTRY(); ++ ++ list_for_each_entry_safe(reg, tmp_reg, &dev->dev_registrants_list, ++ dev_registrants_list_entry) { ++ scst_pr_remove_registrant(dev, reg); ++ } ++ ++ kfree(dev->pr_file_name); ++ kfree(dev->pr_file_name1); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Called under scst_mutex */ ++int scst_pr_init_tgt_dev(struct scst_tgt_dev *tgt_dev) ++{ ++ int res = 0; ++ struct scst_dev_registrant *reg; ++ struct scst_device *dev = tgt_dev->dev; ++ const uint8_t *transport_id = tgt_dev->sess->transport_id; ++ const uint16_t rel_tgt_id = tgt_dev->sess->tgt->rel_tgt_id; ++ ++ TRACE_ENTRY(); ++ ++ if (tgt_dev->sess->transport_id == NULL) ++ goto out; ++ ++ scst_pr_write_lock(dev); ++ ++ reg = scst_pr_find_reg(dev, transport_id, rel_tgt_id); ++ if ((reg != NULL) && (reg->tgt_dev == NULL)) { ++ TRACE_PR("Assigning reg %s/%d (%p) to tgt_dev %p (dev %s)", ++ debug_transport_id_to_initiator_name(transport_id), ++ rel_tgt_id, reg, tgt_dev, dev->virt_name); ++ tgt_dev->registrant = reg; ++ reg->tgt_dev = tgt_dev; ++ } ++ ++ scst_pr_write_unlock(dev); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* Called under scst_mutex */ ++void scst_pr_clear_tgt_dev(struct scst_tgt_dev *tgt_dev) ++{ ++ TRACE_ENTRY(); ++ ++ if (tgt_dev->registrant != NULL) { ++ struct scst_dev_registrant *reg = tgt_dev->registrant; ++ struct scst_device *dev = tgt_dev->dev; ++ struct scst_tgt_dev *t; ++ ++ scst_pr_write_lock(dev); ++ ++ tgt_dev->registrant = NULL; ++ reg->tgt_dev = NULL; ++ ++ /* Just in case, actually. It should never happen. */ ++ list_for_each_entry(t, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ if (t == tgt_dev) ++ continue; ++ if ((t->sess->tgt->rel_tgt_id == reg->rel_tgt_id) && ++ tid_equal(t->sess->transport_id, reg->transport_id)) { ++ TRACE_PR("Reassigning reg %s/%d (%p) to tgt_dev " ++ "%p (being cleared tgt_dev %p)", ++ debug_transport_id_to_initiator_name( ++ reg->transport_id), ++ reg->rel_tgt_id, reg, t, tgt_dev); ++ t->registrant = reg; ++ reg->tgt_dev = t; ++ break; ++ } ++ } ++ ++ scst_pr_write_unlock(dev); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Called with dev_pr_mutex locked. Might also be called under scst_mutex2. */ ++static int scst_pr_register_with_spec_i_pt(struct scst_cmd *cmd, ++ const uint16_t rel_tgt_id, uint8_t *buffer, int buffer_size, ++ struct list_head *rollback_list) ++{ ++ int res = 0; ++ int offset, ext_size; ++ __be64 action_key; ++ struct scst_device *dev = cmd->dev; ++ struct scst_dev_registrant *reg; ++ uint8_t *transport_id; ++ ++ action_key = get_unaligned((__be64 *)&buffer[8]); ++ ++ ext_size = be32_to_cpu(get_unaligned((__be32 *)&buffer[24])); ++ if ((ext_size + 28) > buffer_size) { ++ TRACE_PR("Invalid buffer size %d (max %d)", buffer_size, ++ ext_size + 28); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_parameter_list_length_invalid)); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ offset = 0; ++ while (offset < ext_size) { ++ transport_id = &buffer[28 + offset]; ++ ++ if ((offset + tid_size(transport_id)) > ext_size) { ++ TRACE_PR("Invalid transport_id size %d (max %d)", ++ tid_size(transport_id), ext_size - offset); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_parm_list)); ++ res = -EINVAL; ++ goto out; ++ } ++ tid_secure(transport_id); ++ offset += tid_size(transport_id); ++ } ++ ++ offset = 0; ++ while (offset < ext_size) { ++ struct scst_tgt_dev *t; ++ ++ transport_id = &buffer[28 + offset]; ++ ++ TRACE_PR("rel_tgt_id %d, transport_id %s", rel_tgt_id, ++ debug_transport_id_to_initiator_name(transport_id)); ++ ++ if ((transport_id[0] & 0x0f) == SCSI_TRANSPORTID_PROTOCOLID_ISCSI && ++ (transport_id[0] & 0xc0) == 0) { ++ TRACE_PR("Wildcard iSCSI TransportID %s", ++ &transport_id[4]); ++ /* ++ * We can't use scst_mutex here, because of the ++ * circular locking dependency with dev_pr_mutex. ++ */ ++ spin_lock_bh(&dev->dev_lock); ++ list_for_each_entry(t, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ /* ++ * We must go over all matching tgt_devs and ++ * register them on the requested rel_tgt_id ++ */ ++ if (!tid_equal(t->sess->transport_id, ++ transport_id)) ++ continue; ++ ++ reg = scst_pr_find_reg(dev, ++ t->sess->transport_id, rel_tgt_id); ++ if (reg == NULL) { ++ reg = scst_pr_add_registrant(dev, ++ t->sess->transport_id, ++ rel_tgt_id, action_key, true); ++ if (reg == NULL) { ++ spin_unlock_bh(&dev->dev_lock); ++ scst_set_busy(cmd); ++ res = -ENOMEM; ++ goto out; ++ } ++ } else if (reg->key != action_key) { ++ TRACE_PR("Changing key of reg %p " ++ "(tgt_dev %p)", reg, t); ++ reg->rollback_key = reg->key; ++ reg->key = action_key; ++ } else ++ continue; ++ ++ list_add_tail(®->aux_list_entry, ++ rollback_list); ++ } ++ spin_unlock_bh(&dev->dev_lock); ++ } else { ++ reg = scst_pr_find_reg(dev, transport_id, rel_tgt_id); ++ if (reg != NULL) { ++ if (reg->key == action_key) ++ goto next; ++ TRACE_PR("Changing key of reg %p (tgt_dev %p)", ++ reg, reg->tgt_dev); ++ reg->rollback_key = reg->key; ++ reg->key = action_key; ++ } else { ++ reg = scst_pr_add_registrant(dev, transport_id, ++ rel_tgt_id, action_key, false); ++ if (reg == NULL) { ++ scst_set_busy(cmd); ++ res = -ENOMEM; ++ goto out; ++ } ++ } ++ ++ list_add_tail(®->aux_list_entry, ++ rollback_list); ++ } ++next: ++ offset += tid_size(transport_id); ++ } ++out: ++ return res; ++} ++ ++/* Called with dev_pr_mutex locked, no IRQ */ ++static void scst_pr_unregister(struct scst_device *dev, ++ struct scst_dev_registrant *reg) ++{ ++ bool is_holder; ++ uint8_t pr_type; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_PR("Unregistering key %0llx", reg->key); ++ ++ is_holder = scst_pr_is_holder(dev, reg); ++ pr_type = dev->pr_type; ++ ++ scst_pr_remove_registrant(dev, reg); ++ ++ if (is_holder && !dev->pr_is_set) { ++ /* A registration just released */ ++ switch (pr_type) { ++ case TYPE_WRITE_EXCLUSIVE_REGONLY: ++ case TYPE_EXCLUSIVE_ACCESS_REGONLY: ++ scst_pr_send_ua_all(dev, NULL, ++ SCST_LOAD_SENSE(scst_sense_reservation_released)); ++ break; ++ } ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Called with dev_pr_mutex locked, no IRQ */ ++static void scst_pr_unregister_all_tg_pt(struct scst_device *dev, ++ const uint8_t *transport_id) ++{ ++ struct scst_tgt_template *tgtt; ++ uint8_t proto_id = transport_id[0] & 0x0f; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * We can't use scst_mutex here, because of the circular locking ++ * dependency with dev_pr_mutex. ++ */ ++ mutex_lock(&scst_mutex2); ++ ++ list_for_each_entry(tgtt, &scst_template_list, scst_template_list_entry) { ++ struct scst_tgt *tgt; ++ ++ if (tgtt->get_initiator_port_transport_id == NULL) ++ continue; ++ ++ list_for_each_entry(tgt, &tgtt->tgt_list, tgt_list_entry) { ++ struct scst_dev_registrant *reg; ++ ++ if (tgtt->get_initiator_port_transport_id(tgt, NULL, NULL) != proto_id) ++ continue; ++ ++ reg = scst_pr_find_reg(dev, transport_id, ++ tgt->rel_tgt_id); ++ if (reg == NULL) ++ continue; ++ ++ scst_pr_unregister(dev, reg); ++ } ++ } ++ ++ mutex_unlock(&scst_mutex2); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Called with dev_pr_mutex locked. Might also be called under scst_mutex2. */ ++static int scst_pr_register_on_tgt_id(struct scst_cmd *cmd, ++ const uint16_t rel_tgt_id, uint8_t *buffer, int buffer_size, ++ bool spec_i_pt, struct list_head *rollback_list) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_PR("rel_tgt_id %d, spec_i_pt %d", rel_tgt_id, spec_i_pt); ++ ++ if (spec_i_pt) { ++ res = scst_pr_register_with_spec_i_pt(cmd, rel_tgt_id, buffer, ++ buffer_size, rollback_list); ++ if (res != 0) ++ goto out; ++ } ++ ++ /* tgt_dev can be among TIDs for scst_pr_register_with_spec_i_pt() */ ++ ++ if (scst_pr_find_reg(cmd->dev, cmd->sess->transport_id, rel_tgt_id) == NULL) { ++ __be64 action_key; ++ struct scst_dev_registrant *reg; ++ ++ action_key = get_unaligned((__be64 *)&buffer[8]); ++ ++ reg = scst_pr_add_registrant(cmd->dev, cmd->sess->transport_id, ++ rel_tgt_id, action_key, false); ++ if (reg == NULL) { ++ res = -ENOMEM; ++ scst_set_busy(cmd); ++ goto out; ++ } ++ ++ list_add_tail(®->aux_list_entry, rollback_list); ++ } ++ ++ res = 0; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* Called with dev_pr_mutex locked, no IRQ */ ++static int scst_pr_register_all_tg_pt(struct scst_cmd *cmd, uint8_t *buffer, ++ int buffer_size, bool spec_i_pt, struct list_head *rollback_list) ++{ ++ int res = 0; ++ struct scst_tgt_template *tgtt; ++ uint8_t proto_id = cmd->sess->transport_id[0] & 0x0f; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * We can't use scst_mutex here, because of the circular locking ++ * dependency with dev_pr_mutex. ++ */ ++ mutex_lock(&scst_mutex2); ++ ++ list_for_each_entry(tgtt, &scst_template_list, scst_template_list_entry) { ++ struct scst_tgt *tgt; ++ ++ if (tgtt->get_initiator_port_transport_id == NULL) ++ continue; ++ ++ TRACE_PR("tgtt %s, spec_i_pt %d", tgtt->name, spec_i_pt); ++ ++ list_for_each_entry(tgt, &tgtt->tgt_list, tgt_list_entry) { ++ if (tgtt->get_initiator_port_transport_id(tgt, NULL, NULL) != proto_id) ++ continue; ++ if (tgt->rel_tgt_id == 0) ++ continue; ++ TRACE_PR("tgt %s, rel_tgt_id %d", tgt->tgt_name, ++ tgt->rel_tgt_id); ++ res = scst_pr_register_on_tgt_id(cmd, tgt->rel_tgt_id, ++ buffer, buffer_size, spec_i_pt, rollback_list); ++ if (res != 0) ++ goto out_unlock; ++ } ++ } ++ ++out_unlock: ++ mutex_unlock(&scst_mutex2); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* Called with dev_pr_mutex locked, no IRQ */ ++static int __scst_pr_register(struct scst_cmd *cmd, uint8_t *buffer, ++ int buffer_size, bool spec_i_pt, bool all_tg_pt) ++{ ++ int res; ++ struct scst_dev_registrant *reg, *treg; ++ LIST_HEAD(rollback_list); ++ ++ TRACE_ENTRY(); ++ ++ if (all_tg_pt) { ++ res = scst_pr_register_all_tg_pt(cmd, buffer, buffer_size, ++ spec_i_pt, &rollback_list); ++ if (res != 0) ++ goto out_rollback; ++ } else { ++ res = scst_pr_register_on_tgt_id(cmd, ++ cmd->sess->tgt->rel_tgt_id, buffer, buffer_size, ++ spec_i_pt, &rollback_list); ++ if (res != 0) ++ goto out_rollback; ++ } ++ ++ list_for_each_entry(reg, &rollback_list, aux_list_entry) { ++ reg->rollback_key = 0; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_rollback: ++ list_for_each_entry_safe(reg, treg, &rollback_list, aux_list_entry) { ++ list_del(®->aux_list_entry); ++ if (reg->rollback_key == 0) ++ scst_pr_remove_registrant(cmd->dev, reg); ++ else { ++ reg->key = reg->rollback_key; ++ reg->rollback_key = 0; ++ } ++ } ++ goto out; ++} ++ ++/* Called with dev_pr_mutex locked, no IRQ */ ++void scst_pr_register(struct scst_cmd *cmd, uint8_t *buffer, int buffer_size) ++{ ++ int aptpl, spec_i_pt, all_tg_pt; ++ __be64 key, action_key; ++ struct scst_device *dev = cmd->dev; ++ struct scst_tgt_dev *tgt_dev = cmd->tgt_dev; ++ struct scst_session *sess = cmd->sess; ++ struct scst_dev_registrant *reg; ++ ++ TRACE_ENTRY(); ++ ++ aptpl = buffer[20] & 0x01; ++ spec_i_pt = (buffer[20] >> 3) & 0x01; ++ all_tg_pt = (buffer[20] >> 2) & 0x01; ++ key = get_unaligned((__be64 *)&buffer[0]); ++ action_key = get_unaligned((__be64 *)&buffer[8]); ++ ++ if (spec_i_pt == 0 && buffer_size != 24) { ++ TRACE_PR("Invalid buffer size %d", buffer_size); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_parameter_list_length_invalid)); ++ goto out; ++ } ++ ++ reg = tgt_dev->registrant; ++ ++ TRACE_PR("Register: initiator %s/%d (%p), key %0llx, action_key %0llx " ++ "(tgt_dev %p)", ++ debug_transport_id_to_initiator_name(sess->transport_id), ++ sess->tgt->rel_tgt_id, reg, key, action_key, tgt_dev); ++ ++ if (reg == NULL) { ++ TRACE_PR("tgt_dev %p is not registered yet - registering", ++ tgt_dev); ++ if (key) { ++ TRACE_PR("%s", "Key must be zero on new registration"); ++ scst_set_cmd_error_status(cmd, SAM_STAT_RESERVATION_CONFLICT); ++ goto out; ++ } ++ if (action_key) { ++ int rc = __scst_pr_register(cmd, buffer, buffer_size, ++ spec_i_pt, all_tg_pt); ++ if (rc != 0) ++ goto out; ++ } else ++ TRACE_PR("%s", "Doing nothing - action_key is zero"); ++ } else { ++ if (reg->key != key) { ++ TRACE_PR("tgt_dev %p already registered - reservation " ++ "key %0llx mismatch", tgt_dev, reg->key); ++ scst_set_cmd_error_status(cmd, ++ SAM_STAT_RESERVATION_CONFLICT); ++ goto out; ++ } ++ if (spec_i_pt) { ++ TRACE_PR("%s", "spec_i_pt must be zero in this case"); ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE( ++ scst_sense_invalid_field_in_cdb)); ++ goto out; ++ } ++ if (action_key == 0) { ++ if (all_tg_pt) ++ scst_pr_unregister_all_tg_pt(dev, ++ sess->transport_id); ++ else ++ scst_pr_unregister(dev, reg); ++ } else ++ reg->key = action_key; ++ } ++ ++ dev->pr_generation++; ++ ++ dev->pr_aptpl = aptpl; ++ ++ scst_pr_dump_prs(dev, false); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Called with dev_pr_mutex locked, no IRQ */ ++void scst_pr_register_and_ignore(struct scst_cmd *cmd, uint8_t *buffer, ++ int buffer_size) ++{ ++ int aptpl, all_tg_pt; ++ __be64 action_key; ++ struct scst_dev_registrant *reg = NULL; ++ struct scst_device *dev = cmd->dev; ++ struct scst_tgt_dev *tgt_dev = cmd->tgt_dev; ++ struct scst_session *sess = cmd->sess; ++ ++ TRACE_ENTRY(); ++ ++ aptpl = buffer[20] & 0x01; ++ all_tg_pt = (buffer[20] >> 2) & 0x01; ++ action_key = get_unaligned((__be64 *)&buffer[8]); ++ ++ if (buffer_size != 24) { ++ TRACE_PR("Invalid buffer size %d", buffer_size); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_parameter_list_length_invalid)); ++ goto out; ++ } ++ ++ reg = tgt_dev->registrant; ++ ++ TRACE_PR("Register and ignore: initiator %s/%d (%p), action_key " ++ "%016llx (tgt_dev %p)", ++ debug_transport_id_to_initiator_name(sess->transport_id), ++ sess->tgt->rel_tgt_id, reg, action_key, tgt_dev); ++ ++ if (reg == NULL) { ++ TRACE_PR("Tgt_dev %p is not registered yet - trying to " ++ "register", tgt_dev); ++ if (action_key) { ++ int rc = __scst_pr_register(cmd, buffer, buffer_size, ++ false, all_tg_pt); ++ if (rc != 0) ++ goto out; ++ } else ++ TRACE_PR("%s", "Doing nothing, action_key is zero"); ++ } else { ++ if (action_key == 0) { ++ if (all_tg_pt) ++ scst_pr_unregister_all_tg_pt(dev, ++ sess->transport_id); ++ else ++ scst_pr_unregister(dev, reg); ++ } else ++ reg->key = action_key; ++ } ++ ++ dev->pr_generation++; ++ ++ dev->pr_aptpl = aptpl; ++ ++ scst_pr_dump_prs(dev, false); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Called with dev_pr_mutex locked, no IRQ */ ++void scst_pr_register_and_move(struct scst_cmd *cmd, uint8_t *buffer, ++ int buffer_size) ++{ ++ int aptpl; ++ int unreg; ++ int tid_buffer_size; ++ __be64 key, action_key; ++ struct scst_device *dev = cmd->dev; ++ struct scst_tgt_dev *tgt_dev = cmd->tgt_dev; ++ struct scst_session *sess = cmd->sess; ++ struct scst_dev_registrant *reg, *reg_move; ++ const uint8_t *transport_id = NULL; ++ uint8_t *transport_id_move = NULL; ++ uint16_t rel_tgt_id_move; ++ ++ TRACE_ENTRY(); ++ ++ aptpl = buffer[17] & 0x01; ++ key = get_unaligned((__be64 *)&buffer[0]); ++ action_key = get_unaligned((__be64 *)&buffer[8]); ++ unreg = (buffer[17] >> 1) & 0x01; ++ tid_buffer_size = be32_to_cpu(get_unaligned((__be32 *)&buffer[20])); ++ ++ if ((tid_buffer_size + 24) > buffer_size) { ++ TRACE_PR("Invalid buffer size %d (%d)", ++ buffer_size, tid_buffer_size + 24); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_parm_list)); ++ goto out; ++ } ++ ++ if (tid_buffer_size < 24) { ++ TRACE_PR("%s", "Transport id buffer too small"); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_parm_list)); ++ goto out; ++ } ++ ++ reg = tgt_dev->registrant; ++ /* We already checked reg is not NULL */ ++ if (reg->key != key) { ++ TRACE_PR("Registrant's %s/%d (%p) key %016llx mismatch with " ++ "%016llx (tgt_dev %p)", ++ debug_transport_id_to_initiator_name(reg->transport_id), ++ reg->rel_tgt_id, reg, reg->key, key, tgt_dev); ++ scst_set_cmd_error_status(cmd, SAM_STAT_RESERVATION_CONFLICT); ++ goto out; ++ } ++ ++ if (!dev->pr_is_set) { ++ TRACE_PR("%s", "There must be a PR"); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out; ++ } ++ ++ /* ++ * This check also required by table "PERSISTENT RESERVE OUT service ++ * actions that are allowed in the presence of various reservations". ++ */ ++ if (!scst_pr_is_holder(dev, reg)) { ++ TRACE_PR("Registrant %s/%d (%p) is not a holder (tgt_dev %p)", ++ debug_transport_id_to_initiator_name( ++ reg->transport_id), reg->rel_tgt_id, ++ reg, tgt_dev); ++ scst_set_cmd_error_status(cmd, SAM_STAT_RESERVATION_CONFLICT); ++ goto out; ++ } ++ ++ if (action_key == 0) { ++ TRACE_PR("%s", "Action key must be non-zero"); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out; ++ } ++ ++ transport_id = sess->transport_id; ++ transport_id_move = (uint8_t *)&buffer[24]; ++ rel_tgt_id_move = be16_to_cpu(get_unaligned((__be16 *)&buffer[18])); ++ ++ if ((tid_size(transport_id_move) + 24) > buffer_size) { ++ TRACE_PR("Invalid buffer size %d (%d)", ++ buffer_size, tid_size(transport_id_move) + 24); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_parm_list)); ++ goto out; ++ } ++ ++ tid_secure(transport_id_move); ++ ++ if (dev->pr_type == TYPE_WRITE_EXCLUSIVE_ALL_REG || ++ dev->pr_type == TYPE_EXCLUSIVE_ACCESS_ALL_REG) { ++ TRACE_PR("Unable to finish operation due to wrong reservation " ++ "type %02x", dev->pr_type); ++ scst_set_cmd_error_status(cmd, SAM_STAT_RESERVATION_CONFLICT); ++ goto out; ++ } ++ ++ if (tid_equal(transport_id, transport_id_move)) { ++ TRACE_PR("%s", "Equal transport id's"); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_parm_list)); ++ goto out; ++ } ++ ++ reg_move = scst_pr_find_reg(dev, transport_id_move, rel_tgt_id_move); ++ if (reg_move == NULL) { ++ reg_move = scst_pr_add_registrant(dev, transport_id_move, ++ rel_tgt_id_move, action_key, false); ++ if (reg_move == NULL) { ++ scst_set_busy(cmd); ++ goto out; ++ } ++ } else if (reg_move->key != action_key) { ++ TRACE_PR("Changing key for reg %p", reg); ++ reg_move->key = action_key; ++ } ++ ++ TRACE_PR("Register and move: from initiator %s/%d (%p, tgt_dev %p) to " ++ "initiator %s/%d (%p, tgt_dev %p), key %016llx (unreg %d)", ++ debug_transport_id_to_initiator_name(reg->transport_id), ++ reg->rel_tgt_id, reg, reg->tgt_dev, ++ debug_transport_id_to_initiator_name(transport_id_move), ++ rel_tgt_id_move, reg_move, reg_move->tgt_dev, action_key, ++ unreg); ++ ++ /* Move the holder */ ++ scst_pr_set_holder(dev, reg_move, dev->pr_scope, dev->pr_type); ++ ++ if (unreg) ++ scst_pr_remove_registrant(dev, reg); ++ ++ dev->pr_generation++; ++ ++ dev->pr_aptpl = aptpl; ++ ++ scst_pr_dump_prs(dev, false); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Called with dev_pr_mutex locked, no IRQ */ ++void scst_pr_reserve(struct scst_cmd *cmd, uint8_t *buffer, int buffer_size) ++{ ++ uint8_t scope, type; ++ __be64 key; ++ struct scst_device *dev = cmd->dev; ++ struct scst_tgt_dev *tgt_dev = cmd->tgt_dev; ++ struct scst_dev_registrant *reg; ++ ++ TRACE_ENTRY(); ++ ++ key = get_unaligned((__be64 *)&buffer[0]); ++ scope = (cmd->cdb[2] & 0x0f) >> 4; ++ type = cmd->cdb[2] & 0x0f; ++ ++ if (buffer_size != 24) { ++ TRACE_PR("Invalid buffer size %d", buffer_size); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_parameter_list_length_invalid)); ++ goto out; ++ } ++ ++ if (!scst_pr_type_valid(type)) { ++ TRACE_PR("Invalid reservation type %d", type); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out; ++ } ++ ++ if (((cmd->cdb[2] & 0x0f) >> 4) != SCOPE_LU) { ++ TRACE_PR("Invalid reservation scope %d", scope); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out; ++ } ++ ++ reg = tgt_dev->registrant; ++ ++ TRACE_PR("Reserve: initiator %s/%d (%p), key %016llx, scope %d, " ++ "type %d (tgt_dev %p)", ++ debug_transport_id_to_initiator_name(cmd->sess->transport_id), ++ cmd->sess->tgt->rel_tgt_id, reg, key, scope, type, tgt_dev); ++ ++ /* We already checked reg is not NULL */ ++ if (reg->key != key) { ++ TRACE_PR("Registrant's %p key %016llx mismatch with %016llx", ++ reg, reg->key, key); ++ scst_set_cmd_error_status(cmd, SAM_STAT_RESERVATION_CONFLICT); ++ goto out; ++ } ++ ++ if (!dev->pr_is_set) ++ scst_pr_set_holder(dev, reg, scope, type); ++ else { ++ if (!scst_pr_is_holder(dev, reg)) { ++ /* ++ * This check also required by table "PERSISTENT ++ * RESERVE OUT service actions that are allowed in the ++ * presence of various reservations". ++ */ ++ TRACE_PR("Only holder can override - reg %p is not a " ++ "holder", reg); ++ scst_set_cmd_error_status(cmd, ++ SAM_STAT_RESERVATION_CONFLICT); ++ goto out; ++ } else { ++ if (dev->pr_scope != scope || dev->pr_type != type) { ++ TRACE_PR("Error overriding scope or type for " ++ "reg %p", reg); ++ scst_set_cmd_error_status(cmd, ++ SAM_STAT_RESERVATION_CONFLICT); ++ goto out; ++ } else ++ TRACE_PR("Do nothing: reservation of reg %p " ++ "is the same", reg); ++ } ++ } ++ ++ scst_pr_dump_prs(dev, false); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Called with dev_pr_mutex locked, no IRQ */ ++void scst_pr_release(struct scst_cmd *cmd, uint8_t *buffer, int buffer_size) ++{ ++ int scope, type; ++ __be64 key; ++ struct scst_device *dev = cmd->dev; ++ struct scst_tgt_dev *tgt_dev = cmd->tgt_dev; ++ struct scst_dev_registrant *reg; ++ uint8_t cur_pr_type; ++ ++ TRACE_ENTRY(); ++ ++ key = get_unaligned((__be64 *)&buffer[0]); ++ scope = (cmd->cdb[2] & 0x0f) >> 4; ++ type = cmd->cdb[2] & 0x0f; ++ ++ if (buffer_size != 24) { ++ TRACE_PR("Invalid buffer size %d", buffer_size); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_parameter_list_length_invalid)); ++ goto out; ++ } ++ ++ if (!dev->pr_is_set) { ++ TRACE_PR("%s", "There is no PR - do nothing"); ++ goto out; ++ } ++ ++ reg = tgt_dev->registrant; ++ ++ TRACE_PR("Release: initiator %s/%d (%p), key %016llx, scope %d, type " ++ "%d (tgt_dev %p)", debug_transport_id_to_initiator_name( ++ cmd->sess->transport_id), ++ cmd->sess->tgt->rel_tgt_id, reg, key, scope, type, tgt_dev); ++ ++ /* We already checked reg is not NULL */ ++ if (reg->key != key) { ++ TRACE_PR("Registrant's %p key %016llx mismatch with %016llx", ++ reg, reg->key, key); ++ scst_set_cmd_error_status(cmd, SAM_STAT_RESERVATION_CONFLICT); ++ goto out; ++ } ++ ++ if (!scst_pr_is_holder(dev, reg)) { ++ TRACE_PR("Registrant %p is not a holder - do nothing", reg); ++ goto out; ++ } ++ ++ if (dev->pr_scope != scope || dev->pr_type != type) { ++ TRACE_PR("%s", "Released scope or type do not match with " ++ "holder"); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_release)); ++ goto out; ++ } ++ ++ cur_pr_type = dev->pr_type; /* it will be cleared */ ++ ++ scst_pr_clear_reservation(dev); ++ ++ switch (cur_pr_type) { ++ case TYPE_WRITE_EXCLUSIVE_REGONLY: ++ case TYPE_EXCLUSIVE_ACCESS_REGONLY: ++ case TYPE_WRITE_EXCLUSIVE_ALL_REG: ++ case TYPE_EXCLUSIVE_ACCESS_ALL_REG: ++ scst_pr_send_ua_all(dev, reg, ++ SCST_LOAD_SENSE(scst_sense_reservation_released)); ++ } ++ ++ scst_pr_dump_prs(dev, false); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Called with dev_pr_mutex locked, no IRQ */ ++void scst_pr_clear(struct scst_cmd *cmd, uint8_t *buffer, int buffer_size) ++{ ++ __be64 key; ++ struct scst_device *dev = cmd->dev; ++ struct scst_tgt_dev *tgt_dev = cmd->tgt_dev; ++ struct scst_dev_registrant *reg, *r, *t; ++ ++ TRACE_ENTRY(); ++ ++ key = get_unaligned((__be64 *)&buffer[0]); ++ ++ if (buffer_size != 24) { ++ TRACE_PR("Invalid buffer size %d", buffer_size); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_parameter_list_length_invalid)); ++ goto out; ++ } ++ ++ reg = tgt_dev->registrant; ++ ++ TRACE_PR("Clear: initiator %s/%d (%p), key %016llx (tgt_dev %p)", ++ debug_transport_id_to_initiator_name(cmd->sess->transport_id), ++ cmd->sess->tgt->rel_tgt_id, reg, key, tgt_dev); ++ ++ /* We already checked reg is not NULL */ ++ if (reg->key != key) { ++ TRACE_PR("Registrant's %p key %016llx mismatch with %016llx", ++ reg, reg->key, key); ++ scst_set_cmd_error_status(cmd, SAM_STAT_RESERVATION_CONFLICT); ++ goto out; ++ } ++ ++ scst_pr_send_ua_all(dev, reg, ++ SCST_LOAD_SENSE(scst_sense_reservation_preempted)); ++ ++ list_for_each_entry_safe(r, t, &dev->dev_registrants_list, ++ dev_registrants_list_entry) { ++ scst_pr_remove_registrant(dev, r); ++ } ++ ++ dev->pr_generation++; ++ ++ scst_pr_dump_prs(dev, false); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static void scst_pr_do_preempt(struct scst_cmd *cmd, uint8_t *buffer, ++ int buffer_size, bool abort) ++{ ++ __be64 key, action_key; ++ int scope, type; ++ struct scst_device *dev = cmd->dev; ++ struct scst_tgt_dev *tgt_dev = cmd->tgt_dev; ++ struct scst_dev_registrant *reg, *r, *rt; ++ int existing_pr_type = dev->pr_type; ++ int existing_pr_scope = dev->pr_scope; ++ LIST_HEAD(preempt_list); ++ ++ TRACE_ENTRY(); ++ ++ key = get_unaligned((__be64 *)&buffer[0]); ++ action_key = get_unaligned((__be64 *)&buffer[8]); ++ scope = (cmd->cdb[2] & 0x0f) >> 4; ++ type = cmd->cdb[2] & 0x0f; ++ ++ if (buffer_size != 24) { ++ TRACE_PR("Invalid buffer size %d", buffer_size); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_parameter_list_length_invalid)); ++ goto out; ++ } ++ ++ if (!scst_pr_type_valid(type)) { ++ TRACE_PR("Invalid reservation type %d", type); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out; ++ } ++ ++ reg = tgt_dev->registrant; ++ ++ TRACE_PR("Preempt%s: initiator %s/%d (%p), key %016llx, action_key " ++ "%016llx, scope %x type %x (tgt_dev %p)", ++ abort ? " and abort" : "", ++ debug_transport_id_to_initiator_name(cmd->sess->transport_id), ++ cmd->sess->tgt->rel_tgt_id, reg, key, action_key, scope, type, ++ tgt_dev); ++ ++ /* We already checked reg is not NULL */ ++ if (reg->key != key) { ++ TRACE_PR("Registrant's %p key %016llx mismatch with %016llx", ++ reg, reg->key, key); ++ scst_set_cmd_error_status(cmd, SAM_STAT_RESERVATION_CONFLICT); ++ goto out; ++ } ++ ++ if (!dev->pr_is_set) { ++ scst_pr_find_registrants_list_key(dev, action_key, ++ &preempt_list); ++ if (list_empty(&preempt_list)) ++ goto out_error; ++ list_for_each_entry_safe(r, rt, &preempt_list, aux_list_entry) { ++ if (abort) ++ scst_pr_abort_reg(dev, cmd, r); ++ if (r != reg) { ++ scst_pr_send_ua_reg(dev, r, SCST_LOAD_SENSE( ++ scst_sense_registrations_preempted)); ++ scst_pr_remove_registrant(dev, r); ++ } ++ } ++ goto done; ++ } ++ ++ if (dev->pr_type == TYPE_WRITE_EXCLUSIVE_ALL_REG || ++ dev->pr_type == TYPE_EXCLUSIVE_ACCESS_ALL_REG) { ++ if (action_key == 0) { ++ scst_pr_find_registrants_list_all(dev, reg, ++ &preempt_list); ++ list_for_each_entry_safe(r, rt, &preempt_list, ++ aux_list_entry) { ++ BUG_ON(r == reg); ++ if (abort) ++ scst_pr_abort_reg(dev, cmd, r); ++ scst_pr_send_ua_reg(dev, r, ++ SCST_LOAD_SENSE( ++ scst_sense_registrations_preempted)); ++ scst_pr_remove_registrant(dev, r); ++ } ++ scst_pr_set_holder(dev, reg, scope, type); ++ } else { ++ scst_pr_find_registrants_list_key(dev, action_key, ++ &preempt_list); ++ if (list_empty(&preempt_list)) ++ goto out_error; ++ list_for_each_entry_safe(r, rt, &preempt_list, ++ aux_list_entry) { ++ if (abort) ++ scst_pr_abort_reg(dev, cmd, r); ++ if (r != reg) { ++ scst_pr_send_ua_reg(dev, r, ++ SCST_LOAD_SENSE( ++ scst_sense_registrations_preempted)); ++ scst_pr_remove_registrant(dev, r); ++ } ++ } ++ } ++ goto done; ++ } ++ ++ if (dev->pr_holder->key != action_key) { ++ if (action_key == 0) { ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE( ++ scst_sense_invalid_field_in_parm_list)); ++ goto out; ++ } else { ++ scst_pr_find_registrants_list_key(dev, action_key, ++ &preempt_list); ++ if (list_empty(&preempt_list)) ++ goto out_error; ++ list_for_each_entry_safe(r, rt, &preempt_list, ++ aux_list_entry) { ++ if (abort) ++ scst_pr_abort_reg(dev, cmd, r); ++ if (r != reg) ++ scst_pr_send_ua_reg(dev, r, ++ SCST_LOAD_SENSE( ++ scst_sense_registrations_preempted)); ++ scst_pr_remove_registrant(dev, r); ++ } ++ goto done; ++ } ++ } ++ ++ scst_pr_find_registrants_list_key(dev, action_key, ++ &preempt_list); ++ ++ list_for_each_entry_safe(r, rt, &preempt_list, aux_list_entry) { ++ if (abort) ++ scst_pr_abort_reg(dev, cmd, r); ++ if (r != reg) { ++ scst_pr_send_ua_reg(dev, r, SCST_LOAD_SENSE( ++ scst_sense_registrations_preempted)); ++ scst_pr_remove_registrant(dev, r); ++ } ++ } ++ ++ scst_pr_set_holder(dev, reg, scope, type); ++ ++ if (existing_pr_type != type || existing_pr_scope != scope) { ++ list_for_each_entry(r, &dev->dev_registrants_list, ++ dev_registrants_list_entry) { ++ if (r != reg) ++ scst_pr_send_ua_reg(dev, r, SCST_LOAD_SENSE( ++ scst_sense_reservation_released)); ++ } ++ } ++ ++done: ++ dev->pr_generation++; ++ ++ scst_pr_dump_prs(dev, false); ++ ++out: ++ TRACE_EXIT(); ++ return; ++ ++out_error: ++ TRACE_PR("Invalid key %016llx", action_key); ++ scst_set_cmd_error_status(cmd, SAM_STAT_RESERVATION_CONFLICT); ++ goto out; ++} ++ ++/* Called with dev_pr_mutex locked, no IRQ */ ++void scst_pr_preempt(struct scst_cmd *cmd, uint8_t *buffer, int buffer_size) ++{ ++ TRACE_ENTRY(); ++ ++ scst_pr_do_preempt(cmd, buffer, buffer_size, false); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void scst_cmd_done_pr_preempt(struct scst_cmd *cmd, int next_state, ++ enum scst_exec_context pref_context) ++{ ++ void (*saved_cmd_done) (struct scst_cmd *cmd, int next_state, ++ enum scst_exec_context pref_context); ++ ++ TRACE_ENTRY(); ++ ++ if (!atomic_dec_and_test(&cmd->pr_abort_counter->pr_abort_pending_cnt)) ++ goto out; ++ ++ saved_cmd_done = cmd->pr_abort_counter->saved_cmd_done; ++ kfree(cmd->pr_abort_counter); ++ cmd->pr_abort_counter = NULL; ++ ++ saved_cmd_done(cmd, next_state, pref_context); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * Called with dev_pr_mutex locked, no IRQ. Expects session_list_lock ++ * not locked ++ */ ++void scst_pr_preempt_and_abort(struct scst_cmd *cmd, uint8_t *buffer, ++ int buffer_size) ++{ ++ TRACE_ENTRY(); ++ ++ cmd->pr_abort_counter = kzalloc(sizeof(*cmd->pr_abort_counter), ++ GFP_KERNEL); ++ if (cmd->pr_abort_counter == NULL) { ++ PRINT_ERROR("Unable to allocate PR abort counter (size %zd)", ++ sizeof(*cmd->pr_abort_counter)); ++ scst_set_busy(cmd); ++ goto out; ++ } ++ ++ /* 1 to protect cmd from be done by the TM thread too early */ ++ atomic_set(&cmd->pr_abort_counter->pr_abort_pending_cnt, 1); ++ atomic_set(&cmd->pr_abort_counter->pr_aborting_cnt, 1); ++ init_completion(&cmd->pr_abort_counter->pr_aborting_cmpl); ++ ++ cmd->pr_abort_counter->saved_cmd_done = cmd->scst_cmd_done; ++ cmd->scst_cmd_done = scst_cmd_done_pr_preempt; ++ ++ scst_pr_do_preempt(cmd, buffer, buffer_size, true); ++ ++ if (!atomic_dec_and_test(&cmd->pr_abort_counter->pr_aborting_cnt)) ++ wait_for_completion(&cmd->pr_abort_counter->pr_aborting_cmpl); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Checks if this is a Compatible Reservation Handling (CRH) case */ ++bool scst_pr_crh_case(struct scst_cmd *cmd) ++{ ++ bool allowed; ++ struct scst_device *dev = cmd->dev; ++ struct scst_tgt_dev *tgt_dev = cmd->tgt_dev; ++ struct scst_dev_registrant *reg; ++ uint8_t type; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Test if there is a CRH case for command %s (0x%x) from " ++ "%s", cmd->op_name, cmd->cdb[0], cmd->sess->initiator_name); ++ ++ if (!dev->pr_is_set) { ++ TRACE_PR("%s", "PR not set"); ++ allowed = false; ++ goto out; ++ } ++ ++ reg = tgt_dev->registrant; ++ type = dev->pr_type; ++ ++ switch (type) { ++ case TYPE_WRITE_EXCLUSIVE: ++ case TYPE_EXCLUSIVE_ACCESS: ++ WARN_ON(dev->pr_holder == NULL); ++ if (reg == dev->pr_holder) ++ allowed = true; ++ else ++ allowed = false; ++ break; ++ ++ case TYPE_WRITE_EXCLUSIVE_REGONLY: ++ case TYPE_EXCLUSIVE_ACCESS_REGONLY: ++ case TYPE_WRITE_EXCLUSIVE_ALL_REG: ++ case TYPE_EXCLUSIVE_ACCESS_ALL_REG: ++ allowed = (reg != NULL); ++ break; ++ ++ default: ++ PRINT_ERROR("Invalid PR type %x", type); ++ allowed = false; ++ break; ++ } ++ ++ if (!allowed) ++ TRACE_PR("Command %s (0x%x) from %s rejected due to not CRH " ++ "reservation", cmd->op_name, cmd->cdb[0], ++ cmd->sess->initiator_name); ++ else ++ TRACE_DBG("Command %s (0x%x) from %s is allowed to execute " ++ "due to CRH", cmd->op_name, cmd->cdb[0], ++ cmd->sess->initiator_name); ++ ++out: ++ TRACE_EXIT_RES(allowed); ++ return allowed; ++ ++} ++ ++/* Check if command allowed in presence of reservation */ ++bool scst_pr_is_cmd_allowed(struct scst_cmd *cmd) ++{ ++ bool allowed; ++ struct scst_device *dev = cmd->dev; ++ struct scst_tgt_dev *tgt_dev = cmd->tgt_dev; ++ struct scst_dev_registrant *reg; ++ uint8_t type; ++ bool unlock; ++ ++ TRACE_ENTRY(); ++ ++ unlock = scst_pr_read_lock(cmd); ++ ++ TRACE_DBG("Testing if command %s (0x%x) from %s allowed to execute", ++ cmd->op_name, cmd->cdb[0], cmd->sess->initiator_name); ++ ++ /* Recheck, because it can change while we were waiting for the lock */ ++ if (unlikely(!dev->pr_is_set)) { ++ allowed = true; ++ goto out_unlock; ++ } ++ ++ reg = tgt_dev->registrant; ++ type = dev->pr_type; ++ ++ switch (type) { ++ case TYPE_WRITE_EXCLUSIVE: ++ if (reg && reg == dev->pr_holder) ++ allowed = true; ++ else ++ allowed = (cmd->op_flags & SCST_WRITE_EXCL_ALLOWED) != 0; ++ break; ++ ++ case TYPE_EXCLUSIVE_ACCESS: ++ if (reg && reg == dev->pr_holder) ++ allowed = true; ++ else ++ allowed = (cmd->op_flags & SCST_EXCL_ACCESS_ALLOWED) != 0; ++ break; ++ ++ case TYPE_WRITE_EXCLUSIVE_REGONLY: ++ case TYPE_WRITE_EXCLUSIVE_ALL_REG: ++ if (reg) ++ allowed = true; ++ else ++ allowed = (cmd->op_flags & SCST_WRITE_EXCL_ALLOWED) != 0; ++ break; ++ ++ case TYPE_EXCLUSIVE_ACCESS_REGONLY: ++ case TYPE_EXCLUSIVE_ACCESS_ALL_REG: ++ if (reg) ++ allowed = true; ++ else ++ allowed = (cmd->op_flags & SCST_EXCL_ACCESS_ALLOWED) != 0; ++ break; ++ ++ default: ++ PRINT_ERROR("Invalid PR type %x", type); ++ allowed = false; ++ break; ++ } ++ ++ if (!allowed) ++ TRACE_PR("Command %s (0x%x) from %s rejected due " ++ "to PR", cmd->op_name, cmd->cdb[0], ++ cmd->sess->initiator_name); ++ else ++ TRACE_DBG("Command %s (0x%x) from %s is allowed to execute", ++ cmd->op_name, cmd->cdb[0], cmd->sess->initiator_name); ++ ++out_unlock: ++ scst_pr_read_unlock(cmd, unlock); ++ ++ TRACE_EXIT_RES(allowed); ++ return allowed; ++} ++ ++/* Called with dev_pr_mutex locked, no IRQ */ ++void scst_pr_read_keys(struct scst_cmd *cmd, uint8_t *buffer, int buffer_size) ++{ ++ int i, offset = 0, size, size_max; ++ struct scst_device *dev = cmd->dev; ++ struct scst_dev_registrant *reg; ++ ++ TRACE_ENTRY(); ++ ++ if (buffer_size < 8) { ++ TRACE_PR("buffer_size too small: %d. expected >= 8 " ++ "(buffer %p)", buffer_size, buffer); ++ goto skip; ++ } ++ ++ TRACE_PR("Read Keys (dev %s): PRGen %d", dev->virt_name, ++ dev->pr_generation); ++ ++ put_unaligned(cpu_to_be32(dev->pr_generation), (__be32 *)&buffer[0]); ++ ++ offset = 8; ++ size = 0; ++ size_max = buffer_size - 8; ++ ++ i = 0; ++ list_for_each_entry(reg, &dev->dev_registrants_list, ++ dev_registrants_list_entry) { ++ if (size_max - size >= 8) { ++ TRACE_PR("Read Keys (dev %s): key 0x%llx", ++ dev->virt_name, reg->key); ++ ++ WARN_ON(reg->key == 0); ++ ++ put_unaligned(reg->key, ++ (__be64 *)&buffer[offset + 8 * i]); ++ ++ offset += 8; ++ } ++ size += 8; ++ } ++ ++ put_unaligned(cpu_to_be32(size), (__be32 *)&buffer[4]); ++ ++skip: ++ scst_set_resp_data_len(cmd, offset); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Called with dev_pr_mutex locked, no IRQ */ ++void scst_pr_read_reservation(struct scst_cmd *cmd, uint8_t *buffer, ++ int buffer_size) ++{ ++ struct scst_device *dev = cmd->dev; ++ uint8_t b[24]; ++ int size = 0; ++ ++ TRACE_ENTRY(); ++ ++ if (buffer_size < 8) { ++ TRACE_PR("buffer_size too small: %d. expected >= 8 " ++ "(buffer %p)", buffer_size, buffer); ++ goto skip; ++ } ++ ++ memset(b, 0, sizeof(b)); ++ ++ put_unaligned(cpu_to_be32(dev->pr_generation), (__be32 *)&b[0]); ++ ++ if (!dev->pr_is_set) { ++ TRACE_PR("Read Reservation: no reservations for dev %s", ++ dev->virt_name); ++ b[4] = ++ b[5] = ++ b[6] = ++ b[7] = 0; ++ ++ size = 8; ++ } else { ++ __be64 key = dev->pr_holder ? dev->pr_holder->key : 0; ++ ++ TRACE_PR("Read Reservation: dev %s, holder %p, key 0x%llx, " ++ "scope %d, type %d", dev->virt_name, dev->pr_holder, ++ key, dev->pr_scope, dev->pr_type); ++ ++ b[4] = ++ b[5] = ++ b[6] = 0; ++ b[7] = 0x10; ++ ++ put_unaligned(key, (__be64 *)&b[8]); ++ b[21] = dev->pr_scope << 4 | dev->pr_type; ++ ++ size = 24; ++ } ++ ++ memset(buffer, 0, buffer_size); ++ memcpy(buffer, b, min(size, buffer_size)); ++ ++skip: ++ scst_set_resp_data_len(cmd, size); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Called with dev_pr_mutex locked, no IRQ */ ++void scst_pr_report_caps(struct scst_cmd *cmd, uint8_t *buffer, int buffer_size) ++{ ++ int offset = 0; ++ unsigned int crh = 1; ++ unsigned int atp_c = 1; ++ unsigned int sip_c = 1; ++ unsigned int ptpl_c = 1; ++ struct scst_device *dev = cmd->dev; ++ ++ TRACE_ENTRY(); ++ ++ if (buffer_size < 8) { ++ TRACE_PR("buffer_size too small: %d. expected >= 8 " ++ "(buffer %p)", buffer_size, buffer); ++ goto skip; ++ } ++ ++ TRACE_PR("Reporting capabilities (dev %s): crh %x, sip_c %x, " ++ "atp_c %x, ptpl_c %x, pr_aptpl %x", dev->virt_name, ++ crh, sip_c, atp_c, ptpl_c, dev->pr_aptpl); ++ ++ buffer[0] = 0; ++ buffer[1] = 8; ++ ++ buffer[2] = crh << 4 | sip_c << 3 | atp_c << 2 | ptpl_c; ++ buffer[3] = (1 << 7) | (dev->pr_aptpl > 0 ? 1 : 0); ++ ++ /* All commands supported */ ++ buffer[4] = 0xEA; ++ buffer[5] = 0x1; ++ ++ offset += 8; ++ ++skip: ++ scst_set_resp_data_len(cmd, offset); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Called with dev_pr_mutex locked, no IRQ */ ++void scst_pr_read_full_status(struct scst_cmd *cmd, uint8_t *buffer, ++ int buffer_size) ++{ ++ int offset = 0, size, size_max; ++ struct scst_device *dev = cmd->dev; ++ struct scst_dev_registrant *reg; ++ ++ TRACE_ENTRY(); ++ ++ if (buffer_size < 8) ++ goto skip; ++ ++ put_unaligned(cpu_to_be32(dev->pr_generation), (__be32 *)&buffer[0]); ++ offset += 8; ++ ++ size = 0; ++ size_max = buffer_size - 8; ++ ++ list_for_each_entry(reg, &dev->dev_registrants_list, ++ dev_registrants_list_entry) { ++ int ts; ++ int rec_len; ++ ++ ts = tid_size(reg->transport_id); ++ rec_len = 24 + ts; ++ ++ if (size_max - size > rec_len) { ++ memset(&buffer[offset], 0, rec_len); ++ ++ put_unaligned(reg->key, (__be64 *)(&buffer[offset])); ++ ++ if (dev->pr_is_set && scst_pr_is_holder(dev, reg)) { ++ buffer[offset + 12] = 1; ++ buffer[offset + 13] = (dev->pr_scope << 4) | dev->pr_type; ++ } ++ ++ put_unaligned(cpu_to_be16(reg->rel_tgt_id), ++ (__be16 *)&buffer[offset + 18]); ++ put_unaligned(cpu_to_be32(ts), ++ (__be32 *)&buffer[offset + 20]); ++ ++ memcpy(&buffer[offset + 24], reg->transport_id, ts); ++ ++ offset += rec_len; ++ } ++ size += rec_len; ++ } ++ ++ put_unaligned(cpu_to_be32(size), (__be32 *)&buffer[4]); ++ ++skip: ++ scst_set_resp_data_len(cmd, offset); ++ ++ TRACE_EXIT(); ++ return; ++} +diff -uprN orig/linux-3.2/drivers/scst/scst_sysfs.c linux-3.2/drivers/scst/scst_sysfs.c +--- orig/linux-3.2/drivers/scst/scst_sysfs.c ++++ linux-3.2/drivers/scst/scst_sysfs.c +@@ -0,0 +1,6224 @@ ++/* ++ * scst_sysfs.c ++ * ++ * Copyright (C) 2009 Daniel Henrique Debonzi <debonzi@linux.vnet.ibm.com> ++ * Copyright (C) 2009 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2009 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/kobject.h> ++#include <linux/string.h> ++#include <linux/sysfs.h> ++#include <linux/module.h> ++#include <linux/init.h> ++#include <linux/ctype.h> ++#include <linux/slab.h> ++#include <linux/kthread.h> ++ ++#include <scst/scst.h> ++#include "scst_priv.h" ++#include "scst_pres.h" ++ ++static DECLARE_COMPLETION(scst_sysfs_root_release_completion); ++ ++static struct kobject *scst_targets_kobj; ++static struct kobject *scst_devices_kobj; ++static struct kobject *scst_handlers_kobj; ++static struct kobject *scst_device_groups_kobj; ++ ++static const char *const scst_dev_handler_types[] = { ++ "Direct-access device (e.g., magnetic disk)", ++ "Sequential-access device (e.g., magnetic tape)", ++ "Printer device", ++ "Processor device", ++ "Write-once device (e.g., some optical disks)", ++ "CD-ROM device", ++ "Scanner device (obsolete)", ++ "Optical memory device (e.g., some optical disks)", ++ "Medium changer device (e.g., jukeboxes)", ++ "Communications device (obsolete)", ++ "Defined by ASC IT8 (Graphic arts pre-press devices)", ++ "Defined by ASC IT8 (Graphic arts pre-press devices)", ++ "Storage array controller device (e.g., RAID)", ++ "Enclosure services device", ++ "Simplified direct-access device (e.g., magnetic disk)", ++ "Optical card reader/writer device" ++}; ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ ++static DEFINE_MUTEX(scst_log_mutex); ++ ++static struct scst_trace_log scst_trace_tbl[] = { ++ { TRACE_OUT_OF_MEM, "out_of_mem" }, ++ { TRACE_MINOR, "minor" }, ++ { TRACE_SG_OP, "sg" }, ++ { TRACE_MEMORY, "mem" }, ++ { TRACE_BUFF, "buff" }, ++#ifndef GENERATING_UPSTREAM_PATCH ++ { TRACE_ENTRYEXIT, "entryexit" }, ++#endif ++ { TRACE_PID, "pid" }, ++ { TRACE_LINE, "line" }, ++ { TRACE_FUNCTION, "function" }, ++ { TRACE_DEBUG, "debug" }, ++ { TRACE_SPECIAL, "special" }, ++ { TRACE_SCSI, "scsi" }, ++ { TRACE_MGMT, "mgmt" }, ++ { TRACE_MGMT_DEBUG, "mgmt_dbg" }, ++ { TRACE_FLOW_CONTROL, "flow_control" }, ++ { TRACE_PRES, "pr" }, ++ { 0, NULL } ++}; ++ ++static struct scst_trace_log scst_local_trace_tbl[] = { ++ { TRACE_RTRY, "retry" }, ++ { TRACE_SCSI_SERIALIZING, "scsi_serializing" }, ++ { TRACE_RCV_BOT, "recv_bot" }, ++ { TRACE_SND_BOT, "send_bot" }, ++ { TRACE_RCV_TOP, "recv_top" }, ++ { TRACE_SND_TOP, "send_top" }, ++ { 0, NULL } ++}; ++ ++static void scst_read_trace_tbl(const struct scst_trace_log *tbl, char *buf, ++ unsigned long log_level, int *pos) ++{ ++ const struct scst_trace_log *t = tbl; ++ ++ if (t == NULL) ++ goto out; ++ ++ while (t->token) { ++ if (log_level & t->val) { ++ *pos += sprintf(&buf[*pos], "%s%s", ++ (*pos == 0) ? "" : " | ", ++ t->token); ++ } ++ t++; ++ } ++out: ++ return; ++} ++ ++static ssize_t scst_trace_level_show(const struct scst_trace_log *local_tbl, ++ unsigned long log_level, char *buf, const char *help) ++{ ++ int pos = 0; ++ ++ scst_read_trace_tbl(scst_trace_tbl, buf, log_level, &pos); ++ scst_read_trace_tbl(local_tbl, buf, log_level, &pos); ++ ++ pos += sprintf(&buf[pos], "\n\n\nUsage:\n" ++ " echo \"all|none|default\" >trace_level\n" ++ " echo \"value DEC|0xHEX|0OCT\" >trace_level\n" ++ " echo \"add|del TOKEN\" >trace_level\n" ++ "\nwhere TOKEN is one of [debug, function, line, pid,\n" ++#ifndef GENERATING_UPSTREAM_PATCH ++ " entryexit, buff, mem, sg, out_of_mem,\n" ++#else ++ " buff, mem, sg, out_of_mem,\n" ++#endif ++ " special, scsi, mgmt, minor,\n" ++ " mgmt_dbg, scsi_serializing,\n" ++ " retry, recv_bot, send_bot, recv_top, pr,\n" ++ " send_top%s]\n", help != NULL ? help : ""); ++ ++ return pos; ++} ++ ++static int scst_write_trace(const char *buf, size_t length, ++ unsigned long *log_level, unsigned long default_level, ++ const char *name, const struct scst_trace_log *tbl) ++{ ++ int res = length; ++ int action; ++ unsigned long level = 0, oldlevel; ++ char *buffer, *p, *e; ++ const struct scst_trace_log *t; ++ enum { ++ SCST_TRACE_ACTION_ALL = 1, ++ SCST_TRACE_ACTION_NONE = 2, ++ SCST_TRACE_ACTION_DEFAULT = 3, ++ SCST_TRACE_ACTION_ADD = 4, ++ SCST_TRACE_ACTION_DEL = 5, ++ SCST_TRACE_ACTION_VALUE = 6, ++ }; ++ ++ TRACE_ENTRY(); ++ ++ if ((buf == NULL) || (length == 0)) { ++ res = -EINVAL; ++ goto out; ++ } ++ ++ buffer = kasprintf(GFP_KERNEL, "%.*s", (int)length, buf); ++ if (buffer == NULL) { ++ PRINT_ERROR("Unable to alloc intermediate buffer (size %zd)", ++ length+1); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ TRACE_DBG("buffer %s", buffer); ++ ++ p = buffer; ++ if (!strncasecmp("all", p, 3)) { ++ action = SCST_TRACE_ACTION_ALL; ++ } else if (!strncasecmp("none", p, 4) || !strncasecmp("null", p, 4)) { ++ action = SCST_TRACE_ACTION_NONE; ++ } else if (!strncasecmp("default", p, 7)) { ++ action = SCST_TRACE_ACTION_DEFAULT; ++ } else if (!strncasecmp("add", p, 3)) { ++ p += 3; ++ action = SCST_TRACE_ACTION_ADD; ++ } else if (!strncasecmp("del", p, 3)) { ++ p += 3; ++ action = SCST_TRACE_ACTION_DEL; ++ } else if (!strncasecmp("value", p, 5)) { ++ p += 5; ++ action = SCST_TRACE_ACTION_VALUE; ++ } else { ++ if (p[strlen(p) - 1] == '\n') ++ p[strlen(p) - 1] = '\0'; ++ PRINT_ERROR("Unknown action \"%s\"", p); ++ res = -EINVAL; ++ goto out_free; ++ } ++ ++ switch (action) { ++ case SCST_TRACE_ACTION_ADD: ++ case SCST_TRACE_ACTION_DEL: ++ case SCST_TRACE_ACTION_VALUE: ++ if (!isspace(*p)) { ++ PRINT_ERROR("%s", "Syntax error"); ++ res = -EINVAL; ++ goto out_free; ++ } ++ } ++ ++ switch (action) { ++ case SCST_TRACE_ACTION_ALL: ++ level = TRACE_ALL; ++ break; ++ case SCST_TRACE_ACTION_DEFAULT: ++ level = default_level; ++ break; ++ case SCST_TRACE_ACTION_NONE: ++ level = TRACE_NULL; ++ break; ++ case SCST_TRACE_ACTION_ADD: ++ case SCST_TRACE_ACTION_DEL: ++ while (isspace(*p) && *p != '\0') ++ p++; ++ e = p; ++ while (!isspace(*e) && *e != '\0') ++ e++; ++ *e = 0; ++ if (tbl) { ++ t = tbl; ++ while (t->token) { ++ if (!strcasecmp(p, t->token)) { ++ level = t->val; ++ break; ++ } ++ t++; ++ } ++ } ++ if (level == 0) { ++ t = scst_trace_tbl; ++ while (t->token) { ++ if (!strcasecmp(p, t->token)) { ++ level = t->val; ++ break; ++ } ++ t++; ++ } ++ } ++ if (level == 0) { ++ PRINT_ERROR("Unknown token \"%s\"", p); ++ res = -EINVAL; ++ goto out_free; ++ } ++ break; ++ case SCST_TRACE_ACTION_VALUE: ++ while (isspace(*p) && *p != '\0') ++ p++; ++ res = strict_strtoul(p, 0, &level); ++ if (res != 0) { ++ PRINT_ERROR("Invalid trace value \"%s\"", p); ++ res = -EINVAL; ++ goto out_free; ++ } ++ break; ++ } ++ ++ oldlevel = *log_level; ++ ++ switch (action) { ++ case SCST_TRACE_ACTION_ADD: ++ *log_level |= level; ++ break; ++ case SCST_TRACE_ACTION_DEL: ++ *log_level &= ~level; ++ break; ++ default: ++ *log_level = level; ++ break; ++ } ++ ++ PRINT_INFO("Changed trace level for \"%s\": old 0x%08lx, new 0x%08lx", ++ name, oldlevel, *log_level); ++ ++out_free: ++ kfree(buffer); ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++#endif /* defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) */ ++ ++/** ++ ** Sysfs work ++ **/ ++ ++static DEFINE_SPINLOCK(sysfs_work_lock); ++static LIST_HEAD(sysfs_work_list); ++static DECLARE_WAIT_QUEUE_HEAD(sysfs_work_waitQ); ++static int active_sysfs_works; ++static int last_sysfs_work_res; ++static struct task_struct *sysfs_work_thread; ++ ++/** ++ * scst_alloc_sysfs_work() - allocates a sysfs work ++ */ ++int scst_alloc_sysfs_work(int (*sysfs_work_fn)(struct scst_sysfs_work_item *), ++ bool read_only_action, struct scst_sysfs_work_item **res_work) ++{ ++ int res = 0; ++ struct scst_sysfs_work_item *work; ++ ++ TRACE_ENTRY(); ++ ++ if (sysfs_work_fn == NULL) { ++ PRINT_ERROR("%s", "sysfs_work_fn is NULL"); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ *res_work = NULL; ++ ++ work = kzalloc(sizeof(*work), GFP_KERNEL); ++ if (work == NULL) { ++ PRINT_ERROR("Unable to alloc sysfs work (size %zd)", ++ sizeof(*work)); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ work->read_only_action = read_only_action; ++ kref_init(&work->sysfs_work_kref); ++ init_completion(&work->sysfs_work_done); ++ work->sysfs_work_fn = sysfs_work_fn; ++ ++ *res_work = work; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL(scst_alloc_sysfs_work); ++ ++static void scst_sysfs_work_release(struct kref *kref) ++{ ++ struct scst_sysfs_work_item *work; ++ ++ TRACE_ENTRY(); ++ ++ work = container_of(kref, struct scst_sysfs_work_item, ++ sysfs_work_kref); ++ ++ TRACE_DBG("Freeing sysfs work %p (buf %p)", work, work->buf); ++ ++ kfree(work->buf); ++ kfree(work->res_buf); ++ kfree(work); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ * scst_sysfs_work_get() - increases ref counter of the sysfs work ++ */ ++void scst_sysfs_work_get(struct scst_sysfs_work_item *work) ++{ ++ kref_get(&work->sysfs_work_kref); ++} ++EXPORT_SYMBOL(scst_sysfs_work_get); ++ ++/** ++ * scst_sysfs_work_put() - decreases ref counter of the sysfs work ++ */ ++void scst_sysfs_work_put(struct scst_sysfs_work_item *work) ++{ ++ kref_put(&work->sysfs_work_kref, scst_sysfs_work_release); ++} ++EXPORT_SYMBOL(scst_sysfs_work_put); ++ ++/* Called under sysfs_work_lock and drops/reacquire it inside */ ++static void scst_process_sysfs_works(void) ++ __releases(&sysfs_work_lock) ++ __acquires(&sysfs_work_lock) ++{ ++ struct scst_sysfs_work_item *work; ++ ++ TRACE_ENTRY(); ++ ++ while (!list_empty(&sysfs_work_list)) { ++ work = list_entry(sysfs_work_list.next, ++ struct scst_sysfs_work_item, sysfs_work_list_entry); ++ list_del(&work->sysfs_work_list_entry); ++ spin_unlock(&sysfs_work_lock); ++ ++ TRACE_DBG("Sysfs work %p", work); ++ ++ work->work_res = work->sysfs_work_fn(work); ++ ++ spin_lock(&sysfs_work_lock); ++ if (!work->read_only_action) ++ last_sysfs_work_res = work->work_res; ++ active_sysfs_works--; ++ spin_unlock(&sysfs_work_lock); ++ ++ complete_all(&work->sysfs_work_done); ++ kref_put(&work->sysfs_work_kref, scst_sysfs_work_release); ++ ++ spin_lock(&sysfs_work_lock); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static inline int test_sysfs_work_list(void) ++{ ++ int res = !list_empty(&sysfs_work_list) || ++ unlikely(kthread_should_stop()); ++ return res; ++} ++ ++static int sysfs_work_thread_fn(void *arg) ++{ ++ bool one_time_only = (bool)arg; ++ ++ TRACE_ENTRY(); ++ ++ if (!one_time_only) ++ PRINT_INFO("User interface thread started, PID %d", current->pid); ++ ++ current->flags |= PF_NOFREEZE; ++ ++ set_user_nice(current, -10); ++ ++ spin_lock(&sysfs_work_lock); ++ while (!kthread_should_stop()) { ++ wait_queue_t wait; ++ init_waitqueue_entry(&wait, current); ++ ++ if (one_time_only && !test_sysfs_work_list()) ++ break; ++ ++ if (!test_sysfs_work_list()) { ++ add_wait_queue_exclusive(&sysfs_work_waitQ, &wait); ++ for (;;) { ++ set_current_state(TASK_INTERRUPTIBLE); ++ if (test_sysfs_work_list()) ++ break; ++ spin_unlock(&sysfs_work_lock); ++ schedule(); ++ spin_lock(&sysfs_work_lock); ++ } ++ set_current_state(TASK_RUNNING); ++ remove_wait_queue(&sysfs_work_waitQ, &wait); ++ } ++ ++ scst_process_sysfs_works(); ++ } ++ spin_unlock(&sysfs_work_lock); ++ ++ if (!one_time_only) { ++ /* ++ * If kthread_should_stop() is true, we are guaranteed to be ++ * on the module unload, so both lists must be empty. ++ */ ++ BUG_ON(!list_empty(&sysfs_work_list)); ++ ++ PRINT_INFO("User interface thread PID %d finished", current->pid); ++ } ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++/** ++ * scst_sysfs_queue_wait_work() - waits for the work to complete ++ * ++ * Returns status of the completed work or -EAGAIN if the work not ++ * completed before timeout. In the latter case a user should poll ++ * last_sysfs_mgmt_res until it returns the result of the processing. ++ */ ++int scst_sysfs_queue_wait_work(struct scst_sysfs_work_item *work) ++{ ++ int res = 0, rc; ++ unsigned long timeout = 15*HZ; ++ struct task_struct *t; ++ static atomic_t uid_thread_name = ATOMIC_INIT(0); ++ ++ TRACE_ENTRY(); ++ ++ spin_lock(&sysfs_work_lock); ++ ++ TRACE_DBG("Adding sysfs work %p to the list", work); ++ list_add_tail(&work->sysfs_work_list_entry, &sysfs_work_list); ++ ++ active_sysfs_works++; ++ ++ kref_get(&work->sysfs_work_kref); ++ ++ spin_unlock(&sysfs_work_lock); ++ ++ wake_up(&sysfs_work_waitQ); ++ ++ /* ++ * We can have a dead lock possibility like: the sysfs thread is waiting ++ * for the last put during some object unregistration and at the same ++ * time another queued work is having reference on that object taken and ++ * waiting for attention from the sysfs thread. Generally, all sysfs ++ * functions calling kobject_get() and then queuing sysfs thread job ++ * affected by this. This is especially dangerous in read only cases, ++ * like vdev_sysfs_filename_show(). ++ * ++ * So, to eliminate that deadlock we will create an extra sysfs thread ++ * for each queued sysfs work. This thread will quit as soon as it will ++ * see that there is not more queued works to process. ++ */ ++ ++ t = kthread_run(sysfs_work_thread_fn, (void *)true, "scst_uid%d", ++ atomic_inc_return(&uid_thread_name)); ++ if (IS_ERR(t)) ++ PRINT_ERROR("kthread_run() for user interface thread %d " ++ "failed: %d", atomic_read(&uid_thread_name), ++ (int)PTR_ERR(t)); ++ ++ while (1) { ++ rc = wait_for_completion_interruptible_timeout( ++ &work->sysfs_work_done, timeout); ++ if (rc == 0) { ++ if (!mutex_is_locked(&scst_mutex)) { ++ TRACE_DBG("scst_mutex not locked, continue " ++ "waiting (work %p)", work); ++ timeout = 5*HZ; ++ continue; ++ } ++ TRACE_MGMT_DBG("Time out waiting for work %p", work); ++ res = -EAGAIN; ++ goto out_put; ++ } else if (rc < 0) { ++ res = rc; ++ goto out_put; ++ } ++ break; ++ } ++ ++ res = work->work_res; ++ ++out_put: ++ kref_put(&work->sysfs_work_kref, scst_sysfs_work_release); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL(scst_sysfs_queue_wait_work); ++ ++/* No locks */ ++static int scst_check_grab_tgtt_ptr(struct scst_tgt_template *tgtt) ++{ ++ int res = 0; ++ struct scst_tgt_template *tt; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_mutex); ++ ++ list_for_each_entry(tt, &scst_template_list, scst_template_list_entry) { ++ if (tt == tgtt) { ++ tgtt->tgtt_active_sysfs_works_count++; ++ goto out_unlock; ++ } ++ } ++ ++ TRACE_DBG("Tgtt %p not found", tgtt); ++ res = -ENOENT; ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* No locks */ ++static void scst_ungrab_tgtt_ptr(struct scst_tgt_template *tgtt) ++{ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_mutex); ++ tgtt->tgtt_active_sysfs_works_count--; ++ mutex_unlock(&scst_mutex); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* scst_mutex supposed to be locked */ ++static int scst_check_tgt_acg_ptrs(struct scst_tgt *tgt, struct scst_acg *acg) ++{ ++ int res = 0; ++ struct scst_tgt_template *tgtt; ++ ++ list_for_each_entry(tgtt, &scst_template_list, scst_template_list_entry) { ++ struct scst_tgt *t; ++ list_for_each_entry(t, &tgtt->tgt_list, tgt_list_entry) { ++ if (t == tgt) { ++ struct scst_acg *a; ++ if (acg == NULL) ++ goto out; ++ if (acg == tgt->default_acg) ++ goto out; ++ list_for_each_entry(a, &tgt->tgt_acg_list, ++ acg_list_entry) { ++ if (a == acg) ++ goto out; ++ } ++ } ++ } ++ } ++ ++ TRACE_DBG("Tgt %p/ACG %p not found", tgt, acg); ++ res = -ENOENT; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* scst_mutex supposed to be locked */ ++static int scst_check_devt_ptr(struct scst_dev_type *devt, ++ struct list_head *list) ++{ ++ int res = 0; ++ struct scst_dev_type *dt; ++ ++ TRACE_ENTRY(); ++ ++ list_for_each_entry(dt, list, dev_type_list_entry) { ++ if (dt == devt) ++ goto out; ++ } ++ ++ TRACE_DBG("Devt %p not found", devt); ++ res = -ENOENT; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* scst_mutex supposed to be locked */ ++static int scst_check_dev_ptr(struct scst_device *dev) ++{ ++ int res = 0; ++ struct scst_device *d; ++ ++ TRACE_ENTRY(); ++ ++ list_for_each_entry(d, &scst_dev_list, dev_list_entry) { ++ if (d == dev) ++ goto out; ++ } ++ ++ TRACE_DBG("Dev %p not found", dev); ++ res = -ENOENT; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* No locks */ ++static int scst_check_grab_devt_ptr(struct scst_dev_type *devt, ++ struct list_head *list) ++{ ++ int res = 0; ++ struct scst_dev_type *dt; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_mutex); ++ ++ list_for_each_entry(dt, list, dev_type_list_entry) { ++ if (dt == devt) { ++ devt->devt_active_sysfs_works_count++; ++ goto out_unlock; ++ } ++ } ++ ++ TRACE_DBG("Devt %p not found", devt); ++ res = -ENOENT; ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* No locks */ ++static void scst_ungrab_devt_ptr(struct scst_dev_type *devt) ++{ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_mutex); ++ devt->devt_active_sysfs_works_count--; ++ mutex_unlock(&scst_mutex); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ ** Regular SCST sysfs ops ++ **/ ++static ssize_t scst_show(struct kobject *kobj, struct attribute *attr, ++ char *buf) ++{ ++ struct kobj_attribute *kobj_attr; ++ kobj_attr = container_of(attr, struct kobj_attribute, attr); ++ ++ return kobj_attr->show(kobj, kobj_attr, buf); ++} ++ ++static ssize_t scst_store(struct kobject *kobj, struct attribute *attr, ++ const char *buf, size_t count) ++{ ++ struct kobj_attribute *kobj_attr; ++ kobj_attr = container_of(attr, struct kobj_attribute, attr); ++ ++ if (kobj_attr->store) ++ return kobj_attr->store(kobj, kobj_attr, buf, count); ++ else ++ return -EIO; ++} ++ ++const struct sysfs_ops scst_sysfs_ops = { ++ .show = scst_show, ++ .store = scst_store, ++}; ++ ++const struct sysfs_ops *scst_sysfs_get_sysfs_ops(void) ++{ ++ return &scst_sysfs_ops; ++} ++EXPORT_SYMBOL_GPL(scst_sysfs_get_sysfs_ops); ++ ++/** ++ ** Target Template ++ **/ ++ ++static void scst_tgtt_release(struct kobject *kobj) ++{ ++ struct scst_tgt_template *tgtt; ++ ++ TRACE_ENTRY(); ++ ++ tgtt = container_of(kobj, struct scst_tgt_template, tgtt_kobj); ++ if (tgtt->tgtt_kobj_release_cmpl) ++ complete_all(tgtt->tgtt_kobj_release_cmpl); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static struct kobj_type tgtt_ktype = { ++ .sysfs_ops = &scst_sysfs_ops, ++ .release = scst_tgtt_release, ++}; ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ ++static ssize_t scst_tgtt_trace_level_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_tgt_template *tgtt; ++ ++ tgtt = container_of(kobj, struct scst_tgt_template, tgtt_kobj); ++ ++ return scst_trace_level_show(tgtt->trace_tbl, ++ tgtt->trace_flags ? *tgtt->trace_flags : 0, buf, ++ tgtt->trace_tbl_help); ++} ++ ++static ssize_t scst_tgtt_trace_level_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ struct scst_tgt_template *tgtt; ++ ++ TRACE_ENTRY(); ++ ++ tgtt = container_of(kobj, struct scst_tgt_template, tgtt_kobj); ++ ++ res = mutex_lock_interruptible(&scst_log_mutex); ++ if (res != 0) ++ goto out; ++ ++ res = scst_write_trace(buf, count, tgtt->trace_flags, ++ tgtt->default_trace_flags, tgtt->name, tgtt->trace_tbl); ++ ++ mutex_unlock(&scst_log_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute tgtt_trace_attr = ++ __ATTR(trace_level, S_IRUGO | S_IWUSR, ++ scst_tgtt_trace_level_show, scst_tgtt_trace_level_store); ++ ++#endif /* defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) */ ++ ++static ssize_t scst_tgtt_mgmt_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ static const char help[] = ++ "Usage: echo \"add_target target_name [parameters]\" >mgmt\n" ++ " echo \"del_target target_name\" >mgmt\n" ++ "%s%s" ++ "%s" ++ "\n" ++ "where parameters are one or more " ++ "param_name=value pairs separated by ';'\n\n" ++ "%s%s%s%s%s%s%s%s\n"; ++ struct scst_tgt_template *tgtt; ++ ++ tgtt = container_of(kobj, struct scst_tgt_template, tgtt_kobj); ++ ++ return scnprintf(buf, SCST_SYSFS_BLOCK_SIZE, help, ++ (tgtt->tgtt_optional_attributes != NULL) ? ++ " echo \"add_attribute <attribute> <value>\" >mgmt\n" ++ " echo \"del_attribute <attribute> <value>\" >mgmt\n" : "", ++ (tgtt->tgt_optional_attributes != NULL) ? ++ " echo \"add_target_attribute target_name <attribute> <value>\" >mgmt\n" ++ " echo \"del_target_attribute target_name <attribute> <value>\" >mgmt\n" : "", ++ (tgtt->mgmt_cmd_help) ? tgtt->mgmt_cmd_help : "", ++ (tgtt->add_target_parameters != NULL) ? ++ "The following parameters available: " : "", ++ (tgtt->add_target_parameters != NULL) ? ++ tgtt->add_target_parameters : "", ++ (tgtt->tgtt_optional_attributes != NULL) ? ++ "The following target driver attributes available: " : "", ++ (tgtt->tgtt_optional_attributes != NULL) ? ++ tgtt->tgtt_optional_attributes : "", ++ (tgtt->tgtt_optional_attributes != NULL) ? "\n" : "", ++ (tgtt->tgt_optional_attributes != NULL) ? ++ "The following target attributes available: " : "", ++ (tgtt->tgt_optional_attributes != NULL) ? ++ tgtt->tgt_optional_attributes : "", ++ (tgtt->tgt_optional_attributes != NULL) ? "\n" : ""); ++} ++ ++static int scst_process_tgtt_mgmt_store(char *buffer, ++ struct scst_tgt_template *tgtt) ++{ ++ int res = 0; ++ char *p, *pp, *target_name; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("buffer %s", buffer); ++ ++ /* Check if our pointer is still alive and, if yes, grab it */ ++ if (scst_check_grab_tgtt_ptr(tgtt) != 0) ++ goto out; ++ ++ pp = buffer; ++ if (pp[strlen(pp) - 1] == '\n') ++ pp[strlen(pp) - 1] = '\0'; ++ ++ p = scst_get_next_lexem(&pp); ++ ++ if (strcasecmp("add_target", p) == 0) { ++ target_name = scst_get_next_lexem(&pp); ++ if (*target_name == '\0') { ++ PRINT_ERROR("%s", "Target name required"); ++ res = -EINVAL; ++ goto out_ungrab; ++ } ++ res = tgtt->add_target(target_name, pp); ++ } else if (strcasecmp("del_target", p) == 0) { ++ target_name = scst_get_next_lexem(&pp); ++ if (*target_name == '\0') { ++ PRINT_ERROR("%s", "Target name required"); ++ res = -EINVAL; ++ goto out_ungrab; ++ } ++ ++ p = scst_get_next_lexem(&pp); ++ if (*p != '\0') ++ goto out_syntax_err; ++ ++ res = tgtt->del_target(target_name); ++ } else if (tgtt->mgmt_cmd != NULL) { ++ scst_restore_token_str(p, pp); ++ res = tgtt->mgmt_cmd(buffer); ++ } else { ++ PRINT_ERROR("Unknown action \"%s\"", p); ++ res = -EINVAL; ++ goto out_ungrab; ++ } ++ ++out_ungrab: ++ scst_ungrab_tgtt_ptr(tgtt); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_syntax_err: ++ PRINT_ERROR("Syntax error on \"%s\"", p); ++ res = -EINVAL; ++ goto out_ungrab; ++} ++ ++static int scst_tgtt_mgmt_store_work_fn(struct scst_sysfs_work_item *work) ++{ ++ return scst_process_tgtt_mgmt_store(work->buf, work->tgtt); ++} ++ ++static ssize_t scst_tgtt_mgmt_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ char *buffer; ++ struct scst_sysfs_work_item *work; ++ struct scst_tgt_template *tgtt; ++ ++ TRACE_ENTRY(); ++ ++ tgtt = container_of(kobj, struct scst_tgt_template, tgtt_kobj); ++ ++ buffer = kasprintf(GFP_KERNEL, "%.*s", (int)count, buf); ++ if (buffer == NULL) { ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ res = scst_alloc_sysfs_work(scst_tgtt_mgmt_store_work_fn, false, &work); ++ if (res != 0) ++ goto out_free; ++ ++ work->buf = buffer; ++ work->tgtt = tgtt; ++ ++ res = scst_sysfs_queue_wait_work(work); ++ if (res == 0) ++ res = count; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free: ++ kfree(buffer); ++ goto out; ++} ++ ++static struct kobj_attribute scst_tgtt_mgmt = ++ __ATTR(mgmt, S_IRUGO | S_IWUSR, scst_tgtt_mgmt_show, ++ scst_tgtt_mgmt_store); ++ ++int scst_tgtt_sysfs_create(struct scst_tgt_template *tgtt) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ res = kobject_init_and_add(&tgtt->tgtt_kobj, &tgtt_ktype, ++ scst_targets_kobj, tgtt->name); ++ if (res != 0) { ++ PRINT_ERROR("Can't add tgtt %s to sysfs", tgtt->name); ++ goto out; ++ } ++ ++ if (tgtt->add_target != NULL) { ++ res = sysfs_create_file(&tgtt->tgtt_kobj, ++ &scst_tgtt_mgmt.attr); ++ if (res != 0) { ++ PRINT_ERROR("Can't add mgmt attr for target driver %s", ++ tgtt->name); ++ goto out_del; ++ } ++ } ++ ++ if (tgtt->tgtt_attrs) { ++ res = sysfs_create_files(&tgtt->tgtt_kobj, tgtt->tgtt_attrs); ++ if (res != 0) { ++ PRINT_ERROR("Can't add attributes for target " ++ "driver %s", tgtt->name); ++ goto out_del; ++ } ++ } ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ if (tgtt->trace_flags != NULL) { ++ res = sysfs_create_file(&tgtt->tgtt_kobj, ++ &tgtt_trace_attr.attr); ++ if (res != 0) { ++ PRINT_ERROR("Can't add trace_flag for target " ++ "driver %s", tgtt->name); ++ goto out_del; ++ } ++ } ++#endif ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_del: ++ scst_tgtt_sysfs_del(tgtt); ++ goto out; ++} ++ ++/* ++ * Must not be called under scst_mutex, due to possible deadlock with ++ * sysfs ref counting in sysfs works (it is waiting for the last put, but ++ * the last ref counter holder is waiting for scst_mutex) ++ */ ++void scst_tgtt_sysfs_del(struct scst_tgt_template *tgtt) ++{ ++ int rc; ++ DECLARE_COMPLETION_ONSTACK(c); ++ ++ TRACE_ENTRY(); ++ ++ tgtt->tgtt_kobj_release_cmpl = &c; ++ ++ kobject_del(&tgtt->tgtt_kobj); ++ kobject_put(&tgtt->tgtt_kobj); ++ ++ rc = wait_for_completion_timeout(tgtt->tgtt_kobj_release_cmpl, HZ); ++ if (rc == 0) { ++ PRINT_INFO("Waiting for releasing sysfs entry " ++ "for target template %s (%d refs)...", tgtt->name, ++ atomic_read(&tgtt->tgtt_kobj.kref.refcount)); ++ wait_for_completion(tgtt->tgtt_kobj_release_cmpl); ++ PRINT_INFO("Done waiting for releasing sysfs " ++ "entry for target template %s", tgtt->name); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ ** Target directory implementation ++ **/ ++ ++static void scst_tgt_release(struct kobject *kobj) ++{ ++ struct scst_tgt *tgt; ++ ++ TRACE_ENTRY(); ++ ++ tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ if (tgt->tgt_kobj_release_cmpl) ++ complete_all(tgt->tgt_kobj_release_cmpl); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static struct kobj_type tgt_ktype = { ++ .sysfs_ops = &scst_sysfs_ops, ++ .release = scst_tgt_release, ++}; ++ ++static int __scst_process_luns_mgmt_store(char *buffer, ++ struct scst_tgt *tgt, struct scst_acg *acg, bool tgt_kobj) ++{ ++ int res, read_only = 0, action; ++ char *p, *e = NULL; ++ unsigned int virt_lun; ++ struct scst_acg_dev *acg_dev = NULL, *acg_dev_tmp; ++ struct scst_device *d, *dev = NULL; ++ enum { ++ SCST_LUN_ACTION_ADD = 1, ++ SCST_LUN_ACTION_DEL = 2, ++ SCST_LUN_ACTION_REPLACE = 3, ++ SCST_LUN_ACTION_CLEAR = 4, ++ }; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("buffer %s", buffer); ++ ++ p = buffer; ++ if (p[strlen(p) - 1] == '\n') ++ p[strlen(p) - 1] = '\0'; ++ if (strncasecmp("add", p, 3) == 0) { ++ p += 3; ++ action = SCST_LUN_ACTION_ADD; ++ } else if (strncasecmp("del", p, 3) == 0) { ++ p += 3; ++ action = SCST_LUN_ACTION_DEL; ++ } else if (!strncasecmp("replace", p, 7)) { ++ p += 7; ++ action = SCST_LUN_ACTION_REPLACE; ++ } else if (!strncasecmp("clear", p, 5)) { ++ p += 5; ++ action = SCST_LUN_ACTION_CLEAR; ++ } else { ++ PRINT_ERROR("Unknown action \"%s\"", p); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ res = scst_suspend_activity(true); ++ if (res != 0) ++ goto out; ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res != 0) ++ goto out_resume; ++ ++ /* Check if tgt and acg not already freed while we were coming here */ ++ if (scst_check_tgt_acg_ptrs(tgt, acg) != 0) ++ goto out_unlock; ++ ++ if ((action != SCST_LUN_ACTION_CLEAR) && ++ (action != SCST_LUN_ACTION_DEL)) { ++ if (!isspace(*p)) { ++ PRINT_ERROR("%s", "Syntax error"); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++ while (isspace(*p) && *p != '\0') ++ p++; ++ e = p; /* save p */ ++ while (!isspace(*e) && *e != '\0') ++ e++; ++ *e = '\0'; ++ ++ list_for_each_entry(d, &scst_dev_list, dev_list_entry) { ++ if (!strcmp(d->virt_name, p)) { ++ dev = d; ++ TRACE_DBG("Device %p (%s) found", dev, p); ++ break; ++ } ++ } ++ if (dev == NULL) { ++ PRINT_ERROR("Device '%s' not found", p); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ } ++ ++ switch (action) { ++ case SCST_LUN_ACTION_ADD: ++ case SCST_LUN_ACTION_REPLACE: ++ { ++ bool dev_replaced = false; ++ ++ e++; ++ while (isspace(*e) && *e != '\0') ++ e++; ++ ++ virt_lun = simple_strtoul(e, &e, 0); ++ if (virt_lun > SCST_MAX_LUN) { ++ PRINT_ERROR("Too big LUN %d (max %d)", virt_lun, ++ SCST_MAX_LUN); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++ while (isspace(*e) && *e != '\0') ++ e++; ++ ++ while (1) { ++ char *pp; ++ unsigned long val; ++ char *param = scst_get_next_token_str(&e); ++ if (param == NULL) ++ break; ++ ++ p = scst_get_next_lexem(¶m); ++ if (*p == '\0') { ++ PRINT_ERROR("Syntax error at %s (device %s)", ++ param, dev->virt_name); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++ pp = scst_get_next_lexem(¶m); ++ if (*pp == '\0') { ++ PRINT_ERROR("Parameter %s value missed for device %s", ++ p, dev->virt_name); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++ if (scst_get_next_lexem(¶m)[0] != '\0') { ++ PRINT_ERROR("Too many parameter's %s values (device %s)", ++ p, dev->virt_name); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++ res = strict_strtoul(pp, 0, &val); ++ if (res != 0) { ++ PRINT_ERROR("strict_strtoul() for %s failed: %d " ++ "(device %s)", pp, res, dev->virt_name); ++ goto out_unlock; ++ } ++ ++ if (!strcasecmp("read_only", p)) { ++ read_only = val; ++ TRACE_DBG("READ ONLY %d", read_only); ++ } else { ++ PRINT_ERROR("Unknown parameter %s (device %s)", ++ p, dev->virt_name); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ } ++ ++ acg_dev = NULL; ++ list_for_each_entry(acg_dev_tmp, &acg->acg_dev_list, ++ acg_dev_list_entry) { ++ if (acg_dev_tmp->lun == virt_lun) { ++ acg_dev = acg_dev_tmp; ++ break; ++ } ++ } ++ ++ if (acg_dev != NULL) { ++ if (action == SCST_LUN_ACTION_ADD) { ++ PRINT_ERROR("virt lun %d already exists in " ++ "group %s", virt_lun, acg->acg_name); ++ res = -EEXIST; ++ goto out_unlock; ++ } else { ++ /* Replace */ ++ res = scst_acg_del_lun(acg, acg_dev->lun, ++ false); ++ if (res != 0) ++ goto out_unlock; ++ ++ dev_replaced = true; ++ } ++ } ++ ++ res = scst_acg_add_lun(acg, ++ tgt_kobj ? tgt->tgt_luns_kobj : acg->luns_kobj, ++ dev, virt_lun, read_only, !dev_replaced, NULL); ++ if (res != 0) ++ goto out_unlock; ++ ++ if (dev_replaced) { ++ struct scst_tgt_dev *tgt_dev; ++ ++ list_for_each_entry(tgt_dev, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ if ((tgt_dev->acg_dev->acg == acg) && ++ (tgt_dev->lun == virt_lun)) { ++ TRACE_MGMT_DBG("INQUIRY DATA HAS CHANGED" ++ " on tgt_dev %p", tgt_dev); ++ scst_gen_aen_or_ua(tgt_dev, ++ SCST_LOAD_SENSE(scst_sense_inquery_data_changed)); ++ } ++ } ++ } ++ ++ break; ++ } ++ case SCST_LUN_ACTION_DEL: ++ while (isspace(*p) && *p != '\0') ++ p++; ++ virt_lun = simple_strtoul(p, &p, 0); ++ ++ res = scst_acg_del_lun(acg, virt_lun, true); ++ if (res != 0) ++ goto out_unlock; ++ break; ++ case SCST_LUN_ACTION_CLEAR: ++ PRINT_INFO("Removed all devices from group %s", ++ acg->acg_name); ++ list_for_each_entry_safe(acg_dev, acg_dev_tmp, ++ &acg->acg_dev_list, ++ acg_dev_list_entry) { ++ res = scst_acg_del_lun(acg, acg_dev->lun, ++ list_is_last(&acg_dev->acg_dev_list_entry, ++ &acg->acg_dev_list)); ++ if (res != 0) ++ goto out_unlock; ++ } ++ break; ++ } ++ ++ res = 0; ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ ++out_resume: ++ scst_resume_activity(); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_luns_mgmt_store_work_fn(struct scst_sysfs_work_item *work) ++{ ++ return __scst_process_luns_mgmt_store(work->buf, work->tgt, work->acg, ++ work->is_tgt_kobj); ++} ++ ++static ssize_t __scst_acg_mgmt_store(struct scst_acg *acg, ++ const char *buf, size_t count, bool is_tgt_kobj, ++ int (*sysfs_work_fn)(struct scst_sysfs_work_item *)) ++{ ++ int res; ++ char *buffer; ++ struct scst_sysfs_work_item *work; ++ ++ TRACE_ENTRY(); ++ ++ buffer = kasprintf(GFP_KERNEL, "%.*s", (int)count, buf); ++ if (buffer == NULL) { ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ res = scst_alloc_sysfs_work(sysfs_work_fn, false, &work); ++ if (res != 0) ++ goto out_free; ++ ++ work->buf = buffer; ++ work->tgt = acg->tgt; ++ work->acg = acg; ++ work->is_tgt_kobj = is_tgt_kobj; ++ ++ res = scst_sysfs_queue_wait_work(work); ++ if (res == 0) ++ res = count; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free: ++ kfree(buffer); ++ goto out; ++} ++ ++static ssize_t __scst_luns_mgmt_store(struct scst_acg *acg, ++ bool tgt_kobj, const char *buf, size_t count) ++{ ++ return __scst_acg_mgmt_store(acg, buf, count, tgt_kobj, ++ scst_luns_mgmt_store_work_fn); ++} ++ ++static ssize_t scst_luns_mgmt_show(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ char *buf) ++{ ++ static const char help[] = ++ "Usage: echo \"add|del H:C:I:L lun [parameters]\" >mgmt\n" ++ " echo \"add VNAME lun [parameters]\" >mgmt\n" ++ " echo \"del lun\" >mgmt\n" ++ " echo \"replace H:C:I:L lun [parameters]\" >mgmt\n" ++ " echo \"replace VNAME lun [parameters]\" >mgmt\n" ++ " echo \"clear\" >mgmt\n" ++ "\n" ++ "where parameters are one or more " ++ "param_name=value pairs separated by ';'\n" ++ "\nThe following parameters available: read_only.\n"; ++ ++ return sprintf(buf, "%s", help); ++} ++ ++static ssize_t scst_luns_mgmt_store(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ const char *buf, size_t count) ++{ ++ int res; ++ struct scst_acg *acg; ++ struct scst_tgt *tgt; ++ ++ tgt = container_of(kobj->parent, struct scst_tgt, tgt_kobj); ++ acg = tgt->default_acg; ++ ++ res = __scst_luns_mgmt_store(acg, true, buf, count); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_luns_mgmt = ++ __ATTR(mgmt, S_IRUGO | S_IWUSR, scst_luns_mgmt_show, ++ scst_luns_mgmt_store); ++ ++static ssize_t __scst_acg_addr_method_show(struct scst_acg *acg, char *buf) ++{ ++ int res; ++ ++ switch (acg->addr_method) { ++ case SCST_LUN_ADDR_METHOD_FLAT: ++ res = sprintf(buf, "FLAT\n"); ++ break; ++ case SCST_LUN_ADDR_METHOD_PERIPHERAL: ++ res = sprintf(buf, "PERIPHERAL\n"); ++ break; ++ case SCST_LUN_ADDR_METHOD_LUN: ++ res = sprintf(buf, "LUN\n"); ++ break; ++ default: ++ res = sprintf(buf, "UNKNOWN\n"); ++ break; ++ } ++ ++ if (acg->addr_method != acg->tgt->tgtt->preferred_addr_method) ++ res += sprintf(&buf[res], "%s\n", SCST_SYSFS_KEY_MARK); ++ ++ return res; ++} ++ ++static ssize_t __scst_acg_addr_method_store(struct scst_acg *acg, ++ const char *buf, size_t count) ++{ ++ int res = count; ++ ++ if (strncasecmp(buf, "FLAT", min_t(int, 4, count)) == 0) ++ acg->addr_method = SCST_LUN_ADDR_METHOD_FLAT; ++ else if (strncasecmp(buf, "PERIPHERAL", min_t(int, 10, count)) == 0) ++ acg->addr_method = SCST_LUN_ADDR_METHOD_PERIPHERAL; ++ else if (strncasecmp(buf, "LUN", min_t(int, 3, count)) == 0) ++ acg->addr_method = SCST_LUN_ADDR_METHOD_LUN; ++ else { ++ PRINT_ERROR("Unknown address method %s", buf); ++ res = -EINVAL; ++ } ++ ++ TRACE_DBG("acg %p, addr_method %d", acg, acg->addr_method); ++ ++ return res; ++} ++ ++static ssize_t scst_tgt_addr_method_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_acg *acg; ++ struct scst_tgt *tgt; ++ ++ tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ acg = tgt->default_acg; ++ ++ return __scst_acg_addr_method_show(acg, buf); ++} ++ ++static ssize_t scst_tgt_addr_method_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ struct scst_acg *acg; ++ struct scst_tgt *tgt; ++ ++ tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ acg = tgt->default_acg; ++ ++ res = __scst_acg_addr_method_store(acg, buf, count); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_tgt_addr_method = ++ __ATTR(addr_method, S_IRUGO | S_IWUSR, scst_tgt_addr_method_show, ++ scst_tgt_addr_method_store); ++ ++static ssize_t __scst_acg_io_grouping_type_show(struct scst_acg *acg, char *buf) ++{ ++ int res; ++ ++ switch (acg->acg_io_grouping_type) { ++ case SCST_IO_GROUPING_AUTO: ++ res = sprintf(buf, "%s\n", SCST_IO_GROUPING_AUTO_STR); ++ break; ++ case SCST_IO_GROUPING_THIS_GROUP_ONLY: ++ res = sprintf(buf, "%s\n%s\n", ++ SCST_IO_GROUPING_THIS_GROUP_ONLY_STR, ++ SCST_SYSFS_KEY_MARK); ++ break; ++ case SCST_IO_GROUPING_NEVER: ++ res = sprintf(buf, "%s\n%s\n", SCST_IO_GROUPING_NEVER_STR, ++ SCST_SYSFS_KEY_MARK); ++ break; ++ default: ++ res = sprintf(buf, "%d\n%s\n", acg->acg_io_grouping_type, ++ SCST_SYSFS_KEY_MARK); ++ break; ++ } ++ ++ return res; ++} ++ ++static int __scst_acg_process_io_grouping_type_store(struct scst_tgt *tgt, ++ struct scst_acg *acg, int io_grouping_type) ++{ ++ int res = 0; ++ struct scst_acg_dev *acg_dev; ++ ++ TRACE_DBG("tgt %p, acg %p, io_grouping_type %d", tgt, acg, ++ io_grouping_type); ++ ++ res = scst_suspend_activity(true); ++ if (res != 0) ++ goto out; ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res != 0) ++ goto out_resume; ++ ++ /* Check if tgt and acg not already freed while we were coming here */ ++ if (scst_check_tgt_acg_ptrs(tgt, acg) != 0) ++ goto out_unlock; ++ ++ acg->acg_io_grouping_type = io_grouping_type; ++ ++ list_for_each_entry(acg_dev, &acg->acg_dev_list, acg_dev_list_entry) { ++ int rc; ++ ++ scst_stop_dev_threads(acg_dev->dev); ++ ++ rc = scst_create_dev_threads(acg_dev->dev); ++ if (rc != 0) ++ res = rc; ++ } ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ ++out_resume: ++ scst_resume_activity(); ++ ++out: ++ return res; ++} ++ ++static int __scst_acg_io_grouping_type_store_work_fn(struct scst_sysfs_work_item *work) ++{ ++ return __scst_acg_process_io_grouping_type_store(work->tgt, work->acg, ++ work->io_grouping_type); ++} ++ ++static ssize_t __scst_acg_io_grouping_type_store(struct scst_acg *acg, ++ const char *buf, size_t count) ++{ ++ int res = 0; ++ int prev = acg->acg_io_grouping_type; ++ long io_grouping_type; ++ struct scst_sysfs_work_item *work; ++ ++ if (strncasecmp(buf, SCST_IO_GROUPING_AUTO_STR, ++ min_t(int, strlen(SCST_IO_GROUPING_AUTO_STR), count)) == 0) ++ io_grouping_type = SCST_IO_GROUPING_AUTO; ++ else if (strncasecmp(buf, SCST_IO_GROUPING_THIS_GROUP_ONLY_STR, ++ min_t(int, strlen(SCST_IO_GROUPING_THIS_GROUP_ONLY_STR), count)) == 0) ++ io_grouping_type = SCST_IO_GROUPING_THIS_GROUP_ONLY; ++ else if (strncasecmp(buf, SCST_IO_GROUPING_NEVER_STR, ++ min_t(int, strlen(SCST_IO_GROUPING_NEVER_STR), count)) == 0) ++ io_grouping_type = SCST_IO_GROUPING_NEVER; ++ else { ++ res = strict_strtol(buf, 0, &io_grouping_type); ++ if ((res != 0) || (io_grouping_type <= 0)) { ++ PRINT_ERROR("Unknown or not allowed I/O grouping type " ++ "%s", buf); ++ res = -EINVAL; ++ goto out; ++ } ++ } ++ ++ if (prev == io_grouping_type) ++ goto out; ++ ++ res = scst_alloc_sysfs_work(__scst_acg_io_grouping_type_store_work_fn, ++ false, &work); ++ if (res != 0) ++ goto out; ++ ++ work->tgt = acg->tgt; ++ work->acg = acg; ++ work->io_grouping_type = io_grouping_type; ++ ++ res = scst_sysfs_queue_wait_work(work); ++ ++out: ++ return res; ++} ++ ++static ssize_t scst_tgt_io_grouping_type_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_acg *acg; ++ struct scst_tgt *tgt; ++ ++ tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ acg = tgt->default_acg; ++ ++ return __scst_acg_io_grouping_type_show(acg, buf); ++} ++ ++static ssize_t scst_tgt_io_grouping_type_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ struct scst_acg *acg; ++ struct scst_tgt *tgt; ++ ++ tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ acg = tgt->default_acg; ++ ++ res = __scst_acg_io_grouping_type_store(acg, buf, count); ++ if (res != 0) ++ goto out; ++ ++ res = count; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_tgt_io_grouping_type = ++ __ATTR(io_grouping_type, S_IRUGO | S_IWUSR, ++ scst_tgt_io_grouping_type_show, ++ scst_tgt_io_grouping_type_store); ++ ++static ssize_t __scst_acg_cpu_mask_show(struct scst_acg *acg, char *buf) ++{ ++ int res; ++ ++ res = cpumask_scnprintf(buf, SCST_SYSFS_BLOCK_SIZE, ++ &acg->acg_cpu_mask); ++ if (!cpus_equal(acg->acg_cpu_mask, default_cpu_mask)) ++ res += sprintf(&buf[res], "\n%s\n", SCST_SYSFS_KEY_MARK); ++ ++ return res; ++} ++ ++static int __scst_acg_process_cpu_mask_store(struct scst_tgt *tgt, ++ struct scst_acg *acg, cpumask_t *cpu_mask) ++{ ++ int res = 0; ++ struct scst_session *sess; ++ ++ TRACE_DBG("tgt %p, acg %p", tgt, acg); ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res != 0) ++ goto out; ++ ++ /* Check if tgt and acg not already freed while we were coming here */ ++ if (scst_check_tgt_acg_ptrs(tgt, acg) != 0) ++ goto out_unlock; ++ ++ cpumask_copy(&acg->acg_cpu_mask, cpu_mask); ++ ++ list_for_each_entry(sess, &acg->acg_sess_list, acg_sess_list_entry) { ++ int i; ++ for (i = 0; i < SESS_TGT_DEV_LIST_HASH_SIZE; i++) { ++ struct scst_tgt_dev *tgt_dev; ++ struct list_head *head = &sess->sess_tgt_dev_list[i]; ++ list_for_each_entry(tgt_dev, head, ++ sess_tgt_dev_list_entry) { ++ struct scst_cmd_thread_t *thr; ++ if (tgt_dev->active_cmd_threads != &tgt_dev->tgt_dev_cmd_threads) ++ continue; ++ list_for_each_entry(thr, ++ &tgt_dev->active_cmd_threads->threads_list, ++ thread_list_entry) { ++ int rc; ++ rc = set_cpus_allowed_ptr(thr->cmd_thread, cpu_mask); ++ if (rc != 0) ++ PRINT_ERROR("Setting CPU " ++ "affinity failed: %d", rc); ++ } ++ } ++ } ++ if (tgt->tgtt->report_aen != NULL) { ++ struct scst_aen *aen; ++ int rc; ++ ++ aen = scst_alloc_aen(sess, 0); ++ if (aen == NULL) { ++ PRINT_ERROR("Unable to notify target driver %s " ++ "about cpu_mask change", tgt->tgt_name); ++ continue; ++ } ++ ++ aen->event_fn = SCST_AEN_CPU_MASK_CHANGED; ++ ++ TRACE_DBG("Calling target's %s report_aen(%p)", ++ tgt->tgtt->name, aen); ++ rc = tgt->tgtt->report_aen(aen); ++ TRACE_DBG("Target's %s report_aen(%p) returned %d", ++ tgt->tgtt->name, aen, rc); ++ if (rc != SCST_AEN_RES_SUCCESS) ++ scst_free_aen(aen); ++ } ++ } ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ ++out: ++ return res; ++} ++ ++static int __scst_acg_cpu_mask_store_work_fn(struct scst_sysfs_work_item *work) ++{ ++ return __scst_acg_process_cpu_mask_store(work->tgt, work->acg, ++ &work->cpu_mask); ++} ++ ++static ssize_t __scst_acg_cpu_mask_store(struct scst_acg *acg, ++ const char *buf, size_t count) ++{ ++ int res; ++ struct scst_sysfs_work_item *work; ++ ++ /* cpumask might be too big for stack */ ++ ++ res = scst_alloc_sysfs_work(__scst_acg_cpu_mask_store_work_fn, ++ false, &work); ++ if (res != 0) ++ goto out; ++ ++ /* ++ * We can't use cpumask_parse_user() here, because it expects ++ * buffer in the user space. ++ */ ++ res = __bitmap_parse(buf, count, 0, cpumask_bits(&work->cpu_mask), ++ nr_cpumask_bits); ++ if (res != 0) { ++ PRINT_ERROR("__bitmap_parse() failed: %d", res); ++ goto out_release; ++ } ++ ++ if (cpus_equal(acg->acg_cpu_mask, work->cpu_mask)) ++ goto out; ++ ++ work->tgt = acg->tgt; ++ work->acg = acg; ++ ++ res = scst_sysfs_queue_wait_work(work); ++ ++out: ++ return res; ++ ++out_release: ++ scst_sysfs_work_release(&work->sysfs_work_kref); ++ goto out; ++} ++ ++static ssize_t scst_tgt_cpu_mask_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_acg *acg; ++ struct scst_tgt *tgt; ++ ++ tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ acg = tgt->default_acg; ++ ++ return __scst_acg_cpu_mask_show(acg, buf); ++} ++ ++static ssize_t scst_tgt_cpu_mask_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ struct scst_acg *acg; ++ struct scst_tgt *tgt; ++ ++ tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ acg = tgt->default_acg; ++ ++ res = __scst_acg_cpu_mask_store(acg, buf, count); ++ if (res != 0) ++ goto out; ++ ++ res = count; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_tgt_cpu_mask = ++ __ATTR(cpu_mask, S_IRUGO | S_IWUSR, ++ scst_tgt_cpu_mask_show, ++ scst_tgt_cpu_mask_store); ++ ++static ssize_t scst_ini_group_mgmt_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ static const char help[] = ++ "Usage: echo \"create GROUP_NAME\" >mgmt\n" ++ " echo \"del GROUP_NAME\" >mgmt\n"; ++ ++ return sprintf(buf, "%s", help); ++} ++ ++static int scst_process_ini_group_mgmt_store(char *buffer, ++ struct scst_tgt *tgt) ++{ ++ int res, action; ++ char *p, *e = NULL; ++ struct scst_acg *a, *acg = NULL; ++ enum { ++ SCST_INI_GROUP_ACTION_CREATE = 1, ++ SCST_INI_GROUP_ACTION_DEL = 2, ++ }; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("tgt %p, buffer %s", tgt, buffer); ++ ++ p = buffer; ++ if (p[strlen(p) - 1] == '\n') ++ p[strlen(p) - 1] = '\0'; ++ if (strncasecmp("create ", p, 7) == 0) { ++ p += 7; ++ action = SCST_INI_GROUP_ACTION_CREATE; ++ } else if (strncasecmp("del ", p, 4) == 0) { ++ p += 4; ++ action = SCST_INI_GROUP_ACTION_DEL; ++ } else { ++ PRINT_ERROR("Unknown action \"%s\"", p); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ res = scst_suspend_activity(true); ++ if (res != 0) ++ goto out; ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res != 0) ++ goto out_resume; ++ ++ /* Check if our pointer is still alive */ ++ if (scst_check_tgt_acg_ptrs(tgt, NULL) != 0) ++ goto out_unlock; ++ ++ while (isspace(*p) && *p != '\0') ++ p++; ++ e = p; ++ while (!isspace(*e) && *e != '\0') ++ e++; ++ *e = '\0'; ++ ++ if (p[0] == '\0') { ++ PRINT_ERROR("%s", "Group name required"); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++ list_for_each_entry(a, &tgt->tgt_acg_list, acg_list_entry) { ++ if (strcmp(a->acg_name, p) == 0) { ++ TRACE_DBG("group (acg) %p %s found", ++ a, a->acg_name); ++ acg = a; ++ break; ++ } ++ } ++ ++ switch (action) { ++ case SCST_INI_GROUP_ACTION_CREATE: ++ TRACE_DBG("Creating group '%s'", p); ++ if (acg != NULL) { ++ PRINT_ERROR("acg name %s exist", p); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ acg = scst_alloc_add_acg(tgt, p, true); ++ if (acg == NULL) ++ goto out_unlock; ++ break; ++ case SCST_INI_GROUP_ACTION_DEL: ++ TRACE_DBG("Deleting group '%s'", p); ++ if (acg == NULL) { ++ PRINT_ERROR("Group %s not found", p); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ if (!scst_acg_sess_is_empty(acg)) { ++ PRINT_ERROR("Group %s is not empty", acg->acg_name); ++ res = -EBUSY; ++ goto out_unlock; ++ } ++ scst_del_free_acg(acg); ++ break; ++ } ++ ++ res = 0; ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ ++out_resume: ++ scst_resume_activity(); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_ini_group_mgmt_store_work_fn(struct scst_sysfs_work_item *work) ++{ ++ return scst_process_ini_group_mgmt_store(work->buf, work->tgt); ++} ++ ++static ssize_t scst_ini_group_mgmt_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ char *buffer; ++ struct scst_tgt *tgt; ++ struct scst_sysfs_work_item *work; ++ ++ TRACE_ENTRY(); ++ ++ tgt = container_of(kobj->parent, struct scst_tgt, tgt_kobj); ++ ++ buffer = kasprintf(GFP_KERNEL, "%.*s", (int)count, buf); ++ if (buffer == NULL) { ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ res = scst_alloc_sysfs_work(scst_ini_group_mgmt_store_work_fn, false, ++ &work); ++ if (res != 0) ++ goto out_free; ++ ++ work->buf = buffer; ++ work->tgt = tgt; ++ ++ res = scst_sysfs_queue_wait_work(work); ++ if (res == 0) ++ res = count; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free: ++ kfree(buffer); ++ goto out; ++} ++ ++static struct kobj_attribute scst_ini_group_mgmt = ++ __ATTR(mgmt, S_IRUGO | S_IWUSR, scst_ini_group_mgmt_show, ++ scst_ini_group_mgmt_store); ++ ++static ssize_t scst_tgt_enable_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_tgt *tgt; ++ int res; ++ bool enabled; ++ ++ TRACE_ENTRY(); ++ ++ tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ ++ enabled = tgt->tgtt->is_target_enabled(tgt); ++ ++ res = sprintf(buf, "%d\n", enabled ? 1 : 0); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_process_tgt_enable_store(struct scst_tgt *tgt, bool enable) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ /* Tgt protected by kobject reference */ ++ ++ TRACE_DBG("tgt %s, enable %d", tgt->tgt_name, enable); ++ ++ if (enable) { ++ if (tgt->rel_tgt_id == 0) { ++ res = gen_relative_target_port_id(&tgt->rel_tgt_id); ++ if (res != 0) ++ goto out_put; ++ PRINT_INFO("Using autogenerated rel ID %d for target " ++ "%s", tgt->rel_tgt_id, tgt->tgt_name); ++ } else { ++ if (!scst_is_relative_target_port_id_unique( ++ tgt->rel_tgt_id, tgt)) { ++ PRINT_ERROR("Relative port id %d is not unique", ++ tgt->rel_tgt_id); ++ res = -EBADSLT; ++ goto out_put; ++ } ++ } ++ } ++ ++ res = tgt->tgtt->enable_target(tgt, enable); ++ ++out_put: ++ kobject_put(&tgt->tgt_kobj); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_tgt_enable_store_work_fn(struct scst_sysfs_work_item *work) ++{ ++ return scst_process_tgt_enable_store(work->tgt, work->enable); ++} ++ ++static ssize_t scst_tgt_enable_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ struct scst_tgt *tgt; ++ bool enable; ++ struct scst_sysfs_work_item *work; ++ ++ TRACE_ENTRY(); ++ ++ if (buf == NULL) { ++ PRINT_ERROR("%s: NULL buffer?", __func__); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ ++ switch (buf[0]) { ++ case '0': ++ enable = false; ++ break; ++ case '1': ++ enable = true; ++ break; ++ default: ++ PRINT_ERROR("%s: Requested action not understood: %s", ++ __func__, buf); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ res = scst_alloc_sysfs_work(scst_tgt_enable_store_work_fn, false, ++ &work); ++ if (res != 0) ++ goto out; ++ ++ work->tgt = tgt; ++ work->enable = enable; ++ ++ kobject_get(&tgt->tgt_kobj); ++ ++ res = scst_sysfs_queue_wait_work(work); ++ if (res == 0) ++ res = count; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute tgt_enable_attr = ++ __ATTR(enabled, S_IRUGO | S_IWUSR, ++ scst_tgt_enable_show, scst_tgt_enable_store); ++ ++static ssize_t scst_rel_tgt_id_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_tgt *tgt; ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ ++ res = sprintf(buf, "%d\n%s", tgt->rel_tgt_id, ++ (tgt->rel_tgt_id != 0) ? SCST_SYSFS_KEY_MARK "\n" : ""); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_process_rel_tgt_id_store(struct scst_sysfs_work_item *work) ++{ ++ int res = 0; ++ struct scst_tgt *tgt = work->tgt_r; ++ unsigned long rel_tgt_id = work->rel_tgt_id; ++ bool enabled; ++ ++ TRACE_ENTRY(); ++ ++ /* tgt protected by kobject_get() */ ++ ++ TRACE_DBG("Trying to set relative target port id %d", ++ (uint16_t)rel_tgt_id); ++ ++ if (tgt->tgtt->is_target_enabled != NULL) ++ enabled = tgt->tgtt->is_target_enabled(tgt); ++ else ++ enabled = true; ++ ++ if (enabled && rel_tgt_id != tgt->rel_tgt_id) { ++ if (!scst_is_relative_target_port_id_unique(rel_tgt_id, tgt)) { ++ PRINT_ERROR("Relative port id %d is not unique", ++ (uint16_t)rel_tgt_id); ++ res = -EBADSLT; ++ goto out_put; ++ } ++ } ++ ++ if (rel_tgt_id < SCST_MIN_REL_TGT_ID || ++ rel_tgt_id > SCST_MAX_REL_TGT_ID) { ++ if ((rel_tgt_id == 0) && !enabled) ++ goto set; ++ ++ PRINT_ERROR("Invalid relative port id %d", ++ (uint16_t)rel_tgt_id); ++ res = -EINVAL; ++ goto out_put; ++ } ++ ++set: ++ tgt->rel_tgt_id = (uint16_t)rel_tgt_id; ++ ++out_put: ++ kobject_put(&tgt->tgt_kobj); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t scst_rel_tgt_id_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res = 0; ++ struct scst_tgt *tgt; ++ unsigned long rel_tgt_id; ++ struct scst_sysfs_work_item *work; ++ ++ TRACE_ENTRY(); ++ ++ if (buf == NULL) ++ goto out; ++ ++ tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ ++ res = strict_strtoul(buf, 0, &rel_tgt_id); ++ if (res != 0) { ++ PRINT_ERROR("%s", "Wrong rel_tgt_id"); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ res = scst_alloc_sysfs_work(scst_process_rel_tgt_id_store, false, ++ &work); ++ if (res != 0) ++ goto out; ++ ++ work->tgt_r = tgt; ++ work->rel_tgt_id = rel_tgt_id; ++ ++ kobject_get(&tgt->tgt_kobj); ++ ++ res = scst_sysfs_queue_wait_work(work); ++ if (res == 0) ++ res = count; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_rel_tgt_id = ++ __ATTR(rel_tgt_id, S_IRUGO | S_IWUSR, scst_rel_tgt_id_show, ++ scst_rel_tgt_id_store); ++ ++static ssize_t scst_tgt_comment_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_tgt *tgt; ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ ++ if (tgt->tgt_comment != NULL) ++ res = sprintf(buf, "%s\n%s", tgt->tgt_comment, ++ SCST_SYSFS_KEY_MARK "\n"); ++ else ++ res = 0; ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t scst_tgt_comment_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ struct scst_tgt *tgt; ++ char *p; ++ int len; ++ ++ TRACE_ENTRY(); ++ ++ if ((buf == NULL) || (count == 0)) { ++ res = 0; ++ goto out; ++ } ++ ++ tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ ++ len = strnlen(buf, count); ++ if (buf[count-1] == '\n') ++ len--; ++ ++ if (len == 0) { ++ kfree(tgt->tgt_comment); ++ tgt->tgt_comment = NULL; ++ goto out_done; ++ } ++ ++ p = kmalloc(len+1, GFP_KERNEL); ++ if (p == NULL) { ++ PRINT_ERROR("Unable to alloc tgt_comment string (len %d)", ++ len+1); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ memcpy(p, buf, len); ++ p[len] = '\0'; ++ ++ kfree(tgt->tgt_comment); ++ ++ tgt->tgt_comment = p; ++ ++out_done: ++ res = count; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_tgt_comment = ++ __ATTR(comment, S_IRUGO | S_IWUSR, scst_tgt_comment_show, ++ scst_tgt_comment_store); ++ ++/* ++ * Supposed to be called under scst_mutex. In case of error will drop, ++ * then reacquire it. ++ */ ++int scst_tgt_sysfs_create(struct scst_tgt *tgt) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ res = kobject_init_and_add(&tgt->tgt_kobj, &tgt_ktype, ++ &tgt->tgtt->tgtt_kobj, tgt->tgt_name); ++ if (res != 0) { ++ PRINT_ERROR("Can't add tgt %s to sysfs", tgt->tgt_name); ++ goto out; ++ } ++ ++ if ((tgt->tgtt->enable_target != NULL) && ++ (tgt->tgtt->is_target_enabled != NULL)) { ++ res = sysfs_create_file(&tgt->tgt_kobj, ++ &tgt_enable_attr.attr); ++ if (res != 0) { ++ PRINT_ERROR("Can't add attr %s to sysfs", ++ tgt_enable_attr.attr.name); ++ goto out_err; ++ } ++ } ++ ++ tgt->tgt_sess_kobj = kobject_create_and_add("sessions", &tgt->tgt_kobj); ++ if (tgt->tgt_sess_kobj == NULL) { ++ PRINT_ERROR("Can't create sess kobj for tgt %s", tgt->tgt_name); ++ goto out_nomem; ++ } ++ ++ tgt->tgt_luns_kobj = kobject_create_and_add("luns", &tgt->tgt_kobj); ++ if (tgt->tgt_luns_kobj == NULL) { ++ PRINT_ERROR("Can't create luns kobj for tgt %s", tgt->tgt_name); ++ goto out_nomem; ++ } ++ ++ res = sysfs_create_file(tgt->tgt_luns_kobj, &scst_luns_mgmt.attr); ++ if (res != 0) { ++ PRINT_ERROR("Can't add attribute %s for tgt %s", ++ scst_luns_mgmt.attr.name, tgt->tgt_name); ++ goto out_err; ++ } ++ ++ tgt->tgt_ini_grp_kobj = kobject_create_and_add("ini_groups", ++ &tgt->tgt_kobj); ++ if (tgt->tgt_ini_grp_kobj == NULL) { ++ PRINT_ERROR("Can't create ini_grp kobj for tgt %s", ++ tgt->tgt_name); ++ goto out_nomem; ++ } ++ ++ res = sysfs_create_file(tgt->tgt_ini_grp_kobj, ++ &scst_ini_group_mgmt.attr); ++ if (res != 0) { ++ PRINT_ERROR("Can't add attribute %s for tgt %s", ++ scst_ini_group_mgmt.attr.name, tgt->tgt_name); ++ goto out_err; ++ } ++ ++ res = sysfs_create_file(&tgt->tgt_kobj, ++ &scst_rel_tgt_id.attr); ++ if (res != 0) { ++ PRINT_ERROR("Can't add attribute %s for tgt %s", ++ scst_rel_tgt_id.attr.name, tgt->tgt_name); ++ goto out_err; ++ } ++ ++ res = sysfs_create_file(&tgt->tgt_kobj, ++ &scst_tgt_comment.attr); ++ if (res != 0) { ++ PRINT_ERROR("Can't add attribute %s for tgt %s", ++ scst_tgt_comment.attr.name, tgt->tgt_name); ++ goto out_err; ++ } ++ ++ res = sysfs_create_file(&tgt->tgt_kobj, ++ &scst_tgt_addr_method.attr); ++ if (res != 0) { ++ PRINT_ERROR("Can't add attribute %s for tgt %s", ++ scst_tgt_addr_method.attr.name, tgt->tgt_name); ++ goto out_err; ++ } ++ ++ res = sysfs_create_file(&tgt->tgt_kobj, ++ &scst_tgt_io_grouping_type.attr); ++ if (res != 0) { ++ PRINT_ERROR("Can't add attribute %s for tgt %s", ++ scst_tgt_io_grouping_type.attr.name, tgt->tgt_name); ++ goto out_err; ++ } ++ ++ res = sysfs_create_file(&tgt->tgt_kobj, &scst_tgt_cpu_mask.attr); ++ if (res != 0) { ++ PRINT_ERROR("Can't add attribute %s for tgt %s", ++ scst_tgt_cpu_mask.attr.name, tgt->tgt_name); ++ goto out_err; ++ } ++ ++ if (tgt->tgtt->tgt_attrs) { ++ res = sysfs_create_files(&tgt->tgt_kobj, tgt->tgtt->tgt_attrs); ++ if (res != 0) { ++ PRINT_ERROR("Can't add attributes for tgt %s", ++ tgt->tgt_name); ++ goto out_err; ++ } ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_nomem: ++ res = -ENOMEM; ++ ++out_err: ++ mutex_unlock(&scst_mutex); ++ scst_tgt_sysfs_del(tgt); ++ mutex_lock(&scst_mutex); ++ goto out; ++} ++ ++/* ++ * Must not be called under scst_mutex, due to possible deadlock with ++ * sysfs ref counting in sysfs works (it is waiting for the last put, but ++ * the last ref counter holder is waiting for scst_mutex) ++ */ ++void scst_tgt_sysfs_del(struct scst_tgt *tgt) ++{ ++ int rc; ++ DECLARE_COMPLETION_ONSTACK(c); ++ ++ TRACE_ENTRY(); ++ ++ tgt->tgt_kobj_release_cmpl = &c; ++ ++ kobject_del(tgt->tgt_sess_kobj); ++ kobject_del(tgt->tgt_luns_kobj); ++ kobject_del(tgt->tgt_ini_grp_kobj); ++ kobject_del(&tgt->tgt_kobj); ++ ++ kobject_put(tgt->tgt_sess_kobj); ++ kobject_put(tgt->tgt_luns_kobj); ++ kobject_put(tgt->tgt_ini_grp_kobj); ++ kobject_put(&tgt->tgt_kobj); ++ ++ rc = wait_for_completion_timeout(tgt->tgt_kobj_release_cmpl, HZ); ++ if (rc == 0) { ++ PRINT_INFO("Waiting for releasing sysfs entry " ++ "for target %s (%d refs)...", tgt->tgt_name, ++ atomic_read(&tgt->tgt_kobj.kref.refcount)); ++ wait_for_completion(tgt->tgt_kobj_release_cmpl); ++ PRINT_INFO("Done waiting for releasing sysfs " ++ "entry for target %s", tgt->tgt_name); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ ** Devices directory implementation ++ **/ ++ ++static ssize_t scst_dev_sysfs_type_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos = 0; ++ ++ struct scst_device *dev; ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ ++ pos = sprintf(buf, "%d - %s\n", dev->type, ++ (unsigned)dev->type >= ARRAY_SIZE(scst_dev_handler_types) ? ++ "unknown" : scst_dev_handler_types[dev->type]); ++ ++ return pos; ++} ++ ++static struct kobj_attribute dev_type_attr = ++ __ATTR(type, S_IRUGO, scst_dev_sysfs_type_show, NULL); ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ ++static ssize_t scst_dev_sysfs_dump_prs(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ struct scst_device *dev; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ ++ scst_pr_dump_prs(dev, true); ++ ++ TRACE_EXIT_RES(count); ++ return count; ++} ++ ++static struct kobj_attribute dev_dump_prs_attr = ++ __ATTR(dump_prs, S_IWUSR, NULL, scst_dev_sysfs_dump_prs); ++ ++#endif /* defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) */ ++ ++static int scst_process_dev_sysfs_threads_data_store( ++ struct scst_device *dev, int threads_num, ++ enum scst_dev_type_threads_pool_type threads_pool_type) ++{ ++ int res = 0; ++ int oldtn = dev->threads_num; ++ enum scst_dev_type_threads_pool_type oldtt = dev->threads_pool_type; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("dev %p, threads_num %d, threads_pool_type %d", dev, ++ threads_num, threads_pool_type); ++ ++ res = scst_suspend_activity(true); ++ if (res != 0) ++ goto out; ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res != 0) ++ goto out_resume; ++ ++ /* Check if our pointer is still alive */ ++ if (scst_check_dev_ptr(dev) != 0) ++ goto out_unlock; ++ ++ scst_stop_dev_threads(dev); ++ ++ dev->threads_num = threads_num; ++ dev->threads_pool_type = threads_pool_type; ++ ++ res = scst_create_dev_threads(dev); ++ if (res != 0) ++ goto out_unlock; ++ ++ if (oldtn != dev->threads_num) ++ PRINT_INFO("Changed cmd threads num to %d", dev->threads_num); ++ else if (oldtt != dev->threads_pool_type) ++ PRINT_INFO("Changed cmd threads pool type to %d", ++ dev->threads_pool_type); ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ ++out_resume: ++ scst_resume_activity(); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_dev_sysfs_threads_data_store_work_fn( ++ struct scst_sysfs_work_item *work) ++{ ++ return scst_process_dev_sysfs_threads_data_store(work->dev, ++ work->new_threads_num, work->new_threads_pool_type); ++} ++ ++static ssize_t scst_dev_sysfs_check_threads_data( ++ struct scst_device *dev, int threads_num, ++ enum scst_dev_type_threads_pool_type threads_pool_type, bool *stop) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ *stop = false; ++ ++ if (dev->threads_num < 0) { ++ PRINT_ERROR("Threads pool disabled for device %s", ++ dev->virt_name); ++ res = -EPERM; ++ goto out; ++ } ++ ++ if ((threads_num == dev->threads_num) && ++ (threads_pool_type == dev->threads_pool_type)) { ++ *stop = true; ++ goto out; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t scst_dev_sysfs_threads_num_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos = 0; ++ struct scst_device *dev; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ ++ pos = sprintf(buf, "%d\n%s", dev->threads_num, ++ (dev->threads_num != dev->handler->threads_num) ? ++ SCST_SYSFS_KEY_MARK "\n" : ""); ++ ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static ssize_t scst_dev_sysfs_threads_num_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ struct scst_device *dev; ++ long newtn; ++ bool stop; ++ struct scst_sysfs_work_item *work; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ ++ res = strict_strtol(buf, 0, &newtn); ++ if (res != 0) { ++ PRINT_ERROR("strict_strtol() for %s failed: %d ", buf, res); ++ goto out; ++ } ++ if (newtn < 0) { ++ PRINT_ERROR("Illegal threads num value %ld", newtn); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ res = scst_dev_sysfs_check_threads_data(dev, newtn, ++ dev->threads_pool_type, &stop); ++ if ((res != 0) || stop) ++ goto out; ++ ++ res = scst_alloc_sysfs_work(scst_dev_sysfs_threads_data_store_work_fn, ++ false, &work); ++ if (res != 0) ++ goto out; ++ ++ work->dev = dev; ++ work->new_threads_num = newtn; ++ work->new_threads_pool_type = dev->threads_pool_type; ++ ++ res = scst_sysfs_queue_wait_work(work); ++ ++out: ++ if (res == 0) ++ res = count; ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute dev_threads_num_attr = ++ __ATTR(threads_num, S_IRUGO | S_IWUSR, ++ scst_dev_sysfs_threads_num_show, ++ scst_dev_sysfs_threads_num_store); ++ ++static ssize_t scst_dev_sysfs_threads_pool_type_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos = 0; ++ struct scst_device *dev; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ ++ if (dev->threads_num == 0) { ++ pos = sprintf(buf, "Async\n"); ++ goto out; ++ } else if (dev->threads_num < 0) { ++ pos = sprintf(buf, "Not valid\n"); ++ goto out; ++ } ++ ++ switch (dev->threads_pool_type) { ++ case SCST_THREADS_POOL_PER_INITIATOR: ++ pos = sprintf(buf, "%s\n%s", SCST_THREADS_POOL_PER_INITIATOR_STR, ++ (dev->threads_pool_type != dev->handler->threads_pool_type) ? ++ SCST_SYSFS_KEY_MARK "\n" : ""); ++ break; ++ case SCST_THREADS_POOL_SHARED: ++ pos = sprintf(buf, "%s\n%s", SCST_THREADS_POOL_SHARED_STR, ++ (dev->threads_pool_type != dev->handler->threads_pool_type) ? ++ SCST_SYSFS_KEY_MARK "\n" : ""); ++ break; ++ default: ++ pos = sprintf(buf, "Unknown\n"); ++ break; ++ } ++ ++out: ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static ssize_t scst_dev_sysfs_threads_pool_type_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ struct scst_device *dev; ++ enum scst_dev_type_threads_pool_type newtpt; ++ struct scst_sysfs_work_item *work; ++ bool stop; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ ++ newtpt = scst_parse_threads_pool_type(buf, count); ++ if (newtpt == SCST_THREADS_POOL_TYPE_INVALID) { ++ PRINT_ERROR("Illegal threads pool type %s", buf); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ TRACE_DBG("buf %s, count %zd, newtpt %d", buf, count, newtpt); ++ ++ res = scst_dev_sysfs_check_threads_data(dev, dev->threads_num, ++ newtpt, &stop); ++ if ((res != 0) || stop) ++ goto out; ++ ++ res = scst_alloc_sysfs_work(scst_dev_sysfs_threads_data_store_work_fn, ++ false, &work); ++ if (res != 0) ++ goto out; ++ ++ work->dev = dev; ++ work->new_threads_num = dev->threads_num; ++ work->new_threads_pool_type = newtpt; ++ ++ res = scst_sysfs_queue_wait_work(work); ++ ++out: ++ if (res == 0) ++ res = count; ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute dev_threads_pool_type_attr = ++ __ATTR(threads_pool_type, S_IRUGO | S_IWUSR, ++ scst_dev_sysfs_threads_pool_type_show, ++ scst_dev_sysfs_threads_pool_type_store); ++ ++static struct attribute *scst_dev_attrs[] = { ++ &dev_type_attr.attr, ++ NULL, ++}; ++ ++static void scst_sysfs_dev_release(struct kobject *kobj) ++{ ++ struct scst_device *dev; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ if (dev->dev_kobj_release_cmpl) ++ complete_all(dev->dev_kobj_release_cmpl); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++int scst_devt_dev_sysfs_create(struct scst_device *dev) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ if (dev->handler == &scst_null_devtype) ++ goto out; ++ ++ res = sysfs_create_link(&dev->dev_kobj, ++ &dev->handler->devt_kobj, "handler"); ++ if (res != 0) { ++ PRINT_ERROR("Can't create handler link for dev %s", ++ dev->virt_name); ++ goto out; ++ } ++ ++ res = sysfs_create_link(&dev->handler->devt_kobj, ++ &dev->dev_kobj, dev->virt_name); ++ if (res != 0) { ++ PRINT_ERROR("Can't create handler link for dev %s", ++ dev->virt_name); ++ goto out_err; ++ } ++ ++ if (dev->handler->threads_num >= 0) { ++ res = sysfs_create_file(&dev->dev_kobj, ++ &dev_threads_num_attr.attr); ++ if (res != 0) { ++ PRINT_ERROR("Can't add dev attr %s for dev %s", ++ dev_threads_num_attr.attr.name, ++ dev->virt_name); ++ goto out_err; ++ } ++ res = sysfs_create_file(&dev->dev_kobj, ++ &dev_threads_pool_type_attr.attr); ++ if (res != 0) { ++ PRINT_ERROR("Can't add dev attr %s for dev %s", ++ dev_threads_pool_type_attr.attr.name, ++ dev->virt_name); ++ goto out_err; ++ } ++ } ++ ++ if (dev->handler->dev_attrs) { ++ res = sysfs_create_files(&dev->dev_kobj, ++ dev->handler->dev_attrs); ++ if (res != 0) { ++ PRINT_ERROR("Can't add dev attributes for dev %s", ++ dev->virt_name); ++ goto out_err; ++ } ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_err: ++ scst_devt_dev_sysfs_del(dev); ++ goto out; ++} ++ ++void scst_devt_dev_sysfs_del(struct scst_device *dev) ++{ ++ TRACE_ENTRY(); ++ ++ if (dev->handler == &scst_null_devtype) ++ goto out; ++ ++ if (dev->handler->dev_attrs) ++ sysfs_remove_files(&dev->dev_kobj, dev->handler->dev_attrs); ++ ++ sysfs_remove_link(&dev->dev_kobj, "handler"); ++ sysfs_remove_link(&dev->handler->devt_kobj, dev->virt_name); ++ ++ if (dev->handler->threads_num >= 0) { ++ sysfs_remove_file(&dev->dev_kobj, ++ &dev_threads_num_attr.attr); ++ sysfs_remove_file(&dev->dev_kobj, ++ &dev_threads_pool_type_attr.attr); ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static struct kobj_type scst_dev_ktype = { ++ .sysfs_ops = &scst_sysfs_ops, ++ .release = scst_sysfs_dev_release, ++ .default_attrs = scst_dev_attrs, ++}; ++ ++/* ++ * Must not be called under scst_mutex, because it can call ++ * scst_dev_sysfs_del() ++ */ ++int scst_dev_sysfs_create(struct scst_device *dev) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ res = kobject_init_and_add(&dev->dev_kobj, &scst_dev_ktype, ++ scst_devices_kobj, dev->virt_name); ++ if (res != 0) { ++ PRINT_ERROR("Can't add device %s to sysfs", dev->virt_name); ++ goto out; ++ } ++ ++ dev->dev_exp_kobj = kobject_create_and_add("exported", ++ &dev->dev_kobj); ++ if (dev->dev_exp_kobj == NULL) { ++ PRINT_ERROR("Can't create exported link for device %s", ++ dev->virt_name); ++ res = -ENOMEM; ++ goto out_del; ++ } ++ ++ if (dev->scsi_dev != NULL) { ++ res = sysfs_create_link(&dev->dev_kobj, ++ &dev->scsi_dev->sdev_dev.kobj, "scsi_device"); ++ if (res != 0) { ++ PRINT_ERROR("Can't create scsi_device link for dev %s", ++ dev->virt_name); ++ goto out_del; ++ } ++ } ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ if (dev->scsi_dev == NULL) { ++ res = sysfs_create_file(&dev->dev_kobj, ++ &dev_dump_prs_attr.attr); ++ if (res != 0) { ++ PRINT_ERROR("Can't create attr %s for dev %s", ++ dev_dump_prs_attr.attr.name, dev->virt_name); ++ goto out_del; ++ } ++ } ++#endif ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_del: ++ scst_dev_sysfs_del(dev); ++ goto out; ++} ++ ++/* ++ * Must not be called under scst_mutex, due to possible deadlock with ++ * sysfs ref counting in sysfs works (it is waiting for the last put, but ++ * the last ref counter holder is waiting for scst_mutex) ++ */ ++void scst_dev_sysfs_del(struct scst_device *dev) ++{ ++ int rc; ++ DECLARE_COMPLETION_ONSTACK(c); ++ ++ TRACE_ENTRY(); ++ ++ dev->dev_kobj_release_cmpl = &c; ++ ++ kobject_del(dev->dev_exp_kobj); ++ kobject_del(&dev->dev_kobj); ++ ++ kobject_put(dev->dev_exp_kobj); ++ kobject_put(&dev->dev_kobj); ++ ++ rc = wait_for_completion_timeout(dev->dev_kobj_release_cmpl, HZ); ++ if (rc == 0) { ++ PRINT_INFO("Waiting for releasing sysfs entry " ++ "for device %s (%d refs)...", dev->virt_name, ++ atomic_read(&dev->dev_kobj.kref.refcount)); ++ wait_for_completion(dev->dev_kobj_release_cmpl); ++ PRINT_INFO("Done waiting for releasing sysfs " ++ "entry for device %s", dev->virt_name); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ ** Tgt_dev implementation ++ **/ ++ ++#ifdef CONFIG_SCST_MEASURE_LATENCY ++ ++static char *scst_io_size_names[] = { ++ "<=8K ", ++ "<=32K ", ++ "<=128K", ++ "<=512K", ++ ">512K " ++}; ++ ++static ssize_t scst_tgt_dev_latency_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buffer) ++{ ++ int res = 0, i; ++ char buf[50]; ++ struct scst_tgt_dev *tgt_dev; ++ ++ TRACE_ENTRY(); ++ ++ tgt_dev = container_of(kobj, struct scst_tgt_dev, tgt_dev_kobj); ++ ++ for (i = 0; i < SCST_LATENCY_STATS_NUM; i++) { ++ uint64_t scst_time_wr, tgt_time_wr, dev_time_wr; ++ unsigned int processed_cmds_wr; ++ uint64_t scst_time_rd, tgt_time_rd, dev_time_rd; ++ unsigned int processed_cmds_rd; ++ struct scst_ext_latency_stat *latency_stat; ++ ++ latency_stat = &tgt_dev->dev_latency_stat[i]; ++ scst_time_wr = latency_stat->scst_time_wr; ++ scst_time_rd = latency_stat->scst_time_rd; ++ tgt_time_wr = latency_stat->tgt_time_wr; ++ tgt_time_rd = latency_stat->tgt_time_rd; ++ dev_time_wr = latency_stat->dev_time_wr; ++ dev_time_rd = latency_stat->dev_time_rd; ++ processed_cmds_wr = latency_stat->processed_cmds_wr; ++ processed_cmds_rd = latency_stat->processed_cmds_rd; ++ ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-5s %-9s %-15lu ", "Write", scst_io_size_names[i], ++ (unsigned long)processed_cmds_wr); ++ if (processed_cmds_wr == 0) ++ processed_cmds_wr = 1; ++ ++ do_div(scst_time_wr, processed_cmds_wr); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_scst_time_wr, ++ (unsigned long)scst_time_wr, ++ (unsigned long)latency_stat->max_scst_time_wr, ++ (unsigned long)latency_stat->scst_time_wr); ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-47s", buf); ++ ++ do_div(tgt_time_wr, processed_cmds_wr); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_tgt_time_wr, ++ (unsigned long)tgt_time_wr, ++ (unsigned long)latency_stat->max_tgt_time_wr, ++ (unsigned long)latency_stat->tgt_time_wr); ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-47s", buf); ++ ++ do_div(dev_time_wr, processed_cmds_wr); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_dev_time_wr, ++ (unsigned long)dev_time_wr, ++ (unsigned long)latency_stat->max_dev_time_wr, ++ (unsigned long)latency_stat->dev_time_wr); ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-47s\n", buf); ++ ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-5s %-9s %-15lu ", "Read", scst_io_size_names[i], ++ (unsigned long)processed_cmds_rd); ++ if (processed_cmds_rd == 0) ++ processed_cmds_rd = 1; ++ ++ do_div(scst_time_rd, processed_cmds_rd); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_scst_time_rd, ++ (unsigned long)scst_time_rd, ++ (unsigned long)latency_stat->max_scst_time_rd, ++ (unsigned long)latency_stat->scst_time_rd); ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-47s", buf); ++ ++ do_div(tgt_time_rd, processed_cmds_rd); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_tgt_time_rd, ++ (unsigned long)tgt_time_rd, ++ (unsigned long)latency_stat->max_tgt_time_rd, ++ (unsigned long)latency_stat->tgt_time_rd); ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-47s", buf); ++ ++ do_div(dev_time_rd, processed_cmds_rd); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_dev_time_rd, ++ (unsigned long)dev_time_rd, ++ (unsigned long)latency_stat->max_dev_time_rd, ++ (unsigned long)latency_stat->dev_time_rd); ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-47s\n", buf); ++ } ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute tgt_dev_latency_attr = ++ __ATTR(latency, S_IRUGO, ++ scst_tgt_dev_latency_show, NULL); ++ ++#endif /* CONFIG_SCST_MEASURE_LATENCY */ ++ ++static ssize_t scst_tgt_dev_active_commands_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos = 0; ++ struct scst_tgt_dev *tgt_dev; ++ ++ tgt_dev = container_of(kobj, struct scst_tgt_dev, tgt_dev_kobj); ++ ++ pos = sprintf(buf, "%d\n", atomic_read(&tgt_dev->tgt_dev_cmd_count)); ++ ++ return pos; ++} ++ ++static struct kobj_attribute tgt_dev_active_commands_attr = ++ __ATTR(active_commands, S_IRUGO, ++ scst_tgt_dev_active_commands_show, NULL); ++ ++static struct attribute *scst_tgt_dev_attrs[] = { ++ &tgt_dev_active_commands_attr.attr, ++#ifdef CONFIG_SCST_MEASURE_LATENCY ++ &tgt_dev_latency_attr.attr, ++#endif ++ NULL, ++}; ++ ++static void scst_sysfs_tgt_dev_release(struct kobject *kobj) ++{ ++ struct scst_tgt_dev *tgt_dev; ++ ++ TRACE_ENTRY(); ++ ++ tgt_dev = container_of(kobj, struct scst_tgt_dev, tgt_dev_kobj); ++ if (tgt_dev->tgt_dev_kobj_release_cmpl) ++ complete_all(tgt_dev->tgt_dev_kobj_release_cmpl); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static struct kobj_type scst_tgt_dev_ktype = { ++ .sysfs_ops = &scst_sysfs_ops, ++ .release = scst_sysfs_tgt_dev_release, ++ .default_attrs = scst_tgt_dev_attrs, ++}; ++ ++int scst_tgt_dev_sysfs_create(struct scst_tgt_dev *tgt_dev) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ res = kobject_init_and_add(&tgt_dev->tgt_dev_kobj, &scst_tgt_dev_ktype, ++ &tgt_dev->sess->sess_kobj, "lun%lld", ++ (unsigned long long)tgt_dev->lun); ++ if (res != 0) { ++ PRINT_ERROR("Can't add tgt_dev %lld to sysfs", ++ (unsigned long long)tgt_dev->lun); ++ goto out; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* ++ * Called with scst_mutex held. ++ * ++ * !! No sysfs works must use kobject_get() to protect tgt_dev, due to possible ++ * !! deadlock with scst_mutex (it is waiting for the last put, but ++ * !! the last ref counter holder is waiting for scst_mutex) ++ */ ++void scst_tgt_dev_sysfs_del(struct scst_tgt_dev *tgt_dev) ++{ ++ int rc; ++ DECLARE_COMPLETION_ONSTACK(c); ++ ++ TRACE_ENTRY(); ++ ++ tgt_dev->tgt_dev_kobj_release_cmpl = &c; ++ ++ kobject_del(&tgt_dev->tgt_dev_kobj); ++ kobject_put(&tgt_dev->tgt_dev_kobj); ++ ++ rc = wait_for_completion_timeout( ++ tgt_dev->tgt_dev_kobj_release_cmpl, HZ); ++ if (rc == 0) { ++ PRINT_INFO("Waiting for releasing sysfs entry " ++ "for tgt_dev %lld (%d refs)...", ++ (unsigned long long)tgt_dev->lun, ++ atomic_read(&tgt_dev->tgt_dev_kobj.kref.refcount)); ++ wait_for_completion(tgt_dev->tgt_dev_kobj_release_cmpl); ++ PRINT_INFO("Done waiting for releasing sysfs entry for " ++ "tgt_dev %lld", (unsigned long long)tgt_dev->lun); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ ** Sessions subdirectory implementation ++ **/ ++ ++#ifdef CONFIG_SCST_MEASURE_LATENCY ++ ++static ssize_t scst_sess_latency_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buffer) ++{ ++ ssize_t res = 0; ++ struct scst_session *sess; ++ int i; ++ char buf[50]; ++ uint64_t scst_time, tgt_time, dev_time; ++ unsigned int processed_cmds; ++ ++ TRACE_ENTRY(); ++ ++ sess = container_of(kobj, struct scst_session, sess_kobj); ++ ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-15s %-15s %-46s %-46s %-46s\n", ++ "T-L names", "Total commands", "SCST latency", ++ "Target latency", "Dev latency (min/avg/max/all ns)"); ++ ++ spin_lock_bh(&sess->lat_lock); ++ ++ for (i = 0; i < SCST_LATENCY_STATS_NUM ; i++) { ++ uint64_t scst_time_wr, tgt_time_wr, dev_time_wr; ++ unsigned int processed_cmds_wr; ++ uint64_t scst_time_rd, tgt_time_rd, dev_time_rd; ++ unsigned int processed_cmds_rd; ++ struct scst_ext_latency_stat *latency_stat; ++ ++ latency_stat = &sess->sess_latency_stat[i]; ++ scst_time_wr = latency_stat->scst_time_wr; ++ scst_time_rd = latency_stat->scst_time_rd; ++ tgt_time_wr = latency_stat->tgt_time_wr; ++ tgt_time_rd = latency_stat->tgt_time_rd; ++ dev_time_wr = latency_stat->dev_time_wr; ++ dev_time_rd = latency_stat->dev_time_rd; ++ processed_cmds_wr = latency_stat->processed_cmds_wr; ++ processed_cmds_rd = latency_stat->processed_cmds_rd; ++ ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-5s %-9s %-15lu ", ++ "Write", scst_io_size_names[i], ++ (unsigned long)processed_cmds_wr); ++ if (processed_cmds_wr == 0) ++ processed_cmds_wr = 1; ++ ++ do_div(scst_time_wr, processed_cmds_wr); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_scst_time_wr, ++ (unsigned long)scst_time_wr, ++ (unsigned long)latency_stat->max_scst_time_wr, ++ (unsigned long)latency_stat->scst_time_wr); ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-47s", buf); ++ ++ do_div(tgt_time_wr, processed_cmds_wr); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_tgt_time_wr, ++ (unsigned long)tgt_time_wr, ++ (unsigned long)latency_stat->max_tgt_time_wr, ++ (unsigned long)latency_stat->tgt_time_wr); ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-47s", buf); ++ ++ do_div(dev_time_wr, processed_cmds_wr); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_dev_time_wr, ++ (unsigned long)dev_time_wr, ++ (unsigned long)latency_stat->max_dev_time_wr, ++ (unsigned long)latency_stat->dev_time_wr); ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-47s\n", buf); ++ ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-5s %-9s %-15lu ", ++ "Read", scst_io_size_names[i], ++ (unsigned long)processed_cmds_rd); ++ if (processed_cmds_rd == 0) ++ processed_cmds_rd = 1; ++ ++ do_div(scst_time_rd, processed_cmds_rd); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_scst_time_rd, ++ (unsigned long)scst_time_rd, ++ (unsigned long)latency_stat->max_scst_time_rd, ++ (unsigned long)latency_stat->scst_time_rd); ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-47s", buf); ++ ++ do_div(tgt_time_rd, processed_cmds_rd); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_tgt_time_rd, ++ (unsigned long)tgt_time_rd, ++ (unsigned long)latency_stat->max_tgt_time_rd, ++ (unsigned long)latency_stat->tgt_time_rd); ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-47s", buf); ++ ++ do_div(dev_time_rd, processed_cmds_rd); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_dev_time_rd, ++ (unsigned long)dev_time_rd, ++ (unsigned long)latency_stat->max_dev_time_rd, ++ (unsigned long)latency_stat->dev_time_rd); ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-47s\n", buf); ++ } ++ ++ scst_time = sess->scst_time; ++ tgt_time = sess->tgt_time; ++ dev_time = sess->dev_time; ++ processed_cmds = sess->processed_cmds; ++ ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "\n%-15s %-16d", "Overall ", processed_cmds); ++ ++ if (processed_cmds == 0) ++ processed_cmds = 1; ++ ++ do_div(scst_time, processed_cmds); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)sess->min_scst_time, ++ (unsigned long)scst_time, ++ (unsigned long)sess->max_scst_time, ++ (unsigned long)sess->scst_time); ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-47s", buf); ++ ++ do_div(tgt_time, processed_cmds); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)sess->min_tgt_time, ++ (unsigned long)tgt_time, ++ (unsigned long)sess->max_tgt_time, ++ (unsigned long)sess->tgt_time); ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-47s", buf); ++ ++ do_div(dev_time, processed_cmds); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)sess->min_dev_time, ++ (unsigned long)dev_time, ++ (unsigned long)sess->max_dev_time, ++ (unsigned long)sess->dev_time); ++ res += scnprintf(&buffer[res], SCST_SYSFS_BLOCK_SIZE - res, ++ "%-47s\n\n", buf); ++ ++ spin_unlock_bh(&sess->lat_lock); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_sess_zero_latency(struct scst_sysfs_work_item *work) ++{ ++ int res = 0, t; ++ struct scst_session *sess = work->sess; ++ ++ TRACE_ENTRY(); ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res != 0) ++ goto out_put; ++ ++ PRINT_INFO("Zeroing latency statistics for initiator " ++ "%s", sess->initiator_name); ++ ++ spin_lock_bh(&sess->lat_lock); ++ ++ sess->scst_time = 0; ++ sess->tgt_time = 0; ++ sess->dev_time = 0; ++ sess->min_scst_time = 0; ++ sess->min_tgt_time = 0; ++ sess->min_dev_time = 0; ++ sess->max_scst_time = 0; ++ sess->max_tgt_time = 0; ++ sess->max_dev_time = 0; ++ sess->processed_cmds = 0; ++ memset(sess->sess_latency_stat, 0, ++ sizeof(sess->sess_latency_stat)); ++ ++ for (t = SESS_TGT_DEV_LIST_HASH_SIZE-1; t >= 0; t--) { ++ struct list_head *head = &sess->sess_tgt_dev_list[t]; ++ struct scst_tgt_dev *tgt_dev; ++ list_for_each_entry(tgt_dev, head, sess_tgt_dev_list_entry) { ++ tgt_dev->scst_time = 0; ++ tgt_dev->tgt_time = 0; ++ tgt_dev->dev_time = 0; ++ tgt_dev->processed_cmds = 0; ++ memset(tgt_dev->dev_latency_stat, 0, ++ sizeof(tgt_dev->dev_latency_stat)); ++ } ++ } ++ ++ spin_unlock_bh(&sess->lat_lock); ++ ++ mutex_unlock(&scst_mutex); ++ ++out_put: ++ kobject_put(&sess->sess_kobj); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t scst_sess_latency_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ struct scst_session *sess; ++ struct scst_sysfs_work_item *work; ++ ++ TRACE_ENTRY(); ++ ++ sess = container_of(kobj, struct scst_session, sess_kobj); ++ ++ res = scst_alloc_sysfs_work(scst_sess_zero_latency, false, &work); ++ if (res != 0) ++ goto out; ++ ++ work->sess = sess; ++ ++ kobject_get(&sess->sess_kobj); ++ ++ res = scst_sysfs_queue_wait_work(work); ++ if (res == 0) ++ res = count; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute session_latency_attr = ++ __ATTR(latency, S_IRUGO | S_IWUSR, scst_sess_latency_show, ++ scst_sess_latency_store); ++ ++#endif /* CONFIG_SCST_MEASURE_LATENCY */ ++ ++static ssize_t scst_sess_sysfs_commands_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_session *sess; ++ ++ sess = container_of(kobj, struct scst_session, sess_kobj); ++ ++ return sprintf(buf, "%i\n", atomic_read(&sess->sess_cmd_count)); ++} ++ ++static struct kobj_attribute session_commands_attr = ++ __ATTR(commands, S_IRUGO, scst_sess_sysfs_commands_show, NULL); ++ ++static int scst_sysfs_sess_get_active_commands(struct scst_session *sess) ++{ ++ int res; ++ int active_cmds = 0, t; ++ ++ TRACE_ENTRY(); ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res != 0) ++ goto out_put; ++ ++ for (t = SESS_TGT_DEV_LIST_HASH_SIZE-1; t >= 0; t--) { ++ struct list_head *head = &sess->sess_tgt_dev_list[t]; ++ struct scst_tgt_dev *tgt_dev; ++ list_for_each_entry(tgt_dev, head, sess_tgt_dev_list_entry) { ++ active_cmds += atomic_read(&tgt_dev->tgt_dev_cmd_count); ++ } ++ } ++ ++ mutex_unlock(&scst_mutex); ++ ++ res = active_cmds; ++ ++out_put: ++ kobject_put(&sess->sess_kobj); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_sysfs_sess_get_active_commands_work_fn(struct scst_sysfs_work_item *work) ++{ ++ return scst_sysfs_sess_get_active_commands(work->sess); ++} ++ ++static ssize_t scst_sess_sysfs_active_commands_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int res; ++ struct scst_session *sess; ++ struct scst_sysfs_work_item *work; ++ ++ sess = container_of(kobj, struct scst_session, sess_kobj); ++ ++ res = scst_alloc_sysfs_work(scst_sysfs_sess_get_active_commands_work_fn, ++ true, &work); ++ if (res != 0) ++ goto out; ++ ++ work->sess = sess; ++ ++ kobject_get(&sess->sess_kobj); ++ ++ res = scst_sysfs_queue_wait_work(work); ++ if (res != -EAGAIN) ++ res = sprintf(buf, "%i\n", res); ++ ++out: ++ return res; ++} ++ ++static struct kobj_attribute session_active_commands_attr = ++ __ATTR(active_commands, S_IRUGO, scst_sess_sysfs_active_commands_show, ++ NULL); ++ ++static ssize_t scst_sess_sysfs_initiator_name_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_session *sess; ++ ++ sess = container_of(kobj, struct scst_session, sess_kobj); ++ ++ return scnprintf(buf, SCST_SYSFS_BLOCK_SIZE, "%s\n", ++ sess->initiator_name); ++} ++ ++static struct kobj_attribute session_initiator_name_attr = ++ __ATTR(initiator_name, S_IRUGO, scst_sess_sysfs_initiator_name_show, ++ NULL); ++ ++#define SCST_SESS_SYSFS_STAT_ATTR(name, exported_name, dir, kb) \ ++static ssize_t scst_sess_sysfs_##exported_name##_show(struct kobject *kobj, \ ++ struct kobj_attribute *attr, char *buf) \ ++{ \ ++ struct scst_session *sess; \ ++ int res; \ ++ uint64_t v; \ ++ \ ++ BUILD_BUG_ON(SCST_DATA_UNKNOWN != 0); \ ++ BUILD_BUG_ON(SCST_DATA_WRITE != 1); \ ++ BUILD_BUG_ON(SCST_DATA_READ != 2); \ ++ BUILD_BUG_ON(SCST_DATA_BIDI != 3); \ ++ BUILD_BUG_ON(SCST_DATA_NONE != 4); \ ++ \ ++ BUILD_BUG_ON(dir >= SCST_DATA_DIR_MAX); \ ++ \ ++ sess = container_of(kobj, struct scst_session, sess_kobj); \ ++ v = sess->io_stats[dir].name; \ ++ if (kb) \ ++ v >>= 10; \ ++ res = sprintf(buf, "%llu\n", (unsigned long long)v); \ ++ return res; \ ++} \ ++ \ ++static ssize_t scst_sess_sysfs_##exported_name##_store(struct kobject *kobj, \ ++ struct kobj_attribute *attr, const char *buf, size_t count) \ ++{ \ ++ struct scst_session *sess; \ ++ sess = container_of(kobj, struct scst_session, sess_kobj); \ ++ spin_lock_irq(&sess->sess_list_lock); \ ++ BUILD_BUG_ON(dir >= SCST_DATA_DIR_MAX); \ ++ sess->io_stats[dir].cmd_count = 0; \ ++ sess->io_stats[dir].io_byte_count = 0; \ ++ spin_unlock_irq(&sess->sess_list_lock); \ ++ return count; \ ++} \ ++ \ ++static struct kobj_attribute session_##exported_name##_attr = \ ++ __ATTR(exported_name, S_IRUGO | S_IWUSR, \ ++ scst_sess_sysfs_##exported_name##_show, \ ++ scst_sess_sysfs_##exported_name##_store); ++ ++SCST_SESS_SYSFS_STAT_ATTR(cmd_count, unknown_cmd_count, SCST_DATA_UNKNOWN, 0); ++SCST_SESS_SYSFS_STAT_ATTR(cmd_count, write_cmd_count, SCST_DATA_WRITE, 0); ++SCST_SESS_SYSFS_STAT_ATTR(io_byte_count, write_io_count_kb, SCST_DATA_WRITE, 1); ++SCST_SESS_SYSFS_STAT_ATTR(cmd_count, read_cmd_count, SCST_DATA_READ, 0); ++SCST_SESS_SYSFS_STAT_ATTR(io_byte_count, read_io_count_kb, SCST_DATA_READ, 1); ++SCST_SESS_SYSFS_STAT_ATTR(cmd_count, bidi_cmd_count, SCST_DATA_BIDI, 0); ++SCST_SESS_SYSFS_STAT_ATTR(io_byte_count, bidi_io_count_kb, SCST_DATA_BIDI, 1); ++SCST_SESS_SYSFS_STAT_ATTR(cmd_count, none_cmd_count, SCST_DATA_NONE, 0); ++ ++static struct attribute *scst_session_attrs[] = { ++ &session_commands_attr.attr, ++ &session_active_commands_attr.attr, ++ &session_initiator_name_attr.attr, ++ &session_unknown_cmd_count_attr.attr, ++ &session_write_cmd_count_attr.attr, ++ &session_write_io_count_kb_attr.attr, ++ &session_read_cmd_count_attr.attr, ++ &session_read_io_count_kb_attr.attr, ++ &session_bidi_cmd_count_attr.attr, ++ &session_bidi_io_count_kb_attr.attr, ++ &session_none_cmd_count_attr.attr, ++#ifdef CONFIG_SCST_MEASURE_LATENCY ++ &session_latency_attr.attr, ++#endif /* CONFIG_SCST_MEASURE_LATENCY */ ++ NULL, ++}; ++ ++static void scst_sysfs_session_release(struct kobject *kobj) ++{ ++ struct scst_session *sess; ++ ++ TRACE_ENTRY(); ++ ++ sess = container_of(kobj, struct scst_session, sess_kobj); ++ if (sess->sess_kobj_release_cmpl) ++ complete_all(sess->sess_kobj_release_cmpl); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static struct kobj_type scst_session_ktype = { ++ .sysfs_ops = &scst_sysfs_ops, ++ .release = scst_sysfs_session_release, ++ .default_attrs = scst_session_attrs, ++}; ++ ++static int scst_create_sess_luns_link(struct scst_session *sess) ++{ ++ int res; ++ ++ /* ++ * No locks are needed, because sess supposed to be in acg->acg_sess_list ++ * and tgt->sess_list, so blocking them from disappearing. ++ */ ++ ++ if (sess->acg == sess->tgt->default_acg) ++ res = sysfs_create_link(&sess->sess_kobj, ++ sess->tgt->tgt_luns_kobj, "luns"); ++ else ++ res = sysfs_create_link(&sess->sess_kobj, ++ sess->acg->luns_kobj, "luns"); ++ ++ if (res != 0) ++ PRINT_ERROR("Can't create luns link for initiator %s", ++ sess->initiator_name); ++ ++ return res; ++} ++ ++int scst_recreate_sess_luns_link(struct scst_session *sess) ++{ ++ sysfs_remove_link(&sess->sess_kobj, "luns"); ++ return scst_create_sess_luns_link(sess); ++} ++ ++/* Supposed to be called under scst_mutex */ ++int scst_sess_sysfs_create(struct scst_session *sess) ++{ ++ int res = 0; ++ struct scst_session *s; ++ char *name = (char *)sess->initiator_name; ++ int len = strlen(name) + 1, n = 1; ++ ++ TRACE_ENTRY(); ++ ++restart: ++ list_for_each_entry(s, &sess->tgt->sess_list, sess_list_entry) { ++ if (!s->sess_kobj_ready) ++ continue; ++ ++ if (strcmp(name, kobject_name(&s->sess_kobj)) == 0) { ++ if (s == sess) ++ continue; ++ ++ TRACE_DBG("Duplicated session from the same initiator " ++ "%s found", name); ++ ++ if (name == sess->initiator_name) { ++ len = strlen(sess->initiator_name); ++ len += 20; ++ name = kmalloc(len, GFP_KERNEL); ++ if (name == NULL) { ++ PRINT_ERROR("Unable to allocate a " ++ "replacement name (size %d)", ++ len); ++ } ++ } ++ ++ snprintf(name, len, "%s_%d", sess->initiator_name, n); ++ n++; ++ goto restart; ++ } ++ } ++ ++ TRACE_DBG("Adding session %s to sysfs", name); ++ ++ res = kobject_init_and_add(&sess->sess_kobj, &scst_session_ktype, ++ sess->tgt->tgt_sess_kobj, name); ++ if (res != 0) { ++ PRINT_ERROR("Can't add session %s to sysfs", name); ++ goto out_free; ++ } ++ ++ sess->sess_kobj_ready = 1; ++ ++ if (sess->tgt->tgtt->sess_attrs) { ++ res = sysfs_create_files(&sess->sess_kobj, ++ sess->tgt->tgtt->sess_attrs); ++ if (res != 0) { ++ PRINT_ERROR("Can't add attributes for session %s", name); ++ goto out_free; ++ } ++ } ++ ++ res = scst_create_sess_luns_link(sess); ++ ++out_free: ++ if (name != sess->initiator_name) ++ kfree(name); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* ++ * Must not be called under scst_mutex, due to possible deadlock with ++ * sysfs ref counting in sysfs works (it is waiting for the last put, but ++ * the last ref counter holder is waiting for scst_mutex) ++ */ ++void scst_sess_sysfs_del(struct scst_session *sess) ++{ ++ int rc; ++ DECLARE_COMPLETION_ONSTACK(c); ++ ++ TRACE_ENTRY(); ++ ++ if (!sess->sess_kobj_ready) ++ goto out; ++ ++ TRACE_DBG("Deleting session %s from sysfs", ++ kobject_name(&sess->sess_kobj)); ++ ++ sess->sess_kobj_release_cmpl = &c; ++ ++ kobject_del(&sess->sess_kobj); ++ kobject_put(&sess->sess_kobj); ++ ++ rc = wait_for_completion_timeout(sess->sess_kobj_release_cmpl, HZ); ++ if (rc == 0) { ++ PRINT_INFO("Waiting for releasing sysfs entry " ++ "for session from %s (%d refs)...", sess->initiator_name, ++ atomic_read(&sess->sess_kobj.kref.refcount)); ++ wait_for_completion(sess->sess_kobj_release_cmpl); ++ PRINT_INFO("Done waiting for releasing sysfs " ++ "entry for session %s", sess->initiator_name); ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ ** Target luns directory implementation ++ **/ ++ ++static void scst_acg_dev_release(struct kobject *kobj) ++{ ++ struct scst_acg_dev *acg_dev; ++ ++ TRACE_ENTRY(); ++ ++ acg_dev = container_of(kobj, struct scst_acg_dev, acg_dev_kobj); ++ if (acg_dev->acg_dev_kobj_release_cmpl) ++ complete_all(acg_dev->acg_dev_kobj_release_cmpl); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static ssize_t scst_lun_rd_only_show(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ char *buf) ++{ ++ struct scst_acg_dev *acg_dev; ++ ++ acg_dev = container_of(kobj, struct scst_acg_dev, acg_dev_kobj); ++ ++ if (acg_dev->rd_only || acg_dev->dev->rd_only) ++ return sprintf(buf, "%d\n%s\n", 1, SCST_SYSFS_KEY_MARK); ++ else ++ return sprintf(buf, "%d\n", 0); ++} ++ ++static struct kobj_attribute lun_options_attr = ++ __ATTR(read_only, S_IRUGO, scst_lun_rd_only_show, NULL); ++ ++static struct attribute *lun_attrs[] = { ++ &lun_options_attr.attr, ++ NULL, ++}; ++ ++static struct kobj_type acg_dev_ktype = { ++ .sysfs_ops = &scst_sysfs_ops, ++ .release = scst_acg_dev_release, ++ .default_attrs = lun_attrs, ++}; ++ ++/* ++ * Called with scst_mutex held. ++ * ++ * !! No sysfs works must use kobject_get() to protect acg_dev, due to possible ++ * !! deadlock with scst_mutex (it is waiting for the last put, but ++ * !! the last ref counter holder is waiting for scst_mutex) ++ */ ++void scst_acg_dev_sysfs_del(struct scst_acg_dev *acg_dev) ++{ ++ int rc; ++ DECLARE_COMPLETION_ONSTACK(c); ++ ++ TRACE_ENTRY(); ++ ++ acg_dev->acg_dev_kobj_release_cmpl = &c; ++ ++ if (acg_dev->dev != NULL) { ++ sysfs_remove_link(acg_dev->dev->dev_exp_kobj, ++ acg_dev->acg_dev_link_name); ++ kobject_put(&acg_dev->dev->dev_kobj); ++ } ++ ++ kobject_del(&acg_dev->acg_dev_kobj); ++ kobject_put(&acg_dev->acg_dev_kobj); ++ ++ rc = wait_for_completion_timeout(acg_dev->acg_dev_kobj_release_cmpl, HZ); ++ if (rc == 0) { ++ PRINT_INFO("Waiting for releasing sysfs entry " ++ "for acg_dev %p (%d refs)...", acg_dev, ++ atomic_read(&acg_dev->acg_dev_kobj.kref.refcount)); ++ wait_for_completion(acg_dev->acg_dev_kobj_release_cmpl); ++ PRINT_INFO("Done waiting for releasing sysfs " ++ "entry for acg_dev %p", acg_dev); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++int scst_acg_dev_sysfs_create(struct scst_acg_dev *acg_dev, ++ struct kobject *parent) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ res = kobject_init_and_add(&acg_dev->acg_dev_kobj, &acg_dev_ktype, ++ parent, "%llu", acg_dev->lun); ++ if (res != 0) { ++ PRINT_ERROR("Can't add acg_dev %p to sysfs", acg_dev); ++ goto out; ++ } ++ ++ kobject_get(&acg_dev->dev->dev_kobj); ++ ++ snprintf(acg_dev->acg_dev_link_name, sizeof(acg_dev->acg_dev_link_name), ++ "export%u", acg_dev->dev->dev_exported_lun_num++); ++ ++ res = sysfs_create_link(acg_dev->dev->dev_exp_kobj, ++ &acg_dev->acg_dev_kobj, acg_dev->acg_dev_link_name); ++ if (res != 0) { ++ PRINT_ERROR("Can't create acg %s LUN link", ++ acg_dev->acg->acg_name); ++ goto out_del; ++ } ++ ++ res = sysfs_create_link(&acg_dev->acg_dev_kobj, ++ &acg_dev->dev->dev_kobj, "device"); ++ if (res != 0) { ++ PRINT_ERROR("Can't create acg %s device link", ++ acg_dev->acg->acg_name); ++ goto out_del; ++ } ++ ++out: ++ return res; ++ ++out_del: ++ scst_acg_dev_sysfs_del(acg_dev); ++ goto out; ++} ++ ++/** ++ ** ini_groups directory implementation. ++ **/ ++ ++static void scst_acg_release(struct kobject *kobj) ++{ ++ struct scst_acg *acg; ++ ++ TRACE_ENTRY(); ++ ++ acg = container_of(kobj, struct scst_acg, acg_kobj); ++ if (acg->acg_kobj_release_cmpl) ++ complete_all(acg->acg_kobj_release_cmpl); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static struct kobj_type acg_ktype = { ++ .sysfs_ops = &scst_sysfs_ops, ++ .release = scst_acg_release, ++}; ++ ++static ssize_t scst_acg_ini_mgmt_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ static const char help[] = ++ "Usage: echo \"add INITIATOR_NAME\" >mgmt\n" ++ " echo \"del INITIATOR_NAME\" >mgmt\n" ++ " echo \"move INITIATOR_NAME DEST_GROUP_NAME\" >mgmt\n" ++ " echo \"clear\" >mgmt\n"; ++ ++ return sprintf(buf, "%s", help); ++} ++ ++static int scst_process_acg_ini_mgmt_store(char *buffer, ++ struct scst_tgt *tgt, struct scst_acg *acg) ++{ ++ int res, action; ++ char *p, *e = NULL; ++ char *name = NULL, *group = NULL; ++ struct scst_acg *acg_dest = NULL; ++ struct scst_acn *acn = NULL, *acn_tmp; ++ enum { ++ SCST_ACG_ACTION_INI_ADD = 1, ++ SCST_ACG_ACTION_INI_DEL = 2, ++ SCST_ACG_ACTION_INI_CLEAR = 3, ++ SCST_ACG_ACTION_INI_MOVE = 4, ++ }; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("tgt %p, acg %p, buffer %s", tgt, acg, buffer); ++ ++ p = buffer; ++ if (p[strlen(p) - 1] == '\n') ++ p[strlen(p) - 1] = '\0'; ++ ++ if (strncasecmp("add", p, 3) == 0) { ++ p += 3; ++ action = SCST_ACG_ACTION_INI_ADD; ++ } else if (strncasecmp("del", p, 3) == 0) { ++ p += 3; ++ action = SCST_ACG_ACTION_INI_DEL; ++ } else if (strncasecmp("clear", p, 5) == 0) { ++ p += 5; ++ action = SCST_ACG_ACTION_INI_CLEAR; ++ } else if (strncasecmp("move", p, 4) == 0) { ++ p += 4; ++ action = SCST_ACG_ACTION_INI_MOVE; ++ } else { ++ PRINT_ERROR("Unknown action \"%s\"", p); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (action != SCST_ACG_ACTION_INI_CLEAR) ++ if (!isspace(*p)) { ++ PRINT_ERROR("%s", "Syntax error"); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ res = scst_suspend_activity(true); ++ if (res != 0) ++ goto out; ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res != 0) ++ goto out_resume; ++ ++ /* Check if tgt and acg not already freed while we were coming here */ ++ if (scst_check_tgt_acg_ptrs(tgt, acg) != 0) ++ goto out_unlock; ++ ++ if (action != SCST_ACG_ACTION_INI_CLEAR) ++ while (isspace(*p) && *p != '\0') ++ p++; ++ ++ switch (action) { ++ case SCST_ACG_ACTION_INI_ADD: ++ e = p; ++ while (!isspace(*e) && *e != '\0') ++ e++; ++ *e = '\0'; ++ name = p; ++ ++ if (name[0] == '\0') { ++ PRINT_ERROR("%s", "Invalid initiator name"); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++ res = scst_acg_add_acn(acg, name); ++ if (res != 0) ++ goto out_unlock; ++ break; ++ case SCST_ACG_ACTION_INI_DEL: ++ e = p; ++ while (!isspace(*e) && *e != '\0') ++ e++; ++ *e = '\0'; ++ name = p; ++ ++ if (name[0] == '\0') { ++ PRINT_ERROR("%s", "Invalid initiator name"); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++ acn = scst_find_acn(acg, name); ++ if (acn == NULL) { ++ PRINT_ERROR("Unable to find " ++ "initiator '%s' in group '%s'", ++ name, acg->acg_name); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ scst_del_free_acn(acn, true); ++ break; ++ case SCST_ACG_ACTION_INI_CLEAR: ++ list_for_each_entry_safe(acn, acn_tmp, &acg->acn_list, ++ acn_list_entry) { ++ scst_del_free_acn(acn, false); ++ } ++ scst_check_reassign_sessions(); ++ break; ++ case SCST_ACG_ACTION_INI_MOVE: ++ e = p; ++ while (!isspace(*e) && *e != '\0') ++ e++; ++ if (*e == '\0') { ++ PRINT_ERROR("%s", "Too few parameters"); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ *e = '\0'; ++ name = p; ++ ++ if (name[0] == '\0') { ++ PRINT_ERROR("%s", "Invalid initiator name"); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++ e++; ++ p = e; ++ while (!isspace(*e) && *e != '\0') ++ e++; ++ *e = '\0'; ++ group = p; ++ ++ if (group[0] == '\0') { ++ PRINT_ERROR("%s", "Invalid group name"); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++ TRACE_DBG("Move initiator '%s' to group '%s'", ++ name, group); ++ ++ acn = scst_find_acn(acg, name); ++ if (acn == NULL) { ++ PRINT_ERROR("Unable to find " ++ "initiator '%s' in group '%s'", ++ name, acg->acg_name); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ acg_dest = scst_tgt_find_acg(tgt, group); ++ if (acg_dest == NULL) { ++ PRINT_ERROR("Unable to find group '%s' in target '%s'", ++ group, tgt->tgt_name); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ if (scst_find_acn(acg_dest, name) != NULL) { ++ PRINT_ERROR("Initiator '%s' already exists in group '%s'", ++ name, acg_dest->acg_name); ++ res = -EEXIST; ++ goto out_unlock; ++ } ++ scst_del_free_acn(acn, false); ++ ++ res = scst_acg_add_acn(acg_dest, name); ++ if (res != 0) ++ goto out_unlock; ++ break; ++ } ++ ++ res = 0; ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ ++out_resume: ++ scst_resume_activity(); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_acg_ini_mgmt_store_work_fn(struct scst_sysfs_work_item *work) ++{ ++ return scst_process_acg_ini_mgmt_store(work->buf, work->tgt, work->acg); ++} ++ ++static ssize_t scst_acg_ini_mgmt_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ struct scst_acg *acg; ++ ++ acg = container_of(kobj->parent, struct scst_acg, acg_kobj); ++ ++ return __scst_acg_mgmt_store(acg, buf, count, false, ++ scst_acg_ini_mgmt_store_work_fn); ++} ++ ++static struct kobj_attribute scst_acg_ini_mgmt = ++ __ATTR(mgmt, S_IRUGO | S_IWUSR, scst_acg_ini_mgmt_show, ++ scst_acg_ini_mgmt_store); ++ ++static ssize_t scst_acg_luns_mgmt_store(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ const char *buf, size_t count) ++{ ++ int res; ++ struct scst_acg *acg; ++ ++ acg = container_of(kobj->parent, struct scst_acg, acg_kobj); ++ res = __scst_luns_mgmt_store(acg, false, buf, count); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_acg_luns_mgmt = ++ __ATTR(mgmt, S_IRUGO | S_IWUSR, scst_luns_mgmt_show, ++ scst_acg_luns_mgmt_store); ++ ++static ssize_t scst_acg_addr_method_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_acg *acg; ++ ++ acg = container_of(kobj, struct scst_acg, acg_kobj); ++ ++ return __scst_acg_addr_method_show(acg, buf); ++} ++ ++static ssize_t scst_acg_addr_method_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ struct scst_acg *acg; ++ ++ acg = container_of(kobj, struct scst_acg, acg_kobj); ++ ++ res = __scst_acg_addr_method_store(acg, buf, count); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_acg_addr_method = ++ __ATTR(addr_method, S_IRUGO | S_IWUSR, scst_acg_addr_method_show, ++ scst_acg_addr_method_store); ++ ++static ssize_t scst_acg_io_grouping_type_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_acg *acg; ++ ++ acg = container_of(kobj, struct scst_acg, acg_kobj); ++ ++ return __scst_acg_io_grouping_type_show(acg, buf); ++} ++ ++static ssize_t scst_acg_io_grouping_type_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ struct scst_acg *acg; ++ ++ acg = container_of(kobj, struct scst_acg, acg_kobj); ++ ++ res = __scst_acg_io_grouping_type_store(acg, buf, count); ++ if (res != 0) ++ goto out; ++ ++ res = count; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_acg_io_grouping_type = ++ __ATTR(io_grouping_type, S_IRUGO | S_IWUSR, ++ scst_acg_io_grouping_type_show, ++ scst_acg_io_grouping_type_store); ++ ++static ssize_t scst_acg_cpu_mask_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_acg *acg; ++ ++ acg = container_of(kobj, struct scst_acg, acg_kobj); ++ ++ return __scst_acg_cpu_mask_show(acg, buf); ++} ++ ++static ssize_t scst_acg_cpu_mask_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ struct scst_acg *acg; ++ ++ acg = container_of(kobj, struct scst_acg, acg_kobj); ++ ++ res = __scst_acg_cpu_mask_store(acg, buf, count); ++ if (res != 0) ++ goto out; ++ ++ res = count; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_acg_cpu_mask = ++ __ATTR(cpu_mask, S_IRUGO | S_IWUSR, ++ scst_acg_cpu_mask_show, ++ scst_acg_cpu_mask_store); ++ ++/* ++ * Called with scst_mutex held. ++ * ++ * !! No sysfs works must use kobject_get() to protect acg, due to possible ++ * !! deadlock with scst_mutex (it is waiting for the last put, but ++ * !! the last ref counter holder is waiting for scst_mutex) ++ */ ++void scst_acg_sysfs_del(struct scst_acg *acg) ++{ ++ int rc; ++ DECLARE_COMPLETION_ONSTACK(c); ++ ++ TRACE_ENTRY(); ++ ++ acg->acg_kobj_release_cmpl = &c; ++ ++ kobject_del(acg->luns_kobj); ++ kobject_del(acg->initiators_kobj); ++ kobject_del(&acg->acg_kobj); ++ ++ kobject_put(acg->luns_kobj); ++ kobject_put(acg->initiators_kobj); ++ kobject_put(&acg->acg_kobj); ++ ++ rc = wait_for_completion_timeout(acg->acg_kobj_release_cmpl, HZ); ++ if (rc == 0) { ++ PRINT_INFO("Waiting for releasing sysfs entry " ++ "for acg %s (%d refs)...", acg->acg_name, ++ atomic_read(&acg->acg_kobj.kref.refcount)); ++ wait_for_completion(acg->acg_kobj_release_cmpl); ++ PRINT_INFO("Done waiting for releasing sysfs " ++ "entry for acg %s", acg->acg_name); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++int scst_acg_sysfs_create(struct scst_tgt *tgt, ++ struct scst_acg *acg) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ res = kobject_init_and_add(&acg->acg_kobj, &acg_ktype, ++ tgt->tgt_ini_grp_kobj, acg->acg_name); ++ if (res != 0) { ++ PRINT_ERROR("Can't add acg '%s' to sysfs", acg->acg_name); ++ goto out; ++ } ++ ++ acg->luns_kobj = kobject_create_and_add("luns", &acg->acg_kobj); ++ if (acg->luns_kobj == NULL) { ++ PRINT_ERROR("Can't create luns kobj for tgt %s", ++ tgt->tgt_name); ++ res = -ENOMEM; ++ goto out_del; ++ } ++ ++ res = sysfs_create_file(acg->luns_kobj, &scst_acg_luns_mgmt.attr); ++ if (res != 0) { ++ PRINT_ERROR("Can't add tgt attr %s for tgt %s", ++ scst_acg_luns_mgmt.attr.name, tgt->tgt_name); ++ goto out_del; ++ } ++ ++ acg->initiators_kobj = kobject_create_and_add("initiators", ++ &acg->acg_kobj); ++ if (acg->initiators_kobj == NULL) { ++ PRINT_ERROR("Can't create initiators kobj for tgt %s", ++ tgt->tgt_name); ++ res = -ENOMEM; ++ goto out_del; ++ } ++ ++ res = sysfs_create_file(acg->initiators_kobj, ++ &scst_acg_ini_mgmt.attr); ++ if (res != 0) { ++ PRINT_ERROR("Can't add tgt attr %s for tgt %s", ++ scst_acg_ini_mgmt.attr.name, tgt->tgt_name); ++ goto out_del; ++ } ++ ++ res = sysfs_create_file(&acg->acg_kobj, &scst_acg_addr_method.attr); ++ if (res != 0) { ++ PRINT_ERROR("Can't add tgt attr %s for tgt %s", ++ scst_acg_addr_method.attr.name, tgt->tgt_name); ++ goto out_del; ++ } ++ ++ res = sysfs_create_file(&acg->acg_kobj, &scst_acg_io_grouping_type.attr); ++ if (res != 0) { ++ PRINT_ERROR("Can't add tgt attr %s for tgt %s", ++ scst_acg_io_grouping_type.attr.name, tgt->tgt_name); ++ goto out_del; ++ } ++ ++ res = sysfs_create_file(&acg->acg_kobj, &scst_acg_cpu_mask.attr); ++ if (res != 0) { ++ PRINT_ERROR("Can't add tgt attr %s for tgt %s", ++ scst_acg_cpu_mask.attr.name, tgt->tgt_name); ++ goto out_del; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_del: ++ scst_acg_sysfs_del(acg); ++ goto out; ++} ++ ++/** ++ ** acn ++ **/ ++ ++static ssize_t scst_acn_file_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ return scnprintf(buf, SCST_SYSFS_BLOCK_SIZE, "%s\n", ++ attr->attr.name); ++} ++ ++int scst_acn_sysfs_create(struct scst_acn *acn) ++{ ++ int res = 0; ++ struct scst_acg *acg = acn->acg; ++ struct kobj_attribute *attr = NULL; ++#ifdef CONFIG_DEBUG_LOCK_ALLOC ++ static struct lock_class_key __key; ++#endif ++ ++ TRACE_ENTRY(); ++ ++ acn->acn_attr = NULL; ++ ++ attr = kzalloc(sizeof(struct kobj_attribute), GFP_KERNEL); ++ if (attr == NULL) { ++ PRINT_ERROR("Unable to allocate attributes for initiator '%s'", ++ acn->name); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ attr->attr.name = kstrdup(acn->name, GFP_KERNEL); ++ if (attr->attr.name == NULL) { ++ PRINT_ERROR("Unable to allocate attributes for initiator '%s'", ++ acn->name); ++ res = -ENOMEM; ++ goto out_free; ++ } ++ ++#ifdef CONFIG_DEBUG_LOCK_ALLOC ++ attr->attr.key = &__key; ++#endif ++ ++ attr->attr.mode = S_IRUGO; ++ attr->show = scst_acn_file_show; ++ attr->store = NULL; ++ ++ res = sysfs_create_file(acg->initiators_kobj, &attr->attr); ++ if (res != 0) { ++ PRINT_ERROR("Unable to create acn '%s' for group '%s'", ++ acn->name, acg->acg_name); ++ kfree(attr->attr.name); ++ goto out_free; ++ } ++ ++ acn->acn_attr = attr; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free: ++ kfree(attr); ++ goto out; ++} ++ ++void scst_acn_sysfs_del(struct scst_acn *acn) ++{ ++ struct scst_acg *acg = acn->acg; ++ ++ TRACE_ENTRY(); ++ ++ if (acn->acn_attr != NULL) { ++ sysfs_remove_file(acg->initiators_kobj, ++ &acn->acn_attr->attr); ++ kfree(acn->acn_attr->attr.name); ++ kfree(acn->acn_attr); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ ** Dev handlers ++ **/ ++ ++static void scst_devt_release(struct kobject *kobj) ++{ ++ struct scst_dev_type *devt; ++ ++ TRACE_ENTRY(); ++ ++ devt = container_of(kobj, struct scst_dev_type, devt_kobj); ++ if (devt->devt_kobj_release_compl) ++ complete_all(devt->devt_kobj_release_compl); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ ++static ssize_t scst_devt_trace_level_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_dev_type *devt; ++ ++ devt = container_of(kobj, struct scst_dev_type, devt_kobj); ++ ++ return scst_trace_level_show(devt->trace_tbl, ++ devt->trace_flags ? *devt->trace_flags : 0, buf, ++ devt->trace_tbl_help); ++} ++ ++static ssize_t scst_devt_trace_level_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ struct scst_dev_type *devt; ++ ++ TRACE_ENTRY(); ++ ++ devt = container_of(kobj, struct scst_dev_type, devt_kobj); ++ ++ res = mutex_lock_interruptible(&scst_log_mutex); ++ if (res != 0) ++ goto out; ++ ++ res = scst_write_trace(buf, count, devt->trace_flags, ++ devt->default_trace_flags, devt->name, devt->trace_tbl); ++ ++ mutex_unlock(&scst_log_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute devt_trace_attr = ++ __ATTR(trace_level, S_IRUGO | S_IWUSR, ++ scst_devt_trace_level_show, scst_devt_trace_level_store); ++ ++#endif /* defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) */ ++ ++static ssize_t scst_devt_type_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos; ++ struct scst_dev_type *devt; ++ ++ devt = container_of(kobj, struct scst_dev_type, devt_kobj); ++ ++ pos = sprintf(buf, "%d - %s\n", devt->type, ++ (unsigned)devt->type >= ARRAY_SIZE(scst_dev_handler_types) ? ++ "unknown" : scst_dev_handler_types[devt->type]); ++ ++ return pos; ++} ++ ++static struct kobj_attribute scst_devt_type_attr = ++ __ATTR(type, S_IRUGO, scst_devt_type_show, NULL); ++ ++static struct attribute *scst_devt_default_attrs[] = { ++ &scst_devt_type_attr.attr, ++ NULL, ++}; ++ ++static struct kobj_type scst_devt_ktype = { ++ .sysfs_ops = &scst_sysfs_ops, ++ .release = scst_devt_release, ++ .default_attrs = scst_devt_default_attrs, ++}; ++ ++static ssize_t scst_devt_mgmt_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ static const char help[] = ++ "Usage: echo \"add_device device_name [parameters]\" >mgmt\n" ++ " echo \"del_device device_name\" >mgmt\n" ++ "%s%s" ++ "%s" ++ "\n" ++ "where parameters are one or more " ++ "param_name=value pairs separated by ';'\n\n" ++ "%s%s%s%s%s%s%s%s\n"; ++ struct scst_dev_type *devt; ++ ++ devt = container_of(kobj, struct scst_dev_type, devt_kobj); ++ ++ return scnprintf(buf, SCST_SYSFS_BLOCK_SIZE, help, ++ (devt->devt_optional_attributes != NULL) ? ++ " echo \"add_attribute <attribute> <value>\" >mgmt\n" ++ " echo \"del_attribute <attribute> <value>\" >mgmt\n" : "", ++ (devt->dev_optional_attributes != NULL) ? ++ " echo \"add_device_attribute device_name <attribute> <value>\" >mgmt" ++ " echo \"del_device_attribute device_name <attribute> <value>\" >mgmt\n" : "", ++ (devt->mgmt_cmd_help) ? devt->mgmt_cmd_help : "", ++ (devt->add_device_parameters != NULL) ? ++ "The following parameters available: " : "", ++ (devt->add_device_parameters != NULL) ? ++ devt->add_device_parameters : "", ++ (devt->devt_optional_attributes != NULL) ? ++ "The following dev handler attributes available: " : "", ++ (devt->devt_optional_attributes != NULL) ? ++ devt->devt_optional_attributes : "", ++ (devt->devt_optional_attributes != NULL) ? "\n" : "", ++ (devt->dev_optional_attributes != NULL) ? ++ "The following device attributes available: " : "", ++ (devt->dev_optional_attributes != NULL) ? ++ devt->dev_optional_attributes : "", ++ (devt->dev_optional_attributes != NULL) ? "\n" : ""); ++} ++ ++static int scst_process_devt_mgmt_store(char *buffer, ++ struct scst_dev_type *devt) ++{ ++ int res = 0; ++ char *p, *pp, *dev_name; ++ ++ TRACE_ENTRY(); ++ ++ /* Check if our pointer is still alive and, if yes, grab it */ ++ if (scst_check_grab_devt_ptr(devt, &scst_virtual_dev_type_list) != 0) ++ goto out; ++ ++ TRACE_DBG("devt %p, buffer %s", devt, buffer); ++ ++ pp = buffer; ++ if (pp[strlen(pp) - 1] == '\n') ++ pp[strlen(pp) - 1] = '\0'; ++ ++ p = scst_get_next_lexem(&pp); ++ ++ if (strcasecmp("add_device", p) == 0) { ++ dev_name = scst_get_next_lexem(&pp); ++ if (*dev_name == '\0') { ++ PRINT_ERROR("%s", "Device name required"); ++ res = -EINVAL; ++ goto out_ungrab; ++ } ++ res = devt->add_device(dev_name, pp); ++ } else if (strcasecmp("del_device", p) == 0) { ++ dev_name = scst_get_next_lexem(&pp); ++ if (*dev_name == '\0') { ++ PRINT_ERROR("%s", "Device name required"); ++ res = -EINVAL; ++ goto out_ungrab; ++ } ++ ++ p = scst_get_next_lexem(&pp); ++ if (*p != '\0') ++ goto out_syntax_err; ++ ++ res = devt->del_device(dev_name); ++ } else if (devt->mgmt_cmd != NULL) { ++ scst_restore_token_str(p, pp); ++ res = devt->mgmt_cmd(buffer); ++ } else { ++ PRINT_ERROR("Unknown action \"%s\"", p); ++ res = -EINVAL; ++ goto out_ungrab; ++ } ++ ++out_ungrab: ++ scst_ungrab_devt_ptr(devt); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_syntax_err: ++ PRINT_ERROR("Syntax error on \"%s\"", p); ++ res = -EINVAL; ++ goto out_ungrab; ++} ++ ++static int scst_devt_mgmt_store_work_fn(struct scst_sysfs_work_item *work) ++{ ++ return scst_process_devt_mgmt_store(work->buf, work->devt); ++} ++ ++static ssize_t __scst_devt_mgmt_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count, ++ int (*sysfs_work_fn)(struct scst_sysfs_work_item *work)) ++{ ++ int res; ++ char *buffer; ++ struct scst_dev_type *devt; ++ struct scst_sysfs_work_item *work; ++ ++ TRACE_ENTRY(); ++ ++ devt = container_of(kobj, struct scst_dev_type, devt_kobj); ++ ++ buffer = kasprintf(GFP_KERNEL, "%.*s", (int)count, buf); ++ if (buffer == NULL) { ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ res = scst_alloc_sysfs_work(sysfs_work_fn, false, &work); ++ if (res != 0) ++ goto out_free; ++ ++ work->buf = buffer; ++ work->devt = devt; ++ ++ res = scst_sysfs_queue_wait_work(work); ++ if (res == 0) ++ res = count; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free: ++ kfree(buffer); ++ goto out; ++} ++ ++static ssize_t scst_devt_mgmt_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ return __scst_devt_mgmt_store(kobj, attr, buf, count, ++ scst_devt_mgmt_store_work_fn); ++} ++ ++static struct kobj_attribute scst_devt_mgmt = ++ __ATTR(mgmt, S_IRUGO | S_IWUSR, scst_devt_mgmt_show, ++ scst_devt_mgmt_store); ++ ++static ssize_t scst_devt_pass_through_mgmt_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ static const char help[] = ++ "Usage: echo \"add_device H:C:I:L\" >mgmt\n" ++ " echo \"del_device H:C:I:L\" >mgmt\n"; ++ return sprintf(buf, "%s", help); ++} ++ ++static int scst_process_devt_pass_through_mgmt_store(char *buffer, ++ struct scst_dev_type *devt) ++{ ++ int res = 0; ++ char *p, *pp, *action; ++ unsigned long host, channel, id, lun; ++ struct scst_device *d, *dev = NULL; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("devt %p, buffer %s", devt, buffer); ++ ++ pp = buffer; ++ if (pp[strlen(pp) - 1] == '\n') ++ pp[strlen(pp) - 1] = '\0'; ++ ++ action = scst_get_next_lexem(&pp); ++ p = scst_get_next_lexem(&pp); ++ if (*p == '\0') { ++ PRINT_ERROR("%s", "Device required"); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (*scst_get_next_lexem(&pp) != '\0') { ++ PRINT_ERROR("%s", "Too many parameters"); ++ res = -EINVAL; ++ goto out_syntax_err; ++ } ++ ++ host = simple_strtoul(p, &p, 0); ++ if ((host == ULONG_MAX) || (*p != ':')) ++ goto out_syntax_err; ++ p++; ++ channel = simple_strtoul(p, &p, 0); ++ if ((channel == ULONG_MAX) || (*p != ':')) ++ goto out_syntax_err; ++ p++; ++ id = simple_strtoul(p, &p, 0); ++ if ((channel == ULONG_MAX) || (*p != ':')) ++ goto out_syntax_err; ++ p++; ++ lun = simple_strtoul(p, &p, 0); ++ if (lun == ULONG_MAX) ++ goto out_syntax_err; ++ ++ TRACE_DBG("Dev %ld:%ld:%ld:%ld", host, channel, id, lun); ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res != 0) ++ goto out; ++ ++ /* Check if devt not be already freed while we were coming here */ ++ if (scst_check_devt_ptr(devt, &scst_dev_type_list) != 0) ++ goto out_unlock; ++ ++ list_for_each_entry(d, &scst_dev_list, dev_list_entry) { ++ if ((d->virt_id == 0) && ++ d->scsi_dev->host->host_no == host && ++ d->scsi_dev->channel == channel && ++ d->scsi_dev->id == id && ++ d->scsi_dev->lun == lun) { ++ dev = d; ++ TRACE_DBG("Dev %p (%ld:%ld:%ld:%ld) found", ++ dev, host, channel, id, lun); ++ break; ++ } ++ } ++ if (dev == NULL) { ++ PRINT_ERROR("Device %ld:%ld:%ld:%ld not found", ++ host, channel, id, lun); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++ if (dev->scsi_dev->type != devt->type) { ++ PRINT_ERROR("Type %d of device %s differs from type " ++ "%d of dev handler %s", dev->type, ++ dev->virt_name, devt->type, devt->name); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++ if (strcasecmp("add_device", action) == 0) { ++ res = scst_assign_dev_handler(dev, devt); ++ if (res == 0) ++ PRINT_INFO("Device %s assigned to dev handler %s", ++ dev->virt_name, devt->name); ++ } else if (strcasecmp("del_device", action) == 0) { ++ if (dev->handler != devt) { ++ PRINT_ERROR("Device %s is not assigned to handler %s", ++ dev->virt_name, devt->name); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ res = scst_assign_dev_handler(dev, &scst_null_devtype); ++ if (res == 0) ++ PRINT_INFO("Device %s unassigned from dev handler %s", ++ dev->virt_name, devt->name); ++ } else { ++ PRINT_ERROR("Unknown action \"%s\"", action); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_syntax_err: ++ PRINT_ERROR("Syntax error on \"%s\"", p); ++ res = -EINVAL; ++ goto out; ++} ++ ++static int scst_devt_pass_through_mgmt_store_work_fn( ++ struct scst_sysfs_work_item *work) ++{ ++ return scst_process_devt_pass_through_mgmt_store(work->buf, work->devt); ++} ++ ++static ssize_t scst_devt_pass_through_mgmt_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ return __scst_devt_mgmt_store(kobj, attr, buf, count, ++ scst_devt_pass_through_mgmt_store_work_fn); ++} ++ ++static struct kobj_attribute scst_devt_pass_through_mgmt = ++ __ATTR(mgmt, S_IRUGO | S_IWUSR, scst_devt_pass_through_mgmt_show, ++ scst_devt_pass_through_mgmt_store); ++ ++int scst_devt_sysfs_create(struct scst_dev_type *devt) ++{ ++ int res; ++ struct kobject *parent; ++ ++ TRACE_ENTRY(); ++ ++ if (devt->parent != NULL) ++ parent = &devt->parent->devt_kobj; ++ else ++ parent = scst_handlers_kobj; ++ ++ res = kobject_init_and_add(&devt->devt_kobj, &scst_devt_ktype, ++ parent, devt->name); ++ if (res != 0) { ++ PRINT_ERROR("Can't add devt %s to sysfs", devt->name); ++ goto out; ++ } ++ ++ if (devt->add_device != NULL) { ++ res = sysfs_create_file(&devt->devt_kobj, ++ &scst_devt_mgmt.attr); ++ } else { ++ res = sysfs_create_file(&devt->devt_kobj, ++ &scst_devt_pass_through_mgmt.attr); ++ } ++ if (res != 0) { ++ PRINT_ERROR("Can't add mgmt attr for dev handler %s", ++ devt->name); ++ goto out_err; ++ } ++ ++ if (devt->devt_attrs) { ++ res = sysfs_create_files(&devt->devt_kobj, devt->devt_attrs); ++ if (res != 0) { ++ PRINT_ERROR("Can't add attributes for dev handler %s", ++ devt->name); ++ goto out_err; ++ } ++ } ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ if (devt->trace_flags != NULL) { ++ res = sysfs_create_file(&devt->devt_kobj, ++ &devt_trace_attr.attr); ++ if (res != 0) { ++ PRINT_ERROR("Can't add devt trace_flag for dev " ++ "handler %s", devt->name); ++ goto out_err; ++ } ++ } ++#endif ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_err: ++ scst_devt_sysfs_del(devt); ++ goto out; ++} ++ ++void scst_devt_sysfs_del(struct scst_dev_type *devt) ++{ ++ int rc; ++ DECLARE_COMPLETION_ONSTACK(c); ++ ++ TRACE_ENTRY(); ++ ++ devt->devt_kobj_release_compl = &c; ++ ++ kobject_del(&devt->devt_kobj); ++ kobject_put(&devt->devt_kobj); ++ ++ rc = wait_for_completion_timeout(devt->devt_kobj_release_compl, HZ); ++ if (rc == 0) { ++ PRINT_INFO("Waiting for releasing of sysfs entry " ++ "for dev handler template %s (%d refs)...", devt->name, ++ atomic_read(&devt->devt_kobj.kref.refcount)); ++ wait_for_completion(devt->devt_kobj_release_compl); ++ PRINT_INFO("Done waiting for releasing sysfs entry " ++ "for dev handler template %s", devt->name); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ ** SCST sysfs device_groups/<dg>/devices/<dev> implementation. ++ **/ ++ ++int scst_dg_dev_sysfs_add(struct scst_dev_group *dg, struct scst_dg_dev *dgdev) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ res = sysfs_create_link(dg->dev_kobj, &dgdev->dev->dev_kobj, ++ dgdev->dev->virt_name); ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++void scst_dg_dev_sysfs_del(struct scst_dev_group *dg, struct scst_dg_dev *dgdev) ++{ ++ TRACE_ENTRY(); ++ sysfs_remove_link(dg->dev_kobj, dgdev->dev->virt_name); ++ TRACE_EXIT(); ++} ++ ++/** ++ ** SCST sysfs device_groups/<dg>/devices directory implementation. ++ **/ ++ ++static ssize_t scst_dg_devs_mgmt_show(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ char *buf) ++{ ++ static const char help[] = ++ "Usage: echo \"add device\" >mgmt\n" ++ " echo \"del device\" >mgmt\n"; ++ ++ return scnprintf(buf, PAGE_SIZE, help); ++} ++ ++static int scst_dg_devs_mgmt_store_work_fn(struct scst_sysfs_work_item *w) ++{ ++ struct scst_dev_group *dg; ++ char *cmd, *p, *pp, *dev_name; ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ cmd = w->buf; ++ dg = scst_lookup_dg_by_kobj(w->kobj); ++ WARN_ON(!dg); ++ ++ p = strchr(cmd, '\n'); ++ if (p) ++ *p = '\0'; ++ ++ res = -EINVAL; ++ pp = cmd; ++ p = scst_get_next_lexem(&pp); ++ if (strcasecmp(p, "add") == 0) { ++ dev_name = scst_get_next_lexem(&pp); ++ if (!*dev_name) ++ goto out; ++ res = scst_dg_dev_add(dg, dev_name); ++ } else if (strcasecmp(p, "del") == 0) { ++ dev_name = scst_get_next_lexem(&pp); ++ if (!*dev_name) ++ goto out; ++ res = scst_dg_dev_remove_by_name(dg, dev_name); ++ } ++out: ++ kobject_put(w->kobj); ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t scst_dg_devs_mgmt_store(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ const char *buf, size_t count) ++{ ++ char *cmd; ++ struct scst_sysfs_work_item *work; ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ res = -ENOMEM; ++ cmd = kasprintf(GFP_KERNEL, "%.*s", (int)count, buf); ++ if (!cmd) ++ goto out; ++ ++ res = scst_alloc_sysfs_work(scst_dg_devs_mgmt_store_work_fn, false, ++ &work); ++ if (res) ++ goto out; ++ ++ work->buf = cmd; ++ work->kobj = kobj; ++ kobject_get(kobj); ++ res = scst_sysfs_queue_wait_work(work); ++ ++out: ++ if (res == 0) ++ res = count; ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_dg_devs_mgmt = ++ __ATTR(mgmt, S_IRUGO | S_IWUSR, scst_dg_devs_mgmt_show, ++ scst_dg_devs_mgmt_store); ++ ++static const struct attribute *scst_dg_devs_attrs[] = { ++ &scst_dg_devs_mgmt.attr, ++ NULL, ++}; ++ ++/** ++ ** SCST sysfs device_groups/<dg>/target_groups/<tg>/<tgt> implementation. ++ **/ ++ ++static ssize_t scst_tg_tgt_rel_tgt_id_show(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ char *buf) ++{ ++ struct scst_tg_tgt *tg_tgt; ++ ++ tg_tgt = container_of(kobj, struct scst_tg_tgt, kobj); ++ return scnprintf(buf, PAGE_SIZE, "%u\n" SCST_SYSFS_KEY_MARK "\n", ++ tg_tgt->rel_tgt_id); ++} ++ ++static ssize_t scst_tg_tgt_rel_tgt_id_store(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ const char *buf, size_t count) ++{ ++ struct scst_tg_tgt *tg_tgt; ++ unsigned long rel_tgt_id; ++ char ch[8]; ++ int res; ++ ++ TRACE_ENTRY(); ++ tg_tgt = container_of(kobj, struct scst_tg_tgt, kobj); ++ snprintf(ch, sizeof(ch), "%.*s", min_t(int, count, sizeof(ch)-1), buf); ++ res = strict_strtoul(ch, 0, &rel_tgt_id); ++ if (res) ++ goto out; ++ res = -EINVAL; ++ if (rel_tgt_id == 0 || rel_tgt_id > 0xffff) ++ goto out; ++ tg_tgt->rel_tgt_id = rel_tgt_id; ++ res = count; ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_tg_tgt_rel_tgt_id = ++ __ATTR(rel_tgt_id, S_IRUGO | S_IWUSR, scst_tg_tgt_rel_tgt_id_show, ++ scst_tg_tgt_rel_tgt_id_store); ++ ++static const struct attribute *scst_tg_tgt_attrs[] = { ++ &scst_tg_tgt_rel_tgt_id.attr, ++ NULL, ++}; ++ ++int scst_tg_tgt_sysfs_add(struct scst_target_group *tg, ++ struct scst_tg_tgt *tg_tgt) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ BUG_ON(!tg); ++ BUG_ON(!tg_tgt); ++ BUG_ON(!tg_tgt->name); ++ if (tg_tgt->tgt) ++ res = sysfs_create_link(&tg->kobj, &tg_tgt->tgt->tgt_kobj, ++ tg_tgt->name); ++ else { ++ res = kobject_add(&tg_tgt->kobj, &tg->kobj, "%s", tg_tgt->name); ++ if (res) ++ goto err; ++ res = sysfs_create_files(&tg_tgt->kobj, scst_tg_tgt_attrs); ++ if (res) ++ goto err; ++ } ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++err: ++ scst_tg_tgt_sysfs_del(tg, tg_tgt); ++ goto out; ++} ++ ++void scst_tg_tgt_sysfs_del(struct scst_target_group *tg, ++ struct scst_tg_tgt *tg_tgt) ++{ ++ TRACE_ENTRY(); ++ if (tg_tgt->tgt) ++ sysfs_remove_link(&tg->kobj, tg_tgt->name); ++ else { ++ sysfs_remove_files(&tg_tgt->kobj, scst_tg_tgt_attrs); ++ kobject_del(&tg_tgt->kobj); ++ } ++ TRACE_EXIT(); ++} ++ ++/** ++ ** SCST sysfs device_groups/<dg>/target_groups/<tg> directory implementation. ++ **/ ++ ++static ssize_t scst_tg_group_id_show(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ char *buf) ++{ ++ struct scst_target_group *tg; ++ ++ tg = container_of(kobj, struct scst_target_group, kobj); ++ return scnprintf(buf, PAGE_SIZE, "%u\n" SCST_SYSFS_KEY_MARK "\n", ++ tg->group_id); ++} ++ ++static ssize_t scst_tg_group_id_store(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ const char *buf, size_t count) ++{ ++ struct scst_target_group *tg; ++ unsigned long group_id; ++ char ch[8]; ++ int res; ++ ++ TRACE_ENTRY(); ++ tg = container_of(kobj, struct scst_target_group, kobj); ++ snprintf(ch, sizeof(ch), "%.*s", min_t(int, count, sizeof(ch)-1), buf); ++ res = strict_strtoul(ch, 0, &group_id); ++ if (res) ++ goto out; ++ res = -EINVAL; ++ if (group_id == 0 || group_id > 0xffff) ++ goto out; ++ tg->group_id = group_id; ++ res = count; ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_tg_group_id = ++ __ATTR(group_id, S_IRUGO | S_IWUSR, scst_tg_group_id_show, ++ scst_tg_group_id_store); ++ ++static ssize_t scst_tg_preferred_show(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ char *buf) ++{ ++ struct scst_target_group *tg; ++ ++ tg = container_of(kobj, struct scst_target_group, kobj); ++ return scnprintf(buf, PAGE_SIZE, "%u\n%s", ++ tg->preferred, SCST_SYSFS_KEY_MARK "\n"); ++} ++ ++static ssize_t scst_tg_preferred_store(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ const char *buf, size_t count) ++{ ++ struct scst_target_group *tg; ++ unsigned long preferred; ++ char ch[8]; ++ int res; ++ ++ TRACE_ENTRY(); ++ tg = container_of(kobj, struct scst_target_group, kobj); ++ snprintf(ch, sizeof(ch), "%.*s", min_t(int, count, sizeof(ch)-1), buf); ++ res = strict_strtoul(ch, 0, &preferred); ++ if (res) ++ goto out; ++ res = -EINVAL; ++ if (preferred != 0 && preferred != 1) ++ goto out; ++ tg->preferred = preferred; ++ res = count; ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_tg_preferred = ++ __ATTR(preferred, S_IRUGO | S_IWUSR, scst_tg_preferred_show, ++ scst_tg_preferred_store); ++ ++static struct { enum scst_tg_state s; const char *n; } scst_tg_state_names[] = { ++ { SCST_TG_STATE_OPTIMIZED, "active" }, ++ { SCST_TG_STATE_NONOPTIMIZED, "nonoptimized" }, ++ { SCST_TG_STATE_STANDBY, "standby" }, ++ { SCST_TG_STATE_UNAVAILABLE, "unavailable" }, ++ { SCST_TG_STATE_OFFLINE, "offline" }, ++ { SCST_TG_STATE_TRANSITIONING, "transitioning" }, ++}; ++ ++static ssize_t scst_tg_state_show(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ char *buf) ++{ ++ struct scst_target_group *tg; ++ int i; ++ ++ tg = container_of(kobj, struct scst_target_group, kobj); ++ for (i = ARRAY_SIZE(scst_tg_state_names) - 1; i >= 0; i--) ++ if (scst_tg_state_names[i].s == tg->state) ++ break; ++ ++ return scnprintf(buf, PAGE_SIZE, "%s\n" SCST_SYSFS_KEY_MARK "\n", ++ i >= 0 ? scst_tg_state_names[i].n : "???"); ++} ++ ++static int scst_tg_state_store_work_fn(struct scst_sysfs_work_item *w) ++{ ++ struct scst_target_group *tg; ++ char *cmd, *p; ++ int i, res; ++ ++ TRACE_ENTRY(); ++ ++ cmd = w->buf; ++ tg = container_of(w->kobj, struct scst_target_group, kobj); ++ ++ p = strchr(cmd, '\n'); ++ if (p) ++ *p = '\0'; ++ ++ for (i = ARRAY_SIZE(scst_tg_state_names) - 1; i >= 0; i--) ++ if (strcmp(scst_tg_state_names[i].n, cmd) == 0) ++ break; ++ ++ res = -EINVAL; ++ if (i < 0) ++ goto out; ++ res = scst_tg_set_state(tg, scst_tg_state_names[i].s); ++out: ++ kobject_put(w->kobj); ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t scst_tg_state_store(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ const char *buf, size_t count) ++{ ++ char *cmd; ++ struct scst_sysfs_work_item *work; ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ res = -ENOMEM; ++ cmd = kasprintf(GFP_KERNEL, "%.*s", (int)count, buf); ++ if (!cmd) ++ goto out; ++ ++ res = scst_alloc_sysfs_work(scst_tg_state_store_work_fn, false, ++ &work); ++ if (res) ++ goto out; ++ ++ work->buf = cmd; ++ work->kobj = kobj; ++ kobject_get(kobj); ++ res = scst_sysfs_queue_wait_work(work); ++ ++out: ++ if (res == 0) ++ res = count; ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_tg_state = ++ __ATTR(state, S_IRUGO | S_IWUSR, scst_tg_state_show, ++ scst_tg_state_store); ++ ++static ssize_t scst_tg_mgmt_show(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ char *buf) ++{ ++ static const char help[] = ++ "Usage: echo \"add target\" >mgmt\n" ++ " echo \"del target\" >mgmt\n"; ++ ++ return scnprintf(buf, PAGE_SIZE, help); ++} ++ ++static int scst_tg_mgmt_store_work_fn(struct scst_sysfs_work_item *w) ++{ ++ struct scst_target_group *tg; ++ char *cmd, *p, *pp, *target_name; ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ cmd = w->buf; ++ tg = container_of(w->kobj, struct scst_target_group, kobj); ++ ++ p = strchr(cmd, '\n'); ++ if (p) ++ *p = '\0'; ++ ++ res = -EINVAL; ++ pp = cmd; ++ p = scst_get_next_lexem(&pp); ++ if (strcasecmp(p, "add") == 0) { ++ target_name = scst_get_next_lexem(&pp); ++ if (!*target_name) ++ goto out; ++ res = scst_tg_tgt_add(tg, target_name); ++ } else if (strcasecmp(p, "del") == 0) { ++ target_name = scst_get_next_lexem(&pp); ++ if (!*target_name) ++ goto out; ++ res = scst_tg_tgt_remove_by_name(tg, target_name); ++ } ++out: ++ kobject_put(w->kobj); ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t scst_tg_mgmt_store(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ const char *buf, size_t count) ++{ ++ char *cmd; ++ struct scst_sysfs_work_item *work; ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ res = -ENOMEM; ++ cmd = kasprintf(GFP_KERNEL, "%.*s", (int)count, buf); ++ if (!cmd) ++ goto out; ++ ++ res = scst_alloc_sysfs_work(scst_tg_mgmt_store_work_fn, false, ++ &work); ++ if (res) ++ goto out; ++ ++ work->buf = cmd; ++ work->kobj = kobj; ++ kobject_get(kobj); ++ res = scst_sysfs_queue_wait_work(work); ++ ++out: ++ if (res == 0) ++ res = count; ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_tg_mgmt = ++ __ATTR(mgmt, S_IRUGO | S_IWUSR, scst_tg_mgmt_show, ++ scst_tg_mgmt_store); ++ ++static const struct attribute *scst_tg_attrs[] = { ++ &scst_tg_mgmt.attr, ++ &scst_tg_group_id.attr, ++ &scst_tg_preferred.attr, ++ &scst_tg_state.attr, ++ NULL, ++}; ++ ++int scst_tg_sysfs_add(struct scst_dev_group *dg, struct scst_target_group *tg) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ res = kobject_add(&tg->kobj, dg->tg_kobj, "%s", tg->name); ++ if (res) ++ goto err; ++ res = sysfs_create_files(&tg->kobj, scst_tg_attrs); ++ if (res) ++ goto err; ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++err: ++ scst_tg_sysfs_del(tg); ++ goto out; ++} ++ ++void scst_tg_sysfs_del(struct scst_target_group *tg) ++{ ++ TRACE_ENTRY(); ++ sysfs_remove_files(&tg->kobj, scst_tg_attrs); ++ kobject_del(&tg->kobj); ++ TRACE_EXIT(); ++} ++ ++/** ++ ** SCST sysfs device_groups/<dg>/target_groups directory implementation. ++ **/ ++ ++static ssize_t scst_dg_tgs_mgmt_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ static const char help[] = ++ "Usage: echo \"create group_name\" >mgmt\n" ++ " echo \"del group_name\" >mgmt\n"; ++ ++ return scnprintf(buf, PAGE_SIZE, help); ++} ++ ++static int scst_dg_tgs_mgmt_store_work_fn(struct scst_sysfs_work_item *w) ++{ ++ struct scst_dev_group *dg; ++ char *cmd, *p, *pp, *dev_name; ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ cmd = w->buf; ++ dg = scst_lookup_dg_by_kobj(w->kobj); ++ WARN_ON(!dg); ++ ++ p = strchr(cmd, '\n'); ++ if (p) ++ *p = '\0'; ++ ++ res = -EINVAL; ++ pp = cmd; ++ p = scst_get_next_lexem(&pp); ++ if (strcasecmp(p, "create") == 0 || strcasecmp(p, "add") == 0) { ++ dev_name = scst_get_next_lexem(&pp); ++ if (!*dev_name) ++ goto out; ++ res = scst_tg_add(dg, dev_name); ++ } else if (strcasecmp(p, "del") == 0) { ++ dev_name = scst_get_next_lexem(&pp); ++ if (!*dev_name) ++ goto out; ++ res = scst_tg_remove_by_name(dg, dev_name); ++ } ++out: ++ kobject_put(w->kobj); ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t scst_dg_tgs_mgmt_store(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ const char *buf, size_t count) ++{ ++ char *cmd; ++ struct scst_sysfs_work_item *work; ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ res = -ENOMEM; ++ cmd = kasprintf(GFP_KERNEL, "%.*s", (int)count, buf); ++ if (!cmd) ++ goto out; ++ ++ res = scst_alloc_sysfs_work(scst_dg_tgs_mgmt_store_work_fn, false, ++ &work); ++ if (res) ++ goto out; ++ ++ work->buf = cmd; ++ work->kobj = kobj; ++ kobject_get(kobj); ++ res = scst_sysfs_queue_wait_work(work); ++ ++out: ++ if (res == 0) ++ res = count; ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_dg_tgs_mgmt = ++ __ATTR(mgmt, S_IRUGO | S_IWUSR, scst_dg_tgs_mgmt_show, ++ scst_dg_tgs_mgmt_store); ++ ++static const struct attribute *scst_dg_tgs_attrs[] = { ++ &scst_dg_tgs_mgmt.attr, ++ NULL, ++}; ++ ++/** ++ ** SCST sysfs device_groups directory implementation. ++ **/ ++ ++int scst_dg_sysfs_add(struct kobject *parent, struct scst_dev_group *dg) ++{ ++ int res; ++ ++ dg->dev_kobj = NULL; ++ dg->tg_kobj = NULL; ++ res = kobject_add(&dg->kobj, parent, "%s", dg->name); ++ if (res) ++ goto err; ++ res = -EEXIST; ++ dg->dev_kobj = kobject_create_and_add("devices", &dg->kobj); ++ if (!dg->dev_kobj) ++ goto err; ++ res = sysfs_create_files(dg->dev_kobj, scst_dg_devs_attrs); ++ if (res) ++ goto err; ++ dg->tg_kobj = kobject_create_and_add("target_groups", &dg->kobj); ++ if (!dg->tg_kobj) ++ goto err; ++ res = sysfs_create_files(dg->tg_kobj, scst_dg_tgs_attrs); ++ if (res) ++ goto err; ++out: ++ return res; ++err: ++ scst_dg_sysfs_del(dg); ++ goto out; ++} ++ ++void scst_dg_sysfs_del(struct scst_dev_group *dg) ++{ ++ if (dg->tg_kobj) { ++ sysfs_remove_files(dg->tg_kobj, scst_dg_tgs_attrs); ++ kobject_del(dg->tg_kobj); ++ kobject_put(dg->tg_kobj); ++ dg->tg_kobj = NULL; ++ } ++ if (dg->dev_kobj) { ++ sysfs_remove_files(dg->dev_kobj, scst_dg_devs_attrs); ++ kobject_del(dg->dev_kobj); ++ kobject_put(dg->dev_kobj); ++ dg->dev_kobj = NULL; ++ } ++ kobject_del(&dg->kobj); ++} ++ ++static ssize_t scst_device_groups_mgmt_show(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ char *buf) ++{ ++ static const char help[] = ++ "Usage: echo \"create group_name\" >mgmt\n" ++ " echo \"del group_name\" >mgmt\n"; ++ ++ return scnprintf(buf, PAGE_SIZE, help); ++} ++ ++static ssize_t scst_device_groups_mgmt_store(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ const char *buf, size_t count) ++{ ++ int res; ++ char *p, *pp, *input, *group_name; ++ ++ TRACE_ENTRY(); ++ ++ input = kasprintf(GFP_KERNEL, "%.*s", (int)count, buf); ++ pp = input; ++ p = strchr(input, '\n'); ++ if (p) ++ *p = '\0'; ++ ++ res = -EINVAL; ++ p = scst_get_next_lexem(&pp); ++ if (strcasecmp(p, "create") == 0 || strcasecmp(p, "add") == 0) { ++ group_name = scst_get_next_lexem(&pp); ++ if (!*group_name) ++ goto out; ++ res = scst_dg_add(scst_device_groups_kobj, group_name); ++ } else if (strcasecmp(p, "del") == 0) { ++ group_name = scst_get_next_lexem(&pp); ++ if (!*group_name) ++ goto out; ++ res = scst_dg_remove(group_name); ++ } ++out: ++ kfree(input); ++ if (res == 0) ++ res = count; ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_device_groups_mgmt = ++ __ATTR(mgmt, S_IRUGO | S_IWUSR, scst_device_groups_mgmt_show, ++ scst_device_groups_mgmt_store); ++ ++static const struct attribute *scst_device_groups_attrs[] = { ++ &scst_device_groups_mgmt.attr, ++ NULL, ++}; ++ ++/** ++ ** SCST sysfs root directory implementation ++ **/ ++ ++static ssize_t scst_threads_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int count; ++ ++ TRACE_ENTRY(); ++ ++ count = sprintf(buf, "%d\n%s", scst_main_cmd_threads.nr_threads, ++ (scst_main_cmd_threads.nr_threads != scst_threads) ? ++ SCST_SYSFS_KEY_MARK "\n" : ""); ++ ++ TRACE_EXIT(); ++ return count; ++} ++ ++static int scst_process_threads_store(int newtn) ++{ ++ int res; ++ long oldtn, delta; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("newtn %d", newtn); ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res != 0) ++ goto out; ++ ++ oldtn = scst_main_cmd_threads.nr_threads; ++ ++ delta = newtn - oldtn; ++ if (delta < 0) ++ scst_del_threads(&scst_main_cmd_threads, -delta); ++ else { ++ res = scst_add_threads(&scst_main_cmd_threads, NULL, NULL, delta); ++ if (res != 0) ++ goto out_up; ++ } ++ ++ PRINT_INFO("Changed cmd threads num: old %ld, new %d", oldtn, newtn); ++ ++out_up: ++ mutex_unlock(&scst_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_threads_store_work_fn(struct scst_sysfs_work_item *work) ++{ ++ return scst_process_threads_store(work->new_threads_num); ++} ++ ++static ssize_t scst_threads_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ long newtn; ++ struct scst_sysfs_work_item *work; ++ ++ TRACE_ENTRY(); ++ ++ res = strict_strtol(buf, 0, &newtn); ++ if (res != 0) { ++ PRINT_ERROR("strict_strtol() for %s failed: %d ", buf, res); ++ goto out; ++ } ++ if (newtn <= 0) { ++ PRINT_ERROR("Illegal threads num value %ld", newtn); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ res = scst_alloc_sysfs_work(scst_threads_store_work_fn, false, &work); ++ if (res != 0) ++ goto out; ++ ++ work->new_threads_num = newtn; ++ ++ res = scst_sysfs_queue_wait_work(work); ++ if (res == 0) ++ res = count; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_threads_attr = ++ __ATTR(threads, S_IRUGO | S_IWUSR, scst_threads_show, ++ scst_threads_store); ++ ++static ssize_t scst_setup_id_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int count; ++ ++ TRACE_ENTRY(); ++ ++ count = sprintf(buf, "0x%x\n%s\n", scst_setup_id, ++ (scst_setup_id == 0) ? "" : SCST_SYSFS_KEY_MARK); ++ ++ TRACE_EXIT(); ++ return count; ++} ++ ++static ssize_t scst_setup_id_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ unsigned long val; ++ ++ TRACE_ENTRY(); ++ ++ res = strict_strtoul(buf, 0, &val); ++ if (res != 0) { ++ PRINT_ERROR("strict_strtoul() for %s failed: %d ", buf, res); ++ goto out; ++ } ++ ++ scst_setup_id = val; ++ PRINT_INFO("Changed scst_setup_id to %x", scst_setup_id); ++ ++ res = count; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_setup_id_attr = ++ __ATTR(setup_id, S_IRUGO | S_IWUSR, scst_setup_id_show, ++ scst_setup_id_store); ++ ++static ssize_t scst_max_tasklet_cmd_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int count; ++ ++ TRACE_ENTRY(); ++ ++ count = sprintf(buf, "%d\n%s\n", scst_max_tasklet_cmd, ++ (scst_max_tasklet_cmd == SCST_DEF_MAX_TASKLET_CMD) ++ ? "" : SCST_SYSFS_KEY_MARK); ++ ++ TRACE_EXIT(); ++ return count; ++} ++ ++static ssize_t scst_max_tasklet_cmd_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ unsigned long val; ++ ++ TRACE_ENTRY(); ++ ++ res = strict_strtoul(buf, 0, &val); ++ if (res != 0) { ++ PRINT_ERROR("strict_strtoul() for %s failed: %d ", buf, res); ++ goto out; ++ } ++ ++ scst_max_tasklet_cmd = val; ++ PRINT_INFO("Changed scst_max_tasklet_cmd to %d", scst_max_tasklet_cmd); ++ ++ res = count; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_max_tasklet_cmd_attr = ++ __ATTR(max_tasklet_cmd, S_IRUGO | S_IWUSR, scst_max_tasklet_cmd_show, ++ scst_max_tasklet_cmd_store); ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ ++static ssize_t scst_main_trace_level_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ return scst_trace_level_show(scst_local_trace_tbl, trace_flag, ++ buf, NULL); ++} ++ ++static ssize_t scst_main_trace_level_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ res = mutex_lock_interruptible(&scst_log_mutex); ++ if (res != 0) ++ goto out; ++ ++ res = scst_write_trace(buf, count, &trace_flag, ++ SCST_DEFAULT_LOG_FLAGS, "scst", scst_local_trace_tbl); ++ ++ mutex_unlock(&scst_log_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_main_trace_level_attr = ++ __ATTR(trace_level, S_IRUGO | S_IWUSR, scst_main_trace_level_show, ++ scst_main_trace_level_store); ++ ++#endif /* defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) */ ++ ++static ssize_t scst_version_show(struct kobject *kobj, ++ struct kobj_attribute *attr, ++ char *buf) ++{ ++ TRACE_ENTRY(); ++ ++ sprintf(buf, "%s\n", SCST_VERSION_STRING); ++ ++#ifdef CONFIG_SCST_STRICT_SERIALIZING ++ strcat(buf, "STRICT_SERIALIZING\n"); ++#endif ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ strcat(buf, "EXTRACHECKS\n"); ++#endif ++ ++#ifdef CONFIG_SCST_TRACING ++ strcat(buf, "TRACING\n"); ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG ++ strcat(buf, "DEBUG\n"); ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG_TM ++ strcat(buf, "DEBUG_TM\n"); ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG_RETRY ++ strcat(buf, "DEBUG_RETRY\n"); ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG_OOM ++ strcat(buf, "DEBUG_OOM\n"); ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG_SN ++ strcat(buf, "DEBUG_SN\n"); ++#endif ++ ++#ifdef CONFIG_SCST_USE_EXPECTED_VALUES ++ strcat(buf, "USE_EXPECTED_VALUES\n"); ++#endif ++ ++#ifdef CONFIG_SCST_TEST_IO_IN_SIRQ ++ strcat(buf, "TEST_IO_IN_SIRQ\n"); ++#endif ++ ++#ifdef CONFIG_SCST_STRICT_SECURITY ++ strcat(buf, "STRICT_SECURITY\n"); ++#endif ++ ++ TRACE_EXIT(); ++ return strlen(buf); ++} ++ ++static struct kobj_attribute scst_version_attr = ++ __ATTR(version, S_IRUGO, scst_version_show, NULL); ++ ++static ssize_t scst_last_sysfs_mgmt_res_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ spin_lock(&sysfs_work_lock); ++ TRACE_DBG("active_sysfs_works %d", active_sysfs_works); ++ if (active_sysfs_works > 0) ++ res = -EAGAIN; ++ else ++ res = sprintf(buf, "%d\n", last_sysfs_work_res); ++ spin_unlock(&sysfs_work_lock); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute scst_last_sysfs_mgmt_res_attr = ++ __ATTR(last_sysfs_mgmt_res, S_IRUGO, ++ scst_last_sysfs_mgmt_res_show, NULL); ++ ++static struct attribute *scst_sysfs_root_default_attrs[] = { ++ &scst_threads_attr.attr, ++ &scst_setup_id_attr.attr, ++ &scst_max_tasklet_cmd_attr.attr, ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ &scst_main_trace_level_attr.attr, ++#endif ++ &scst_version_attr.attr, ++ &scst_last_sysfs_mgmt_res_attr.attr, ++ NULL, ++}; ++ ++static void scst_sysfs_root_release(struct kobject *kobj) ++{ ++ complete_all(&scst_sysfs_root_release_completion); ++} ++ ++static struct kobj_type scst_sysfs_root_ktype = { ++ .sysfs_ops = &scst_sysfs_ops, ++ .release = scst_sysfs_root_release, ++ .default_attrs = scst_sysfs_root_default_attrs, ++}; ++ ++/** ++ ** Sysfs user info ++ **/ ++ ++static DEFINE_MUTEX(scst_sysfs_user_info_mutex); ++ ++/* All protected by scst_sysfs_user_info_mutex */ ++static LIST_HEAD(scst_sysfs_user_info_list); ++static uint32_t scst_sysfs_info_cur_cookie; ++ ++/* scst_sysfs_user_info_mutex supposed to be held */ ++static struct scst_sysfs_user_info *scst_sysfs_user_find_info(uint32_t cookie) ++{ ++ struct scst_sysfs_user_info *info, *res = NULL; ++ ++ TRACE_ENTRY(); ++ ++ list_for_each_entry(info, &scst_sysfs_user_info_list, ++ info_list_entry) { ++ if (info->info_cookie == cookie) { ++ res = info; ++ break; ++ } ++ } ++ ++ TRACE_EXIT_HRES(res); ++ return res; ++} ++ ++/** ++ * scst_sysfs_user_get_info() - get user_info ++ * ++ * Finds the user_info based on cookie and mark it as received the reply by ++ * setting for it flag info_being_executed. ++ * ++ * Returns found entry or NULL. ++ */ ++struct scst_sysfs_user_info *scst_sysfs_user_get_info(uint32_t cookie) ++{ ++ struct scst_sysfs_user_info *res = NULL; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_sysfs_user_info_mutex); ++ ++ res = scst_sysfs_user_find_info(cookie); ++ if (res != NULL) { ++ if (!res->info_being_executed) ++ res->info_being_executed = 1; ++ } ++ ++ mutex_unlock(&scst_sysfs_user_info_mutex); ++ ++ TRACE_EXIT_HRES(res); ++ return res; ++} ++EXPORT_SYMBOL_GPL(scst_sysfs_user_get_info); ++ ++/** ++ ** Helper functionality to help target drivers and dev handlers support ++ ** sending events to user space and wait for their completion in a safe ++ ** manner. See samples how to use it in iscsi-scst or scst_user. ++ **/ ++ ++/** ++ * scst_sysfs_user_add_info() - create and add user_info in the global list ++ * ++ * Creates an info structure and adds it in the info_list. ++ * Returns 0 and out_info on success, error code otherwise. ++ */ ++int scst_sysfs_user_add_info(struct scst_sysfs_user_info **out_info) ++{ ++ int res = 0; ++ struct scst_sysfs_user_info *info; ++ ++ TRACE_ENTRY(); ++ ++ info = kzalloc(sizeof(*info), GFP_KERNEL); ++ if (info == NULL) { ++ PRINT_ERROR("Unable to allocate sysfs user info (size %zd)", ++ sizeof(*info)); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ mutex_lock(&scst_sysfs_user_info_mutex); ++ ++ while ((info->info_cookie == 0) || ++ (scst_sysfs_user_find_info(info->info_cookie) != NULL)) ++ info->info_cookie = scst_sysfs_info_cur_cookie++; ++ ++ init_completion(&info->info_completion); ++ ++ list_add_tail(&info->info_list_entry, &scst_sysfs_user_info_list); ++ info->info_in_list = 1; ++ ++ *out_info = info; ++ ++ mutex_unlock(&scst_sysfs_user_info_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL_GPL(scst_sysfs_user_add_info); ++ ++/** ++ * scst_sysfs_user_del_info - delete and frees user_info ++ */ ++void scst_sysfs_user_del_info(struct scst_sysfs_user_info *info) ++{ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_sysfs_user_info_mutex); ++ ++ if (info->info_in_list) ++ list_del(&info->info_list_entry); ++ ++ mutex_unlock(&scst_sysfs_user_info_mutex); ++ ++ kfree(info); ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL_GPL(scst_sysfs_user_del_info); ++ ++/* ++ * Returns true if the reply received and being processed by another part of ++ * the kernel, false otherwise. Also removes the user_info from the list to ++ * fix for the user space that it missed the timeout. ++ */ ++static bool scst_sysfs_user_info_executing(struct scst_sysfs_user_info *info) ++{ ++ bool res; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_sysfs_user_info_mutex); ++ ++ res = info->info_being_executed; ++ ++ if (info->info_in_list) { ++ list_del(&info->info_list_entry); ++ info->info_in_list = 0; ++ } ++ ++ mutex_unlock(&scst_sysfs_user_info_mutex); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/** ++ * scst_wait_info_completion() - wait an user space event's completion ++ * ++ * Waits for the info request been completed by user space at most timeout ++ * jiffies. If the reply received before timeout and being processed by ++ * another part of the kernel, i.e. scst_sysfs_user_info_executing() ++ * returned true, waits for it to complete indefinitely. ++ * ++ * Returns status of the request completion. ++ */ ++int scst_wait_info_completion(struct scst_sysfs_user_info *info, ++ unsigned long timeout) ++{ ++ int res, rc; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Waiting for info %p completion", info); ++ ++ while (1) { ++ rc = wait_for_completion_interruptible_timeout( ++ &info->info_completion, timeout); ++ if (rc > 0) { ++ TRACE_DBG("Waiting for info %p finished with %d", ++ info, rc); ++ break; ++ } else if (rc == 0) { ++ if (!scst_sysfs_user_info_executing(info)) { ++ PRINT_ERROR("Timeout waiting for user " ++ "space event %p", info); ++ res = -EBUSY; ++ goto out; ++ } else { ++ /* Req is being executed in the kernel */ ++ TRACE_DBG("Keep waiting for info %p completion", ++ info); ++ wait_for_completion(&info->info_completion); ++ break; ++ } ++ } else if (rc != -ERESTARTSYS) { ++ res = rc; ++ PRINT_ERROR("wait_for_completion() failed: %d", ++ res); ++ goto out; ++ } else { ++ TRACE_DBG("Waiting for info %p finished with %d, " ++ "retrying", info, rc); ++ } ++ } ++ ++ TRACE_DBG("info %p, status %d", info, info->info_status); ++ res = info->info_status; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL_GPL(scst_wait_info_completion); ++ ++static struct kobject scst_sysfs_root_kobj; ++ ++int __init scst_sysfs_init(void) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ sysfs_work_thread = kthread_run(sysfs_work_thread_fn, ++ NULL, "scst_uid"); ++ if (IS_ERR(sysfs_work_thread)) { ++ res = PTR_ERR(sysfs_work_thread); ++ PRINT_ERROR("kthread_run() for user interface thread " ++ "failed: %d", res); ++ sysfs_work_thread = NULL; ++ goto out; ++ } ++ ++ res = kobject_init_and_add(&scst_sysfs_root_kobj, ++ &scst_sysfs_root_ktype, kernel_kobj, "%s", "scst_tgt"); ++ if (res != 0) ++ goto sysfs_root_add_error; ++ ++ scst_targets_kobj = kobject_create_and_add("targets", ++ &scst_sysfs_root_kobj); ++ if (scst_targets_kobj == NULL) ++ goto targets_kobj_error; ++ ++ scst_devices_kobj = kobject_create_and_add("devices", ++ &scst_sysfs_root_kobj); ++ if (scst_devices_kobj == NULL) ++ goto devices_kobj_error; ++ ++ res = scst_add_sgv_kobj(&scst_sysfs_root_kobj, "sgv"); ++ if (res != 0) ++ goto sgv_kobj_error; ++ ++ scst_handlers_kobj = kobject_create_and_add("handlers", ++ &scst_sysfs_root_kobj); ++ if (scst_handlers_kobj == NULL) ++ goto handlers_kobj_error; ++ ++ scst_device_groups_kobj = kobject_create_and_add("device_groups", ++ &scst_sysfs_root_kobj); ++ if (scst_device_groups_kobj == NULL) ++ goto device_groups_kobj_error; ++ ++ if (sysfs_create_files(scst_device_groups_kobj, ++ scst_device_groups_attrs)) ++ goto device_groups_attrs_error; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++device_groups_attrs_error: ++ kobject_del(scst_device_groups_kobj); ++ kobject_put(scst_device_groups_kobj); ++ ++device_groups_kobj_error: ++ kobject_del(scst_handlers_kobj); ++ kobject_put(scst_handlers_kobj); ++ ++handlers_kobj_error: ++ scst_del_put_sgv_kobj(); ++ ++sgv_kobj_error: ++ kobject_del(scst_devices_kobj); ++ kobject_put(scst_devices_kobj); ++ ++devices_kobj_error: ++ kobject_del(scst_targets_kobj); ++ kobject_put(scst_targets_kobj); ++ ++targets_kobj_error: ++ kobject_del(&scst_sysfs_root_kobj); ++ ++sysfs_root_add_error: ++ kobject_put(&scst_sysfs_root_kobj); ++ ++ kthread_stop(sysfs_work_thread); ++ ++ if (res == 0) ++ res = -EINVAL; ++ ++ goto out; ++} ++ ++void scst_sysfs_cleanup(void) ++{ ++ TRACE_ENTRY(); ++ ++ PRINT_INFO("%s", "Exiting SCST sysfs hierarchy..."); ++ ++ scst_del_put_sgv_kobj(); ++ ++ kobject_del(scst_devices_kobj); ++ kobject_put(scst_devices_kobj); ++ ++ kobject_del(scst_targets_kobj); ++ kobject_put(scst_targets_kobj); ++ ++ kobject_del(scst_handlers_kobj); ++ kobject_put(scst_handlers_kobj); ++ ++ sysfs_remove_files(scst_device_groups_kobj, scst_device_groups_attrs); ++ ++ kobject_del(scst_device_groups_kobj); ++ kobject_put(scst_device_groups_kobj); ++ ++ kobject_del(&scst_sysfs_root_kobj); ++ kobject_put(&scst_sysfs_root_kobj); ++ ++ wait_for_completion(&scst_sysfs_root_release_completion); ++ /* ++ * There is a race, when in the release() schedule happens just after ++ * calling complete(), so if we exit and unload scst module immediately, ++ * there will be oops there. So let's give it a chance to quit ++ * gracefully. Unfortunately, current kobjects implementation ++ * doesn't allow better ways to handle it. ++ */ ++ msleep(3000); ++ ++ if (sysfs_work_thread) ++ kthread_stop(sysfs_work_thread); ++ ++ PRINT_INFO("%s", "Exiting SCST sysfs hierarchy done"); ++ ++ TRACE_EXIT(); ++ return; ++} +diff -uprN orig/linux-3.2/include/scst/scst_debug.h linux-3.2/include/scst/scst_debug.h +--- orig/linux-3.2/include/scst/scst_debug.h ++++ linux-3.2/include/scst/scst_debug.h +@@ -0,0 +1,351 @@ ++/* ++ * include/scst_debug.h ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * Contains macros for execution tracing and error reporting ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#ifndef __SCST_DEBUG_H ++#define __SCST_DEBUG_H ++ ++#include <generated/autoconf.h> /* for CONFIG_* */ ++ ++#include <linux/bug.h> /* for WARN_ON_ONCE */ ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++#define EXTRACHECKS_BUG_ON(a) BUG_ON(a) ++#define EXTRACHECKS_WARN_ON(a) WARN_ON(a) ++#define EXTRACHECKS_WARN_ON_ONCE(a) WARN_ON_ONCE(a) ++#else ++#define EXTRACHECKS_BUG_ON(a) do { } while (0) ++#define EXTRACHECKS_WARN_ON(a) do { } while (0) ++#define EXTRACHECKS_WARN_ON_ONCE(a) do { } while (0) ++#endif ++ ++#define TRACE_NULL 0x00000000 ++#define TRACE_DEBUG 0x00000001 ++#define TRACE_FUNCTION 0x00000002 ++#define TRACE_LINE 0x00000004 ++#define TRACE_PID 0x00000008 ++#ifndef GENERATING_UPSTREAM_PATCH ++#define TRACE_ENTRYEXIT 0x00000010 ++#endif ++#define TRACE_BUFF 0x00000020 ++#define TRACE_MEMORY 0x00000040 ++#define TRACE_SG_OP 0x00000080 ++#define TRACE_OUT_OF_MEM 0x00000100 ++#define TRACE_MINOR 0x00000200 /* less important events */ ++#define TRACE_MGMT 0x00000400 ++#define TRACE_MGMT_DEBUG 0x00000800 ++#define TRACE_SCSI 0x00001000 ++#define TRACE_SPECIAL 0x00002000 /* filtering debug, etc */ ++#define TRACE_FLOW_CONTROL 0x00004000 /* flow control in action */ ++#define TRACE_PRES 0x00008000 ++#define TRACE_ALL 0xffffffff ++/* Flags 0xXXXX0000 are local for users */ ++ ++#define TRACE_MINOR_AND_MGMT_DBG (TRACE_MINOR|TRACE_MGMT_DEBUG) ++ ++#ifndef KERN_CONT ++#define KERN_CONT "" ++#endif ++ ++/* ++ * Note: in the next two printk() statements the KERN_CONT macro is only ++ * present to suppress a checkpatch warning (KERN_CONT is defined as ""). ++ */ ++#define PRINT(log_flag, format, args...) \ ++ printk(log_flag format "\n", ## args) ++#define PRINTN(log_flag, format, args...) \ ++ printk(log_flag format, ## args) ++ ++#ifdef LOG_PREFIX ++#define __LOG_PREFIX LOG_PREFIX ++#else ++#define __LOG_PREFIX NULL ++#endif ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ ++#ifndef CONFIG_SCST_DEBUG ++#define ___unlikely(a) (a) ++#else ++#define ___unlikely(a) unlikely(a) ++#endif ++ ++/* ++ * We don't print prefix for debug traces to not put additional pressure ++ * on the logging system in case of a lot of logging. ++ */ ++ ++int debug_print_prefix(unsigned long trace_flag, ++ const char *prefix, const char *func, int line); ++void debug_print_buffer(const void *data, int len); ++const char *debug_transport_id_to_initiator_name(const uint8_t *transport_id); ++ ++#define TRACING_MINOR() (trace_flag & TRACE_MINOR) ++ ++#define TRACE(trace, format, args...) \ ++do { \ ++ if (___unlikely(trace_flag & (trace))) { \ ++ debug_print_prefix(trace_flag, __LOG_PREFIX, \ ++ __func__, __LINE__); \ ++ PRINT(KERN_CONT, format, args); \ ++ } \ ++} while (0) ++ ++#ifdef CONFIG_SCST_DEBUG ++ ++#define PRINT_BUFFER(message, buff, len) \ ++do { \ ++ PRINT(KERN_INFO, "%s:%s:", __func__, message); \ ++ debug_print_buffer(buff, len); \ ++} while (0) ++ ++#else ++ ++#define PRINT_BUFFER(message, buff, len) \ ++do { \ ++ PRINT(KERN_INFO, "%s:", message); \ ++ debug_print_buffer(buff, len); \ ++} while (0) ++ ++#endif ++ ++#define PRINT_BUFF_FLAG(flag, message, buff, len) \ ++do { \ ++ if (___unlikely(trace_flag & (flag))) { \ ++ debug_print_prefix(trace_flag, NULL, __func__, __LINE__);\ ++ PRINT(KERN_CONT, "%s:", message); \ ++ debug_print_buffer(buff, len); \ ++ } \ ++} while (0) ++ ++#else /* CONFIG_SCST_DEBUG || CONFIG_SCST_TRACING */ ++ ++#define TRACING_MINOR() (false) ++ ++#define TRACE(trace, args...) do {} while (0) ++#define PRINT_BUFFER(message, buff, len) do {} while (0) ++#define PRINT_BUFF_FLAG(flag, message, buff, len) do {} while (0) ++ ++#endif /* defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) */ ++ ++#ifdef CONFIG_SCST_DEBUG ++ ++#define TRACE_DBG_FLAG(trace, format, args...) \ ++do { \ ++ if (trace_flag & (trace)) { \ ++ debug_print_prefix(trace_flag, NULL, __func__, __LINE__);\ ++ PRINT(KERN_CONT, format, args); \ ++ } \ ++} while (0) ++ ++#define TRACE_MEM(args...) TRACE_DBG_FLAG(TRACE_MEMORY, args) ++#define TRACE_SG(args...) TRACE_DBG_FLAG(TRACE_SG_OP, args) ++#define TRACE_DBG(args...) TRACE_DBG_FLAG(TRACE_DEBUG, args) ++#define TRACE_DBG_SPECIAL(args...) TRACE_DBG_FLAG(TRACE_DEBUG|TRACE_SPECIAL, args) ++#define TRACE_MGMT_DBG(args...) TRACE_DBG_FLAG(TRACE_MGMT_DEBUG, args) ++#define TRACE_MGMT_DBG_SPECIAL(args...) \ ++ TRACE_DBG_FLAG(TRACE_MGMT_DEBUG|TRACE_SPECIAL, args) ++#define TRACE_PR(args...) TRACE_DBG_FLAG(TRACE_PRES, args) ++ ++#define TRACE_BUFFER(message, buff, len) \ ++do { \ ++ if (trace_flag & TRACE_BUFF) { \ ++ debug_print_prefix(trace_flag, NULL, __func__, __LINE__);\ ++ PRINT(KERN_CONT, "%s:", message); \ ++ debug_print_buffer(buff, len); \ ++ } \ ++} while (0) ++ ++#define TRACE_BUFF_FLAG(flag, message, buff, len) \ ++do { \ ++ if (trace_flag & (flag)) { \ ++ debug_print_prefix(trace_flag, NULL, __func__, __LINE__);\ ++ PRINT(KERN_CONT, "%s:", message); \ ++ debug_print_buffer(buff, len); \ ++ } \ ++} while (0) ++ ++#define PRINT_LOG_FLAG(log_flag, format, args...) \ ++do { \ ++ debug_print_prefix(trace_flag, __LOG_PREFIX, __func__, __LINE__);\ ++ PRINT(KERN_CONT, format, args); \ ++} while (0) ++ ++#define PRINT_WARNING(format, args...) \ ++do { \ ++ debug_print_prefix(trace_flag, __LOG_PREFIX, __func__, __LINE__);\ ++ PRINT(KERN_CONT, "***WARNING***: " format, args); \ ++} while (0) ++ ++#define PRINT_ERROR(format, args...) \ ++do { \ ++ debug_print_prefix(trace_flag, __LOG_PREFIX, __func__, __LINE__);\ ++ PRINT(KERN_CONT, "***ERROR***: " format, args); \ ++} while (0) ++ ++#define PRINT_CRIT_ERROR(format, args...) \ ++do { \ ++ debug_print_prefix(trace_flag, __LOG_PREFIX, __func__, __LINE__);\ ++ PRINT(KERN_CONT, "***CRITICAL ERROR***: " format, args); \ ++} while (0) ++ ++#define PRINT_INFO(format, args...) \ ++do { \ ++ debug_print_prefix(trace_flag, __LOG_PREFIX, __func__, __LINE__);\ ++ PRINT(KERN_CONT, format, args); \ ++} while (0) ++ ++#ifndef GENERATING_UPSTREAM_PATCH ++#define TRACE_ENTRY() \ ++do { \ ++ if (trace_flag & TRACE_ENTRYEXIT) { \ ++ if (trace_flag & TRACE_PID) { \ ++ PRINT(KERN_INFO, "[%d]: ENTRY %s", current->pid, \ ++ __func__); \ ++ } \ ++ else { \ ++ PRINT(KERN_INFO, "ENTRY %s", __func__); \ ++ } \ ++ } \ ++} while (0) ++ ++#define TRACE_EXIT() \ ++do { \ ++ if (trace_flag & TRACE_ENTRYEXIT) { \ ++ if (trace_flag & TRACE_PID) { \ ++ PRINT(KERN_INFO, "[%d]: EXIT %s", current->pid, \ ++ __func__); \ ++ } \ ++ else { \ ++ PRINT(KERN_INFO, "EXIT %s", __func__); \ ++ } \ ++ } \ ++} while (0) ++ ++#define TRACE_EXIT_RES(res) \ ++do { \ ++ if (trace_flag & TRACE_ENTRYEXIT) { \ ++ if (trace_flag & TRACE_PID) { \ ++ PRINT(KERN_INFO, "[%d]: EXIT %s: %ld", current->pid, \ ++ __func__, (long)(res)); \ ++ } \ ++ else { \ ++ PRINT(KERN_INFO, "EXIT %s: %ld", \ ++ __func__, (long)(res)); \ ++ } \ ++ } \ ++} while (0) ++ ++#define TRACE_EXIT_HRES(res) \ ++do { \ ++ if (trace_flag & TRACE_ENTRYEXIT) { \ ++ if (trace_flag & TRACE_PID) { \ ++ PRINT(KERN_INFO, "[%d]: EXIT %s: 0x%lx", current->pid, \ ++ __func__, (long)(res)); \ ++ } \ ++ else { \ ++ PRINT(KERN_INFO, "EXIT %s: %lx", \ ++ __func__, (long)(res)); \ ++ } \ ++ } \ ++} while (0) ++#endif ++ ++#else /* CONFIG_SCST_DEBUG */ ++ ++#define TRACE_MEM(format, args...) do {} while (0) ++#define TRACE_SG(format, args...) do {} while (0) ++#define TRACE_DBG(format, args...) do {} while (0) ++#define TRACE_DBG_FLAG(format, args...) do {} while (0) ++#define TRACE_DBG_SPECIAL(format, args...) do {} while (0) ++#define TRACE_MGMT_DBG(format, args...) do {} while (0) ++#define TRACE_MGMT_DBG_SPECIAL(format, args...) do {} while (0) ++#define TRACE_PR(format, args...) do {} while (0) ++#define TRACE_BUFFER(message, buff, len) do {} while (0) ++#define TRACE_BUFF_FLAG(flag, message, buff, len) do {} while (0) ++ ++#ifndef GENERATING_UPSTREAM_PATCH ++#define TRACE_ENTRY() do {} while (0) ++#define TRACE_EXIT() do {} while (0) ++#define TRACE_EXIT_RES(res) do {} while (0) ++#define TRACE_EXIT_HRES(res) do {} while (0) ++#endif ++ ++#ifdef LOG_PREFIX ++ ++#define PRINT_INFO(format, args...) \ ++do { \ ++ PRINT(KERN_INFO, "%s: " format, LOG_PREFIX, args); \ ++} while (0) ++ ++#define PRINT_WARNING(format, args...) \ ++do { \ ++ PRINT(KERN_INFO, "%s: ***WARNING***: " \ ++ format, LOG_PREFIX, args); \ ++} while (0) ++ ++#define PRINT_ERROR(format, args...) \ ++do { \ ++ PRINT(KERN_INFO, "%s: ***ERROR***: " \ ++ format, LOG_PREFIX, args); \ ++} while (0) ++ ++#define PRINT_CRIT_ERROR(format, args...) \ ++do { \ ++ PRINT(KERN_INFO, "%s: ***CRITICAL ERROR***: " \ ++ format, LOG_PREFIX, args); \ ++} while (0) ++ ++#else ++ ++#define PRINT_INFO(format, args...) \ ++do { \ ++ PRINT(KERN_INFO, format, args); \ ++} while (0) ++ ++#define PRINT_WARNING(format, args...) \ ++do { \ ++ PRINT(KERN_INFO, "***WARNING***: " \ ++ format, args); \ ++} while (0) ++ ++#define PRINT_ERROR(format, args...) \ ++do { \ ++ PRINT(KERN_ERR, "***ERROR***: " \ ++ format, args); \ ++} while (0) ++ ++#define PRINT_CRIT_ERROR(format, args...) \ ++do { \ ++ PRINT(KERN_CRIT, "***CRITICAL ERROR***: " \ ++ format, args); \ ++} while (0) ++ ++#endif /* LOG_PREFIX */ ++ ++#endif /* CONFIG_SCST_DEBUG */ ++ ++#if defined(CONFIG_SCST_DEBUG) && defined(CONFIG_DEBUG_SLAB) ++#define SCST_SLAB_FLAGS (SLAB_RED_ZONE | SLAB_POISON) ++#else ++#define SCST_SLAB_FLAGS 0L ++#endif ++ ++#endif /* __SCST_DEBUG_H */ +diff -uprN orig/linux-3.2/drivers/scst/scst_debug.c linux-3.2/drivers/scst/scst_debug.c +--- orig/linux-3.2/drivers/scst/scst_debug.c ++++ linux-3.2/drivers/scst/scst_debug.c +@@ -0,0 +1,228 @@ ++/* ++ * scst_debug.c ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * Contains helper functions for execution tracing and error reporting. ++ * Intended to be included in main .c file. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/version.h> ++ ++#include <linux/export.h> ++ ++#include <scst/scst.h> ++#include <scst/scst_debug.h> ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ ++#define TRACE_BUF_SIZE 512 ++ ++static char trace_buf[TRACE_BUF_SIZE]; ++static DEFINE_SPINLOCK(trace_buf_lock); ++ ++static inline int get_current_tid(void) ++{ ++ /* Code should be the same as in sys_gettid() */ ++ if (in_interrupt()) { ++ /* ++ * Unfortunately, task_pid_vnr() isn't IRQ-safe, so otherwise ++ * it can oops. ToDo. ++ */ ++ return 0; ++ } ++ return task_pid_vnr(current); ++} ++ ++/** ++ * debug_print_prefix() - print debug prefix for a log line ++ * ++ * Prints, if requested by trace_flag, debug prefix for each log line ++ */ ++int debug_print_prefix(unsigned long trace_flag, ++ const char *prefix, const char *func, int line) ++{ ++ int i = 0; ++ unsigned long flags; ++ int pid = get_current_tid(); ++ ++ spin_lock_irqsave(&trace_buf_lock, flags); ++ ++ trace_buf[0] = '\0'; ++ ++ if (trace_flag & TRACE_PID) ++ i += snprintf(&trace_buf[i], TRACE_BUF_SIZE, "[%d]: ", pid); ++ if (prefix != NULL) ++ i += snprintf(&trace_buf[i], TRACE_BUF_SIZE - i, "%s: ", ++ prefix); ++ if (trace_flag & TRACE_FUNCTION) ++ i += snprintf(&trace_buf[i], TRACE_BUF_SIZE - i, "%s:", func); ++ if (trace_flag & TRACE_LINE) ++ i += snprintf(&trace_buf[i], TRACE_BUF_SIZE - i, "%i:", line); ++ ++ PRINTN(KERN_INFO, "%s", trace_buf); ++ ++ spin_unlock_irqrestore(&trace_buf_lock, flags); ++ ++ return i; ++} ++EXPORT_SYMBOL(debug_print_prefix); ++ ++/** ++ * debug_print_buffer() - print a buffer ++ * ++ * Prints in the log data from the buffer ++ */ ++void debug_print_buffer(const void *data, int len) ++{ ++ int z, z1, i; ++ const unsigned char *buf = (const unsigned char *) data; ++ unsigned long flags; ++ ++ if (buf == NULL) ++ return; ++ ++ spin_lock_irqsave(&trace_buf_lock, flags); ++ ++ PRINT(KERN_INFO, " (h)___0__1__2__3__4__5__6__7__8__9__A__B__C__D__E__F"); ++ for (z = 0, z1 = 0, i = 0; z < len; z++) { ++ if (z % 16 == 0) { ++ if (z != 0) { ++ i += snprintf(&trace_buf[i], TRACE_BUF_SIZE - i, ++ " "); ++ for (; (z1 < z) && (i < TRACE_BUF_SIZE - 1); ++ z1++) { ++ if ((buf[z1] >= 0x20) && ++ (buf[z1] < 0x80)) ++ trace_buf[i++] = buf[z1]; ++ else ++ trace_buf[i++] = '.'; ++ } ++ trace_buf[i] = '\0'; ++ PRINT(KERN_INFO, "%s", trace_buf); ++ i = 0; ++ } ++ i += snprintf(&trace_buf[i], TRACE_BUF_SIZE - i, ++ "%4x: ", z); ++ } ++ i += snprintf(&trace_buf[i], TRACE_BUF_SIZE - i, "%02x ", ++ buf[z]); ++ } ++ ++ i += snprintf(&trace_buf[i], TRACE_BUF_SIZE - i, " "); ++ for (; (z1 < z) && (i < TRACE_BUF_SIZE - 1); z1++) { ++ if ((buf[z1] > 0x20) && (buf[z1] < 0x80)) ++ trace_buf[i++] = buf[z1]; ++ else ++ trace_buf[i++] = '.'; ++ } ++ trace_buf[i] = '\0'; ++ ++ PRINT(KERN_INFO, "%s", trace_buf); ++ ++ spin_unlock_irqrestore(&trace_buf_lock, flags); ++ return; ++} ++EXPORT_SYMBOL(debug_print_buffer); ++ ++/* ++ * This function converts transport_id in a string form into internal per-CPU ++ * static buffer. This buffer isn't anyhow protected, because it's acceptable ++ * if the name corrupted in the debug logs because of the race for this buffer. ++ * ++ * Note! You can't call this function 2 or more times in a single logging ++ * (printk) statement, because then each new call of this function will override ++ * data written in this buffer by the previous call. You should instead split ++ * that logging statement on smaller statements each calling ++ * debug_transport_id_to_initiator_name() only once. ++ */ ++const char *debug_transport_id_to_initiator_name(const uint8_t *transport_id) ++{ ++ /* ++ * No external protection, because it's acceptable if the name ++ * corrupted in the debug logs because of the race for this ++ * buffer. ++ */ ++#define SIZEOF_NAME_BUF 256 ++ static char name_bufs[NR_CPUS][SIZEOF_NAME_BUF]; ++ char *name_buf; ++ unsigned long flags; ++ ++ BUG_ON(transport_id == NULL); /* better to catch it not under lock */ ++ ++ spin_lock_irqsave(&trace_buf_lock, flags); ++ ++ name_buf = name_bufs[smp_processor_id()]; ++ ++ /* ++ * To prevent external racing with us users from accidentally ++ * missing their NULL terminator. ++ */ ++ memset(name_buf, 0, SIZEOF_NAME_BUF); ++ smp_mb(); ++ ++ switch (transport_id[0] & 0x0f) { ++ case SCSI_TRANSPORTID_PROTOCOLID_ISCSI: ++ scnprintf(name_buf, SIZEOF_NAME_BUF, "%s", ++ &transport_id[4]); ++ break; ++ case SCSI_TRANSPORTID_PROTOCOLID_FCP2: ++ scnprintf(name_buf, SIZEOF_NAME_BUF, ++ "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", ++ transport_id[8], transport_id[9], ++ transport_id[10], transport_id[11], ++ transport_id[12], transport_id[13], ++ transport_id[14], transport_id[15]); ++ break; ++ case SCSI_TRANSPORTID_PROTOCOLID_SPI5: ++ scnprintf(name_buf, SIZEOF_NAME_BUF, ++ "%x:%x", be16_to_cpu((__force __be16)transport_id[2]), ++ be16_to_cpu((__force __be16)transport_id[6])); ++ break; ++ case SCSI_TRANSPORTID_PROTOCOLID_SRP: ++ scnprintf(name_buf, SIZEOF_NAME_BUF, ++ "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x" ++ ":%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", ++ transport_id[8], transport_id[9], ++ transport_id[10], transport_id[11], ++ transport_id[12], transport_id[13], ++ transport_id[14], transport_id[15], ++ transport_id[16], transport_id[17], ++ transport_id[18], transport_id[19], ++ transport_id[20], transport_id[21], ++ transport_id[22], transport_id[23]); ++ break; ++ case SCSI_TRANSPORTID_PROTOCOLID_SAS: ++ scnprintf(name_buf, SIZEOF_NAME_BUF, ++ "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", ++ transport_id[4], transport_id[5], ++ transport_id[6], transport_id[7], ++ transport_id[8], transport_id[9], ++ transport_id[10], transport_id[11]); ++ break; ++ default: ++ scnprintf(name_buf, SIZEOF_NAME_BUF, ++ "(Not known protocol ID %x)", transport_id[0] & 0x0f); ++ break; ++ } ++ ++ spin_unlock_irqrestore(&trace_buf_lock, flags); ++ ++ return name_buf; ++#undef SIZEOF_NAME_BUF ++} ++ ++#endif /* defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) */ +diff -uprN orig/linux-3.2/include/scst/scst_sgv.h linux-3.2/include/scst/scst_sgv.h +--- orig/linux-3.2/include/scst/scst_sgv.h ++++ linux-3.2/include/scst/scst_sgv.h +@@ -0,0 +1,98 @@ ++/* ++ * include/scst_sgv.h ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * Include file for SCST SGV cache. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++#ifndef __SCST_SGV_H ++#define __SCST_SGV_H ++ ++/** SGV pool routines and flag bits **/ ++ ++/* Set if the allocated object must be not from the cache */ ++#define SGV_POOL_ALLOC_NO_CACHED 1 ++ ++/* Set if there should not be any memory allocations on a cache miss */ ++#define SGV_POOL_NO_ALLOC_ON_CACHE_MISS 2 ++ ++/* Set an object should be returned even if it doesn't have SG vector built */ ++#define SGV_POOL_RETURN_OBJ_ON_ALLOC_FAIL 4 ++ ++/* ++ * Set if the allocated object must be a new one, i.e. from the cache, ++ * but not cached ++ */ ++#define SGV_POOL_ALLOC_GET_NEW 8 ++ ++struct sgv_pool_obj; ++struct sgv_pool; ++ ++/* ++ * Structure to keep a memory limit for an SCST object ++ */ ++struct scst_mem_lim { ++ /* How much memory allocated under this object */ ++ atomic_t alloced_pages; ++ ++ /* ++ * How much memory allowed to allocated under this object. Put here ++ * mostly to save a possible cache miss accessing scst_max_dev_cmd_mem. ++ */ ++ int max_allowed_pages; ++}; ++ ++/* Types of clustering */ ++enum sgv_clustering_types { ++ /* No clustering performed */ ++ sgv_no_clustering = 0, ++ ++ /* ++ * A page will only be merged with the latest previously allocated ++ * page, so the order of pages in the SG will be preserved. ++ */ ++ sgv_tail_clustering, ++ ++ /* ++ * Free merging of pages at any place in the SG is allowed. This mode ++ * usually provides the best merging rate. ++ */ ++ sgv_full_clustering, ++}; ++ ++struct sgv_pool *sgv_pool_create(const char *name, ++ enum sgv_clustering_types clustered, int single_alloc_pages, ++ bool shared, int purge_interval); ++void sgv_pool_del(struct sgv_pool *pool); ++ ++void sgv_pool_get(struct sgv_pool *pool); ++void sgv_pool_put(struct sgv_pool *pool); ++ ++void sgv_pool_flush(struct sgv_pool *pool); ++ ++void sgv_pool_set_allocator(struct sgv_pool *pool, ++ struct page *(*alloc_pages_fn)(struct scatterlist *, gfp_t, void *), ++ void (*free_pages_fn)(struct scatterlist *, int, void *)); ++ ++struct scatterlist *sgv_pool_alloc(struct sgv_pool *pool, unsigned int size, ++ gfp_t gfp_mask, int flags, int *count, ++ struct sgv_pool_obj **sgv, struct scst_mem_lim *mem_lim, void *priv); ++void sgv_pool_free(struct sgv_pool_obj *sgv, struct scst_mem_lim *mem_lim); ++ ++void *sgv_get_priv(struct sgv_pool_obj *sgv); ++ ++void scst_init_mem_lim(struct scst_mem_lim *mem_lim); ++ ++#endif /* __SCST_SGV_H */ +diff -uprN orig/linux-3.2/drivers/scst/scst_mem.h linux-3.2/drivers/scst/scst_mem.h +--- orig/linux-3.2/drivers/scst/scst_mem.h ++++ linux-3.2/drivers/scst/scst_mem.h +@@ -0,0 +1,142 @@ ++/* ++ * scst_mem.h ++ * ++ * Copyright (C) 2006 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/scatterlist.h> ++#include <linux/workqueue.h> ++ ++#define SGV_POOL_ELEMENTS 11 ++ ++/* ++ * sg_num is indexed by the page number, pg_count is indexed by the sg number. ++ * Made in one entry to simplify the code (eg all sizeof(*) parts) and save ++ * some CPU cache for non-clustered case. ++ */ ++struct trans_tbl_ent { ++ unsigned short sg_num; ++ unsigned short pg_count; ++}; ++ ++/* ++ * SGV pool object ++ */ ++struct sgv_pool_obj { ++ int cache_num; ++ int pages; ++ ++ /* jiffies, protected by sgv_pool_lock */ ++ unsigned long time_stamp; ++ ++ struct list_head recycling_list_entry; ++ struct list_head sorted_recycling_list_entry; ++ ++ struct sgv_pool *owner_pool; ++ int orig_sg; ++ int orig_length; ++ int sg_count; ++ void *allocator_priv; ++ struct trans_tbl_ent *trans_tbl; ++ struct scatterlist *sg_entries; ++ struct scatterlist sg_entries_data[0]; ++}; ++ ++/* ++ * SGV pool statistics accounting structure ++ */ ++struct sgv_pool_cache_acc { ++ atomic_t total_alloc, hit_alloc; ++ atomic_t merged; ++}; ++ ++/* ++ * SGV pool allocation functions ++ */ ++struct sgv_pool_alloc_fns { ++ struct page *(*alloc_pages_fn)(struct scatterlist *sg, gfp_t gfp_mask, ++ void *priv); ++ void (*free_pages_fn)(struct scatterlist *sg, int sg_count, ++ void *priv); ++}; ++ ++/* ++ * SGV pool ++ */ ++struct sgv_pool { ++ enum sgv_clustering_types clustering_type; ++ int single_alloc_pages; ++ int max_cached_pages; ++ ++ struct sgv_pool_alloc_fns alloc_fns; ++ ++ /* <=4K, <=8, <=16, <=32, <=64, <=128, <=256, <=512, <=1024, <=2048 */ ++ struct kmem_cache *caches[SGV_POOL_ELEMENTS]; ++ ++ spinlock_t sgv_pool_lock; /* outer lock for sgv_pools_lock! */ ++ ++ int purge_interval; ++ ++ /* Protected by sgv_pool_lock, if necessary */ ++ unsigned int purge_work_scheduled:1; ++ ++ /* Protected by sgv_pool_lock */ ++ struct list_head sorted_recycling_list; ++ ++ int inactive_cached_pages; /* protected by sgv_pool_lock */ ++ ++ /* Protected by sgv_pool_lock */ ++ struct list_head recycling_lists[SGV_POOL_ELEMENTS]; ++ ++ int cached_pages, cached_entries; /* protected by sgv_pool_lock */ ++ ++ struct sgv_pool_cache_acc cache_acc[SGV_POOL_ELEMENTS]; ++ ++ struct delayed_work sgv_purge_work; ++ ++ struct list_head sgv_active_pools_list_entry; ++ ++ atomic_t big_alloc, big_pages, big_merged; ++ atomic_t other_alloc, other_pages, other_merged; ++ ++ atomic_t sgv_pool_ref; ++ ++ int max_caches; ++ ++ /* SCST_MAX_NAME + few more bytes to match scst_user expectations */ ++ char cache_names[SGV_POOL_ELEMENTS][SCST_MAX_NAME + 10]; ++ char name[SCST_MAX_NAME + 10]; ++ ++ struct mm_struct *owner_mm; ++ ++ struct list_head sgv_pools_list_entry; ++ ++ struct kobject sgv_kobj; ++ ++ /* sysfs release completion */ ++ struct completion *sgv_kobj_release_cmpl; ++}; ++ ++static inline struct scatterlist *sgv_pool_sg(struct sgv_pool_obj *obj) ++{ ++ return obj->sg_entries; ++} ++ ++int scst_sgv_pools_init(unsigned long mem_hwmark, unsigned long mem_lwmark); ++void scst_sgv_pools_deinit(void); ++ ++void scst_sgv_pool_use_norm(struct scst_tgt_dev *tgt_dev); ++void scst_sgv_pool_use_norm_clust(struct scst_tgt_dev *tgt_dev); ++void scst_sgv_pool_use_dma(struct scst_tgt_dev *tgt_dev); +diff -uprN orig/linux-3.2/drivers/scst/scst_mem.c linux-3.2/drivers/scst/scst_mem.c +--- orig/linux-3.2/drivers/scst/scst_mem.c ++++ linux-3.2/drivers/scst/scst_mem.c +@@ -0,0 +1,2002 @@ ++/* ++ * scst_mem.c ++ * ++ * Copyright (C) 2006 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/init.h> ++#include <linux/kernel.h> ++#include <linux/errno.h> ++#include <linux/list.h> ++#include <linux/spinlock.h> ++#include <linux/slab.h> ++#include <linux/sched.h> ++#include <linux/mm.h> ++#include <linux/unistd.h> ++#include <linux/string.h> ++ ++#include <scst/scst.h> ++#include "scst_priv.h" ++#include "scst_mem.h" ++ ++#define SGV_DEFAULT_PURGE_INTERVAL (60 * HZ) ++#define SGV_MIN_SHRINK_INTERVAL (1 * HZ) ++ ++/* Max pages freed from a pool per shrinking iteration */ ++#define MAX_PAGES_PER_POOL 50 ++ ++static struct sgv_pool *sgv_norm_clust_pool, *sgv_norm_pool, *sgv_dma_pool; ++ ++static atomic_t sgv_pages_total = ATOMIC_INIT(0); ++ ++/* Both read-only */ ++static int sgv_hi_wmk; ++static int sgv_lo_wmk; ++ ++static int sgv_max_local_pages, sgv_max_trans_pages; ++ ++static DEFINE_SPINLOCK(sgv_pools_lock); /* inner lock for sgv_pool_lock! */ ++static DEFINE_MUTEX(sgv_pools_mutex); ++ ++/* Both protected by sgv_pools_lock */ ++static struct sgv_pool *sgv_cur_purge_pool; ++static LIST_HEAD(sgv_active_pools_list); ++ ++static atomic_t sgv_releases_on_hiwmk = ATOMIC_INIT(0); ++static atomic_t sgv_releases_on_hiwmk_failed = ATOMIC_INIT(0); ++ ++static atomic_t sgv_other_total_alloc = ATOMIC_INIT(0); ++ ++static struct shrinker sgv_shrinker; ++ ++/* ++ * Protected by sgv_pools_mutex AND sgv_pools_lock for writes, ++ * either one for reads. ++ */ ++static LIST_HEAD(sgv_pools_list); ++ ++static struct kobject *scst_sgv_kobj; ++static int scst_sgv_sysfs_create(struct sgv_pool *pool); ++static void scst_sgv_sysfs_del(struct sgv_pool *pool); ++ ++static inline bool sgv_pool_clustered(const struct sgv_pool *pool) ++{ ++ return pool->clustering_type != sgv_no_clustering; ++} ++ ++void scst_sgv_pool_use_norm(struct scst_tgt_dev *tgt_dev) ++{ ++ tgt_dev->gfp_mask = __GFP_NOWARN; ++ tgt_dev->pool = sgv_norm_pool; ++ clear_bit(SCST_TGT_DEV_CLUST_POOL, &tgt_dev->tgt_dev_flags); ++} ++ ++void scst_sgv_pool_use_norm_clust(struct scst_tgt_dev *tgt_dev) ++{ ++ TRACE_MEM("%s", "Use clustering"); ++ tgt_dev->gfp_mask = __GFP_NOWARN; ++ tgt_dev->pool = sgv_norm_clust_pool; ++ set_bit(SCST_TGT_DEV_CLUST_POOL, &tgt_dev->tgt_dev_flags); ++} ++ ++void scst_sgv_pool_use_dma(struct scst_tgt_dev *tgt_dev) ++{ ++ TRACE_MEM("%s", "Use ISA DMA memory"); ++ tgt_dev->gfp_mask = __GFP_NOWARN | GFP_DMA; ++ tgt_dev->pool = sgv_dma_pool; ++ clear_bit(SCST_TGT_DEV_CLUST_POOL, &tgt_dev->tgt_dev_flags); ++} ++ ++/* Must be no locks */ ++static void sgv_dtor_and_free(struct sgv_pool_obj *obj) ++{ ++ struct sgv_pool *pool = obj->owner_pool; ++ ++ TRACE_MEM("Destroying sgv obj %p", obj); ++ ++ if (obj->sg_count != 0) { ++ pool->alloc_fns.free_pages_fn(obj->sg_entries, ++ obj->sg_count, obj->allocator_priv); ++ } ++ if (obj->sg_entries != obj->sg_entries_data) { ++ if (obj->trans_tbl != ++ (struct trans_tbl_ent *)obj->sg_entries_data) { ++ /* kfree() handles NULL parameter */ ++ kfree(obj->trans_tbl); ++ obj->trans_tbl = NULL; ++ } ++ kfree(obj->sg_entries); ++ } ++ ++ kmem_cache_free(pool->caches[obj->cache_num], obj); ++ return; ++} ++ ++/* Might be called under sgv_pool_lock */ ++static inline void sgv_del_from_active(struct sgv_pool *pool) ++{ ++ struct list_head *next; ++ ++ TRACE_MEM("Deleting sgv pool %p from the active list", pool); ++ ++ spin_lock_bh(&sgv_pools_lock); ++ ++ next = pool->sgv_active_pools_list_entry.next; ++ list_del(&pool->sgv_active_pools_list_entry); ++ ++ if (sgv_cur_purge_pool == pool) { ++ TRACE_MEM("Sgv pool %p is sgv cur purge pool", pool); ++ ++ if (next == &sgv_active_pools_list) ++ next = next->next; ++ ++ if (next == &sgv_active_pools_list) { ++ sgv_cur_purge_pool = NULL; ++ TRACE_MEM("%s", "Sgv active list now empty"); ++ } else { ++ sgv_cur_purge_pool = list_entry(next, typeof(*pool), ++ sgv_active_pools_list_entry); ++ TRACE_MEM("New sgv cur purge pool %p", ++ sgv_cur_purge_pool); ++ } ++ } ++ ++ spin_unlock_bh(&sgv_pools_lock); ++ return; ++} ++ ++/* Must be called under sgv_pool_lock held */ ++static void sgv_dec_cached_entries(struct sgv_pool *pool, int pages) ++{ ++ pool->cached_entries--; ++ pool->cached_pages -= pages; ++ ++ if (pool->cached_entries == 0) ++ sgv_del_from_active(pool); ++ ++ return; ++} ++ ++/* Must be called under sgv_pool_lock held */ ++static void __sgv_purge_from_cache(struct sgv_pool_obj *obj) ++{ ++ int pages = obj->pages; ++ struct sgv_pool *pool = obj->owner_pool; ++ ++ TRACE_MEM("Purging sgv obj %p from pool %p (new cached_entries %d)", ++ obj, pool, pool->cached_entries-1); ++ ++ list_del(&obj->sorted_recycling_list_entry); ++ list_del(&obj->recycling_list_entry); ++ ++ pool->inactive_cached_pages -= pages; ++ sgv_dec_cached_entries(pool, pages); ++ ++ atomic_sub(pages, &sgv_pages_total); ++ ++ return; ++} ++ ++/* Must be called under sgv_pool_lock held */ ++static bool sgv_purge_from_cache(struct sgv_pool_obj *obj, int min_interval, ++ unsigned long cur_time) ++{ ++ EXTRACHECKS_BUG_ON(min_interval < 0); ++ ++ TRACE_MEM("Checking if sgv obj %p should be purged (cur time %ld, " ++ "obj time %ld, time to purge %ld)", obj, cur_time, ++ obj->time_stamp, obj->time_stamp + min_interval); ++ ++ if (time_after_eq(cur_time, (obj->time_stamp + min_interval))) { ++ __sgv_purge_from_cache(obj); ++ return true; ++ } ++ return false; ++} ++ ++/* No locks */ ++static int sgv_shrink_pool(struct sgv_pool *pool, int nr, int min_interval, ++ unsigned long cur_time) ++{ ++ int freed = 0; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MEM("Trying to shrink pool %p (nr %d, min_interval %d)", ++ pool, nr, min_interval); ++ ++ if (pool->purge_interval < 0) { ++ TRACE_MEM("Not shrinkable pool %p, skipping", pool); ++ goto out; ++ } ++ ++ spin_lock_bh(&pool->sgv_pool_lock); ++ ++ while (!list_empty(&pool->sorted_recycling_list) && ++ (atomic_read(&sgv_pages_total) > sgv_lo_wmk)) { ++ struct sgv_pool_obj *obj = list_entry( ++ pool->sorted_recycling_list.next, ++ struct sgv_pool_obj, sorted_recycling_list_entry); ++ ++ if (sgv_purge_from_cache(obj, min_interval, cur_time)) { ++ int pages = obj->pages; ++ ++ freed += pages; ++ nr -= pages; ++ ++ TRACE_MEM("%d pages purged from pool %p (nr left %d, " ++ "total freed %d)", pages, pool, nr, freed); ++ ++ spin_unlock_bh(&pool->sgv_pool_lock); ++ sgv_dtor_and_free(obj); ++ spin_lock_bh(&pool->sgv_pool_lock); ++ } else ++ break; ++ ++ if ((nr <= 0) || (freed >= MAX_PAGES_PER_POOL)) { ++ if (freed >= MAX_PAGES_PER_POOL) ++ TRACE_MEM("%d pages purged from pool %p, " ++ "leaving", freed, pool); ++ break; ++ } ++ } ++ ++ spin_unlock_bh(&pool->sgv_pool_lock); ++ ++out: ++ TRACE_EXIT_RES(nr); ++ return nr; ++} ++ ++/* No locks */ ++static int __sgv_shrink(int nr, int min_interval) ++{ ++ struct sgv_pool *pool; ++ unsigned long cur_time = jiffies; ++ int prev_nr = nr; ++ bool circle = false; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MEM("Trying to shrink %d pages from all sgv pools " ++ "(min_interval %d)", nr, min_interval); ++ ++ while (nr > 0) { ++ struct list_head *next; ++ ++ spin_lock_bh(&sgv_pools_lock); ++ ++ pool = sgv_cur_purge_pool; ++ if (pool == NULL) { ++ if (list_empty(&sgv_active_pools_list)) { ++ TRACE_MEM("%s", "Active pools list is empty"); ++ goto out_unlock; ++ } ++ ++ pool = list_entry(sgv_active_pools_list.next, ++ typeof(*pool), ++ sgv_active_pools_list_entry); ++ } ++ sgv_pool_get(pool); ++ ++ next = pool->sgv_active_pools_list_entry.next; ++ if (next == &sgv_active_pools_list) { ++ if (circle && (prev_nr == nr)) { ++ TRACE_MEM("Full circle done, but no progress, " ++ "leaving (nr %d)", nr); ++ goto out_unlock_put; ++ } ++ circle = true; ++ prev_nr = nr; ++ ++ next = next->next; ++ } ++ ++ sgv_cur_purge_pool = list_entry(next, typeof(*pool), ++ sgv_active_pools_list_entry); ++ TRACE_MEM("New cur purge pool %p", sgv_cur_purge_pool); ++ ++ spin_unlock_bh(&sgv_pools_lock); ++ ++ nr = sgv_shrink_pool(pool, nr, min_interval, cur_time); ++ ++ sgv_pool_put(pool); ++ } ++ ++out: ++ TRACE_EXIT_RES(nr); ++ return nr; ++ ++out_unlock: ++ spin_unlock_bh(&sgv_pools_lock); ++ goto out; ++ ++out_unlock_put: ++ spin_unlock_bh(&sgv_pools_lock); ++ sgv_pool_put(pool); ++ goto out; ++} ++ ++static int sgv_shrink(struct shrinker *shrinker, struct shrink_control *sc) ++{ ++ int nr = sc->nr_to_scan; ++ ++ TRACE_ENTRY(); ++ ++ if (nr > 0) { ++ nr = __sgv_shrink(nr, SGV_MIN_SHRINK_INTERVAL); ++ TRACE_MEM("Left %d", nr); ++ } else { ++ struct sgv_pool *pool; ++ int inactive_pages = 0; ++ ++ spin_lock_bh(&sgv_pools_lock); ++ list_for_each_entry(pool, &sgv_active_pools_list, ++ sgv_active_pools_list_entry) { ++ if (pool->purge_interval > 0) ++ inactive_pages += pool->inactive_cached_pages; ++ } ++ spin_unlock_bh(&sgv_pools_lock); ++ ++ nr = max((int)0, inactive_pages - sgv_lo_wmk); ++ TRACE_MEM("Can free %d (total %d)", nr, ++ atomic_read(&sgv_pages_total)); ++ } ++ ++ TRACE_EXIT_RES(nr); ++ return nr; ++} ++ ++static void sgv_purge_work_fn(struct delayed_work *work) ++{ ++ unsigned long cur_time = jiffies; ++ struct sgv_pool *pool = container_of(work, struct sgv_pool, ++ sgv_purge_work); ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MEM("Purge work for pool %p", pool); ++ ++ spin_lock_bh(&pool->sgv_pool_lock); ++ ++ pool->purge_work_scheduled = false; ++ ++ while (!list_empty(&pool->sorted_recycling_list)) { ++ struct sgv_pool_obj *obj = list_entry( ++ pool->sorted_recycling_list.next, ++ struct sgv_pool_obj, sorted_recycling_list_entry); ++ ++ if (sgv_purge_from_cache(obj, pool->purge_interval, cur_time)) { ++ spin_unlock_bh(&pool->sgv_pool_lock); ++ sgv_dtor_and_free(obj); ++ spin_lock_bh(&pool->sgv_pool_lock); ++ } else { ++ /* ++ * Let's reschedule it for full period to not get here ++ * too often. In the worst case we have shrinker ++ * to reclaim buffers more quickly. ++ */ ++ TRACE_MEM("Rescheduling purge work for pool %p (delay " ++ "%d HZ/%d sec)", pool, pool->purge_interval, ++ pool->purge_interval/HZ); ++ schedule_delayed_work(&pool->sgv_purge_work, ++ pool->purge_interval); ++ pool->purge_work_scheduled = true; ++ break; ++ } ++ } ++ ++ spin_unlock_bh(&pool->sgv_pool_lock); ++ ++ TRACE_MEM("Leaving purge work for pool %p", pool); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int sgv_check_full_clustering(struct scatterlist *sg, int cur, int hint) ++{ ++ int res = -1; ++ int i = hint; ++ unsigned long pfn_cur = page_to_pfn(sg_page(&sg[cur])); ++ int len_cur = sg[cur].length; ++ unsigned long pfn_cur_next = pfn_cur + (len_cur >> PAGE_SHIFT); ++ int full_page_cur = (len_cur & (PAGE_SIZE - 1)) == 0; ++ unsigned long pfn, pfn_next; ++ bool full_page; ++ ++#if 0 ++ TRACE_MEM("pfn_cur %ld, pfn_cur_next %ld, len_cur %d, full_page_cur %d", ++ pfn_cur, pfn_cur_next, len_cur, full_page_cur); ++#endif ++ ++ /* check the hint first */ ++ if (i >= 0) { ++ pfn = page_to_pfn(sg_page(&sg[i])); ++ pfn_next = pfn + (sg[i].length >> PAGE_SHIFT); ++ full_page = (sg[i].length & (PAGE_SIZE - 1)) == 0; ++ ++ if ((pfn == pfn_cur_next) && full_page_cur) ++ goto out_head; ++ ++ if ((pfn_next == pfn_cur) && full_page) ++ goto out_tail; ++ } ++ ++ /* ToDo: implement more intelligent search */ ++ for (i = cur - 1; i >= 0; i--) { ++ pfn = page_to_pfn(sg_page(&sg[i])); ++ pfn_next = pfn + (sg[i].length >> PAGE_SHIFT); ++ full_page = (sg[i].length & (PAGE_SIZE - 1)) == 0; ++ ++ if ((pfn == pfn_cur_next) && full_page_cur) ++ goto out_head; ++ ++ if ((pfn_next == pfn_cur) && full_page) ++ goto out_tail; ++ } ++ ++out: ++ return res; ++ ++out_tail: ++ TRACE_MEM("SG segment %d will be tail merged with segment %d", cur, i); ++ sg[i].length += len_cur; ++ sg_clear(&sg[cur]); ++ res = i; ++ goto out; ++ ++out_head: ++ TRACE_MEM("SG segment %d will be head merged with segment %d", cur, i); ++ sg_assign_page(&sg[i], sg_page(&sg[cur])); ++ sg[i].length += len_cur; ++ sg_clear(&sg[cur]); ++ res = i; ++ goto out; ++} ++ ++static int sgv_check_tail_clustering(struct scatterlist *sg, int cur, int hint) ++{ ++ int res = -1; ++ unsigned long pfn_cur = page_to_pfn(sg_page(&sg[cur])); ++ int len_cur = sg[cur].length; ++ int prev; ++ unsigned long pfn_prev; ++ bool full_page; ++ ++#ifdef SCST_HIGHMEM ++ if (page >= highmem_start_page) { ++ TRACE_MEM("%s", "HIGHMEM page allocated, no clustering") ++ goto out; ++ } ++#endif ++ ++#if 0 ++ TRACE_MEM("pfn_cur %ld, pfn_cur_next %ld, len_cur %d, full_page_cur %d", ++ pfn_cur, pfn_cur_next, len_cur, full_page_cur); ++#endif ++ ++ if (cur == 0) ++ goto out; ++ ++ prev = cur - 1; ++ pfn_prev = page_to_pfn(sg_page(&sg[prev])) + ++ (sg[prev].length >> PAGE_SHIFT); ++ full_page = (sg[prev].length & (PAGE_SIZE - 1)) == 0; ++ ++ if ((pfn_prev == pfn_cur) && full_page) { ++ TRACE_MEM("SG segment %d will be tail merged with segment %d", ++ cur, prev); ++ sg[prev].length += len_cur; ++ sg_clear(&sg[cur]); ++ res = prev; ++ } ++ ++out: ++ return res; ++} ++ ++static void sgv_free_sys_sg_entries(struct scatterlist *sg, int sg_count, ++ void *priv) ++{ ++ int i; ++ ++ TRACE_MEM("sg=%p, sg_count=%d", sg, sg_count); ++ ++ for (i = 0; i < sg_count; i++) { ++ struct page *p = sg_page(&sg[i]); ++ int len = sg[i].length; ++ int pages = ++ (len >> PAGE_SHIFT) + ((len & ~PAGE_MASK) != 0); ++ ++ TRACE_MEM("page %lx, len %d, pages %d", ++ (unsigned long)p, len, pages); ++ ++ while (pages > 0) { ++ int order = 0; ++ ++ TRACE_MEM("free_pages(): order %d, page %lx", ++ order, (unsigned long)p); ++ ++ __free_pages(p, order); ++ ++ pages -= 1 << order; ++ p += 1 << order; ++ } ++ } ++} ++ ++static struct page *sgv_alloc_sys_pages(struct scatterlist *sg, ++ gfp_t gfp_mask, void *priv) ++{ ++ struct page *page = alloc_pages(gfp_mask, 0); ++ ++ sg_set_page(sg, page, PAGE_SIZE, 0); ++ TRACE_MEM("page=%p, sg=%p, priv=%p", page, sg, priv); ++ if (page == NULL) { ++ TRACE(TRACE_OUT_OF_MEM, "%s", "Allocation of " ++ "sg page failed"); ++ } ++ return page; ++} ++ ++static int sgv_alloc_sg_entries(struct scatterlist *sg, int pages, ++ gfp_t gfp_mask, enum sgv_clustering_types clustering_type, ++ struct trans_tbl_ent *trans_tbl, ++ const struct sgv_pool_alloc_fns *alloc_fns, void *priv) ++{ ++ int sg_count = 0; ++ int pg, i, j; ++ int merged = -1; ++ ++ TRACE_MEM("pages=%d, clustering_type=%d", pages, clustering_type); ++ ++#if 0 ++ gfp_mask |= __GFP_COLD; ++#endif ++#ifdef CONFIG_SCST_STRICT_SECURITY ++ gfp_mask |= __GFP_ZERO; ++#endif ++ ++ for (pg = 0; pg < pages; pg++) { ++ void *rc; ++#ifdef CONFIG_SCST_DEBUG_OOM ++ if (((gfp_mask & __GFP_NOFAIL) != __GFP_NOFAIL) && ++ ((scst_random() % 10000) == 55)) ++ rc = NULL; ++ else ++#endif ++ rc = alloc_fns->alloc_pages_fn(&sg[sg_count], gfp_mask, ++ priv); ++ if (rc == NULL) ++ goto out_no_mem; ++ ++ /* ++ * This code allows compiler to see full body of the clustering ++ * functions and gives it a chance to generate better code. ++ * At least, the resulting code is smaller, comparing to ++ * calling them using a function pointer. ++ */ ++ if (clustering_type == sgv_full_clustering) ++ merged = sgv_check_full_clustering(sg, sg_count, merged); ++ else if (clustering_type == sgv_tail_clustering) ++ merged = sgv_check_tail_clustering(sg, sg_count, merged); ++ else ++ merged = -1; ++ ++ if (merged == -1) ++ sg_count++; ++ ++ TRACE_MEM("pg=%d, merged=%d, sg_count=%d", pg, merged, ++ sg_count); ++ } ++ ++ if ((clustering_type != sgv_no_clustering) && (trans_tbl != NULL)) { ++ pg = 0; ++ for (i = 0; i < pages; i++) { ++ int n = (sg[i].length >> PAGE_SHIFT) + ++ ((sg[i].length & ~PAGE_MASK) != 0); ++ trans_tbl[i].pg_count = pg; ++ for (j = 0; j < n; j++) ++ trans_tbl[pg++].sg_num = i+1; ++ TRACE_MEM("i=%d, n=%d, pg_count=%d", i, n, ++ trans_tbl[i].pg_count); ++ } ++ } ++ ++out: ++ TRACE_MEM("sg_count=%d", sg_count); ++ return sg_count; ++ ++out_no_mem: ++ alloc_fns->free_pages_fn(sg, sg_count, priv); ++ sg_count = 0; ++ goto out; ++} ++ ++static int sgv_alloc_arrays(struct sgv_pool_obj *obj, ++ int pages_to_alloc, gfp_t gfp_mask) ++{ ++ int sz, tsz = 0; ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ sz = pages_to_alloc * sizeof(obj->sg_entries[0]); ++ ++ obj->sg_entries = kmalloc(sz, gfp_mask); ++ if (unlikely(obj->sg_entries == NULL)) { ++ TRACE(TRACE_OUT_OF_MEM, "Allocation of sgv_pool_obj " ++ "SG vector failed (size %d)", sz); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ sg_init_table(obj->sg_entries, pages_to_alloc); ++ ++ if (sgv_pool_clustered(obj->owner_pool)) { ++ if (pages_to_alloc <= sgv_max_trans_pages) { ++ obj->trans_tbl = ++ (struct trans_tbl_ent *)obj->sg_entries_data; ++ /* ++ * No need to clear trans_tbl, if needed, it will be ++ * fully rewritten in sgv_alloc_sg_entries() ++ */ ++ } else { ++ tsz = pages_to_alloc * sizeof(obj->trans_tbl[0]); ++ obj->trans_tbl = kzalloc(tsz, gfp_mask); ++ if (unlikely(obj->trans_tbl == NULL)) { ++ TRACE(TRACE_OUT_OF_MEM, "Allocation of " ++ "trans_tbl failed (size %d)", tsz); ++ res = -ENOMEM; ++ goto out_free; ++ } ++ } ++ } ++ ++ TRACE_MEM("pages_to_alloc %d, sz %d, tsz %d, obj %p, sg_entries %p, " ++ "trans_tbl %p", pages_to_alloc, sz, tsz, obj, obj->sg_entries, ++ obj->trans_tbl); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free: ++ kfree(obj->sg_entries); ++ obj->sg_entries = NULL; ++ goto out; ++} ++ ++static struct sgv_pool_obj *sgv_get_obj(struct sgv_pool *pool, int cache_num, ++ int pages, gfp_t gfp_mask, bool get_new) ++{ ++ struct sgv_pool_obj *obj; ++ ++ spin_lock_bh(&pool->sgv_pool_lock); ++ ++ if (unlikely(get_new)) { ++ /* Used only for buffers preallocation */ ++ goto get_new; ++ } ++ ++ if (likely(!list_empty(&pool->recycling_lists[cache_num]))) { ++ obj = list_entry(pool->recycling_lists[cache_num].next, ++ struct sgv_pool_obj, recycling_list_entry); ++ ++ list_del(&obj->sorted_recycling_list_entry); ++ list_del(&obj->recycling_list_entry); ++ ++ pool->inactive_cached_pages -= pages; ++ ++ spin_unlock_bh(&pool->sgv_pool_lock); ++ goto out; ++ } ++ ++get_new: ++ if (pool->cached_entries == 0) { ++ TRACE_MEM("Adding pool %p to the active list", pool); ++ spin_lock_bh(&sgv_pools_lock); ++ list_add_tail(&pool->sgv_active_pools_list_entry, ++ &sgv_active_pools_list); ++ spin_unlock_bh(&sgv_pools_lock); ++ } ++ ++ pool->cached_entries++; ++ pool->cached_pages += pages; ++ ++ spin_unlock_bh(&pool->sgv_pool_lock); ++ ++ TRACE_MEM("New cached entries %d (pool %p)", pool->cached_entries, ++ pool); ++ ++ obj = kmem_cache_alloc(pool->caches[cache_num], ++ gfp_mask & ~(__GFP_HIGHMEM|GFP_DMA)); ++ if (likely(obj)) { ++ memset(obj, 0, sizeof(*obj)); ++ obj->cache_num = cache_num; ++ obj->pages = pages; ++ obj->owner_pool = pool; ++ } else { ++ spin_lock_bh(&pool->sgv_pool_lock); ++ sgv_dec_cached_entries(pool, pages); ++ spin_unlock_bh(&pool->sgv_pool_lock); ++ } ++ ++out: ++ return obj; ++} ++ ++static void sgv_put_obj(struct sgv_pool_obj *obj) ++{ ++ struct sgv_pool *pool = obj->owner_pool; ++ struct list_head *entry; ++ struct list_head *list = &pool->recycling_lists[obj->cache_num]; ++ int pages = obj->pages; ++ ++ spin_lock_bh(&pool->sgv_pool_lock); ++ ++ TRACE_MEM("sgv %p, cache num %d, pages %d, sg_count %d", obj, ++ obj->cache_num, pages, obj->sg_count); ++ ++ if (sgv_pool_clustered(pool)) { ++ /* Make objects with less entries more preferred */ ++ __list_for_each(entry, list) { ++ struct sgv_pool_obj *tmp = list_entry(entry, ++ struct sgv_pool_obj, recycling_list_entry); ++ ++ TRACE_MEM("tmp %p, cache num %d, pages %d, sg_count %d", ++ tmp, tmp->cache_num, tmp->pages, tmp->sg_count); ++ ++ if (obj->sg_count <= tmp->sg_count) ++ break; ++ } ++ entry = entry->prev; ++ } else ++ entry = list; ++ ++ TRACE_MEM("Adding in %p (list %p)", entry, list); ++ list_add(&obj->recycling_list_entry, entry); ++ ++ list_add_tail(&obj->sorted_recycling_list_entry, ++ &pool->sorted_recycling_list); ++ ++ obj->time_stamp = jiffies; ++ ++ pool->inactive_cached_pages += pages; ++ ++ if (!pool->purge_work_scheduled) { ++ TRACE_MEM("Scheduling purge work for pool %p", pool); ++ pool->purge_work_scheduled = true; ++ schedule_delayed_work(&pool->sgv_purge_work, ++ pool->purge_interval); ++ } ++ ++ spin_unlock_bh(&pool->sgv_pool_lock); ++ return; ++} ++ ++/* No locks */ ++static int sgv_hiwmk_check(int pages_to_alloc) ++{ ++ int res = 0; ++ int pages = pages_to_alloc; ++ ++ pages += atomic_read(&sgv_pages_total); ++ ++ if (unlikely(pages > sgv_hi_wmk)) { ++ pages -= sgv_hi_wmk; ++ atomic_inc(&sgv_releases_on_hiwmk); ++ ++ pages = __sgv_shrink(pages, 0); ++ if (pages > 0) { ++ TRACE(TRACE_OUT_OF_MEM, "Requested amount of " ++ "memory (%d pages) for being executed " ++ "commands together with the already " ++ "allocated memory exceeds the allowed " ++ "maximum %d. Should you increase " ++ "scst_max_cmd_mem?", pages_to_alloc, ++ sgv_hi_wmk); ++ atomic_inc(&sgv_releases_on_hiwmk_failed); ++ res = -ENOMEM; ++ goto out_unlock; ++ } ++ } ++ ++ atomic_add(pages_to_alloc, &sgv_pages_total); ++ ++out_unlock: ++ TRACE_MEM("pages_to_alloc %d, new total %d", pages_to_alloc, ++ atomic_read(&sgv_pages_total)); ++ ++ return res; ++} ++ ++/* No locks */ ++static void sgv_hiwmk_uncheck(int pages) ++{ ++ atomic_sub(pages, &sgv_pages_total); ++ TRACE_MEM("pages %d, new total %d", pages, ++ atomic_read(&sgv_pages_total)); ++ return; ++} ++ ++/* No locks */ ++static bool sgv_check_allowed_mem(struct scst_mem_lim *mem_lim, int pages) ++{ ++ int alloced; ++ bool res = true; ++ ++ alloced = atomic_add_return(pages, &mem_lim->alloced_pages); ++ if (unlikely(alloced > mem_lim->max_allowed_pages)) { ++ TRACE(TRACE_OUT_OF_MEM, "Requested amount of memory " ++ "(%d pages) for being executed commands on a device " ++ "together with the already allocated memory exceeds " ++ "the allowed maximum %d. Should you increase " ++ "scst_max_dev_cmd_mem?", pages, ++ mem_lim->max_allowed_pages); ++ atomic_sub(pages, &mem_lim->alloced_pages); ++ res = false; ++ } ++ ++ TRACE_MEM("mem_lim %p, pages %d, res %d, new alloced %d", mem_lim, ++ pages, res, atomic_read(&mem_lim->alloced_pages)); ++ ++ return res; ++} ++ ++/* No locks */ ++static void sgv_uncheck_allowed_mem(struct scst_mem_lim *mem_lim, int pages) ++{ ++ atomic_sub(pages, &mem_lim->alloced_pages); ++ ++ TRACE_MEM("mem_lim %p, pages %d, new alloced %d", mem_lim, ++ pages, atomic_read(&mem_lim->alloced_pages)); ++ return; ++} ++ ++/** ++ * sgv_pool_alloc - allocate an SG vector from the SGV pool ++ * @pool: the cache to alloc from ++ * @size: size of the resulting SG vector in bytes ++ * @gfp_mask: the allocation mask ++ * @flags: the allocation flags ++ * @count: the resulting count of SG entries in the resulting SG vector ++ * @sgv: the resulting SGV object ++ * @mem_lim: memory limits ++ * @priv: pointer to private for this allocation data ++ * ++ * Description: ++ * Allocate an SG vector from the SGV pool and returns pointer to it or ++ * NULL in case of any error. See the SGV pool documentation for more details. ++ */ ++struct scatterlist *sgv_pool_alloc(struct sgv_pool *pool, unsigned int size, ++ gfp_t gfp_mask, int flags, int *count, ++ struct sgv_pool_obj **sgv, struct scst_mem_lim *mem_lim, void *priv) ++{ ++ struct sgv_pool_obj *obj; ++ int cache_num, pages, cnt; ++ struct scatterlist *res = NULL; ++ int pages_to_alloc; ++ int no_cached = flags & SGV_POOL_ALLOC_NO_CACHED; ++ bool allowed_mem_checked = false, hiwmk_checked = false; ++ ++ TRACE_ENTRY(); ++ ++ if (unlikely(size == 0)) ++ goto out; ++ ++ EXTRACHECKS_BUG_ON((gfp_mask & __GFP_NOFAIL) == __GFP_NOFAIL); ++ ++ pages = ((size + PAGE_SIZE - 1) >> PAGE_SHIFT); ++ if (pool->single_alloc_pages == 0) { ++ int pages_order = get_order(size); ++ cache_num = pages_order; ++ pages_to_alloc = (1 << pages_order); ++ } else { ++ cache_num = 0; ++ pages_to_alloc = max(pool->single_alloc_pages, pages); ++ } ++ ++ TRACE_MEM("size=%d, pages=%d, pages_to_alloc=%d, cache num=%d, " ++ "flags=%x, no_cached=%d, *sgv=%p", size, pages, ++ pages_to_alloc, cache_num, flags, no_cached, *sgv); ++ ++ if (*sgv != NULL) { ++ obj = *sgv; ++ ++ TRACE_MEM("Supplied obj %p, cache num %d", obj, obj->cache_num); ++ ++ EXTRACHECKS_BUG_ON(obj->sg_count != 0); ++ ++ if (unlikely(!sgv_check_allowed_mem(mem_lim, pages_to_alloc))) ++ goto out_fail_free_sg_entries; ++ allowed_mem_checked = true; ++ ++ if (unlikely(sgv_hiwmk_check(pages_to_alloc) != 0)) ++ goto out_fail_free_sg_entries; ++ hiwmk_checked = true; ++ } else if ((pages_to_alloc <= pool->max_cached_pages) && !no_cached) { ++ if (unlikely(!sgv_check_allowed_mem(mem_lim, pages_to_alloc))) ++ goto out_fail; ++ allowed_mem_checked = true; ++ ++ obj = sgv_get_obj(pool, cache_num, pages_to_alloc, gfp_mask, ++ flags & SGV_POOL_ALLOC_GET_NEW); ++ if (unlikely(obj == NULL)) { ++ TRACE(TRACE_OUT_OF_MEM, "Allocation of " ++ "sgv_pool_obj failed (size %d)", size); ++ goto out_fail; ++ } ++ ++ if (obj->sg_count != 0) { ++ TRACE_MEM("Cached obj %p", obj); ++ atomic_inc(&pool->cache_acc[cache_num].hit_alloc); ++ goto success; ++ } ++ ++ if (flags & SGV_POOL_NO_ALLOC_ON_CACHE_MISS) { ++ if (!(flags & SGV_POOL_RETURN_OBJ_ON_ALLOC_FAIL)) ++ goto out_fail_free; ++ } ++ ++ TRACE_MEM("Brand new obj %p", obj); ++ ++ if (pages_to_alloc <= sgv_max_local_pages) { ++ obj->sg_entries = obj->sg_entries_data; ++ sg_init_table(obj->sg_entries, pages_to_alloc); ++ TRACE_MEM("sg_entries %p", obj->sg_entries); ++ if (sgv_pool_clustered(pool)) { ++ obj->trans_tbl = (struct trans_tbl_ent *) ++ (obj->sg_entries + pages_to_alloc); ++ TRACE_MEM("trans_tbl %p", obj->trans_tbl); ++ /* ++ * No need to clear trans_tbl, if needed, it ++ * will be fully rewritten in ++ * sgv_alloc_sg_entries(). ++ */ ++ } ++ } else { ++ if (unlikely(sgv_alloc_arrays(obj, pages_to_alloc, ++ gfp_mask) != 0)) ++ goto out_fail_free; ++ } ++ ++ if ((flags & SGV_POOL_NO_ALLOC_ON_CACHE_MISS) && ++ (flags & SGV_POOL_RETURN_OBJ_ON_ALLOC_FAIL)) ++ goto out_return; ++ ++ obj->allocator_priv = priv; ++ ++ if (unlikely(sgv_hiwmk_check(pages_to_alloc) != 0)) ++ goto out_fail_free_sg_entries; ++ hiwmk_checked = true; ++ } else { ++ int sz; ++ ++ pages_to_alloc = pages; ++ ++ if (unlikely(!sgv_check_allowed_mem(mem_lim, pages_to_alloc))) ++ goto out_fail; ++ allowed_mem_checked = true; ++ ++ if (flags & SGV_POOL_NO_ALLOC_ON_CACHE_MISS) ++ goto out_return2; ++ ++ sz = sizeof(*obj) + pages * sizeof(obj->sg_entries[0]); ++ ++ obj = kmalloc(sz, gfp_mask); ++ if (unlikely(obj == NULL)) { ++ TRACE(TRACE_OUT_OF_MEM, "Allocation of " ++ "sgv_pool_obj failed (size %d)", size); ++ goto out_fail; ++ } ++ memset(obj, 0, sizeof(*obj)); ++ ++ obj->owner_pool = pool; ++ cache_num = -1; ++ obj->cache_num = cache_num; ++ obj->pages = pages_to_alloc; ++ obj->allocator_priv = priv; ++ ++ obj->sg_entries = obj->sg_entries_data; ++ sg_init_table(obj->sg_entries, pages); ++ ++ if (unlikely(sgv_hiwmk_check(pages_to_alloc) != 0)) ++ goto out_fail_free_sg_entries; ++ hiwmk_checked = true; ++ ++ TRACE_MEM("Big or no_cached obj %p (size %d)", obj, sz); ++ } ++ ++ obj->sg_count = sgv_alloc_sg_entries(obj->sg_entries, ++ pages_to_alloc, gfp_mask, pool->clustering_type, ++ obj->trans_tbl, &pool->alloc_fns, priv); ++ if (unlikely(obj->sg_count <= 0)) { ++ obj->sg_count = 0; ++ if ((flags & SGV_POOL_RETURN_OBJ_ON_ALLOC_FAIL) && ++ (cache_num >= 0)) ++ goto out_return1; ++ else ++ goto out_fail_free_sg_entries; ++ } ++ ++ if (cache_num >= 0) { ++ atomic_add(pages_to_alloc - obj->sg_count, ++ &pool->cache_acc[cache_num].merged); ++ } else { ++ if (no_cached) { ++ atomic_add(pages_to_alloc, ++ &pool->other_pages); ++ atomic_add(pages_to_alloc - obj->sg_count, ++ &pool->other_merged); ++ } else { ++ atomic_add(pages_to_alloc, ++ &pool->big_pages); ++ atomic_add(pages_to_alloc - obj->sg_count, ++ &pool->big_merged); ++ } ++ } ++ ++success: ++ if (cache_num >= 0) { ++ int sg; ++ atomic_inc(&pool->cache_acc[cache_num].total_alloc); ++ if (sgv_pool_clustered(pool)) ++ cnt = obj->trans_tbl[pages-1].sg_num; ++ else ++ cnt = pages; ++ sg = cnt-1; ++ obj->orig_sg = sg; ++ obj->orig_length = obj->sg_entries[sg].length; ++ if (sgv_pool_clustered(pool)) { ++ obj->sg_entries[sg].length = ++ (pages - obj->trans_tbl[sg].pg_count) << PAGE_SHIFT; ++ } ++ } else { ++ cnt = obj->sg_count; ++ if (no_cached) ++ atomic_inc(&pool->other_alloc); ++ else ++ atomic_inc(&pool->big_alloc); ++ } ++ ++ *count = cnt; ++ res = obj->sg_entries; ++ *sgv = obj; ++ ++ if (size & ~PAGE_MASK) ++ obj->sg_entries[cnt-1].length -= ++ PAGE_SIZE - (size & ~PAGE_MASK); ++ ++ TRACE_MEM("obj=%p, sg_entries %p (size=%d, pages=%d, sg_count=%d, " ++ "count=%d, last_len=%d)", obj, obj->sg_entries, size, pages, ++ obj->sg_count, *count, obj->sg_entries[obj->orig_sg].length); ++ ++out: ++ TRACE_EXIT_HRES(res); ++ return res; ++ ++out_return: ++ obj->allocator_priv = priv; ++ obj->owner_pool = pool; ++ ++out_return1: ++ *sgv = obj; ++ TRACE_MEM("Returning failed obj %p (count %d)", obj, *count); ++ ++out_return2: ++ *count = pages_to_alloc; ++ res = NULL; ++ goto out_uncheck; ++ ++out_fail_free_sg_entries: ++ if (obj->sg_entries != obj->sg_entries_data) { ++ if (obj->trans_tbl != ++ (struct trans_tbl_ent *)obj->sg_entries_data) { ++ /* kfree() handles NULL parameter */ ++ kfree(obj->trans_tbl); ++ obj->trans_tbl = NULL; ++ } ++ kfree(obj->sg_entries); ++ obj->sg_entries = NULL; ++ } ++ ++out_fail_free: ++ if (cache_num >= 0) { ++ spin_lock_bh(&pool->sgv_pool_lock); ++ sgv_dec_cached_entries(pool, pages_to_alloc); ++ spin_unlock_bh(&pool->sgv_pool_lock); ++ ++ kmem_cache_free(pool->caches[obj->cache_num], obj); ++ } else ++ kfree(obj); ++ ++out_fail: ++ res = NULL; ++ *count = 0; ++ *sgv = NULL; ++ TRACE_MEM("%s", "Allocation failed"); ++ ++out_uncheck: ++ if (hiwmk_checked) ++ sgv_hiwmk_uncheck(pages_to_alloc); ++ if (allowed_mem_checked) ++ sgv_uncheck_allowed_mem(mem_lim, pages_to_alloc); ++ goto out; ++} ++EXPORT_SYMBOL_GPL(sgv_pool_alloc); ++ ++/** ++ * sgv_get_priv - return the private allocation data ++ * ++ * Allows to get the allocation private data for this SGV ++ * cache object. The private data supposed to be set by sgv_pool_alloc(). ++ */ ++void *sgv_get_priv(struct sgv_pool_obj *obj) ++{ ++ return obj->allocator_priv; ++} ++EXPORT_SYMBOL_GPL(sgv_get_priv); ++ ++/** ++ * sgv_pool_free - free previously allocated SG vector ++ * @sgv: the SGV object to free ++ * @mem_lim: memory limits ++ * ++ * Description: ++ * Frees previously allocated SG vector and updates memory limits ++ */ ++void sgv_pool_free(struct sgv_pool_obj *obj, struct scst_mem_lim *mem_lim) ++{ ++ int pages = (obj->sg_count != 0) ? obj->pages : 0; ++ ++ TRACE_MEM("Freeing obj %p, cache num %d, pages %d, sg_entries %p, " ++ "sg_count %d, allocator_priv %p", obj, obj->cache_num, pages, ++ obj->sg_entries, obj->sg_count, obj->allocator_priv); ++ ++/* ++ * Enable it if you are investigating a data corruption and want to make ++ * sure that target or dev handler didn't leave the pages mapped somewhere and, ++ * hence, provoked a data corruption. ++ * ++ * Make sure the check value for _count is set correctly. In most cases, 1 is ++ * correct, but, e.g., iSCSI-SCST can call it with value 2, because ++ * it frees the corresponding cmd before the last put_page() call from ++ * net_put_page() for the last page in the SG. Also, user space dev handlers ++ * usually have their memory mapped in their address space. ++ */ ++#if 0 ++ { ++ struct scatterlist *sg = obj->sg_entries; ++ int i; ++ for (i = 0; i < obj->sg_count; i++) { ++ struct page *p = sg_page(&sg[i]); ++ int len = sg[i].length; ++ int pages = (len >> PAGE_SHIFT) + ((len & ~PAGE_MASK) != 0); ++ while (pages > 0) { ++ if (atomic_read(&p->_count) != 1) { ++ PRINT_WARNING("Freeing page %p with " ++ "additional owners (_count %d). " ++ "Data corruption possible!", ++ p, atomic_read(&p->_count)); ++ WARN_ON(1); ++ } ++ pages--; ++ p++; ++ } ++ } ++ } ++#endif ++ ++ if (obj->cache_num >= 0) { ++ obj->sg_entries[obj->orig_sg].length = obj->orig_length; ++ sgv_put_obj(obj); ++ } else { ++ obj->owner_pool->alloc_fns.free_pages_fn(obj->sg_entries, ++ obj->sg_count, obj->allocator_priv); ++ kfree(obj); ++ sgv_hiwmk_uncheck(pages); ++ } ++ ++ sgv_uncheck_allowed_mem(mem_lim, pages); ++ return; ++} ++EXPORT_SYMBOL_GPL(sgv_pool_free); ++ ++/** ++ * scst_alloc() - allocates an SG vector ++ * ++ * Allocates and returns pointer to SG vector with data size "size". ++ * In *count returned the count of entries in the vector. ++ * Returns NULL for failure. ++ */ ++struct scatterlist *scst_alloc(int size, gfp_t gfp_mask, int *count) ++{ ++ struct scatterlist *res; ++ int pages = (size >> PAGE_SHIFT) + ((size & ~PAGE_MASK) != 0); ++ struct sgv_pool_alloc_fns sys_alloc_fns = { ++ sgv_alloc_sys_pages, sgv_free_sys_sg_entries }; ++ int no_fail = ((gfp_mask & __GFP_NOFAIL) == __GFP_NOFAIL); ++ int cnt; ++ ++ TRACE_ENTRY(); ++ ++ atomic_inc(&sgv_other_total_alloc); ++ ++ if (unlikely(sgv_hiwmk_check(pages) != 0)) { ++ if (!no_fail) { ++ res = NULL; ++ goto out; ++ } else { ++ /* ++ * Update active_pages_total since alloc can't fail. ++ * If it wasn't updated then the counter would cross 0 ++ * on free again. ++ */ ++ sgv_hiwmk_uncheck(-pages); ++ } ++ } ++ ++ res = kmalloc(pages*sizeof(*res), gfp_mask); ++ if (res == NULL) { ++ TRACE(TRACE_OUT_OF_MEM, "Unable to allocate sg for %d pages", ++ pages); ++ goto out_uncheck; ++ } ++ ++ sg_init_table(res, pages); ++ ++ /* ++ * If we allow use clustering here, we will have troubles in ++ * scst_free() to figure out how many pages are in the SG vector. ++ * So, let's always don't use clustering. ++ */ ++ cnt = sgv_alloc_sg_entries(res, pages, gfp_mask, sgv_no_clustering, ++ NULL, &sys_alloc_fns, NULL); ++ if (cnt <= 0) ++ goto out_free; ++ ++ if (size & ~PAGE_MASK) ++ res[cnt-1].length -= PAGE_SIZE - (size & ~PAGE_MASK); ++ ++ *count = cnt; ++ ++out: ++ TRACE_MEM("Alloced sg %p (count %d, no_fail %d)", res, *count, no_fail); ++ ++ TRACE_EXIT_HRES(res); ++ return res; ++ ++out_free: ++ kfree(res); ++ res = NULL; ++ ++out_uncheck: ++ if (!no_fail) ++ sgv_hiwmk_uncheck(pages); ++ goto out; ++} ++EXPORT_SYMBOL_GPL(scst_alloc); ++ ++/** ++ * scst_free() - frees SG vector ++ * ++ * Frees SG vector returned by scst_alloc(). ++ */ ++void scst_free(struct scatterlist *sg, int count) ++{ ++ TRACE_MEM("Freeing sg=%p", sg); ++ ++ sgv_hiwmk_uncheck(count); ++ ++ sgv_free_sys_sg_entries(sg, count, NULL); ++ kfree(sg); ++ return; ++} ++EXPORT_SYMBOL_GPL(scst_free); ++ ++/* Must be called under sgv_pools_mutex */ ++static void sgv_pool_init_cache(struct sgv_pool *pool, int cache_num) ++{ ++ int size; ++ int pages; ++ struct sgv_pool_obj *obj; ++ ++ atomic_set(&pool->cache_acc[cache_num].total_alloc, 0); ++ atomic_set(&pool->cache_acc[cache_num].hit_alloc, 0); ++ atomic_set(&pool->cache_acc[cache_num].merged, 0); ++ ++ if (pool->single_alloc_pages == 0) ++ pages = 1 << cache_num; ++ else ++ pages = pool->single_alloc_pages; ++ ++ if (pages <= sgv_max_local_pages) { ++ size = sizeof(*obj) + pages * ++ (sizeof(obj->sg_entries[0]) + ++ ((pool->clustering_type != sgv_no_clustering) ? ++ sizeof(obj->trans_tbl[0]) : 0)); ++ } else if (pages <= sgv_max_trans_pages) { ++ /* ++ * sg_entries is allocated outside object, ++ * but trans_tbl is still embedded. ++ */ ++ size = sizeof(*obj) + pages * ++ (((pool->clustering_type != sgv_no_clustering) ? ++ sizeof(obj->trans_tbl[0]) : 0)); ++ } else { ++ size = sizeof(*obj); ++ /* both sgv and trans_tbl are kmalloc'ed() */ ++ } ++ ++ TRACE_MEM("pages=%d, size=%d", pages, size); ++ ++ scnprintf(pool->cache_names[cache_num], ++ sizeof(pool->cache_names[cache_num]), ++ "%s-%uK", pool->name, (pages << PAGE_SHIFT) >> 10); ++ pool->caches[cache_num] = kmem_cache_create( ++ pool->cache_names[cache_num], size, 0, SCST_SLAB_FLAGS, NULL ++ ); ++ return; ++} ++ ++/* Must be called under sgv_pools_mutex */ ++static int sgv_pool_init(struct sgv_pool *pool, const char *name, ++ enum sgv_clustering_types clustering_type, int single_alloc_pages, ++ int purge_interval) ++{ ++ int res = -ENOMEM; ++ int i; ++ ++ TRACE_ENTRY(); ++ ++ if (single_alloc_pages < 0) { ++ PRINT_ERROR("Wrong single_alloc_pages value %d", ++ single_alloc_pages); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ memset(pool, 0, sizeof(*pool)); ++ ++ atomic_set(&pool->big_alloc, 0); ++ atomic_set(&pool->big_pages, 0); ++ atomic_set(&pool->big_merged, 0); ++ atomic_set(&pool->other_alloc, 0); ++ atomic_set(&pool->other_pages, 0); ++ atomic_set(&pool->other_merged, 0); ++ ++ pool->clustering_type = clustering_type; ++ pool->single_alloc_pages = single_alloc_pages; ++ if (purge_interval != 0) { ++ pool->purge_interval = purge_interval; ++ if (purge_interval < 0) { ++ /* Let's pretend that it's always scheduled */ ++ pool->purge_work_scheduled = 1; ++ } ++ } else ++ pool->purge_interval = SGV_DEFAULT_PURGE_INTERVAL; ++ if (single_alloc_pages == 0) { ++ pool->max_caches = SGV_POOL_ELEMENTS; ++ pool->max_cached_pages = 1 << (SGV_POOL_ELEMENTS - 1); ++ } else { ++ pool->max_caches = 1; ++ pool->max_cached_pages = single_alloc_pages; ++ } ++ pool->alloc_fns.alloc_pages_fn = sgv_alloc_sys_pages; ++ pool->alloc_fns.free_pages_fn = sgv_free_sys_sg_entries; ++ ++ TRACE_MEM("name %s, sizeof(*obj)=%zd, clustering_type=%d, " ++ "single_alloc_pages=%d, max_caches=%d, max_cached_pages=%d", ++ name, sizeof(struct sgv_pool_obj), clustering_type, ++ single_alloc_pages, pool->max_caches, pool->max_cached_pages); ++ ++ strlcpy(pool->name, name, sizeof(pool->name)-1); ++ ++ pool->owner_mm = current->mm; ++ ++ for (i = 0; i < pool->max_caches; i++) { ++ sgv_pool_init_cache(pool, i); ++ if (pool->caches[i] == NULL) { ++ PRINT_ERROR("Allocation of sgv_pool " ++ "cache %s(%d) failed", name, i); ++ goto out_free; ++ } ++ } ++ ++ atomic_set(&pool->sgv_pool_ref, 1); ++ spin_lock_init(&pool->sgv_pool_lock); ++ INIT_LIST_HEAD(&pool->sorted_recycling_list); ++ for (i = 0; i < pool->max_caches; i++) ++ INIT_LIST_HEAD(&pool->recycling_lists[i]); ++ ++ INIT_DELAYED_WORK(&pool->sgv_purge_work, ++ (void (*)(struct work_struct *))sgv_purge_work_fn); ++ ++ spin_lock_bh(&sgv_pools_lock); ++ list_add_tail(&pool->sgv_pools_list_entry, &sgv_pools_list); ++ spin_unlock_bh(&sgv_pools_lock); ++ ++ res = scst_sgv_sysfs_create(pool); ++ if (res != 0) ++ goto out_del; ++ ++ res = 0; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_del: ++ spin_lock_bh(&sgv_pools_lock); ++ list_del(&pool->sgv_pools_list_entry); ++ spin_unlock_bh(&sgv_pools_lock); ++ ++out_free: ++ for (i = 0; i < pool->max_caches; i++) { ++ if (pool->caches[i]) { ++ kmem_cache_destroy(pool->caches[i]); ++ pool->caches[i] = NULL; ++ } else ++ break; ++ } ++ goto out; ++} ++ ++static void sgv_evaluate_local_max_pages(void) ++{ ++ int space4sgv_ttbl = PAGE_SIZE - sizeof(struct sgv_pool_obj); ++ ++ sgv_max_local_pages = space4sgv_ttbl / ++ (sizeof(struct trans_tbl_ent) + sizeof(struct scatterlist)); ++ ++ sgv_max_trans_pages = space4sgv_ttbl / sizeof(struct trans_tbl_ent); ++ ++ TRACE_MEM("sgv_max_local_pages %d, sgv_max_trans_pages %d", ++ sgv_max_local_pages, sgv_max_trans_pages); ++ return; ++} ++ ++/** ++ * sgv_pool_flush() - flushes the SGV pool. ++ * ++ * Flushes, i.e. frees, all the cached entries in the SGV pool. ++ */ ++void sgv_pool_flush(struct sgv_pool *pool) ++{ ++ int i; ++ ++ TRACE_ENTRY(); ++ ++ for (i = 0; i < pool->max_caches; i++) { ++ struct sgv_pool_obj *obj; ++ ++ spin_lock_bh(&pool->sgv_pool_lock); ++ ++ while (!list_empty(&pool->recycling_lists[i])) { ++ obj = list_entry(pool->recycling_lists[i].next, ++ struct sgv_pool_obj, recycling_list_entry); ++ ++ __sgv_purge_from_cache(obj); ++ ++ spin_unlock_bh(&pool->sgv_pool_lock); ++ ++ EXTRACHECKS_BUG_ON(obj->owner_pool != pool); ++ sgv_dtor_and_free(obj); ++ ++ spin_lock_bh(&pool->sgv_pool_lock); ++ } ++ spin_unlock_bh(&pool->sgv_pool_lock); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL_GPL(sgv_pool_flush); ++ ++static void sgv_pool_destroy(struct sgv_pool *pool) ++{ ++ int i; ++ ++ TRACE_ENTRY(); ++ ++ cancel_delayed_work_sync(&pool->sgv_purge_work); ++ ++ sgv_pool_flush(pool); ++ ++ mutex_lock(&sgv_pools_mutex); ++ spin_lock_bh(&sgv_pools_lock); ++ list_del(&pool->sgv_pools_list_entry); ++ spin_unlock_bh(&sgv_pools_lock); ++ mutex_unlock(&sgv_pools_mutex); ++ ++ scst_sgv_sysfs_del(pool); ++ ++ for (i = 0; i < pool->max_caches; i++) { ++ if (pool->caches[i]) ++ kmem_cache_destroy(pool->caches[i]); ++ pool->caches[i] = NULL; ++ } ++ ++ kfree(pool); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/** ++ * sgv_pool_set_allocator - set custom pages allocator ++ * @pool: the cache ++ * @alloc_pages_fn: pages allocation function ++ * @free_pages_fn: pages freeing function ++ * ++ * Description: ++ * Allows to set custom pages allocator for the SGV pool. ++ * See the SGV pool documentation for more details. ++ */ ++void sgv_pool_set_allocator(struct sgv_pool *pool, ++ struct page *(*alloc_pages_fn)(struct scatterlist *, gfp_t, void *), ++ void (*free_pages_fn)(struct scatterlist *, int, void *)) ++{ ++ pool->alloc_fns.alloc_pages_fn = alloc_pages_fn; ++ pool->alloc_fns.free_pages_fn = free_pages_fn; ++ return; ++} ++EXPORT_SYMBOL_GPL(sgv_pool_set_allocator); ++ ++/** ++ * sgv_pool_create - creates and initializes an SGV pool ++ * @name: the name of the SGV pool ++ * @clustered: sets type of the pages clustering. ++ * @single_alloc_pages: if 0, then the SGV pool will work in the set of ++ * power 2 size buffers mode. If >0, then the SGV pool will ++ * work in the fixed size buffers mode. In this case ++ * single_alloc_pages sets the size of each buffer in pages. ++ * @shared: sets if the SGV pool can be shared between devices or not. ++ * The cache sharing allowed only between devices created inside ++ * the same address space. If an SGV pool is shared, each ++ * subsequent call of sgv_pool_create() with the same cache name ++ * will not create a new cache, but instead return a reference ++ * to it. ++ * @purge_interval: sets the cache purging interval. I.e., an SG buffer ++ * will be freed if it's unused for time t ++ * purge_interval <= t < 2*purge_interval. If purge_interval ++ * is 0, then the default interval will be used (60 seconds). ++ * If purge_interval <0, then the automatic purging will be ++ * disabled. ++ * ++ * Description: ++ * Returns the resulting SGV pool or NULL in case of any error. ++ */ ++struct sgv_pool *sgv_pool_create(const char *name, ++ enum sgv_clustering_types clustering_type, ++ int single_alloc_pages, bool shared, int purge_interval) ++{ ++ struct sgv_pool *pool; ++ int rc; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&sgv_pools_mutex); ++ ++ list_for_each_entry(pool, &sgv_pools_list, sgv_pools_list_entry) { ++ if (strcmp(pool->name, name) == 0) { ++ if (shared) { ++ if (pool->owner_mm != current->mm) { ++ PRINT_ERROR("Attempt of a shared use " ++ "of SGV pool %s with " ++ "different MM", name); ++ goto out_unlock; ++ } ++ sgv_pool_get(pool); ++ goto out_unlock; ++ } else { ++ PRINT_ERROR("SGV pool %s already exists", name); ++ pool = NULL; ++ goto out_unlock; ++ } ++ } ++ } ++ ++ pool = kzalloc(sizeof(*pool), GFP_KERNEL); ++ if (pool == NULL) { ++ PRINT_ERROR("Allocation of sgv_pool failed (size %zd)", ++ sizeof(*pool)); ++ goto out_unlock; ++ } ++ ++ rc = sgv_pool_init(pool, name, clustering_type, single_alloc_pages, ++ purge_interval); ++ if (rc != 0) ++ goto out_free; ++ ++out_unlock: ++ mutex_unlock(&sgv_pools_mutex); ++ ++ TRACE_EXIT_RES(pool != NULL); ++ return pool; ++ ++out_free: ++ kfree(pool); ++ goto out_unlock; ++} ++EXPORT_SYMBOL_GPL(sgv_pool_create); ++ ++/** ++ * sgv_pool_get - increase ref counter for the corresponding SGV pool ++ * ++ * Increases ref counter for the corresponding SGV pool ++ */ ++void sgv_pool_get(struct sgv_pool *pool) ++{ ++ atomic_inc(&pool->sgv_pool_ref); ++ TRACE_MEM("Incrementing sgv pool %p ref (new value %d)", ++ pool, atomic_read(&pool->sgv_pool_ref)); ++ return; ++} ++EXPORT_SYMBOL_GPL(sgv_pool_get); ++ ++/** ++ * sgv_pool_put - decrease ref counter for the corresponding SGV pool ++ * ++ * Decreases ref counter for the corresponding SGV pool. If the ref ++ * counter reaches 0, the cache will be destroyed. ++ */ ++void sgv_pool_put(struct sgv_pool *pool) ++{ ++ TRACE_MEM("Decrementing sgv pool %p ref (new value %d)", ++ pool, atomic_read(&pool->sgv_pool_ref)-1); ++ if (atomic_dec_and_test(&pool->sgv_pool_ref)) ++ sgv_pool_destroy(pool); ++ return; ++} ++EXPORT_SYMBOL_GPL(sgv_pool_put); ++ ++/** ++ * sgv_pool_del - deletes the corresponding SGV pool ++ * @pool: the cache to delete. ++ * ++ * Description: ++ * If the cache is shared, it will decrease its reference counter. ++ * If the reference counter reaches 0, the cache will be destroyed. ++ */ ++void sgv_pool_del(struct sgv_pool *pool) ++{ ++ TRACE_ENTRY(); ++ ++ sgv_pool_put(pool); ++ ++ TRACE_EXIT(); ++ return; ++} ++EXPORT_SYMBOL_GPL(sgv_pool_del); ++ ++/* Both parameters in pages */ ++int scst_sgv_pools_init(unsigned long mem_hwmark, unsigned long mem_lwmark) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ sgv_hi_wmk = mem_hwmark; ++ sgv_lo_wmk = mem_lwmark; ++ ++ sgv_evaluate_local_max_pages(); ++ ++ sgv_norm_pool = sgv_pool_create("sgv", sgv_no_clustering, 0, false, 0); ++ if (sgv_norm_pool == NULL) ++ goto out_err; ++ ++ sgv_norm_clust_pool = sgv_pool_create("sgv-clust", ++ sgv_full_clustering, 0, false, 0); ++ if (sgv_norm_clust_pool == NULL) ++ goto out_free_norm; ++ ++ sgv_dma_pool = sgv_pool_create("sgv-dma", sgv_no_clustering, 0, ++ false, 0); ++ if (sgv_dma_pool == NULL) ++ goto out_free_clust; ++ ++ sgv_shrinker.shrink = sgv_shrink; ++ sgv_shrinker.seeks = DEFAULT_SEEKS; ++ register_shrinker(&sgv_shrinker); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free_clust: ++ sgv_pool_destroy(sgv_norm_clust_pool); ++ ++out_free_norm: ++ sgv_pool_destroy(sgv_norm_pool); ++ ++out_err: ++ res = -ENOMEM; ++ goto out; ++} ++ ++void scst_sgv_pools_deinit(void) ++{ ++ TRACE_ENTRY(); ++ ++ unregister_shrinker(&sgv_shrinker); ++ ++ sgv_pool_destroy(sgv_dma_pool); ++ sgv_pool_destroy(sgv_norm_pool); ++ sgv_pool_destroy(sgv_norm_clust_pool); ++ ++ flush_scheduled_work(); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static ssize_t sgv_sysfs_stat_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct sgv_pool *pool; ++ int i, total = 0, hit = 0, merged = 0, allocated = 0; ++ int oa, om, res; ++ ++ pool = container_of(kobj, struct sgv_pool, sgv_kobj); ++ ++ for (i = 0; i < SGV_POOL_ELEMENTS; i++) { ++ int t; ++ ++ hit += atomic_read(&pool->cache_acc[i].hit_alloc); ++ total += atomic_read(&pool->cache_acc[i].total_alloc); ++ ++ t = atomic_read(&pool->cache_acc[i].total_alloc) - ++ atomic_read(&pool->cache_acc[i].hit_alloc); ++ allocated += t * (1 << i); ++ merged += atomic_read(&pool->cache_acc[i].merged); ++ } ++ ++ res = sprintf(buf, "%-30s %-11s %-11s %-11s %-11s", "Name", "Hit", "Total", ++ "% merged", "Cached (P/I/O)"); ++ ++ res += sprintf(&buf[res], "\n%-30s %-11d %-11d %-11d %d/%d/%d\n", ++ pool->name, hit, total, ++ (allocated != 0) ? merged*100/allocated : 0, ++ pool->cached_pages, pool->inactive_cached_pages, ++ pool->cached_entries); ++ ++ for (i = 0; i < SGV_POOL_ELEMENTS; i++) { ++ int t = atomic_read(&pool->cache_acc[i].total_alloc) - ++ atomic_read(&pool->cache_acc[i].hit_alloc); ++ allocated = t * (1 << i); ++ merged = atomic_read(&pool->cache_acc[i].merged); ++ ++ res += sprintf(&buf[res], " %-28s %-11d %-11d %d\n", ++ pool->cache_names[i], ++ atomic_read(&pool->cache_acc[i].hit_alloc), ++ atomic_read(&pool->cache_acc[i].total_alloc), ++ (allocated != 0) ? merged*100/allocated : 0); ++ } ++ ++ allocated = atomic_read(&pool->big_pages); ++ merged = atomic_read(&pool->big_merged); ++ oa = atomic_read(&pool->other_pages); ++ om = atomic_read(&pool->other_merged); ++ ++ res += sprintf(&buf[res], " %-40s %d/%-9d %d/%d\n", "big/other", ++ atomic_read(&pool->big_alloc), atomic_read(&pool->other_alloc), ++ (allocated != 0) ? merged*100/allocated : 0, ++ (oa != 0) ? om/oa : 0); ++ ++ return res; ++} ++ ++static ssize_t sgv_sysfs_stat_reset(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ struct sgv_pool *pool; ++ int i; ++ ++ TRACE_ENTRY(); ++ ++ pool = container_of(kobj, struct sgv_pool, sgv_kobj); ++ ++ for (i = 0; i < SGV_POOL_ELEMENTS; i++) { ++ atomic_set(&pool->cache_acc[i].hit_alloc, 0); ++ atomic_set(&pool->cache_acc[i].total_alloc, 0); ++ atomic_set(&pool->cache_acc[i].merged, 0); ++ } ++ ++ atomic_set(&pool->big_pages, 0); ++ atomic_set(&pool->big_merged, 0); ++ atomic_set(&pool->big_alloc, 0); ++ atomic_set(&pool->other_pages, 0); ++ atomic_set(&pool->other_merged, 0); ++ atomic_set(&pool->other_alloc, 0); ++ ++ PRINT_INFO("Statistics for SGV pool %s reset", pool->name); ++ ++ TRACE_EXIT_RES(count); ++ return count; ++} ++ ++static ssize_t sgv_sysfs_global_stat_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct sgv_pool *pool; ++ int inactive_pages = 0, res; ++ ++ TRACE_ENTRY(); ++ ++ spin_lock_bh(&sgv_pools_lock); ++ list_for_each_entry(pool, &sgv_active_pools_list, ++ sgv_active_pools_list_entry) { ++ inactive_pages += pool->inactive_cached_pages; ++ } ++ spin_unlock_bh(&sgv_pools_lock); ++ ++ res = sprintf(buf, "%-42s %d/%d\n%-42s %d/%d\n%-42s %d/%d\n" ++ "%-42s %-11d\n", ++ "Inactive/active pages", inactive_pages, ++ atomic_read(&sgv_pages_total) - inactive_pages, ++ "Hi/lo watermarks [pages]", sgv_hi_wmk, sgv_lo_wmk, ++ "Hi watermark releases/failures", ++ atomic_read(&sgv_releases_on_hiwmk), ++ atomic_read(&sgv_releases_on_hiwmk_failed), ++ "Other allocs", atomic_read(&sgv_other_total_alloc)); ++ ++ TRACE_EXIT(); ++ return res; ++} ++ ++static ssize_t sgv_sysfs_global_stat_reset(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ TRACE_ENTRY(); ++ ++ atomic_set(&sgv_releases_on_hiwmk, 0); ++ atomic_set(&sgv_releases_on_hiwmk_failed, 0); ++ atomic_set(&sgv_other_total_alloc, 0); ++ ++ PRINT_INFO("%s", "Global SGV pool statistics reset"); ++ ++ TRACE_EXIT_RES(count); ++ return count; ++} ++ ++static struct kobj_attribute sgv_stat_attr = ++ __ATTR(stats, S_IRUGO | S_IWUSR, sgv_sysfs_stat_show, ++ sgv_sysfs_stat_reset); ++ ++static struct attribute *sgv_attrs[] = { ++ &sgv_stat_attr.attr, ++ NULL, ++}; ++ ++static void sgv_kobj_release(struct kobject *kobj) ++{ ++ struct sgv_pool *pool; ++ ++ TRACE_ENTRY(); ++ ++ pool = container_of(kobj, struct sgv_pool, sgv_kobj); ++ if (pool->sgv_kobj_release_cmpl != NULL) ++ complete_all(pool->sgv_kobj_release_cmpl); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static struct kobj_type sgv_pool_ktype = { ++ .sysfs_ops = &scst_sysfs_ops, ++ .release = sgv_kobj_release, ++ .default_attrs = sgv_attrs, ++}; ++ ++static int scst_sgv_sysfs_create(struct sgv_pool *pool) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ res = kobject_init_and_add(&pool->sgv_kobj, &sgv_pool_ktype, ++ scst_sgv_kobj, pool->name); ++ if (res != 0) { ++ PRINT_ERROR("Can't add sgv pool %s to sysfs", pool->name); ++ goto out; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void scst_sgv_sysfs_del(struct sgv_pool *pool) ++{ ++ int rc; ++ DECLARE_COMPLETION_ONSTACK(c); ++ ++ TRACE_ENTRY(); ++ ++ pool->sgv_kobj_release_cmpl = &c; ++ ++ kobject_del(&pool->sgv_kobj); ++ kobject_put(&pool->sgv_kobj); ++ ++ rc = wait_for_completion_timeout(pool->sgv_kobj_release_cmpl, HZ); ++ if (rc == 0) { ++ PRINT_INFO("Waiting for releasing sysfs entry " ++ "for SGV pool %s (%d refs)...", pool->name, ++ atomic_read(&pool->sgv_kobj.kref.refcount)); ++ wait_for_completion(pool->sgv_kobj_release_cmpl); ++ PRINT_INFO("Done waiting for releasing sysfs " ++ "entry for SGV pool %s", pool->name); ++ } ++ ++ TRACE_EXIT(); ++} ++ ++static struct kobj_attribute sgv_global_stat_attr = ++ __ATTR(global_stats, S_IRUGO | S_IWUSR, sgv_sysfs_global_stat_show, ++ sgv_sysfs_global_stat_reset); ++ ++static struct attribute *sgv_default_attrs[] = { ++ &sgv_global_stat_attr.attr, ++ NULL, ++}; ++ ++static void scst_sysfs_release(struct kobject *kobj) ++{ ++ kfree(kobj); ++} ++ ++static struct kobj_type sgv_ktype = { ++ .sysfs_ops = &scst_sysfs_ops, ++ .release = scst_sysfs_release, ++ .default_attrs = sgv_default_attrs, ++}; ++ ++/** ++ * scst_add_sgv_kobj() - Initialize and add the root SGV kernel object. ++ */ ++int scst_add_sgv_kobj(struct kobject *parent, const char *name) ++{ ++ int res; ++ ++ WARN_ON(scst_sgv_kobj); ++ res = -ENOMEM; ++ scst_sgv_kobj = kzalloc(sizeof(*scst_sgv_kobj), GFP_KERNEL); ++ if (!scst_sgv_kobj) ++ goto out; ++ res = kobject_init_and_add(scst_sgv_kobj, &sgv_ktype, parent, name); ++ if (res != 0) ++ goto out_free; ++out: ++ return res; ++out_free: ++ kobject_put(scst_sgv_kobj); ++ scst_sgv_kobj = NULL; ++ goto out; ++} ++ ++/** ++ * scst_del_put_sgv_kobj() - Remove the root SGV kernel object. ++ */ ++void scst_del_put_sgv_kobj(void) ++{ ++ WARN_ON(!scst_sgv_kobj); ++ kobject_del(scst_sgv_kobj); ++ kobject_put(scst_sgv_kobj); ++ scst_sgv_kobj = NULL; ++} ++ +diff -uprN orig/linux-3.2/Documentation/scst/sgv_cache.sgml linux-3.2/Documentation/scst/sgv_cache.sgml +--- orig/linux-3.2/Documentation/scst/sgv_cache.sgml ++++ linux-3.2/Documentation/scst/sgv_cache.sgml +@@ -0,0 +1,335 @@ ++<!doctype linuxdoc system> ++ ++<article> ++ ++<title> ++SCST SGV cache description ++</title> ++ ++<author> ++ <name>Vladislav Bolkhovitin</name> ++</author> ++ ++<date>Version 2.1.0</date> ++ ++<toc> ++ ++<sect>Introduction ++ ++<p> ++SCST SGV cache is a memory management subsystem in SCST. One can call it ++a "memory pool", but Linux kernel already have a mempool interface, ++which serves different purposes. SGV cache provides to SCST core, target ++drivers and backend dev handlers facilities to allocate, build and cache ++SG vectors for data buffers. The main advantage of it is the caching ++facility, when it doesn't free to the system each vector, which is not ++used anymore, but keeps it for a while (possibly indefinitely) to let it ++be reused by the next consecutive command. This allows to: ++ ++<itemize> ++ ++<item> Reduce commands processing latencies and, hence, improve performance; ++ ++<item> Make commands processing latencies predictable, which is essential ++ for RT applications. ++ ++</itemize> ++ ++The freed SG vectors are kept by the SGV cache either for some (possibly ++indefinite) time, or, optionally, until the system needs more memory and ++asks to free some using the set_shrinker() interface. Also the SGV cache ++allows to: ++ ++<itemize> ++ ++<item> Cluster pages together. "Cluster" means merging adjacent pages in a ++single SG entry. It allows to have less SG entries in the resulting SG ++vector, hence improve performance handling it as well as allow to ++work with bigger buffers on hardware with limited SG capabilities. ++ ++<item> Set custom page allocator functions. For instance, scst_user device ++handler uses this facility to eliminate unneeded mapping/unmapping of ++user space pages and avoid unneeded IOCTL calls for buffers allocations. ++In fileio_tgt application, which uses a regular malloc() function to ++allocate data buffers, this facility allows ~30% less CPU load and ++considerable performance increase. ++ ++<item> Prevent each initiator or all initiators altogether to allocate too ++much memory and DoS the target. Consider 10 initiators, which can have ++access to 10 devices each. Any of them can queue up to 64 commands, each ++can transfer up to 1MB of data. So, all of them in a peak can allocate ++up to 10*10*64 = ~6.5GB of memory for data buffers. This amount must be ++limited somehow and the SGV cache performs this function. ++ ++</itemize> ++ ++<sect> Implementation ++ ++<p> ++From implementation POV the SGV cache is a simple extension of the kmem ++cache. It can work in 2 modes: ++ ++<enum> ++ ++<item> With fixed size buffers. ++ ++<item> With a set of power 2 size buffers. In this mode each SGV cache ++(struct sgv_pool) has SGV_POOL_ELEMENTS (11 currently) of kmem caches. ++Each of those kmem caches keeps SGV cache objects (struct sgv_pool_obj) ++corresponding to SG vectors with size of order X pages. For instance, ++request to allocate 4 pages will be served from kmem cache[2&rsqb, since the ++order of the of number of requested pages is 2. If later request to ++allocate 11KB comes, the same SG vector with 4 pages will be reused (see ++below). This mode is in average allows less memory overhead comparing ++with the fixed size buffers mode. ++ ++</enum> ++ ++Consider how the SGV cache works in the set of buffers mode. When a ++request to allocate new SG vector comes, sgv_pool_alloc() via ++sgv_get_obj() checks if there is already a cached vector with that ++order. If yes, then that vector will be reused and its length, if ++necessary, will be modified to match the requested size. In the above ++example request for 11KB buffer, 4 pages vector will be reused and ++modified using trans_tbl to contain 3 pages and the last entry will be ++modified to contain the requested length - 2*PAGE_SIZE. If there is no ++cached object, then a new sgv_pool_obj will be allocated from the ++corresponding kmem cache, chosen by the order of number of requested ++pages. Then that vector will be filled by pages and returned. ++ ++In the fixed size buffers mode the SGV cache works similarly, except ++that it always allocate buffer with the predefined fixed size. I.e. ++even for 4K request the whole buffer with predefined size, say, 1MB, ++will be used. ++ ++In both modes, if size of a request exceeds the maximum allowed for ++caching buffer size, the requested buffer will be allocated, but not ++cached. ++ ++Freed cached sgv_pool_obj objects are actually freed to the system ++either by the purge work, which is scheduled once in 60 seconds, or in ++sgv_shrink() called by system, when it's asking for memory. ++ ++<sect> Interface ++ ++<sect1> sgv_pool *sgv_pool_create() ++ ++<p> ++<verb> ++struct sgv_pool *sgv_pool_create( ++ const char *name, ++ enum sgv_clustering_types clustered, int single_alloc_pages, ++ bool shared, int purge_interval) ++</verb> ++ ++This function creates and initializes an SGV cache. It has the following ++arguments: ++ ++<itemize> ++ ++<item> <bf/name/ - the name of the SGV cache ++ ++<item> <bf/clustered/ - sets type of the pages clustering. The type can be: ++ ++ <itemize> ++ ++ <item> <bf/sgv_no_clustering/ - no clustering performed. ++ ++ <item> <bf/sgv_tail_clustering/ - a page will only be merged with the latest ++ previously allocated page, so the order of pages in the SG will be ++ preserved ++ ++ <item> <bf/sgv_full_clustering/ - free merging of pages at any place in ++ the SG is allowed. This mode usually provides the best merging ++ rate. ++ ++ </itemize> ++ ++<item> <bf/single_alloc_pages/ - if 0, then the SGV cache will work in the set of ++ power 2 size buffers mode. If >0, then the SGV cache will work in the ++ fixed size buffers mode. In this case single_alloc_pages sets the ++ size of each buffer in pages. ++ ++<item> <bf/shared/ - sets if the SGV cache can be shared between devices or not. ++ The cache sharing allowed only between devices created inside the same ++ address space. If an SGV cache is shared, each subsequent call of ++ sgv_pool_create() with the same cache name will not create a new cache, ++ but instead return a reference to it. ++ ++<item> <bf/purge_interval/ - sets the cache purging interval. I.e. an SG buffer ++ will be freed if it's unused for time t purge_interval <= t < ++ 2*purge_interval. If purge_interval is 0, then the default interval ++ will be used (60 seconds). If purge_interval <0, then the automatic ++ purging will be disabled. Shrinking by the system's demand will also ++ be disabled. ++ ++</itemize> ++ ++Returns the resulting SGV cache or NULL in case of any error. ++ ++<sect1> void sgv_pool_del() ++ ++<p> ++<verb> ++void sgv_pool_del( ++ struct sgv_pool *pool) ++</verb> ++ ++This function deletes the corresponding SGV cache. If the cache is ++shared, it will decrease its reference counter. If the reference counter ++reaches 0, the cache will be destroyed. ++ ++<sect1> void sgv_pool_flush() ++ ++<p> ++<verb> ++void sgv_pool_flush( ++ struct sgv_pool *pool) ++</verb> ++ ++This function flushes, i.e. frees, all the cached entries in the SGV ++cache. ++ ++<sect1> void sgv_pool_set_allocator() ++ ++<p> ++<verb> ++void sgv_pool_set_allocator( ++ struct sgv_pool *pool, ++ struct page *(*alloc_pages_fn)(struct scatterlist *sg, gfp_t gfp, void *priv), ++ void (*free_pages_fn)(struct scatterlist *sg, int sg_count, void *priv)); ++</verb> ++ ++This function allows to set for the SGV cache a custom pages allocator. For ++instance, scst_user uses such function to supply to the cache mapped from ++user space pages. ++ ++<bf/alloc_pages_fn()/ has the following parameters: ++ ++<itemize> ++ ++<item> <bf/sg/ - SG entry, to which the allocated page should be added. ++ ++<item> <bf/gfp/ - the allocation GFP flags ++ ++<item> <bf/priv/ - pointer to a private data supplied to sgv_pool_alloc() ++ ++</itemize> ++ ++This function should return the allocated page or NULL, if no page was ++allocated. ++ ++ ++<bf/free_pages_fn()/ has the following parameters: ++ ++<itemize> ++ ++<item> <bf/sg/ - SG vector to free ++ ++<item> <bf/sg_count/ - number of SG entries in the sg ++ ++<item> <bf/priv/ - pointer to a private data supplied to the ++corresponding sgv_pool_alloc() ++ ++</itemize> ++ ++<sect1> struct scatterlist *sgv_pool_alloc() ++ ++<p> ++<verb> ++struct scatterlist *sgv_pool_alloc( ++ struct sgv_pool *pool, ++ unsigned int size, ++ gfp_t gfp_mask, ++ int flags, ++ int *count, ++ struct sgv_pool_obj **sgv, ++ struct scst_mem_lim *mem_lim, ++ void *priv) ++</verb> ++ ++This function allocates an SG vector from the SGV cache. It has the ++following parameters: ++ ++<itemize> ++ ++<item> <bf/pool/ - the cache to alloc from ++ ++<item> <bf/size/ - size of the resulting SG vector in bytes ++ ++<item> <bf/gfp_mask/ - the allocation mask ++ ++<item> <bf/flags/ - the allocation flags. The following flags are possible and ++ can be set using OR operation: ++ ++ <enum> ++ ++ <item> <bf/SGV_POOL_ALLOC_NO_CACHED/ - the SG vector must not be cached. ++ ++ <item> <bf/SGV_POOL_NO_ALLOC_ON_CACHE_MISS/ - don't do an allocation on a ++ cache miss. ++ ++ <item> <bf/SGV_POOL_RETURN_OBJ_ON_ALLOC_FAIL/ - return an empty SGV object, ++ i.e. without the SG vector, if the allocation can't be completed. ++ For instance, because SGV_POOL_NO_ALLOC_ON_CACHE_MISS flag set. ++ ++ </enum> ++ ++<item> <bf/count/ - the resulting count of SG entries in the resulting SG vector. ++ ++<item> <bf/sgv/ - the resulting SGV object. It should be used to free the ++ resulting SG vector. ++ ++<item> <bf/mem_lim/ - memory limits, see below. ++ ++<item> <bf/priv/ - pointer to private for this allocation data. This pointer will ++ be supplied to alloc_pages_fn() and free_pages_fn() and can be ++ retrieved by sgv_get_priv(). ++ ++</itemize> ++ ++This function returns pointer to the resulting SG vector or NULL in case ++of any error. ++ ++<sect1> void sgv_pool_free() ++ ++<p> ++<verb> ++void sgv_pool_free( ++ struct sgv_pool_obj *sgv, ++ struct scst_mem_lim *mem_lim) ++</verb> ++ ++This function frees previously allocated SG vector, referenced by SGV ++cache object sgv. ++ ++<sect1> void *sgv_get_priv(struct sgv_pool_obj *sgv) ++ ++<p> ++<verb> ++void *sgv_get_priv( ++ struct sgv_pool_obj *sgv) ++</verb> ++ ++This function allows to get the allocation private data for this SGV ++cache object sgv. The private data are set by sgv_pool_alloc(). ++ ++<sect1> void scst_init_mem_lim() ++ ++<p> ++<verb> ++void scst_init_mem_lim( ++ struct scst_mem_lim *mem_lim) ++</verb> ++ ++This function initializes memory limits structure mem_lim according to ++the current system configuration. This structure should be latter used ++to track and limit allocated by one or more SGV caches memory. ++ ++ ++<sect> Runtime information and statistics. ++ ++<p> ++Runtime information and statistics is available in /sys/kernel/scst_tgt/sgv. ++ ++</article> +diff -uprN orig/linux-3.2/include/scst/scst_user.h linux-3.2/include/scst/scst_user.h +--- orig/linux-3.2/include/scst/scst_user.h ++++ linux-3.2/include/scst/scst_user.h +@@ -0,0 +1,320 @@ ++/* ++ * include/scst_user.h ++ * ++ * Copyright (C) 2007 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * Contains constants and data structures for scst_user module. ++ * See http://scst.sourceforge.net/doc/scst_user_spec.txt or ++ * scst_user_spec.txt for description. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#ifndef __SCST_USER_H ++#define __SCST_USER_H ++ ++#include <scst/scst_const.h> ++ ++#define DEV_USER_NAME "scst_user" ++#define DEV_USER_PATH "/dev/" ++#define DEV_USER_VERSION_NAME SCST_VERSION_NAME ++#define DEV_USER_VERSION \ ++ DEV_USER_VERSION_NAME "$Revision: 3281 $" SCST_CONST_VERSION ++ ++#define SCST_USER_PARSE_STANDARD 0 ++#define SCST_USER_PARSE_CALL 1 ++#define SCST_USER_PARSE_EXCEPTION 2 ++#define SCST_USER_MAX_PARSE_OPT SCST_USER_PARSE_EXCEPTION ++ ++#define SCST_USER_ON_FREE_CMD_CALL 0 ++#define SCST_USER_ON_FREE_CMD_IGNORE 1 ++#define SCST_USER_MAX_ON_FREE_CMD_OPT SCST_USER_ON_FREE_CMD_IGNORE ++ ++#define SCST_USER_MEM_NO_REUSE 0 ++#define SCST_USER_MEM_REUSE_READ 1 ++#define SCST_USER_MEM_REUSE_WRITE 2 ++#define SCST_USER_MEM_REUSE_ALL 3 ++#define SCST_USER_MAX_MEM_REUSE_OPT SCST_USER_MEM_REUSE_ALL ++ ++#define SCST_USER_PARTIAL_TRANSFERS_NOT_SUPPORTED 0 ++#define SCST_USER_PARTIAL_TRANSFERS_SUPPORTED_ORDERED 1 ++#define SCST_USER_PARTIAL_TRANSFERS_SUPPORTED 2 ++#define SCST_USER_MAX_PARTIAL_TRANSFERS_OPT \ ++ SCST_USER_PARTIAL_TRANSFERS_SUPPORTED ++ ++#ifndef aligned_u64 ++#define aligned_u64 uint64_t __attribute__((aligned(8))) ++#endif ++ ++/************************************************************* ++ ** Private ucmd states ++ *************************************************************/ ++#define UCMD_STATE_NEW 0 ++#define UCMD_STATE_PARSING 1 ++#define UCMD_STATE_BUF_ALLOCING 2 ++#define UCMD_STATE_EXECING 3 ++#define UCMD_STATE_ON_FREEING 4 ++#define UCMD_STATE_ON_FREE_SKIPPED 5 ++#define UCMD_STATE_ON_CACHE_FREEING 6 ++#define UCMD_STATE_TM_EXECING 7 ++ ++#define UCMD_STATE_ATTACH_SESS 0x20 ++#define UCMD_STATE_DETACH_SESS 0x21 ++ ++struct scst_user_opt { ++ uint8_t parse_type; ++ uint8_t on_free_cmd_type; ++ uint8_t memory_reuse_type; ++ uint8_t partial_transfers_type; ++ int32_t partial_len; ++ ++ /* SCSI control mode page parameters, see SPC */ ++ uint8_t tst; ++ uint8_t queue_alg; ++ uint8_t tas; ++ uint8_t swp; ++ uint8_t d_sense; ++ ++ uint8_t has_own_order_mgmt; ++}; ++ ++struct scst_user_dev_desc { ++ aligned_u64 version_str; ++ aligned_u64 license_str; ++ uint8_t type; ++ uint8_t sgv_shared; ++ uint8_t sgv_disable_clustered_pool; ++ int32_t sgv_single_alloc_pages; ++ int32_t sgv_purge_interval; ++ struct scst_user_opt opt; ++ uint32_t block_size; ++ uint8_t enable_pr_cmds_notifications; ++ char name[SCST_MAX_NAME]; ++ char sgv_name[SCST_MAX_NAME]; ++}; ++ ++struct scst_user_sess { ++ aligned_u64 sess_h; ++ aligned_u64 lun; ++ uint16_t threads_num; ++ uint8_t rd_only; ++ uint16_t scsi_transport_version; ++ uint16_t phys_transport_version; ++ char initiator_name[SCST_MAX_EXTERNAL_NAME]; ++ char target_name[SCST_MAX_EXTERNAL_NAME]; ++}; ++ ++struct scst_user_scsi_cmd_parse { ++ aligned_u64 sess_h; ++ ++ uint8_t cdb[SCST_MAX_CDB_SIZE]; ++ uint16_t cdb_len; ++ ++ int32_t timeout; ++ int32_t bufflen; ++ int32_t out_bufflen; ++ ++ uint32_t op_flags; ++ ++ uint8_t queue_type; ++ uint8_t data_direction; ++ ++ uint8_t expected_values_set; ++ uint8_t expected_data_direction; ++ int32_t expected_transfer_len; ++ int32_t expected_out_transfer_len; ++ ++ uint32_t sn; ++}; ++ ++struct scst_user_scsi_cmd_alloc_mem { ++ aligned_u64 sess_h; ++ ++ uint8_t cdb[SCST_MAX_CDB_SIZE]; ++ uint16_t cdb_len; ++ ++ int32_t alloc_len; ++ ++ uint8_t queue_type; ++ uint8_t data_direction; ++ ++ uint32_t sn; ++}; ++ ++struct scst_user_scsi_cmd_exec { ++ aligned_u64 sess_h; ++ ++ uint8_t cdb[SCST_MAX_CDB_SIZE]; ++ uint16_t cdb_len; ++ ++ int32_t data_len; ++ int32_t bufflen; ++ int32_t alloc_len; ++ aligned_u64 pbuf; ++ uint8_t queue_type; ++ uint8_t data_direction; ++ uint8_t partial; ++ int32_t timeout; ++ ++ aligned_u64 p_out_buf; ++ int32_t out_bufflen; ++ ++ uint32_t sn; ++ ++ uint32_t parent_cmd_h; ++ int32_t parent_cmd_data_len; ++ uint32_t partial_offset; ++}; ++ ++struct scst_user_scsi_on_free_cmd { ++ aligned_u64 pbuf; ++ int32_t resp_data_len; ++ uint8_t buffer_cached; ++ uint8_t aborted; ++ uint8_t status; ++ uint8_t delivery_status; ++}; ++ ++struct scst_user_on_cached_mem_free { ++ aligned_u64 pbuf; ++}; ++ ++struct scst_user_tm { ++ aligned_u64 sess_h; ++ uint32_t fn; ++ uint32_t cmd_h_to_abort; ++ uint32_t cmd_sn; ++ uint8_t cmd_sn_set; ++}; ++ ++struct scst_user_get_cmd { ++ uint32_t cmd_h; ++ uint32_t subcode; ++ union { ++ aligned_u64 preply; ++ struct scst_user_sess sess; ++ struct scst_user_scsi_cmd_parse parse_cmd; ++ struct scst_user_scsi_cmd_alloc_mem alloc_cmd; ++ struct scst_user_scsi_cmd_exec exec_cmd; ++ struct scst_user_scsi_on_free_cmd on_free_cmd; ++ struct scst_user_on_cached_mem_free on_cached_mem_free; ++ struct scst_user_tm tm_cmd; ++ }; ++}; ++ ++/* Be careful adding new members here, this structure is allocated on stack! */ ++struct scst_user_scsi_cmd_reply_parse { ++ uint8_t status; ++ union { ++ struct { ++ uint8_t queue_type; ++ uint8_t data_direction; ++ uint16_t cdb_len; ++ uint32_t op_flags; ++ int32_t data_len; ++ int32_t bufflen; ++ int32_t out_bufflen; ++ }; ++ struct { ++ uint8_t sense_len; ++ aligned_u64 psense_buffer; ++ }; ++ }; ++}; ++ ++/* Be careful adding new members here, this structure is allocated on stack! */ ++struct scst_user_scsi_cmd_reply_alloc_mem { ++ aligned_u64 pbuf; ++}; ++ ++/* Be careful adding new members here, this structure is allocated on stack! */ ++struct scst_user_scsi_cmd_reply_exec { ++ int32_t resp_data_len; ++ aligned_u64 pbuf; ++ ++#define SCST_EXEC_REPLY_BACKGROUND 0 ++#define SCST_EXEC_REPLY_COMPLETED 1 ++ uint8_t reply_type; ++ ++ uint8_t status; ++ uint8_t sense_len; ++ aligned_u64 psense_buffer; ++}; ++ ++/* Be careful adding new members here, this structure is allocated on stack! */ ++struct scst_user_reply_cmd { ++ uint32_t cmd_h; ++ uint32_t subcode; ++ union { ++ int32_t result; ++ struct scst_user_scsi_cmd_reply_parse parse_reply; ++ struct scst_user_scsi_cmd_reply_alloc_mem alloc_reply; ++ struct scst_user_scsi_cmd_reply_exec exec_reply; ++ }; ++}; ++ ++/* Be careful adding new members here, this structure is allocated on stack! */ ++struct scst_user_get_ext_cdb { ++ uint32_t cmd_h; ++ aligned_u64 ext_cdb_buffer; ++}; ++ ++/* Be careful adding new members here, this structure is allocated on stack! */ ++struct scst_user_prealloc_buffer_in { ++ aligned_u64 pbuf; ++ uint32_t bufflen; ++ uint8_t for_clust_pool; ++}; ++ ++/* Be careful adding new members here, this structure is allocated on stack! */ ++struct scst_user_prealloc_buffer_out { ++ uint32_t cmd_h; ++}; ++ ++/* Be careful adding new members here, this structure is allocated on stack! */ ++union scst_user_prealloc_buffer { ++ struct scst_user_prealloc_buffer_in in; ++ struct scst_user_prealloc_buffer_out out; ++}; ++ ++#define SCST_USER_REGISTER_DEVICE _IOW('u', 1, struct scst_user_dev_desc) ++#define SCST_USER_UNREGISTER_DEVICE _IO('u', 2) ++#define SCST_USER_SET_OPTIONS _IOW('u', 3, struct scst_user_opt) ++#define SCST_USER_GET_OPTIONS _IOR('u', 4, struct scst_user_opt) ++#define SCST_USER_REPLY_AND_GET_CMD _IOWR('u', 5, struct scst_user_get_cmd) ++#define SCST_USER_REPLY_CMD _IOW('u', 6, struct scst_user_reply_cmd) ++#define SCST_USER_FLUSH_CACHE _IO('u', 7) ++#define SCST_USER_DEVICE_CAPACITY_CHANGED _IO('u', 8) ++#define SCST_USER_GET_EXTENDED_CDB _IOWR('u', 9, struct scst_user_get_ext_cdb) ++#define SCST_USER_PREALLOC_BUFFER _IOWR('u', 10, union scst_user_prealloc_buffer) ++ ++/* Values for scst_user_get_cmd.subcode */ ++#define SCST_USER_ATTACH_SESS \ ++ _IOR('s', UCMD_STATE_ATTACH_SESS, struct scst_user_sess) ++#define SCST_USER_DETACH_SESS \ ++ _IOR('s', UCMD_STATE_DETACH_SESS, struct scst_user_sess) ++#define SCST_USER_PARSE \ ++ _IOWR('s', UCMD_STATE_PARSING, struct scst_user_scsi_cmd_parse) ++#define SCST_USER_ALLOC_MEM \ ++ _IOWR('s', UCMD_STATE_BUF_ALLOCING, struct scst_user_scsi_cmd_alloc_mem) ++#define SCST_USER_EXEC \ ++ _IOWR('s', UCMD_STATE_EXECING, struct scst_user_scsi_cmd_exec) ++#define SCST_USER_ON_FREE_CMD \ ++ _IOR('s', UCMD_STATE_ON_FREEING, struct scst_user_scsi_on_free_cmd) ++#define SCST_USER_ON_CACHED_MEM_FREE \ ++ _IOR('s', UCMD_STATE_ON_CACHE_FREEING, \ ++ struct scst_user_on_cached_mem_free) ++#define SCST_USER_TASK_MGMT \ ++ _IOWR('s', UCMD_STATE_TM_EXECING, struct scst_user_tm) ++ ++#endif /* __SCST_USER_H */ +diff -uprN orig/linux-3.2/drivers/scst/dev_handlers/scst_user.c linux-3.2/drivers/scst/dev_handlers/scst_user.c +--- orig/linux-3.2/drivers/scst/dev_handlers/scst_user.c ++++ linux-3.2/drivers/scst/dev_handlers/scst_user.c +@@ -0,0 +1,3751 @@ ++/* ++ * scst_user.c ++ * ++ * Copyright (C) 2007 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * SCSI virtual user space device handler ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/kthread.h> ++#include <linux/delay.h> ++#include <linux/poll.h> ++#include <linux/stddef.h> ++#include <linux/slab.h> ++ ++#define LOG_PREFIX DEV_USER_NAME ++ ++#include <scst/scst.h> ++#include <scst/scst_user.h> ++#include "scst_dev_handler.h" ++ ++#define DEV_USER_CMD_HASH_ORDER 6 ++#define DEV_USER_ATTACH_TIMEOUT (5*HZ) ++ ++struct scst_user_dev { ++ struct rw_semaphore dev_rwsem; ++ ++ /* ++ * Must be kept here, because it's needed on the cleanup time, ++ * when corresponding scst_dev is already dead. ++ */ ++ struct scst_cmd_threads udev_cmd_threads; ++ ++ /* Protected by udev_cmd_threads.cmd_list_lock */ ++ struct list_head ready_cmd_list; ++ ++ /* Protected by dev_rwsem or don't need any protection */ ++ unsigned int blocking:1; ++ unsigned int cleanup_done:1; ++ unsigned int tst:3; ++ unsigned int queue_alg:4; ++ unsigned int tas:1; ++ unsigned int swp:1; ++ unsigned int d_sense:1; ++ unsigned int has_own_order_mgmt:1; ++ ++ int (*generic_parse)(struct scst_cmd *cmd, ++ int (*get_block)(struct scst_cmd *cmd)); ++ ++ int block; ++ int def_block; ++ ++ struct scst_mem_lim udev_mem_lim; ++ struct sgv_pool *pool; ++ struct sgv_pool *pool_clust; ++ ++ uint8_t parse_type; ++ uint8_t on_free_cmd_type; ++ uint8_t memory_reuse_type; ++ uint8_t partial_transfers_type; ++ uint32_t partial_len; ++ ++ struct scst_dev_type devtype; ++ ++ /* Both protected by udev_cmd_threads.cmd_list_lock */ ++ unsigned int handle_counter; ++ struct list_head ucmd_hash[1 << DEV_USER_CMD_HASH_ORDER]; ++ ++ struct scst_device *sdev; ++ ++ int virt_id; ++ struct list_head dev_list_entry; ++ char name[SCST_MAX_NAME]; ++ ++ struct list_head cleanup_list_entry; ++ struct completion cleanup_cmpl; ++}; ++ ++/* Most fields are unprotected, since only one thread at time can access them */ ++struct scst_user_cmd { ++ struct scst_cmd *cmd; ++ struct scst_user_dev *dev; ++ ++ atomic_t ucmd_ref; ++ ++ unsigned int buff_cached:1; ++ unsigned int buf_dirty:1; ++ unsigned int background_exec:1; ++ unsigned int aborted:1; ++ ++ struct scst_user_cmd *buf_ucmd; ++ ++ int cur_data_page; ++ int num_data_pages; ++ int first_page_offset; ++ unsigned long ubuff; ++ struct page **data_pages; ++ struct sgv_pool_obj *sgv; ++ ++ /* ++ * Special flags, which can be accessed asynchronously (hence "long"). ++ * Protected by udev_cmd_threads.cmd_list_lock. ++ */ ++ unsigned long sent_to_user:1; ++ unsigned long jammed:1; ++ unsigned long this_state_unjammed:1; ++ unsigned long seen_by_user:1; /* here only as a small optimization */ ++ ++ unsigned int state; ++ ++ struct list_head ready_cmd_list_entry; ++ ++ unsigned int h; ++ struct list_head hash_list_entry; ++ ++ int user_cmd_payload_len; ++ struct scst_user_get_cmd user_cmd; ++ ++ /* cmpl used only by ATTACH_SESS, mcmd used only by TM */ ++ union { ++ struct completion *cmpl; ++ struct scst_mgmt_cmd *mcmd; ++ }; ++ int result; ++}; ++ ++static struct scst_user_cmd *dev_user_alloc_ucmd(struct scst_user_dev *dev, ++ gfp_t gfp_mask); ++static void dev_user_free_ucmd(struct scst_user_cmd *ucmd); ++ ++static int dev_user_parse(struct scst_cmd *cmd); ++static int dev_user_alloc_data_buf(struct scst_cmd *cmd); ++static int dev_user_exec(struct scst_cmd *cmd); ++static void dev_user_on_free_cmd(struct scst_cmd *cmd); ++static int dev_user_task_mgmt_fn(struct scst_mgmt_cmd *mcmd, ++ struct scst_tgt_dev *tgt_dev); ++ ++static int dev_user_disk_done(struct scst_cmd *cmd); ++static int dev_user_tape_done(struct scst_cmd *cmd); ++ ++static struct page *dev_user_alloc_pages(struct scatterlist *sg, ++ gfp_t gfp_mask, void *priv); ++static void dev_user_free_sg_entries(struct scatterlist *sg, int sg_count, ++ void *priv); ++ ++static void dev_user_add_to_ready(struct scst_user_cmd *ucmd); ++ ++static void dev_user_unjam_cmd(struct scst_user_cmd *ucmd, int busy, ++ unsigned long *flags); ++ ++static int dev_user_process_reply_on_free(struct scst_user_cmd *ucmd); ++static int dev_user_process_reply_tm_exec(struct scst_user_cmd *ucmd, ++ int status); ++static int dev_user_process_reply_sess(struct scst_user_cmd *ucmd, int status); ++static int dev_user_register_dev(struct file *file, ++ const struct scst_user_dev_desc *dev_desc); ++static int dev_user_unregister_dev(struct file *file); ++static int dev_user_flush_cache(struct file *file); ++static int dev_user_capacity_changed(struct file *file); ++static int dev_user_prealloc_buffer(struct file *file, void __user *arg); ++static int __dev_user_set_opt(struct scst_user_dev *dev, ++ const struct scst_user_opt *opt); ++static int dev_user_set_opt(struct file *file, const struct scst_user_opt *opt); ++static int dev_user_get_opt(struct file *file, void __user *arg); ++ ++static unsigned int dev_user_poll(struct file *filp, poll_table *wait); ++static long dev_user_ioctl(struct file *file, unsigned int cmd, ++ unsigned long arg); ++static int dev_user_release(struct inode *inode, struct file *file); ++static int dev_user_exit_dev(struct scst_user_dev *dev); ++ ++static ssize_t dev_user_sysfs_commands_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf); ++ ++static struct kobj_attribute dev_user_commands_attr = ++ __ATTR(commands, S_IRUGO, dev_user_sysfs_commands_show, NULL); ++ ++static const struct attribute *dev_user_dev_attrs[] = { ++ &dev_user_commands_attr.attr, ++ NULL, ++}; ++ ++static int dev_usr_parse(struct scst_cmd *cmd); ++ ++/** Data **/ ++ ++static struct kmem_cache *user_cmd_cachep; ++static struct kmem_cache *user_get_cmd_cachep; ++ ++static DEFINE_MUTEX(dev_priv_mutex); ++ ++static const struct file_operations dev_user_fops = { ++ .poll = dev_user_poll, ++ .unlocked_ioctl = dev_user_ioctl, ++#ifdef CONFIG_COMPAT ++ .compat_ioctl = dev_user_ioctl, ++#endif ++ .release = dev_user_release, ++}; ++ ++static struct scst_dev_type dev_user_devtype = { ++ .name = DEV_USER_NAME, ++ .type = -1, ++ .parse = dev_usr_parse, ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ .default_trace_flags = SCST_DEFAULT_DEV_LOG_FLAGS, ++ .trace_flags = &trace_flag, ++#endif ++}; ++ ++static int dev_user_major; ++ ++static struct class *dev_user_sysfs_class; ++ ++static DEFINE_SPINLOCK(dev_list_lock); ++static LIST_HEAD(dev_list); ++ ++static DEFINE_SPINLOCK(cleanup_lock); ++static LIST_HEAD(cleanup_list); ++static DECLARE_WAIT_QUEUE_HEAD(cleanup_list_waitQ); ++static struct task_struct *cleanup_thread; ++ ++/* ++ * Skip this command if result is not 0. Must be called under ++ * udev_cmd_threads.cmd_list_lock and IRQ off. ++ */ ++static inline bool ucmd_get_check(struct scst_user_cmd *ucmd) ++{ ++ int r = atomic_inc_return(&ucmd->ucmd_ref); ++ int res; ++ if (unlikely(r == 1)) { ++ TRACE_DBG("ucmd %p is being destroyed", ucmd); ++ atomic_dec(&ucmd->ucmd_ref); ++ res = true; ++ /* ++ * Necessary code is serialized by cmd_list_lock in ++ * cmd_remove_hash() ++ */ ++ } else { ++ TRACE_DBG("ucmd %p, new ref_cnt %d", ucmd, ++ atomic_read(&ucmd->ucmd_ref)); ++ res = false; ++ } ++ return res; ++} ++ ++static inline void ucmd_get(struct scst_user_cmd *ucmd) ++{ ++ TRACE_DBG("ucmd %p, ucmd_ref %d", ucmd, atomic_read(&ucmd->ucmd_ref)); ++ atomic_inc(&ucmd->ucmd_ref); ++ /* ++ * For the same reason as in kref_get(). Let's be safe and ++ * always do it. ++ */ ++ smp_mb__after_atomic_inc(); ++} ++ ++/* Must not be called under cmd_list_lock!! */ ++static inline void ucmd_put(struct scst_user_cmd *ucmd) ++{ ++ TRACE_DBG("ucmd %p, ucmd_ref %d", ucmd, atomic_read(&ucmd->ucmd_ref)); ++ ++ EXTRACHECKS_BUG_ON(atomic_read(&ucmd->ucmd_ref) == 0); ++ ++ if (atomic_dec_and_test(&ucmd->ucmd_ref)) ++ dev_user_free_ucmd(ucmd); ++} ++ ++static inline int calc_num_pg(unsigned long buf, int len) ++{ ++ len += buf & ~PAGE_MASK; ++ return (len >> PAGE_SHIFT) + ((len & ~PAGE_MASK) != 0); ++} ++ ++static void __dev_user_not_reg(void) ++{ ++ TRACE_MGMT_DBG("%s", "Device not registered"); ++ return; ++} ++ ++static inline int dev_user_check_reg(struct scst_user_dev *dev) ++{ ++ if (dev == NULL) { ++ __dev_user_not_reg(); ++ return -ENODEV; ++ } ++ return 0; ++} ++ ++static inline int scst_user_cmd_hashfn(int h) ++{ ++ return h & ((1 << DEV_USER_CMD_HASH_ORDER) - 1); ++} ++ ++static inline struct scst_user_cmd *__ucmd_find_hash(struct scst_user_dev *dev, ++ unsigned int h) ++{ ++ struct list_head *head; ++ struct scst_user_cmd *ucmd; ++ ++ head = &dev->ucmd_hash[scst_user_cmd_hashfn(h)]; ++ list_for_each_entry(ucmd, head, hash_list_entry) { ++ if (ucmd->h == h) { ++ TRACE_DBG("Found ucmd %p", ucmd); ++ return ucmd; ++ } ++ } ++ return NULL; ++} ++ ++static void cmd_insert_hash(struct scst_user_cmd *ucmd) ++{ ++ struct list_head *head; ++ struct scst_user_dev *dev = ucmd->dev; ++ struct scst_user_cmd *u; ++ unsigned long flags; ++ ++ spin_lock_irqsave(&dev->udev_cmd_threads.cmd_list_lock, flags); ++ do { ++ ucmd->h = dev->handle_counter++; ++ u = __ucmd_find_hash(dev, ucmd->h); ++ } while (u != NULL); ++ head = &dev->ucmd_hash[scst_user_cmd_hashfn(ucmd->h)]; ++ list_add_tail(&ucmd->hash_list_entry, head); ++ spin_unlock_irqrestore(&dev->udev_cmd_threads.cmd_list_lock, flags); ++ ++ TRACE_DBG("Inserted ucmd %p, h=%d (dev %s)", ucmd, ucmd->h, dev->name); ++ return; ++} ++ ++static inline void cmd_remove_hash(struct scst_user_cmd *ucmd) ++{ ++ unsigned long flags; ++ ++ spin_lock_irqsave(&ucmd->dev->udev_cmd_threads.cmd_list_lock, flags); ++ list_del(&ucmd->hash_list_entry); ++ spin_unlock_irqrestore(&ucmd->dev->udev_cmd_threads.cmd_list_lock, flags); ++ ++ TRACE_DBG("Removed ucmd %p, h=%d", ucmd, ucmd->h); ++ return; ++} ++ ++static void dev_user_free_ucmd(struct scst_user_cmd *ucmd) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_MEM("Freeing ucmd %p", ucmd); ++ ++ cmd_remove_hash(ucmd); ++ EXTRACHECKS_BUG_ON(ucmd->cmd != NULL); ++ ++ kmem_cache_free(user_cmd_cachep, ucmd); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static struct page *dev_user_alloc_pages(struct scatterlist *sg, ++ gfp_t gfp_mask, void *priv) ++{ ++ struct scst_user_cmd *ucmd = priv; ++ int offset = 0; ++ ++ TRACE_ENTRY(); ++ ++ /* *sg supposed to be zeroed */ ++ ++ TRACE_MEM("ucmd %p, ubuff %lx, ucmd->cur_data_page %d", ucmd, ++ ucmd->ubuff, ucmd->cur_data_page); ++ ++ if (ucmd->cur_data_page == 0) { ++ TRACE_MEM("ucmd->first_page_offset %d", ++ ucmd->first_page_offset); ++ offset = ucmd->first_page_offset; ++ ucmd_get(ucmd); ++ } ++ ++ if (ucmd->cur_data_page >= ucmd->num_data_pages) ++ goto out; ++ ++ sg_set_page(sg, ucmd->data_pages[ucmd->cur_data_page], ++ PAGE_SIZE - offset, offset); ++ ucmd->cur_data_page++; ++ ++ TRACE_MEM("page=%p, length=%d, offset=%d", sg_page(sg), sg->length, ++ sg->offset); ++ TRACE_BUFFER("Page data", sg_virt(sg), sg->length); ++ ++out: ++ TRACE_EXIT(); ++ return sg_page(sg); ++} ++ ++static void dev_user_on_cached_mem_free(struct scst_user_cmd *ucmd) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_MEM("Preparing ON_CACHED_MEM_FREE (ucmd %p, h %d, ubuff %lx)", ++ ucmd, ucmd->h, ucmd->ubuff); ++ ++ ucmd->user_cmd_payload_len = ++ offsetof(struct scst_user_get_cmd, on_cached_mem_free) + ++ sizeof(ucmd->user_cmd.on_cached_mem_free); ++ ucmd->user_cmd.cmd_h = ucmd->h; ++ ucmd->user_cmd.subcode = SCST_USER_ON_CACHED_MEM_FREE; ++ ucmd->user_cmd.on_cached_mem_free.pbuf = ucmd->ubuff; ++ ++ ucmd->state = UCMD_STATE_ON_CACHE_FREEING; ++ ++ dev_user_add_to_ready(ucmd); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void dev_user_unmap_buf(struct scst_user_cmd *ucmd) ++{ ++ int i; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MEM("Unmapping data pages (ucmd %p, ubuff %lx, num %d)", ucmd, ++ ucmd->ubuff, ucmd->num_data_pages); ++ ++ for (i = 0; i < ucmd->num_data_pages; i++) { ++ struct page *page = ucmd->data_pages[i]; ++ ++ if (ucmd->buf_dirty) ++ SetPageDirty(page); ++ ++ page_cache_release(page); ++ } ++ ++ kfree(ucmd->data_pages); ++ ucmd->data_pages = NULL; ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void __dev_user_free_sg_entries(struct scst_user_cmd *ucmd) ++{ ++ TRACE_ENTRY(); ++ ++ BUG_ON(ucmd->data_pages == NULL); ++ ++ TRACE_MEM("Freeing data pages (ucmd=%p, ubuff=%lx, buff_cached=%d)", ++ ucmd, ucmd->ubuff, ucmd->buff_cached); ++ ++ dev_user_unmap_buf(ucmd); ++ ++ if (ucmd->buff_cached) ++ dev_user_on_cached_mem_free(ucmd); ++ else ++ ucmd_put(ucmd); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void dev_user_free_sg_entries(struct scatterlist *sg, int sg_count, ++ void *priv) ++{ ++ struct scst_user_cmd *ucmd = priv; ++ ++ TRACE_MEM("Freeing data pages (sg=%p, sg_count=%d, priv %p)", sg, ++ sg_count, ucmd); ++ ++ __dev_user_free_sg_entries(ucmd); ++ ++ return; ++} ++ ++static inline int is_buff_cached(struct scst_user_cmd *ucmd) ++{ ++ int mem_reuse_type = ucmd->dev->memory_reuse_type; ++ ++ if ((mem_reuse_type == SCST_USER_MEM_REUSE_ALL) || ++ ((ucmd->cmd->data_direction == SCST_DATA_READ) && ++ (mem_reuse_type == SCST_USER_MEM_REUSE_READ)) || ++ ((ucmd->cmd->data_direction == SCST_DATA_WRITE) && ++ (mem_reuse_type == SCST_USER_MEM_REUSE_WRITE))) ++ return 1; ++ else ++ return 0; ++} ++ ++static inline int is_need_offs_page(unsigned long buf, int len) ++{ ++ return ((buf & ~PAGE_MASK) != 0) && ++ ((buf & PAGE_MASK) != ((buf+len-1) & PAGE_MASK)); ++} ++ ++/* ++ * Returns 0 for success, <0 for fatal failure, >0 - need pages. ++ * Unmaps the buffer, if needed in case of error ++ */ ++static int dev_user_alloc_sg(struct scst_user_cmd *ucmd, int cached_buff) ++{ ++ int res = 0; ++ struct scst_cmd *cmd = ucmd->cmd; ++ struct scst_user_dev *dev = ucmd->dev; ++ struct sgv_pool *pool; ++ gfp_t gfp_mask; ++ int flags = 0; ++ int bufflen, orig_bufflen; ++ int last_len = 0; ++ int out_sg_pages = 0; ++ ++ TRACE_ENTRY(); ++ ++ gfp_mask = __GFP_NOWARN; ++ gfp_mask |= (scst_cmd_atomic(cmd) ? GFP_ATOMIC : GFP_KERNEL); ++ ++ if (cmd->data_direction != SCST_DATA_BIDI) { ++ orig_bufflen = cmd->bufflen; ++ pool = cmd->tgt_dev->dh_priv; ++ } else { ++ /* Make out_sg->offset 0 */ ++ int len = cmd->bufflen + ucmd->first_page_offset; ++ out_sg_pages = (len >> PAGE_SHIFT) + ((len & ~PAGE_MASK) != 0); ++ orig_bufflen = (out_sg_pages << PAGE_SHIFT) + cmd->out_bufflen; ++ pool = dev->pool; ++ } ++ bufflen = orig_bufflen; ++ ++ EXTRACHECKS_BUG_ON(bufflen == 0); ++ ++ if (cached_buff) { ++ flags |= SGV_POOL_RETURN_OBJ_ON_ALLOC_FAIL; ++ if (ucmd->ubuff == 0) ++ flags |= SGV_POOL_NO_ALLOC_ON_CACHE_MISS; ++ } else { ++ TRACE_MEM("%s", "Not cached buff"); ++ flags |= SGV_POOL_ALLOC_NO_CACHED; ++ if (ucmd->ubuff == 0) { ++ res = 1; ++ goto out; ++ } ++ bufflen += ucmd->first_page_offset; ++ if (is_need_offs_page(ucmd->ubuff, orig_bufflen)) ++ last_len = bufflen & ~PAGE_MASK; ++ else ++ last_len = orig_bufflen & ~PAGE_MASK; ++ } ++ ucmd->buff_cached = cached_buff; ++ ++ cmd->sg = sgv_pool_alloc(pool, bufflen, gfp_mask, flags, &cmd->sg_cnt, ++ &ucmd->sgv, &dev->udev_mem_lim, ucmd); ++ if (cmd->sg != NULL) { ++ struct scst_user_cmd *buf_ucmd = sgv_get_priv(ucmd->sgv); ++ ++ TRACE_MEM("Buf ucmd %p (cmd->sg_cnt %d, last seg len %d, " ++ "last_len %d, bufflen %d)", buf_ucmd, cmd->sg_cnt, ++ cmd->sg[cmd->sg_cnt-1].length, last_len, bufflen); ++ ++ ucmd->ubuff = buf_ucmd->ubuff; ++ ucmd->buf_ucmd = buf_ucmd; ++ ++ EXTRACHECKS_BUG_ON((ucmd->data_pages != NULL) && ++ (ucmd != buf_ucmd)); ++ ++ if (last_len != 0) { ++ cmd->sg[cmd->sg_cnt-1].length &= PAGE_MASK; ++ cmd->sg[cmd->sg_cnt-1].length += last_len; ++ } ++ ++ TRACE_MEM("Buf alloced (ucmd %p, cached_buff %d, ubuff %lx, " ++ "last seg len %d)", ucmd, cached_buff, ucmd->ubuff, ++ cmd->sg[cmd->sg_cnt-1].length); ++ ++ if (cmd->data_direction == SCST_DATA_BIDI) { ++ cmd->out_sg = &cmd->sg[out_sg_pages]; ++ cmd->out_sg_cnt = cmd->sg_cnt - out_sg_pages; ++ cmd->sg_cnt = out_sg_pages; ++ TRACE_MEM("cmd %p, out_sg %p, out_sg_cnt %d, sg_cnt %d", ++ cmd, cmd->out_sg, cmd->out_sg_cnt, cmd->sg_cnt); ++ } ++ ++ if (unlikely(cmd->sg_cnt > cmd->tgt_dev->max_sg_cnt)) { ++ static int ll; ++ if ((ll < 10) || TRACING_MINOR()) { ++ PRINT_INFO("Unable to complete command due to " ++ "SG IO count limitation (requested %d, " ++ "available %d, tgt lim %d)", ++ cmd->sg_cnt, cmd->tgt_dev->max_sg_cnt, ++ cmd->tgt->sg_tablesize); ++ ll++; ++ } ++ cmd->sg = NULL; ++ /* sgv will be freed in dev_user_free_sgv() */ ++ res = -1; ++ } ++ } else { ++ TRACE_MEM("Buf not alloced (ucmd %p, h %d, buff_cached, %d, " ++ "sg_cnt %d, ubuff %lx, sgv %p", ucmd, ucmd->h, ++ ucmd->buff_cached, cmd->sg_cnt, ucmd->ubuff, ucmd->sgv); ++ if (unlikely(cmd->sg_cnt == 0)) { ++ TRACE_MEM("Refused allocation (ucmd %p)", ucmd); ++ BUG_ON(ucmd->sgv != NULL); ++ res = -1; ++ } else { ++ switch (ucmd->state) { ++ case UCMD_STATE_BUF_ALLOCING: ++ res = 1; ++ break; ++ case UCMD_STATE_EXECING: ++ res = -1; ++ break; ++ default: ++ BUG(); ++ break; ++ } ++ } ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int dev_user_alloc_space(struct scst_user_cmd *ucmd) ++{ ++ int rc, res = SCST_CMD_STATE_DEFAULT; ++ struct scst_cmd *cmd = ucmd->cmd; ++ ++ TRACE_ENTRY(); ++ ++ ucmd->state = UCMD_STATE_BUF_ALLOCING; ++ scst_cmd_set_dh_data_buff_alloced(cmd); ++ ++ rc = dev_user_alloc_sg(ucmd, is_buff_cached(ucmd)); ++ if (rc == 0) ++ goto out; ++ else if (rc < 0) { ++ scst_set_busy(cmd); ++ res = scst_set_cmd_abnormal_done_state(cmd); ++ goto out; ++ } ++ ++ if (!(cmd->data_direction & SCST_DATA_WRITE) && ++ !scst_is_cmd_local(cmd)) { ++ TRACE_DBG("Delayed alloc, ucmd %p", ucmd); ++ goto out; ++ } ++ ++ ucmd->user_cmd_payload_len = ++ offsetof(struct scst_user_get_cmd, alloc_cmd) + ++ sizeof(ucmd->user_cmd.alloc_cmd); ++ ucmd->user_cmd.cmd_h = ucmd->h; ++ ucmd->user_cmd.subcode = SCST_USER_ALLOC_MEM; ++ ucmd->user_cmd.alloc_cmd.sess_h = (unsigned long)cmd->tgt_dev; ++ memcpy(ucmd->user_cmd.alloc_cmd.cdb, cmd->cdb, ++ min_t(int, SCST_MAX_CDB_SIZE, cmd->cdb_len)); ++ ucmd->user_cmd.alloc_cmd.cdb_len = cmd->cdb_len; ++ ucmd->user_cmd.alloc_cmd.alloc_len = ucmd->buff_cached ? ++ (cmd->sg_cnt << PAGE_SHIFT) : cmd->bufflen; ++ ucmd->user_cmd.alloc_cmd.queue_type = cmd->queue_type; ++ ucmd->user_cmd.alloc_cmd.data_direction = cmd->data_direction; ++ ucmd->user_cmd.alloc_cmd.sn = cmd->tgt_sn; ++ ++ dev_user_add_to_ready(ucmd); ++ ++ res = SCST_CMD_STATE_STOP; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct scst_user_cmd *dev_user_alloc_ucmd(struct scst_user_dev *dev, ++ gfp_t gfp_mask) ++{ ++ struct scst_user_cmd *ucmd = NULL; ++ ++ TRACE_ENTRY(); ++ ++ ucmd = kmem_cache_zalloc(user_cmd_cachep, gfp_mask); ++ if (unlikely(ucmd == NULL)) { ++ TRACE(TRACE_OUT_OF_MEM, "Unable to allocate " ++ "user cmd (gfp_mask %x)", gfp_mask); ++ goto out; ++ } ++ ucmd->dev = dev; ++ atomic_set(&ucmd->ucmd_ref, 1); ++ ++ cmd_insert_hash(ucmd); ++ ++ TRACE_MEM("ucmd %p allocated", ucmd); ++ ++out: ++ TRACE_EXIT_HRES((unsigned long)ucmd); ++ return ucmd; ++} ++ ++static int dev_user_get_block(struct scst_cmd *cmd) ++{ ++ struct scst_user_dev *dev = cmd->dev->dh_priv; ++ /* ++ * No need for locks here, since *_detach() can not be ++ * called, when there are existing commands. ++ */ ++ TRACE_EXIT_RES(dev->block); ++ return dev->block; ++} ++ ++static int dev_user_parse(struct scst_cmd *cmd) ++{ ++ int rc, res = SCST_CMD_STATE_DEFAULT; ++ struct scst_user_cmd *ucmd; ++ int atomic = scst_cmd_atomic(cmd); ++ struct scst_user_dev *dev = cmd->dev->dh_priv; ++ gfp_t gfp_mask = atomic ? GFP_ATOMIC : GFP_KERNEL; ++ ++ TRACE_ENTRY(); ++ ++ if (cmd->dh_priv == NULL) { ++ ucmd = dev_user_alloc_ucmd(dev, gfp_mask); ++ if (unlikely(ucmd == NULL)) { ++ if (atomic) { ++ res = SCST_CMD_STATE_NEED_THREAD_CTX; ++ goto out; ++ } else { ++ scst_set_busy(cmd); ++ goto out_error; ++ } ++ } ++ ucmd->cmd = cmd; ++ cmd->dh_priv = ucmd; ++ } else { ++ ucmd = cmd->dh_priv; ++ TRACE_DBG("Used ucmd %p, state %x", ucmd, ucmd->state); ++ } ++ ++ TRACE_DBG("ucmd %p, cmd %p, state %x", ucmd, cmd, ucmd->state); ++ ++ if (ucmd->state == UCMD_STATE_PARSING) { ++ /* We've already done */ ++ goto done; ++ } ++ ++ EXTRACHECKS_BUG_ON(ucmd->state != UCMD_STATE_NEW); ++ ++ switch (dev->parse_type) { ++ case SCST_USER_PARSE_STANDARD: ++ TRACE_DBG("PARSE STANDARD: ucmd %p", ucmd); ++ rc = dev->generic_parse(cmd, dev_user_get_block); ++ if (rc != 0) ++ goto out_invalid; ++ break; ++ ++ case SCST_USER_PARSE_EXCEPTION: ++ TRACE_DBG("PARSE EXCEPTION: ucmd %p", ucmd); ++ rc = dev->generic_parse(cmd, dev_user_get_block); ++ if ((rc == 0) && (cmd->op_flags & SCST_INFO_VALID)) ++ break; ++ else if (rc == SCST_CMD_STATE_NEED_THREAD_CTX) { ++ TRACE_MEM("Restarting PARSE to thread context " ++ "(ucmd %p)", ucmd); ++ res = SCST_CMD_STATE_NEED_THREAD_CTX; ++ goto out; ++ } ++ /* else go through */ ++ ++ case SCST_USER_PARSE_CALL: ++ TRACE_DBG("Preparing PARSE for user space (ucmd=%p, h=%d, " ++ "bufflen %d)", ucmd, ucmd->h, cmd->bufflen); ++ ucmd->user_cmd_payload_len = ++ offsetof(struct scst_user_get_cmd, parse_cmd) + ++ sizeof(ucmd->user_cmd.parse_cmd); ++ ucmd->user_cmd.cmd_h = ucmd->h; ++ ucmd->user_cmd.subcode = SCST_USER_PARSE; ++ ucmd->user_cmd.parse_cmd.sess_h = (unsigned long)cmd->tgt_dev; ++ memcpy(ucmd->user_cmd.parse_cmd.cdb, cmd->cdb, ++ min_t(int, SCST_MAX_CDB_SIZE, cmd->cdb_len)); ++ ucmd->user_cmd.parse_cmd.cdb_len = cmd->cdb_len; ++ ucmd->user_cmd.parse_cmd.timeout = cmd->timeout / HZ; ++ ucmd->user_cmd.parse_cmd.bufflen = cmd->bufflen; ++ ucmd->user_cmd.parse_cmd.out_bufflen = cmd->out_bufflen; ++ ucmd->user_cmd.parse_cmd.queue_type = cmd->queue_type; ++ ucmd->user_cmd.parse_cmd.data_direction = cmd->data_direction; ++ ucmd->user_cmd.parse_cmd.expected_values_set = ++ cmd->expected_values_set; ++ ucmd->user_cmd.parse_cmd.expected_data_direction = ++ cmd->expected_data_direction; ++ ucmd->user_cmd.parse_cmd.expected_transfer_len = ++ cmd->expected_transfer_len; ++ ucmd->user_cmd.parse_cmd.expected_out_transfer_len = ++ cmd->expected_out_transfer_len; ++ ucmd->user_cmd.parse_cmd.sn = cmd->tgt_sn; ++ ucmd->user_cmd.parse_cmd.op_flags = cmd->op_flags; ++ ucmd->state = UCMD_STATE_PARSING; ++ dev_user_add_to_ready(ucmd); ++ res = SCST_CMD_STATE_STOP; ++ goto out; ++ ++ default: ++ BUG(); ++ goto out; ++ } ++ ++done: ++ if (cmd->bufflen == 0) { ++ /* ++ * According to SPC bufflen 0 for data transfer commands isn't ++ * an error, so we need to fix the transfer direction. ++ */ ++ cmd->data_direction = SCST_DATA_NONE; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_invalid: ++ PRINT_ERROR("PARSE failed (ucmd %p, rc %d)", ucmd, rc); ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_invalid_opcode)); ++ ++out_error: ++ res = scst_set_cmd_abnormal_done_state(cmd); ++ goto out; ++} ++ ++static int dev_user_alloc_data_buf(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_DEFAULT; ++ struct scst_user_cmd *ucmd = cmd->dh_priv; ++ ++ TRACE_ENTRY(); ++ ++ EXTRACHECKS_BUG_ON((ucmd->state != UCMD_STATE_NEW) && ++ (ucmd->state != UCMD_STATE_PARSING) && ++ (ucmd->state != UCMD_STATE_BUF_ALLOCING)); ++ ++ res = dev_user_alloc_space(ucmd); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void dev_user_flush_dcache(struct scst_user_cmd *ucmd) ++{ ++ struct scst_user_cmd *buf_ucmd = ucmd->buf_ucmd; ++ unsigned long start = buf_ucmd->ubuff; ++ int i, bufflen = ucmd->cmd->bufflen; ++ ++ TRACE_ENTRY(); ++ ++ if (start == 0) ++ goto out; ++ ++ /* ++ * Possibly, flushing of all the pages from ucmd->cmd->sg can be ++ * faster, since it should be cache hot, while ucmd->buf_ucmd and ++ * buf_ucmd->data_pages are cache cold. But, from other side, ++ * sizeof(buf_ucmd->data_pages[0]) is considerably smaller, than ++ * sizeof(ucmd->cmd->sg[0]), so on big buffers going over ++ * data_pages array can lead to less cache misses. So, real numbers are ++ * needed. ToDo. ++ */ ++ ++ for (i = 0; (bufflen > 0) && (i < buf_ucmd->num_data_pages); i++) { ++ struct page *page __attribute__((unused)); ++ page = buf_ucmd->data_pages[i]; ++#ifdef ARCH_HAS_FLUSH_ANON_PAGE ++ struct vm_area_struct *vma = find_vma(current->mm, start); ++ if (vma != NULL) ++ flush_anon_page(vma, page, start); ++#endif ++ flush_dcache_page(page); ++ start += PAGE_SIZE; ++ bufflen -= PAGE_SIZE; ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static int dev_user_exec(struct scst_cmd *cmd) ++{ ++ struct scst_user_cmd *ucmd = cmd->dh_priv; ++ int res = SCST_EXEC_COMPLETED; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Preparing EXEC for user space (ucmd=%p, h=%d, " ++ "bufflen %d, data_len %d, ubuff %lx)", ucmd, ucmd->h, ++ cmd->bufflen, cmd->data_len, ucmd->ubuff); ++ ++ if (cmd->data_direction & SCST_DATA_WRITE) ++ dev_user_flush_dcache(ucmd); ++ ++ ucmd->user_cmd_payload_len = ++ offsetof(struct scst_user_get_cmd, exec_cmd) + ++ sizeof(ucmd->user_cmd.exec_cmd); ++ ucmd->user_cmd.cmd_h = ucmd->h; ++ ucmd->user_cmd.subcode = SCST_USER_EXEC; ++ ucmd->user_cmd.exec_cmd.sess_h = (unsigned long)cmd->tgt_dev; ++ memcpy(ucmd->user_cmd.exec_cmd.cdb, cmd->cdb, ++ min_t(int, SCST_MAX_CDB_SIZE, cmd->cdb_len)); ++ ucmd->user_cmd.exec_cmd.cdb_len = cmd->cdb_len; ++ ucmd->user_cmd.exec_cmd.bufflen = cmd->bufflen; ++ ucmd->user_cmd.exec_cmd.data_len = cmd->data_len; ++ ucmd->user_cmd.exec_cmd.pbuf = ucmd->ubuff; ++ if ((ucmd->ubuff == 0) && (cmd->data_direction != SCST_DATA_NONE)) { ++ ucmd->user_cmd.exec_cmd.alloc_len = ucmd->buff_cached ? ++ (cmd->sg_cnt << PAGE_SHIFT) : cmd->bufflen; ++ } ++ ucmd->user_cmd.exec_cmd.queue_type = cmd->queue_type; ++ ucmd->user_cmd.exec_cmd.data_direction = cmd->data_direction; ++ ucmd->user_cmd.exec_cmd.partial = 0; ++ ucmd->user_cmd.exec_cmd.timeout = cmd->timeout / HZ; ++ ucmd->user_cmd.exec_cmd.p_out_buf = ucmd->ubuff + ++ (cmd->sg_cnt << PAGE_SHIFT); ++ ucmd->user_cmd.exec_cmd.out_bufflen = cmd->out_bufflen; ++ ucmd->user_cmd.exec_cmd.sn = cmd->tgt_sn; ++ ++ ucmd->state = UCMD_STATE_EXECING; ++ ++ dev_user_add_to_ready(ucmd); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void dev_user_free_sgv(struct scst_user_cmd *ucmd) ++{ ++ if (ucmd->sgv != NULL) { ++ sgv_pool_free(ucmd->sgv, &ucmd->dev->udev_mem_lim); ++ ucmd->sgv = NULL; ++ } else if (ucmd->data_pages != NULL) { ++ /* We mapped pages, but for some reason didn't allocate them */ ++ ucmd_get(ucmd); ++ __dev_user_free_sg_entries(ucmd); ++ } ++ return; ++} ++ ++static void dev_user_on_free_cmd(struct scst_cmd *cmd) ++{ ++ struct scst_user_cmd *ucmd = cmd->dh_priv; ++ ++ TRACE_ENTRY(); ++ ++ if (unlikely(ucmd == NULL)) ++ goto out; ++ ++ TRACE_MEM("ucmd %p, cmd %p, buff_cached %d, ubuff %lx", ucmd, ucmd->cmd, ++ ucmd->buff_cached, ucmd->ubuff); ++ ++ ucmd->cmd = NULL; ++ if ((cmd->data_direction & SCST_DATA_WRITE) && ucmd->buf_ucmd != NULL) ++ ucmd->buf_ucmd->buf_dirty = 1; ++ ++ if (ucmd->dev->on_free_cmd_type == SCST_USER_ON_FREE_CMD_IGNORE) { ++ ucmd->state = UCMD_STATE_ON_FREE_SKIPPED; ++ /* The state assignment must be before freeing sgv! */ ++ goto out_reply; ++ } ++ ++ if (unlikely(!ucmd->seen_by_user)) { ++ TRACE_MGMT_DBG("Not seen by user ucmd %p", ucmd); ++ goto out_reply; ++ } ++ ++ ucmd->user_cmd_payload_len = ++ offsetof(struct scst_user_get_cmd, on_free_cmd) + ++ sizeof(ucmd->user_cmd.on_free_cmd); ++ ucmd->user_cmd.cmd_h = ucmd->h; ++ ucmd->user_cmd.subcode = SCST_USER_ON_FREE_CMD; ++ ucmd->user_cmd.on_free_cmd.pbuf = ucmd->ubuff; ++ ucmd->user_cmd.on_free_cmd.resp_data_len = cmd->resp_data_len; ++ ucmd->user_cmd.on_free_cmd.buffer_cached = ucmd->buff_cached; ++ ucmd->user_cmd.on_free_cmd.aborted = ucmd->aborted; ++ ucmd->user_cmd.on_free_cmd.status = cmd->status; ++ ucmd->user_cmd.on_free_cmd.delivery_status = cmd->delivery_status; ++ ++ ucmd->state = UCMD_STATE_ON_FREEING; ++ ++ dev_user_add_to_ready(ucmd); ++ ++out: ++ TRACE_EXIT(); ++ return; ++ ++out_reply: ++ dev_user_process_reply_on_free(ucmd); ++ goto out; ++} ++ ++static void dev_user_set_block(struct scst_cmd *cmd, int block) ++{ ++ struct scst_user_dev *dev = cmd->dev->dh_priv; ++ /* ++ * No need for locks here, since *_detach() can not be ++ * called, when there are existing commands. ++ */ ++ TRACE_DBG("dev %p, new block %d", dev, block); ++ if (block != 0) ++ dev->block = block; ++ else ++ dev->block = dev->def_block; ++ return; ++} ++ ++static int dev_user_disk_done(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_DEFAULT; ++ ++ TRACE_ENTRY(); ++ ++ res = scst_block_generic_dev_done(cmd, dev_user_set_block); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int dev_user_tape_done(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_DEFAULT; ++ ++ TRACE_ENTRY(); ++ ++ res = scst_tape_generic_dev_done(cmd, dev_user_set_block); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void dev_user_add_to_ready(struct scst_user_cmd *ucmd) ++{ ++ struct scst_user_dev *dev = ucmd->dev; ++ unsigned long flags; ++ int do_wake = in_interrupt(); ++ ++ TRACE_ENTRY(); ++ ++ if (ucmd->cmd) ++ do_wake |= ucmd->cmd->preprocessing_only; ++ ++ spin_lock_irqsave(&dev->udev_cmd_threads.cmd_list_lock, flags); ++ ++ ucmd->this_state_unjammed = 0; ++ ++ if ((ucmd->state == UCMD_STATE_PARSING) || ++ (ucmd->state == UCMD_STATE_BUF_ALLOCING)) { ++ /* ++ * If we don't put such commands in the queue head, then under ++ * high load we might delay threads, waiting for memory ++ * allocations, for too long and start loosing NOPs, which ++ * would lead to consider us by remote initiators as ++ * unresponsive and stuck => broken connections, etc. If none ++ * of our commands completed in NOP timeout to allow the head ++ * commands to go, then we are really overloaded and/or stuck. ++ */ ++ TRACE_DBG("Adding ucmd %p (state %d) to head of ready " ++ "cmd list", ucmd, ucmd->state); ++ list_add(&ucmd->ready_cmd_list_entry, ++ &dev->ready_cmd_list); ++ } else if (unlikely(ucmd->state == UCMD_STATE_TM_EXECING) || ++ unlikely(ucmd->state == UCMD_STATE_ATTACH_SESS) || ++ unlikely(ucmd->state == UCMD_STATE_DETACH_SESS)) { ++ TRACE_MGMT_DBG("Adding mgmt ucmd %p (state %d) to head of " ++ "ready cmd list", ucmd, ucmd->state); ++ list_add(&ucmd->ready_cmd_list_entry, ++ &dev->ready_cmd_list); ++ do_wake = 1; ++ } else { ++ if ((ucmd->cmd != NULL) && ++ unlikely((ucmd->cmd->queue_type == SCST_CMD_QUEUE_HEAD_OF_QUEUE))) { ++ TRACE_DBG("Adding HQ ucmd %p to head of ready cmd list", ++ ucmd); ++ list_add(&ucmd->ready_cmd_list_entry, ++ &dev->ready_cmd_list); ++ } else { ++ TRACE_DBG("Adding ucmd %p to ready cmd list", ucmd); ++ list_add_tail(&ucmd->ready_cmd_list_entry, ++ &dev->ready_cmd_list); ++ } ++ do_wake |= ((ucmd->state == UCMD_STATE_ON_CACHE_FREEING) || ++ (ucmd->state == UCMD_STATE_ON_FREEING)); ++ } ++ ++ if (do_wake) { ++ TRACE_DBG("Waking up dev %p", dev); ++ wake_up(&dev->udev_cmd_threads.cmd_list_waitQ); ++ } ++ ++ spin_unlock_irqrestore(&dev->udev_cmd_threads.cmd_list_lock, flags); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int dev_user_map_buf(struct scst_user_cmd *ucmd, unsigned long ubuff, ++ int num_pg) ++{ ++ int res = 0, rc; ++ int i; ++ struct task_struct *tsk = current; ++ ++ TRACE_ENTRY(); ++ ++ if (unlikely(ubuff == 0)) ++ goto out_nomem; ++ ++ BUG_ON(ucmd->data_pages != NULL); ++ ++ ucmd->num_data_pages = num_pg; ++ ++ ucmd->data_pages = ++ kmalloc(sizeof(*ucmd->data_pages) * ucmd->num_data_pages, ++ GFP_KERNEL); ++ if (ucmd->data_pages == NULL) { ++ TRACE(TRACE_OUT_OF_MEM, "Unable to allocate data_pages array " ++ "(num_data_pages=%d)", ucmd->num_data_pages); ++ res = -ENOMEM; ++ goto out_nomem; ++ } ++ ++ TRACE_MEM("Mapping buffer (ucmd %p, ubuff %lx, ucmd->num_data_pages %d," ++ " first_page_offset %d, len %d)", ucmd, ubuff, ++ ucmd->num_data_pages, (int)(ubuff & ~PAGE_MASK), ++ (ucmd->cmd != NULL) ? ucmd->cmd->bufflen : -1); ++ ++ down_read(&tsk->mm->mmap_sem); ++ rc = get_user_pages(tsk, tsk->mm, ubuff, ucmd->num_data_pages, ++ 1/*writable*/, 0/*don't force*/, ucmd->data_pages, NULL); ++ up_read(&tsk->mm->mmap_sem); ++ ++ /* get_user_pages() flushes dcache */ ++ ++ if (rc < ucmd->num_data_pages) ++ goto out_unmap; ++ ++ ucmd->ubuff = ubuff; ++ ucmd->first_page_offset = (ubuff & ~PAGE_MASK); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_nomem: ++ if (ucmd->cmd != NULL) ++ scst_set_busy(ucmd->cmd); ++ /* go through */ ++ ++out_err: ++ if (ucmd->cmd != NULL) ++ scst_set_cmd_abnormal_done_state(ucmd->cmd); ++ goto out; ++ ++out_unmap: ++ PRINT_ERROR("Failed to get %d user pages (rc %d)", ++ ucmd->num_data_pages, rc); ++ if (rc > 0) { ++ for (i = 0; i < rc; i++) ++ page_cache_release(ucmd->data_pages[i]); ++ } ++ kfree(ucmd->data_pages); ++ ucmd->data_pages = NULL; ++ res = -EFAULT; ++ if (ucmd->cmd != NULL) ++ scst_set_cmd_error(ucmd->cmd, SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out_err; ++} ++ ++static int dev_user_process_reply_alloc(struct scst_user_cmd *ucmd, ++ struct scst_user_reply_cmd *reply) ++{ ++ int res = 0; ++ struct scst_cmd *cmd = ucmd->cmd; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("ucmd %p, pbuf %llx", ucmd, reply->alloc_reply.pbuf); ++ ++ if (likely(reply->alloc_reply.pbuf != 0)) { ++ int pages; ++ if (ucmd->buff_cached) { ++ if (unlikely((reply->alloc_reply.pbuf & ~PAGE_MASK) != 0)) { ++ PRINT_ERROR("Supplied pbuf %llx isn't " ++ "page aligned", ++ reply->alloc_reply.pbuf); ++ goto out_hwerr; ++ } ++ pages = cmd->sg_cnt; ++ } else ++ pages = calc_num_pg(reply->alloc_reply.pbuf, ++ cmd->bufflen); ++ res = dev_user_map_buf(ucmd, reply->alloc_reply.pbuf, pages); ++ } else { ++ scst_set_busy(ucmd->cmd); ++ scst_set_cmd_abnormal_done_state(ucmd->cmd); ++ } ++ ++out_process: ++ scst_post_alloc_data_buf(cmd); ++ scst_process_active_cmd(cmd, false); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_hwerr: ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ scst_set_cmd_abnormal_done_state(ucmd->cmd); ++ res = -EINVAL; ++ goto out_process; ++} ++ ++static int dev_user_process_reply_parse(struct scst_user_cmd *ucmd, ++ struct scst_user_reply_cmd *reply) ++{ ++ int res = 0, rc; ++ struct scst_user_scsi_cmd_reply_parse *preply = ++ &reply->parse_reply; ++ struct scst_cmd *cmd = ucmd->cmd; ++ ++ TRACE_ENTRY(); ++ ++ if (preply->status != 0) ++ goto out_status; ++ ++ if (unlikely(preply->queue_type > SCST_CMD_QUEUE_ACA)) ++ goto out_inval; ++ ++ if (unlikely((preply->data_direction != SCST_DATA_WRITE) && ++ (preply->data_direction != SCST_DATA_READ) && ++ (preply->data_direction != SCST_DATA_BIDI) && ++ (preply->data_direction != SCST_DATA_NONE))) ++ goto out_inval; ++ ++ if (unlikely((preply->data_direction != SCST_DATA_NONE) && ++ (preply->bufflen == 0))) ++ goto out_inval; ++ ++ if (unlikely((preply->bufflen < 0) || (preply->out_bufflen < 0) || ++ (preply->data_len < 0))) ++ goto out_inval; ++ ++ if (unlikely(preply->cdb_len > cmd->cdb_len)) ++ goto out_inval; ++ ++ if (!(preply->op_flags & SCST_INFO_VALID)) ++ goto out_inval; ++ ++ TRACE_DBG("ucmd %p, queue_type %x, data_direction, %x, bufflen %d, " ++ "data_len %d, pbuf %llx, cdb_len %d, op_flags %x", ucmd, ++ preply->queue_type, preply->data_direction, preply->bufflen, ++ preply->data_len, reply->alloc_reply.pbuf, preply->cdb_len, ++ preply->op_flags); ++ ++ cmd->queue_type = preply->queue_type; ++ cmd->data_direction = preply->data_direction; ++ cmd->bufflen = preply->bufflen; ++ cmd->out_bufflen = preply->out_bufflen; ++ cmd->data_len = preply->data_len; ++ if (preply->cdb_len > 0) ++ cmd->cdb_len = preply->cdb_len; ++ cmd->op_flags = preply->op_flags; ++ ++out_process: ++ scst_post_parse(cmd); ++ scst_process_active_cmd(cmd, false); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_inval: ++ PRINT_ERROR("Invalid parse_reply parameters (LUN %lld, op %x, cmd %p)", ++ (long long unsigned int)cmd->lun, cmd->cdb[0], cmd); ++ PRINT_BUFFER("Invalid parse_reply", reply, sizeof(*reply)); ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ res = -EINVAL; ++ goto out_abnormal; ++ ++out_hwerr_res_set: ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ ++out_abnormal: ++ scst_set_cmd_abnormal_done_state(cmd); ++ goto out_process; ++ ++out_status: ++ TRACE_DBG("ucmd %p returned with error from user status %x", ++ ucmd, preply->status); ++ ++ if (preply->sense_len != 0) { ++ int sense_len; ++ ++ res = scst_alloc_sense(cmd, 0); ++ if (res != 0) ++ goto out_hwerr_res_set; ++ ++ sense_len = min_t(int, cmd->sense_buflen, preply->sense_len); ++ ++ rc = copy_from_user(cmd->sense, ++ (void __user *)(unsigned long)preply->psense_buffer, ++ sense_len); ++ if (rc != 0) { ++ PRINT_ERROR("Failed to copy %d sense's bytes", rc); ++ res = -EFAULT; ++ goto out_hwerr_res_set; ++ } ++ cmd->sense_valid_len = sense_len; ++ } ++ scst_set_cmd_error_status(cmd, preply->status); ++ goto out_abnormal; ++} ++ ++static int dev_user_process_reply_on_free(struct scst_user_cmd *ucmd) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("ON FREE ucmd %p", ucmd); ++ ++ dev_user_free_sgv(ucmd); ++ ucmd_put(ucmd); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int dev_user_process_reply_on_cache_free(struct scst_user_cmd *ucmd) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("ON CACHE FREE ucmd %p", ucmd); ++ ++ ucmd_put(ucmd); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int dev_user_process_reply_exec(struct scst_user_cmd *ucmd, ++ struct scst_user_reply_cmd *reply) ++{ ++ int res = 0; ++ struct scst_user_scsi_cmd_reply_exec *ereply = ++ &reply->exec_reply; ++ struct scst_cmd *cmd = ucmd->cmd; ++ ++ TRACE_ENTRY(); ++ ++ if (ereply->reply_type == SCST_EXEC_REPLY_COMPLETED) { ++ if (ucmd->background_exec) { ++ TRACE_DBG("Background ucmd %p finished", ucmd); ++ ucmd_put(ucmd); ++ goto out; ++ } ++ if (unlikely(ereply->resp_data_len > cmd->bufflen)) ++ goto out_inval; ++ if (unlikely((cmd->data_direction != SCST_DATA_READ) && ++ (ereply->resp_data_len != 0))) ++ goto out_inval; ++ } else if (ereply->reply_type == SCST_EXEC_REPLY_BACKGROUND) { ++ if (unlikely(ucmd->background_exec)) ++ goto out_inval; ++ if (unlikely((cmd->data_direction & SCST_DATA_READ) || ++ (cmd->resp_data_len != 0))) ++ goto out_inval; ++ /* ++ * background_exec assignment must be after ucmd get. ++ * Otherwise, due to reorder, in dev_user_process_reply() ++ * it is possible that ucmd is destroyed before it "got" here. ++ */ ++ ucmd_get(ucmd); ++ ucmd->background_exec = 1; ++ TRACE_DBG("Background ucmd %p", ucmd); ++ goto out_compl; ++ } else ++ goto out_inval; ++ ++ TRACE_DBG("ucmd %p, status %d, resp_data_len %d", ucmd, ++ ereply->status, ereply->resp_data_len); ++ ++ cmd->atomic = 0; ++ ++ if (ereply->resp_data_len != 0) { ++ if (ucmd->ubuff == 0) { ++ int pages, rc; ++ if (unlikely(ereply->pbuf == 0)) ++ goto out_busy; ++ if (ucmd->buff_cached) { ++ if (unlikely((ereply->pbuf & ~PAGE_MASK) != 0)) { ++ PRINT_ERROR("Supplied pbuf %llx isn't " ++ "page aligned", ereply->pbuf); ++ goto out_hwerr; ++ } ++ pages = cmd->sg_cnt; ++ } else ++ pages = calc_num_pg(ereply->pbuf, cmd->bufflen); ++ rc = dev_user_map_buf(ucmd, ereply->pbuf, pages); ++ if ((rc != 0) || (ucmd->ubuff == 0)) ++ goto out_compl; ++ ++ rc = dev_user_alloc_sg(ucmd, ucmd->buff_cached); ++ if (unlikely(rc != 0)) ++ goto out_busy; ++ } else ++ dev_user_flush_dcache(ucmd); ++ cmd->may_need_dma_sync = 1; ++ scst_set_resp_data_len(cmd, ereply->resp_data_len); ++ } else if (cmd->resp_data_len != ereply->resp_data_len) { ++ if (ucmd->ubuff == 0) { ++ /* ++ * We have an empty SG, so can't call ++ * scst_set_resp_data_len() ++ */ ++ cmd->resp_data_len = ereply->resp_data_len; ++ cmd->resid_possible = 1; ++ } else ++ scst_set_resp_data_len(cmd, ereply->resp_data_len); ++ } ++ ++ cmd->status = ereply->status; ++ if (ereply->sense_len != 0) { ++ int sense_len, rc; ++ ++ res = scst_alloc_sense(cmd, 0); ++ if (res != 0) ++ goto out_compl; ++ ++ sense_len = min_t(int, cmd->sense_buflen, ereply->sense_len); ++ ++ rc = copy_from_user(cmd->sense, ++ (void __user *)(unsigned long)ereply->psense_buffer, ++ sense_len); ++ if (rc != 0) { ++ PRINT_ERROR("Failed to copy %d sense's bytes", rc); ++ res = -EFAULT; ++ goto out_hwerr_res_set; ++ } ++ cmd->sense_valid_len = sense_len; ++ } ++ ++out_compl: ++ cmd->completed = 1; ++ cmd->scst_cmd_done(cmd, SCST_CMD_STATE_DEFAULT, SCST_CONTEXT_DIRECT); ++ /* !! At this point cmd can be already freed !! */ ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_inval: ++ PRINT_ERROR("Invalid exec_reply parameters (LUN %lld, op %x, cmd %p)", ++ (long long unsigned int)cmd->lun, cmd->cdb[0], cmd); ++ PRINT_BUFFER("Invalid exec_reply", reply, sizeof(*reply)); ++ ++out_hwerr: ++ res = -EINVAL; ++ ++out_hwerr_res_set: ++ if (ucmd->background_exec) { ++ ucmd_put(ucmd); ++ goto out; ++ } else { ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out_compl; ++ } ++ ++out_busy: ++ scst_set_busy(cmd); ++ goto out_compl; ++} ++ ++static int dev_user_process_reply(struct scst_user_dev *dev, ++ struct scst_user_reply_cmd *reply) ++{ ++ int res = 0; ++ struct scst_user_cmd *ucmd; ++ int state; ++ ++ TRACE_ENTRY(); ++ ++ spin_lock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ++ ucmd = __ucmd_find_hash(dev, reply->cmd_h); ++ if (unlikely(ucmd == NULL)) { ++ TRACE_MGMT_DBG("cmd_h %d not found", reply->cmd_h); ++ res = -ESRCH; ++ goto out_unlock; ++ } ++ ++ if (unlikely(ucmd_get_check(ucmd))) { ++ TRACE_MGMT_DBG("Found being destroyed cmd_h %d", reply->cmd_h); ++ res = -ESRCH; ++ goto out_unlock; ++ } ++ ++ /* To sync. with dev_user_process_reply_exec(). See comment there. */ ++ smp_mb(); ++ if (ucmd->background_exec) { ++ state = UCMD_STATE_EXECING; ++ goto unlock_process; ++ } ++ ++ if (unlikely(ucmd->this_state_unjammed)) { ++ TRACE_MGMT_DBG("Reply on unjammed ucmd %p, ignoring", ++ ucmd); ++ goto out_unlock_put; ++ } ++ ++ if (unlikely(!ucmd->sent_to_user)) { ++ TRACE_MGMT_DBG("Ucmd %p isn't in the sent to user " ++ "state %x", ucmd, ucmd->state); ++ res = -EINVAL; ++ goto out_unlock_put; ++ } ++ ++ if (unlikely(reply->subcode != ucmd->user_cmd.subcode)) ++ goto out_wrong_state; ++ ++ if (unlikely(_IOC_NR(reply->subcode) != ucmd->state)) ++ goto out_wrong_state; ++ ++ state = ucmd->state; ++ ucmd->sent_to_user = 0; ++ ++unlock_process: ++ spin_unlock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ++ switch (state) { ++ case UCMD_STATE_PARSING: ++ res = dev_user_process_reply_parse(ucmd, reply); ++ break; ++ ++ case UCMD_STATE_BUF_ALLOCING: ++ res = dev_user_process_reply_alloc(ucmd, reply); ++ break; ++ ++ case UCMD_STATE_EXECING: ++ res = dev_user_process_reply_exec(ucmd, reply); ++ break; ++ ++ case UCMD_STATE_ON_FREEING: ++ res = dev_user_process_reply_on_free(ucmd); ++ break; ++ ++ case UCMD_STATE_ON_CACHE_FREEING: ++ res = dev_user_process_reply_on_cache_free(ucmd); ++ break; ++ ++ case UCMD_STATE_TM_EXECING: ++ res = dev_user_process_reply_tm_exec(ucmd, reply->result); ++ break; ++ ++ case UCMD_STATE_ATTACH_SESS: ++ case UCMD_STATE_DETACH_SESS: ++ res = dev_user_process_reply_sess(ucmd, reply->result); ++ break; ++ ++ default: ++ BUG(); ++ break; ++ } ++ ++out_put: ++ ucmd_put(ucmd); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_wrong_state: ++ PRINT_ERROR("Command's %p subcode %x doesn't match internal " ++ "command's state %x or reply->subcode (%x) != ucmd->subcode " ++ "(%x)", ucmd, _IOC_NR(reply->subcode), ucmd->state, ++ reply->subcode, ucmd->user_cmd.subcode); ++ res = -EINVAL; ++ dev_user_unjam_cmd(ucmd, 0, NULL); ++ ++out_unlock_put: ++ spin_unlock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ goto out_put; ++ ++out_unlock: ++ spin_unlock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ goto out; ++} ++ ++static int dev_user_reply_cmd(struct file *file, void __user *arg) ++{ ++ int res = 0, rc; ++ struct scst_user_dev *dev; ++ struct scst_user_reply_cmd reply; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&dev_priv_mutex); ++ dev = file->private_data; ++ res = dev_user_check_reg(dev); ++ if (unlikely(res != 0)) { ++ mutex_unlock(&dev_priv_mutex); ++ goto out; ++ } ++ down_read(&dev->dev_rwsem); ++ mutex_unlock(&dev_priv_mutex); ++ ++ rc = copy_from_user(&reply, arg, sizeof(reply)); ++ if (unlikely(rc != 0)) { ++ PRINT_ERROR("Failed to copy %d user's bytes", rc); ++ res = -EFAULT; ++ goto out_up; ++ } ++ ++ TRACE_DBG("Reply for dev %s", dev->name); ++ ++ TRACE_BUFFER("Reply", &reply, sizeof(reply)); ++ ++ res = dev_user_process_reply(dev, &reply); ++ if (unlikely(res < 0)) ++ goto out_up; ++ ++out_up: ++ up_read(&dev->dev_rwsem); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int dev_user_get_ext_cdb(struct file *file, void __user *arg) ++{ ++ int res = 0, rc; ++ struct scst_user_dev *dev; ++ struct scst_user_cmd *ucmd; ++ struct scst_cmd *cmd = NULL; ++ struct scst_user_get_ext_cdb get; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&dev_priv_mutex); ++ dev = file->private_data; ++ res = dev_user_check_reg(dev); ++ if (unlikely(res != 0)) { ++ mutex_unlock(&dev_priv_mutex); ++ goto out; ++ } ++ down_read(&dev->dev_rwsem); ++ mutex_unlock(&dev_priv_mutex); ++ ++ rc = copy_from_user(&get, arg, sizeof(get)); ++ if (unlikely(rc != 0)) { ++ PRINT_ERROR("Failed to copy %d user's bytes", rc); ++ res = -EFAULT; ++ goto out_up; ++ } ++ ++ TRACE_MGMT_DBG("Get ext cdb for dev %s", dev->name); ++ ++ TRACE_BUFFER("Get ext cdb", &get, sizeof(get)); ++ ++ spin_lock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ++ ucmd = __ucmd_find_hash(dev, get.cmd_h); ++ if (unlikely(ucmd == NULL)) { ++ TRACE_MGMT_DBG("cmd_h %d not found", get.cmd_h); ++ res = -ESRCH; ++ goto out_unlock; ++ } ++ ++ if (unlikely(ucmd_get_check(ucmd))) { ++ TRACE_MGMT_DBG("Found being destroyed cmd_h %d", get.cmd_h); ++ res = -ESRCH; ++ goto out_unlock; ++ } ++ ++ if ((ucmd->cmd != NULL) && (ucmd->state <= UCMD_STATE_EXECING) && ++ (ucmd->sent_to_user || ucmd->background_exec)) { ++ cmd = ucmd->cmd; ++ scst_cmd_get(cmd); ++ } else { ++ TRACE_MGMT_DBG("Invalid ucmd state %d for cmd_h %d", ++ ucmd->state, get.cmd_h); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++ spin_unlock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ++ if (cmd == NULL) ++ goto out_put; ++ ++ BUILD_BUG_ON(sizeof(cmd->cdb_buf) != SCST_MAX_CDB_SIZE); ++ ++ if (cmd->cdb_len <= SCST_MAX_CDB_SIZE) ++ goto out_cmd_put; ++ ++ EXTRACHECKS_BUG_ON(cmd->cdb_buf == cmd->cdb_buf); ++ ++ TRACE_BUFFER("EXT CDB", &cmd->cdb[sizeof(cmd->cdb_buf)], ++ cmd->cdb_len - sizeof(cmd->cdb_buf)); ++ rc = copy_to_user((void __user *)(unsigned long)get.ext_cdb_buffer, ++ &cmd->cdb[sizeof(cmd->cdb_buf)], ++ cmd->cdb_len - sizeof(cmd->cdb_buf)); ++ if (unlikely(rc != 0)) { ++ PRINT_ERROR("Failed to copy to user %d bytes", rc); ++ res = -EFAULT; ++ goto out_cmd_put; ++ } ++ ++out_cmd_put: ++ scst_cmd_put(cmd); ++ ++out_put: ++ ucmd_put(ucmd); ++ ++out_up: ++ up_read(&dev->dev_rwsem); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_unlock: ++ spin_unlock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ goto out_up; ++} ++ ++static int dev_user_process_scst_commands(struct scst_user_dev *dev) ++ __releases(&dev->udev_cmd_threads.cmd_list_lock) ++ __acquires(&dev->udev_cmd_threads.cmd_list_lock) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ while (!list_empty(&dev->udev_cmd_threads.active_cmd_list)) { ++ struct scst_cmd *cmd = list_entry( ++ dev->udev_cmd_threads.active_cmd_list.next, typeof(*cmd), ++ cmd_list_entry); ++ TRACE_DBG("Deleting cmd %p from active cmd list", cmd); ++ list_del(&cmd->cmd_list_entry); ++ spin_unlock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ scst_process_active_cmd(cmd, false); ++ spin_lock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ res++; ++ } ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* Called under udev_cmd_threads.cmd_list_lock and IRQ off */ ++static struct scst_user_cmd *__dev_user_get_next_cmd(struct list_head *cmd_list) ++ __releases(&dev->udev_cmd_threads.cmd_list_lock) ++ __acquires(&dev->udev_cmd_threads.cmd_list_lock) ++{ ++ struct scst_user_cmd *u; ++ ++again: ++ u = NULL; ++ if (!list_empty(cmd_list)) { ++ u = list_entry(cmd_list->next, typeof(*u), ++ ready_cmd_list_entry); ++ ++ TRACE_DBG("Found ready ucmd %p", u); ++ list_del(&u->ready_cmd_list_entry); ++ ++ EXTRACHECKS_BUG_ON(u->this_state_unjammed); ++ ++ if (u->cmd != NULL) { ++ if (u->state == UCMD_STATE_EXECING) { ++ struct scst_user_dev *dev = u->dev; ++ int rc; ++ ++ EXTRACHECKS_BUG_ON(u->jammed); ++ ++ spin_unlock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ++ rc = scst_check_local_events(u->cmd); ++ if (unlikely(rc != 0)) { ++ u->cmd->scst_cmd_done(u->cmd, ++ SCST_CMD_STATE_DEFAULT, ++ SCST_CONTEXT_DIRECT); ++ /* ++ * !! At this point cmd & u can be !! ++ * !! already freed !! ++ */ ++ spin_lock_irq( ++ &dev->udev_cmd_threads.cmd_list_lock); ++ goto again; ++ } ++ ++ spin_lock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ } else if (unlikely(test_bit(SCST_CMD_ABORTED, ++ &u->cmd->cmd_flags))) { ++ switch (u->state) { ++ case UCMD_STATE_PARSING: ++ case UCMD_STATE_BUF_ALLOCING: ++ TRACE_MGMT_DBG("Aborting ucmd %p", u); ++ dev_user_unjam_cmd(u, 0, NULL); ++ goto again; ++ case UCMD_STATE_EXECING: ++ EXTRACHECKS_BUG_ON(1); ++ } ++ } ++ } ++ u->sent_to_user = 1; ++ u->seen_by_user = 1; ++ } ++ return u; ++} ++ ++static inline int test_cmd_threads(struct scst_user_dev *dev) ++{ ++ int res = !list_empty(&dev->udev_cmd_threads.active_cmd_list) || ++ !list_empty(&dev->ready_cmd_list) || ++ !dev->blocking || dev->cleanup_done || ++ signal_pending(current); ++ return res; ++} ++ ++/* Called under udev_cmd_threads.cmd_list_lock and IRQ off */ ++static int dev_user_get_next_cmd(struct scst_user_dev *dev, ++ struct scst_user_cmd **ucmd) ++{ ++ int res = 0; ++ wait_queue_t wait; ++ ++ TRACE_ENTRY(); ++ ++ init_waitqueue_entry(&wait, current); ++ ++ while (1) { ++ if (!test_cmd_threads(dev)) { ++ add_wait_queue_exclusive_head( ++ &dev->udev_cmd_threads.cmd_list_waitQ, ++ &wait); ++ for (;;) { ++ set_current_state(TASK_INTERRUPTIBLE); ++ if (test_cmd_threads(dev)) ++ break; ++ spin_unlock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ schedule(); ++ spin_lock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ } ++ set_current_state(TASK_RUNNING); ++ remove_wait_queue(&dev->udev_cmd_threads.cmd_list_waitQ, ++ &wait); ++ } ++ ++ dev_user_process_scst_commands(dev); ++ ++ *ucmd = __dev_user_get_next_cmd(&dev->ready_cmd_list); ++ if (*ucmd != NULL) ++ break; ++ ++ if (!dev->blocking || dev->cleanup_done) { ++ res = -EAGAIN; ++ TRACE_DBG("No ready commands, returning %d", res); ++ break; ++ } ++ ++ if (signal_pending(current)) { ++ res = -EINTR; ++ TRACE_DBG("Signal pending, returning %d", res); ++ break; ++ } ++ } ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int dev_user_reply_get_cmd(struct file *file, void __user *arg) ++{ ++ int res = 0, rc; ++ struct scst_user_dev *dev; ++ struct scst_user_get_cmd *cmd; ++ struct scst_user_reply_cmd *reply; ++ struct scst_user_cmd *ucmd; ++ uint64_t ureply; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&dev_priv_mutex); ++ dev = file->private_data; ++ res = dev_user_check_reg(dev); ++ if (unlikely(res != 0)) { ++ mutex_unlock(&dev_priv_mutex); ++ goto out; ++ } ++ down_read(&dev->dev_rwsem); ++ mutex_unlock(&dev_priv_mutex); ++ ++ /* get_user() can't be used with 64-bit values on x86_32 */ ++ rc = copy_from_user(&ureply, (uint64_t __user *) ++ &((struct scst_user_get_cmd __user *)arg)->preply, ++ sizeof(ureply)); ++ if (unlikely(rc != 0)) { ++ PRINT_ERROR("Failed to copy %d user's bytes", rc); ++ res = -EFAULT; ++ goto out_up; ++ } ++ ++ TRACE_DBG("ureply %lld (dev %s)", (long long unsigned int)ureply, ++ dev->name); ++ ++ cmd = kmem_cache_alloc(user_get_cmd_cachep, GFP_KERNEL); ++ if (unlikely(cmd == NULL)) { ++ res = -ENOMEM; ++ goto out_up; ++ } ++ ++ if (ureply != 0) { ++ unsigned long u = (unsigned long)ureply; ++ reply = (struct scst_user_reply_cmd *)cmd; ++ rc = copy_from_user(reply, (void __user *)u, sizeof(*reply)); ++ if (unlikely(rc != 0)) { ++ PRINT_ERROR("Failed to copy %d user's bytes", rc); ++ res = -EFAULT; ++ goto out_free; ++ } ++ ++ TRACE_BUFFER("Reply", reply, sizeof(*reply)); ++ ++ res = dev_user_process_reply(dev, reply); ++ if (unlikely(res < 0)) ++ goto out_free; ++ } ++ ++ kmem_cache_free(user_get_cmd_cachep, cmd); ++ ++ spin_lock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++again: ++ res = dev_user_get_next_cmd(dev, &ucmd); ++ if (res == 0) { ++ int len; ++ /* ++ * A misbehaving user space handler can make ucmd to get dead ++ * immediately after we released the lock, which can lead to ++ * copy of dead data to the user space, which can lead to a ++ * leak of sensitive information. ++ */ ++ if (unlikely(ucmd_get_check(ucmd))) { ++ /* Oops, this ucmd is already being destroyed. Retry. */ ++ goto again; ++ } ++ spin_unlock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ++ EXTRACHECKS_BUG_ON(ucmd->user_cmd_payload_len == 0); ++ ++ len = ucmd->user_cmd_payload_len; ++ TRACE_DBG("ucmd %p (user_cmd %p), payload_len %d (len %d)", ++ ucmd, &ucmd->user_cmd, ucmd->user_cmd_payload_len, len); ++ TRACE_BUFFER("UCMD", &ucmd->user_cmd, len); ++ rc = copy_to_user(arg, &ucmd->user_cmd, len); ++ if (unlikely(rc != 0)) { ++ PRINT_ERROR("Copy to user failed (%d), requeuing ucmd " ++ "%p back to head of ready cmd list", rc, ucmd); ++ res = -EFAULT; ++ /* Requeue ucmd back */ ++ spin_lock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ list_add(&ucmd->ready_cmd_list_entry, ++ &dev->ready_cmd_list); ++ spin_unlock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ } ++#ifdef CONFIG_SCST_EXTRACHECKS ++ else ++ ucmd->user_cmd_payload_len = 0; ++#endif ++ ucmd_put(ucmd); ++ } else ++ spin_unlock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ++out_up: ++ up_read(&dev->dev_rwsem); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free: ++ kmem_cache_free(user_get_cmd_cachep, cmd); ++ goto out_up; ++} ++ ++static long dev_user_ioctl(struct file *file, unsigned int cmd, ++ unsigned long arg) ++{ ++ long res, rc; ++ ++ TRACE_ENTRY(); ++ ++ switch (cmd) { ++ case SCST_USER_REPLY_AND_GET_CMD: ++ TRACE_DBG("%s", "REPLY_AND_GET_CMD"); ++ res = dev_user_reply_get_cmd(file, (void __user *)arg); ++ break; ++ ++ case SCST_USER_REPLY_CMD: ++ TRACE_DBG("%s", "REPLY_CMD"); ++ res = dev_user_reply_cmd(file, (void __user *)arg); ++ break; ++ ++ case SCST_USER_GET_EXTENDED_CDB: ++ TRACE_DBG("%s", "GET_EXTENDED_CDB"); ++ res = dev_user_get_ext_cdb(file, (void __user *)arg); ++ break; ++ ++ case SCST_USER_REGISTER_DEVICE: ++ { ++ struct scst_user_dev_desc *dev_desc; ++ TRACE_DBG("%s", "REGISTER_DEVICE"); ++ dev_desc = kmalloc(sizeof(*dev_desc), GFP_KERNEL); ++ if (dev_desc == NULL) { ++ res = -ENOMEM; ++ goto out; ++ } ++ rc = copy_from_user(dev_desc, (void __user *)arg, ++ sizeof(*dev_desc)); ++ if (rc != 0) { ++ PRINT_ERROR("Failed to copy %ld user's bytes", rc); ++ res = -EFAULT; ++ kfree(dev_desc); ++ goto out; ++ } ++ TRACE_BUFFER("dev_desc", dev_desc, sizeof(*dev_desc)); ++ dev_desc->name[sizeof(dev_desc->name)-1] = '\0'; ++ dev_desc->sgv_name[sizeof(dev_desc->sgv_name)-1] = '\0'; ++ res = dev_user_register_dev(file, dev_desc); ++ kfree(dev_desc); ++ break; ++ } ++ ++ case SCST_USER_UNREGISTER_DEVICE: ++ TRACE_DBG("%s", "UNREGISTER_DEVICE"); ++ res = dev_user_unregister_dev(file); ++ break; ++ ++ case SCST_USER_FLUSH_CACHE: ++ TRACE_DBG("%s", "FLUSH_CACHE"); ++ res = dev_user_flush_cache(file); ++ break; ++ ++ case SCST_USER_SET_OPTIONS: ++ { ++ struct scst_user_opt opt; ++ TRACE_DBG("%s", "SET_OPTIONS"); ++ rc = copy_from_user(&opt, (void __user *)arg, sizeof(opt)); ++ if (rc != 0) { ++ PRINT_ERROR("Failed to copy %ld user's bytes", rc); ++ res = -EFAULT; ++ goto out; ++ } ++ TRACE_BUFFER("opt", &opt, sizeof(opt)); ++ res = dev_user_set_opt(file, &opt); ++ break; ++ } ++ ++ case SCST_USER_GET_OPTIONS: ++ TRACE_DBG("%s", "GET_OPTIONS"); ++ res = dev_user_get_opt(file, (void __user *)arg); ++ break; ++ ++ case SCST_USER_DEVICE_CAPACITY_CHANGED: ++ TRACE_DBG("%s", "CAPACITY_CHANGED"); ++ res = dev_user_capacity_changed(file); ++ break; ++ ++ case SCST_USER_PREALLOC_BUFFER: ++ TRACE_DBG("%s", "PREALLOC_BUFFER"); ++ res = dev_user_prealloc_buffer(file, (void __user *)arg); ++ break; ++ ++ default: ++ PRINT_ERROR("Invalid ioctl cmd %x", cmd); ++ res = -EINVAL; ++ goto out; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static unsigned int dev_user_poll(struct file *file, poll_table *wait) ++{ ++ int res = 0; ++ struct scst_user_dev *dev; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&dev_priv_mutex); ++ dev = file->private_data; ++ res = dev_user_check_reg(dev); ++ if (unlikely(res != 0)) { ++ mutex_unlock(&dev_priv_mutex); ++ goto out; ++ } ++ down_read(&dev->dev_rwsem); ++ mutex_unlock(&dev_priv_mutex); ++ ++ spin_lock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ++ if (!list_empty(&dev->ready_cmd_list) || ++ !list_empty(&dev->udev_cmd_threads.active_cmd_list)) { ++ res |= POLLIN | POLLRDNORM; ++ goto out_unlock; ++ } ++ ++ spin_unlock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ++ TRACE_DBG("Before poll_wait() (dev %s)", dev->name); ++ poll_wait(file, &dev->udev_cmd_threads.cmd_list_waitQ, wait); ++ TRACE_DBG("After poll_wait() (dev %s)", dev->name); ++ ++ spin_lock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ++ if (!list_empty(&dev->ready_cmd_list) || ++ !list_empty(&dev->udev_cmd_threads.active_cmd_list)) { ++ res |= POLLIN | POLLRDNORM; ++ goto out_unlock; ++ } ++ ++out_unlock: ++ spin_unlock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ++ up_read(&dev->dev_rwsem); ++ ++out: ++ TRACE_EXIT_HRES(res); ++ return res; ++} ++ ++/* ++ * Called under udev_cmd_threads.cmd_list_lock, but can drop it inside, ++ * then reacquire. ++ */ ++static void dev_user_unjam_cmd(struct scst_user_cmd *ucmd, int busy, ++ unsigned long *flags) ++ __releases(&dev->udev_cmd_threads.cmd_list_lock) ++ __acquires(&dev->udev_cmd_threads.cmd_list_lock) ++{ ++ int state = ucmd->state; ++ struct scst_user_dev *dev = ucmd->dev; ++ ++ TRACE_ENTRY(); ++ ++ if (ucmd->this_state_unjammed) ++ goto out; ++ ++ TRACE_MGMT_DBG("Unjamming ucmd %p (busy %d, state %x)", ucmd, busy, ++ state); ++ ++ ucmd->jammed = 1; ++ ucmd->this_state_unjammed = 1; ++ ucmd->sent_to_user = 0; ++ ++ switch (state) { ++ case UCMD_STATE_PARSING: ++ case UCMD_STATE_BUF_ALLOCING: ++ if (test_bit(SCST_CMD_ABORTED, &ucmd->cmd->cmd_flags)) ++ ucmd->aborted = 1; ++ else { ++ if (busy) ++ scst_set_busy(ucmd->cmd); ++ else ++ scst_set_cmd_error(ucmd->cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ } ++ scst_set_cmd_abnormal_done_state(ucmd->cmd); ++ ++ if (state == UCMD_STATE_PARSING) ++ scst_post_parse(ucmd->cmd); ++ else ++ scst_post_alloc_data_buf(ucmd->cmd); ++ ++ TRACE_MGMT_DBG("Adding ucmd %p to active list", ucmd); ++ list_add(&ucmd->cmd->cmd_list_entry, ++ &ucmd->cmd->cmd_threads->active_cmd_list); ++ wake_up(&ucmd->cmd->cmd_threads->cmd_list_waitQ); ++ break; ++ ++ case UCMD_STATE_EXECING: ++ if (flags != NULL) ++ spin_unlock_irqrestore(&dev->udev_cmd_threads.cmd_list_lock, ++ *flags); ++ else ++ spin_unlock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ++ TRACE_MGMT_DBG("EXEC: unjamming ucmd %p", ucmd); ++ ++ if (test_bit(SCST_CMD_ABORTED, &ucmd->cmd->cmd_flags)) ++ ucmd->aborted = 1; ++ else { ++ if (busy) ++ scst_set_busy(ucmd->cmd); ++ else ++ scst_set_cmd_error(ucmd->cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ } ++ ++ ucmd->cmd->scst_cmd_done(ucmd->cmd, SCST_CMD_STATE_DEFAULT, ++ SCST_CONTEXT_THREAD); ++ /* !! At this point cmd and ucmd can be already freed !! */ ++ ++ if (flags != NULL) ++ spin_lock_irqsave(&dev->udev_cmd_threads.cmd_list_lock, ++ *flags); ++ else ++ spin_lock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ break; ++ ++ case UCMD_STATE_ON_FREEING: ++ case UCMD_STATE_ON_CACHE_FREEING: ++ case UCMD_STATE_TM_EXECING: ++ case UCMD_STATE_ATTACH_SESS: ++ case UCMD_STATE_DETACH_SESS: ++ if (flags != NULL) ++ spin_unlock_irqrestore(&dev->udev_cmd_threads.cmd_list_lock, ++ *flags); ++ else ++ spin_unlock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ++ switch (state) { ++ case UCMD_STATE_ON_FREEING: ++ dev_user_process_reply_on_free(ucmd); ++ break; ++ ++ case UCMD_STATE_ON_CACHE_FREEING: ++ dev_user_process_reply_on_cache_free(ucmd); ++ break; ++ ++ case UCMD_STATE_TM_EXECING: ++ dev_user_process_reply_tm_exec(ucmd, ++ SCST_MGMT_STATUS_FAILED); ++ break; ++ ++ case UCMD_STATE_ATTACH_SESS: ++ case UCMD_STATE_DETACH_SESS: ++ dev_user_process_reply_sess(ucmd, -EFAULT); ++ break; ++ } ++ ++ if (flags != NULL) ++ spin_lock_irqsave(&dev->udev_cmd_threads.cmd_list_lock, ++ *flags); ++ else ++ spin_lock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ break; ++ ++ default: ++ PRINT_CRIT_ERROR("Wrong ucmd state %x", state); ++ BUG(); ++ break; ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static int dev_user_unjam_dev(struct scst_user_dev *dev) ++ __releases(&dev->udev_cmd_threads.cmd_list_lock) ++ __acquires(&dev->udev_cmd_threads.cmd_list_lock) ++{ ++ int i, res = 0; ++ struct scst_user_cmd *ucmd; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Unjamming dev %p", dev); ++ ++ sgv_pool_flush(dev->pool); ++ sgv_pool_flush(dev->pool_clust); ++ ++ spin_lock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ++repeat: ++ for (i = 0; i < (int)ARRAY_SIZE(dev->ucmd_hash); i++) { ++ struct list_head *head = &dev->ucmd_hash[i]; ++ ++ list_for_each_entry(ucmd, head, hash_list_entry) { ++ res++; ++ ++ if (!ucmd->sent_to_user) ++ continue; ++ ++ if (ucmd_get_check(ucmd)) ++ continue; ++ ++ TRACE_MGMT_DBG("ucmd %p, state %x, scst_cmd %p", ucmd, ++ ucmd->state, ucmd->cmd); ++ ++ dev_user_unjam_cmd(ucmd, 0, NULL); ++ ++ spin_unlock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ucmd_put(ucmd); ++ spin_lock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ++ goto repeat; ++ } ++ } ++ ++ if (dev_user_process_scst_commands(dev) != 0) ++ goto repeat; ++ ++ spin_unlock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int dev_user_process_reply_tm_exec(struct scst_user_cmd *ucmd, ++ int status) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("TM reply (ucmd %p, fn %d, status %d)", ucmd, ++ ucmd->user_cmd.tm_cmd.fn, status); ++ ++ if (status == SCST_MGMT_STATUS_TASK_NOT_EXIST) { ++ /* ++ * It is possible that user space seen TM cmd before cmd ++ * to abort or will never see it at all, because it was ++ * aborted on the way there. So, it is safe to return ++ * success instead, because, if there is the TM cmd at this ++ * point, then the cmd to abort apparrently does exist. ++ */ ++ status = SCST_MGMT_STATUS_SUCCESS; ++ } ++ ++ scst_async_mcmd_completed(ucmd->mcmd, status); ++ ++ ucmd_put(ucmd); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void dev_user_abort_ready_commands(struct scst_user_dev *dev) ++{ ++ struct scst_user_cmd *ucmd; ++ unsigned long flags; ++ ++ TRACE_ENTRY(); ++ ++ spin_lock_irqsave(&dev->udev_cmd_threads.cmd_list_lock, flags); ++again: ++ list_for_each_entry(ucmd, &dev->ready_cmd_list, ready_cmd_list_entry) { ++ if ((ucmd->cmd != NULL) && !ucmd->seen_by_user && ++ test_bit(SCST_CMD_ABORTED, &ucmd->cmd->cmd_flags)) { ++ switch (ucmd->state) { ++ case UCMD_STATE_PARSING: ++ case UCMD_STATE_BUF_ALLOCING: ++ case UCMD_STATE_EXECING: ++ TRACE_MGMT_DBG("Aborting ready ucmd %p", ucmd); ++ list_del(&ucmd->ready_cmd_list_entry); ++ dev_user_unjam_cmd(ucmd, 0, &flags); ++ goto again; ++ } ++ } ++ } ++ ++ spin_unlock_irqrestore(&dev->udev_cmd_threads.cmd_list_lock, flags); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Can be called under some spinlock and IRQs off */ ++static int dev_user_task_mgmt_fn(struct scst_mgmt_cmd *mcmd, ++ struct scst_tgt_dev *tgt_dev) ++{ ++ struct scst_user_cmd *ucmd; ++ struct scst_user_dev *dev = tgt_dev->dev->dh_priv; ++ struct scst_user_cmd *ucmd_to_abort = NULL; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * In the used approach we don't do anything with hung devices, which ++ * stopped responding and/or have stuck commands. We forcedly abort such ++ * commands only if they not yet sent to the user space or if the device ++ * is getting unloaded, e.g. if its handler program gets killed. This is ++ * because it's pretty hard to distinguish between stuck and temporary ++ * overloaded states of the device. There are several reasons for that: ++ * ++ * 1. Some commands need a lot of time to complete (several hours), ++ * so for an impatient user such command(s) will always look as ++ * stuck. ++ * ++ * 2. If we forcedly abort, i.e. abort before it's actually completed ++ * in the user space, just one command, we will have to put the whole ++ * device offline until we are sure that no more previously aborted ++ * commands will get executed. Otherwise, we might have a possibility ++ * for data corruption, when aborted and reported as completed ++ * command actually gets executed *after* new commands sent ++ * after the force abort was done. Many journaling file systems and ++ * databases use "provide required commands order via queue draining" ++ * approach and not putting the whole device offline after the forced ++ * abort will break it. This makes our decision, if a command stuck ++ * or not, cost a lot. ++ * ++ * So, we leave policy definition if a device stuck or not to ++ * the user space and simply let all commands live until they are ++ * completed or their devices get closed/killed. This approach is very ++ * much OK, but can affect management commands, which need activity ++ * suspending via scst_suspend_activity() function such as devices or ++ * targets registration/removal. But during normal life such commands ++ * should be rare. Plus, when possible, scst_suspend_activity() will ++ * return after timeout EBUSY status to allow caller to not stuck ++ * forever as well. ++ * ++ * But, anyway, ToDo, we should reimplement that in the SCST core, so ++ * stuck commands would affect only related devices. ++ */ ++ ++ dev_user_abort_ready_commands(dev); ++ ++ /* We can't afford missing TM command due to memory shortage */ ++ ucmd = dev_user_alloc_ucmd(dev, GFP_ATOMIC|__GFP_NOFAIL); ++ if (ucmd == NULL) { ++ PRINT_CRIT_ERROR("Unable to allocate TM %d message " ++ "(dev %s)", mcmd->fn, dev->name); ++ goto out; ++ } ++ ++ ucmd->user_cmd_payload_len = ++ offsetof(struct scst_user_get_cmd, tm_cmd) + ++ sizeof(ucmd->user_cmd.tm_cmd); ++ ucmd->user_cmd.cmd_h = ucmd->h; ++ ucmd->user_cmd.subcode = SCST_USER_TASK_MGMT; ++ ucmd->user_cmd.tm_cmd.sess_h = (unsigned long)tgt_dev; ++ ucmd->user_cmd.tm_cmd.fn = mcmd->fn; ++ ucmd->user_cmd.tm_cmd.cmd_sn = mcmd->cmd_sn; ++ ucmd->user_cmd.tm_cmd.cmd_sn_set = mcmd->cmd_sn_set; ++ ++ if (mcmd->cmd_to_abort != NULL) { ++ ucmd_to_abort = mcmd->cmd_to_abort->dh_priv; ++ if (ucmd_to_abort != NULL) ++ ucmd->user_cmd.tm_cmd.cmd_h_to_abort = ucmd_to_abort->h; ++ } ++ ++ TRACE_MGMT_DBG("Preparing TM ucmd %p (h %d, fn %d, cmd_to_abort %p, " ++ "ucmd_to_abort %p, cmd_h_to_abort %d, mcmd %p)", ucmd, ucmd->h, ++ mcmd->fn, mcmd->cmd_to_abort, ucmd_to_abort, ++ ucmd->user_cmd.tm_cmd.cmd_h_to_abort, mcmd); ++ ++ ucmd->mcmd = mcmd; ++ ucmd->state = UCMD_STATE_TM_EXECING; ++ ++ scst_prepare_async_mcmd(mcmd); ++ ++ dev_user_add_to_ready(ucmd); ++ ++out: ++ TRACE_EXIT(); ++ return SCST_DEV_TM_NOT_COMPLETED; ++} ++ ++static int dev_user_attach(struct scst_device *sdev) ++{ ++ int res = 0; ++ struct scst_user_dev *dev = NULL, *d; ++ ++ TRACE_ENTRY(); ++ ++ spin_lock(&dev_list_lock); ++ list_for_each_entry(d, &dev_list, dev_list_entry) { ++ if (strcmp(d->name, sdev->virt_name) == 0) { ++ dev = d; ++ break; ++ } ++ } ++ spin_unlock(&dev_list_lock); ++ if (dev == NULL) { ++ PRINT_ERROR("Device %s not found", sdev->virt_name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ sdev->dh_priv = dev; ++ sdev->tst = dev->tst; ++ sdev->queue_alg = dev->queue_alg; ++ sdev->swp = dev->swp; ++ sdev->tas = dev->tas; ++ sdev->d_sense = dev->d_sense; ++ sdev->has_own_order_mgmt = dev->has_own_order_mgmt; ++ ++ dev->sdev = sdev; ++ ++ PRINT_INFO("Attached user space virtual device \"%s\"", ++ dev->name); ++ ++out: ++ TRACE_EXIT(); ++ return res; ++} ++ ++static void dev_user_detach(struct scst_device *sdev) ++{ ++ struct scst_user_dev *dev = sdev->dh_priv; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("virt_id %d", sdev->virt_id); ++ ++ PRINT_INFO("Detached user space virtual device \"%s\"", ++ dev->name); ++ ++ /* dev will be freed by the caller */ ++ sdev->dh_priv = NULL; ++ dev->sdev = NULL; ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int dev_user_process_reply_sess(struct scst_user_cmd *ucmd, int status) ++{ ++ int res = 0; ++ unsigned long flags; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("ucmd %p, cmpl %p, status %d", ucmd, ucmd->cmpl, status); ++ ++ spin_lock_irqsave(&ucmd->dev->udev_cmd_threads.cmd_list_lock, flags); ++ ++ if (ucmd->state == UCMD_STATE_ATTACH_SESS) { ++ TRACE_MGMT_DBG("%s", "ATTACH_SESS finished"); ++ ucmd->result = status; ++ } else if (ucmd->state == UCMD_STATE_DETACH_SESS) { ++ TRACE_MGMT_DBG("%s", "DETACH_SESS finished"); ++ } else ++ BUG(); ++ ++ if (ucmd->cmpl != NULL) ++ complete_all(ucmd->cmpl); ++ ++ spin_unlock_irqrestore(&ucmd->dev->udev_cmd_threads.cmd_list_lock, flags); ++ ++ ucmd_put(ucmd); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int dev_user_attach_tgt(struct scst_tgt_dev *tgt_dev) ++{ ++ struct scst_user_dev *dev = tgt_dev->dev->dh_priv; ++ int res = 0, rc; ++ struct scst_user_cmd *ucmd; ++ DECLARE_COMPLETION_ONSTACK(cmpl); ++ struct scst_tgt_template *tgtt = tgt_dev->sess->tgt->tgtt; ++ struct scst_tgt *tgt = tgt_dev->sess->tgt; ++ ++ TRACE_ENTRY(); ++ ++ tgt_dev->active_cmd_threads = &dev->udev_cmd_threads; ++ ++ /* ++ * We can't replace tgt_dev->pool, because it can be used to allocate ++ * memory for SCST local commands, like REPORT LUNS, where there is no ++ * corresponding ucmd. Otherwise we will crash in dev_user_alloc_sg(). ++ */ ++ if (test_bit(SCST_TGT_DEV_CLUST_POOL, &tgt_dev->tgt_dev_flags)) ++ tgt_dev->dh_priv = dev->pool_clust; ++ else ++ tgt_dev->dh_priv = dev->pool; ++ ++ ucmd = dev_user_alloc_ucmd(dev, GFP_KERNEL); ++ if (ucmd == NULL) ++ goto out_nomem; ++ ++ ucmd->cmpl = &cmpl; ++ ++ ucmd->user_cmd_payload_len = offsetof(struct scst_user_get_cmd, sess) + ++ sizeof(ucmd->user_cmd.sess); ++ ucmd->user_cmd.cmd_h = ucmd->h; ++ ucmd->user_cmd.subcode = SCST_USER_ATTACH_SESS; ++ ucmd->user_cmd.sess.sess_h = (unsigned long)tgt_dev; ++ ucmd->user_cmd.sess.lun = (uint64_t)tgt_dev->lun; ++ ucmd->user_cmd.sess.threads_num = tgt_dev->sess->tgt->tgtt->threads_num; ++ ucmd->user_cmd.sess.rd_only = tgt_dev->acg_dev->rd_only; ++ if (tgtt->get_phys_transport_version != NULL) ++ ucmd->user_cmd.sess.phys_transport_version = ++ tgtt->get_phys_transport_version(tgt); ++ if (tgtt->get_scsi_transport_version != NULL) ++ ucmd->user_cmd.sess.scsi_transport_version = ++ tgtt->get_scsi_transport_version(tgt); ++ strlcpy(ucmd->user_cmd.sess.initiator_name, ++ tgt_dev->sess->initiator_name, ++ sizeof(ucmd->user_cmd.sess.initiator_name)-1); ++ strlcpy(ucmd->user_cmd.sess.target_name, ++ tgt_dev->sess->tgt->tgt_name, ++ sizeof(ucmd->user_cmd.sess.target_name)-1); ++ ++ TRACE_MGMT_DBG("Preparing ATTACH_SESS %p (h %d, sess_h %llx, LUN %llx, " ++ "threads_num %d, rd_only %d, initiator %s, target %s)", ++ ucmd, ucmd->h, ucmd->user_cmd.sess.sess_h, ++ ucmd->user_cmd.sess.lun, ucmd->user_cmd.sess.threads_num, ++ ucmd->user_cmd.sess.rd_only, ucmd->user_cmd.sess.initiator_name, ++ ucmd->user_cmd.sess.target_name); ++ ++ ucmd->state = UCMD_STATE_ATTACH_SESS; ++ ++ ucmd_get(ucmd); ++ ++ dev_user_add_to_ready(ucmd); ++ ++ rc = wait_for_completion_timeout(ucmd->cmpl, DEV_USER_ATTACH_TIMEOUT); ++ if (rc > 0) ++ res = ucmd->result; ++ else { ++ PRINT_ERROR("%s", "ATTACH_SESS command timeout"); ++ res = -EFAULT; ++ } ++ ++ BUG_ON(irqs_disabled()); ++ ++ spin_lock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ucmd->cmpl = NULL; ++ spin_unlock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ++ ucmd_put(ucmd); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_nomem: ++ res = -ENOMEM; ++ goto out; ++} ++ ++static void dev_user_detach_tgt(struct scst_tgt_dev *tgt_dev) ++{ ++ struct scst_user_dev *dev = tgt_dev->dev->dh_priv; ++ struct scst_user_cmd *ucmd; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * We can't miss detach command due to memory shortage, because it might ++ * lead to a memory leak in the user space handler. ++ */ ++ ucmd = dev_user_alloc_ucmd(dev, GFP_KERNEL|__GFP_NOFAIL); ++ if (ucmd == NULL) { ++ PRINT_CRIT_ERROR("Unable to allocate DETACH_SESS message " ++ "(dev %s)", dev->name); ++ goto out; ++ } ++ ++ TRACE_MGMT_DBG("Preparing DETACH_SESS %p (h %d, sess_h %llx)", ucmd, ++ ucmd->h, ucmd->user_cmd.sess.sess_h); ++ ++ ucmd->user_cmd_payload_len = offsetof(struct scst_user_get_cmd, sess) + ++ sizeof(ucmd->user_cmd.sess); ++ ucmd->user_cmd.cmd_h = ucmd->h; ++ ucmd->user_cmd.subcode = SCST_USER_DETACH_SESS; ++ ucmd->user_cmd.sess.sess_h = (unsigned long)tgt_dev; ++ ++ ucmd->state = UCMD_STATE_DETACH_SESS; ++ ++ dev_user_add_to_ready(ucmd); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* No locks are needed, but the activity must be suspended */ ++static void dev_user_setup_functions(struct scst_user_dev *dev) ++{ ++ TRACE_ENTRY(); ++ ++ dev->devtype.parse = dev_user_parse; ++ dev->devtype.alloc_data_buf = dev_user_alloc_data_buf; ++ dev->devtype.dev_done = NULL; ++ ++ if (dev->parse_type != SCST_USER_PARSE_CALL) { ++ switch (dev->devtype.type) { ++ case TYPE_DISK: ++ dev->generic_parse = scst_sbc_generic_parse; ++ dev->devtype.dev_done = dev_user_disk_done; ++ break; ++ ++ case TYPE_TAPE: ++ dev->generic_parse = scst_tape_generic_parse; ++ dev->devtype.dev_done = dev_user_tape_done; ++ break; ++ ++ case TYPE_MOD: ++ dev->generic_parse = scst_modisk_generic_parse; ++ dev->devtype.dev_done = dev_user_disk_done; ++ break; ++ ++ case TYPE_ROM: ++ dev->generic_parse = scst_cdrom_generic_parse; ++ dev->devtype.dev_done = dev_user_disk_done; ++ break; ++ ++ case TYPE_MEDIUM_CHANGER: ++ dev->generic_parse = scst_changer_generic_parse; ++ break; ++ ++ case TYPE_PROCESSOR: ++ dev->generic_parse = scst_processor_generic_parse; ++ break; ++ ++ case TYPE_RAID: ++ dev->generic_parse = scst_raid_generic_parse; ++ break; ++ ++ default: ++ PRINT_INFO("Unknown SCSI type %x, using PARSE_CALL " ++ "for it", dev->devtype.type); ++ dev->parse_type = SCST_USER_PARSE_CALL; ++ break; ++ } ++ } else { ++ dev->generic_parse = NULL; ++ dev->devtype.dev_done = NULL; ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int dev_user_check_version(const struct scst_user_dev_desc *dev_desc) ++{ ++ char str[sizeof(DEV_USER_VERSION) > 20 ? sizeof(DEV_USER_VERSION) : 20]; ++ int res = 0, rc; ++ ++ rc = copy_from_user(str, ++ (void __user *)(unsigned long)dev_desc->license_str, ++ sizeof(str)); ++ if (rc != 0) { ++ PRINT_ERROR("%s", "Unable to get license string"); ++ res = -EFAULT; ++ goto out; ++ } ++ str[sizeof(str)-1] = '\0'; ++ ++ if ((strcmp(str, "GPL") != 0) && ++ (strcmp(str, "GPL v2") != 0) && ++ (strcmp(str, "Dual BSD/GPL") != 0) && ++ (strcmp(str, "Dual MIT/GPL") != 0) && ++ (strcmp(str, "Dual MPL/GPL") != 0)) { ++ /* ->name already 0-terminated in dev_user_ioctl() */ ++ PRINT_ERROR("Unsupported license of user device %s (%s). " ++ "Ask license@scst-tgt.com for more info.", ++ dev_desc->name, str); ++ res = -EPERM; ++ goto out; ++ } ++ ++ rc = copy_from_user(str, ++ (void __user *)(unsigned long)dev_desc->version_str, ++ sizeof(str)); ++ if (rc != 0) { ++ PRINT_ERROR("%s", "Unable to get version string"); ++ res = -EFAULT; ++ goto out; ++ } ++ str[sizeof(str)-1] = '\0'; ++ ++ if (strcmp(str, DEV_USER_VERSION) != 0) { ++ /* ->name already 0-terminated in dev_user_ioctl() */ ++ PRINT_ERROR("Incorrect version of user device %s (%s). " ++ "Expected: %s", dev_desc->name, str, ++ DEV_USER_VERSION); ++ res = -EINVAL; ++ goto out; ++ } ++ ++out: ++ return res; ++} ++ ++static int dev_user_register_dev(struct file *file, ++ const struct scst_user_dev_desc *dev_desc) ++{ ++ int res, i; ++ struct scst_user_dev *dev, *d; ++ int block; ++ ++ TRACE_ENTRY(); ++ ++ res = dev_user_check_version(dev_desc); ++ if (res != 0) ++ goto out; ++ ++ switch (dev_desc->type) { ++ case TYPE_DISK: ++ case TYPE_ROM: ++ case TYPE_MOD: ++ if (dev_desc->block_size == 0) { ++ PRINT_ERROR("Wrong block size %d", ++ dev_desc->block_size); ++ res = -EINVAL; ++ goto out; ++ } ++ block = scst_calc_block_shift(dev_desc->block_size); ++ if (block == -1) { ++ res = -EINVAL; ++ goto out; ++ } ++ break; ++ default: ++ block = dev_desc->block_size; ++ break; ++ } ++ ++ if (!try_module_get(THIS_MODULE)) { ++ PRINT_ERROR("%s", "Fail to get module"); ++ res = -ETXTBSY; ++ goto out; ++ } ++ ++ dev = kzalloc(sizeof(*dev), GFP_KERNEL); ++ if (dev == NULL) { ++ res = -ENOMEM; ++ goto out_put; ++ } ++ ++ init_rwsem(&dev->dev_rwsem); ++ INIT_LIST_HEAD(&dev->ready_cmd_list); ++ if (file->f_flags & O_NONBLOCK) { ++ TRACE_DBG("%s", "Non-blocking operations"); ++ dev->blocking = 0; ++ } else ++ dev->blocking = 1; ++ for (i = 0; i < (int)ARRAY_SIZE(dev->ucmd_hash); i++) ++ INIT_LIST_HEAD(&dev->ucmd_hash[i]); ++ ++ scst_init_threads(&dev->udev_cmd_threads); ++ ++ strlcpy(dev->name, dev_desc->name, sizeof(dev->name)-1); ++ ++ scst_init_mem_lim(&dev->udev_mem_lim); ++ ++ scnprintf(dev->devtype.name, sizeof(dev->devtype.name), "%s", ++ (dev_desc->sgv_name[0] == '\0') ? dev->name : ++ dev_desc->sgv_name); ++ dev->pool = sgv_pool_create(dev->devtype.name, sgv_no_clustering, ++ dev_desc->sgv_single_alloc_pages, ++ dev_desc->sgv_shared, ++ dev_desc->sgv_purge_interval); ++ if (dev->pool == NULL) { ++ res = -ENOMEM; ++ goto out_deinit_threads; ++ } ++ sgv_pool_set_allocator(dev->pool, dev_user_alloc_pages, ++ dev_user_free_sg_entries); ++ ++ if (!dev_desc->sgv_disable_clustered_pool) { ++ scnprintf(dev->devtype.name, sizeof(dev->devtype.name), ++ "%s-clust", ++ (dev_desc->sgv_name[0] == '\0') ? dev->name : ++ dev_desc->sgv_name); ++ dev->pool_clust = sgv_pool_create(dev->devtype.name, ++ sgv_tail_clustering, ++ dev_desc->sgv_single_alloc_pages, ++ dev_desc->sgv_shared, ++ dev_desc->sgv_purge_interval); ++ if (dev->pool_clust == NULL) { ++ res = -ENOMEM; ++ goto out_free0; ++ } ++ sgv_pool_set_allocator(dev->pool_clust, dev_user_alloc_pages, ++ dev_user_free_sg_entries); ++ } else { ++ dev->pool_clust = dev->pool; ++ sgv_pool_get(dev->pool_clust); ++ } ++ ++ scnprintf(dev->devtype.name, sizeof(dev->devtype.name), "%s", ++ dev->name); ++ dev->devtype.type = dev_desc->type; ++ dev->devtype.threads_num = -1; ++ dev->devtype.parse_atomic = 1; ++ dev->devtype.alloc_data_buf_atomic = 1; ++ dev->devtype.dev_done_atomic = 1; ++ dev->devtype.dev_attrs = dev_user_dev_attrs; ++ dev->devtype.attach = dev_user_attach; ++ dev->devtype.detach = dev_user_detach; ++ dev->devtype.attach_tgt = dev_user_attach_tgt; ++ dev->devtype.detach_tgt = dev_user_detach_tgt; ++ dev->devtype.exec = dev_user_exec; ++ dev->devtype.on_free_cmd = dev_user_on_free_cmd; ++ dev->devtype.task_mgmt_fn = dev_user_task_mgmt_fn; ++ if (dev_desc->enable_pr_cmds_notifications) ++ dev->devtype.pr_cmds_notifications = 1; ++ ++ init_completion(&dev->cleanup_cmpl); ++ dev->block = block; ++ dev->def_block = block; ++ ++ res = __dev_user_set_opt(dev, &dev_desc->opt); ++ if (res != 0) ++ goto out_free; ++ ++ TRACE_MEM("dev %p, name %s", dev, dev->name); ++ ++ spin_lock(&dev_list_lock); ++ ++ list_for_each_entry(d, &dev_list, dev_list_entry) { ++ if (strcmp(d->name, dev->name) == 0) { ++ PRINT_ERROR("Device %s already exist", ++ dev->name); ++ res = -EEXIST; ++ spin_unlock(&dev_list_lock); ++ goto out_free; ++ } ++ } ++ ++ list_add_tail(&dev->dev_list_entry, &dev_list); ++ ++ spin_unlock(&dev_list_lock); ++ ++ res = scst_register_virtual_dev_driver(&dev->devtype); ++ if (res < 0) ++ goto out_del_free; ++ ++ dev->virt_id = scst_register_virtual_device(&dev->devtype, dev->name); ++ if (dev->virt_id < 0) { ++ res = dev->virt_id; ++ goto out_unreg_handler; ++ } ++ ++ mutex_lock(&dev_priv_mutex); ++ if (file->private_data != NULL) { ++ mutex_unlock(&dev_priv_mutex); ++ PRINT_ERROR("%s", "Device already registered"); ++ res = -EINVAL; ++ goto out_unreg_drv; ++ } ++ file->private_data = dev; ++ mutex_unlock(&dev_priv_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_unreg_drv: ++ scst_unregister_virtual_device(dev->virt_id); ++ ++out_unreg_handler: ++ scst_unregister_virtual_dev_driver(&dev->devtype); ++ ++out_del_free: ++ spin_lock(&dev_list_lock); ++ list_del(&dev->dev_list_entry); ++ spin_unlock(&dev_list_lock); ++ ++out_free: ++ sgv_pool_del(dev->pool_clust); ++ ++out_free0: ++ sgv_pool_del(dev->pool); ++ ++out_deinit_threads: ++ scst_deinit_threads(&dev->udev_cmd_threads); ++ ++ kfree(dev); ++ ++out_put: ++ module_put(THIS_MODULE); ++ goto out; ++} ++ ++static int dev_user_unregister_dev(struct file *file) ++{ ++ int res; ++ struct scst_user_dev *dev; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&dev_priv_mutex); ++ dev = file->private_data; ++ res = dev_user_check_reg(dev); ++ if (res != 0) { ++ mutex_unlock(&dev_priv_mutex); ++ goto out; ++ } ++ down_read(&dev->dev_rwsem); ++ mutex_unlock(&dev_priv_mutex); ++ ++ res = scst_suspend_activity(true); ++ if (res != 0) ++ goto out_up; ++ ++ up_read(&dev->dev_rwsem); ++ ++ mutex_lock(&dev_priv_mutex); ++ dev = file->private_data; ++ if (dev == NULL) { ++ mutex_unlock(&dev_priv_mutex); ++ goto out_resume; ++ } ++ ++ dev->blocking = 0; ++ wake_up_all(&dev->udev_cmd_threads.cmd_list_waitQ); ++ ++ down_write(&dev->dev_rwsem); ++ file->private_data = NULL; ++ mutex_unlock(&dev_priv_mutex); ++ ++ dev_user_exit_dev(dev); ++ ++ up_write(&dev->dev_rwsem); /* to make lockdep happy */ ++ ++ kfree(dev); ++ ++out_resume: ++ scst_resume_activity(); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_up: ++ up_read(&dev->dev_rwsem); ++ goto out; ++} ++ ++static int dev_user_flush_cache(struct file *file) ++{ ++ int res; ++ struct scst_user_dev *dev; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&dev_priv_mutex); ++ dev = file->private_data; ++ res = dev_user_check_reg(dev); ++ if (res != 0) { ++ mutex_unlock(&dev_priv_mutex); ++ goto out; ++ } ++ down_read(&dev->dev_rwsem); ++ mutex_unlock(&dev_priv_mutex); ++ ++ res = scst_suspend_activity(true); ++ if (res != 0) ++ goto out_up; ++ ++ sgv_pool_flush(dev->pool); ++ sgv_pool_flush(dev->pool_clust); ++ ++ scst_resume_activity(); ++ ++out_up: ++ up_read(&dev->dev_rwsem); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int dev_user_capacity_changed(struct file *file) ++{ ++ int res; ++ struct scst_user_dev *dev; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&dev_priv_mutex); ++ dev = file->private_data; ++ res = dev_user_check_reg(dev); ++ if (res != 0) { ++ mutex_unlock(&dev_priv_mutex); ++ goto out; ++ } ++ down_read(&dev->dev_rwsem); ++ mutex_unlock(&dev_priv_mutex); ++ ++ scst_capacity_data_changed(dev->sdev); ++ ++ up_read(&dev->dev_rwsem); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int dev_user_prealloc_buffer(struct file *file, void __user *arg) ++{ ++ int res = 0, rc; ++ struct scst_user_dev *dev; ++ union scst_user_prealloc_buffer pre; ++ aligned_u64 pbuf; ++ uint32_t bufflen; ++ struct scst_user_cmd *ucmd; ++ int pages, sg_cnt; ++ struct sgv_pool *pool; ++ struct scatterlist *sg; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&dev_priv_mutex); ++ dev = file->private_data; ++ res = dev_user_check_reg(dev); ++ if (unlikely(res != 0)) { ++ mutex_unlock(&dev_priv_mutex); ++ goto out; ++ } ++ down_read(&dev->dev_rwsem); ++ mutex_unlock(&dev_priv_mutex); ++ ++ rc = copy_from_user(&pre.in, arg, sizeof(pre.in)); ++ if (unlikely(rc != 0)) { ++ PRINT_ERROR("Failed to copy %d user's bytes", rc); ++ res = -EFAULT; ++ goto out_up; ++ } ++ ++ TRACE_MEM("Prealloc buffer with size %dKB for dev %s", ++ pre.in.bufflen / 1024, dev->name); ++ TRACE_BUFFER("Input param", &pre.in, sizeof(pre.in)); ++ ++ pbuf = pre.in.pbuf; ++ bufflen = pre.in.bufflen; ++ ++ ucmd = dev_user_alloc_ucmd(dev, GFP_KERNEL); ++ if (ucmd == NULL) { ++ res = -ENOMEM; ++ goto out_up; ++ } ++ ++ ucmd->buff_cached = 1; ++ ++ TRACE_MEM("ucmd %p, pbuf %llx", ucmd, pbuf); ++ ++ if (unlikely((pbuf & ~PAGE_MASK) != 0)) { ++ PRINT_ERROR("Supplied pbuf %llx isn't page aligned", pbuf); ++ res = -EINVAL; ++ goto out_put; ++ } ++ ++ pages = calc_num_pg(pbuf, bufflen); ++ res = dev_user_map_buf(ucmd, pbuf, pages); ++ if (res != 0) ++ goto out_put; ++ ++ if (pre.in.for_clust_pool) ++ pool = dev->pool_clust; ++ else ++ pool = dev->pool; ++ ++ sg = sgv_pool_alloc(pool, bufflen, GFP_KERNEL, SGV_POOL_ALLOC_GET_NEW, ++ &sg_cnt, &ucmd->sgv, &dev->udev_mem_lim, ucmd); ++ if (sg != NULL) { ++ struct scst_user_cmd *buf_ucmd = sgv_get_priv(ucmd->sgv); ++ ++ TRACE_MEM("Buf ucmd %p (sg_cnt %d, last seg len %d, " ++ "bufflen %d)", buf_ucmd, sg_cnt, ++ sg[sg_cnt-1].length, bufflen); ++ ++ EXTRACHECKS_BUG_ON(ucmd != buf_ucmd); ++ ++ ucmd->buf_ucmd = buf_ucmd; ++ } else { ++ res = -ENOMEM; ++ goto out_put; ++ } ++ ++ dev_user_free_sgv(ucmd); ++ ++ pre.out.cmd_h = ucmd->h; ++ rc = copy_to_user(arg, &pre.out, sizeof(pre.out)); ++ if (unlikely(rc != 0)) { ++ PRINT_ERROR("Failed to copy to user %d bytes", rc); ++ res = -EFAULT; ++ goto out_put; ++ } ++ ++out_put: ++ ucmd_put(ucmd); ++ ++out_up: ++ up_read(&dev->dev_rwsem); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int __dev_user_set_opt(struct scst_user_dev *dev, ++ const struct scst_user_opt *opt) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("dev %s, parse_type %x, on_free_cmd_type %x, " ++ "memory_reuse_type %x, partial_transfers_type %x, " ++ "partial_len %d", dev->name, opt->parse_type, ++ opt->on_free_cmd_type, opt->memory_reuse_type, ++ opt->partial_transfers_type, opt->partial_len); ++ ++ if (opt->parse_type > SCST_USER_MAX_PARSE_OPT || ++ opt->on_free_cmd_type > SCST_USER_MAX_ON_FREE_CMD_OPT || ++ opt->memory_reuse_type > SCST_USER_MAX_MEM_REUSE_OPT || ++ opt->partial_transfers_type > SCST_USER_MAX_PARTIAL_TRANSFERS_OPT) { ++ PRINT_ERROR("%s", "Invalid option"); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (((opt->tst != SCST_CONTR_MODE_ONE_TASK_SET) && ++ (opt->tst != SCST_CONTR_MODE_SEP_TASK_SETS)) || ++ ((opt->queue_alg != SCST_CONTR_MODE_QUEUE_ALG_RESTRICTED_REORDER) && ++ (opt->queue_alg != SCST_CONTR_MODE_QUEUE_ALG_UNRESTRICTED_REORDER)) || ++ (opt->swp > 1) || (opt->tas > 1) || (opt->has_own_order_mgmt > 1) || ++ (opt->d_sense > 1)) { ++ PRINT_ERROR("Invalid SCSI option (tst %x, queue_alg %x, swp %x," ++ " tas %x, d_sense %d, has_own_order_mgmt %x)", opt->tst, ++ opt->queue_alg, opt->swp, opt->tas, opt->d_sense, ++ opt->has_own_order_mgmt); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ dev->parse_type = opt->parse_type; ++ dev->on_free_cmd_type = opt->on_free_cmd_type; ++ dev->memory_reuse_type = opt->memory_reuse_type; ++ dev->partial_transfers_type = opt->partial_transfers_type; ++ dev->partial_len = opt->partial_len; ++ ++ dev->tst = opt->tst; ++ dev->queue_alg = opt->queue_alg; ++ dev->swp = opt->swp; ++ dev->tas = opt->tas; ++ dev->tst = opt->tst; ++ dev->d_sense = opt->d_sense; ++ dev->has_own_order_mgmt = opt->has_own_order_mgmt; ++ if (dev->sdev != NULL) { ++ dev->sdev->tst = opt->tst; ++ dev->sdev->queue_alg = opt->queue_alg; ++ dev->sdev->swp = opt->swp; ++ dev->sdev->tas = opt->tas; ++ dev->sdev->d_sense = opt->d_sense; ++ dev->sdev->has_own_order_mgmt = opt->has_own_order_mgmt; ++ } ++ ++ dev_user_setup_functions(dev); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int dev_user_set_opt(struct file *file, const struct scst_user_opt *opt) ++{ ++ int res; ++ struct scst_user_dev *dev; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&dev_priv_mutex); ++ dev = file->private_data; ++ res = dev_user_check_reg(dev); ++ if (res != 0) { ++ mutex_unlock(&dev_priv_mutex); ++ goto out; ++ } ++ down_read(&dev->dev_rwsem); ++ mutex_unlock(&dev_priv_mutex); ++ ++ res = scst_suspend_activity(true); ++ if (res != 0) ++ goto out_up; ++ ++ res = __dev_user_set_opt(dev, opt); ++ ++ scst_resume_activity(); ++ ++out_up: ++ up_read(&dev->dev_rwsem); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int dev_user_get_opt(struct file *file, void __user *arg) ++{ ++ int res, rc; ++ struct scst_user_dev *dev; ++ struct scst_user_opt opt; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&dev_priv_mutex); ++ dev = file->private_data; ++ res = dev_user_check_reg(dev); ++ if (res != 0) { ++ mutex_unlock(&dev_priv_mutex); ++ goto out; ++ } ++ down_read(&dev->dev_rwsem); ++ mutex_unlock(&dev_priv_mutex); ++ ++ opt.parse_type = dev->parse_type; ++ opt.on_free_cmd_type = dev->on_free_cmd_type; ++ opt.memory_reuse_type = dev->memory_reuse_type; ++ opt.partial_transfers_type = dev->partial_transfers_type; ++ opt.partial_len = dev->partial_len; ++ opt.tst = dev->tst; ++ opt.queue_alg = dev->queue_alg; ++ opt.tas = dev->tas; ++ opt.swp = dev->swp; ++ opt.d_sense = dev->d_sense; ++ opt.has_own_order_mgmt = dev->has_own_order_mgmt; ++ ++ TRACE_DBG("dev %s, parse_type %x, on_free_cmd_type %x, " ++ "memory_reuse_type %x, partial_transfers_type %x, " ++ "partial_len %d", dev->name, opt.parse_type, ++ opt.on_free_cmd_type, opt.memory_reuse_type, ++ opt.partial_transfers_type, opt.partial_len); ++ ++ rc = copy_to_user(arg, &opt, sizeof(opt)); ++ if (unlikely(rc != 0)) { ++ PRINT_ERROR("Failed to copy to user %d bytes", rc); ++ res = -EFAULT; ++ goto out_up; ++ } ++ ++out_up: ++ up_read(&dev->dev_rwsem); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int dev_usr_parse(struct scst_cmd *cmd) ++{ ++ BUG(); ++ return SCST_CMD_STATE_DEFAULT; ++} ++ ++static int dev_user_exit_dev(struct scst_user_dev *dev) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE(TRACE_MGMT, "Releasing dev %s", dev->name); ++ ++ spin_lock(&dev_list_lock); ++ list_del(&dev->dev_list_entry); ++ spin_unlock(&dev_list_lock); ++ ++ dev->blocking = 0; ++ wake_up_all(&dev->udev_cmd_threads.cmd_list_waitQ); ++ ++ spin_lock(&cleanup_lock); ++ list_add_tail(&dev->cleanup_list_entry, &cleanup_list); ++ spin_unlock(&cleanup_lock); ++ ++ wake_up(&cleanup_list_waitQ); ++ ++ scst_unregister_virtual_device(dev->virt_id); ++ scst_unregister_virtual_dev_driver(&dev->devtype); ++ ++ sgv_pool_flush(dev->pool_clust); ++ sgv_pool_flush(dev->pool); ++ ++ TRACE_MGMT_DBG("Unregistering finished (dev %p)", dev); ++ ++ dev->cleanup_done = 1; ++ ++ wake_up(&cleanup_list_waitQ); ++ wake_up(&dev->udev_cmd_threads.cmd_list_waitQ); ++ ++ wait_for_completion(&dev->cleanup_cmpl); ++ ++ sgv_pool_del(dev->pool_clust); ++ sgv_pool_del(dev->pool); ++ ++ scst_deinit_threads(&dev->udev_cmd_threads); ++ ++ TRACE_MGMT_DBG("Releasing completed (dev %p)", dev); ++ ++ module_put(THIS_MODULE); ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++static int __dev_user_release(void *arg) ++{ ++ struct scst_user_dev *dev = arg; ++ dev_user_exit_dev(dev); ++ kfree(dev); ++ return 0; ++} ++ ++static int dev_user_release(struct inode *inode, struct file *file) ++{ ++ struct scst_user_dev *dev; ++ struct task_struct *t; ++ ++ TRACE_ENTRY(); ++ ++ dev = file->private_data; ++ if (dev == NULL) ++ goto out; ++ file->private_data = NULL; ++ ++ TRACE_MGMT_DBG("Going to release dev %s", dev->name); ++ ++ t = kthread_run(__dev_user_release, dev, "scst_usr_released"); ++ if (IS_ERR(t)) { ++ PRINT_CRIT_ERROR("kthread_run() failed (%ld), releasing device " ++ "%p directly. If you have several devices under load " ++ "it might deadlock!", PTR_ERR(t), dev); ++ __dev_user_release(dev); ++ } ++ ++out: ++ TRACE_EXIT(); ++ return 0; ++} ++ ++static int dev_user_process_cleanup(struct scst_user_dev *dev) ++{ ++ struct scst_user_cmd *ucmd; ++ int rc = 0, res = 1; ++ ++ TRACE_ENTRY(); ++ ++ BUG_ON(dev->blocking); ++ wake_up_all(&dev->udev_cmd_threads.cmd_list_waitQ); /* just in case */ ++ ++ while (1) { ++ int rc1; ++ ++ TRACE_DBG("Cleanuping dev %p", dev); ++ ++ rc1 = dev_user_unjam_dev(dev); ++ if ((rc1 == 0) && (rc == -EAGAIN) && dev->cleanup_done) ++ break; ++ ++ spin_lock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ++ rc = dev_user_get_next_cmd(dev, &ucmd); ++ if (rc == 0) ++ dev_user_unjam_cmd(ucmd, 1, NULL); ++ ++ spin_unlock_irq(&dev->udev_cmd_threads.cmd_list_lock); ++ ++ if (rc == -EAGAIN) { ++ if (!dev->cleanup_done) { ++ TRACE_DBG("No more commands (dev %p)", dev); ++ goto out; ++ } ++ } ++ } ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++{ ++ int i; ++ for (i = 0; i < (int)ARRAY_SIZE(dev->ucmd_hash); i++) { ++ struct list_head *head = &dev->ucmd_hash[i]; ++ struct scst_user_cmd *ucmd2; ++again: ++ list_for_each_entry(ucmd2, head, hash_list_entry) { ++ PRINT_ERROR("Lost ucmd %p (state %x, ref %d)", ucmd2, ++ ucmd2->state, atomic_read(&ucmd2->ucmd_ref)); ++ ucmd_put(ucmd2); ++ goto again; ++ } ++ } ++} ++#endif ++ ++ TRACE_DBG("Cleanuping done (dev %p)", dev); ++ complete_all(&dev->cleanup_cmpl); ++ res = 0; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t dev_user_sysfs_commands_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos = 0, ppos, i; ++ struct scst_device *dev; ++ struct scst_user_dev *udev; ++ unsigned long flags; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ udev = dev->dh_priv; ++ ++ spin_lock_irqsave(&udev->udev_cmd_threads.cmd_list_lock, flags); ++ for (i = 0; i < (int)ARRAY_SIZE(udev->ucmd_hash); i++) { ++ struct list_head *head = &udev->ucmd_hash[i]; ++ struct scst_user_cmd *ucmd; ++ list_for_each_entry(ucmd, head, hash_list_entry) { ++ ppos = pos; ++ pos += scnprintf(&buf[pos], ++ SCST_SYSFS_BLOCK_SIZE - pos, ++ "ucmd %p (state %x, ref %d), " ++ "sent_to_user %d, seen_by_user %d, " ++ "aborted %d, jammed %d, scst_cmd %p\n", ++ ucmd, ucmd->state, ++ atomic_read(&ucmd->ucmd_ref), ++ ucmd->sent_to_user, ucmd->seen_by_user, ++ ucmd->aborted, ucmd->jammed, ucmd->cmd); ++ if (pos >= SCST_SYSFS_BLOCK_SIZE-1) { ++ ppos += scnprintf(&buf[ppos], ++ SCST_SYSFS_BLOCK_SIZE - ppos, "...\n"); ++ pos = ppos; ++ break; ++ } ++ } ++ } ++ spin_unlock_irqrestore(&udev->udev_cmd_threads.cmd_list_lock, flags); ++ ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static inline int test_cleanup_list(void) ++{ ++ int res = !list_empty(&cleanup_list) || ++ unlikely(kthread_should_stop()); ++ return res; ++} ++ ++static int dev_user_cleanup_thread(void *arg) ++{ ++ TRACE_ENTRY(); ++ ++ PRINT_INFO("Cleanup thread started, PID %d", current->pid); ++ ++ current->flags |= PF_NOFREEZE; ++ ++ spin_lock(&cleanup_lock); ++ while (!kthread_should_stop()) { ++ wait_queue_t wait; ++ init_waitqueue_entry(&wait, current); ++ ++ if (!test_cleanup_list()) { ++ add_wait_queue_exclusive(&cleanup_list_waitQ, &wait); ++ for (;;) { ++ set_current_state(TASK_INTERRUPTIBLE); ++ if (test_cleanup_list()) ++ break; ++ spin_unlock(&cleanup_lock); ++ schedule(); ++ spin_lock(&cleanup_lock); ++ } ++ set_current_state(TASK_RUNNING); ++ remove_wait_queue(&cleanup_list_waitQ, &wait); ++ } ++ ++ /* ++ * We have to poll devices, because commands can go from SCST ++ * core on cmd_list_waitQ and we have no practical way to ++ * detect them. ++ */ ++ ++ while (1) { ++ struct scst_user_dev *dev; ++ LIST_HEAD(cl_devs); ++ ++ while (!list_empty(&cleanup_list)) { ++ int rc; ++ ++ dev = list_entry(cleanup_list.next, ++ typeof(*dev), cleanup_list_entry); ++ list_del(&dev->cleanup_list_entry); ++ ++ spin_unlock(&cleanup_lock); ++ rc = dev_user_process_cleanup(dev); ++ spin_lock(&cleanup_lock); ++ ++ if (rc != 0) ++ list_add_tail(&dev->cleanup_list_entry, ++ &cl_devs); ++ } ++ ++ if (list_empty(&cl_devs)) ++ break; ++ ++ spin_unlock(&cleanup_lock); ++ msleep(100); ++ spin_lock(&cleanup_lock); ++ ++ while (!list_empty(&cl_devs)) { ++ dev = list_entry(cl_devs.next, typeof(*dev), ++ cleanup_list_entry); ++ list_move_tail(&dev->cleanup_list_entry, ++ &cleanup_list); ++ } ++ } ++ } ++ spin_unlock(&cleanup_lock); ++ ++ /* ++ * If kthread_should_stop() is true, we are guaranteed to be ++ * on the module unload, so cleanup_list must be empty. ++ */ ++ BUG_ON(!list_empty(&cleanup_list)); ++ ++ PRINT_INFO("Cleanup thread PID %d finished", current->pid); ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++static int __init init_scst_user(void) ++{ ++ int res = 0; ++ struct max_get_reply { ++ union { ++ struct scst_user_get_cmd g; ++ struct scst_user_reply_cmd r; ++ }; ++ }; ++ struct device *dev; ++ ++ TRACE_ENTRY(); ++ ++ user_cmd_cachep = KMEM_CACHE(scst_user_cmd, SCST_SLAB_FLAGS); ++ if (user_cmd_cachep == NULL) { ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ user_get_cmd_cachep = KMEM_CACHE(max_get_reply, SCST_SLAB_FLAGS); ++ if (user_get_cmd_cachep == NULL) { ++ res = -ENOMEM; ++ goto out_cache; ++ } ++ ++ dev_user_devtype.module = THIS_MODULE; ++ ++ res = scst_register_virtual_dev_driver(&dev_user_devtype); ++ if (res < 0) ++ goto out_cache1; ++ ++ dev_user_sysfs_class = class_create(THIS_MODULE, DEV_USER_NAME); ++ if (IS_ERR(dev_user_sysfs_class)) { ++ PRINT_ERROR("%s", "Unable create sysfs class for SCST user " ++ "space handler"); ++ res = PTR_ERR(dev_user_sysfs_class); ++ goto out_unreg; ++ } ++ ++ dev_user_major = register_chrdev(0, DEV_USER_NAME, &dev_user_fops); ++ if (dev_user_major < 0) { ++ PRINT_ERROR("register_chrdev() failed: %d", res); ++ res = dev_user_major; ++ goto out_class; ++ } ++ ++ dev = device_create(dev_user_sysfs_class, NULL, ++ MKDEV(dev_user_major, 0), ++ NULL, ++ DEV_USER_NAME); ++ if (IS_ERR(dev)) { ++ res = PTR_ERR(dev); ++ goto out_chrdev; ++ } ++ ++ cleanup_thread = kthread_run(dev_user_cleanup_thread, NULL, ++ "scst_usr_cleanupd"); ++ if (IS_ERR(cleanup_thread)) { ++ res = PTR_ERR(cleanup_thread); ++ PRINT_ERROR("kthread_create() failed: %d", res); ++ goto out_dev; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_dev: ++ device_destroy(dev_user_sysfs_class, MKDEV(dev_user_major, 0)); ++ ++out_chrdev: ++ unregister_chrdev(dev_user_major, DEV_USER_NAME); ++ ++out_class: ++ class_destroy(dev_user_sysfs_class); ++ ++out_unreg: ++ scst_unregister_dev_driver(&dev_user_devtype); ++ ++out_cache1: ++ kmem_cache_destroy(user_get_cmd_cachep); ++ ++out_cache: ++ kmem_cache_destroy(user_cmd_cachep); ++ goto out; ++} ++ ++static void __exit exit_scst_user(void) ++{ ++ int rc; ++ ++ TRACE_ENTRY(); ++ ++ rc = kthread_stop(cleanup_thread); ++ if (rc < 0) ++ TRACE_MGMT_DBG("kthread_stop() failed: %d", rc); ++ ++ unregister_chrdev(dev_user_major, DEV_USER_NAME); ++ device_destroy(dev_user_sysfs_class, MKDEV(dev_user_major, 0)); ++ class_destroy(dev_user_sysfs_class); ++ ++ scst_unregister_virtual_dev_driver(&dev_user_devtype); ++ ++ kmem_cache_destroy(user_get_cmd_cachep); ++ kmem_cache_destroy(user_cmd_cachep); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++module_init(init_scst_user); ++module_exit(exit_scst_user); ++ ++MODULE_AUTHOR("Vladislav Bolkhovitin"); ++MODULE_LICENSE("GPL"); ++MODULE_DESCRIPTION("User space device handler for SCST"); ++MODULE_VERSION(SCST_VERSION_STRING); +diff -uprN orig/linux-3.2/drivers/scst/dev_handlers/scst_vdisk.c linux-3.2/drivers/scst/dev_handlers/scst_vdisk.c +--- orig/linux-3.2/drivers/scst/dev_handlers/scst_vdisk.c ++++ linux-3.2/drivers/scst/dev_handlers/scst_vdisk.c +@@ -0,0 +1,4529 @@ ++/* ++ * scst_vdisk.c ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2007 Ming Zhang <blackmagic02881 at gmail dot com> ++ * Copyright (C) 2007 Ross Walker <rswwalker at hotmail dot com> ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * SCSI disk (type 0) and CDROM (type 5) dev handler using files ++ * on file systems or block devices (VDISK) ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/file.h> ++#include <linux/fs.h> ++#include <linux/string.h> ++#include <linux/types.h> ++#include <linux/unistd.h> ++#include <linux/spinlock.h> ++#include <linux/init.h> ++#include <linux/uio.h> ++#include <linux/list.h> ++#include <linux/ctype.h> ++#include <linux/writeback.h> ++#include <linux/vmalloc.h> ++#include <asm/atomic.h> ++#include <linux/kthread.h> ++#include <linux/sched.h> ++#include <linux/delay.h> ++#include <asm/div64.h> ++#include <asm/unaligned.h> ++#include <linux/slab.h> ++#include <linux/bio.h> ++#include <linux/crc32c.h> ++ ++#define LOG_PREFIX "dev_vdisk" ++ ++#include <scst/scst.h> ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ ++#define TRACE_ORDER 0x80000000 ++ ++static struct scst_trace_log vdisk_local_trace_tbl[] = { ++ { TRACE_ORDER, "order" }, ++ { 0, NULL } ++}; ++#define trace_log_tbl vdisk_local_trace_tbl ++ ++#define VDISK_TRACE_TBL_HELP ", order" ++ ++#endif ++ ++#include "scst_dev_handler.h" ++ ++/* 8 byte ASCII Vendor */ ++#define SCST_FIO_VENDOR "SCST_FIO" ++#define SCST_BIO_VENDOR "SCST_BIO" ++/* 4 byte ASCII Product Revision Level - left aligned */ ++#define SCST_FIO_REV " 220" ++ ++#define MAX_USN_LEN (20+1) /* For '\0' */ ++ ++#define INQ_BUF_SZ 256 ++#define EVPD 0x01 ++#define CMDDT 0x02 ++ ++#define MSENSE_BUF_SZ 256 ++#define DBD 0x08 /* disable block descriptor */ ++#define WP 0x80 /* write protect */ ++#define DPOFUA 0x10 /* DPOFUA bit */ ++#define WCE 0x04 /* write cache enable */ ++ ++#define PF 0x10 /* page format */ ++#define SP 0x01 /* save pages */ ++#define PS 0x80 /* parameter saveable */ ++ ++#define BYTE 8 ++#define DEF_DISK_BLOCKSIZE_SHIFT 9 ++#define DEF_DISK_BLOCKSIZE (1 << DEF_DISK_BLOCKSIZE_SHIFT) ++#define DEF_CDROM_BLOCKSIZE_SHIFT 11 ++#define DEF_CDROM_BLOCKSIZE (1 << DEF_CDROM_BLOCKSIZE_SHIFT) ++#define DEF_SECTORS 56 ++#define DEF_HEADS 255 ++#define LEN_MEM (32 * 1024) ++#define DEF_RD_ONLY 0 ++#define DEF_WRITE_THROUGH 0 ++#define DEF_NV_CACHE 0 ++#define DEF_O_DIRECT 0 ++#define DEF_REMOVABLE 0 ++#define DEF_THIN_PROVISIONED 0 ++ ++#define VDISK_NULLIO_SIZE (3LL*1024*1024*1024*1024/2) ++ ++#define DEF_TST SCST_CONTR_MODE_SEP_TASK_SETS ++ ++/* ++ * Since we can't control backstorage device's reordering, we have to always ++ * report unrestricted reordering. ++ */ ++#define DEF_QUEUE_ALG_WT SCST_CONTR_MODE_QUEUE_ALG_UNRESTRICTED_REORDER ++#define DEF_QUEUE_ALG SCST_CONTR_MODE_QUEUE_ALG_UNRESTRICTED_REORDER ++#define DEF_SWP 0 ++#define DEF_TAS 0 ++ ++#define DEF_DSENSE SCST_CONTR_MODE_FIXED_SENSE ++ ++struct scst_vdisk_dev { ++ uint32_t block_size; ++ uint64_t nblocks; ++ int block_shift; ++ loff_t file_size; /* in bytes */ ++ ++ /* ++ * This lock can be taken on both SIRQ and thread context, but in ++ * all cases for each particular instance it's taken consistenly either ++ * on SIRQ or thread context. Mix of them is forbidden. ++ */ ++ spinlock_t flags_lock; ++ ++ /* ++ * Below flags are protected by flags_lock or suspended activity ++ * with scst_vdisk_mutex. ++ */ ++ unsigned int rd_only:1; ++ unsigned int wt_flag:1; ++ unsigned int nv_cache:1; ++ unsigned int o_direct_flag:1; ++ unsigned int media_changed:1; ++ unsigned int prevent_allow_medium_removal:1; ++ unsigned int nullio:1; ++ unsigned int blockio:1; ++ unsigned int cdrom_empty:1; ++ unsigned int removable:1; ++ unsigned int thin_provisioned:1; ++ ++ int virt_id; ++ char name[16+1]; /* Name of the virtual device, ++ must be <= SCSI Model + 1 */ ++ char *filename; /* File name, protected by ++ scst_mutex and suspended activities */ ++ uint16_t command_set_version; ++ ++ /* All 4 protected by vdisk_serial_rwlock */ ++ unsigned int t10_dev_id_set:1; /* true if t10_dev_id manually set */ ++ unsigned int usn_set:1; /* true if usn manually set */ ++ char t10_dev_id[16+8+2]; /* T10 device ID */ ++ char usn[MAX_USN_LEN]; ++ ++ struct scst_device *dev; ++ struct list_head vdev_list_entry; ++ ++ struct scst_dev_type *vdev_devt; ++}; ++ ++struct scst_vdisk_thr { ++ struct scst_thr_data_hdr hdr; ++ struct file *fd; ++ struct block_device *bdev; ++ struct iovec *iv; ++ int iv_count; ++}; ++ ++/* Context RA patch supposed to be applied on the kernel */ ++#define DEF_NUM_THREADS 8 ++static int num_threads = DEF_NUM_THREADS; ++ ++module_param_named(num_threads, num_threads, int, S_IRUGO); ++MODULE_PARM_DESC(num_threads, "vdisk threads count"); ++ ++static int vdisk_attach(struct scst_device *dev); ++static void vdisk_detach(struct scst_device *dev); ++static int vdisk_attach_tgt(struct scst_tgt_dev *tgt_dev); ++static void vdisk_detach_tgt(struct scst_tgt_dev *tgt_dev); ++static int vdisk_parse(struct scst_cmd *); ++static int vdisk_do_job(struct scst_cmd *cmd); ++static int vcdrom_parse(struct scst_cmd *); ++static int vcdrom_exec(struct scst_cmd *cmd); ++static void vdisk_exec_read(struct scst_cmd *cmd, ++ struct scst_vdisk_thr *thr, loff_t loff); ++static void vdisk_exec_write(struct scst_cmd *cmd, ++ struct scst_vdisk_thr *thr, loff_t loff); ++static void blockio_exec_rw(struct scst_cmd *cmd, struct scst_vdisk_thr *thr, ++ u64 lba_start, int write); ++static int vdisk_blockio_flush(struct block_device *bdev, gfp_t gfp_mask, ++ bool report_error); ++static void vdisk_exec_verify(struct scst_cmd *cmd, ++ struct scst_vdisk_thr *thr, loff_t loff); ++static void vdisk_exec_read_capacity(struct scst_cmd *cmd); ++static void vdisk_exec_read_capacity16(struct scst_cmd *cmd); ++static void vdisk_exec_report_tpgs(struct scst_cmd *cmd); ++static void vdisk_exec_inquiry(struct scst_cmd *cmd); ++static void vdisk_exec_request_sense(struct scst_cmd *cmd); ++static void vdisk_exec_mode_sense(struct scst_cmd *cmd); ++static void vdisk_exec_mode_select(struct scst_cmd *cmd); ++static void vdisk_exec_log(struct scst_cmd *cmd); ++static void vdisk_exec_read_toc(struct scst_cmd *cmd); ++static void vdisk_exec_prevent_allow_medium_removal(struct scst_cmd *cmd); ++static void vdisk_exec_unmap(struct scst_cmd *cmd, struct scst_vdisk_thr *thr); ++static int vdisk_fsync(struct scst_vdisk_thr *thr, loff_t loff, ++ loff_t len, struct scst_cmd *cmd, struct scst_device *dev); ++static ssize_t vdisk_add_fileio_device(const char *device_name, char *params); ++static ssize_t vdisk_add_blockio_device(const char *device_name, char *params); ++static ssize_t vdisk_add_nullio_device(const char *device_name, char *params); ++static ssize_t vdisk_del_device(const char *device_name); ++static ssize_t vcdrom_add_device(const char *device_name, char *params); ++static ssize_t vcdrom_del_device(const char *device_name); ++static int vdisk_task_mgmt_fn(struct scst_mgmt_cmd *mcmd, ++ struct scst_tgt_dev *tgt_dev); ++static uint64_t vdisk_gen_dev_id_num(const char *virt_dev_name); ++ ++/** SYSFS **/ ++ ++static ssize_t vdev_sysfs_size_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf); ++static ssize_t vdisk_sysfs_blocksize_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf); ++static ssize_t vdisk_sysfs_rd_only_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf); ++static ssize_t vdisk_sysfs_wt_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf); ++static ssize_t vdisk_sysfs_tp_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf); ++static ssize_t vdisk_sysfs_nv_cache_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf); ++static ssize_t vdisk_sysfs_o_direct_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf); ++static ssize_t vdisk_sysfs_removable_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf); ++static ssize_t vdev_sysfs_filename_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf); ++static ssize_t vdisk_sysfs_resync_size_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count); ++static ssize_t vdev_sysfs_t10_dev_id_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count); ++static ssize_t vdev_sysfs_t10_dev_id_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf); ++static ssize_t vdev_sysfs_usn_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count); ++static ssize_t vdev_sysfs_usn_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf); ++ ++static ssize_t vcdrom_sysfs_filename_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count); ++ ++static struct kobj_attribute vdev_size_attr = ++ __ATTR(size_mb, S_IRUGO, vdev_sysfs_size_show, NULL); ++static struct kobj_attribute vdisk_blocksize_attr = ++ __ATTR(blocksize, S_IRUGO, vdisk_sysfs_blocksize_show, NULL); ++static struct kobj_attribute vdisk_rd_only_attr = ++ __ATTR(read_only, S_IRUGO, vdisk_sysfs_rd_only_show, NULL); ++static struct kobj_attribute vdisk_wt_attr = ++ __ATTR(write_through, S_IRUGO, vdisk_sysfs_wt_show, NULL); ++static struct kobj_attribute vdisk_tp_attr = ++ __ATTR(thin_provisioned, S_IRUGO, vdisk_sysfs_tp_show, NULL); ++static struct kobj_attribute vdisk_nv_cache_attr = ++ __ATTR(nv_cache, S_IRUGO, vdisk_sysfs_nv_cache_show, NULL); ++static struct kobj_attribute vdisk_o_direct_attr = ++ __ATTR(o_direct, S_IRUGO, vdisk_sysfs_o_direct_show, NULL); ++static struct kobj_attribute vdisk_removable_attr = ++ __ATTR(removable, S_IRUGO, vdisk_sysfs_removable_show, NULL); ++static struct kobj_attribute vdisk_filename_attr = ++ __ATTR(filename, S_IRUGO, vdev_sysfs_filename_show, NULL); ++static struct kobj_attribute vdisk_resync_size_attr = ++ __ATTR(resync_size, S_IWUSR, NULL, vdisk_sysfs_resync_size_store); ++static struct kobj_attribute vdev_t10_dev_id_attr = ++ __ATTR(t10_dev_id, S_IWUSR|S_IRUGO, vdev_sysfs_t10_dev_id_show, ++ vdev_sysfs_t10_dev_id_store); ++static struct kobj_attribute vdev_usn_attr = ++ __ATTR(usn, S_IWUSR|S_IRUGO, vdev_sysfs_usn_show, vdev_sysfs_usn_store); ++ ++static struct kobj_attribute vcdrom_filename_attr = ++ __ATTR(filename, S_IRUGO|S_IWUSR, vdev_sysfs_filename_show, ++ vcdrom_sysfs_filename_store); ++ ++static const struct attribute *vdisk_fileio_attrs[] = { ++ &vdev_size_attr.attr, ++ &vdisk_blocksize_attr.attr, ++ &vdisk_rd_only_attr.attr, ++ &vdisk_wt_attr.attr, ++ &vdisk_tp_attr.attr, ++ &vdisk_nv_cache_attr.attr, ++ &vdisk_o_direct_attr.attr, ++ &vdisk_removable_attr.attr, ++ &vdisk_filename_attr.attr, ++ &vdisk_resync_size_attr.attr, ++ &vdev_t10_dev_id_attr.attr, ++ &vdev_usn_attr.attr, ++ NULL, ++}; ++ ++static const struct attribute *vdisk_blockio_attrs[] = { ++ &vdev_size_attr.attr, ++ &vdisk_blocksize_attr.attr, ++ &vdisk_rd_only_attr.attr, ++ &vdisk_nv_cache_attr.attr, ++ &vdisk_removable_attr.attr, ++ &vdisk_filename_attr.attr, ++ &vdisk_resync_size_attr.attr, ++ &vdev_t10_dev_id_attr.attr, ++ &vdev_usn_attr.attr, ++ &vdisk_tp_attr.attr, ++ NULL, ++}; ++ ++static const struct attribute *vdisk_nullio_attrs[] = { ++ &vdev_size_attr.attr, ++ &vdisk_blocksize_attr.attr, ++ &vdisk_rd_only_attr.attr, ++ &vdisk_removable_attr.attr, ++ &vdev_t10_dev_id_attr.attr, ++ &vdev_usn_attr.attr, ++ NULL, ++}; ++ ++static const struct attribute *vcdrom_attrs[] = { ++ &vdev_size_attr.attr, ++ &vcdrom_filename_attr.attr, ++ &vdev_t10_dev_id_attr.attr, ++ &vdev_usn_attr.attr, ++ NULL, ++}; ++ ++/* Protects vdisks addition/deletion and related activities, like search */ ++static DEFINE_MUTEX(scst_vdisk_mutex); ++ ++/* Protects devices t10_dev_id and usn */ ++static DEFINE_RWLOCK(vdisk_serial_rwlock); ++ ++/* Protected by scst_vdisk_mutex */ ++static LIST_HEAD(vdev_list); ++ ++static struct kmem_cache *vdisk_thr_cachep; ++ ++/* ++ * Be careful changing "name" field, since it is the name of the corresponding ++ * /sys/kernel/scst_tgt entry, hence a part of user space ABI. ++ */ ++ ++static struct scst_dev_type vdisk_file_devtype = { ++ .name = "vdisk_fileio", ++ .type = TYPE_DISK, ++ .exec_sync = 1, ++ .threads_num = -1, ++ .parse_atomic = 1, ++ .dev_done_atomic = 1, ++ .attach = vdisk_attach, ++ .detach = vdisk_detach, ++ .attach_tgt = vdisk_attach_tgt, ++ .detach_tgt = vdisk_detach_tgt, ++ .parse = vdisk_parse, ++ .exec = vdisk_do_job, ++ .task_mgmt_fn = vdisk_task_mgmt_fn, ++ .add_device = vdisk_add_fileio_device, ++ .del_device = vdisk_del_device, ++ .dev_attrs = vdisk_fileio_attrs, ++ .add_device_parameters = "filename, blocksize, write_through, " ++ "nv_cache, o_direct, read_only, removable, thin_provisioned", ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ .default_trace_flags = SCST_DEFAULT_DEV_LOG_FLAGS, ++ .trace_flags = &trace_flag, ++ .trace_tbl = vdisk_local_trace_tbl, ++ .trace_tbl_help = VDISK_TRACE_TBL_HELP, ++#endif ++}; ++ ++static struct kmem_cache *blockio_work_cachep; ++ ++static struct scst_dev_type vdisk_blk_devtype = { ++ .name = "vdisk_blockio", ++ .type = TYPE_DISK, ++ .threads_num = 1, ++ .parse_atomic = 1, ++ .dev_done_atomic = 1, ++ .attach = vdisk_attach, ++ .detach = vdisk_detach, ++ .attach_tgt = vdisk_attach_tgt, ++ .detach_tgt = vdisk_detach_tgt, ++ .parse = vdisk_parse, ++ .exec = vdisk_do_job, ++ .task_mgmt_fn = vdisk_task_mgmt_fn, ++ .add_device = vdisk_add_blockio_device, ++ .del_device = vdisk_del_device, ++ .dev_attrs = vdisk_blockio_attrs, ++ .add_device_parameters = "filename, blocksize, nv_cache, read_only, " ++ "removable, thin_provisioned", ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ .default_trace_flags = SCST_DEFAULT_DEV_LOG_FLAGS, ++ .trace_flags = &trace_flag, ++ .trace_tbl = vdisk_local_trace_tbl, ++ .trace_tbl_help = VDISK_TRACE_TBL_HELP, ++#endif ++}; ++ ++static struct scst_dev_type vdisk_null_devtype = { ++ .name = "vdisk_nullio", ++ .type = TYPE_DISK, ++ .threads_num = 0, ++ .parse_atomic = 1, ++ .dev_done_atomic = 1, ++ .attach = vdisk_attach, ++ .detach = vdisk_detach, ++ .attach_tgt = vdisk_attach_tgt, ++ .detach_tgt = vdisk_detach_tgt, ++ .parse = vdisk_parse, ++ .exec = vdisk_do_job, ++ .task_mgmt_fn = vdisk_task_mgmt_fn, ++ .add_device = vdisk_add_nullio_device, ++ .del_device = vdisk_del_device, ++ .dev_attrs = vdisk_nullio_attrs, ++ .add_device_parameters = "blocksize, read_only, removable", ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ .default_trace_flags = SCST_DEFAULT_DEV_LOG_FLAGS, ++ .trace_flags = &trace_flag, ++ .trace_tbl = vdisk_local_trace_tbl, ++ .trace_tbl_help = VDISK_TRACE_TBL_HELP, ++#endif ++}; ++ ++static struct scst_dev_type vcdrom_devtype = { ++ .name = "vcdrom", ++ .type = TYPE_ROM, ++ .exec_sync = 1, ++ .threads_num = -1, ++ .parse_atomic = 1, ++ .dev_done_atomic = 1, ++ .attach = vdisk_attach, ++ .detach = vdisk_detach, ++ .attach_tgt = vdisk_attach_tgt, ++ .detach_tgt = vdisk_detach_tgt, ++ .parse = vcdrom_parse, ++ .exec = vcdrom_exec, ++ .task_mgmt_fn = vdisk_task_mgmt_fn, ++ .add_device = vcdrom_add_device, ++ .del_device = vcdrom_del_device, ++ .dev_attrs = vcdrom_attrs, ++ .add_device_parameters = NULL, ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ .default_trace_flags = SCST_DEFAULT_DEV_LOG_FLAGS, ++ .trace_flags = &trace_flag, ++ .trace_tbl = vdisk_local_trace_tbl, ++ .trace_tbl_help = VDISK_TRACE_TBL_HELP, ++#endif ++}; ++ ++static struct scst_vdisk_thr nullio_thr_data; ++ ++static const char *vdev_get_filename(const struct scst_vdisk_dev *virt_dev) ++{ ++ if (virt_dev->filename != NULL) ++ return virt_dev->filename; ++ else ++ return "none"; ++} ++ ++/* Returns fd, use IS_ERR(fd) to get error status */ ++static struct file *vdev_open_fd(const struct scst_vdisk_dev *virt_dev) ++{ ++ int open_flags = 0; ++ struct file *fd; ++ ++ TRACE_ENTRY(); ++ ++ if (virt_dev->dev->rd_only) ++ open_flags |= O_RDONLY; ++ else ++ open_flags |= O_RDWR; ++ if (virt_dev->o_direct_flag) ++ open_flags |= O_DIRECT; ++ if (virt_dev->wt_flag && !virt_dev->nv_cache) ++ open_flags |= O_SYNC; ++ TRACE_DBG("Opening file %s, flags 0x%x", ++ virt_dev->filename, open_flags); ++ fd = filp_open(virt_dev->filename, O_LARGEFILE | open_flags, 0600); ++ ++ TRACE_EXIT(); ++ return fd; ++} ++ ++static void vdisk_blockio_check_flush_support(struct scst_vdisk_dev *virt_dev) ++{ ++ struct inode *inode; ++ struct file *fd; ++ ++ TRACE_ENTRY(); ++ ++ if (!virt_dev->blockio || virt_dev->rd_only || virt_dev->nv_cache) ++ goto out; ++ ++ fd = filp_open(virt_dev->filename, O_LARGEFILE, 0600); ++ if (IS_ERR(fd)) { ++ PRINT_ERROR("filp_open(%s) returned error %ld", ++ virt_dev->filename, PTR_ERR(fd)); ++ goto out; ++ } ++ ++ inode = fd->f_dentry->d_inode; ++ ++ if (!S_ISBLK(inode->i_mode)) { ++ PRINT_ERROR("%s is NOT a block device", virt_dev->filename); ++ goto out_close; ++ } ++ ++ if (vdisk_blockio_flush(inode->i_bdev, GFP_KERNEL, false) != 0) { ++ PRINT_WARNING("Device %s doesn't support barriers, switching " ++ "to NV_CACHE mode. Read README for more details.", ++ virt_dev->filename); ++ virt_dev->nv_cache = 1; ++ } ++ ++out_close: ++ filp_close(fd, NULL); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static void vdisk_check_tp_support(struct scst_vdisk_dev *virt_dev) ++{ ++ struct inode *inode; ++ struct file *fd; ++ bool supported = false; ++ ++ TRACE_ENTRY(); ++ ++ if (virt_dev->rd_only || !virt_dev->thin_provisioned) ++ goto out; ++ ++ fd = filp_open(virt_dev->filename, O_LARGEFILE, 0600); ++ if (IS_ERR(fd)) { ++ PRINT_ERROR("filp_open(%s) returned error %ld", ++ virt_dev->filename, PTR_ERR(fd)); ++ goto out; ++ } ++ ++ inode = fd->f_dentry->d_inode; ++ ++ if (virt_dev->blockio) { ++ if (!S_ISBLK(inode->i_mode)) { ++ PRINT_ERROR("%s is NOT a block device", ++ virt_dev->filename); ++ goto out_close; ++ } ++ supported = blk_queue_discard(bdev_get_queue(inode->i_bdev)); ++ ++ } else { ++ /* ++ * truncate_range() was chosen rather as a sample. In future, ++ * when unmap of range of blocks in file become standard, we ++ * will just switch to the new call. ++ */ ++ supported = (inode->i_op->truncate_range != NULL); ++ } ++ ++ if (!supported) { ++ PRINT_WARNING("Device %s doesn't support thin " ++ "provisioning, disabling it.", ++ virt_dev->filename); ++ virt_dev->thin_provisioned = 0; ++ } ++ ++out_close: ++ filp_close(fd, NULL); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Returns 0 on success and file size in *file_size, error code otherwise */ ++static int vdisk_get_file_size(const char *filename, bool blockio, ++ loff_t *file_size) ++{ ++ struct inode *inode; ++ int res = 0; ++ struct file *fd; ++ ++ TRACE_ENTRY(); ++ ++ *file_size = 0; ++ ++ fd = filp_open(filename, O_LARGEFILE | O_RDONLY, 0600); ++ if (IS_ERR(fd)) { ++ res = PTR_ERR(fd); ++ PRINT_ERROR("filp_open(%s) returned error %d", filename, res); ++ goto out; ++ } ++ ++ inode = fd->f_dentry->d_inode; ++ ++ if (blockio && !S_ISBLK(inode->i_mode)) { ++ PRINT_ERROR("File %s is NOT a block device", filename); ++ res = -EINVAL; ++ goto out_close; ++ } ++ ++ if (S_ISREG(inode->i_mode)) ++ /* Nothing to do */; ++ else if (S_ISBLK(inode->i_mode)) ++ inode = inode->i_bdev->bd_inode; ++ else { ++ res = -EINVAL; ++ goto out_close; ++ } ++ ++ *file_size = inode->i_size; ++ ++out_close: ++ filp_close(fd, NULL); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* scst_vdisk_mutex supposed to be held */ ++static struct scst_vdisk_dev *vdev_find(const char *name) ++{ ++ struct scst_vdisk_dev *res, *vv; ++ ++ TRACE_ENTRY(); ++ ++ res = NULL; ++ list_for_each_entry(vv, &vdev_list, vdev_list_entry) { ++ if (strcmp(vv->name, name) == 0) { ++ res = vv; ++ break; ++ } ++ } ++ ++ TRACE_EXIT_HRES((unsigned long)res); ++ return res; ++} ++ ++static int vdisk_attach(struct scst_device *dev) ++{ ++ int res = 0; ++ loff_t err; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("virt_id %d (%s)", dev->virt_id, dev->virt_name); ++ ++ if (dev->virt_id == 0) { ++ PRINT_ERROR("%s", "Not a virtual device"); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ /* ++ * scst_vdisk_mutex must be already taken before ++ * scst_register_virtual_device() ++ */ ++ virt_dev = vdev_find(dev->virt_name); ++ if (virt_dev == NULL) { ++ PRINT_ERROR("Device %s not found", dev->virt_name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ virt_dev->dev = dev; ++ ++ dev->rd_only = virt_dev->rd_only; ++ ++ if (!virt_dev->cdrom_empty) { ++ if (virt_dev->nullio) ++ err = VDISK_NULLIO_SIZE; ++ else { ++ res = vdisk_get_file_size(virt_dev->filename, ++ virt_dev->blockio, &err); ++ if (res != 0) ++ goto out; ++ } ++ virt_dev->file_size = err; ++ ++ TRACE_DBG("size of file: %lld", (long long unsigned int)err); ++ ++ vdisk_blockio_check_flush_support(virt_dev); ++ vdisk_check_tp_support(virt_dev); ++ } else ++ virt_dev->file_size = 0; ++ ++ virt_dev->nblocks = virt_dev->file_size >> virt_dev->block_shift; ++ ++ if (!virt_dev->cdrom_empty) { ++ PRINT_INFO("Attached SCSI target virtual %s %s " ++ "(file=\"%s\", fs=%lldMB, bs=%d, nblocks=%lld," ++ " cyln=%lld%s)", ++ (dev->type == TYPE_DISK) ? "disk" : "cdrom", ++ virt_dev->name, vdev_get_filename(virt_dev), ++ virt_dev->file_size >> 20, virt_dev->block_size, ++ (long long unsigned int)virt_dev->nblocks, ++ (long long unsigned int)virt_dev->nblocks/64/32, ++ virt_dev->nblocks < 64*32 ++ ? " !WARNING! cyln less than 1" : ""); ++ } else { ++ PRINT_INFO("Attached empty SCSI target virtual cdrom %s", ++ virt_dev->name); ++ } ++ ++ dev->dh_priv = virt_dev; ++ ++ dev->tst = DEF_TST; ++ dev->d_sense = DEF_DSENSE; ++ if (virt_dev->wt_flag && !virt_dev->nv_cache) ++ dev->queue_alg = DEF_QUEUE_ALG_WT; ++ else ++ dev->queue_alg = DEF_QUEUE_ALG; ++ dev->swp = DEF_SWP; ++ dev->tas = DEF_TAS; ++ ++out: ++ TRACE_EXIT(); ++ return res; ++} ++ ++/* scst_mutex supposed to be held */ ++static void vdisk_detach(struct scst_device *dev) ++{ ++ struct scst_vdisk_dev *virt_dev = dev->dh_priv; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("virt_id %d", dev->virt_id); ++ ++ PRINT_INFO("Detached virtual device %s (\"%s\")", ++ virt_dev->name, vdev_get_filename(virt_dev)); ++ ++ /* virt_dev will be freed by the caller */ ++ dev->dh_priv = NULL; ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void vdisk_free_thr_data(struct scst_thr_data_hdr *d) ++{ ++ struct scst_vdisk_thr *thr = ++ container_of(d, struct scst_vdisk_thr, hdr); ++ ++ TRACE_ENTRY(); ++ ++ if (thr->fd) ++ filp_close(thr->fd, NULL); ++ ++ kfree(thr->iv); ++ ++ kmem_cache_free(vdisk_thr_cachep, thr); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static struct scst_vdisk_thr *vdisk_init_thr_data( ++ struct scst_tgt_dev *tgt_dev, gfp_t gfp_mask) ++{ ++ struct scst_vdisk_thr *res; ++ struct scst_vdisk_dev *virt_dev = tgt_dev->dev->dh_priv; ++ ++ TRACE_ENTRY(); ++ ++ EXTRACHECKS_BUG_ON(virt_dev->nullio); ++ ++ res = kmem_cache_zalloc(vdisk_thr_cachep, gfp_mask); ++ if (res == NULL) { ++ PRINT_ERROR("Unable to allocate struct scst_vdisk_thr" ++ " (size %zd)", sizeof(*res)); ++ goto out; ++ } ++ ++ if (!virt_dev->cdrom_empty) { ++ res->fd = vdev_open_fd(virt_dev); ++ if (IS_ERR(res->fd)) { ++ PRINT_ERROR("filp_open(%s) returned an error %ld", ++ virt_dev->filename, PTR_ERR(res->fd)); ++ goto out_free; ++ } ++ if (virt_dev->blockio) ++ res->bdev = res->fd->f_dentry->d_inode->i_bdev; ++ else ++ res->bdev = NULL; ++ } else ++ res->fd = NULL; ++ ++ scst_add_thr_data(tgt_dev, &res->hdr, vdisk_free_thr_data); ++ ++out: ++ TRACE_EXIT_HRES((unsigned long)res); ++ return res; ++ ++out_free: ++ kmem_cache_free(vdisk_thr_cachep, res); ++ res = NULL; ++ goto out; ++} ++ ++static int vdisk_attach_tgt(struct scst_tgt_dev *tgt_dev) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ /* Nothing to do */ ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void vdisk_detach_tgt(struct scst_tgt_dev *tgt_dev) ++{ ++ TRACE_ENTRY(); ++ ++ scst_del_all_thr_data(tgt_dev); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int vdisk_do_job(struct scst_cmd *cmd) ++{ ++ int rc, res; ++ uint64_t lba_start = 0; ++ loff_t data_len = 0; ++ uint8_t *cdb = cmd->cdb; ++ int opcode = cdb[0]; ++ loff_t loff; ++ struct scst_device *dev = cmd->dev; ++ struct scst_tgt_dev *tgt_dev = cmd->tgt_dev; ++ struct scst_vdisk_dev *virt_dev = dev->dh_priv; ++ struct scst_thr_data_hdr *d; ++ struct scst_vdisk_thr *thr = NULL; ++ int fua = 0; ++ ++ TRACE_ENTRY(); ++ ++ switch (cmd->queue_type) { ++ case SCST_CMD_QUEUE_ORDERED: ++ TRACE(TRACE_ORDER, "ORDERED cmd %p (op %x)", cmd, cmd->cdb[0]); ++ break; ++ case SCST_CMD_QUEUE_HEAD_OF_QUEUE: ++ TRACE(TRACE_ORDER, "HQ cmd %p (op %x)", cmd, cmd->cdb[0]); ++ break; ++ default: ++ break; ++ } ++ ++ rc = scst_check_local_events(cmd); ++ if (unlikely(rc != 0)) ++ goto out_done; ++ ++ cmd->status = 0; ++ cmd->msg_status = 0; ++ cmd->host_status = DID_OK; ++ cmd->driver_status = 0; ++ ++ if (!virt_dev->nullio) { ++ d = scst_find_thr_data(tgt_dev); ++ if (unlikely(d == NULL)) { ++ thr = vdisk_init_thr_data(tgt_dev, ++ cmd->noio_mem_alloc ? GFP_NOIO : GFP_KERNEL); ++ if (thr == NULL) { ++ scst_set_busy(cmd); ++ goto out_compl; ++ } ++ scst_thr_data_get(&thr->hdr); ++ } else ++ thr = container_of(d, struct scst_vdisk_thr, hdr); ++ } else { ++ thr = &nullio_thr_data; ++ scst_thr_data_get(&thr->hdr); ++ } ++ ++ switch (opcode) { ++ case READ_6: ++ case WRITE_6: ++ case VERIFY_6: ++ lba_start = (((cdb[1] & 0x1f) << (BYTE * 2)) + ++ (cdb[2] << (BYTE * 1)) + ++ (cdb[3] << (BYTE * 0))); ++ data_len = cmd->bufflen; ++ break; ++ case READ_10: ++ case READ_12: ++ case WRITE_10: ++ case WRITE_12: ++ case VERIFY: ++ case WRITE_VERIFY: ++ case WRITE_VERIFY_12: ++ case VERIFY_12: ++ lba_start |= ((u64)cdb[2]) << 24; ++ lba_start |= ((u64)cdb[3]) << 16; ++ lba_start |= ((u64)cdb[4]) << 8; ++ lba_start |= ((u64)cdb[5]); ++ data_len = cmd->bufflen; ++ break; ++ case READ_16: ++ case WRITE_16: ++ case WRITE_VERIFY_16: ++ case VERIFY_16: ++ lba_start |= ((u64)cdb[2]) << 56; ++ lba_start |= ((u64)cdb[3]) << 48; ++ lba_start |= ((u64)cdb[4]) << 40; ++ lba_start |= ((u64)cdb[5]) << 32; ++ lba_start |= ((u64)cdb[6]) << 24; ++ lba_start |= ((u64)cdb[7]) << 16; ++ lba_start |= ((u64)cdb[8]) << 8; ++ lba_start |= ((u64)cdb[9]); ++ data_len = cmd->bufflen; ++ break; ++ case SYNCHRONIZE_CACHE: ++ lba_start |= ((u64)cdb[2]) << 24; ++ lba_start |= ((u64)cdb[3]) << 16; ++ lba_start |= ((u64)cdb[4]) << 8; ++ lba_start |= ((u64)cdb[5]); ++ data_len = ((cdb[7] << (BYTE * 1)) + (cdb[8] << (BYTE * 0))) ++ << virt_dev->block_shift; ++ if (data_len == 0) ++ data_len = virt_dev->file_size - ++ ((loff_t)lba_start << virt_dev->block_shift); ++ break; ++ } ++ ++ loff = (loff_t)lba_start << virt_dev->block_shift; ++ TRACE_DBG("cmd %p, lba_start %lld, loff %lld, data_len %lld", cmd, ++ (long long unsigned int)lba_start, ++ (long long unsigned int)loff, ++ (long long unsigned int)data_len); ++ if (unlikely(loff < 0) || unlikely(data_len < 0) || ++ unlikely((loff + data_len) > virt_dev->file_size)) { ++ PRINT_INFO("Access beyond the end of the device " ++ "(%lld of %lld, len %lld)", ++ (long long unsigned int)loff, ++ (long long unsigned int)virt_dev->file_size, ++ (long long unsigned int)data_len); ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE( ++ scst_sense_block_out_range_error)); ++ goto out_compl; ++ } ++ ++ switch (opcode) { ++ case WRITE_10: ++ case WRITE_12: ++ case WRITE_16: ++ fua = (cdb[1] & 0x8); ++ if (fua) { ++ TRACE(TRACE_ORDER, "FUA: loff=%lld, " ++ "data_len=%lld", (long long unsigned int)loff, ++ (long long unsigned int)data_len); ++ } ++ break; ++ } ++ ++ switch (opcode) { ++ case READ_6: ++ case READ_10: ++ case READ_12: ++ case READ_16: ++ if (virt_dev->blockio) { ++ blockio_exec_rw(cmd, thr, lba_start, 0); ++ goto out_thr; ++ } else ++ vdisk_exec_read(cmd, thr, loff); ++ break; ++ case WRITE_6: ++ case WRITE_10: ++ case WRITE_12: ++ case WRITE_16: ++ { ++ if (virt_dev->blockio) { ++ blockio_exec_rw(cmd, thr, lba_start, 1); ++ goto out_thr; ++ } else ++ vdisk_exec_write(cmd, thr, loff); ++ /* O_SYNC flag is used for WT devices */ ++ if (fua) ++ vdisk_fsync(thr, loff, data_len, cmd, dev); ++ break; ++ } ++ case WRITE_VERIFY: ++ case WRITE_VERIFY_12: ++ case WRITE_VERIFY_16: ++ { ++ /* ToDo: BLOCKIO VERIFY */ ++ vdisk_exec_write(cmd, thr, loff); ++ /* O_SYNC flag is used for WT devices */ ++ if (scsi_status_is_good(cmd->status)) ++ vdisk_exec_verify(cmd, thr, loff); ++ break; ++ } ++ case SYNCHRONIZE_CACHE: ++ { ++ int immed = cdb[1] & 0x2; ++ TRACE(TRACE_ORDER, "SYNCHRONIZE_CACHE: " ++ "loff=%lld, data_len=%lld, immed=%d", ++ (long long unsigned int)loff, ++ (long long unsigned int)data_len, immed); ++ if (immed) { ++ scst_cmd_get(cmd); /* to protect dev */ ++ cmd->completed = 1; ++ cmd->scst_cmd_done(cmd, SCST_CMD_STATE_DEFAULT, ++ SCST_CONTEXT_SAME); ++ vdisk_fsync(thr, loff, data_len, NULL, dev); ++ /* ToDo: vdisk_fsync() error processing */ ++ scst_cmd_put(cmd); ++ goto out_thr; ++ } else { ++ vdisk_fsync(thr, loff, data_len, cmd, dev); ++ break; ++ } ++ } ++ case VERIFY_6: ++ case VERIFY: ++ case VERIFY_12: ++ case VERIFY_16: ++ vdisk_exec_verify(cmd, thr, loff); ++ break; ++ case MODE_SENSE: ++ case MODE_SENSE_10: ++ vdisk_exec_mode_sense(cmd); ++ break; ++ case MODE_SELECT: ++ case MODE_SELECT_10: ++ vdisk_exec_mode_select(cmd); ++ break; ++ case LOG_SELECT: ++ case LOG_SENSE: ++ vdisk_exec_log(cmd); ++ break; ++ case ALLOW_MEDIUM_REMOVAL: ++ vdisk_exec_prevent_allow_medium_removal(cmd); ++ break; ++ case READ_TOC: ++ vdisk_exec_read_toc(cmd); ++ break; ++ case START_STOP: ++ vdisk_fsync(thr, 0, virt_dev->file_size, cmd, dev); ++ break; ++ case RESERVE: ++ case RESERVE_10: ++ case RELEASE: ++ case RELEASE_10: ++ case TEST_UNIT_READY: ++ break; ++ case INQUIRY: ++ vdisk_exec_inquiry(cmd); ++ break; ++ case REQUEST_SENSE: ++ vdisk_exec_request_sense(cmd); ++ break; ++ case READ_CAPACITY: ++ vdisk_exec_read_capacity(cmd); ++ break; ++ case SERVICE_ACTION_IN: ++ if ((cmd->cdb[1] & 0x1f) == SAI_READ_CAPACITY_16) { ++ vdisk_exec_read_capacity16(cmd); ++ break; ++ } ++ goto out_invalid_opcode; ++ case UNMAP: ++ vdisk_exec_unmap(cmd, thr); ++ break; ++ case MAINTENANCE_IN: ++ switch (cmd->cdb[1] & 0x1f) { ++ case MI_REPORT_TARGET_PGS: ++ vdisk_exec_report_tpgs(cmd); ++ break; ++ default: ++ goto out_invalid_opcode; ++ } ++ break; ++ case REPORT_LUNS: ++ default: ++ goto out_invalid_opcode; ++ } ++ ++out_compl: ++ cmd->completed = 1; ++ ++out_done: ++ cmd->scst_cmd_done(cmd, SCST_CMD_STATE_DEFAULT, SCST_CONTEXT_SAME); ++ ++out_thr: ++ if (likely(thr != NULL)) ++ scst_thr_data_put(&thr->hdr); ++ ++ res = SCST_EXEC_COMPLETED; ++ ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_invalid_opcode: ++ TRACE_DBG("Invalid opcode %d", opcode); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_opcode)); ++ goto out_compl; ++} ++ ++static int vdisk_get_block_shift(struct scst_cmd *cmd) ++{ ++ struct scst_vdisk_dev *virt_dev = cmd->dev->dh_priv; ++ return virt_dev->block_shift; ++} ++ ++static int vdisk_parse(struct scst_cmd *cmd) ++{ ++ scst_sbc_generic_parse(cmd, vdisk_get_block_shift); ++ return SCST_CMD_STATE_DEFAULT; ++} ++ ++static int vcdrom_parse(struct scst_cmd *cmd) ++{ ++ scst_cdrom_generic_parse(cmd, vdisk_get_block_shift); ++ return SCST_CMD_STATE_DEFAULT; ++} ++ ++static int vcdrom_exec(struct scst_cmd *cmd) ++{ ++ int res = SCST_EXEC_COMPLETED; ++ int opcode = cmd->cdb[0]; ++ struct scst_vdisk_dev *virt_dev = cmd->dev->dh_priv; ++ ++ TRACE_ENTRY(); ++ ++ cmd->status = 0; ++ cmd->msg_status = 0; ++ cmd->host_status = DID_OK; ++ cmd->driver_status = 0; ++ ++ if (virt_dev->cdrom_empty && (opcode != INQUIRY)) { ++ TRACE_DBG("%s", "CDROM empty"); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_not_ready)); ++ goto out_done; ++ } ++ ++ if (virt_dev->media_changed && scst_is_ua_command(cmd)) { ++ spin_lock(&virt_dev->flags_lock); ++ if (virt_dev->media_changed) { ++ virt_dev->media_changed = 0; ++ TRACE_DBG("%s", "Reporting media changed"); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_medium_changed_UA)); ++ spin_unlock(&virt_dev->flags_lock); ++ goto out_done; ++ } ++ spin_unlock(&virt_dev->flags_lock); ++ } ++ ++ res = vdisk_do_job(cmd); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_done: ++ cmd->scst_cmd_done(cmd, SCST_CMD_STATE_DEFAULT, SCST_CONTEXT_SAME); ++ goto out; ++} ++ ++static uint64_t vdisk_gen_dev_id_num(const char *virt_dev_name) ++{ ++ uint32_t dev_id_num; ++ ++ dev_id_num = crc32c(0, virt_dev_name, strlen(virt_dev_name)+1); ++ ++ return ((uint64_t)scst_get_setup_id() << 32) | dev_id_num; ++} ++ ++static void vdisk_exec_unmap(struct scst_cmd *cmd, struct scst_vdisk_thr *thr) ++{ ++ struct scst_vdisk_dev *virt_dev = cmd->dev->dh_priv; ++ ssize_t length = 0; ++ struct file *fd = thr->fd; ++ struct inode *inode; ++ uint8_t *address; ++ int offset, descriptor_len, total_len; ++ ++ TRACE_ENTRY(); ++ ++ if (unlikely(!virt_dev->thin_provisioned)) { ++ TRACE_DBG("%s", "Invalid opcode UNMAP"); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_opcode)); ++ goto out; ++ } ++ ++ if (unlikely(cmd->cdb[1] & 1)) { ++ /* ANCHOR not supported */ ++ TRACE_DBG("%s", "Invalid ANCHOR field"); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out; ++ } ++ ++ length = scst_get_buf_full(cmd, &address); ++ if (unlikely(length <= 0)) { ++ if (length == 0) ++ goto out_put; ++ else if (length == -ENOMEM) ++ scst_set_busy(cmd); ++ else ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out; ++ } ++ ++ inode = fd->f_dentry->d_inode; ++ ++ total_len = cmd->cdb[7] << 8 | cmd->cdb[8]; /* length */ ++ offset = 8; ++ ++ descriptor_len = address[2] << 8 | address[3]; ++ ++ TRACE_DBG("total_len %d, descriptor_len %d", total_len, descriptor_len); ++ ++ if (descriptor_len == 0) ++ goto out_put; ++ ++ if (unlikely((descriptor_len > (total_len - 8)) || ++ ((descriptor_len % 16) != 0))) { ++ PRINT_ERROR("Bad descriptor length: %d < %d - 8", ++ descriptor_len, total_len); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_parm_list)); ++ goto out_put; ++ } ++ ++ while ((offset - 8) < descriptor_len) { ++ int err; ++ uint64_t start; ++ uint32_t len; ++ start = be64_to_cpu(get_unaligned((__be64 *)&address[offset])); ++ offset += 8; ++ len = be32_to_cpu(get_unaligned((__be32 *)&address[offset])); ++ offset += 8; ++ ++ if ((start > virt_dev->nblocks) || ++ ((start + len) > virt_dev->nblocks)) { ++ PRINT_ERROR("Device %s: attempt to write beyond max " ++ "size", virt_dev->name); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out_put; ++ } ++ ++ TRACE_DBG("Unmapping lba %lld (blocks %d)", ++ (unsigned long long)start, len); ++ ++ if (virt_dev->blockio) { ++ gfp_t gfp = cmd->noio_mem_alloc ? GFP_NOIO : GFP_KERNEL; ++ err = blkdev_issue_discard(inode->i_bdev, start, len, ++ gfp, 0); ++ if (unlikely(err != 0)) { ++ PRINT_ERROR("blkdev_issue_discard() for " ++ "LBA %lld len %d failed with err %d", ++ (unsigned long long)start, len, err); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_write_error)); ++ goto out_put; ++ } ++ } else { ++ const int block_shift = virt_dev->block_shift; ++ const loff_t a0 = start << block_shift; ++ const loff_t a2 = (start + len) << block_shift; ++ const loff_t a1 = max_t(loff_t, a2 & PAGE_CACHE_MASK, ++ a0); ++ ++ /* ++ * The SCSI UNMAP command discards a range of blocks ++ * of size (1 << block_shift) while the Linux VFS ++ * truncate_range() function discards a range of blocks ++ * of size PAGE_CACHE_SIZE. Hence pass range [a0, a1) ++ * to truncate_range() instead of range [a0, ++ * a2). Note: since we do not set TPRZ it is not ++ * necessary to overwrite the range [a1, a2) with ++ * zeroes. ++ */ ++ WARN_ON(!(a0 <= a1 && a1 <= a2)); ++ WARN_ON(!((a1 & (PAGE_CACHE_SIZE - 1)) == 0 || ++ a0 == a1)); ++ if (a0 < a1) ++ inode->i_op->truncate_range(inode, a0, a1 - 1); ++ } ++ } ++ ++out_put: ++ scst_put_buf_full(cmd, address); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static void vdisk_exec_inquiry(struct scst_cmd *cmd) ++{ ++ int32_t length, i, resp_len = 0; ++ uint8_t *address; ++ uint8_t *buf; ++ struct scst_vdisk_dev *virt_dev = cmd->dev->dh_priv; ++ uint16_t tg_id; ++ ++ TRACE_ENTRY(); ++ ++ buf = kzalloc(INQ_BUF_SZ, GFP_KERNEL); ++ if (buf == NULL) { ++ scst_set_busy(cmd); ++ goto out; ++ } ++ ++ length = scst_get_buf_full(cmd, &address); ++ TRACE_DBG("length %d", length); ++ if (unlikely(length <= 0)) { ++ if (length < 0) { ++ PRINT_ERROR("scst_get_buf_full() failed: %d", length); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ } ++ goto out_free; ++ } ++ ++ if (cmd->cdb[1] & CMDDT) { ++ TRACE_DBG("%s", "INQUIRY: CMDDT is unsupported"); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out_put; ++ } ++ ++ buf[0] = cmd->dev->type; /* type dev */ ++ /* Vital Product */ ++ if (cmd->cdb[1] & EVPD) { ++ if (0 == cmd->cdb[2]) { ++ /* supported vital product data pages */ ++ buf[3] = 3; ++ buf[4] = 0x0; /* this page */ ++ buf[5] = 0x80; /* unit serial number */ ++ buf[6] = 0x83; /* device identification */ ++ if (virt_dev->dev->type == TYPE_DISK) { ++ buf[3] += 1; ++ buf[7] = 0xB0; /* block limits */ ++ if (virt_dev->thin_provisioned) { ++ buf[3] += 1; ++ buf[8] = 0xB2; /* thin provisioning */ ++ } ++ } ++ resp_len = buf[3] + 4; ++ } else if (0x80 == cmd->cdb[2]) { ++ /* unit serial number */ ++ buf[1] = 0x80; ++ if (cmd->tgtt->get_serial) { ++ buf[3] = cmd->tgtt->get_serial(cmd->tgt_dev, ++ &buf[4], INQ_BUF_SZ - 4); ++ } else { ++ int usn_len; ++ read_lock(&vdisk_serial_rwlock); ++ usn_len = strlen(virt_dev->usn); ++ buf[3] = usn_len; ++ strncpy(&buf[4], virt_dev->usn, usn_len); ++ read_unlock(&vdisk_serial_rwlock); ++ } ++ resp_len = buf[3] + 4; ++ } else if (0x83 == cmd->cdb[2]) { ++ /* device identification */ ++ int num = 4; ++ ++ buf[1] = 0x83; ++ /* T10 vendor identifier field format (faked) */ ++ buf[num + 0] = 0x2; /* ASCII */ ++ buf[num + 1] = 0x1; /* Vendor ID */ ++ if (cmd->tgtt->vendor) ++ memcpy(&buf[num + 4], cmd->tgtt->vendor, 8); ++ else if (virt_dev->blockio) ++ memcpy(&buf[num + 4], SCST_BIO_VENDOR, 8); ++ else ++ memcpy(&buf[num + 4], SCST_FIO_VENDOR, 8); ++ ++ read_lock(&vdisk_serial_rwlock); ++ i = strlen(virt_dev->t10_dev_id); ++ memcpy(&buf[num + 12], virt_dev->t10_dev_id, i); ++ read_unlock(&vdisk_serial_rwlock); ++ ++ buf[num + 3] = 8 + i; ++ num += buf[num + 3]; ++ ++ num += 4; ++ ++ /* ++ * Relative target port identifier ++ */ ++ buf[num + 0] = 0x01; /* binary */ ++ /* Relative target port id */ ++ buf[num + 1] = 0x10 | 0x04; ++ ++ put_unaligned(cpu_to_be16(cmd->tgt->rel_tgt_id), ++ (__be16 *)&buf[num + 4 + 2]); ++ ++ buf[num + 3] = 4; ++ num += buf[num + 3]; ++ ++ num += 4; ++ ++ tg_id = scst_lookup_tg_id(cmd->dev, cmd->tgt); ++ if (tg_id) { ++ /* ++ * Target port group designator ++ */ ++ buf[num + 0] = 0x01; /* binary */ ++ /* Target port group id */ ++ buf[num + 1] = 0x10 | 0x05; ++ ++ put_unaligned(cpu_to_be16(tg_id), ++ (__be16 *)&buf[num + 4 + 2]); ++ ++ buf[num + 3] = 4; ++ num += 4 + buf[num + 3]; ++ } ++ ++ /* ++ * IEEE id ++ */ ++ buf[num + 0] = 0x01; /* binary */ ++ ++ /* EUI-64 */ ++ buf[num + 1] = 0x02; ++ buf[num + 2] = 0x00; ++ buf[num + 3] = 0x08; ++ ++ /* IEEE id */ ++ buf[num + 4] = virt_dev->t10_dev_id[0]; ++ buf[num + 5] = virt_dev->t10_dev_id[1]; ++ buf[num + 6] = virt_dev->t10_dev_id[2]; ++ ++ /* IEEE ext id */ ++ buf[num + 7] = virt_dev->t10_dev_id[3]; ++ buf[num + 8] = virt_dev->t10_dev_id[4]; ++ buf[num + 9] = virt_dev->t10_dev_id[5]; ++ buf[num + 10] = virt_dev->t10_dev_id[6]; ++ buf[num + 11] = virt_dev->t10_dev_id[7]; ++ num += buf[num + 3]; ++ ++ resp_len = num; ++ buf[2] = (resp_len >> 8) & 0xFF; ++ buf[3] = resp_len & 0xFF; ++ resp_len += 4; ++ } else if ((0xB0 == cmd->cdb[2]) && ++ (virt_dev->dev->type == TYPE_DISK)) { ++ /* Block Limits */ ++ int max_transfer; ++ buf[1] = 0xB0; ++ buf[3] = 0x3C; ++ /* Optimal transfer granuality is PAGE_SIZE */ ++ put_unaligned(cpu_to_be16(max_t(int, ++ PAGE_SIZE/virt_dev->block_size, 1)), ++ (uint16_t *)&buf[6]); ++ /* Max transfer len is min of sg limit and 8M */ ++ max_transfer = min_t(int, ++ cmd->tgt_dev->max_sg_cnt << PAGE_SHIFT, ++ 8*1024*1024) / virt_dev->block_size; ++ put_unaligned(cpu_to_be32(max_transfer), ++ (uint32_t *)&buf[8]); ++ /* ++ * Let's have optimal transfer len 512KB. Better to not ++ * set it at all, because we don't have such limit, ++ * but some initiators may not understand that (?). ++ * From other side, too big transfers are not optimal, ++ * because SGV cache supports only <4M buffers. ++ */ ++ put_unaligned(cpu_to_be32(min_t(int, ++ max_transfer, ++ 512*1024 / virt_dev->block_size)), ++ (uint32_t *)&buf[12]); ++ if (virt_dev->thin_provisioned) { ++ /* MAXIMUM UNMAP LBA COUNT is UNLIMITED */ ++ put_unaligned(__constant_cpu_to_be32(0xFFFFFFFF), ++ (uint32_t *)&buf[20]); ++ /* MAXIMUM UNMAP BLOCK DESCRIPTOR COUNT is UNLIMITED */ ++ put_unaligned(__constant_cpu_to_be32(0xFFFFFFFF), ++ (uint32_t *)&buf[24]); ++ /* OPTIMAL UNMAP GRANULARITY is 1 */ ++ put_unaligned(__constant_cpu_to_be32(1), ++ (uint32_t *)&buf[28]); ++ } ++ resp_len = buf[3] + 4; ++ } else if ((0xB2 == cmd->cdb[2]) && ++ (virt_dev->dev->type == TYPE_DISK) && ++ virt_dev->thin_provisioned) { ++ /* Thin Provisioning */ ++ buf[1] = 0xB2; ++ buf[3] = 2; ++ buf[5] = 0x80; ++ resp_len = buf[3] + 4; ++ } else { ++ TRACE_DBG("INQUIRY: Unsupported EVPD page %x", ++ cmd->cdb[2]); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out_put; ++ } ++ } else { ++ int len, num; ++ ++ if (cmd->cdb[2] != 0) { ++ TRACE_DBG("INQUIRY: Unsupported page %x", cmd->cdb[2]); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out_put; ++ } ++ ++ if (virt_dev->removable) ++ buf[1] = 0x80; /* removable */ ++ buf[2] = 5; /* Device complies to SPC-3 */ ++ buf[3] = 0x02; /* Data in format specified in SPC */ ++ if (cmd->tgtt->fake_aca) ++ buf[3] |= 0x20; ++ buf[4] = 31;/* n - 4 = 35 - 4 = 31 for full 36 byte data */ ++ if (scst_impl_alua_configured(cmd->dev)) ++ buf[5] = SCST_INQ_TPGS_MODE_IMPLICIT; ++ buf[6] = 0x10; /* MultiP 1 */ ++ buf[7] = 2; /* CMDQUE 1, BQue 0 => commands queuing supported */ ++ ++ /* ++ * 8 byte ASCII Vendor Identification of the target ++ * - left aligned. ++ */ ++ if (cmd->tgtt->vendor) ++ memcpy(&buf[8], cmd->tgtt->vendor, 8); ++ else if (virt_dev->blockio) ++ memcpy(&buf[8], SCST_BIO_VENDOR, 8); ++ else ++ memcpy(&buf[8], SCST_FIO_VENDOR, 8); ++ ++ /* ++ * 16 byte ASCII Product Identification of the target - left ++ * aligned. ++ */ ++ memset(&buf[16], ' ', 16); ++ if (cmd->tgtt->get_product_id) ++ cmd->tgtt->get_product_id(cmd->tgt_dev, &buf[16], 16); ++ else { ++ len = min_t(size_t, strlen(virt_dev->name), 16); ++ memcpy(&buf[16], virt_dev->name, len); ++ } ++ ++ /* ++ * 4 byte ASCII Product Revision Level of the target - left ++ * aligned. ++ */ ++ if (cmd->tgtt->revision) ++ memcpy(&buf[32], cmd->tgtt->revision, 4); ++ else ++ memcpy(&buf[32], SCST_FIO_REV, 4); ++ ++ /** Version descriptors **/ ++ ++ buf[4] += 58 - 36; ++ num = 0; ++ ++ /* SAM-3 T10/1561-D revision 14 */ ++ buf[58 + num] = 0x0; ++ buf[58 + num + 1] = 0x76; ++ num += 2; ++ ++ /* Physical transport */ ++ if (cmd->tgtt->get_phys_transport_version != NULL) { ++ uint16_t v = cmd->tgtt->get_phys_transport_version(cmd->tgt); ++ if (v != 0) { ++ *((__be16 *)&buf[58 + num]) = cpu_to_be16(v); ++ num += 2; ++ } ++ } ++ ++ /* SCSI transport */ ++ if (cmd->tgtt->get_scsi_transport_version != NULL) { ++ *((__be16 *)&buf[58 + num]) = ++ cpu_to_be16(cmd->tgtt->get_scsi_transport_version(cmd->tgt)); ++ num += 2; ++ } ++ ++ /* SPC-3 T10/1416-D revision 23 */ ++ buf[58 + num] = 0x3; ++ buf[58 + num + 1] = 0x12; ++ num += 2; ++ ++ /* Device command set */ ++ if (virt_dev->command_set_version != 0) { ++ *((__be16 *)&buf[58 + num]) = ++ cpu_to_be16(virt_dev->command_set_version); ++ num += 2; ++ } ++ ++ /* Vendor specific information. */ ++ if (cmd->tgtt->get_vend_specific) { ++ /* Skip to byte 96. */ ++ num = 96 - 58; ++ num += cmd->tgtt->get_vend_specific(cmd->tgt_dev, ++ &buf[96], INQ_BUF_SZ - 96); ++ } ++ ++ buf[4] += num; ++ resp_len = buf[4] + 5; ++ } ++ ++ BUG_ON(resp_len >= INQ_BUF_SZ); ++ ++ if (length > resp_len) ++ length = resp_len; ++ memcpy(address, buf, length); ++ ++out_put: ++ scst_put_buf_full(cmd, address); ++ if (length < cmd->resp_data_len) ++ scst_set_resp_data_len(cmd, length); ++ ++out_free: ++ kfree(buf); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static void vdisk_exec_request_sense(struct scst_cmd *cmd) ++{ ++ int32_t length, sl; ++ uint8_t *address; ++ uint8_t b[SCST_STANDARD_SENSE_LEN]; ++ ++ TRACE_ENTRY(); ++ ++ sl = scst_set_sense(b, sizeof(b), cmd->dev->d_sense, ++ SCST_LOAD_SENSE(scst_sense_no_sense)); ++ ++ length = scst_get_buf_full(cmd, &address); ++ TRACE_DBG("length %d", length); ++ if (length < 0) { ++ PRINT_ERROR("scst_get_buf_full() failed: %d)", length); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out; ++ } ++ ++ length = min(sl, length); ++ memcpy(address, b, length); ++ scst_set_resp_data_len(cmd, length); ++ ++ scst_put_buf_full(cmd, address); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * <<Following mode pages info copied from ST318451LW with some corrections>> ++ * ++ * ToDo: revise them ++ */ ++static int vdisk_err_recov_pg(unsigned char *p, int pcontrol, ++ struct scst_vdisk_dev *virt_dev) ++{ /* Read-Write Error Recovery page for mode_sense */ ++ const unsigned char err_recov_pg[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0, ++ 5, 0, 0xff, 0xff}; ++ ++ memcpy(p, err_recov_pg, sizeof(err_recov_pg)); ++ if (1 == pcontrol) ++ memset(p + 2, 0, sizeof(err_recov_pg) - 2); ++ return sizeof(err_recov_pg); ++} ++ ++static int vdisk_disconnect_pg(unsigned char *p, int pcontrol, ++ struct scst_vdisk_dev *virt_dev) ++{ /* Disconnect-Reconnect page for mode_sense */ ++ const unsigned char disconnect_pg[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0}; ++ ++ memcpy(p, disconnect_pg, sizeof(disconnect_pg)); ++ if (1 == pcontrol) ++ memset(p + 2, 0, sizeof(disconnect_pg) - 2); ++ return sizeof(disconnect_pg); ++} ++ ++static int vdisk_rigid_geo_pg(unsigned char *p, int pcontrol, ++ struct scst_vdisk_dev *virt_dev) ++{ ++ unsigned char geo_m_pg[] = {0x04, 0x16, 0, 0, 0, DEF_HEADS, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0x3a, 0x98/* 15K RPM */, 0, 0}; ++ int32_t ncyl, n, rem; ++ uint64_t dividend; ++ ++ memcpy(p, geo_m_pg, sizeof(geo_m_pg)); ++ /* ++ * Divide virt_dev->nblocks by (DEF_HEADS * DEF_SECTORS) and store ++ * the quotient in ncyl and the remainder in rem. ++ */ ++ dividend = virt_dev->nblocks; ++ rem = do_div(dividend, DEF_HEADS * DEF_SECTORS); ++ ncyl = dividend; ++ if (rem != 0) ++ ncyl++; ++ memcpy(&n, p + 2, sizeof(u32)); ++ n = n | ((__force u32)cpu_to_be32(ncyl) >> 8); ++ memcpy(p + 2, &n, sizeof(u32)); ++ if (1 == pcontrol) ++ memset(p + 2, 0, sizeof(geo_m_pg) - 2); ++ return sizeof(geo_m_pg); ++} ++ ++static int vdisk_format_pg(unsigned char *p, int pcontrol, ++ struct scst_vdisk_dev *virt_dev) ++{ /* Format device page for mode_sense */ ++ const unsigned char format_pg[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0x40, 0, 0, 0}; ++ ++ memcpy(p, format_pg, sizeof(format_pg)); ++ p[10] = (DEF_SECTORS >> 8) & 0xff; ++ p[11] = DEF_SECTORS & 0xff; ++ p[12] = (virt_dev->block_size >> 8) & 0xff; ++ p[13] = virt_dev->block_size & 0xff; ++ if (1 == pcontrol) ++ memset(p + 2, 0, sizeof(format_pg) - 2); ++ return sizeof(format_pg); ++} ++ ++static int vdisk_caching_pg(unsigned char *p, int pcontrol, ++ struct scst_vdisk_dev *virt_dev) ++{ /* Caching page for mode_sense */ ++ const unsigned char caching_pg[] = {0x8, 18, 0x10, 0, 0xff, 0xff, 0, 0, ++ 0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0, 0, 0, 0, 0}; ++ ++ memcpy(p, caching_pg, sizeof(caching_pg)); ++ p[2] |= !(virt_dev->wt_flag || virt_dev->nv_cache) ? WCE : 0; ++ if (1 == pcontrol) ++ memset(p + 2, 0, sizeof(caching_pg) - 2); ++ return sizeof(caching_pg); ++} ++ ++static int vdisk_ctrl_m_pg(unsigned char *p, int pcontrol, ++ struct scst_vdisk_dev *virt_dev) ++{ /* Control mode page for mode_sense */ ++ const unsigned char ctrl_m_pg[] = {0xa, 0xa, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0x2, 0x4b}; ++ ++ memcpy(p, ctrl_m_pg, sizeof(ctrl_m_pg)); ++ switch (pcontrol) { ++ case 0: ++ p[2] |= virt_dev->dev->tst << 5; ++ p[2] |= virt_dev->dev->d_sense << 2; ++ p[3] |= virt_dev->dev->queue_alg << 4; ++ p[4] |= virt_dev->dev->swp << 3; ++ p[5] |= virt_dev->dev->tas << 6; ++ break; ++ case 1: ++ memset(p + 2, 0, sizeof(ctrl_m_pg) - 2); ++#if 0 /* ++ * It's too early to implement it, since we can't control the ++ * backstorage device parameters. ToDo ++ */ ++ p[2] |= 7 << 5; /* TST */ ++ p[3] |= 0xF << 4; /* QUEUE ALGORITHM MODIFIER */ ++#endif ++ p[2] |= 1 << 2; /* D_SENSE */ ++ p[4] |= 1 << 3; /* SWP */ ++ p[5] |= 1 << 6; /* TAS */ ++ break; ++ case 2: ++ p[2] |= DEF_TST << 5; ++ p[2] |= DEF_DSENSE << 2; ++ if (virt_dev->wt_flag || virt_dev->nv_cache) ++ p[3] |= DEF_QUEUE_ALG_WT << 4; ++ else ++ p[3] |= DEF_QUEUE_ALG << 4; ++ p[4] |= DEF_SWP << 3; ++ p[5] |= DEF_TAS << 6; ++ break; ++ default: ++ BUG(); ++ } ++ return sizeof(ctrl_m_pg); ++} ++ ++static int vdisk_iec_m_pg(unsigned char *p, int pcontrol, ++ struct scst_vdisk_dev *virt_dev) ++{ /* Informational Exceptions control mode page for mode_sense */ ++ const unsigned char iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0, ++ 0, 0, 0x0, 0x0}; ++ memcpy(p, iec_m_pg, sizeof(iec_m_pg)); ++ if (1 == pcontrol) ++ memset(p + 2, 0, sizeof(iec_m_pg) - 2); ++ return sizeof(iec_m_pg); ++} ++ ++static void vdisk_exec_mode_sense(struct scst_cmd *cmd) ++{ ++ int32_t length; ++ uint8_t *address; ++ uint8_t *buf; ++ struct scst_vdisk_dev *virt_dev; ++ uint32_t blocksize; ++ uint64_t nblocks; ++ unsigned char dbd, type; ++ int pcontrol, pcode, subpcode; ++ unsigned char dev_spec; ++ int msense_6, offset = 0, len; ++ unsigned char *bp; ++ ++ TRACE_ENTRY(); ++ ++ buf = kzalloc(MSENSE_BUF_SZ, GFP_KERNEL); ++ if (buf == NULL) { ++ scst_set_busy(cmd); ++ goto out; ++ } ++ ++ virt_dev = cmd->dev->dh_priv; ++ blocksize = virt_dev->block_size; ++ nblocks = virt_dev->nblocks; ++ ++ type = cmd->dev->type; /* type dev */ ++ dbd = cmd->cdb[1] & DBD; ++ pcontrol = (cmd->cdb[2] & 0xc0) >> 6; ++ pcode = cmd->cdb[2] & 0x3f; ++ subpcode = cmd->cdb[3]; ++ msense_6 = (MODE_SENSE == cmd->cdb[0]); ++ dev_spec = (virt_dev->dev->rd_only || ++ cmd->tgt_dev->acg_dev->rd_only) ? WP : 0; ++ ++ if (!virt_dev->blockio) ++ dev_spec |= DPOFUA; ++ ++ length = scst_get_buf_full(cmd, &address); ++ if (unlikely(length <= 0)) { ++ if (length < 0) { ++ PRINT_ERROR("scst_get_buf_full() failed: %d", length); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ } ++ goto out_free; ++ } ++ ++ if (0x3 == pcontrol) { ++ TRACE_DBG("%s", "MODE SENSE: Saving values not supported"); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_saving_params_unsup)); ++ goto out_put; ++ } ++ ++ if (msense_6) { ++ buf[1] = type; ++ buf[2] = dev_spec; ++ offset = 4; ++ } else { ++ buf[2] = type; ++ buf[3] = dev_spec; ++ offset = 8; ++ } ++ ++ if (0 != subpcode) { ++ /* TODO: Control Extension page */ ++ TRACE_DBG("%s", "MODE SENSE: Only subpage 0 is supported"); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out_put; ++ } ++ ++ if (!dbd) { ++ /* Create block descriptor */ ++ buf[offset - 1] = 0x08; /* block descriptor length */ ++ if (nblocks >> 32) { ++ buf[offset + 0] = 0xFF; ++ buf[offset + 1] = 0xFF; ++ buf[offset + 2] = 0xFF; ++ buf[offset + 3] = 0xFF; ++ } else { ++ /* num blks */ ++ buf[offset + 0] = (nblocks >> (BYTE * 3)) & 0xFF; ++ buf[offset + 1] = (nblocks >> (BYTE * 2)) & 0xFF; ++ buf[offset + 2] = (nblocks >> (BYTE * 1)) & 0xFF; ++ buf[offset + 3] = (nblocks >> (BYTE * 0)) & 0xFF; ++ } ++ buf[offset + 4] = 0; /* density code */ ++ buf[offset + 5] = (blocksize >> (BYTE * 2)) & 0xFF;/* blklen */ ++ buf[offset + 6] = (blocksize >> (BYTE * 1)) & 0xFF; ++ buf[offset + 7] = (blocksize >> (BYTE * 0)) & 0xFF; ++ ++ offset += 8; /* increment offset */ ++ } ++ ++ bp = buf + offset; ++ ++ switch (pcode) { ++ case 0x1: /* Read-Write error recovery page, direct access */ ++ len = vdisk_err_recov_pg(bp, pcontrol, virt_dev); ++ break; ++ case 0x2: /* Disconnect-Reconnect page, all devices */ ++ len = vdisk_disconnect_pg(bp, pcontrol, virt_dev); ++ break; ++ case 0x3: /* Format device page, direct access */ ++ len = vdisk_format_pg(bp, pcontrol, virt_dev); ++ break; ++ case 0x4: /* Rigid disk geometry */ ++ len = vdisk_rigid_geo_pg(bp, pcontrol, virt_dev); ++ break; ++ case 0x8: /* Caching page, direct access */ ++ len = vdisk_caching_pg(bp, pcontrol, virt_dev); ++ break; ++ case 0xa: /* Control Mode page, all devices */ ++ len = vdisk_ctrl_m_pg(bp, pcontrol, virt_dev); ++ break; ++ case 0x1c: /* Informational Exceptions Mode page, all devices */ ++ len = vdisk_iec_m_pg(bp, pcontrol, virt_dev); ++ break; ++ case 0x3f: /* Read all Mode pages */ ++ len = vdisk_err_recov_pg(bp, pcontrol, virt_dev); ++ len += vdisk_disconnect_pg(bp + len, pcontrol, virt_dev); ++ len += vdisk_format_pg(bp + len, pcontrol, virt_dev); ++ len += vdisk_caching_pg(bp + len, pcontrol, virt_dev); ++ len += vdisk_ctrl_m_pg(bp + len, pcontrol, virt_dev); ++ len += vdisk_iec_m_pg(bp + len, pcontrol, virt_dev); ++ len += vdisk_rigid_geo_pg(bp + len, pcontrol, virt_dev); ++ break; ++ default: ++ TRACE_DBG("MODE SENSE: Unsupported page %x", pcode); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out_put; ++ } ++ ++ offset += len; ++ ++ if (msense_6) ++ buf[0] = offset - 1; ++ else { ++ buf[0] = ((offset - 2) >> 8) & 0xff; ++ buf[1] = (offset - 2) & 0xff; ++ } ++ ++ if (offset > length) ++ offset = length; ++ memcpy(address, buf, offset); ++ ++out_put: ++ scst_put_buf_full(cmd, address); ++ if (offset < cmd->resp_data_len) ++ scst_set_resp_data_len(cmd, offset); ++ ++out_free: ++ kfree(buf); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static int vdisk_set_wt(struct scst_vdisk_dev *virt_dev, int wt) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ if ((virt_dev->wt_flag == wt) || virt_dev->nullio || virt_dev->nv_cache) ++ goto out; ++ ++ spin_lock(&virt_dev->flags_lock); ++ virt_dev->wt_flag = wt; ++ spin_unlock(&virt_dev->flags_lock); ++ ++ scst_dev_del_all_thr_data(virt_dev->dev); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void vdisk_ctrl_m_pg_select(unsigned char *p, ++ struct scst_vdisk_dev *virt_dev, struct scst_cmd *cmd) ++{ ++ struct scst_device *dev = virt_dev->dev; ++ int old_swp = dev->swp, old_tas = dev->tas, old_dsense = dev->d_sense; ++ ++#if 0 /* Not implemented yet, see comment in vdisk_ctrl_m_pg() */ ++ dev->tst = (p[2] >> 5) & 1; ++ dev->queue_alg = p[3] >> 4; ++#else ++ if ((dev->tst != ((p[2] >> 5) & 1)) || (dev->queue_alg != (p[3] >> 4))) { ++ TRACE(TRACE_MINOR|TRACE_SCSI, "%s", "MODE SELECT: Changing of " ++ "TST and QUEUE ALGORITHM not supported"); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ return; ++ } ++#endif ++ dev->swp = (p[4] & 0x8) >> 3; ++ dev->tas = (p[5] & 0x40) >> 6; ++ dev->d_sense = (p[2] & 0x4) >> 2; ++ ++ PRINT_INFO("Device %s: new control mode page parameters: SWP %x " ++ "(was %x), TAS %x (was %x), D_SENSE %d (was %d)", ++ virt_dev->name, dev->swp, old_swp, dev->tas, old_tas, ++ dev->d_sense, old_dsense); ++ return; ++} ++ ++static void vdisk_exec_mode_select(struct scst_cmd *cmd) ++{ ++ int32_t length; ++ uint8_t *address; ++ struct scst_vdisk_dev *virt_dev; ++ int mselect_6, offset; ++ ++ TRACE_ENTRY(); ++ ++ virt_dev = cmd->dev->dh_priv; ++ mselect_6 = (MODE_SELECT == cmd->cdb[0]); ++ ++ length = scst_get_buf_full(cmd, &address); ++ if (unlikely(length <= 0)) { ++ if (length < 0) { ++ PRINT_ERROR("scst_get_buf_full() failed: %d", length); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ } ++ goto out; ++ } ++ ++ if (!(cmd->cdb[1] & PF) || (cmd->cdb[1] & SP)) { ++ TRACE(TRACE_MINOR|TRACE_SCSI, "MODE SELECT: Unsupported " ++ "value(s) of PF and/or SP bits (cdb[1]=%x)", ++ cmd->cdb[1]); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out_put; ++ } ++ ++ if (mselect_6) ++ offset = 4; ++ else ++ offset = 8; ++ ++ if (address[offset - 1] == 8) { ++ offset += 8; ++ } else if (address[offset - 1] != 0) { ++ PRINT_ERROR("%s", "MODE SELECT: Wrong parameters list " ++ "lenght"); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_parm_list)); ++ goto out_put; ++ } ++ ++ while (length > offset + 2) { ++ if (address[offset] & PS) { ++ PRINT_ERROR("%s", "MODE SELECT: Illegal PS bit"); ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE( ++ scst_sense_invalid_field_in_parm_list)); ++ goto out_put; ++ } ++ if ((address[offset] & 0x3f) == 0x8) { ++ /* Caching page */ ++ if (address[offset + 1] != 18) { ++ PRINT_ERROR("%s", "MODE SELECT: Invalid " ++ "caching page request"); ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE( ++ scst_sense_invalid_field_in_parm_list)); ++ goto out_put; ++ } ++ if (vdisk_set_wt(virt_dev, ++ (address[offset + 2] & WCE) ? 0 : 1) != 0) { ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out_put; ++ } ++ break; ++ } else if ((address[offset] & 0x3f) == 0xA) { ++ /* Control page */ ++ if (address[offset + 1] != 0xA) { ++ PRINT_ERROR("%s", "MODE SELECT: Invalid " ++ "control page request"); ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE( ++ scst_sense_invalid_field_in_parm_list)); ++ goto out_put; ++ } ++ vdisk_ctrl_m_pg_select(&address[offset], virt_dev, cmd); ++ } else { ++ PRINT_ERROR("MODE SELECT: Invalid request %x", ++ address[offset] & 0x3f); ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE( ++ scst_sense_invalid_field_in_parm_list)); ++ goto out_put; ++ } ++ offset += address[offset + 1]; ++ } ++ ++out_put: ++ scst_put_buf_full(cmd, address); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static void vdisk_exec_log(struct scst_cmd *cmd) ++{ ++ TRACE_ENTRY(); ++ ++ /* No log pages are supported */ ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void vdisk_exec_read_capacity(struct scst_cmd *cmd) ++{ ++ int32_t length; ++ uint8_t *address; ++ struct scst_vdisk_dev *virt_dev; ++ uint32_t blocksize; ++ uint64_t nblocks; ++ uint8_t buffer[8]; ++ ++ TRACE_ENTRY(); ++ ++ virt_dev = cmd->dev->dh_priv; ++ blocksize = virt_dev->block_size; ++ nblocks = virt_dev->nblocks; ++ ++ if ((cmd->cdb[8] & 1) == 0) { ++ uint64_t lba = be64_to_cpu(get_unaligned((__be64 *)&cmd->cdb[2])); ++ if (lba != 0) { ++ TRACE_DBG("PMI zero and LBA not zero (cmd %p)", cmd); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out; ++ } ++ } ++ ++ /* Last block on the virt_dev is (nblocks-1) */ ++ memset(buffer, 0, sizeof(buffer)); ++ ++ /* ++ * If we are thinly provisioned, we must ensure that the initiator ++ * issues a READ_CAPACITY(16) so we can return the TPE bit. By ++ * returning 0xFFFFFFFF we do that. ++ */ ++ if (nblocks >> 32 || virt_dev->thin_provisioned) { ++ buffer[0] = 0xFF; ++ buffer[1] = 0xFF; ++ buffer[2] = 0xFF; ++ buffer[3] = 0xFF; ++ } else { ++ buffer[0] = ((nblocks - 1) >> (BYTE * 3)) & 0xFF; ++ buffer[1] = ((nblocks - 1) >> (BYTE * 2)) & 0xFF; ++ buffer[2] = ((nblocks - 1) >> (BYTE * 1)) & 0xFF; ++ buffer[3] = ((nblocks - 1) >> (BYTE * 0)) & 0xFF; ++ } ++ buffer[4] = (blocksize >> (BYTE * 3)) & 0xFF; ++ buffer[5] = (blocksize >> (BYTE * 2)) & 0xFF; ++ buffer[6] = (blocksize >> (BYTE * 1)) & 0xFF; ++ buffer[7] = (blocksize >> (BYTE * 0)) & 0xFF; ++ ++ length = scst_get_buf_full(cmd, &address); ++ if (unlikely(length <= 0)) { ++ if (length < 0) { ++ PRINT_ERROR("scst_get_buf_full() failed: %d", length); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ } ++ goto out; ++ } ++ ++ length = min_t(int, length, sizeof(buffer)); ++ ++ memcpy(address, buffer, length); ++ ++ scst_put_buf_full(cmd, address); ++ ++ if (length < cmd->resp_data_len) ++ scst_set_resp_data_len(cmd, length); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static void vdisk_exec_read_capacity16(struct scst_cmd *cmd) ++{ ++ int32_t length; ++ uint8_t *address; ++ struct scst_vdisk_dev *virt_dev; ++ uint32_t blocksize; ++ uint64_t nblocks; ++ uint8_t buffer[32]; ++ ++ TRACE_ENTRY(); ++ ++ virt_dev = cmd->dev->dh_priv; ++ blocksize = virt_dev->block_size; ++ nblocks = virt_dev->nblocks - 1; ++ ++ if ((cmd->cdb[14] & 1) == 0) { ++ uint64_t lba = be64_to_cpu(get_unaligned((__be64 *)&cmd->cdb[2])); ++ if (lba != 0) { ++ TRACE_DBG("PMI zero and LBA not zero (cmd %p)", cmd); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out; ++ } ++ } ++ ++ memset(buffer, 0, sizeof(buffer)); ++ ++ buffer[0] = nblocks >> 56; ++ buffer[1] = (nblocks >> 48) & 0xFF; ++ buffer[2] = (nblocks >> 40) & 0xFF; ++ buffer[3] = (nblocks >> 32) & 0xFF; ++ buffer[4] = (nblocks >> 24) & 0xFF; ++ buffer[5] = (nblocks >> 16) & 0xFF; ++ buffer[6] = (nblocks >> 8) & 0xFF; ++ buffer[7] = nblocks & 0xFF; ++ ++ buffer[8] = (blocksize >> (BYTE * 3)) & 0xFF; ++ buffer[9] = (blocksize >> (BYTE * 2)) & 0xFF; ++ buffer[10] = (blocksize >> (BYTE * 1)) & 0xFF; ++ buffer[11] = (blocksize >> (BYTE * 0)) & 0xFF; ++ ++ switch (blocksize) { ++ case 512: ++ buffer[13] = 3; ++ break; ++ case 1024: ++ buffer[13] = 2; ++ break; ++ case 2048: ++ buffer[13] = 1; ++ break; ++ case 4096: ++ default: ++ buffer[13] = 0; ++ break; ++ } ++ ++ if (virt_dev->thin_provisioned) { ++ buffer[14] |= 0x80; /* Add TPE */ ++#if 0 /* ++ * Might be a big performance and functionality win, but might be ++ * dangerous as well, although generally nearly always it should be set, ++ * because nearly all devices should return zero for unmapped blocks. ++ * But let's be on the safe side and disable it for now. ++ */ ++ buffer[14] |= 0x40; /* Add TPRZ */ ++#endif ++ } ++ ++ length = scst_get_buf_full(cmd, &address); ++ if (unlikely(length <= 0)) { ++ if (length < 0) { ++ PRINT_ERROR("scst_get_buf_full() failed: %d", length); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ } ++ goto out; ++ } ++ ++ length = min_t(int, length, sizeof(buffer)); ++ ++ memcpy(address, buffer, length); ++ ++ scst_put_buf_full(cmd, address); ++ ++ if (length < cmd->resp_data_len) ++ scst_set_resp_data_len(cmd, length); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* SPC-4 REPORT TARGET PORT GROUPS command */ ++static void vdisk_exec_report_tpgs(struct scst_cmd *cmd) ++{ ++ struct scst_device *dev; ++ uint8_t *address; ++ void *buf; ++ int32_t buf_len; ++ uint32_t allocation_length, data_length, length; ++ uint8_t data_format; ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ buf_len = scst_get_buf_full(cmd, &address); ++ if (buf_len < 0) { ++ PRINT_ERROR("scst_get_buf_full() failed: %d", buf_len); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out; ++ } ++ ++ if (cmd->cdb_len < 12) ++ PRINT_WARNING("received invalid REPORT TARGET PORT GROUPS " ++ "command - length %d is too small (should be at " ++ "least 12 bytes)", cmd->cdb_len); ++ ++ dev = cmd->dev; ++ data_format = cmd->cdb_len > 1 ? cmd->cdb[1] >> 5 : 0; ++ allocation_length = cmd->cdb_len >= 10 ? ++ be32_to_cpu(get_unaligned((__be32 *)(cmd->cdb + 6))) : 1024; ++ ++ res = scst_tg_get_group_info(&buf, &data_length, dev, data_format); ++ if (res == -ENOMEM) { ++ scst_set_busy(cmd); ++ goto out_put; ++ } else if (res < 0) { ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out_put; ++ } ++ ++ length = min_t(uint32_t, min(allocation_length, data_length), buf_len); ++ memcpy(address, buf, length); ++ kfree(buf); ++ if (length < cmd->resp_data_len) ++ scst_set_resp_data_len(cmd, length); ++ ++out_put: ++ scst_put_buf_full(cmd, address); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static void vdisk_exec_read_toc(struct scst_cmd *cmd) ++{ ++ int32_t length, off = 0; ++ uint8_t *address; ++ struct scst_vdisk_dev *virt_dev; ++ uint32_t nblocks; ++ uint8_t buffer[4+8+8] = { 0x00, 0x0a, 0x01, 0x01, 0x00, 0x14, ++ 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 }; ++ ++ TRACE_ENTRY(); ++ ++ if (cmd->dev->type != TYPE_ROM) { ++ PRINT_ERROR("%s", "READ TOC for non-CDROM device"); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_opcode)); ++ goto out; ++ } ++ ++ if (cmd->cdb[2] & 0x0e/*Format*/) { ++ PRINT_ERROR("%s", "READ TOC: invalid requested data format"); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out; ++ } ++ ++ if ((cmd->cdb[6] != 0 && (cmd->cdb[2] & 0x01)) || ++ (cmd->cdb[6] > 1 && cmd->cdb[6] != 0xAA)) { ++ PRINT_ERROR("READ TOC: invalid requested track number %x", ++ cmd->cdb[6]); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ goto out; ++ } ++ ++ length = scst_get_buf_full(cmd, &address); ++ if (unlikely(length <= 0)) { ++ if (length < 0) { ++ PRINT_ERROR("scst_get_buf_full() failed: %d", length); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ } ++ goto out; ++ } ++ ++ virt_dev = cmd->dev->dh_priv; ++ /* ToDo when you have > 8TB ROM device. */ ++ nblocks = (uint32_t)virt_dev->nblocks; ++ ++ /* Header */ ++ memset(buffer, 0, sizeof(buffer)); ++ buffer[2] = 0x01; /* First Track/Session */ ++ buffer[3] = 0x01; /* Last Track/Session */ ++ off = 4; ++ if (cmd->cdb[6] <= 1) { ++ /* Fistr TOC Track Descriptor */ ++ /* ADDR 0x10 - Q Sub-channel encodes current position data ++ CONTROL 0x04 - Data track, recoreded uninterrupted */ ++ buffer[off+1] = 0x14; ++ /* Track Number */ ++ buffer[off+2] = 0x01; ++ off += 8; ++ } ++ if (!(cmd->cdb[2] & 0x01)) { ++ /* Lead-out area TOC Track Descriptor */ ++ buffer[off+1] = 0x14; ++ /* Track Number */ ++ buffer[off+2] = 0xAA; ++ /* Track Start Address */ ++ buffer[off+4] = (nblocks >> (BYTE * 3)) & 0xFF; ++ buffer[off+5] = (nblocks >> (BYTE * 2)) & 0xFF; ++ buffer[off+6] = (nblocks >> (BYTE * 1)) & 0xFF; ++ buffer[off+7] = (nblocks >> (BYTE * 0)) & 0xFF; ++ off += 8; ++ } ++ ++ buffer[1] = off - 2; /* Data Length */ ++ ++ if (off > length) ++ off = length; ++ memcpy(address, buffer, off); ++ ++ scst_put_buf_full(cmd, address); ++ ++ if (off < cmd->resp_data_len) ++ scst_set_resp_data_len(cmd, off); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static void vdisk_exec_prevent_allow_medium_removal(struct scst_cmd *cmd) ++{ ++ struct scst_vdisk_dev *virt_dev = cmd->dev->dh_priv; ++ ++ TRACE_DBG("PERSIST/PREVENT 0x%02x", cmd->cdb[4]); ++ ++ spin_lock(&virt_dev->flags_lock); ++ virt_dev->prevent_allow_medium_removal = cmd->cdb[4] & 0x01 ? 1 : 0; ++ spin_unlock(&virt_dev->flags_lock); ++ ++ return; ++} ++ ++static int vdisk_fsync(struct scst_vdisk_thr *thr, loff_t loff, ++ loff_t len, struct scst_cmd *cmd, struct scst_device *dev) ++{ ++ int res = 0; ++ struct scst_vdisk_dev *virt_dev = dev->dh_priv; ++ struct file *file; ++ ++ TRACE_ENTRY(); ++ ++ /* Hopefully, the compiler will generate the single comparison */ ++ if (virt_dev->nv_cache || virt_dev->wt_flag || ++ virt_dev->o_direct_flag || virt_dev->nullio) ++ goto out; ++ ++ if (virt_dev->blockio) { ++ res = vdisk_blockio_flush(thr->bdev, ++ (cmd->noio_mem_alloc ? GFP_NOIO : GFP_KERNEL), true); ++ goto out; ++ } ++ ++ file = thr->fd; ++ ++#if 0 /* For sparse files we might need to sync metadata as well */ ++ res = generic_write_sync(file, loff, len); ++#else ++ res = filemap_write_and_wait_range(file->f_mapping, loff, len); ++#endif ++ if (unlikely(res != 0)) { ++ PRINT_ERROR("sync range failed (%d)", res); ++ if (cmd != NULL) { ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_write_error)); ++ } ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct iovec *vdisk_alloc_iv(struct scst_cmd *cmd, ++ struct scst_vdisk_thr *thr) ++{ ++ int iv_count; ++ ++ iv_count = min_t(int, scst_get_buf_count(cmd), UIO_MAXIOV); ++ if (iv_count > thr->iv_count) { ++ kfree(thr->iv); ++ /* It can't be called in atomic context */ ++ thr->iv = kmalloc(sizeof(*thr->iv) * iv_count, GFP_KERNEL); ++ if (thr->iv == NULL) { ++ PRINT_ERROR("Unable to allocate iv (%d)", iv_count); ++ scst_set_busy(cmd); ++ goto out; ++ } ++ thr->iv_count = iv_count; ++ } ++ ++out: ++ return thr->iv; ++} ++ ++static void vdisk_exec_read(struct scst_cmd *cmd, ++ struct scst_vdisk_thr *thr, loff_t loff) ++{ ++ mm_segment_t old_fs; ++ loff_t err; ++ ssize_t length, full_len; ++ uint8_t __user *address; ++ struct scst_vdisk_dev *virt_dev = cmd->dev->dh_priv; ++ struct file *fd = thr->fd; ++ struct iovec *iv; ++ int iv_count, i; ++ bool finished = false; ++ ++ TRACE_ENTRY(); ++ ++ if (virt_dev->nullio) ++ goto out; ++ ++ iv = vdisk_alloc_iv(cmd, thr); ++ if (iv == NULL) ++ goto out; ++ ++ length = scst_get_buf_first(cmd, (uint8_t __force **)&address); ++ if (unlikely(length < 0)) { ++ PRINT_ERROR("scst_get_buf_first() failed: %zd", length); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out; ++ } ++ ++ old_fs = get_fs(); ++ set_fs(get_ds()); ++ ++ while (1) { ++ iv_count = 0; ++ full_len = 0; ++ i = -1; ++ while (length > 0) { ++ full_len += length; ++ i++; ++ iv_count++; ++ iv[i].iov_base = address; ++ iv[i].iov_len = length; ++ if (iv_count == UIO_MAXIOV) ++ break; ++ length = scst_get_buf_next(cmd, ++ (uint8_t __force **)&address); ++ } ++ if (length == 0) { ++ finished = true; ++ if (unlikely(iv_count == 0)) ++ break; ++ } else if (unlikely(length < 0)) { ++ PRINT_ERROR("scst_get_buf_next() failed: %zd", length); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out_set_fs; ++ } ++ ++ TRACE_DBG("(iv_count %d, full_len %zd)", iv_count, full_len); ++ /* SEEK */ ++ if (fd->f_op->llseek) ++ err = fd->f_op->llseek(fd, loff, 0/*SEEK_SET*/); ++ else ++ err = default_llseek(fd, loff, 0/*SEEK_SET*/); ++ if (err != loff) { ++ PRINT_ERROR("lseek trouble %lld != %lld", ++ (long long unsigned int)err, ++ (long long unsigned int)loff); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out_set_fs; ++ } ++ ++ /* READ */ ++ err = vfs_readv(fd, (struct iovec __force __user *)iv, iv_count, ++ &fd->f_pos); ++ ++ if ((err < 0) || (err < full_len)) { ++ PRINT_ERROR("readv() returned %lld from %zd", ++ (long long unsigned int)err, ++ full_len); ++ if (err == -EAGAIN) ++ scst_set_busy(cmd); ++ else { ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_read_error)); ++ } ++ goto out_set_fs; ++ } ++ ++ for (i = 0; i < iv_count; i++) ++ scst_put_buf(cmd, (void __force *)(iv[i].iov_base)); ++ ++ if (finished) ++ break; ++ ++ loff += full_len; ++ length = scst_get_buf_next(cmd, (uint8_t __force **)&address); ++ }; ++ ++ set_fs(old_fs); ++ ++out: ++ TRACE_EXIT(); ++ return; ++ ++out_set_fs: ++ set_fs(old_fs); ++ for (i = 0; i < iv_count; i++) ++ scst_put_buf(cmd, (void __force *)(iv[i].iov_base)); ++ goto out; ++} ++ ++static void vdisk_exec_write(struct scst_cmd *cmd, ++ struct scst_vdisk_thr *thr, loff_t loff) ++{ ++ mm_segment_t old_fs; ++ loff_t err; ++ ssize_t length, full_len, saved_full_len; ++ uint8_t __user *address; ++ struct scst_vdisk_dev *virt_dev = cmd->dev->dh_priv; ++ struct file *fd = thr->fd; ++ struct iovec *iv, *eiv; ++ int i, iv_count, eiv_count; ++ bool finished = false; ++ ++ TRACE_ENTRY(); ++ ++ if (virt_dev->nullio) ++ goto out; ++ ++ iv = vdisk_alloc_iv(cmd, thr); ++ if (iv == NULL) ++ goto out; ++ ++ length = scst_get_buf_first(cmd, (uint8_t __force **)&address); ++ if (unlikely(length < 0)) { ++ PRINT_ERROR("scst_get_buf_first() failed: %zd", length); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out; ++ } ++ ++ old_fs = get_fs(); ++ set_fs(get_ds()); ++ ++ while (1) { ++ iv_count = 0; ++ full_len = 0; ++ i = -1; ++ while (length > 0) { ++ full_len += length; ++ i++; ++ iv_count++; ++ iv[i].iov_base = address; ++ iv[i].iov_len = length; ++ if (iv_count == UIO_MAXIOV) ++ break; ++ length = scst_get_buf_next(cmd, ++ (uint8_t __force **)&address); ++ } ++ if (length == 0) { ++ finished = true; ++ if (unlikely(iv_count == 0)) ++ break; ++ } else if (unlikely(length < 0)) { ++ PRINT_ERROR("scst_get_buf_next() failed: %zd", length); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out_set_fs; ++ } ++ ++ saved_full_len = full_len; ++ eiv = iv; ++ eiv_count = iv_count; ++restart: ++ TRACE_DBG("writing(eiv_count %d, full_len %zd)", eiv_count, full_len); ++ ++ /* SEEK */ ++ if (fd->f_op->llseek) ++ err = fd->f_op->llseek(fd, loff, 0 /*SEEK_SET */); ++ else ++ err = default_llseek(fd, loff, 0 /*SEEK_SET */); ++ if (err != loff) { ++ PRINT_ERROR("lseek trouble %lld != %lld", ++ (long long unsigned int)err, ++ (long long unsigned int)loff); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out_set_fs; ++ } ++ ++ /* WRITE */ ++ err = vfs_writev(fd, (struct iovec __force __user *)eiv, eiv_count, ++ &fd->f_pos); ++ ++ if (err < 0) { ++ PRINT_ERROR("write() returned %lld from %zd", ++ (long long unsigned int)err, ++ full_len); ++ if (err == -EAGAIN) ++ scst_set_busy(cmd); ++ else { ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_write_error)); ++ } ++ goto out_set_fs; ++ } else if (err < full_len) { ++ /* ++ * Probably that's wrong, but sometimes write() returns ++ * value less, than requested. Let's restart. ++ */ ++ int e = eiv_count; ++ TRACE_MGMT_DBG("write() returned %d from %zd " ++ "(iv_count=%d)", (int)err, full_len, ++ eiv_count); ++ if (err == 0) { ++ PRINT_INFO("Suspicious: write() returned 0 from " ++ "%zd (iv_count=%d)", full_len, eiv_count); ++ } ++ full_len -= err; ++ for (i = 0; i < e; i++) { ++ if ((long long)eiv->iov_len < err) { ++ err -= eiv->iov_len; ++ eiv++; ++ eiv_count--; ++ } else { ++ eiv->iov_base = ++ (uint8_t __force __user *)eiv->iov_base + err; ++ eiv->iov_len -= err; ++ break; ++ } ++ } ++ goto restart; ++ } ++ ++ for (i = 0; i < iv_count; i++) ++ scst_put_buf(cmd, (void __force *)(iv[i].iov_base)); ++ ++ if (finished) ++ break; ++ ++ loff += saved_full_len; ++ length = scst_get_buf_next(cmd, (uint8_t __force **)&address); ++ } ++ ++ set_fs(old_fs); ++ ++out: ++ TRACE_EXIT(); ++ return; ++ ++out_set_fs: ++ set_fs(old_fs); ++ for (i = 0; i < iv_count; i++) ++ scst_put_buf(cmd, (void __force *)(iv[i].iov_base)); ++ goto out; ++} ++ ++struct scst_blockio_work { ++ atomic_t bios_inflight; ++ struct scst_cmd *cmd; ++}; ++ ++static inline void blockio_check_finish(struct scst_blockio_work *blockio_work) ++{ ++ /* Decrement the bios in processing, and if zero signal completion */ ++ if (atomic_dec_and_test(&blockio_work->bios_inflight)) { ++ blockio_work->cmd->completed = 1; ++ blockio_work->cmd->scst_cmd_done(blockio_work->cmd, ++ SCST_CMD_STATE_DEFAULT, scst_estimate_context()); ++ kmem_cache_free(blockio_work_cachep, blockio_work); ++ } ++ return; ++} ++ ++static void blockio_endio(struct bio *bio, int error) ++{ ++ struct scst_blockio_work *blockio_work = bio->bi_private; ++ ++ if (unlikely(!bio_flagged(bio, BIO_UPTODATE))) { ++ if (error == 0) { ++ PRINT_ERROR("Not up to date bio with error 0 for " ++ "cmd %p, returning -EIO", blockio_work->cmd); ++ error = -EIO; ++ } ++ } ++ ++ if (unlikely(error != 0)) { ++ static DEFINE_SPINLOCK(blockio_endio_lock); ++ unsigned long flags; ++ ++ PRINT_ERROR("cmd %p returned error %d", blockio_work->cmd, ++ error); ++ ++ /* To protect from several bios finishing simultaneously */ ++ spin_lock_irqsave(&blockio_endio_lock, flags); ++ ++ if (bio->bi_rw & REQ_WRITE) ++ scst_set_cmd_error(blockio_work->cmd, ++ SCST_LOAD_SENSE(scst_sense_write_error)); ++ else ++ scst_set_cmd_error(blockio_work->cmd, ++ SCST_LOAD_SENSE(scst_sense_read_error)); ++ ++ spin_unlock_irqrestore(&blockio_endio_lock, flags); ++ } ++ ++ blockio_check_finish(blockio_work); ++ ++ bio_put(bio); ++ return; ++} ++ ++static void blockio_exec_rw(struct scst_cmd *cmd, struct scst_vdisk_thr *thr, ++ u64 lba_start, int write) ++{ ++ struct scst_vdisk_dev *virt_dev = cmd->dev->dh_priv; ++ struct block_device *bdev = thr->bdev; ++ struct request_queue *q = bdev_get_queue(bdev); ++ int length, max_nr_vecs = 0, offset; ++ struct page *page; ++ struct bio *bio = NULL, *hbio = NULL, *tbio = NULL; ++ int need_new_bio; ++ struct scst_blockio_work *blockio_work; ++ int bios = 0; ++ gfp_t gfp_mask = (cmd->noio_mem_alloc ? GFP_NOIO : GFP_KERNEL); ++ struct blk_plug plug; ++ ++ TRACE_ENTRY(); ++ ++ if (virt_dev->nullio) ++ goto out; ++ ++ /* Allocate and initialize blockio_work struct */ ++ blockio_work = kmem_cache_alloc(blockio_work_cachep, gfp_mask); ++ if (blockio_work == NULL) ++ goto out_no_mem; ++ ++ blockio_work->cmd = cmd; ++ ++ if (q) ++ max_nr_vecs = min(bio_get_nr_vecs(bdev), BIO_MAX_PAGES); ++ else ++ max_nr_vecs = 1; ++ ++ need_new_bio = 1; ++ ++ length = scst_get_sg_page_first(cmd, &page, &offset); ++ while (length > 0) { ++ int len, bytes, off, thislen; ++ struct page *pg; ++ u64 lba_start0; ++ ++ pg = page; ++ len = length; ++ off = offset; ++ thislen = 0; ++ lba_start0 = lba_start; ++ ++ while (len > 0) { ++ int rc; ++ ++ if (need_new_bio) { ++ bio = bio_kmalloc(gfp_mask, max_nr_vecs); ++ if (!bio) { ++ PRINT_ERROR("Failed to create bio " ++ "for data segment %d (cmd %p)", ++ cmd->get_sg_buf_entry_num, cmd); ++ goto out_no_bio; ++ } ++ ++ bios++; ++ need_new_bio = 0; ++ bio->bi_end_io = blockio_endio; ++ bio->bi_sector = lba_start0 << ++ (virt_dev->block_shift - 9); ++ bio->bi_bdev = bdev; ++ bio->bi_private = blockio_work; ++ /* ++ * Better to fail fast w/o any local recovery ++ * and retries. ++ */ ++ bio->bi_rw |= REQ_FAILFAST_DEV | ++ REQ_FAILFAST_TRANSPORT | ++ REQ_FAILFAST_DRIVER; ++#if 0 /* It could be win, but could be not, so a performance study is needed */ ++ bio->bi_rw |= REQ_SYNC; ++#endif ++ if (!hbio) ++ hbio = tbio = bio; ++ else ++ tbio = tbio->bi_next = bio; ++ } ++ ++ bytes = min_t(unsigned int, len, PAGE_SIZE - off); ++ ++ rc = bio_add_page(bio, pg, bytes, off); ++ if (rc < bytes) { ++ BUG_ON(rc != 0); ++ need_new_bio = 1; ++ lba_start0 += thislen >> virt_dev->block_shift; ++ thislen = 0; ++ continue; ++ } ++ ++ pg++; ++ thislen += bytes; ++ len -= bytes; ++ off = 0; ++ } ++ ++ lba_start += length >> virt_dev->block_shift; ++ ++ scst_put_sg_page(cmd, page, offset); ++ length = scst_get_sg_page_next(cmd, &page, &offset); ++ } ++ ++ /* +1 to prevent erroneous too early command completion */ ++ atomic_set(&blockio_work->bios_inflight, bios+1); ++ ++ blk_start_plug(&plug); ++ ++ while (hbio) { ++ bio = hbio; ++ hbio = hbio->bi_next; ++ bio->bi_next = NULL; ++ submit_bio((write != 0), bio); ++ } ++ ++ blk_finish_plug(&plug); ++ ++ blockio_check_finish(blockio_work); ++ ++out: ++ TRACE_EXIT(); ++ return; ++ ++out_no_bio: ++ while (hbio) { ++ bio = hbio; ++ hbio = hbio->bi_next; ++ bio_put(bio); ++ } ++ kmem_cache_free(blockio_work_cachep, blockio_work); ++ ++out_no_mem: ++ scst_set_busy(cmd); ++ goto out; ++} ++ ++static int vdisk_blockio_flush(struct block_device *bdev, gfp_t gfp_mask, ++ bool report_error) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ res = blkdev_issue_flush(bdev, gfp_mask, NULL); ++ if ((res != 0) && report_error) ++ PRINT_ERROR("blkdev_issue_flush() failed: %d", res); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void vdisk_exec_verify(struct scst_cmd *cmd, ++ struct scst_vdisk_thr *thr, loff_t loff) ++{ ++ mm_segment_t old_fs; ++ loff_t err; ++ ssize_t length, len_mem = 0; ++ uint8_t *address_sav, *address; ++ int compare; ++ struct scst_vdisk_dev *virt_dev = cmd->dev->dh_priv; ++ struct file *fd = thr->fd; ++ uint8_t *mem_verify = NULL; ++ ++ TRACE_ENTRY(); ++ ++ if (vdisk_fsync(thr, loff, cmd->bufflen, cmd, cmd->dev) != 0) ++ goto out; ++ ++ /* ++ * Until the cache is cleared prior the verifying, there is not ++ * much point in this code. ToDo. ++ * ++ * Nevertherless, this code is valuable if the data have not read ++ * from the file/disk yet. ++ */ ++ ++ /* SEEK */ ++ old_fs = get_fs(); ++ set_fs(get_ds()); ++ ++ if (!virt_dev->nullio) { ++ if (fd->f_op->llseek) ++ err = fd->f_op->llseek(fd, loff, 0/*SEEK_SET*/); ++ else ++ err = default_llseek(fd, loff, 0/*SEEK_SET*/); ++ if (err != loff) { ++ PRINT_ERROR("lseek trouble %lld != %lld", ++ (long long unsigned int)err, ++ (long long unsigned int)loff); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out_set_fs; ++ } ++ } ++ ++ mem_verify = vmalloc(LEN_MEM); ++ if (mem_verify == NULL) { ++ PRINT_ERROR("Unable to allocate memory %d for verify", ++ LEN_MEM); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out_set_fs; ++ } ++ ++ length = scst_get_buf_first(cmd, &address); ++ address_sav = address; ++ if (!length && cmd->data_len) { ++ length = cmd->data_len; ++ compare = 0; ++ } else ++ compare = 1; ++ ++ while (length > 0) { ++ len_mem = (length > LEN_MEM) ? LEN_MEM : length; ++ TRACE_DBG("Verify: length %zd - len_mem %zd", length, len_mem); ++ ++ if (!virt_dev->nullio) ++ err = vfs_read(fd, (char __force __user *)mem_verify, ++ len_mem, &fd->f_pos); ++ else ++ err = len_mem; ++ if ((err < 0) || (err < len_mem)) { ++ PRINT_ERROR("verify() returned %lld from %zd", ++ (long long unsigned int)err, len_mem); ++ if (err == -EAGAIN) ++ scst_set_busy(cmd); ++ else { ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_read_error)); ++ } ++ if (compare) ++ scst_put_buf(cmd, address_sav); ++ goto out_set_fs; ++ } ++ if (compare && memcmp(address, mem_verify, len_mem) != 0) { ++ TRACE_DBG("Verify: error memcmp length %zd", length); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_miscompare_error)); ++ scst_put_buf(cmd, address_sav); ++ goto out_set_fs; ++ } ++ length -= len_mem; ++ address += len_mem; ++ if (compare && length <= 0) { ++ scst_put_buf(cmd, address_sav); ++ length = scst_get_buf_next(cmd, &address); ++ address_sav = address; ++ } ++ } ++ ++ if (length < 0) { ++ PRINT_ERROR("scst_get_buf_() failed: %zd", length); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ } ++ ++out_set_fs: ++ set_fs(old_fs); ++ if (mem_verify) ++ vfree(mem_verify); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static int vdisk_task_mgmt_fn(struct scst_mgmt_cmd *mcmd, ++ struct scst_tgt_dev *tgt_dev) ++{ ++ TRACE_ENTRY(); ++ ++ if ((mcmd->fn == SCST_LUN_RESET) || (mcmd->fn == SCST_TARGET_RESET)) { ++ /* Restore default values */ ++ struct scst_device *dev = tgt_dev->dev; ++ struct scst_vdisk_dev *virt_dev = dev->dh_priv; ++ ++ dev->tst = DEF_TST; ++ dev->d_sense = DEF_DSENSE; ++ if (virt_dev->wt_flag && !virt_dev->nv_cache) ++ dev->queue_alg = DEF_QUEUE_ALG_WT; ++ else ++ dev->queue_alg = DEF_QUEUE_ALG; ++ dev->swp = DEF_SWP; ++ dev->tas = DEF_TAS; ++ ++ spin_lock(&virt_dev->flags_lock); ++ virt_dev->prevent_allow_medium_removal = 0; ++ spin_unlock(&virt_dev->flags_lock); ++ } else if (mcmd->fn == SCST_PR_ABORT_ALL) { ++ struct scst_device *dev = tgt_dev->dev; ++ struct scst_vdisk_dev *virt_dev = dev->dh_priv; ++ spin_lock(&virt_dev->flags_lock); ++ virt_dev->prevent_allow_medium_removal = 0; ++ spin_unlock(&virt_dev->flags_lock); ++ } ++ ++ TRACE_EXIT(); ++ return SCST_DEV_TM_NOT_COMPLETED; ++} ++ ++static void vdisk_report_registering(const struct scst_vdisk_dev *virt_dev) ++{ ++ char buf[128]; ++ int i, j; ++ ++ i = snprintf(buf, sizeof(buf), "Registering virtual %s device %s ", ++ virt_dev->vdev_devt->name, virt_dev->name); ++ j = i; ++ ++ if (virt_dev->wt_flag) ++ i += snprintf(&buf[i], sizeof(buf) - i, "(WRITE_THROUGH"); ++ ++ if (virt_dev->nv_cache) ++ i += snprintf(&buf[i], sizeof(buf) - i, "%sNV_CACHE", ++ (j == i) ? "(" : ", "); ++ ++ if (virt_dev->rd_only) ++ i += snprintf(&buf[i], sizeof(buf) - i, "%sREAD_ONLY", ++ (j == i) ? "(" : ", "); ++ ++ if (virt_dev->o_direct_flag) ++ i += snprintf(&buf[i], sizeof(buf) - i, "%sO_DIRECT", ++ (j == i) ? "(" : ", "); ++ ++ if (virt_dev->nullio) ++ i += snprintf(&buf[i], sizeof(buf) - i, "%sNULLIO", ++ (j == i) ? "(" : ", "); ++ ++ if (virt_dev->blockio) ++ i += snprintf(&buf[i], sizeof(buf) - i, "%sBLOCKIO", ++ (j == i) ? "(" : ", "); ++ ++ if (virt_dev->removable) ++ i += snprintf(&buf[i], sizeof(buf) - i, "%sREMOVABLE", ++ (j == i) ? "(" : ", "); ++ ++ if (virt_dev->thin_provisioned) ++ i += snprintf(&buf[i], sizeof(buf) - i, "%sTHIN PROVISIONED", ++ (j == i) ? "(" : ", "); ++ ++ if (j == i) ++ PRINT_INFO("%s", buf); ++ else ++ PRINT_INFO("%s)", buf); ++ ++ return; ++} ++ ++static int vdisk_resync_size(struct scst_vdisk_dev *virt_dev) ++{ ++ loff_t file_size; ++ int res = 0; ++ ++ BUG_ON(virt_dev->nullio); ++ ++ res = vdisk_get_file_size(virt_dev->filename, ++ virt_dev->blockio, &file_size); ++ if (res != 0) ++ goto out; ++ ++ if (file_size == virt_dev->file_size) { ++ PRINT_INFO("Size of virtual disk %s remained the same", ++ virt_dev->name); ++ goto out; ++ } ++ ++ res = scst_suspend_activity(true); ++ if (res != 0) ++ goto out; ++ ++ virt_dev->file_size = file_size; ++ virt_dev->nblocks = virt_dev->file_size >> virt_dev->block_shift; ++ ++ scst_dev_del_all_thr_data(virt_dev->dev); ++ ++ PRINT_INFO("New size of SCSI target virtual disk %s " ++ "(fs=%lldMB, bs=%d, nblocks=%lld, cyln=%lld%s)", ++ virt_dev->name, virt_dev->file_size >> 20, ++ virt_dev->block_size, ++ (long long unsigned int)virt_dev->nblocks, ++ (long long unsigned int)virt_dev->nblocks/64/32, ++ virt_dev->nblocks < 64*32 ? " !WARNING! cyln less " ++ "than 1" : ""); ++ ++ scst_capacity_data_changed(virt_dev->dev); ++ ++ scst_resume_activity(); ++ ++out: ++ return res; ++} ++ ++static int vdev_create(struct scst_dev_type *devt, ++ const char *name, struct scst_vdisk_dev **res_virt_dev) ++{ ++ int res; ++ struct scst_vdisk_dev *virt_dev; ++ uint64_t dev_id_num; ++ ++ res = -EEXIST; ++ if (vdev_find(name)) ++ goto out; ++ ++ virt_dev = kzalloc(sizeof(*virt_dev), GFP_KERNEL); ++ if (virt_dev == NULL) { ++ PRINT_ERROR("Allocation of virtual device %s failed", ++ devt->name); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ spin_lock_init(&virt_dev->flags_lock); ++ virt_dev->vdev_devt = devt; ++ ++ virt_dev->rd_only = DEF_RD_ONLY; ++ virt_dev->removable = DEF_REMOVABLE; ++ virt_dev->thin_provisioned = DEF_THIN_PROVISIONED; ++ ++ virt_dev->block_size = DEF_DISK_BLOCKSIZE; ++ virt_dev->block_shift = DEF_DISK_BLOCKSIZE_SHIFT; ++ ++ if (strlen(name) >= sizeof(virt_dev->name)) { ++ PRINT_ERROR("Name %s is too long (max allowed %zd)", name, ++ sizeof(virt_dev->name)-1); ++ res = -EINVAL; ++ goto out_free; ++ } ++ strcpy(virt_dev->name, name); ++ ++ dev_id_num = vdisk_gen_dev_id_num(virt_dev->name); ++ ++ snprintf(virt_dev->t10_dev_id, sizeof(virt_dev->t10_dev_id), ++ "%llx-%s", dev_id_num, virt_dev->name); ++ TRACE_DBG("t10_dev_id %s", virt_dev->t10_dev_id); ++ ++ scnprintf(virt_dev->usn, sizeof(virt_dev->usn), "%llx", dev_id_num); ++ TRACE_DBG("usn %s", virt_dev->usn); ++ ++ *res_virt_dev = virt_dev; ++ res = 0; ++ ++out: ++ return res; ++ ++out_free: ++ kfree(virt_dev); ++ goto out; ++} ++ ++static void vdev_destroy(struct scst_vdisk_dev *virt_dev) ++{ ++ kfree(virt_dev->filename); ++ kfree(virt_dev); ++ return; ++} ++ ++static int vdev_parse_add_dev_params(struct scst_vdisk_dev *virt_dev, ++ char *params, const char *allowed_params[]) ++{ ++ int res = 0; ++ unsigned long val; ++ char *param, *p, *pp; ++ ++ TRACE_ENTRY(); ++ ++ while (1) { ++ param = scst_get_next_token_str(¶ms); ++ if (param == NULL) ++ break; ++ ++ p = scst_get_next_lexem(¶m); ++ if (*p == '\0') { ++ PRINT_ERROR("Syntax error at %s (device %s)", ++ param, virt_dev->name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (allowed_params != NULL) { ++ const char **a = allowed_params; ++ bool allowed = false; ++ ++ while (*a != NULL) { ++ if (!strcasecmp(*a, p)) { ++ allowed = true; ++ break; ++ } ++ a++; ++ } ++ ++ if (!allowed) { ++ PRINT_ERROR("Unknown parameter %s (device %s)", p, ++ virt_dev->name); ++ res = -EINVAL; ++ goto out; ++ } ++ } ++ ++ pp = scst_get_next_lexem(¶m); ++ if (*pp == '\0') { ++ PRINT_ERROR("Parameter %s value missed for device %s", ++ p, virt_dev->name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (scst_get_next_lexem(¶m)[0] != '\0') { ++ PRINT_ERROR("Too many parameter's %s values (device %s)", ++ p, virt_dev->name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (!strcasecmp("filename", p)) { ++ if (*pp != '/') { ++ PRINT_ERROR("Filename %s must be global " ++ "(device %s)", pp, virt_dev->name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ virt_dev->filename = kstrdup(pp, GFP_KERNEL); ++ if (virt_dev->filename == NULL) { ++ PRINT_ERROR("Unable to duplicate file name %s " ++ "(device %s)", pp, virt_dev->name); ++ res = -ENOMEM; ++ goto out; ++ } ++ continue; ++ } ++ ++ res = strict_strtoul(pp, 0, &val); ++ if (res != 0) { ++ PRINT_ERROR("strict_strtoul() for %s failed: %d " ++ "(device %s)", pp, res, virt_dev->name); ++ goto out; ++ } ++ ++ if (!strcasecmp("write_through", p)) { ++ virt_dev->wt_flag = val; ++ TRACE_DBG("WRITE THROUGH %d", virt_dev->wt_flag); ++ } else if (!strcasecmp("nv_cache", p)) { ++ virt_dev->nv_cache = val; ++ TRACE_DBG("NON-VOLATILE CACHE %d", virt_dev->nv_cache); ++ } else if (!strcasecmp("o_direct", p)) { ++#if 0 ++ virt_dev->o_direct_flag = val; ++ TRACE_DBG("O_DIRECT %d", virt_dev->o_direct_flag); ++#else ++ PRINT_INFO("O_DIRECT flag doesn't currently" ++ " work, ignoring it, use fileio_tgt " ++ "in O_DIRECT mode instead (device %s)", virt_dev->name); ++#endif ++ } else if (!strcasecmp("read_only", p)) { ++ virt_dev->rd_only = val; ++ TRACE_DBG("READ ONLY %d", virt_dev->rd_only); ++ } else if (!strcasecmp("removable", p)) { ++ virt_dev->removable = val; ++ TRACE_DBG("REMOVABLE %d", virt_dev->removable); ++ } else if (!strcasecmp("thin_provisioned", p)) { ++ virt_dev->thin_provisioned = val; ++ TRACE_DBG("THIN PROVISIONED %d", ++ virt_dev->thin_provisioned); ++ } else if (!strcasecmp("blocksize", p)) { ++ virt_dev->block_size = val; ++ virt_dev->block_shift = scst_calc_block_shift( ++ virt_dev->block_size); ++ if (virt_dev->block_shift < 9) { ++ res = -EINVAL; ++ goto out; ++ } ++ TRACE_DBG("block_size %d, block_shift %d", ++ virt_dev->block_size, ++ virt_dev->block_shift); ++ } else { ++ PRINT_ERROR("Unknown parameter %s (device %s)", p, ++ virt_dev->name); ++ res = -EINVAL; ++ goto out; ++ } ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* scst_vdisk_mutex supposed to be held */ ++static int vdev_fileio_add_device(const char *device_name, char *params) ++{ ++ int res = 0; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ res = vdev_create(&vdisk_file_devtype, device_name, &virt_dev); ++ if (res != 0) ++ goto out; ++ ++ virt_dev->command_set_version = 0x04C0; /* SBC-3 */ ++ ++ virt_dev->wt_flag = DEF_WRITE_THROUGH; ++ virt_dev->nv_cache = DEF_NV_CACHE; ++ virt_dev->o_direct_flag = DEF_O_DIRECT; ++ ++ res = vdev_parse_add_dev_params(virt_dev, params, NULL); ++ if (res != 0) ++ goto out_destroy; ++ ++ if (virt_dev->rd_only && (virt_dev->wt_flag || virt_dev->nv_cache)) { ++ PRINT_ERROR("Write options on read only device %s", ++ virt_dev->name); ++ res = -EINVAL; ++ goto out_destroy; ++ } ++ ++ if (virt_dev->filename == NULL) { ++ PRINT_ERROR("File name required (device %s)", virt_dev->name); ++ res = -EINVAL; ++ goto out_destroy; ++ } ++ ++ list_add_tail(&virt_dev->vdev_list_entry, &vdev_list); ++ ++ vdisk_report_registering(virt_dev); ++ ++ virt_dev->virt_id = scst_register_virtual_device(virt_dev->vdev_devt, ++ virt_dev->name); ++ if (virt_dev->virt_id < 0) { ++ res = virt_dev->virt_id; ++ goto out_del; ++ } ++ ++ TRACE_DBG("Registered virt_dev %s with id %d", virt_dev->name, ++ virt_dev->virt_id); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_del: ++ list_del(&virt_dev->vdev_list_entry); ++ ++out_destroy: ++ vdev_destroy(virt_dev); ++ goto out; ++} ++ ++/* scst_vdisk_mutex supposed to be held */ ++static int vdev_blockio_add_device(const char *device_name, char *params) ++{ ++ int res = 0; ++ const char *allowed_params[] = { "filename", "read_only", "removable", ++ "blocksize", "nv_cache", ++ "thin_provisioned", NULL }; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ res = vdev_create(&vdisk_blk_devtype, device_name, &virt_dev); ++ if (res != 0) ++ goto out; ++ ++ virt_dev->command_set_version = 0x04C0; /* SBC-3 */ ++ ++ virt_dev->blockio = 1; ++ ++ res = vdev_parse_add_dev_params(virt_dev, params, allowed_params); ++ if (res != 0) ++ goto out_destroy; ++ ++ if (virt_dev->filename == NULL) { ++ PRINT_ERROR("File name required (device %s)", virt_dev->name); ++ res = -EINVAL; ++ goto out_destroy; ++ } ++ ++ list_add_tail(&virt_dev->vdev_list_entry, &vdev_list); ++ ++ vdisk_report_registering(virt_dev); ++ ++ virt_dev->virt_id = scst_register_virtual_device(virt_dev->vdev_devt, ++ virt_dev->name); ++ if (virt_dev->virt_id < 0) { ++ res = virt_dev->virt_id; ++ goto out_del; ++ } ++ ++ TRACE_DBG("Registered virt_dev %s with id %d", virt_dev->name, ++ virt_dev->virt_id); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_del: ++ list_del(&virt_dev->vdev_list_entry); ++ ++out_destroy: ++ vdev_destroy(virt_dev); ++ goto out; ++} ++ ++/* scst_vdisk_mutex supposed to be held */ ++static int vdev_nullio_add_device(const char *device_name, char *params) ++{ ++ int res = 0; ++ const char *allowed_params[] = { "read_only", "removable", ++ "blocksize", NULL }; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ res = vdev_create(&vdisk_null_devtype, device_name, &virt_dev); ++ if (res != 0) ++ goto out; ++ ++ virt_dev->command_set_version = 0x04C0; /* SBC-3 */ ++ ++ virt_dev->nullio = 1; ++ ++ res = vdev_parse_add_dev_params(virt_dev, params, allowed_params); ++ if (res != 0) ++ goto out_destroy; ++ ++ list_add_tail(&virt_dev->vdev_list_entry, &vdev_list); ++ ++ vdisk_report_registering(virt_dev); ++ ++ virt_dev->virt_id = scst_register_virtual_device(virt_dev->vdev_devt, ++ virt_dev->name); ++ if (virt_dev->virt_id < 0) { ++ res = virt_dev->virt_id; ++ goto out_del; ++ } ++ ++ TRACE_DBG("Registered virt_dev %s with id %d", virt_dev->name, ++ virt_dev->virt_id); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_del: ++ list_del(&virt_dev->vdev_list_entry); ++ ++out_destroy: ++ vdev_destroy(virt_dev); ++ goto out; ++} ++ ++static ssize_t vdisk_add_fileio_device(const char *device_name, char *params) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ if (mutex_lock_interruptible(&scst_vdisk_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ ++ res = vdev_fileio_add_device(device_name, params); ++ ++ mutex_unlock(&scst_vdisk_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t vdisk_add_blockio_device(const char *device_name, char *params) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ if (mutex_lock_interruptible(&scst_vdisk_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ ++ res = vdev_blockio_add_device(device_name, params); ++ ++ mutex_unlock(&scst_vdisk_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++} ++ ++static ssize_t vdisk_add_nullio_device(const char *device_name, char *params) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ if (mutex_lock_interruptible(&scst_vdisk_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ ++ res = vdev_nullio_add_device(device_name, params); ++ ++ mutex_unlock(&scst_vdisk_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++} ++ ++/* scst_vdisk_mutex supposed to be held */ ++static void vdev_del_device(struct scst_vdisk_dev *virt_dev) ++{ ++ TRACE_ENTRY(); ++ ++ scst_unregister_virtual_device(virt_dev->virt_id); ++ ++ list_del(&virt_dev->vdev_list_entry); ++ ++ PRINT_INFO("Virtual device %s unregistered", virt_dev->name); ++ TRACE_DBG("virt_id %d unregistered", virt_dev->virt_id); ++ ++ vdev_destroy(virt_dev); ++ ++ return; ++} ++ ++static ssize_t vdisk_del_device(const char *device_name) ++{ ++ int res = 0; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ if (mutex_lock_interruptible(&scst_vdisk_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ ++ virt_dev = vdev_find(device_name); ++ if (virt_dev == NULL) { ++ PRINT_ERROR("Device %s not found", device_name); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++ vdev_del_device(virt_dev); ++ ++out_unlock: ++ mutex_unlock(&scst_vdisk_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* scst_vdisk_mutex supposed to be held */ ++static ssize_t __vcdrom_add_device(const char *device_name, char *params) ++{ ++ int res = 0; ++ const char *allowed_params[] = { NULL }; /* no params */ ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ res = vdev_create(&vcdrom_devtype, device_name, &virt_dev); ++ if (res != 0) ++ goto out; ++ ++#if 0 /* ++ * Our implementation is pretty minimalistic and doesn't support all ++ * mandatory commands, so it's better to not claim any standard ++ * confirmance. ++ */ ++ virt_dev->command_set_version = 0x02A0; /* MMC-3 */ ++#endif ++ ++ virt_dev->rd_only = 1; ++ virt_dev->removable = 1; ++ virt_dev->cdrom_empty = 1; ++ ++ virt_dev->block_size = DEF_CDROM_BLOCKSIZE; ++ virt_dev->block_shift = DEF_CDROM_BLOCKSIZE_SHIFT; ++ ++ res = vdev_parse_add_dev_params(virt_dev, params, allowed_params); ++ if (res != 0) ++ goto out_destroy; ++ ++ list_add_tail(&virt_dev->vdev_list_entry, &vdev_list); ++ ++ vdisk_report_registering(virt_dev); ++ ++ virt_dev->virt_id = scst_register_virtual_device(virt_dev->vdev_devt, ++ virt_dev->name); ++ if (virt_dev->virt_id < 0) { ++ res = virt_dev->virt_id; ++ goto out_del; ++ } ++ ++ TRACE_DBG("Registered virt_dev %s with id %d", virt_dev->name, ++ virt_dev->virt_id); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_del: ++ list_del(&virt_dev->vdev_list_entry); ++ ++out_destroy: ++ vdev_destroy(virt_dev); ++ goto out; ++} ++ ++static ssize_t vcdrom_add_device(const char *device_name, char *params) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ if (mutex_lock_interruptible(&scst_vdisk_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ ++ res = __vcdrom_add_device(device_name, params); ++ ++ mutex_unlock(&scst_vdisk_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++} ++ ++static ssize_t vcdrom_del_device(const char *device_name) ++{ ++ int res = 0; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ if (mutex_lock_interruptible(&scst_vdisk_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ ++ virt_dev = vdev_find(device_name); ++ if (virt_dev == NULL) { ++ PRINT_ERROR("Device %s not found", device_name); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++ vdev_del_device(virt_dev); ++ ++out_unlock: ++ mutex_unlock(&scst_vdisk_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int vcdrom_change(struct scst_vdisk_dev *virt_dev, ++ char *buffer) ++{ ++ loff_t err; ++ char *old_fn, *p, *pp; ++ const char *filename = NULL; ++ int length = strlen(buffer); ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ p = buffer; ++ ++ while (isspace(*p) && *p != '\0') ++ p++; ++ filename = p; ++ p = &buffer[length-1]; ++ pp = &buffer[length]; ++ while (isspace(*p) && (*p != '\0')) { ++ pp = p; ++ p--; ++ } ++ *pp = '\0'; ++ ++ res = scst_suspend_activity(true); ++ if (res != 0) ++ goto out; ++ ++ /* To sync with detach*() functions */ ++ mutex_lock(&scst_mutex); ++ ++ if (*filename == '\0') { ++ virt_dev->cdrom_empty = 1; ++ TRACE_DBG("%s", "No media"); ++ } else if (*filename != '/') { ++ PRINT_ERROR("File path \"%s\" is not absolute", filename); ++ res = -EINVAL; ++ goto out_unlock; ++ } else ++ virt_dev->cdrom_empty = 0; ++ ++ old_fn = virt_dev->filename; ++ ++ if (!virt_dev->cdrom_empty) { ++ char *fn = kstrdup(filename, GFP_KERNEL); ++ if (fn == NULL) { ++ PRINT_ERROR("%s", "Allocation of filename failed"); ++ res = -ENOMEM; ++ goto out_unlock; ++ } ++ ++ virt_dev->filename = fn; ++ ++ res = vdisk_get_file_size(virt_dev->filename, ++ virt_dev->blockio, &err); ++ if (res != 0) ++ goto out_free_fn; ++ } else { ++ err = 0; ++ virt_dev->filename = NULL; ++ } ++ ++ if (virt_dev->prevent_allow_medium_removal) { ++ PRINT_ERROR("Prevent medium removal for " ++ "virtual device with name %s", virt_dev->name); ++ res = -EINVAL; ++ goto out_free_fn; ++ } ++ ++ virt_dev->file_size = err; ++ virt_dev->nblocks = virt_dev->file_size >> virt_dev->block_shift; ++ if (!virt_dev->cdrom_empty) ++ virt_dev->media_changed = 1; ++ ++ mutex_unlock(&scst_mutex); ++ ++ scst_dev_del_all_thr_data(virt_dev->dev); ++ ++ if (!virt_dev->cdrom_empty) { ++ PRINT_INFO("Changed SCSI target virtual cdrom %s " ++ "(file=\"%s\", fs=%lldMB, bs=%d, nblocks=%lld," ++ " cyln=%lld%s)", virt_dev->name, ++ vdev_get_filename(virt_dev), ++ virt_dev->file_size >> 20, virt_dev->block_size, ++ (long long unsigned int)virt_dev->nblocks, ++ (long long unsigned int)virt_dev->nblocks/64/32, ++ virt_dev->nblocks < 64*32 ? " !WARNING! cyln less " ++ "than 1" : ""); ++ } else { ++ PRINT_INFO("Removed media from SCSI target virtual cdrom %s", ++ virt_dev->name); ++ } ++ ++ kfree(old_fn); ++ ++out_resume: ++ scst_resume_activity(); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free_fn: ++ kfree(virt_dev->filename); ++ virt_dev->filename = old_fn; ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ goto out_resume; ++} ++ ++static int vcdrom_sysfs_process_filename_store(struct scst_sysfs_work_item *work) ++{ ++ int res; ++ struct scst_device *dev = work->dev; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ /* It's safe, since we taken dev_kobj and dh_priv NULLed in attach() */ ++ virt_dev = dev->dh_priv; ++ ++ res = vcdrom_change(virt_dev, work->buf); ++ ++ kobject_put(&dev->dev_kobj); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t vcdrom_sysfs_filename_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ char *i_buf; ++ struct scst_sysfs_work_item *work; ++ struct scst_device *dev; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ ++ i_buf = kasprintf(GFP_KERNEL, "%.*s", (int)count, buf); ++ if (i_buf == NULL) { ++ PRINT_ERROR("Unable to alloc intermediate buffer with size %zd", ++ count+1); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ res = scst_alloc_sysfs_work(vcdrom_sysfs_process_filename_store, ++ false, &work); ++ if (res != 0) ++ goto out_free; ++ ++ work->buf = i_buf; ++ work->dev = dev; ++ ++ kobject_get(&dev->dev_kobj); ++ ++ res = scst_sysfs_queue_wait_work(work); ++ if (res == 0) ++ res = count; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free: ++ kfree(i_buf); ++ goto out; ++} ++ ++static ssize_t vdev_sysfs_size_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos = 0; ++ struct scst_device *dev; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ virt_dev = dev->dh_priv; ++ ++ pos = sprintf(buf, "%lld\n", virt_dev->file_size / 1024 / 1024); ++ ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static ssize_t vdisk_sysfs_blocksize_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos = 0; ++ struct scst_device *dev; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ virt_dev = dev->dh_priv; ++ ++ pos = sprintf(buf, "%d\n%s", (int)virt_dev->block_size, ++ (virt_dev->block_size == DEF_DISK_BLOCKSIZE) ? "" : ++ SCST_SYSFS_KEY_MARK "\n"); ++ ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static ssize_t vdisk_sysfs_rd_only_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos = 0; ++ struct scst_device *dev; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ virt_dev = dev->dh_priv; ++ ++ pos = sprintf(buf, "%d\n%s", virt_dev->rd_only ? 1 : 0, ++ (virt_dev->rd_only == DEF_RD_ONLY) ? "" : ++ SCST_SYSFS_KEY_MARK "\n"); ++ ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static ssize_t vdisk_sysfs_wt_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos = 0; ++ struct scst_device *dev; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ virt_dev = dev->dh_priv; ++ ++ pos = sprintf(buf, "%d\n%s", virt_dev->wt_flag ? 1 : 0, ++ (virt_dev->wt_flag == DEF_WRITE_THROUGH) ? "" : ++ SCST_SYSFS_KEY_MARK "\n"); ++ ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static ssize_t vdisk_sysfs_tp_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos = 0; ++ struct scst_device *dev; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ virt_dev = dev->dh_priv; ++ ++ pos = sprintf(buf, "%d\n%s", virt_dev->thin_provisioned ? 1 : 0, ++ (virt_dev->thin_provisioned == DEF_THIN_PROVISIONED) ? "" : ++ SCST_SYSFS_KEY_MARK "\n"); ++ ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static ssize_t vdisk_sysfs_nv_cache_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos = 0; ++ struct scst_device *dev; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ virt_dev = dev->dh_priv; ++ ++ pos = sprintf(buf, "%d\n%s", virt_dev->nv_cache ? 1 : 0, ++ (virt_dev->nv_cache == DEF_NV_CACHE) ? "" : ++ SCST_SYSFS_KEY_MARK "\n"); ++ ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static ssize_t vdisk_sysfs_o_direct_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos = 0; ++ struct scst_device *dev; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ virt_dev = dev->dh_priv; ++ ++ pos = sprintf(buf, "%d\n%s", virt_dev->o_direct_flag ? 1 : 0, ++ (virt_dev->o_direct_flag == DEF_O_DIRECT) ? "" : ++ SCST_SYSFS_KEY_MARK "\n"); ++ ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static ssize_t vdisk_sysfs_removable_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos = 0; ++ struct scst_device *dev; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ virt_dev = dev->dh_priv; ++ ++ pos = sprintf(buf, "%d\n", virt_dev->removable ? 1 : 0); ++ ++ if ((virt_dev->dev->type != TYPE_ROM) && ++ (virt_dev->removable != DEF_REMOVABLE)) ++ pos += sprintf(&buf[pos], "%s\n", SCST_SYSFS_KEY_MARK); ++ ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static int vdev_sysfs_process_get_filename(struct scst_sysfs_work_item *work) ++{ ++ int res = 0; ++ struct scst_device *dev; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ dev = work->dev; ++ ++ /* ++ * Since we have a get() on dev->dev_kobj, we can not simply mutex_lock ++ * scst_vdisk_mutex, because otherwise we can fall in a deadlock with ++ * vdisk_del_device(), which is waiting for the last ref to dev_kobj ++ * under scst_vdisk_mutex. ++ */ ++ while (!mutex_trylock(&scst_vdisk_mutex)) { ++ if ((volatile bool)(dev->dev_unregistering)) { ++ TRACE_MGMT_DBG("Skipping being unregistered dev %s", ++ dev->virt_name); ++ res = -ENOENT; ++ goto out_put; ++ } ++ if (signal_pending(current)) { ++ res = -EINTR; ++ goto out_put; ++ } ++ msleep(100); ++ } ++ ++ virt_dev = dev->dh_priv; ++ ++ if (virt_dev == NULL) ++ goto out_unlock; ++ ++ if (virt_dev->filename != NULL) ++ work->res_buf = kasprintf(GFP_KERNEL, "%s\n%s\n", ++ vdev_get_filename(virt_dev), SCST_SYSFS_KEY_MARK); ++ else ++ work->res_buf = kasprintf(GFP_KERNEL, "%s\n", ++ vdev_get_filename(virt_dev)); ++ ++out_unlock: ++ mutex_unlock(&scst_vdisk_mutex); ++ ++out_put: ++ kobject_put(&dev->dev_kobj); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t vdev_sysfs_filename_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int res = 0; ++ struct scst_device *dev; ++ struct scst_sysfs_work_item *work; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ ++ res = scst_alloc_sysfs_work(vdev_sysfs_process_get_filename, ++ true, &work); ++ if (res != 0) ++ goto out; ++ ++ work->dev = dev; ++ ++ kobject_get(&dev->dev_kobj); ++ ++ scst_sysfs_work_get(work); ++ ++ res = scst_sysfs_queue_wait_work(work); ++ if (res != 0) ++ goto out_put; ++ ++ res = snprintf(buf, SCST_SYSFS_BLOCK_SIZE, "%s\n", work->res_buf); ++ ++out_put: ++ scst_sysfs_work_put(work); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int vdisk_sysfs_process_resync_size_store( ++ struct scst_sysfs_work_item *work) ++{ ++ int res; ++ struct scst_device *dev = work->dev; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ /* It's safe, since we taken dev_kobj and dh_priv NULLed in attach() */ ++ virt_dev = dev->dh_priv; ++ ++ res = vdisk_resync_size(virt_dev); ++ ++ kobject_put(&dev->dev_kobj); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t vdisk_sysfs_resync_size_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ struct scst_device *dev; ++ struct scst_sysfs_work_item *work; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ ++ res = scst_alloc_sysfs_work(vdisk_sysfs_process_resync_size_store, ++ false, &work); ++ if (res != 0) ++ goto out; ++ ++ work->dev = dev; ++ ++ kobject_get(&dev->dev_kobj); ++ ++ res = scst_sysfs_queue_wait_work(work); ++ if (res == 0) ++ res = count; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t vdev_sysfs_t10_dev_id_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res, i; ++ struct scst_device *dev; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ virt_dev = dev->dh_priv; ++ ++ write_lock(&vdisk_serial_rwlock); ++ ++ if ((count > sizeof(virt_dev->t10_dev_id)) || ++ ((count == sizeof(virt_dev->t10_dev_id)) && ++ (buf[count-1] != '\n'))) { ++ PRINT_ERROR("T10 device id is too long (max %zd " ++ "characters)", sizeof(virt_dev->t10_dev_id)-1); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++ memset(virt_dev->t10_dev_id, 0, sizeof(virt_dev->t10_dev_id)); ++ memcpy(virt_dev->t10_dev_id, buf, count); ++ ++ i = 0; ++ while (i < sizeof(virt_dev->t10_dev_id)) { ++ if (virt_dev->t10_dev_id[i] == '\n') { ++ virt_dev->t10_dev_id[i] = '\0'; ++ break; ++ } ++ i++; ++ } ++ ++ virt_dev->t10_dev_id_set = 1; ++ ++ res = count; ++ ++ PRINT_INFO("T10 device id for device %s changed to %s", virt_dev->name, ++ virt_dev->t10_dev_id); ++ ++out_unlock: ++ write_unlock(&vdisk_serial_rwlock); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t vdev_sysfs_t10_dev_id_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos = 0; ++ struct scst_device *dev; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ virt_dev = dev->dh_priv; ++ ++ read_lock(&vdisk_serial_rwlock); ++ pos = sprintf(buf, "%s\n%s", virt_dev->t10_dev_id, ++ virt_dev->t10_dev_id_set ? SCST_SYSFS_KEY_MARK "\n" : ""); ++ read_unlock(&vdisk_serial_rwlock); ++ ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static ssize_t vdev_sysfs_usn_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res, i; ++ struct scst_device *dev; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ virt_dev = dev->dh_priv; ++ ++ write_lock(&vdisk_serial_rwlock); ++ ++ if ((count > sizeof(virt_dev->usn)) || ++ ((count == sizeof(virt_dev->usn)) && ++ (buf[count-1] != '\n'))) { ++ PRINT_ERROR("USN is too long (max %zd " ++ "characters)", sizeof(virt_dev->usn)-1); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++ memset(virt_dev->usn, 0, sizeof(virt_dev->usn)); ++ memcpy(virt_dev->usn, buf, count); ++ ++ i = 0; ++ while (i < sizeof(virt_dev->usn)) { ++ if (virt_dev->usn[i] == '\n') { ++ virt_dev->usn[i] = '\0'; ++ break; ++ } ++ i++; ++ } ++ ++ virt_dev->usn_set = 1; ++ ++ res = count; ++ ++ PRINT_INFO("USN for device %s changed to %s", virt_dev->name, ++ virt_dev->usn); ++ ++out_unlock: ++ write_unlock(&vdisk_serial_rwlock); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t vdev_sysfs_usn_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos = 0; ++ struct scst_device *dev; ++ struct scst_vdisk_dev *virt_dev; ++ ++ TRACE_ENTRY(); ++ ++ dev = container_of(kobj, struct scst_device, dev_kobj); ++ virt_dev = dev->dh_priv; ++ ++ read_lock(&vdisk_serial_rwlock); ++ pos = sprintf(buf, "%s\n%s", virt_dev->usn, ++ virt_dev->usn_set ? SCST_SYSFS_KEY_MARK "\n" : ""); ++ read_unlock(&vdisk_serial_rwlock); ++ ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static int __init init_scst_vdisk(struct scst_dev_type *devtype) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ devtype->module = THIS_MODULE; ++ ++ res = scst_register_virtual_dev_driver(devtype); ++ if (res < 0) ++ goto out; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++} ++ ++static void exit_scst_vdisk(struct scst_dev_type *devtype) ++{ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_vdisk_mutex); ++ while (1) { ++ struct scst_vdisk_dev *virt_dev; ++ ++ if (list_empty(&vdev_list)) ++ break; ++ ++ virt_dev = list_entry(vdev_list.next, typeof(*virt_dev), ++ vdev_list_entry); ++ ++ vdev_del_device(virt_dev); ++ } ++ mutex_unlock(&scst_vdisk_mutex); ++ ++ scst_unregister_virtual_dev_driver(devtype); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int __init init_scst_vdisk_driver(void) ++{ ++ int res; ++ ++ vdisk_thr_cachep = KMEM_CACHE(scst_vdisk_thr, SCST_SLAB_FLAGS); ++ if (vdisk_thr_cachep == NULL) { ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ blockio_work_cachep = KMEM_CACHE(scst_blockio_work, SCST_SLAB_FLAGS); ++ if (blockio_work_cachep == NULL) { ++ res = -ENOMEM; ++ goto out_free_vdisk_cache; ++ } ++ ++ if (num_threads < 1) { ++ PRINT_ERROR("num_threads can not be less than 1, use " ++ "default %d", DEF_NUM_THREADS); ++ num_threads = DEF_NUM_THREADS; ++ } ++ ++ vdisk_file_devtype.threads_num = num_threads; ++ vcdrom_devtype.threads_num = num_threads; ++ ++ atomic_set(&nullio_thr_data.hdr.ref, 1); /* never destroy it */ ++ ++ res = init_scst_vdisk(&vdisk_file_devtype); ++ if (res != 0) ++ goto out_free_slab; ++ ++ res = init_scst_vdisk(&vdisk_blk_devtype); ++ if (res != 0) ++ goto out_free_vdisk; ++ ++ res = init_scst_vdisk(&vdisk_null_devtype); ++ if (res != 0) ++ goto out_free_blk; ++ ++ res = init_scst_vdisk(&vcdrom_devtype); ++ if (res != 0) ++ goto out_free_null; ++ ++out: ++ return res; ++ ++out_free_null: ++ exit_scst_vdisk(&vdisk_null_devtype); ++ ++out_free_blk: ++ exit_scst_vdisk(&vdisk_blk_devtype); ++ ++out_free_vdisk: ++ exit_scst_vdisk(&vdisk_file_devtype); ++ ++out_free_slab: ++ kmem_cache_destroy(blockio_work_cachep); ++ ++out_free_vdisk_cache: ++ kmem_cache_destroy(vdisk_thr_cachep); ++ goto out; ++} ++ ++static void __exit exit_scst_vdisk_driver(void) ++{ ++ exit_scst_vdisk(&vdisk_null_devtype); ++ exit_scst_vdisk(&vdisk_blk_devtype); ++ exit_scst_vdisk(&vdisk_file_devtype); ++ exit_scst_vdisk(&vcdrom_devtype); ++ ++ kmem_cache_destroy(blockio_work_cachep); ++ kmem_cache_destroy(vdisk_thr_cachep); ++} ++ ++module_init(init_scst_vdisk_driver); ++module_exit(exit_scst_vdisk_driver); ++ ++MODULE_AUTHOR("Vladislav Bolkhovitin & Leonid Stoljar"); ++MODULE_LICENSE("GPL"); ++MODULE_DESCRIPTION("SCSI disk (type 0) and CDROM (type 5) dev handler for " ++ "SCST using files on file systems or block devices"); ++MODULE_VERSION(SCST_VERSION_STRING); +diff -uprN orig/linux-3.2/drivers/scst/scst_tg.c linux-3.2/drivers/scst/scst_tg.c +--- orig/linux-3.2/drivers/scst/scst_tg.c ++++ linux-3.2/drivers/scst/scst_tg.c +@@ -0,0 +1,809 @@ ++/* ++ * scst_tg.c ++ * ++ * SCSI target group related code. ++ * ++ * Copyright (C) 2011 Bart Van Assche <bvanassche@acm.org>. ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * version 2 as published by the Free Software Foundation. ++ * ++ * 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. ++ */ ++ ++#include <asm/unaligned.h> ++#include <scst/scst.h> ++#include "scst_priv.h" ++ ++static struct list_head scst_dev_group_list; ++ ++/* Look up a device by name. */ ++static struct scst_device *__lookup_dev(const char *name) ++{ ++ struct scst_device *dev; ++ ++ list_for_each_entry(dev, &scst_dev_list, dev_list_entry) ++ if (strcmp(dev->virt_name, name) == 0) ++ return dev; ++ ++ return NULL; ++} ++ ++/* Look up a target by name. */ ++static struct scst_tgt *__lookup_tgt(const char *name) ++{ ++ struct scst_tgt_template *t; ++ struct scst_tgt *tgt; ++ ++ list_for_each_entry(t, &scst_template_list, scst_template_list_entry) ++ list_for_each_entry(tgt, &t->tgt_list, tgt_list_entry) ++ if (strcmp(tgt->tgt_name, name) == 0) ++ return tgt; ++ ++ return NULL; ++} ++ ++/* Look up a target by name in the given device group. */ ++static struct scst_tg_tgt *__lookup_dg_tgt(struct scst_dev_group *dg, ++ const char *tgt_name) ++{ ++ struct scst_target_group *tg; ++ struct scst_tg_tgt *tg_tgt; ++ ++ BUG_ON(!dg); ++ BUG_ON(!tgt_name); ++ list_for_each_entry(tg, &dg->tg_list, entry) ++ list_for_each_entry(tg_tgt, &tg->tgt_list, entry) ++ if (strcmp(tg_tgt->name, tgt_name) == 0) ++ return tg_tgt; ++ ++ return NULL; ++} ++ ++/* Look up a target group by name in the given device group. */ ++static struct scst_target_group * ++__lookup_tg_by_name(struct scst_dev_group *dg, const char *name) ++{ ++ struct scst_target_group *tg; ++ ++ list_for_each_entry(tg, &dg->tg_list, entry) ++ if (strcmp(tg->name, name) == 0) ++ return tg; ++ ++ return NULL; ++} ++ ++/* Look up a device node by device pointer in the given device group. */ ++static struct scst_dg_dev *__lookup_dg_dev_by_dev(struct scst_dev_group *dg, ++ struct scst_device *dev) ++{ ++ struct scst_dg_dev *dgd; ++ ++ list_for_each_entry(dgd, &dg->dev_list, entry) ++ if (dgd->dev == dev) ++ return dgd; ++ ++ return NULL; ++} ++ ++/* Look up a device node by name in the given device group. */ ++static struct scst_dg_dev *__lookup_dg_dev_by_name(struct scst_dev_group *dg, ++ const char *name) ++{ ++ struct scst_dg_dev *dgd; ++ ++ list_for_each_entry(dgd, &dg->dev_list, entry) ++ if (strcmp(dgd->dev->virt_name, name) == 0) ++ return dgd; ++ ++ return NULL; ++} ++ ++/* Look up a device node by name in any device group. */ ++static struct scst_dg_dev *__global_lookup_dg_dev_by_name(const char *name) ++{ ++ struct scst_dev_group *dg; ++ struct scst_dg_dev *dgd; ++ ++ list_for_each_entry(dg, &scst_dev_group_list, entry) { ++ dgd = __lookup_dg_dev_by_name(dg, name); ++ if (dgd) ++ return dgd; ++ } ++ return NULL; ++} ++ ++/* Look up a device group by name. */ ++static struct scst_dev_group *__lookup_dg_by_name(const char *name) ++{ ++ struct scst_dev_group *dg; ++ ++ list_for_each_entry(dg, &scst_dev_group_list, entry) ++ if (strcmp(dg->name, name) == 0) ++ return dg; ++ ++ return NULL; ++} ++ ++/* Look up a device group by device pointer. */ ++static struct scst_dev_group *__lookup_dg_by_dev(struct scst_device *dev) ++{ ++ struct scst_dev_group *dg; ++ ++ list_for_each_entry(dg, &scst_dev_group_list, entry) ++ if (__lookup_dg_dev_by_dev(dg, dev)) ++ return dg; ++ ++ return NULL; ++} ++ ++/* ++ * Target group contents management. ++ */ ++ ++static void scst_release_tg_tgt(struct kobject *kobj) ++{ ++ struct scst_tg_tgt *tg_tgt; ++ ++ tg_tgt = container_of(kobj, struct scst_tg_tgt, kobj); ++ kfree(tg_tgt->name); ++ kfree(tg_tgt); ++} ++ ++static struct kobj_type scst_tg_tgt_ktype = { ++ .sysfs_ops = &scst_sysfs_ops, ++ .release = scst_release_tg_tgt, ++}; ++ ++/** ++ * scst_tg_tgt_add() - Add a target to a target group. ++ */ ++int scst_tg_tgt_add(struct scst_target_group *tg, const char *name) ++{ ++ struct scst_tg_tgt *tg_tgt; ++ struct scst_tgt *tgt; ++ int res; ++ ++ TRACE_ENTRY(); ++ BUG_ON(!tg); ++ BUG_ON(!name); ++ res = -ENOMEM; ++ tg_tgt = kzalloc(sizeof *tg_tgt, GFP_KERNEL); ++ if (!tg_tgt) ++ goto out; ++ tg_tgt->tg = tg; ++ kobject_init(&tg_tgt->kobj, &scst_tg_tgt_ktype); ++ tg_tgt->name = kstrdup(name, GFP_KERNEL); ++ if (!tg_tgt->name) ++ goto out_put; ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res) ++ goto out_put; ++ res = -EEXIST; ++ tgt = __lookup_tgt(name); ++ if (__lookup_dg_tgt(tg->dg, name)) ++ goto out_unlock; ++ tg_tgt->tgt = tgt; ++ res = scst_tg_tgt_sysfs_add(tg, tg_tgt); ++ if (res) ++ goto out_unlock; ++ list_add_tail(&tg_tgt->entry, &tg->tgt_list); ++ res = 0; ++ mutex_unlock(&scst_mutex); ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++out_unlock: ++ mutex_unlock(&scst_mutex); ++out_put: ++ kobject_put(&tg_tgt->kobj); ++ goto out; ++} ++ ++static void __scst_tg_tgt_remove(struct scst_target_group *tg, ++ struct scst_tg_tgt *tg_tgt) ++{ ++ TRACE_ENTRY(); ++ list_del(&tg_tgt->entry); ++ scst_tg_tgt_sysfs_del(tg, tg_tgt); ++ kobject_put(&tg_tgt->kobj); ++ TRACE_EXIT(); ++} ++ ++/** ++ * scst_tg_tgt_remove_by_name() - Remove a target from a target group. ++ */ ++int scst_tg_tgt_remove_by_name(struct scst_target_group *tg, const char *name) ++{ ++ struct scst_tg_tgt *tg_tgt; ++ int res; ++ ++ TRACE_ENTRY(); ++ BUG_ON(!tg); ++ BUG_ON(!name); ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res) ++ goto out; ++ res = -EINVAL; ++ tg_tgt = __lookup_dg_tgt(tg->dg, name); ++ if (!tg_tgt) ++ goto out_unlock; ++ __scst_tg_tgt_remove(tg, tg_tgt); ++ res = 0; ++out_unlock: ++ mutex_unlock(&scst_mutex); ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* Caller must hold scst_mutex. Called from the target removal code. */ ++void scst_tg_tgt_remove_by_tgt(struct scst_tgt *tgt) ++{ ++ struct scst_dev_group *dg; ++ struct scst_target_group *tg; ++ struct scst_tg_tgt *t, *t2; ++ ++ BUG_ON(!tgt); ++ list_for_each_entry(dg, &scst_dev_group_list, entry) ++ list_for_each_entry(tg, &dg->tg_list, entry) ++ list_for_each_entry_safe(t, t2, &tg->tgt_list, entry) ++ if (t->tgt == tgt) ++ __scst_tg_tgt_remove(tg, t); ++} ++ ++/* ++ * Target group management. ++ */ ++ ++static void scst_release_tg(struct kobject *kobj) ++{ ++ struct scst_target_group *tg; ++ ++ tg = container_of(kobj, struct scst_target_group, kobj); ++ kfree(tg->name); ++ kfree(tg); ++} ++ ++static struct kobj_type scst_tg_ktype = { ++ .sysfs_ops = &scst_sysfs_ops, ++ .release = scst_release_tg, ++}; ++ ++/** ++ * scst_tg_add() - Add a target group. ++ */ ++int scst_tg_add(struct scst_dev_group *dg, const char *name) ++{ ++ struct scst_target_group *tg; ++ int res; ++ ++ TRACE_ENTRY(); ++ res = -ENOMEM; ++ tg = kzalloc(sizeof *tg, GFP_KERNEL); ++ if (!tg) ++ goto out; ++ kobject_init(&tg->kobj, &scst_tg_ktype); ++ tg->name = kstrdup(name, GFP_KERNEL); ++ if (!tg->name) ++ goto out_put; ++ tg->dg = dg; ++ tg->state = SCST_TG_STATE_OPTIMIZED; ++ INIT_LIST_HEAD(&tg->tgt_list); ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res) ++ goto out_put; ++ res = -EEXIST; ++ if (__lookup_tg_by_name(dg, name)) ++ goto out_unlock; ++ res = scst_tg_sysfs_add(dg, tg); ++ if (res) ++ goto out_unlock; ++ list_add_tail(&tg->entry, &dg->tg_list); ++ mutex_unlock(&scst_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++out_put: ++ kobject_put(&tg->kobj); ++ goto out; ++} ++ ++static void __scst_tg_remove(struct scst_dev_group *dg, ++ struct scst_target_group *tg) ++{ ++ struct scst_tg_tgt *tg_tgt; ++ ++ TRACE_ENTRY(); ++ BUG_ON(!dg); ++ BUG_ON(!tg); ++ while (!list_empty(&tg->tgt_list)) { ++ tg_tgt = list_first_entry(&tg->tgt_list, struct scst_tg_tgt, ++ entry); ++ __scst_tg_tgt_remove(tg, tg_tgt); ++ } ++ list_del(&tg->entry); ++ scst_tg_sysfs_del(tg); ++ kobject_put(&tg->kobj); ++ TRACE_EXIT(); ++} ++ ++/** ++ * scst_tg_remove_by_name() - Remove a target group. ++ */ ++int scst_tg_remove_by_name(struct scst_dev_group *dg, const char *name) ++{ ++ struct scst_target_group *tg; ++ int res; ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res) ++ goto out; ++ res = -EINVAL; ++ tg = __lookup_tg_by_name(dg, name); ++ if (!tg) ++ goto out_unlock; ++ __scst_tg_remove(dg, tg); ++ res = 0; ++out_unlock: ++ mutex_unlock(&scst_mutex); ++out: ++ return res; ++} ++ ++int scst_tg_set_state(struct scst_target_group *tg, enum scst_tg_state state) ++{ ++ struct scst_dg_dev *dg_dev; ++ struct scst_device *dev; ++ struct scst_tgt_dev *tgt_dev; ++ int res; ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res) ++ goto out; ++ ++ tg->state = state; ++ ++ list_for_each_entry(dg_dev, &tg->dg->dev_list, entry) { ++ dev = dg_dev->dev; ++ list_for_each_entry(tgt_dev, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ TRACE_MGMT_DBG("ALUA state of tgt_dev %p has changed", ++ tgt_dev); ++ scst_gen_aen_or_ua(tgt_dev, ++ SCST_LOAD_SENSE(scst_sense_asym_access_state_changed)); ++ } ++ } ++ mutex_unlock(&scst_mutex); ++out: ++ return res; ++} ++ ++/* ++ * Device group contents manipulation. ++ */ ++ ++/** ++ * scst_dg_dev_add() - Add a device to a device group. ++ * ++ * It is verified whether 'name' refers to an existing device and whether that ++ * device has not yet been added to any other device group. ++ */ ++int scst_dg_dev_add(struct scst_dev_group *dg, const char *name) ++{ ++ struct scst_dg_dev *dgdev; ++ struct scst_device *dev; ++ int res; ++ ++ res = -ENOMEM; ++ dgdev = kzalloc(sizeof *dgdev, GFP_KERNEL); ++ if (!dgdev) ++ goto out; ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res) ++ goto out_free; ++ res = -EEXIST; ++ if (__global_lookup_dg_dev_by_name(name)) ++ goto out_unlock; ++ res = -EINVAL; ++ dev = __lookup_dev(name); ++ if (!dev) ++ goto out_unlock; ++ dgdev->dev = dev; ++ res = scst_dg_dev_sysfs_add(dg, dgdev); ++ if (res) ++ goto out_unlock; ++ list_add_tail(&dgdev->entry, &dg->dev_list); ++ mutex_unlock(&scst_mutex); ++ ++out: ++ return res; ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++out_free: ++ kfree(dgdev); ++ goto out; ++} ++ ++static void __scst_dg_dev_remove(struct scst_dev_group *dg, ++ struct scst_dg_dev *dgdev) ++{ ++ list_del(&dgdev->entry); ++ scst_dg_dev_sysfs_del(dg, dgdev); ++ kfree(dgdev); ++} ++ ++/** ++ * scst_dg_dev_remove_by_name() - Remove a device from a device group. ++ */ ++int scst_dg_dev_remove_by_name(struct scst_dev_group *dg, const char *name) ++{ ++ struct scst_dg_dev *dgdev; ++ int res; ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res) ++ goto out; ++ res = -EINVAL; ++ dgdev = __lookup_dg_dev_by_name(dg, name); ++ if (!dgdev) ++ goto out_unlock; ++ __scst_dg_dev_remove(dg, dgdev); ++ res = 0; ++out_unlock: ++ mutex_unlock(&scst_mutex); ++out: ++ return res; ++} ++ ++/* Caller must hold scst_mutex. Called from the device removal code. */ ++int scst_dg_dev_remove_by_dev(struct scst_device *dev) ++{ ++ struct scst_dev_group *dg; ++ struct scst_dg_dev *dgdev; ++ int res; ++ ++ res = -EINVAL; ++ dg = __lookup_dg_by_dev(dev); ++ if (!dg) ++ goto out; ++ dgdev = __lookup_dg_dev_by_dev(dg, dev); ++ BUG_ON(!dgdev); ++ __scst_dg_dev_remove(dg, dgdev); ++ res = 0; ++out: ++ return res; ++} ++ ++/* ++ * Device group management. ++ */ ++ ++static void scst_release_dg(struct kobject *kobj) ++{ ++ struct scst_dev_group *dg; ++ ++ dg = container_of(kobj, struct scst_dev_group, kobj); ++ kfree(dg->name); ++ kfree(dg); ++} ++ ++static struct kobj_type scst_dg_ktype = { ++ .sysfs_ops = &scst_sysfs_ops, ++ .release = scst_release_dg, ++}; ++ ++/** ++ * scst_dg_add() - Add a new device group object and make it visible in sysfs. ++ */ ++int scst_dg_add(struct kobject *parent, const char *name) ++{ ++ struct scst_dev_group *dg; ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ res = -ENOMEM; ++ dg = kzalloc(sizeof(*dg), GFP_KERNEL); ++ if (!dg) ++ goto out; ++ kobject_init(&dg->kobj, &scst_dg_ktype); ++ dg->name = kstrdup(name, GFP_KERNEL); ++ if (!dg->name) ++ goto out_put; ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res) ++ goto out_put; ++ res = -EEXIST; ++ if (__lookup_dg_by_name(name)) ++ goto out_unlock; ++ res = -ENOMEM; ++ INIT_LIST_HEAD(&dg->dev_list); ++ INIT_LIST_HEAD(&dg->tg_list); ++ res = scst_dg_sysfs_add(parent, dg); ++ if (res) ++ goto out_unlock; ++ list_add_tail(&dg->entry, &scst_dev_group_list); ++ mutex_unlock(&scst_mutex); ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++out_put: ++ kobject_put(&dg->kobj); ++ goto out; ++} ++ ++static void __scst_dg_remove(struct scst_dev_group *dg) ++{ ++ struct scst_dg_dev *dgdev; ++ struct scst_target_group *tg; ++ ++ list_del(&dg->entry); ++ scst_dg_sysfs_del(dg); ++ while (!list_empty(&dg->dev_list)) { ++ dgdev = list_first_entry(&dg->dev_list, struct scst_dg_dev, ++ entry); ++ __scst_dg_dev_remove(dg, dgdev); ++ } ++ while (!list_empty(&dg->tg_list)) { ++ tg = list_first_entry(&dg->tg_list, struct scst_target_group, ++ entry); ++ __scst_tg_remove(dg, tg); ++ } ++ kobject_put(&dg->kobj); ++} ++ ++int scst_dg_remove(const char *name) ++{ ++ struct scst_dev_group *dg; ++ int res; ++ ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res) ++ goto out; ++ res = -EINVAL; ++ dg = __lookup_dg_by_name(name); ++ if (!dg) ++ goto out_unlock; ++ __scst_dg_remove(dg); ++ res = 0; ++out_unlock: ++ mutex_unlock(&scst_mutex); ++out: ++ return res; ++} ++ ++/* ++ * Given a pointer to a device_groups/<dg>/devices or ++ * device_groups/<dg>/target_groups kobject, return the pointer to the ++ * corresponding device group. ++ * ++ * Note: The caller must hold a reference on the kobject to avoid that the ++ * object disappears before the caller stops using the device group pointer. ++ */ ++struct scst_dev_group *scst_lookup_dg_by_kobj(struct kobject *kobj) ++{ ++ int res; ++ struct scst_dev_group *dg; ++ ++ dg = NULL; ++ res = mutex_lock_interruptible(&scst_mutex); ++ if (res) ++ goto out; ++ list_for_each_entry(dg, &scst_dev_group_list, entry) ++ if (dg->dev_kobj == kobj || dg->tg_kobj == kobj) ++ goto out_unlock; ++ dg = NULL; ++out_unlock: ++ mutex_unlock(&scst_mutex); ++out: ++ return dg; ++} ++ ++/* ++ * Target group module management. ++ */ ++ ++void scst_tg_init(void) ++{ ++ INIT_LIST_HEAD(&scst_dev_group_list); ++} ++ ++void scst_tg_cleanup(void) ++{ ++ struct scst_dev_group *tg; ++ ++ mutex_lock(&scst_mutex); ++ while (!list_empty(&scst_dev_group_list)) { ++ tg = list_first_entry(&scst_dev_group_list, ++ struct scst_dev_group, entry); ++ __scst_dg_remove(tg); ++ } ++ mutex_unlock(&scst_mutex); ++} ++ ++/* ++ * Functions for target group related SCSI command support. ++ */ ++ ++/** ++ * scst_lookup_tg_id() - Look up a target port group identifier. ++ * @dev: SCST device. ++ * @tgt: SCST target. ++ * ++ * Returns a non-zero number if the lookup was successful and zero if not. ++ */ ++uint16_t scst_lookup_tg_id(struct scst_device *dev, struct scst_tgt *tgt) ++{ ++ struct scst_dev_group *dg; ++ struct scst_target_group *tg; ++ struct scst_tg_tgt *tg_tgt; ++ uint16_t tg_id = 0; ++ ++ TRACE_ENTRY(); ++ mutex_lock(&scst_mutex); ++ dg = __lookup_dg_by_dev(dev); ++ if (!dg) ++ goto out_unlock; ++ tg_tgt = __lookup_dg_tgt(dg, tgt->tgt_name); ++ if (!tg_tgt) ++ goto out_unlock; ++ tg = tg_tgt->tg; ++ BUG_ON(!tg); ++ tg_id = tg->group_id; ++out_unlock: ++ mutex_unlock(&scst_mutex); ++ ++ TRACE_EXIT_RES(tg_id); ++ return tg_id; ++} ++EXPORT_SYMBOL_GPL(scst_lookup_tg_id); ++ ++/** ++ * scst_impl_alua_configured() - Whether implicit ALUA has been configured. ++ * @dev: Pointer to the SCST device to verify. ++ */ ++bool scst_impl_alua_configured(struct scst_device *dev) ++{ ++ struct scst_dev_group *dg; ++ bool res; ++ ++ mutex_lock(&scst_mutex); ++ dg = __lookup_dg_by_dev(dev); ++ res = dg != NULL; ++ mutex_unlock(&scst_mutex); ++ ++ return res; ++} ++EXPORT_SYMBOL_GPL(scst_impl_alua_configured); ++ ++/** ++ * scst_tg_get_group_info() - Build REPORT TARGET GROUPS response. ++ * @buf: Pointer to a pointer to which the result buffer pointer will be set. ++ * @length: Response length, including the "RETURN DATA LENGTH" field. ++ * @dev: Pointer to the SCST device for which to obtain group information. ++ * @data_format: Three-bit response data format specification. ++ */ ++int scst_tg_get_group_info(void **buf, uint32_t *length, ++ struct scst_device *dev, uint8_t data_format) ++{ ++ struct scst_dev_group *dg; ++ struct scst_target_group *tg; ++ struct scst_tg_tgt *tgtgt; ++ struct scst_tgt *tgt; ++ uint8_t *p; ++ uint32_t ret_data_len; ++ uint16_t rel_tgt_id; ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ BUG_ON(!buf); ++ BUG_ON(!length); ++ ++ ret_data_len = 0; ++ ++ res = -EINVAL; ++ switch (data_format) { ++ case 0: ++ break; ++ case 1: ++ /* Extended header */ ++ ret_data_len += 4; ++ break; ++ default: ++ goto out; ++ } ++ ++ *length = 4; ++ ++ mutex_lock(&scst_mutex); ++ ++ dg = __lookup_dg_by_dev(dev); ++ if (dg) { ++ list_for_each_entry(tg, &dg->tg_list, entry) { ++ /* Target port group descriptor header. */ ++ ret_data_len += 8; ++ list_for_each_entry(tgtgt, &tg->tgt_list, entry) { ++ /* Target port descriptor. */ ++ ret_data_len += 4; ++ } ++ } ++ } ++ ++ *length += ret_data_len; ++ ++ res = -ENOMEM; ++ *buf = kzalloc(*length, GFP_KERNEL); ++ if (!*buf) ++ goto out_unlock; ++ ++ p = *buf; ++ /* Return data length. */ ++ put_unaligned(cpu_to_be32(ret_data_len), (__be32 *)p); ++ p += 4; ++ if (data_format == 1) { ++ /* Extended header */ ++ *p++ = 0x10; /* format = 1 */ ++ *p++ = 0x00; /* implicit transition time = 0 */ ++ p += 2; /* reserved */ ++ } ++ ++ if (!dg) ++ goto done; ++ ++ list_for_each_entry(tg, &dg->tg_list, entry) { ++ /* Target port group descriptor header. */ ++ *p++ = (tg->preferred ? SCST_TG_PREFERRED : 0) | tg->state; ++ *p++ = SCST_TG_SUP_OPTIMIZED ++ | SCST_TG_SUP_NONOPTIMIZED ++ | SCST_TG_SUP_STANDBY ++ | SCST_TG_SUP_UNAVAILABLE; ++ put_unaligned(cpu_to_be16(tg->group_id), (__be16 *)p); ++ p += 2; ++ p++; /* reserved */ ++ *p++ = 2; /* status code: implicit transition */ ++ p++; /* vendor specific */ ++ list_for_each_entry(tgtgt, &tg->tgt_list, entry) ++ (*p)++; /* target port count */ ++ p++; ++ list_for_each_entry(tgtgt, &tg->tgt_list, entry) { ++ tgt = tgtgt->tgt; ++ rel_tgt_id = tgt ? tgt->rel_tgt_id : tgtgt->rel_tgt_id; ++ /* Target port descriptor. */ ++ p += 2; /* reserved */ ++ /* Relative target port identifier. */ ++ put_unaligned(cpu_to_be16(rel_tgt_id), ++ (__be16 *)p); ++ p += 2; ++ } ++ } ++ ++done: ++ WARN_ON(p - (uint8_t *)*buf != *length); ++ ++ res = 0; ++ ++out_unlock: ++ mutex_unlock(&scst_mutex); ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL_GPL(scst_tg_get_group_info); +diff -uprN orig/linux-3.2/drivers/scst/scst_proc.c linux-3.2/drivers/scst/scst_proc.c +--- orig/linux-3.2/drivers/scst/scst_proc.c ++++ linux-3.2/drivers/scst/scst_proc.c +@@ -0,0 +1,2716 @@ ++/* ++ * scst_proc.c ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/module.h> ++ ++#include <linux/init.h> ++#include <linux/kernel.h> ++#include <linux/errno.h> ++#include <linux/list.h> ++#include <linux/spinlock.h> ++#include <linux/slab.h> ++#include <linux/sched.h> ++#include <linux/unistd.h> ++#include <linux/string.h> ++#include <linux/proc_fs.h> ++#include <linux/seq_file.h> ++ ++#include <scst/scst.h> ++#include "scst_priv.h" ++#include "scst_mem.h" ++#include "scst_pres.h" ++ ++static int scst_proc_init_groups(void); ++static void scst_proc_cleanup_groups(void); ++static int scst_proc_assign_handler(char *buf); ++static int scst_proc_group_add(const char *p, unsigned int addr_method); ++static int scst_proc_del_free_acg(struct scst_acg *acg, int remove_proc); ++ ++static struct scst_proc_data scst_version_proc_data; ++static struct scst_proc_data scst_help_proc_data; ++static struct scst_proc_data scst_sgv_proc_data; ++static struct scst_proc_data scst_groups_names_proc_data; ++static struct scst_proc_data scst_groups_devices_proc_data; ++static struct scst_proc_data scst_groups_addr_method_proc_data; ++static struct scst_proc_data scst_sessions_proc_data; ++static struct scst_proc_data scst_dev_handler_type_proc_data; ++static struct scst_proc_data scst_tgt_proc_data; ++static struct scst_proc_data scst_threads_proc_data; ++static struct scst_proc_data scst_scsi_tgt_proc_data; ++static struct scst_proc_data scst_dev_handler_proc_data; ++ ++/* ++ * Must be less than 4K page size, since our output routines ++ * use some slack for overruns ++ */ ++#define SCST_PROC_BLOCK_SIZE (PAGE_SIZE - 512) ++ ++#define SCST_PROC_LOG_ENTRY_NAME "trace_level" ++#define SCST_PROC_DEV_HANDLER_TYPE_ENTRY_NAME "type" ++#define SCST_PROC_VERSION_NAME "version" ++#define SCST_PROC_SESSIONS_NAME "sessions" ++#define SCST_PROC_HELP_NAME "help" ++#define SCST_PROC_THREADS_NAME "threads" ++#define SCST_PROC_GROUPS_ENTRY_NAME "groups" ++#define SCST_PROC_GROUPS_DEVICES_ENTRY_NAME "devices" ++#define SCST_PROC_GROUPS_USERS_ENTRY_NAME "names" ++#define SCST_PROC_GROUPS_ADDR_METHOD_ENTRY_NAME "addr_method" ++ ++#ifdef CONFIG_SCST_MEASURE_LATENCY ++#define SCST_PROC_LAT_ENTRY_NAME "latency" ++#endif ++ ++#define SCST_PROC_ACTION_ALL 1 ++#define SCST_PROC_ACTION_NONE 2 ++#define SCST_PROC_ACTION_DEFAULT 3 ++#define SCST_PROC_ACTION_ADD 4 ++#define SCST_PROC_ACTION_CLEAR 5 ++#define SCST_PROC_ACTION_MOVE 6 ++#define SCST_PROC_ACTION_DEL 7 ++#define SCST_PROC_ACTION_REPLACE 8 ++#define SCST_PROC_ACTION_VALUE 9 ++#define SCST_PROC_ACTION_ASSIGN 10 ++#define SCST_PROC_ACTION_ADD_GROUP 11 ++#define SCST_PROC_ACTION_DEL_GROUP 12 ++#define SCST_PROC_ACTION_RENAME_GROUP 13 ++#define SCST_PROC_ACTION_DUMP_PRS 14 ++ ++static struct proc_dir_entry *scst_proc_scsi_tgt; ++static struct proc_dir_entry *scst_proc_groups_root; ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++static struct scst_proc_data scst_log_proc_data; ++ ++static struct scst_trace_log scst_proc_trace_tbl[] = { ++ { TRACE_OUT_OF_MEM, "out_of_mem" }, ++ { TRACE_MINOR, "minor" }, ++ { TRACE_SG_OP, "sg" }, ++ { TRACE_MEMORY, "mem" }, ++ { TRACE_BUFF, "buff" }, ++#ifndef GENERATING_UPSTREAM_PATCH ++ { TRACE_ENTRYEXIT, "entryexit" }, ++#endif ++ { TRACE_PID, "pid" }, ++ { TRACE_LINE, "line" }, ++ { TRACE_FUNCTION, "function" }, ++ { TRACE_DEBUG, "debug" }, ++ { TRACE_SPECIAL, "special" }, ++ { TRACE_SCSI, "scsi" }, ++ { TRACE_MGMT, "mgmt" }, ++ { TRACE_MGMT_DEBUG, "mgmt_dbg" }, ++ { TRACE_FLOW_CONTROL, "flow_control" }, ++ { TRACE_PRES, "pr" }, ++ { 0, NULL } ++}; ++ ++static struct scst_trace_log scst_proc_local_trace_tbl[] = { ++ { TRACE_RTRY, "retry" }, ++ { TRACE_SCSI_SERIALIZING, "scsi_serializing" }, ++ { TRACE_RCV_BOT, "recv_bot" }, ++ { TRACE_SND_BOT, "send_bot" }, ++ { TRACE_RCV_TOP, "recv_top" }, ++ { TRACE_SND_TOP, "send_top" }, ++ { 0, NULL } ++}; ++#endif ++ ++static char *scst_proc_help_string = ++" echo \"assign H:C:I:L HANDLER_NAME\" >/proc/scsi_tgt/scsi_tgt\n" ++"\n" ++" echo \"add_group GROUP_NAME [FLAT]\" >/proc/scsi_tgt/scsi_tgt\n" ++" echo \"add_group GROUP_NAME [LUN]\" >/proc/scsi_tgt/scsi_tgt\n" ++" echo \"del_group GROUP_NAME\" >/proc/scsi_tgt/scsi_tgt\n" ++" echo \"rename_group OLD_NAME NEW_NAME\" >/proc/scsi_tgt/scsi_tgt\n" ++"\n" ++" echo \"add|del H:C:I:L lun [READ_ONLY]\"" ++" >/proc/scsi_tgt/groups/GROUP_NAME/devices\n" ++" echo \"replace H:C:I:L lun [READ_ONLY]\"" ++" >/proc/scsi_tgt/groups/GROUP_NAME/devices\n" ++" echo \"add|del V_NAME lun [READ_ONLY]\"" ++" >/proc/scsi_tgt/groups/GROUP_NAME/devices\n" ++" echo \"replace V_NAME lun [READ_ONLY]\"" ++" >/proc/scsi_tgt/groups/GROUP_NAME/devices\n" ++" echo \"clear\" >/proc/scsi_tgt/groups/GROUP_NAME/devices\n" ++"\n" ++" echo \"add|del NAME\" >/proc/scsi_tgt/groups/GROUP_NAME/names\n" ++" echo \"move NAME NEW_GROUP_NAME\" >/proc/scsi_tgt/groups/OLD_GROUP_NAME/names\n" ++" echo \"clear\" >/proc/scsi_tgt/groups/GROUP_NAME/names\n" ++"\n" ++" echo \"DEC|0xHEX|0OCT\" >/proc/scsi_tgt/threads\n" ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++"\n" ++" echo \"all|none|default\" >/proc/scsi_tgt/[DEV_HANDLER_NAME/]trace_level\n" ++" echo \"value DEC|0xHEX|0OCT\"" ++" >/proc/scsi_tgt/[DEV_HANDLER_NAME/]trace_level\n" ++" echo \"set|add|del TOKEN\"" ++" >/proc/scsi_tgt/[DEV_HANDLER_NAME/]trace_level\n" ++" where TOKEN is one of [debug, function, line, pid, entryexit,\n" ++" buff, mem, sg, out_of_mem, special, scsi,\n" ++" mgmt, minor, mgmt_dbg]\n" ++" Additionally for /proc/scsi_tgt/trace_level there are these TOKENs\n" ++" [scsi_serializing, retry, recv_bot, send_bot, recv_top, send_top]\n" ++" echo \"dump_prs dev_name\" >/proc/scsi_tgt/trace_level\n" ++#endif ++; ++ ++static char *scst_proc_dev_handler_type[] = { ++ "Direct-access device (e.g., magnetic disk)", ++ "Sequential-access device (e.g., magnetic tape)", ++ "Printer device", ++ "Processor device", ++ "Write-once device (e.g., some optical disks)", ++ "CD-ROM device", ++ "Scanner device (obsolete)", ++ "Optical memory device (e.g., some optical disks)", ++ "Medium changer device (e.g., jukeboxes)", ++ "Communications device (obsolete)", ++ "Defined by ASC IT8 (Graphic arts pre-press devices)", ++ "Defined by ASC IT8 (Graphic arts pre-press devices)", ++ "Storage array controller device (e.g., RAID)", ++ "Enclosure services device", ++ "Simplified direct-access device (e.g., magnetic disk)", ++ "Optical card reader/writer device" ++}; ++ ++static DEFINE_MUTEX(scst_proc_mutex); ++ ++#include <linux/ctype.h> ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ ++static DEFINE_MUTEX(scst_log_mutex); ++ ++int scst_proc_log_entry_write(struct file *file, const char __user *buf, ++ unsigned long length, unsigned long *log_level, ++ unsigned long default_level, const struct scst_trace_log *tbl) ++{ ++ int res = length; ++ int action; ++ unsigned long level = 0, oldlevel; ++ char *buffer, *p, *e; ++ const struct scst_trace_log *t; ++ char *data = (char *)PDE(file->f_dentry->d_inode)->data; ++ ++ TRACE_ENTRY(); ++ ++ if (length > SCST_PROC_BLOCK_SIZE) { ++ res = -EOVERFLOW; ++ goto out; ++ } ++ if (!buf) { ++ res = -EINVAL; ++ goto out; ++ } ++ buffer = (char *)__get_free_page(GFP_KERNEL); ++ if (!buffer) { ++ res = -ENOMEM; ++ goto out; ++ } ++ if (copy_from_user(buffer, buf, length)) { ++ res = -EFAULT; ++ goto out_free; ++ } ++ if (length < PAGE_SIZE) { ++ buffer[length] = '\0'; ++ } else if (buffer[PAGE_SIZE-1]) { ++ res = -EINVAL; ++ goto out_free; ++ } ++ ++ /* ++ * Usage: ++ * echo "all|none|default" >/proc/scsi_tgt/trace_level ++ * echo "value DEC|0xHEX|0OCT" >/proc/scsi_tgt/trace_level ++ * echo "add|del TOKEN" >/proc/scsi_tgt/trace_level ++ */ ++ p = buffer; ++ if (!strncasecmp("all", p, 3)) { ++ action = SCST_PROC_ACTION_ALL; ++ } else if (!strncasecmp("none", p, 4) || !strncasecmp("null", p, 4)) { ++ action = SCST_PROC_ACTION_NONE; ++ } else if (!strncasecmp("default", p, 7)) { ++ action = SCST_PROC_ACTION_DEFAULT; ++ } else if (!strncasecmp("add ", p, 4)) { ++ p += 4; ++ action = SCST_PROC_ACTION_ADD; ++ } else if (!strncasecmp("del ", p, 4)) { ++ p += 4; ++ action = SCST_PROC_ACTION_DEL; ++ } else if (!strncasecmp("value ", p, 6)) { ++ p += 6; ++ action = SCST_PROC_ACTION_VALUE; ++ } else if (!strncasecmp("dump_prs ", p, 9)) { ++ p += 9; ++ action = SCST_PROC_ACTION_DUMP_PRS; ++ } else { ++ if (p[strlen(p) - 1] == '\n') ++ p[strlen(p) - 1] = '\0'; ++ PRINT_ERROR("Unknown action \"%s\"", p); ++ res = -EINVAL; ++ goto out_free; ++ } ++ ++ switch (action) { ++ case SCST_PROC_ACTION_ALL: ++ level = TRACE_ALL; ++ break; ++ case SCST_PROC_ACTION_DEFAULT: ++ level = default_level; ++ break; ++ case SCST_PROC_ACTION_NONE: ++ level = TRACE_NULL; ++ break; ++ case SCST_PROC_ACTION_ADD: ++ case SCST_PROC_ACTION_DEL: ++ while (isspace(*p) && *p != '\0') ++ p++; ++ e = p; ++ while (!isspace(*e) && *e != '\0') ++ e++; ++ *e = 0; ++ if (tbl) { ++ t = tbl; ++ while (t->token) { ++ if (!strcasecmp(p, t->token)) { ++ level = t->val; ++ break; ++ } ++ t++; ++ } ++ } ++ if (level == 0) { ++ t = scst_proc_trace_tbl; ++ while (t->token) { ++ if (!strcasecmp(p, t->token)) { ++ level = t->val; ++ break; ++ } ++ t++; ++ } ++ } ++ if (level == 0) { ++ PRINT_ERROR("Unknown token \"%s\"", p); ++ res = -EINVAL; ++ goto out_free; ++ } ++ break; ++ case SCST_PROC_ACTION_VALUE: ++ while (isspace(*p) && *p != '\0') ++ p++; ++ level = simple_strtoul(p, NULL, 0); ++ break; ++ case SCST_PROC_ACTION_DUMP_PRS: ++ { ++ struct scst_device *dev; ++ ++ while (isspace(*p) && *p != '\0') ++ p++; ++ e = p; ++ while (!isspace(*e) && *e != '\0') ++ e++; ++ *e = '\0'; ++ ++ if (mutex_lock_interruptible(&scst_mutex) != 0) { ++ res = -EINTR; ++ goto out_free; ++ } ++ ++ list_for_each_entry(dev, &scst_dev_list, dev_list_entry) { ++ if (strcmp(dev->virt_name, p) == 0) { ++ scst_pr_dump_prs(dev, true); ++ goto out_up; ++ } ++ } ++ ++ PRINT_ERROR("Device %s not found", p); ++ res = -ENOENT; ++out_up: ++ mutex_unlock(&scst_mutex); ++ goto out_free; ++ } ++ } ++ ++ oldlevel = *log_level; ++ ++ switch (action) { ++ case SCST_PROC_ACTION_ADD: ++ *log_level |= level; ++ break; ++ case SCST_PROC_ACTION_DEL: ++ *log_level &= ~level; ++ break; ++ default: ++ *log_level = level; ++ break; ++ } ++ ++ PRINT_INFO("Changed trace level for \"%s\": " ++ "old 0x%08lx, new 0x%08lx", ++ (char *)data, oldlevel, *log_level); ++ ++out_free: ++ free_page((unsigned long)buffer); ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL_GPL(scst_proc_log_entry_write); ++ ++static ssize_t scst_proc_scsi_tgt_gen_write_log(struct file *file, ++ const char __user *buf, ++ size_t length, loff_t *off) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ if (mutex_lock_interruptible(&scst_log_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ ++ res = scst_proc_log_entry_write(file, buf, length, ++ &trace_flag, SCST_DEFAULT_LOG_FLAGS, ++ scst_proc_local_trace_tbl); ++ ++ mutex_unlock(&scst_log_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++#endif /* defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) */ ++ ++#ifdef CONFIG_SCST_MEASURE_LATENCY ++ ++static char *scst_io_size_names[] = { ++ "<=8K ", ++ "<=32K ", ++ "<=128K", ++ "<=512K", ++ ">512K " ++}; ++ ++static int lat_info_show(struct seq_file *seq, void *v) ++{ ++ int res = 0; ++ struct scst_acg *acg; ++ struct scst_session *sess; ++ char buf[50]; ++ ++ TRACE_ENTRY(); ++ ++ BUILD_BUG_ON(SCST_LATENCY_STATS_NUM != ARRAY_SIZE(scst_io_size_names)); ++ BUILD_BUG_ON(SCST_LATENCY_STATS_NUM != ARRAY_SIZE(sess->sess_latency_stat)); ++ ++ if (mutex_lock_interruptible(&scst_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ ++ list_for_each_entry(acg, &scst_acg_list, acg_list_entry) { ++ bool header_printed = false; ++ ++ list_for_each_entry(sess, &acg->acg_sess_list, ++ acg_sess_list_entry) { ++ unsigned int i; ++ int t; ++ uint64_t scst_time, tgt_time, dev_time; ++ unsigned int processed_cmds; ++ ++ if (!header_printed) { ++ seq_printf(seq, "%-15s %-15s %-46s %-46s %-46s\n", ++ "T-L names", "Total commands", "SCST latency", ++ "Target latency", "Dev latency (min/avg/max/all ns)"); ++ header_printed = true; ++ } ++ ++ seq_printf(seq, "Target name: %s\nInitiator name: %s\n", ++ sess->tgt->tgtt->name, ++ sess->initiator_name); ++ ++ spin_lock_bh(&sess->lat_lock); ++ ++ for (i = 0; i < SCST_LATENCY_STATS_NUM ; i++) { ++ uint64_t scst_time_wr, tgt_time_wr, dev_time_wr; ++ unsigned int processed_cmds_wr; ++ uint64_t scst_time_rd, tgt_time_rd, dev_time_rd; ++ unsigned int processed_cmds_rd; ++ struct scst_ext_latency_stat *latency_stat; ++ ++ latency_stat = &sess->sess_latency_stat[i]; ++ scst_time_wr = latency_stat->scst_time_wr; ++ scst_time_rd = latency_stat->scst_time_rd; ++ tgt_time_wr = latency_stat->tgt_time_wr; ++ tgt_time_rd = latency_stat->tgt_time_rd; ++ dev_time_wr = latency_stat->dev_time_wr; ++ dev_time_rd = latency_stat->dev_time_rd; ++ processed_cmds_wr = latency_stat->processed_cmds_wr; ++ processed_cmds_rd = latency_stat->processed_cmds_rd; ++ ++ seq_printf(seq, "%-5s %-9s %-15lu ", ++ "Write", scst_io_size_names[i], ++ (unsigned long)processed_cmds_wr); ++ if (processed_cmds_wr == 0) ++ processed_cmds_wr = 1; ++ ++ do_div(scst_time_wr, processed_cmds_wr); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_scst_time_wr, ++ (unsigned long)scst_time_wr, ++ (unsigned long)latency_stat->max_scst_time_wr, ++ (unsigned long)latency_stat->scst_time_wr); ++ seq_printf(seq, "%-47s", buf); ++ ++ do_div(tgt_time_wr, processed_cmds_wr); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_tgt_time_wr, ++ (unsigned long)tgt_time_wr, ++ (unsigned long)latency_stat->max_tgt_time_wr, ++ (unsigned long)latency_stat->tgt_time_wr); ++ seq_printf(seq, "%-47s", buf); ++ ++ do_div(dev_time_wr, processed_cmds_wr); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_dev_time_wr, ++ (unsigned long)dev_time_wr, ++ (unsigned long)latency_stat->max_dev_time_wr, ++ (unsigned long)latency_stat->dev_time_wr); ++ seq_printf(seq, "%-47s\n", buf); ++ ++ seq_printf(seq, "%-5s %-9s %-15lu ", ++ "Read", scst_io_size_names[i], ++ (unsigned long)processed_cmds_rd); ++ if (processed_cmds_rd == 0) ++ processed_cmds_rd = 1; ++ ++ do_div(scst_time_rd, processed_cmds_rd); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_scst_time_rd, ++ (unsigned long)scst_time_rd, ++ (unsigned long)latency_stat->max_scst_time_rd, ++ (unsigned long)latency_stat->scst_time_rd); ++ seq_printf(seq, "%-47s", buf); ++ ++ do_div(tgt_time_rd, processed_cmds_rd); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_tgt_time_rd, ++ (unsigned long)tgt_time_rd, ++ (unsigned long)latency_stat->max_tgt_time_rd, ++ (unsigned long)latency_stat->tgt_time_rd); ++ seq_printf(seq, "%-47s", buf); ++ ++ do_div(dev_time_rd, processed_cmds_rd); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_dev_time_rd, ++ (unsigned long)dev_time_rd, ++ (unsigned long)latency_stat->max_dev_time_rd, ++ (unsigned long)latency_stat->dev_time_rd); ++ seq_printf(seq, "%-47s\n", buf); ++ } ++ ++ for (t = SESS_TGT_DEV_LIST_HASH_SIZE-1; t >= 0; t--) { ++ struct list_head *head = ++ &sess->sess_tgt_dev_list[t]; ++ struct scst_tgt_dev *tgt_dev; ++ list_for_each_entry(tgt_dev, head, ++ sess_tgt_dev_list_entry) { ++ ++ seq_printf(seq, "\nLUN: %llu\n", tgt_dev->lun); ++ ++ for (i = 0; i < SCST_LATENCY_STATS_NUM ; i++) { ++ uint64_t scst_time_wr, tgt_time_wr, dev_time_wr; ++ unsigned int processed_cmds_wr; ++ uint64_t scst_time_rd, tgt_time_rd, dev_time_rd; ++ unsigned int processed_cmds_rd; ++ struct scst_ext_latency_stat *latency_stat; ++ ++ latency_stat = &tgt_dev->dev_latency_stat[i]; ++ scst_time_wr = latency_stat->scst_time_wr; ++ scst_time_rd = latency_stat->scst_time_rd; ++ tgt_time_wr = latency_stat->tgt_time_wr; ++ tgt_time_rd = latency_stat->tgt_time_rd; ++ dev_time_wr = latency_stat->dev_time_wr; ++ dev_time_rd = latency_stat->dev_time_rd; ++ processed_cmds_wr = latency_stat->processed_cmds_wr; ++ processed_cmds_rd = latency_stat->processed_cmds_rd; ++ ++ seq_printf(seq, "%-5s %-9s %-15lu ", ++ "Write", scst_io_size_names[i], ++ (unsigned long)processed_cmds_wr); ++ if (processed_cmds_wr == 0) ++ processed_cmds_wr = 1; ++ ++ do_div(scst_time_wr, processed_cmds_wr); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_scst_time_wr, ++ (unsigned long)scst_time_wr, ++ (unsigned long)latency_stat->max_scst_time_wr, ++ (unsigned long)latency_stat->scst_time_wr); ++ seq_printf(seq, "%-47s", buf); ++ ++ do_div(tgt_time_wr, processed_cmds_wr); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_tgt_time_wr, ++ (unsigned long)tgt_time_wr, ++ (unsigned long)latency_stat->max_tgt_time_wr, ++ (unsigned long)latency_stat->tgt_time_wr); ++ seq_printf(seq, "%-47s", buf); ++ ++ do_div(dev_time_wr, processed_cmds_wr); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_dev_time_wr, ++ (unsigned long)dev_time_wr, ++ (unsigned long)latency_stat->max_dev_time_wr, ++ (unsigned long)latency_stat->dev_time_wr); ++ seq_printf(seq, "%-47s\n", buf); ++ ++ seq_printf(seq, "%-5s %-9s %-15lu ", ++ "Read", scst_io_size_names[i], ++ (unsigned long)processed_cmds_rd); ++ if (processed_cmds_rd == 0) ++ processed_cmds_rd = 1; ++ ++ do_div(scst_time_rd, processed_cmds_rd); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_scst_time_rd, ++ (unsigned long)scst_time_rd, ++ (unsigned long)latency_stat->max_scst_time_rd, ++ (unsigned long)latency_stat->scst_time_rd); ++ seq_printf(seq, "%-47s", buf); ++ ++ do_div(tgt_time_rd, processed_cmds_rd); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_tgt_time_rd, ++ (unsigned long)tgt_time_rd, ++ (unsigned long)latency_stat->max_tgt_time_rd, ++ (unsigned long)latency_stat->tgt_time_rd); ++ seq_printf(seq, "%-47s", buf); ++ ++ do_div(dev_time_rd, processed_cmds_rd); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)latency_stat->min_dev_time_rd, ++ (unsigned long)dev_time_rd, ++ (unsigned long)latency_stat->max_dev_time_rd, ++ (unsigned long)latency_stat->dev_time_rd); ++ seq_printf(seq, "%-47s\n", buf); ++ } ++ } ++ } ++ ++ scst_time = sess->scst_time; ++ tgt_time = sess->tgt_time; ++ dev_time = sess->dev_time; ++ processed_cmds = sess->processed_cmds; ++ ++ seq_printf(seq, "\n%-15s %-16d", "Overall ", ++ processed_cmds); ++ ++ if (processed_cmds == 0) ++ processed_cmds = 1; ++ ++ do_div(scst_time, processed_cmds); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)sess->min_scst_time, ++ (unsigned long)scst_time, ++ (unsigned long)sess->max_scst_time, ++ (unsigned long)sess->scst_time); ++ seq_printf(seq, "%-47s", buf); ++ ++ do_div(tgt_time, processed_cmds); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)sess->min_tgt_time, ++ (unsigned long)tgt_time, ++ (unsigned long)sess->max_tgt_time, ++ (unsigned long)sess->tgt_time); ++ seq_printf(seq, "%-47s", buf); ++ ++ do_div(dev_time, processed_cmds); ++ snprintf(buf, sizeof(buf), "%lu/%lu/%lu/%lu", ++ (unsigned long)sess->min_dev_time, ++ (unsigned long)dev_time, ++ (unsigned long)sess->max_dev_time, ++ (unsigned long)sess->dev_time); ++ seq_printf(seq, "%-47s\n\n", buf); ++ ++ spin_unlock_bh(&sess->lat_lock); ++ } ++ } ++ ++ mutex_unlock(&scst_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t scst_proc_scsi_tgt_gen_write_lat(struct file *file, ++ const char __user *buf, ++ size_t length, loff_t *off) ++{ ++ int res = length, t; ++ struct scst_acg *acg; ++ struct scst_session *sess; ++ ++ TRACE_ENTRY(); ++ ++ if (mutex_lock_interruptible(&scst_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ ++ list_for_each_entry(acg, &scst_acg_list, acg_list_entry) { ++ list_for_each_entry(sess, &acg->acg_sess_list, ++ acg_sess_list_entry) { ++ PRINT_INFO("Zeroing latency statistics for initiator " ++ "%s", sess->initiator_name); ++ spin_lock_bh(&sess->lat_lock); ++ ++ sess->scst_time = 0; ++ sess->tgt_time = 0; ++ sess->dev_time = 0; ++ sess->min_scst_time = 0; ++ sess->min_tgt_time = 0; ++ sess->min_dev_time = 0; ++ sess->max_scst_time = 0; ++ sess->max_tgt_time = 0; ++ sess->max_dev_time = 0; ++ sess->processed_cmds = 0; ++ memset(sess->sess_latency_stat, 0, ++ sizeof(sess->sess_latency_stat)); ++ ++ for (t = SESS_TGT_DEV_LIST_HASH_SIZE-1; t >= 0; t--) { ++ struct list_head *head = ++ &sess->sess_tgt_dev_list[t]; ++ struct scst_tgt_dev *tgt_dev; ++ list_for_each_entry(tgt_dev, head, ++ sess_tgt_dev_list_entry) { ++ tgt_dev->scst_time = 0; ++ tgt_dev->tgt_time = 0; ++ tgt_dev->dev_time = 0; ++ tgt_dev->processed_cmds = 0; ++ memset(tgt_dev->dev_latency_stat, 0, ++ sizeof(tgt_dev->dev_latency_stat)); ++ } ++ } ++ ++ spin_unlock_bh(&sess->lat_lock); ++ } ++ } ++ ++ mutex_unlock(&scst_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct scst_proc_data scst_lat_proc_data = { ++ SCST_DEF_RW_SEQ_OP(scst_proc_scsi_tgt_gen_write_lat) ++ .show = lat_info_show, ++ .data = "scsi_tgt", ++}; ++ ++#endif /* CONFIG_SCST_MEASURE_LATENCY */ ++ ++static int __init scst_proc_init_module_log(void) ++{ ++ int res = 0; ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) || \ ++ defined(CONFIG_SCST_MEASURE_LATENCY) ++ struct proc_dir_entry *generic; ++#endif ++ ++ TRACE_ENTRY(); ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ generic = scst_create_proc_entry(scst_proc_scsi_tgt, ++ SCST_PROC_LOG_ENTRY_NAME, ++ &scst_log_proc_data); ++ if (!generic) { ++ PRINT_ERROR("cannot init /proc/%s/%s", ++ SCST_PROC_ENTRY_NAME, SCST_PROC_LOG_ENTRY_NAME); ++ res = -ENOMEM; ++ } ++#endif ++ ++#ifdef CONFIG_SCST_MEASURE_LATENCY ++ if (res == 0) { ++ generic = scst_create_proc_entry(scst_proc_scsi_tgt, ++ SCST_PROC_LAT_ENTRY_NAME, ++ &scst_lat_proc_data); ++ if (!generic) { ++ PRINT_ERROR("cannot init /proc/%s/%s", ++ SCST_PROC_ENTRY_NAME, ++ SCST_PROC_LAT_ENTRY_NAME); ++ res = -ENOMEM; ++ } ++ } ++#endif ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void scst_proc_cleanup_module_log(void) ++{ ++ TRACE_ENTRY(); ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ remove_proc_entry(SCST_PROC_LOG_ENTRY_NAME, scst_proc_scsi_tgt); ++#endif ++ ++#ifdef CONFIG_SCST_MEASURE_LATENCY ++ remove_proc_entry(SCST_PROC_LAT_ENTRY_NAME, scst_proc_scsi_tgt); ++#endif ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int scst_proc_group_add_tree(struct scst_acg *acg, const char *name) ++{ ++ int res = 0; ++ struct proc_dir_entry *generic; ++ ++ TRACE_ENTRY(); ++ ++ acg->acg_proc_root = proc_mkdir(name, scst_proc_groups_root); ++ if (acg->acg_proc_root == NULL) { ++ PRINT_ERROR("Not enough memory to register %s entry in " ++ "/proc/%s/%s", name, SCST_PROC_ENTRY_NAME, ++ SCST_PROC_GROUPS_ENTRY_NAME); ++ goto out; ++ } ++ ++ scst_groups_addr_method_proc_data.data = acg; ++ generic = scst_create_proc_entry(acg->acg_proc_root, ++ SCST_PROC_GROUPS_ADDR_METHOD_ENTRY_NAME, ++ &scst_groups_addr_method_proc_data); ++ if (!generic) { ++ PRINT_ERROR("Cannot init /proc/%s/%s/%s/%s", ++ SCST_PROC_ENTRY_NAME, ++ SCST_PROC_GROUPS_ENTRY_NAME, ++ name, SCST_PROC_GROUPS_ADDR_METHOD_ENTRY_NAME); ++ res = -ENOMEM; ++ goto out_remove; ++ } ++ ++ scst_groups_devices_proc_data.data = acg; ++ generic = scst_create_proc_entry(acg->acg_proc_root, ++ SCST_PROC_GROUPS_DEVICES_ENTRY_NAME, ++ &scst_groups_devices_proc_data); ++ if (!generic) { ++ PRINT_ERROR("Cannot init /proc/%s/%s/%s/%s", ++ SCST_PROC_ENTRY_NAME, ++ SCST_PROC_GROUPS_ENTRY_NAME, ++ name, SCST_PROC_GROUPS_DEVICES_ENTRY_NAME); ++ res = -ENOMEM; ++ goto out_remove0; ++ } ++ ++ scst_groups_names_proc_data.data = acg; ++ generic = scst_create_proc_entry(acg->acg_proc_root, ++ SCST_PROC_GROUPS_USERS_ENTRY_NAME, ++ &scst_groups_names_proc_data); ++ if (!generic) { ++ PRINT_ERROR("Cannot init /proc/%s/%s/%s/%s", ++ SCST_PROC_ENTRY_NAME, ++ SCST_PROC_GROUPS_ENTRY_NAME, ++ name, SCST_PROC_GROUPS_USERS_ENTRY_NAME); ++ res = -ENOMEM; ++ goto out_remove1; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_remove1: ++ remove_proc_entry(SCST_PROC_GROUPS_DEVICES_ENTRY_NAME, ++ acg->acg_proc_root); ++ ++out_remove0: ++ remove_proc_entry(SCST_PROC_GROUPS_ADDR_METHOD_ENTRY_NAME, ++ acg->acg_proc_root); ++out_remove: ++ remove_proc_entry(name, scst_proc_groups_root); ++ goto out; ++} ++ ++static void scst_proc_del_acg_tree(struct proc_dir_entry *acg_proc_root, ++ const char *name) ++{ ++ TRACE_ENTRY(); ++ ++ remove_proc_entry(SCST_PROC_GROUPS_ADDR_METHOD_ENTRY_NAME, acg_proc_root); ++ remove_proc_entry(SCST_PROC_GROUPS_USERS_ENTRY_NAME, acg_proc_root); ++ remove_proc_entry(SCST_PROC_GROUPS_DEVICES_ENTRY_NAME, acg_proc_root); ++ remove_proc_entry(name, scst_proc_groups_root); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++static int scst_proc_group_add(const char *p, unsigned int addr_method) ++{ ++ int res = 0, len = strlen(p) + 1; ++ struct scst_acg *acg; ++ char *name = NULL; ++ ++ TRACE_ENTRY(); ++ ++ name = kmalloc(len, GFP_KERNEL); ++ if (name == NULL) { ++ PRINT_ERROR("Allocation of new name (size %d) failed", len); ++ goto out_nomem; ++ } ++ strlcpy(name, p, len); ++ ++ acg = scst_alloc_add_acg(NULL, name, false); ++ if (acg == NULL) { ++ PRINT_ERROR("scst_alloc_add_acg() (name %s) failed", name); ++ goto out_free; ++ } ++ ++ acg->addr_method = addr_method; ++ ++ res = scst_proc_group_add_tree(acg, p); ++ if (res != 0) ++ goto out_free_acg; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free_acg: ++ scst_proc_del_free_acg(acg, 0); ++ ++out_free: ++ kfree(name); ++ ++out_nomem: ++ res = -ENOMEM; ++ goto out; ++} ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++static int scst_proc_del_free_acg(struct scst_acg *acg, int remove_proc) ++{ ++ struct proc_dir_entry *acg_proc_root = acg->acg_proc_root; ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ if (acg != scst_default_acg) { ++ if (!scst_acg_sess_is_empty(acg)) { ++ PRINT_ERROR("%s", "Session is not empty"); ++ res = -EBUSY; ++ goto out; ++ } ++ if (remove_proc) ++ scst_proc_del_acg_tree(acg_proc_root, acg->acg_name); ++ scst_del_free_acg(acg); ++ } ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++static int scst_proc_rename_acg(struct scst_acg *acg, const char *new_name) ++{ ++ int res = 0, len = strlen(new_name) + 1; ++ char *name; ++ struct proc_dir_entry *old_acg_proc_root = acg->acg_proc_root; ++ ++ TRACE_ENTRY(); ++ ++ name = kmalloc(len, GFP_KERNEL); ++ if (name == NULL) { ++ PRINT_ERROR("Allocation of new name (size %d) failed", len); ++ goto out_nomem; ++ } ++ strlcpy(name, new_name, len); ++ ++ res = scst_proc_group_add_tree(acg, new_name); ++ if (res != 0) ++ goto out_free; ++ ++ scst_proc_del_acg_tree(old_acg_proc_root, acg->acg_name); ++ ++ kfree(acg->acg_name); ++ acg->acg_name = name; ++ ++ scst_check_reassign_sessions(); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free: ++ kfree(name); ++ ++out_nomem: ++ res = -ENOMEM; ++ goto out; ++} ++ ++static int __init scst_proc_init_groups(void) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ /* create the proc directory entry for the device */ ++ scst_proc_groups_root = proc_mkdir(SCST_PROC_GROUPS_ENTRY_NAME, ++ scst_proc_scsi_tgt); ++ if (scst_proc_groups_root == NULL) { ++ PRINT_ERROR("Not enough memory to register %s entry in " ++ "/proc/%s", SCST_PROC_GROUPS_ENTRY_NAME, ++ SCST_PROC_ENTRY_NAME); ++ goto out_nomem; ++ } ++ ++ res = scst_proc_group_add_tree(scst_default_acg, ++ SCST_DEFAULT_ACG_NAME); ++ if (res != 0) ++ goto out_remove; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_remove: ++ remove_proc_entry(SCST_PROC_GROUPS_ENTRY_NAME, scst_proc_scsi_tgt); ++ ++out_nomem: ++ res = -ENOMEM; ++ goto out; ++} ++ ++static void scst_proc_cleanup_groups(void) ++{ ++ struct scst_acg *acg_tmp, *acg; ++ ++ TRACE_ENTRY(); ++ ++ /* remove all groups (dir & entries) */ ++ list_for_each_entry_safe(acg, acg_tmp, &scst_acg_list, ++ acg_list_entry) { ++ scst_proc_del_free_acg(acg, 1); ++ } ++ ++ scst_proc_del_acg_tree(scst_default_acg->acg_proc_root, ++ SCST_DEFAULT_ACG_NAME); ++ TRACE_DBG("remove_proc_entry(%s, %p)", ++ SCST_PROC_GROUPS_ENTRY_NAME, scst_proc_scsi_tgt); ++ remove_proc_entry(SCST_PROC_GROUPS_ENTRY_NAME, scst_proc_scsi_tgt); ++ ++ TRACE_EXIT(); ++} ++ ++static int __init scst_proc_init_sgv(void) ++{ ++ int res = 0; ++ struct proc_dir_entry *pr; ++ ++ TRACE_ENTRY(); ++ ++ pr = scst_create_proc_entry(scst_proc_scsi_tgt, "sgv", ++ &scst_sgv_proc_data); ++ if (pr == NULL) { ++ PRINT_ERROR("%s", "cannot create sgv /proc entry"); ++ res = -ENOMEM; ++ } ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void __exit scst_proc_cleanup_sgv(void) ++{ ++ TRACE_ENTRY(); ++ remove_proc_entry("sgv", scst_proc_scsi_tgt); ++ TRACE_EXIT(); ++} ++ ++int __init scst_proc_init_module(void) ++{ ++ int res = 0; ++ struct proc_dir_entry *generic; ++ ++ TRACE_ENTRY(); ++ ++ scst_proc_scsi_tgt = proc_mkdir(SCST_PROC_ENTRY_NAME, NULL); ++ if (!scst_proc_scsi_tgt) { ++ PRINT_ERROR("cannot init /proc/%s", SCST_PROC_ENTRY_NAME); ++ goto out_nomem; ++ } ++ ++ generic = scst_create_proc_entry(scst_proc_scsi_tgt, ++ SCST_PROC_ENTRY_NAME, ++ &scst_tgt_proc_data); ++ if (!generic) { ++ PRINT_ERROR("cannot init /proc/%s/%s", ++ SCST_PROC_ENTRY_NAME, SCST_PROC_ENTRY_NAME); ++ goto out_remove; ++ } ++ ++ generic = scst_create_proc_entry(scst_proc_scsi_tgt, ++ SCST_PROC_VERSION_NAME, ++ &scst_version_proc_data); ++ if (!generic) { ++ PRINT_ERROR("cannot init /proc/%s/%s", ++ SCST_PROC_ENTRY_NAME, SCST_PROC_VERSION_NAME); ++ goto out_remove1; ++ } ++ ++ generic = scst_create_proc_entry(scst_proc_scsi_tgt, ++ SCST_PROC_SESSIONS_NAME, ++ &scst_sessions_proc_data); ++ if (!generic) { ++ PRINT_ERROR("cannot init /proc/%s/%s", ++ SCST_PROC_ENTRY_NAME, SCST_PROC_SESSIONS_NAME); ++ goto out_remove2; ++ } ++ ++ generic = scst_create_proc_entry(scst_proc_scsi_tgt, ++ SCST_PROC_HELP_NAME, ++ &scst_help_proc_data); ++ if (!generic) { ++ PRINT_ERROR("cannot init /proc/%s/%s", ++ SCST_PROC_ENTRY_NAME, SCST_PROC_HELP_NAME); ++ goto out_remove3; ++ } ++ ++ generic = scst_create_proc_entry(scst_proc_scsi_tgt, ++ SCST_PROC_THREADS_NAME, ++ &scst_threads_proc_data); ++ if (!generic) { ++ PRINT_ERROR("cannot init /proc/%s/%s", ++ SCST_PROC_ENTRY_NAME, SCST_PROC_THREADS_NAME); ++ goto out_remove4; ++ } ++ ++ if (scst_proc_init_module_log() < 0) ++ goto out_remove5; ++ ++ if (scst_proc_init_groups() < 0) ++ goto out_remove6; ++ ++ if (scst_proc_init_sgv() < 0) ++ goto out_remove7; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_remove7: ++ scst_proc_cleanup_groups(); ++ ++out_remove6: ++ scst_proc_cleanup_module_log(); ++ ++out_remove5: ++ remove_proc_entry(SCST_PROC_THREADS_NAME, scst_proc_scsi_tgt); ++ ++out_remove4: ++ remove_proc_entry(SCST_PROC_HELP_NAME, scst_proc_scsi_tgt); ++ ++out_remove3: ++ remove_proc_entry(SCST_PROC_SESSIONS_NAME, scst_proc_scsi_tgt); ++ ++out_remove2: ++ remove_proc_entry(SCST_PROC_VERSION_NAME, scst_proc_scsi_tgt); ++ ++out_remove1: ++ remove_proc_entry(SCST_PROC_ENTRY_NAME, scst_proc_scsi_tgt); ++ ++out_remove: ++ remove_proc_entry(SCST_PROC_ENTRY_NAME, NULL); ++ ++out_nomem: ++ res = -ENOMEM; ++ goto out; ++} ++ ++void __exit scst_proc_cleanup_module(void) ++{ ++ TRACE_ENTRY(); ++ ++ /* We may not bother about locks here */ ++ scst_proc_cleanup_sgv(); ++ scst_proc_cleanup_groups(); ++ scst_proc_cleanup_module_log(); ++ remove_proc_entry(SCST_PROC_THREADS_NAME, scst_proc_scsi_tgt); ++ remove_proc_entry(SCST_PROC_HELP_NAME, scst_proc_scsi_tgt); ++ remove_proc_entry(SCST_PROC_SESSIONS_NAME, scst_proc_scsi_tgt); ++ remove_proc_entry(SCST_PROC_VERSION_NAME, scst_proc_scsi_tgt); ++ remove_proc_entry(SCST_PROC_ENTRY_NAME, scst_proc_scsi_tgt); ++ remove_proc_entry(SCST_PROC_ENTRY_NAME, NULL); ++ ++ TRACE_EXIT(); ++} ++ ++static ssize_t scst_proc_threads_write(struct file *file, ++ const char __user *buf, ++ size_t length, loff_t *off) ++{ ++ int res = length; ++ int oldtn, newtn, delta; ++ char *buffer; ++ ++ TRACE_ENTRY(); ++ ++ if (length > SCST_PROC_BLOCK_SIZE) { ++ res = -EOVERFLOW; ++ goto out; ++ } ++ if (!buf) { ++ res = -EINVAL; ++ goto out; ++ } ++ buffer = (char *)__get_free_page(GFP_KERNEL); ++ if (!buffer) { ++ res = -ENOMEM; ++ goto out; ++ } ++ if (copy_from_user(buffer, buf, length)) { ++ res = -EFAULT; ++ goto out_free; ++ } ++ if (length < PAGE_SIZE) { ++ buffer[length] = '\0'; ++ } else if (buffer[PAGE_SIZE-1]) { ++ res = -EINVAL; ++ goto out_free; ++ } ++ ++ if (mutex_lock_interruptible(&scst_proc_mutex) != 0) { ++ res = -EINTR; ++ goto out_free; ++ } ++ ++ mutex_lock(&scst_mutex); ++ ++ oldtn = scst_main_cmd_threads.nr_threads; ++ newtn = simple_strtoul(buffer, NULL, 0); ++ if (newtn <= 0) { ++ PRINT_ERROR("Illegal threads num value %d", newtn); ++ res = -EINVAL; ++ goto out_up_thr_free; ++ } ++ delta = newtn - oldtn; ++ if (delta < 0) ++ scst_del_threads(&scst_main_cmd_threads, -delta); ++ else { ++ int rc = scst_add_threads(&scst_main_cmd_threads, NULL, NULL, ++ delta); ++ if (rc != 0) ++ res = rc; ++ } ++ ++ PRINT_INFO("Changed cmd threads num: old %d, new %d", oldtn, newtn); ++ ++out_up_thr_free: ++ mutex_unlock(&scst_mutex); ++ ++ mutex_unlock(&scst_proc_mutex); ++ ++out_free: ++ free_page((unsigned long)buffer); ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++int scst_build_proc_target_dir_entries(struct scst_tgt_template *vtt) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ /* create the proc directory entry for the device */ ++ vtt->proc_tgt_root = proc_mkdir(vtt->name, scst_proc_scsi_tgt); ++ if (vtt->proc_tgt_root == NULL) { ++ PRINT_ERROR("Not enough memory to register SCSI target %s " ++ "in /proc/%s", vtt->name, SCST_PROC_ENTRY_NAME); ++ goto out_nomem; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_nomem: ++ res = -ENOMEM; ++ goto out; ++} ++ ++void scst_cleanup_proc_target_dir_entries(struct scst_tgt_template *vtt) ++{ ++ TRACE_ENTRY(); ++ ++ remove_proc_entry(vtt->name, scst_proc_scsi_tgt); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Called under scst_mutex */ ++int scst_build_proc_target_entries(struct scst_tgt *vtt) ++{ ++ int res = 0; ++ struct proc_dir_entry *p; ++ char name[20]; ++ ++ TRACE_ENTRY(); ++ ++ if (vtt->tgtt->read_proc || vtt->tgtt->write_proc) { ++ /* create the proc file entry for the device */ ++ scnprintf(name, sizeof(name), "%d", vtt->tgtt->proc_dev_num); ++ scst_scsi_tgt_proc_data.data = (void *)vtt; ++ p = scst_create_proc_entry(vtt->tgtt->proc_tgt_root, ++ name, ++ &scst_scsi_tgt_proc_data); ++ if (p == NULL) { ++ PRINT_ERROR("Not enough memory to register SCSI " ++ "target entry %s in /proc/%s/%s", name, ++ SCST_PROC_ENTRY_NAME, vtt->tgtt->name); ++ res = -ENOMEM; ++ goto out; ++ } ++ vtt->proc_num = vtt->tgtt->proc_dev_num; ++ vtt->tgtt->proc_dev_num++; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++void scst_cleanup_proc_target_entries(struct scst_tgt *vtt) ++{ ++ char name[20]; ++ ++ TRACE_ENTRY(); ++ ++ if (vtt->tgtt->read_proc || vtt->tgtt->write_proc) { ++ scnprintf(name, sizeof(name), "%d", vtt->proc_num); ++ remove_proc_entry(name, vtt->tgtt->proc_tgt_root); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static ssize_t scst_proc_scsi_tgt_write(struct file *file, ++ const char __user *buf, ++ size_t length, loff_t *off) ++{ ++ struct scst_tgt *vtt = ++ (struct scst_tgt *)PDE(file->f_dentry->d_inode)->data; ++ ssize_t res = 0; ++ char *buffer; ++ char *start; ++ int eof = 0; ++ ++ TRACE_ENTRY(); ++ ++ if (vtt->tgtt->write_proc == NULL) { ++ res = -ENOSYS; ++ goto out; ++ } ++ ++ if (length > SCST_PROC_BLOCK_SIZE) { ++ res = -EOVERFLOW; ++ goto out; ++ } ++ if (!buf) { ++ res = -EINVAL; ++ goto out; ++ } ++ buffer = (char *)__get_free_page(GFP_KERNEL); ++ if (!buffer) { ++ res = -ENOMEM; ++ goto out; ++ } ++ if (copy_from_user(buffer, buf, length)) { ++ res = -EFAULT; ++ goto out_free; ++ } ++ if (length < PAGE_SIZE) { ++ buffer[length] = '\0'; ++ } else if (buffer[PAGE_SIZE-1]) { ++ res = -EINVAL; ++ goto out_free; ++ } ++ ++ TRACE_BUFFER("Buffer", buffer, length); ++ ++ if (mutex_lock_interruptible(&scst_proc_mutex) != 0) { ++ res = -EINTR; ++ goto out_free; ++ } ++ ++ res = vtt->tgtt->write_proc(buffer, &start, 0, length, &eof, vtt); ++ ++ mutex_unlock(&scst_proc_mutex); ++ ++out_free: ++ free_page((unsigned long)buffer); ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++int scst_build_proc_dev_handler_dir_entries(struct scst_dev_type *dev_type) ++{ ++ int res = 0; ++ struct proc_dir_entry *p; ++ const char *name; /* workaround to keep /proc ABI intact */ ++ ++ TRACE_ENTRY(); ++ ++ BUG_ON(dev_type->proc_dev_type_root); ++ ++ if (strcmp(dev_type->name, "vdisk_fileio") == 0) ++ name = "vdisk"; ++ else ++ name = dev_type->name; ++ ++ /* create the proc directory entry for the dev type handler */ ++ dev_type->proc_dev_type_root = proc_mkdir(name, ++ scst_proc_scsi_tgt); ++ if (dev_type->proc_dev_type_root == NULL) { ++ PRINT_ERROR("Not enough memory to register dev handler dir " ++ "%s in /proc/%s", name, SCST_PROC_ENTRY_NAME); ++ goto out_nomem; ++ } ++ ++ scst_dev_handler_type_proc_data.data = dev_type; ++ if (dev_type->type >= 0) { ++ p = scst_create_proc_entry(dev_type->proc_dev_type_root, ++ SCST_PROC_DEV_HANDLER_TYPE_ENTRY_NAME, ++ &scst_dev_handler_type_proc_data); ++ if (p == NULL) { ++ PRINT_ERROR("Not enough memory to register dev " ++ "handler entry %s in /proc/%s/%s", ++ SCST_PROC_DEV_HANDLER_TYPE_ENTRY_NAME, ++ SCST_PROC_ENTRY_NAME, name); ++ goto out_remove; ++ } ++ } ++ ++ if (dev_type->read_proc || dev_type->write_proc) { ++ /* create the proc file entry for the dev type handler */ ++ scst_dev_handler_proc_data.data = (void *)dev_type; ++ p = scst_create_proc_entry(dev_type->proc_dev_type_root, ++ name, ++ &scst_dev_handler_proc_data); ++ if (p == NULL) { ++ PRINT_ERROR("Not enough memory to register dev " ++ "handler entry %s in /proc/%s/%s", name, ++ SCST_PROC_ENTRY_NAME, name); ++ goto out_remove1; ++ } ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_remove1: ++ if (dev_type->type >= 0) ++ remove_proc_entry(SCST_PROC_DEV_HANDLER_TYPE_ENTRY_NAME, ++ dev_type->proc_dev_type_root); ++ ++out_remove: ++ remove_proc_entry(name, scst_proc_scsi_tgt); ++ ++out_nomem: ++ res = -ENOMEM; ++ goto out; ++} ++ ++void scst_cleanup_proc_dev_handler_dir_entries(struct scst_dev_type *dev_type) ++{ ++ /* Workaround to keep /proc ABI intact */ ++ const char *name; ++ ++ TRACE_ENTRY(); ++ ++ BUG_ON(dev_type->proc_dev_type_root == NULL); ++ ++ if (strcmp(dev_type->name, "vdisk_fileio") == 0) ++ name = "vdisk"; ++ else ++ name = dev_type->name; ++ ++ if (dev_type->type >= 0) { ++ remove_proc_entry(SCST_PROC_DEV_HANDLER_TYPE_ENTRY_NAME, ++ dev_type->proc_dev_type_root); ++ } ++ if (dev_type->read_proc || dev_type->write_proc) ++ remove_proc_entry(name, dev_type->proc_dev_type_root); ++ remove_proc_entry(name, scst_proc_scsi_tgt); ++ dev_type->proc_dev_type_root = NULL; ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static ssize_t scst_proc_scsi_dev_handler_write(struct file *file, ++ const char __user *buf, ++ size_t length, loff_t *off) ++{ ++ struct scst_dev_type *dev_type = ++ (struct scst_dev_type *)PDE(file->f_dentry->d_inode)->data; ++ ssize_t res = 0; ++ char *buffer; ++ char *start; ++ int eof = 0; ++ ++ TRACE_ENTRY(); ++ ++ if (dev_type->write_proc == NULL) { ++ res = -ENOSYS; ++ goto out; ++ } ++ ++ if (length > SCST_PROC_BLOCK_SIZE) { ++ res = -EOVERFLOW; ++ goto out; ++ } ++ if (!buf) { ++ res = -EINVAL; ++ goto out; ++ } ++ ++ buffer = (char *)__get_free_page(GFP_KERNEL); ++ if (!buffer) { ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ if (copy_from_user(buffer, buf, length)) { ++ res = -EFAULT; ++ goto out_free; ++ } ++ if (length < PAGE_SIZE) { ++ buffer[length] = '\0'; ++ } else if (buffer[PAGE_SIZE-1]) { ++ res = -EINVAL; ++ goto out_free; ++ } ++ ++ TRACE_BUFFER("Buffer", buffer, length); ++ ++ if (mutex_lock_interruptible(&scst_proc_mutex) != 0) { ++ res = -EINTR; ++ goto out_free; ++ } ++ ++ res = dev_type->write_proc(buffer, &start, 0, length, &eof, dev_type); ++ ++ mutex_unlock(&scst_proc_mutex); ++ ++out_free: ++ free_page((unsigned long)buffer); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t scst_proc_scsi_tgt_gen_write(struct file *file, ++ const char __user *buf, ++ size_t length, loff_t *off) ++{ ++ int res, rc = 0, action; ++ char *buffer, *p, *pp, *ppp; ++ struct scst_acg *a, *acg = NULL; ++ unsigned int addr_method = SCST_LUN_ADDR_METHOD_PERIPHERAL; ++ ++ TRACE_ENTRY(); ++ ++ if (length > SCST_PROC_BLOCK_SIZE) { ++ res = -EOVERFLOW; ++ goto out; ++ } ++ if (!buf) { ++ res = -EINVAL; ++ goto out; ++ } ++ buffer = (char *)__get_free_page(GFP_KERNEL); ++ if (!buffer) { ++ res = -ENOMEM; ++ goto out; ++ } ++ if (copy_from_user(buffer, buf, length)) { ++ res = -EFAULT; ++ goto out_free; ++ } ++ if (length < PAGE_SIZE) { ++ buffer[length] = '\0'; ++ } else if (buffer[PAGE_SIZE-1]) { ++ res = -EINVAL; ++ goto out_free; ++ } ++ ++ /* ++ * Usage: echo "add_group GROUP_NAME [FLAT]" >/proc/scsi_tgt/scsi_tgt ++ * or echo "add_group GROUP_NAME [LUN]" >/proc/scsi_tgt/scsi_tgt ++ * or echo "del_group GROUP_NAME" >/proc/scsi_tgt/scsi_tgt ++ * or echo "rename_group OLD_NAME NEW_NAME" >/proc/scsi_tgt/scsi_tgt" ++ * or echo "assign H:C:I:L HANDLER_NAME" >/proc/scsi_tgt/scsi_tgt ++ */ ++ p = buffer; ++ if (p[strlen(p) - 1] == '\n') ++ p[strlen(p) - 1] = '\0'; ++ if (!strncasecmp("assign ", p, 7)) { ++ p += 7; ++ action = SCST_PROC_ACTION_ASSIGN; ++ } else if (!strncasecmp("add_group ", p, 10)) { ++ p += 10; ++ action = SCST_PROC_ACTION_ADD_GROUP; ++ } else if (!strncasecmp("del_group ", p, 10)) { ++ p += 10; ++ action = SCST_PROC_ACTION_DEL_GROUP; ++ } else if (!strncasecmp("rename_group ", p, 13)) { ++ p += 13; ++ action = SCST_PROC_ACTION_RENAME_GROUP; ++ } else { ++ PRINT_ERROR("Unknown action \"%s\"", p); ++ res = -EINVAL; ++ goto out_free; ++ } ++ ++ res = scst_suspend_activity(true); ++ if (res != 0) ++ goto out_free; ++ ++ if (mutex_lock_interruptible(&scst_mutex) != 0) { ++ res = -EINTR; ++ goto out_free_resume; ++ } ++ ++ res = length; ++ ++ while (isspace(*p) && *p != '\0') ++ p++; ++ ++ switch (action) { ++ case SCST_PROC_ACTION_ADD_GROUP: ++ case SCST_PROC_ACTION_DEL_GROUP: ++ case SCST_PROC_ACTION_RENAME_GROUP: ++ pp = p; ++ while (!isspace(*pp) && *pp != '\0') ++ pp++; ++ if (*pp != '\0') { ++ *pp = '\0'; ++ pp++; ++ while (isspace(*pp) && *pp != '\0') ++ pp++; ++ if (*pp != '\0') { ++ switch (action) { ++ case SCST_PROC_ACTION_ADD_GROUP: ++ ppp = pp; ++ while (!isspace(*ppp) && *ppp != '\0') ++ ppp++; ++ if (*ppp != '\0') { ++ *ppp = '\0'; ++ ppp++; ++ while (isspace(*ppp) && *ppp != '\0') ++ ppp++; ++ if (*ppp != '\0') { ++ PRINT_ERROR("%s", "Too many " ++ "arguments"); ++ res = -EINVAL; ++ goto out_up_free; ++ } ++ } ++ if (strcasecmp(pp, "FLAT") == 0) ++ addr_method = SCST_LUN_ADDR_METHOD_FLAT; ++ else if (strcasecmp(pp, "LUN") == 0) ++ addr_method = SCST_LUN_ADDR_METHOD_LUN; ++ else { ++ PRINT_ERROR("Unexpected " ++ "argument %s", pp); ++ res = -EINVAL; ++ goto out_up_free; ++ } ++ break; ++ case SCST_PROC_ACTION_DEL_GROUP: ++ PRINT_ERROR("%s", "Too many " ++ "arguments"); ++ res = -EINVAL; ++ goto out_up_free; ++ } ++ } ++ } ++ ++ if (strcmp(p, SCST_DEFAULT_ACG_NAME) == 0) { ++ PRINT_ERROR("Attempt to add/delete/rename predefined " ++ "group \"%s\"", p); ++ res = -EINVAL; ++ goto out_up_free; ++ } ++ ++ list_for_each_entry(a, &scst_acg_list, acg_list_entry) { ++ if (strcmp(a->acg_name, p) == 0) { ++ TRACE_DBG("group (acg) %p %s found", ++ a, a->acg_name); ++ acg = a; ++ break; ++ } ++ } ++ ++ switch (action) { ++ case SCST_PROC_ACTION_ADD_GROUP: ++ if (acg) { ++ PRINT_ERROR("acg name %s exist", p); ++ res = -EINVAL; ++ goto out_up_free; ++ } ++ rc = scst_proc_group_add(p, addr_method); ++ break; ++ case SCST_PROC_ACTION_DEL_GROUP: ++ if (acg == NULL) { ++ PRINT_ERROR("acg name %s not found", p); ++ res = -EINVAL; ++ goto out_up_free; ++ } ++ rc = scst_proc_del_free_acg(acg, 1); ++ break; ++ case SCST_PROC_ACTION_RENAME_GROUP: ++ if (acg == NULL) { ++ PRINT_ERROR("acg name %s not found", p); ++ res = -EINVAL; ++ goto out_up_free; ++ } ++ ++ p = pp; ++ while (!isspace(*pp) && *pp != '\0') ++ pp++; ++ if (*pp != '\0') { ++ *pp = '\0'; ++ pp++; ++ while (isspace(*pp) && *pp != '\0') ++ pp++; ++ if (*pp != '\0') { ++ PRINT_ERROR("%s", "Too many arguments"); ++ res = -EINVAL; ++ goto out_up_free; ++ } ++ } ++ rc = scst_proc_rename_acg(acg, p); ++ break; ++ } ++ break; ++ case SCST_PROC_ACTION_ASSIGN: ++ rc = scst_proc_assign_handler(p); ++ break; ++ } ++ ++ if (rc != 0) ++ res = rc; ++ ++out_up_free: ++ mutex_unlock(&scst_mutex); ++ ++out_free_resume: ++ scst_resume_activity(); ++ ++out_free: ++ free_page((unsigned long)buffer); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* The activity supposed to be suspended and scst_mutex held */ ++static int scst_proc_assign_handler(char *buf) ++{ ++ int res = 0; ++ char *p = buf, *e, *ee; ++ unsigned long host, channel = 0, id = 0, lun = 0; ++ struct scst_device *d, *dev = NULL; ++ struct scst_dev_type *dt, *handler = NULL; ++ ++ TRACE_ENTRY(); ++ ++ while (isspace(*p) && *p != '\0') ++ p++; ++ ++ host = simple_strtoul(p, &p, 0); ++ if ((host == ULONG_MAX) || (*p != ':')) ++ goto out_synt_err; ++ p++; ++ channel = simple_strtoul(p, &p, 0); ++ if ((channel == ULONG_MAX) || (*p != ':')) ++ goto out_synt_err; ++ p++; ++ id = simple_strtoul(p, &p, 0); ++ if ((channel == ULONG_MAX) || (*p != ':')) ++ goto out_synt_err; ++ p++; ++ lun = simple_strtoul(p, &p, 0); ++ if (lun == ULONG_MAX) ++ goto out_synt_err; ++ ++ e = p; ++ e++; ++ while (isspace(*e) && *e != '\0') ++ e++; ++ ee = e; ++ while (!isspace(*ee) && *ee != '\0') ++ ee++; ++ *ee = '\0'; ++ ++ TRACE_DBG("Dev %ld:%ld:%ld:%ld, handler %s", host, channel, id, lun, e); ++ ++ list_for_each_entry(d, &scst_dev_list, dev_list_entry) { ++ if ((d->virt_id == 0) && ++ d->scsi_dev->host->host_no == host && ++ d->scsi_dev->channel == channel && ++ d->scsi_dev->id == id && ++ d->scsi_dev->lun == lun) { ++ dev = d; ++ TRACE_DBG("Dev %p (%ld:%ld:%ld:%ld) found", ++ dev, host, channel, id, lun); ++ break; ++ } ++ } ++ ++ if (dev == NULL) { ++ PRINT_ERROR("Device %ld:%ld:%ld:%ld not found", ++ host, channel, id, lun); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ list_for_each_entry(dt, &scst_dev_type_list, dev_type_list_entry) { ++ if (!strcmp(dt->name, e)) { ++ handler = dt; ++ TRACE_DBG("Dev handler %p with name %s found", ++ dt, dt->name); ++ break; ++ } ++ } ++ ++ if (handler == NULL) { ++ PRINT_ERROR("Handler %s not found", e); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (dev->scsi_dev->type != handler->type) { ++ PRINT_ERROR("Type %d of device %s differs from type " ++ "%d of dev handler %s", dev->type, ++ dev->handler->name, handler->type, handler->name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ res = scst_assign_dev_handler(dev, handler); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_synt_err: ++ PRINT_ERROR("Syntax error on %s", p); ++ res = -EINVAL; ++ goto out; ++} ++ ++static ssize_t scst_proc_groups_devices_write(struct file *file, ++ const char __user *buf, ++ size_t length, loff_t *off) ++{ ++ int res, action, rc, read_only = 0; ++ char *buffer, *p, *e = NULL; ++ unsigned int virt_lun; ++ struct scst_acg *acg = ++ (struct scst_acg *)PDE(file->f_dentry->d_inode)->data; ++ struct scst_acg_dev *acg_dev = NULL, *acg_dev_tmp; ++ struct scst_device *d, *dev = NULL; ++ ++ TRACE_ENTRY(); ++ ++ if (length > SCST_PROC_BLOCK_SIZE) { ++ res = -EOVERFLOW; ++ goto out; ++ } ++ if (!buf) { ++ res = -EINVAL; ++ goto out; ++ } ++ buffer = (char *)__get_free_page(GFP_KERNEL); ++ if (!buffer) { ++ res = -ENOMEM; ++ goto out; ++ } ++ if (copy_from_user(buffer, buf, length)) { ++ res = -EFAULT; ++ goto out_free; ++ } ++ if (length < PAGE_SIZE) { ++ buffer[length] = '\0'; ++ } else if (buffer[PAGE_SIZE-1]) { ++ res = -EINVAL; ++ goto out_free; ++ } ++ ++ /* ++ * Usage: echo "add|del H:C:I:L lun [READ_ONLY]" \ ++ * >/proc/scsi_tgt/groups/GROUP_NAME/devices ++ * or echo "replace H:C:I:L lun [READ_ONLY]" \ ++ * >/proc/scsi_tgt/groups/GROUP_NAME/devices ++ * or echo "add|del V_NAME lun [READ_ONLY]" \ ++ * >/proc/scsi_tgt/groups/GROUP_NAME/devices ++ * or echo "replace V_NAME lun [READ_ONLY]" \ ++ * >/proc/scsi_tgt/groups/GROUP_NAME/devices ++ * or echo "clear" >/proc/scsi_tgt/groups/GROUP_NAME/devices ++ */ ++ p = buffer; ++ if (p[strlen(p) - 1] == '\n') ++ p[strlen(p) - 1] = '\0'; ++ if (!strncasecmp("clear", p, 5)) { ++ action = SCST_PROC_ACTION_CLEAR; ++ } else if (!strncasecmp("add ", p, 4)) { ++ p += 4; ++ action = SCST_PROC_ACTION_ADD; ++ } else if (!strncasecmp("del ", p, 4)) { ++ p += 4; ++ action = SCST_PROC_ACTION_DEL; ++ } else if (!strncasecmp("replace ", p, 8)) { ++ p += 8; ++ action = SCST_PROC_ACTION_REPLACE; ++ } else { ++ PRINT_ERROR("Unknown action \"%s\"", p); ++ res = -EINVAL; ++ goto out_free; ++ } ++ ++ res = scst_suspend_activity(true); ++ if (res != 0) ++ goto out_free; ++ ++ if (mutex_lock_interruptible(&scst_mutex) != 0) { ++ res = -EINTR; ++ goto out_free_resume; ++ } ++ ++ res = length; ++ ++ switch (action) { ++ case SCST_PROC_ACTION_ADD: ++ case SCST_PROC_ACTION_DEL: ++ case SCST_PROC_ACTION_REPLACE: ++ while (isspace(*p) && *p != '\0') ++ p++; ++ e = p; /* save p */ ++ while (!isspace(*e) && *e != '\0') ++ e++; ++ *e = 0; ++ ++ list_for_each_entry(d, &scst_dev_list, dev_list_entry) { ++ if (!strcmp(d->virt_name, p)) { ++ dev = d; ++ TRACE_DBG("Device %p (%s) found", dev, p); ++ break; ++ } ++ } ++ if (dev == NULL) { ++ PRINT_ERROR("Device %s not found", p); ++ res = -EINVAL; ++ goto out_free_up; ++ } ++ break; ++ } ++ ++ /* ToDo: create separate functions */ ++ ++ switch (action) { ++ case SCST_PROC_ACTION_ADD: ++ case SCST_PROC_ACTION_REPLACE: ++ { ++ bool dev_replaced = false; ++ ++ e++; ++ while (isspace(*e) && *e != '\0') ++ e++; ++ ++ virt_lun = simple_strtoul(e, &e, 0); ++ if (virt_lun > SCST_MAX_LUN) { ++ PRINT_ERROR("Too big LUN %d (max %d)", virt_lun, ++ SCST_MAX_LUN); ++ res = -EINVAL; ++ goto out_free_up; ++ } ++ ++ while (isspace(*e) && *e != '\0') ++ e++; ++ ++ if (*e != '\0') { ++ if (!strncasecmp("READ_ONLY", e, 9)) ++ read_only = 1; ++ else { ++ PRINT_ERROR("Unknown option \"%s\"", e); ++ res = -EINVAL; ++ goto out_free_up; ++ } ++ } ++ ++ list_for_each_entry(acg_dev_tmp, &acg->acg_dev_list, ++ acg_dev_list_entry) { ++ if (acg_dev_tmp->lun == virt_lun) { ++ acg_dev = acg_dev_tmp; ++ break; ++ } ++ } ++ if (acg_dev != NULL) { ++ if (action == SCST_PROC_ACTION_ADD) { ++ PRINT_ERROR("virt lun %d already exists in " ++ "group %s", virt_lun, acg->acg_name); ++ res = -EEXIST; ++ goto out_free_up; ++ } else { ++ /* Replace */ ++ rc = scst_acg_del_lun(acg, acg_dev->lun, ++ false); ++ if (rc) { ++ res = rc; ++ goto out_free_up; ++ } ++ dev_replaced = true; ++ } ++ } ++ ++ rc = scst_acg_add_lun(acg, NULL, dev, virt_lun, read_only, ++ false, NULL); ++ if (rc) { ++ res = rc; ++ goto out_free_up; ++ } ++ ++ if (action == SCST_PROC_ACTION_ADD) ++ scst_report_luns_changed(acg); ++ ++ if (dev_replaced) { ++ struct scst_tgt_dev *tgt_dev; ++ ++ list_for_each_entry(tgt_dev, &dev->dev_tgt_dev_list, ++ dev_tgt_dev_list_entry) { ++ if ((tgt_dev->acg_dev->acg == acg) && ++ (tgt_dev->lun == virt_lun)) { ++ TRACE_MGMT_DBG("INQUIRY DATA HAS CHANGED" ++ " on tgt_dev %p", tgt_dev); ++ scst_gen_aen_or_ua(tgt_dev, ++ SCST_LOAD_SENSE(scst_sense_inquery_data_changed)); ++ } ++ } ++ } ++ break; ++ } ++ case SCST_PROC_ACTION_DEL: ++ { ++ /* ++ * This code doesn't handle if there are >1 LUNs for the same ++ * device in the group. Instead, it always deletes the first ++ * entry. It wasn't fixed for compatibility reasons, because ++ * procfs is now obsoleted. ++ */ ++ struct scst_acg_dev *a; ++ list_for_each_entry(a, &acg->acg_dev_list, acg_dev_list_entry) { ++ if (a->dev == dev) { ++ rc = scst_acg_del_lun(acg, a->lun, true); ++ if (rc) ++ res = rc; ++ goto out_free_up; ++ } ++ } ++ PRINT_ERROR("Device is not found in group %s", acg->acg_name); ++ break; ++ } ++ case SCST_PROC_ACTION_CLEAR: ++ list_for_each_entry_safe(acg_dev, acg_dev_tmp, ++ &acg->acg_dev_list, ++ acg_dev_list_entry) { ++ rc = scst_acg_del_lun(acg, acg_dev->lun, ++ list_is_last(&acg_dev->acg_dev_list_entry, ++ &acg->acg_dev_list)); ++ if (rc) { ++ res = rc; ++ goto out_free_up; ++ } ++ } ++ break; ++ } ++ ++out_free_up: ++ mutex_unlock(&scst_mutex); ++ ++out_free_resume: ++ scst_resume_activity(); ++ ++out_free: ++ free_page((unsigned long)buffer); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t scst_proc_groups_names_write(struct file *file, ++ const char __user *buf, ++ size_t length, loff_t *off) ++{ ++ int res = length, rc = 0, action; ++ char *buffer, *p, *pp = NULL; ++ struct scst_acg *acg = ++ (struct scst_acg *)PDE(file->f_dentry->d_inode)->data; ++ struct scst_acn *n, *nn; ++ ++ TRACE_ENTRY(); ++ ++ if (length > SCST_PROC_BLOCK_SIZE) { ++ res = -EOVERFLOW; ++ goto out; ++ } ++ if (!buf) { ++ res = -EINVAL; ++ goto out; ++ } ++ buffer = (char *)__get_free_page(GFP_KERNEL); ++ if (!buffer) { ++ res = -ENOMEM; ++ goto out; ++ } ++ if (copy_from_user(buffer, buf, length)) { ++ res = -EFAULT; ++ goto out_free; ++ } ++ if (length < PAGE_SIZE) { ++ buffer[length] = '\0'; ++ } else if (buffer[PAGE_SIZE-1]) { ++ res = -EINVAL; ++ goto out_free; ++ } ++ ++ /* ++ * Usage: echo "add|del NAME" >/proc/scsi_tgt/groups/GROUP_NAME/names ++ * or echo "move NAME NEW_GROUP_NAME" >/proc/scsi_tgt/groups/OLD_GROUP_NAME/names" ++ * or echo "clear" >/proc/scsi_tgt/groups/GROUP_NAME/names ++ */ ++ p = buffer; ++ if (p[strlen(p) - 1] == '\n') ++ p[strlen(p) - 1] = '\0'; ++ if (!strncasecmp("clear", p, 5)) { ++ action = SCST_PROC_ACTION_CLEAR; ++ } else if (!strncasecmp("add ", p, 4)) { ++ p += 4; ++ action = SCST_PROC_ACTION_ADD; ++ } else if (!strncasecmp("del ", p, 4)) { ++ p += 4; ++ action = SCST_PROC_ACTION_DEL; ++ } else if (!strncasecmp("move ", p, 5)) { ++ p += 5; ++ action = SCST_PROC_ACTION_MOVE; ++ } else { ++ PRINT_ERROR("Unknown action \"%s\"", p); ++ res = -EINVAL; ++ goto out_free; ++ } ++ ++ switch (action) { ++ case SCST_PROC_ACTION_ADD: ++ case SCST_PROC_ACTION_DEL: ++ case SCST_PROC_ACTION_MOVE: ++ while (isspace(*p) && *p != '\0') ++ p++; ++ pp = p; ++ while (!isspace(*pp) && *pp != '\0') ++ pp++; ++ if (*pp != '\0') { ++ *pp = '\0'; ++ pp++; ++ while (isspace(*pp) && *pp != '\0') ++ pp++; ++ if (*pp != '\0') { ++ switch (action) { ++ case SCST_PROC_ACTION_ADD: ++ case SCST_PROC_ACTION_DEL: ++ PRINT_ERROR("%s", "Too many " ++ "arguments"); ++ res = -EINVAL; ++ goto out_free; ++ } ++ } ++ } ++ break; ++ } ++ ++ rc = scst_suspend_activity(true); ++ if (rc != 0) ++ goto out_free; ++ ++ if (mutex_lock_interruptible(&scst_mutex) != 0) { ++ res = -EINTR; ++ goto out_free_resume; ++ } ++ ++ switch (action) { ++ case SCST_PROC_ACTION_ADD: ++ rc = scst_acg_add_acn(acg, p); ++ break; ++ case SCST_PROC_ACTION_DEL: ++ rc = scst_acg_remove_name(acg, p, true); ++ break; ++ case SCST_PROC_ACTION_MOVE: ++ { ++ struct scst_acg *a, *new_acg = NULL; ++ char *name = p; ++ p = pp; ++ while (!isspace(*pp) && *pp != '\0') ++ pp++; ++ if (*pp != '\0') { ++ *pp = '\0'; ++ pp++; ++ while (isspace(*pp) && *pp != '\0') ++ pp++; ++ if (*pp != '\0') { ++ PRINT_ERROR("%s", "Too many arguments"); ++ res = -EINVAL; ++ goto out_free_unlock; ++ } ++ } ++ list_for_each_entry(a, &scst_acg_list, acg_list_entry) { ++ if (strcmp(a->acg_name, p) == 0) { ++ TRACE_DBG("group (acg) %p %s found", ++ a, a->acg_name); ++ new_acg = a; ++ break; ++ } ++ } ++ if (new_acg == NULL) { ++ PRINT_ERROR("Group %s not found", p); ++ res = -EINVAL; ++ goto out_free_unlock; ++ } ++ rc = scst_acg_remove_name(acg, name, false); ++ if (rc != 0) ++ goto out_free_unlock; ++ rc = scst_acg_add_acn(new_acg, name); ++ if (rc != 0) ++ scst_acg_add_acn(acg, name); ++ break; ++ } ++ case SCST_PROC_ACTION_CLEAR: ++ list_for_each_entry_safe(n, nn, &acg->acn_list, ++ acn_list_entry) { ++ scst_del_free_acn(n, false); ++ } ++ scst_check_reassign_sessions(); ++ break; ++ } ++ ++out_free_unlock: ++ mutex_unlock(&scst_mutex); ++ ++out_free_resume: ++ scst_resume_activity(); ++ ++out_free: ++ free_page((unsigned long)buffer); ++ ++out: ++ if (rc < 0) ++ res = rc; ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_version_info_show(struct seq_file *seq, void *v) ++{ ++ TRACE_ENTRY(); ++ ++ seq_printf(seq, "%s\n", SCST_VERSION_STRING); ++ ++#ifdef CONFIG_SCST_STRICT_SERIALIZING ++ seq_printf(seq, "STRICT_SERIALIZING\n"); ++#endif ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ seq_printf(seq, "EXTRACHECKS\n"); ++#endif ++ ++#ifdef CONFIG_SCST_TRACING ++ seq_printf(seq, "TRACING\n"); ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG ++ seq_printf(seq, "DEBUG\n"); ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG_TM ++ seq_printf(seq, "DEBUG_TM\n"); ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG_RETRY ++ seq_printf(seq, "DEBUG_RETRY\n"); ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG_OOM ++ seq_printf(seq, "DEBUG_OOM\n"); ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG_SN ++ seq_printf(seq, "DEBUG_SN\n"); ++#endif ++ ++#ifdef CONFIG_SCST_USE_EXPECTED_VALUES ++ seq_printf(seq, "USE_EXPECTED_VALUES\n"); ++#endif ++ ++#ifdef CONFIG_SCST_TEST_IO_IN_SIRQ ++ seq_printf(seq, "TEST_IO_IN_SIRQ\n"); ++#endif ++ ++#ifdef CONFIG_SCST_STRICT_SECURITY ++ seq_printf(seq, "STRICT_SECURITY\n"); ++#endif ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++static struct scst_proc_data scst_version_proc_data = { ++ SCST_DEF_RW_SEQ_OP(NULL) ++ .show = scst_version_info_show, ++}; ++ ++static int scst_help_info_show(struct seq_file *seq, void *v) ++{ ++ TRACE_ENTRY(); ++ ++ seq_printf(seq, "%s\n", scst_proc_help_string); ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++static struct scst_proc_data scst_help_proc_data = { ++ SCST_DEF_RW_SEQ_OP(NULL) ++ .show = scst_help_info_show, ++}; ++ ++static int scst_dev_handler_type_info_show(struct seq_file *seq, void *v) ++{ ++ struct scst_dev_type *dev_type = (struct scst_dev_type *)seq->private; ++ ++ TRACE_ENTRY(); ++ ++ seq_printf(seq, "%d - %s\n", dev_type->type, ++ dev_type->type > (int)ARRAY_SIZE(scst_proc_dev_handler_type) ++ ? "unknown" : scst_proc_dev_handler_type[dev_type->type]); ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++static struct scst_proc_data scst_dev_handler_type_proc_data = { ++ SCST_DEF_RW_SEQ_OP(NULL) ++ .show = scst_dev_handler_type_info_show, ++}; ++ ++static int scst_sessions_info_show(struct seq_file *seq, void *v) ++{ ++ int res = 0; ++ struct scst_acg *acg; ++ struct scst_session *sess; ++ ++ TRACE_ENTRY(); ++ ++ if (mutex_lock_interruptible(&scst_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ ++ seq_printf(seq, "%-20s %-45s %-35s %-15s\n", ++ "Target name", "Initiator name", ++ "Group name", "Active/All Commands Count"); ++ ++ list_for_each_entry(acg, &scst_acg_list, acg_list_entry) { ++ list_for_each_entry(sess, &acg->acg_sess_list, ++ acg_sess_list_entry) { ++ int active_cmds = 0, t; ++ for (t = SESS_TGT_DEV_LIST_HASH_SIZE-1; t >= 0; t--) { ++ struct list_head *head = ++ &sess->sess_tgt_dev_list[t]; ++ struct scst_tgt_dev *tgt_dev; ++ list_for_each_entry(tgt_dev, head, ++ sess_tgt_dev_list_entry) { ++ active_cmds += atomic_read(&tgt_dev->tgt_dev_cmd_count); ++ } ++ } ++ seq_printf(seq, "%-20s %-45s %-35s %d/%d\n", ++ sess->tgt->tgtt->name, ++ sess->initiator_name, ++ acg->acg_name, active_cmds, ++ atomic_read(&sess->sess_cmd_count)); ++ } ++ } ++ ++ mutex_unlock(&scst_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct scst_proc_data scst_sessions_proc_data = { ++ SCST_DEF_RW_SEQ_OP(NULL) ++ .show = scst_sessions_info_show, ++}; ++ ++static struct scst_proc_data scst_sgv_proc_data = { ++ SCST_DEF_RW_SEQ_OP(NULL) ++ .show = sgv_procinfo_show, ++}; ++ ++static int scst_groups_names_show(struct seq_file *seq, void *v) ++{ ++ int res = 0; ++ struct scst_acg *acg = (struct scst_acg *)seq->private; ++ struct scst_acn *name; ++ ++ TRACE_ENTRY(); ++ ++ if (mutex_lock_interruptible(&scst_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ ++ list_for_each_entry(name, &acg->acn_list, acn_list_entry) { ++ seq_printf(seq, "%s\n", name->name); ++ } ++ ++ mutex_unlock(&scst_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct scst_proc_data scst_groups_names_proc_data = { ++ SCST_DEF_RW_SEQ_OP(scst_proc_groups_names_write) ++ .show = scst_groups_names_show, ++}; ++ ++static int scst_groups_addr_method_show(struct seq_file *seq, void *v) ++{ ++ int res = 0; ++ struct scst_acg *acg = (struct scst_acg *)seq->private; ++ ++ TRACE_ENTRY(); ++ ++ if (mutex_lock_interruptible(&scst_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ ++ switch (acg->addr_method) { ++ case SCST_LUN_ADDR_METHOD_FLAT: ++ seq_printf(seq, "%s\n", "FLAT"); ++ break; ++ case SCST_LUN_ADDR_METHOD_PERIPHERAL: ++ seq_printf(seq, "%s\n", "PERIPHERAL"); ++ break; ++ case SCST_LUN_ADDR_METHOD_LUN: ++ seq_printf(seq, "%s\n", "LUN"); ++ break; ++ default: ++ seq_printf(seq, "%s\n", "UNKNOWN"); ++ break; ++ } ++ ++ mutex_unlock(&scst_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++static struct scst_proc_data scst_groups_addr_method_proc_data = { ++ SCST_DEF_RW_SEQ_OP(NULL) ++ .show = scst_groups_addr_method_show, ++}; ++static int scst_groups_devices_show(struct seq_file *seq, void *v) ++{ ++ int res = 0; ++ struct scst_acg *acg = (struct scst_acg *)seq->private; ++ struct scst_acg_dev *acg_dev; ++ ++ TRACE_ENTRY(); ++ ++ if (mutex_lock_interruptible(&scst_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ ++ seq_printf(seq, "%-60s%-13s%s\n", "Device (host:ch:id:lun or name)", ++ "LUN", "Options"); ++ ++ list_for_each_entry(acg_dev, &acg->acg_dev_list, acg_dev_list_entry) { ++ seq_printf(seq, "%-60s%-13lld%s\n", ++ acg_dev->dev->virt_name, ++ (long long unsigned int)acg_dev->lun, ++ acg_dev->rd_only ? "RO" : ""); ++ } ++ mutex_unlock(&scst_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct scst_proc_data scst_groups_devices_proc_data = { ++ SCST_DEF_RW_SEQ_OP(scst_proc_groups_devices_write) ++ .show = scst_groups_devices_show, ++}; ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ ++static int scst_proc_read_tbl(const struct scst_trace_log *tbl, ++ struct seq_file *seq, ++ unsigned long log_level, int *first) ++{ ++ const struct scst_trace_log *t = tbl; ++ int res = 0; ++ ++ while (t->token) { ++ if (log_level & t->val) { ++ seq_printf(seq, "%s%s", *first ? "" : " | ", t->token); ++ *first = 0; ++ } ++ t++; ++ } ++ return res; ++} ++ ++int scst_proc_log_entry_read(struct seq_file *seq, unsigned long log_level, ++ const struct scst_trace_log *tbl) ++{ ++ int res = 0, first = 1; ++ ++ TRACE_ENTRY(); ++ ++ scst_proc_read_tbl(scst_proc_trace_tbl, seq, log_level, &first); ++ ++ if (tbl) ++ scst_proc_read_tbl(tbl, seq, log_level, &first); ++ ++ seq_printf(seq, "%s\n", first ? "none" : ""); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++EXPORT_SYMBOL_GPL(scst_proc_log_entry_read); ++ ++static int log_info_show(struct seq_file *seq, void *v) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ if (mutex_lock_interruptible(&scst_log_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ ++ res = scst_proc_log_entry_read(seq, trace_flag, ++ scst_proc_local_trace_tbl); ++ ++ mutex_unlock(&scst_log_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct scst_proc_data scst_log_proc_data = { ++ SCST_DEF_RW_SEQ_OP(scst_proc_scsi_tgt_gen_write_log) ++ .show = log_info_show, ++ .data = "scsi_tgt", ++}; ++ ++#endif ++ ++static int scst_tgt_info_show(struct seq_file *seq, void *v) ++{ ++ int res = 0; ++ struct scst_device *dev; ++ ++ TRACE_ENTRY(); ++ ++ if (mutex_lock_interruptible(&scst_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ ++ seq_printf(seq, "%-60s%s\n", "Device (host:ch:id:lun or name)", ++ "Device handler"); ++ list_for_each_entry(dev, &scst_dev_list, dev_list_entry) { ++ seq_printf(seq, "%-60s%s\n", ++ dev->virt_name, dev->handler->name); ++ } ++ ++ mutex_unlock(&scst_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct scst_proc_data scst_tgt_proc_data = { ++ SCST_DEF_RW_SEQ_OP(scst_proc_scsi_tgt_gen_write) ++ .show = scst_tgt_info_show, ++}; ++ ++static int scst_threads_info_show(struct seq_file *seq, void *v) ++{ ++ TRACE_ENTRY(); ++ ++ seq_printf(seq, "%d\n", scst_main_cmd_threads.nr_threads); ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++static struct scst_proc_data scst_threads_proc_data = { ++ SCST_DEF_RW_SEQ_OP(scst_proc_threads_write) ++ .show = scst_threads_info_show, ++}; ++ ++static int scst_scsi_tgtinfo_show(struct seq_file *seq, void *v) ++{ ++ struct scst_tgt *vtt = seq->private; ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ if (mutex_lock_interruptible(&scst_proc_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ ++ if (vtt->tgtt->read_proc) ++ res = vtt->tgtt->read_proc(seq, vtt); ++ ++ mutex_unlock(&scst_proc_mutex); ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct scst_proc_data scst_scsi_tgt_proc_data = { ++ SCST_DEF_RW_SEQ_OP(scst_proc_scsi_tgt_write) ++ .show = scst_scsi_tgtinfo_show, ++}; ++ ++static int scst_dev_handler_info_show(struct seq_file *seq, void *v) ++{ ++ struct scst_dev_type *dev_type = seq->private; ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ if (mutex_lock_interruptible(&scst_proc_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ ++ if (dev_type->read_proc) ++ res = dev_type->read_proc(seq, dev_type); ++ ++ mutex_unlock(&scst_proc_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct scst_proc_data scst_dev_handler_proc_data = { ++ SCST_DEF_RW_SEQ_OP(scst_proc_scsi_dev_handler_write) ++ .show = scst_dev_handler_info_show, ++}; ++ ++struct proc_dir_entry *scst_create_proc_entry(struct proc_dir_entry *root, ++ const char *name, struct scst_proc_data *pdata) ++{ ++ struct proc_dir_entry *p = NULL; ++ ++ TRACE_ENTRY(); ++ ++ if (root) { ++ mode_t mode; ++ ++ mode = S_IFREG | S_IRUGO | (pdata->seq_op.write ? S_IWUSR : 0); ++ p = create_proc_entry(name, mode, root); ++ if (p == NULL) { ++ PRINT_ERROR("Fail to create entry %s in /proc", name); ++ } else { ++ p->proc_fops = &pdata->seq_op; ++ p->data = pdata->data; ++ } ++ } ++ ++ TRACE_EXIT(); ++ return p; ++} ++EXPORT_SYMBOL_GPL(scst_create_proc_entry); ++ ++int scst_single_seq_open(struct inode *inode, struct file *file) ++{ ++ struct scst_proc_data *pdata = container_of(PDE(inode)->proc_fops, ++ struct scst_proc_data, seq_op); ++ return single_open(file, pdata->show, PDE(inode)->data); ++} ++EXPORT_SYMBOL_GPL(scst_single_seq_open); ++ ++struct proc_dir_entry *scst_proc_get_tgt_root( ++ struct scst_tgt_template *vtt) ++{ ++ return vtt->proc_tgt_root; ++} ++EXPORT_SYMBOL_GPL(scst_proc_get_tgt_root); ++ ++struct proc_dir_entry *scst_proc_get_dev_type_root( ++ struct scst_dev_type *dtt) ++{ ++ return dtt->proc_dev_type_root; ++} ++EXPORT_SYMBOL_GPL(scst_proc_get_dev_type_root); +diff -uprN orig/linux-3.2/Documentation/scst/README.scst linux-3.2/Documentation/scst/README.scst +--- orig/linux-3.2/Documentation/scst/README.scst ++++ linux-3.2/Documentation/scst/README.scst +@@ -0,0 +1,1535 @@ ++Generic SCSI target mid-level for Linux (SCST) ++============================================== ++ ++SCST is designed to provide unified, consistent interface between SCSI ++target drivers and Linux kernel and simplify target drivers development ++as much as possible. Detail description of SCST's features and internals ++could be found on its Internet page http://scst.sourceforge.net. ++ ++SCST supports the following I/O modes: ++ ++ * Pass-through mode with one to many relationship, i.e. when multiple ++ initiators can connect to the exported pass-through devices, for ++ the following SCSI devices types: disks (type 0), tapes (type 1), ++ processors (type 3), CDROMs (type 5), MO disks (type 7), medium ++ changers (type 8) and RAID controllers (type 0xC). ++ ++ * FILEIO mode, which allows to use files on file systems or block ++ devices as virtual remotely available SCSI disks or CDROMs with ++ benefits of the Linux page cache. ++ ++ * BLOCKIO mode, which performs direct block IO with a block device, ++ bypassing page-cache for all operations. This mode works ideally with ++ high-end storage HBAs and for applications that either do not need ++ caching between application and disk or need the large block ++ throughput. ++ ++ * "Performance" device handlers, which provide in pseudo pass-through ++ mode a way for direct performance measurements without overhead of ++ actual data transferring from/to underlying SCSI device. ++ ++In addition, SCST supports advanced per-initiator access and devices ++visibility management, so different initiators could see different set ++of devices with different access permissions. See below for details. ++ ++Full list of SCST features and comparison with other Linux targets you ++can find on http://scst.sourceforge.net/comparison.html. ++ ++ ++Installation ++------------ ++ ++To see your devices remotely, you need to add a corresponding LUN for ++them (see below how). By default, no local devices are seen remotely. ++There must be LUN 0 in each LUNs set (security group), i.e. LUs ++numeration must not start from, e.g., 1. Otherwise you will see no ++devices on remote initiators and SCST core will write into the kernel ++log message: "tgt_dev for LUN 0 not found, command to unexisting LU?" ++ ++It is highly recommended to use scstadmin utility for configuring ++devices and security groups. ++ ++The flow of SCST inialization should be as the following: ++ ++1. Load of SCST modules with necessary module parameters, if needed. ++ ++2. Configure targets, devices, LUNs, etc. using either scstadmin ++(recommended), or the sysfs interface directly as described below. ++ ++If you experience problems during modules load or running, check your ++kernel logs (or run dmesg command for the few most recent messages). ++ ++IMPORTANT: Without loading appropriate device handler, corresponding devices ++========= will be invisible for remote initiators, which could lead to holes ++ in the LUN addressing, so automatic device scanning by remote SCSI ++ mid-level could not notice the devices. Therefore you will have ++ to add them manually via ++ 'echo "- - -" >/sys/class/scsi_host/hostX/scan', ++ where X - is the host number. ++ ++IMPORTANT: Working of target and initiator on the same host is ++========= supported, except the following 2 cases: swap over target exported ++ device and using a writable mmap over a file from target ++ exported device. The latter means you can't mount a file ++ system over target exported device. In other words, you can ++ freely use any sg, sd, st, etc. devices imported from target ++ on the same host, but you can't mount file systems or put ++ swap on them. This is a limitation of Linux memory/cache ++ manager, because in this case a memory allocation deadlock is ++ possible like: system needs some memory -> it decides to ++ clear some cache -> the cache is needed to be written on a ++ target exported device -> initiator sends request to the ++ target located on the same system -> the target needs memory ++ -> the system needs even more memory -> deadlock. ++ ++IMPORTANT: In the current version simultaneous access to local SCSI devices ++========= via standard high-level SCSI drivers (sd, st, sg, etc.) and ++ SCST's target drivers is unsupported. Especially it is ++ important for execution via sg and st commands that change ++ the state of devices and their parameters, because that could ++ lead to data corruption. If any such command is done, at ++ least related device handler(s) must be restarted. For block ++ devices READ/WRITE commands using direct disk handler are ++ generally safe. ++ ++ ++Usage in failover mode ++---------------------- ++ ++It is recommended to use TEST UNIT READY ("tur") command to check if ++SCST target is alive in MPIO configurations. ++ ++ ++Device handlers ++--------------- ++ ++Device specific drivers (device handlers) are plugins for SCST, which ++help SCST to analyze incoming requests and determine parameters, ++specific to various types of devices. If an appropriate device handler ++for a SCSI device type isn't loaded, SCST doesn't know how to handle ++devices of this type, so they will be invisible for remote initiators ++(more precisely, "LUN not supported" sense code will be returned). ++ ++In addition to device handlers for real devices, there are VDISK, user ++space and "performance" device handlers. ++ ++VDISK device handler works over files on file systems and makes from ++them virtual remotely available SCSI disks or CDROM's. In addition, it ++allows to work directly over a block device, e.g. local IDE or SCSI disk ++or ever disk partition, where there is no file systems overhead. Using ++block devices comparing to sending SCSI commands directly to SCSI ++mid-level via scsi_do_req()/scsi_execute_async() has advantage that data ++are transferred via system cache, so it is possible to fully benefit ++from caching and read ahead performed by Linux's VM subsystem. The only ++disadvantage here that in the FILEIO mode there is superfluous data ++copying between the cache and SCST's buffers. This issue is going to be ++addressed in one of the future releases. Virtual CDROM's are useful for ++remote installation. See below for details how to setup and use VDISK ++device handler. ++ ++"Performance" device handlers for disks, MO disks and tapes in their ++exec() method skip (pretend to execute) all READ and WRITE operations ++and thus provide a way for direct link performance measurements without ++overhead of actual data transferring from/to underlying SCSI device. ++ ++NOTE: Since "perf" device handlers on READ operations don't touch the ++==== commands' data buffer, it is returned to remote initiators as it ++ was allocated, without even being zeroed. Thus, "perf" device ++ handlers impose some security risk, so use them with caution. ++ ++ ++Compilation options ++------------------- ++ ++There are the following compilation options, that could be change using ++your favorite kernel configuration Makefile target, e.g. "make xconfig": ++ ++ - CONFIG_SCST_DEBUG - if defined, turns on some debugging code, ++ including some logging. Makes the driver considerably bigger and slower, ++ producing large amount of log data. ++ ++ - CONFIG_SCST_TRACING - if defined, turns on ability to log events. Makes the ++ driver considerably bigger and leads to some performance loss. ++ ++ - CONFIG_SCST_EXTRACHECKS - if defined, adds extra validity checks in ++ the various places. ++ ++ - CONFIG_SCST_USE_EXPECTED_VALUES - if not defined (default), initiator ++ supplied expected data transfer length and direction will be used ++ only for verification purposes to return error or warn in case if one ++ of them is invalid. Instead, locally decoded from SCSI command values ++ will be used. This is necessary for security reasons, because ++ otherwise a faulty initiator can crash target by supplying invalid ++ value in one of those parameters. This is especially important in ++ case of pass-through mode. If CONFIG_SCST_USE_EXPECTED_VALUES is ++ defined, initiator supplied expected data transfer length and ++ direction will override the locally decoded values. This might be ++ necessary if internal SCST commands translation table doesn't contain ++ SCSI command, which is used in your environment. You can know that if ++ you enable "minor" trace level and have messages like "Unknown ++ opcode XX for YY. Should you update scst_scsi_op_table?" in your ++ kernel log and your initiator returns an error. Also report those ++ messages in the SCST mailing list scst-devel@lists.sourceforge.net. ++ Note, that not all SCSI transports support supplying expected values. ++ You should try to enable this option if you have a not working with ++ SCST pass-through device, for instance, an SATA CDROM. ++ ++ - CONFIG_SCST_DEBUG_TM - if defined, turns on task management functions ++ debugging, when on LUN 6 some of the commands will be delayed for ++ about 60 sec., so making the remote initiator send TM functions, eg ++ ABORT TASK and TARGET RESET. Also define ++ CONFIG_SCST_TM_DBG_GO_OFFLINE symbol in the Makefile if you want that ++ the device eventually become completely unresponsive, or otherwise to ++ circle around ABORTs and RESETs code. Needs CONFIG_SCST_DEBUG turned ++ on. ++ ++ - CONFIG_SCST_STRICT_SERIALIZING - if defined, makes SCST send all commands to ++ underlying SCSI device synchronously, one after one. This makes task ++ management more reliable, with cost of some performance penalty. This ++ is mostly actual for stateful SCSI devices like tapes, where the ++ result of command's execution depends from device's settings defined ++ by previous commands. Disk and RAID devices are stateless in the most ++ cases. The current SCSI core in Linux doesn't allow to abort all ++ commands reliably if they sent asynchronously to a stateful device. ++ Turned off by default, turn it on if you use stateful device(s) and ++ need as much error recovery reliability as possible. As a side effect ++ of CONFIG_SCST_STRICT_SERIALIZING, on kernels below 2.6.30 no kernel ++ patching is necessary for pass-through device handlers (scst_disk, ++ etc.). ++ ++ - CONFIG_SCST_TEST_IO_IN_SIRQ - if defined, allows SCST to submit selected ++ SCSI commands (TUR and READ/WRITE) from soft-IRQ context (tasklets). ++ Enabling it will decrease amount of context switches and slightly ++ improve performance. The goal of this option is to be able to measure ++ overhead of the context switches. If after enabling this option you ++ don't see under load in vmstat output on the target significant ++ decrease of amount of context switches, then your target driver ++ doesn't submit commands to SCST in IRQ context. For instance, ++ iSCSI-SCST doesn't do that, but qla2x00t with ++ CONFIG_QLA_TGT_DEBUG_WORK_IN_THREAD disabled - does. This option is ++ designed to be used with vdisk NULLIO backend. ++ ++ WARNING! Using this option enabled with other backend than vdisk ++ NULLIO is unsafe and can lead you to a kernel crash! ++ ++ - CONFIG_SCST_STRICT_SECURITY - if defined, makes SCST zero allocated data ++ buffers. Undefining it (default) considerably improves performance ++ and eases CPU load, but could create a security hole (information ++ leakage), so enable it, if you have strict security requirements. ++ ++ - CONFIG_SCST_ABORT_CONSIDER_FINISHED_TASKS_AS_NOT_EXISTING - if defined, ++ in case when TASK MANAGEMENT function ABORT TASK is trying to abort a ++ command, which has already finished, remote initiator, which sent the ++ ABORT TASK request, will receive TASK NOT EXIST (or ABORT FAILED) ++ response for the ABORT TASK request. This is more logical response, ++ since, because the command finished, attempt to abort it failed, but ++ some initiators, particularly VMware iSCSI initiator, consider TASK ++ NOT EXIST response as if the target got crazy and try to RESET it. ++ Then sometimes get crazy itself. So, this option is disabled by ++ default. ++ ++ - CONFIG_SCST_MEASURE_LATENCY - if defined, provides in "latency" files ++ global and per-LUN average commands processing latency statistic. You ++ can clear already measured results by writing 0 in each file. Note, ++ you need a non-preemptible kernel to have correct results. ++ ++HIGHMEM kernel configurations are fully supported, but not recommended ++for performance reasons. ++ ++ ++Module parameters ++----------------- ++ ++Module scst supports the following parameters: ++ ++ - scst_threads - allows to set count of SCST's threads. By default it ++ is CPU count. ++ ++ - scst_max_cmd_mem - sets maximum amount of memory in MB allowed to be ++ consumed by the SCST commands for data buffers at any given time. By ++ default it is approximately TotalMem/4. ++ ++ ++SCST sysfs interface ++-------------------- ++ ++SCST sysfs interface designed to be self descriptive and self ++containing. This means that a high level managament tool for it can be ++written once and automatically support any future sysfs interface ++changes (attributes additions or removals, new target drivers and dev ++handlers, etc.) without any modifications. Scstadmin is an example of ++such management tool. ++ ++To implement that an management tool should not be implemented around ++drivers and their attributes, but around common rules those drivers and ++attributes follow. You can find those rules in SysfsRules file. For ++instance, each SCST sysfs file (attribute) can contain in the last line ++mark "[key]". It is automatically added to allow scstadmin and other ++management tools to see which attributes it should save in the config ++file. If you are doing manual attributes manipulations, you can ignore ++this mark. ++ ++Root of SCST sysfs interface is /sys/kernel/scst_tgt. It has the ++following entries: ++ ++ - devices - this is a root subdirectory for all SCST devices ++ ++ - handlers - this is a root subdirectory for all SCST dev handlers ++ ++ - max_tasklet_cmd - specifies how many commands at max can be queued in ++ the SCST core simultaneously on a single CPU from all connected ++ initiators to allow processing commands on this CPU in soft-IRQ ++ context in tasklets. If the count of the commands exceeds this value, ++ then all of them will be processed only in SCST threads. This is to ++ to prevent possible under heavy load starvation of processes on the ++ CPUs serving soft IRQs and in some cases to improve performance by ++ more evenly spreading load over available CPUs. ++ ++ - sgv - this is a root subdirectory for all SCST SGV caches ++ ++ - targets - this is a root subdirectory for all SCST targets ++ ++ - setup_id - allows to read and write SCST setup ID. This ID can be ++ used in cases, when the same SCST configuration should be installed ++ on several targets, but exported from those targets devices should ++ have different IDs and SNs. For instance, VDISK dev handler uses this ++ ID to generate T10 vendor specific identifier and SN of the devices. ++ ++ - threads - allows to read and set number of global SCST I/O threads. ++ Those threads used with async. dev handlers, for instance, vdisk ++ BLOCKIO or NULLIO. ++ ++ - trace_level - allows to enable and disable various tracing ++ facilities. See content of this file for help how to use it. See also ++ section "Dealing with massive logs" for more info how to make correct ++ logs when you enabled trace levels producing a lot of logs data. ++ ++ - version - read-only attribute, which allows to see version of ++ SCST and enabled optional features. ++ ++ - last_sysfs_mgmt_res - read-only attribute returning completion status ++ of the last management command. In the sysfs implementation there are ++ some problems between internal sysfs and internal SCST locking. To ++ avoid them in some cases sysfs calls can return error with errno ++ EAGAIN. This doesn't mean the operation failed. It only means that ++ the operation queued and not yet completed. To wait for it to ++ complete, an management tool should poll this file. If the operation ++ hasn't yet completed, it will also return EAGAIN. But after it's ++ completed, it will return the result of this operation (0 for success ++ or -errno for error). ++ ++"Devices" subdirectory contains subdirectories for each SCST devices. ++ ++Content of each device's subdirectory is dev handler specific. See ++documentation for your dev handlers for more info about it as well as ++SysfsRules file for more info about common to all dev handlers rules. ++SCST dev handlers can have the following common entries: ++ ++ - exported - subdirectory containing links to all LUNs where this ++ device was exported. ++ ++ - handler - if dev handler determined for this device, this link points ++ to it. The handler can be not set for pass-through devices. ++ ++ - threads_num - shows and allows to set number of threads in this device's ++ threads pool. If 0 - no threads will be created, and global SCST ++ threads pool will be used. If <0 - creation of the threads pool is ++ prohibited. ++ ++ - threads_pool_type - shows and allows to sets threads pool type. ++ Possible values: "per_initiator" and "shared". When the value is ++ "per_initiator" (default), each session from each initiator will use ++ separate dedicated pool of threads. When the value is "shared", all ++ sessions from all initiators will share the same per-device pool of ++ threads. Valid only if threads_num attribute >0. ++ ++ - dump_prs - allows to dump persistent reservations information in the ++ kernel log. ++ ++ - type - SCSI type of this device ++ ++See below for more information about other entries of this subdirectory ++of the standard SCST dev handlers. ++ ++"Handlers" subdirectory contains subdirectories for each SCST dev ++handler. ++ ++Content of each handler's subdirectory is dev handler specific. See ++documentation for your dev handlers for more info about it as well as ++SysfsRules file for more info about common to all dev handlers rules. ++SCST dev handlers can have the following common entries: ++ ++ - mgmt - this entry allows to create virtual devices and their ++ attributes (for virtual devices dev handlers) or assign/unassign real ++ SCSI devices to/from this dev handler (for pass-through dev ++ handlers). ++ ++ - trace_level - allows to enable and disable various tracing ++ facilities. See content of this file for help how to use it. See also ++ section "Dealing with massive logs" for more info how to make correct ++ logs when you enabled trace levels producing a lot of logs data. ++ ++ - type - SCSI type of devices served by this dev handler. ++ ++See below for more information about other entries of this subdirectory ++of the standard SCST dev handlers. ++ ++"Sgv" subdirectory contains statistic information of SCST SGV caches. It ++has the following entries: ++ ++ - None, one or more subdirectories for each existing SGV cache. ++ ++ - global_stats - file containing global SGV caches statistics. ++ ++Each SGV cache's subdirectory has the following item: ++ ++ - stats - file containing statistics for this SGV caches. ++ ++"Targets" subdirectory contains subdirectories for each SCST target. ++ ++Content of each target's subdirectory is target specific. See ++documentation for your target for more info about it as well as ++SysfsRules file for more info about common to all targets rules. ++Every target should have at least the following entries: ++ ++ - ini_groups - subdirectory, which contains and allows to define ++ initiator-oriented access control information, see below. ++ ++ - luns - subdirectory, which contains list of available LUNs in the ++ target-oriented access control and allows to define it, see below. ++ ++ - sessions - subdirectory containing connected to this target sessions. ++ ++ - comment - this attribute can be used to store any human readable info ++ to help identify target. For instance, to help identify the target's ++ mapping to the corresponding hardware port. It isn't anyhow used by ++ SCST. ++ ++ - enabled - using this attribute you can enable or disable this target/ ++ It allows to finish configuring it before it starts accepting new ++ connections. 0 by default. ++ ++ - addr_method - used LUNs addressing method. Possible values: ++ "Peripheral" and "Flat". Most initiators work well with Peripheral ++ addressing method (default), but some (HP-UX, for instance) may ++ require Flat method. This attribute is also available in the ++ initiators security groups, so you can assign the addressing method ++ on per-initiator basis. ++ ++ - cpu_mask - defines CPU affinity mask for threads serving this target. ++ For threads serving LUNs it is used only for devices with ++ threads_pool_type "per_initiator". ++ ++ - io_grouping_type - defines how I/O from sessions to this target are ++ grouped together. This I/O grouping is very important for ++ performance. By setting this attribute in a right value, you can ++ considerably increase performance of your setup. This grouping is ++ performed only if you use CFQ I/O scheduler on the target and for ++ devices with threads_num >= 0 and, if threads_num > 0, with ++ threads_pool_type "per_initiator". Possible values: ++ "this_group_only", "never", "auto", or I/O group number >0. When the ++ value is "this_group_only" all I/O from all sessions in this target ++ will be grouped together. When the value is "never", I/O from ++ different sessions will not be grouped together, i.e. all sessions in ++ this target will have separate dedicated I/O groups. When the value ++ is "auto" (default), all I/O from initiators with the same name ++ (iSCSI initiator name, for instance) in all targets will be grouped ++ together with a separate dedicated I/O group for each initiator name. ++ For iSCSI this mode works well, but other transports usually use ++ different initiator names for different sessions, so using such ++ transports in MPIO configurations you should either use value ++ "this_group_only", or an explicit I/O group number. This attribute is ++ also available in the initiators security groups, so you can assign ++ the I/O grouping on per-initiator basis. See below for more info how ++ to use this attribute. ++ ++ - rel_tgt_id - allows to read or write SCSI Relative Target Port ++ Identifier attribute. This identifier is used to identify SCSI Target ++ Ports by some SCSI commands, mainly by Persistent Reservations ++ commands. This identifier must be unique among all SCST targets, but ++ for convenience SCST allows disabled targets to have not unique ++ rel_tgt_id. In this case SCST will not allow to enable this target ++ until rel_tgt_id becomes unique. This attribute initialized unique by ++ SCST by default. ++ ++A target driver may have also the following entries: ++ ++ - "hw_target" - if the target driver supports both hardware and virtual ++ targets (for instance, an FC adapter supporting NPIV, which has ++ hardware targets for its physical ports as well as virtual NPIV ++ targets), this read only attribute for all hardware targets will ++ exist and contain value 1. ++ ++Subdirectory "sessions" contains one subdirectory for each connected ++session with name equal to name of the connected initiator. ++ ++Each session subdirectory contains the following entries: ++ ++ - initiator_name - contains initiator name ++ ++ - force_close - optional write-only attribute, which allows to force ++ close this session. ++ ++ - active_commands - contains number of active, i.e. not yet or being ++ executed, SCSI commands in this session. ++ ++ - commands - contains overall number of SCSI commands in this session. ++ ++ - latency - if CONFIG_SCST_MEASURE_LATENCY enabled, contains latency ++ statistics for this session. ++ ++ - luns - a link pointing out to the corresponding LUNs set (security ++ group) where this session was attached to. ++ ++ - One or more "lunX" subdirectories, where 'X' is a number, for each LUN ++ this session has (see below). ++ ++ - other target driver specific attributes and subdirectories. ++ ++See below description of the VDISK's sysfs interface for samples. ++ ++ ++Access and devices visibility management (LUN masking) ++------------------------------------------------------ ++ ++Access and devices visibility management allows for an initiator or ++group of initiators to see different devices with different LUNs ++with necessary access permissions. ++ ++SCST supports two modes of access control: ++ ++1. Target-oriented. In this mode you define for each target a default ++set of LUNs, which are accessible to all initiators, connected to that ++target. This is a regular access control mode, which people usually mean ++thinking about access control in general. For instance, in IET this is ++the only supported mode. ++ ++2. Initiator-oriented. In this mode you define which LUNs are accessible ++for each initiator. In this mode you should create for each set of one ++or more initiators, which should access to the same set of devices with ++the same LUNs, a separate security group, then add to it devices and ++names of allowed initiator(s). ++ ++Both modes can be used simultaneously. In this case the ++initiator-oriented mode has higher priority, than the target-oriented, ++i.e. initiators are at first searched in all defined security groups for ++this target and, if none matches, the default target's set of LUNs is ++used. This set of LUNs might be empty, then the initiator will not see ++any LUNs from the target. ++ ++You can at any time find out which set of LUNs each session is assigned ++to by looking where link ++/sys/kernel/scst_tgt/targets/target_driver/target_name/sessions/initiator_name/luns ++points to. ++ ++To configure the target-oriented access control SCST provides the ++following interface. Each target's sysfs subdirectory ++(/sys/kernel/scst_tgt/targets/target_driver/target_name) has "luns" ++subdirectory. This subdirectory contains the list of already defined ++target-oriented access control LUNs for this target as well as file ++"mgmt". This file has the following commands, which you can send to it, ++for instance, using "echo" shell command. You can always get a small ++help about supported commands by looking inside this file. "Parameters" ++are one or more param_name=value pairs separated by ';'. ++ ++ - "add H:C:I:L lun [parameters]" - adds a pass-through device with ++ host:channel:id:lun with LUN "lun". Optionally, the device could be ++ marked as read only by using parameter "read_only". The recommended ++ way to find out H:C:I:L numbers is use of lsscsi utility. ++ ++ - "replace H:C:I:L lun [parameters]" - replaces by pass-through device ++ with host:channel:id:lun existing with LUN "lun" device with ++ generation of INQUIRY DATA HAS CHANGED Unit Attention. If the old ++ device doesn't exist, this command acts as the "add" command. ++ Optionally, the device could be marked as read only by using ++ parameter "read_only". The recommended way to find out H:C:I:L ++ numbers is use of lsscsi utility. ++ ++ - "add VNAME lun [parameters]" - adds a virtual device with name VNAME ++ with LUN "lun". Optionally, the device could be marked as read only ++ by using parameter "read_only". ++ ++ - "replace VNAME lun [parameters]" - replaces by virtual device ++ with name VNAME existing with LUN "lun" device with generation of ++ INQUIRY DATA HAS CHANGED Unit Attention. If the old device doesn't ++ exist, this command acts as the "add" command. Optionally, the device ++ could be marked as read only by using parameter "read_only". ++ ++ - "del lun" - deletes LUN lun ++ ++ - "clear" - clears the list of devices ++ ++To configure the initiator-oriented access control SCST provides the ++following interface. Each target's sysfs subdirectory ++(/sys/kernel/scst_tgt/targets/target_driver/target_name) has "ini_groups" ++subdirectory. This subdirectory contains the list of already defined ++security groups for this target as well as file "mgmt". This file has ++the following commands, which you can send to it, for instance, using ++"echo" shell command. You can always get a small help about supported ++commands by looking inside this file. ++ ++ - "create GROUP_NAME" - creates a new security group. ++ ++ - "del GROUP_NAME" - deletes a new security group. ++ ++Each security group's subdirectory contains 2 subdirectories: initiators ++and luns as well as the following attributes: addr_method, cpu_mask and ++io_grouping_type. See above description of them. ++ ++Each "initiators" subdirectory contains list of added to this groups ++initiator as well as as well as file "mgmt". This file has the following ++commands, which you can send to it, for instance, using "echo" shell ++command. You can always get a small help about supported commands by ++looking inside this file. ++ ++ - "add INITIATOR_NAME" - adds initiator with name INITIATOR_NAME to the ++ group. ++ ++ - "del INITIATOR_NAME" - deletes initiator with name INITIATOR_NAME ++ from the group. ++ ++ - "move INITIATOR_NAME DEST_GROUP_NAME" moves initiator with name ++ INITIATOR_NAME from the current group to group with name ++ DEST_GROUP_NAME. ++ ++ - "clear" - deletes all initiators from this group. ++ ++For "add" and "del" commands INITIATOR_NAME can be a simple DOS-type ++patterns, containing '*' and '?' symbols. '*' means match all any ++symbols, '?' means match only any single symbol. For instance, ++"blah.xxx" will match "bl?h.*". Additionally, you can use negative sign ++'!' to revert the value of the pattern. For instance, "ah.xxx" will ++match "!bl?h.*". ++ ++Each "luns" subdirectory contains the list of already defined LUNs for ++this group as well as file "mgmt". Content of this file as well as list ++of available in it commands is fully identical to the "luns" ++subdirectory of the target-oriented access control. ++ ++Examples: ++ ++ - echo "create INI" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt1/ini_groups/mgmt - ++ creates security group INI for target iqn.2006-10.net.vlnb:tgt1. ++ ++ - echo "add 2:0:1:0 11" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt1/ini_groups/INI/luns/mgmt - ++ adds a pass-through device sitting on host 2, channel 0, ID 1, LUN 0 ++ to group with name INI as LUN 11. ++ ++ - echo "add disk1 0" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt1/ini_groups/INI/luns/mgmt - ++ adds a virtual disk with name disk1 to group with name INI as LUN 0. ++ ++ - echo "add 21:*:e0:?b:83:*" >/sys/kernel/scst_tgt/targets/21:00:00:a0:8c:54:52:12/ini_groups/INI/initiators/mgmt - ++ adds a pattern to group with name INI to Fibre Channel target with ++ WWN 21:00:00:a0:8c:54:52:12, which matches WWNs of Fibre Channel ++ initiator ports. ++ ++Consider you need to have an iSCSI target with name ++"iqn.2007-05.com.example:storage.disk1.sys1.xyz", which should export ++virtual device "dev1" with LUN 0 and virtual device "dev2" with LUN 1, ++but initiator with name ++"iqn.2007-05.com.example:storage.disk1.spec_ini.xyz" should see only ++virtual device "dev2" read only with LUN 0. To achieve that you should ++do the following commands: ++ ++# echo "iqn.2007-05.com.example:storage.disk1.sys1.xyz" >/sys/kernel/scst_tgt/targets/iscsi/mgmt ++# echo "add dev1 0" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2007-05.com.example:storage.disk1.sys1.xyz/luns/mgmt ++# echo "add dev2 1" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2007-05.com.example:storage.disk1.sys1.xyz/luns/mgmt ++# echo "create SPEC_INI" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2007-05.com.example:storage.disk1.sys1.xyz/ini_groups/mgmt ++# echo "add dev2 0 read_only=1" \ ++ >/sys/kernel/scst_tgt/targets/iscsi/iqn.2007-05.com.example:storage.disk1.sys1.xyz/ini_groups/SPEC_INI/luns/mgmt ++# echo "iqn.2007-05.com.example:storage.disk1.spec_ini.xyz" \ ++ >/sys/kernel/scst_tgt/targets/iscsi/iqn.2007-05.com.example:storage.disk1.sys1.xyz/ini_groups/SPEC_INI/initiators/mgmt ++ ++For Fibre Channel or SAS in the above example you should use target's ++and initiator ports WWNs instead of iSCSI names. ++ ++It is highly recommended to use scstadmin utility instead of described ++in this section low level interface. ++ ++IMPORTANT ++========= ++ ++There must be LUN 0 in each set of LUNs, i.e. LUs numeration must not ++start from, e.g., 1. Otherwise you will see no devices on remote ++initiators and SCST core will write into the kernel log message: "tgt_dev ++for LUN 0 not found, command to unexisting LU?" ++ ++IMPORTANT ++========= ++ ++All the access control must be fully configured BEFORE the corresponding ++target is enabled. When you enable a target, it will immediately start ++accepting new connections, hence creating new sessions, and those new ++sessions will be assigned to security groups according to the ++*currently* configured access control settings. For instance, to ++the default target's set of LUNs, instead of "HOST004" group as you may ++need, because "HOST004" doesn't exist yet. So, you must configure all ++the security groups before new connections from the initiators are ++created, i.e. before the target enabled. ++ ++ ++VDISK device handler ++-------------------- ++ ++VDISK has 4 built-in dev handlers: vdisk_fileio, vdisk_blockio, ++vdisk_nullio and vcdrom. Roots of their sysfs interface are ++/sys/kernel/scst_tgt/handlers/handler_name, e.g. for vdisk_fileio: ++/sys/kernel/scst_tgt/handlers/vdisk_fileio. Each root has the following ++entries: ++ ++ - None, one or more links to devices with name equal to names ++ of the corresponding devices. ++ ++ - trace_level - allows to enable and disable various tracing ++ facilities. See content of this file for help how to use it. See also ++ section "Dealing with massive logs" for more info how to make correct ++ logs when you enabled trace levels producing a lot of logs data. ++ ++ - mgmt - main management entry, which allows to add/delete VDISK ++ devices with the corresponding type. ++ ++The "mgmt" file has the following commands, which you can send to it, ++for instance, using "echo" shell command. You can always get a small ++help about supported commands by looking inside this file. "Parameters" ++are one or more param_name=value pairs separated by ';'. ++ ++ - echo "add_device device_name [parameters]" - adds a virtual device ++ with name device_name and specified parameters (see below) ++ ++ - echo "del_device device_name" - deletes a virtual device with name ++ device_name. ++ ++Handler vdisk_fileio provides FILEIO mode to create virtual devices. ++This mode uses as backend files and accesses to them using regular ++read()/write() file calls. This allows to use full power of Linux page ++cache. The following parameters possible for vdisk_fileio: ++ ++ - filename - specifies path and file name of the backend file. The path ++ must be absolute. ++ ++ - blocksize - specifies block size used by this virtual device. The ++ block size must be power of 2 and >= 512 bytes. Default is 512. ++ ++ - write_through - disables write back caching. Note, this option ++ has sense only if you also *manually* disable write-back cache in ++ *all* your backstorage devices and make sure it's actually disabled, ++ since many devices are known to lie about this mode to get better ++ benchmark results. Default is 0. ++ ++ - read_only - read only. Default is 0. ++ ++ - o_direct - disables both read and write caching. This mode isn't ++ currently fully implemented, you should use user space fileio_tgt ++ program in O_DIRECT mode instead (see below). ++ ++ - nv_cache - enables "non-volatile cache" mode. In this mode it is ++ assumed that the target has a GOOD UPS with ability to cleanly ++ shutdown target in case of power failure and it is software/hardware ++ bugs free, i.e. all data from the target's cache are guaranteed ++ sooner or later to go to the media. Hence all data synchronization ++ with media operations, like SYNCHRONIZE_CACHE, are ignored in order ++ to bring more performance. Also in this mode target reports to ++ initiators that the corresponding device has write-through cache to ++ disable all write-back cache workarounds used by initiators. Use with ++ extreme caution, since in this mode after a crash of the target ++ journaled file systems don't guarantee the consistency after journal ++ recovery, therefore manual fsck MUST be ran. Note, that since usually ++ the journal barrier protection (see "IMPORTANT" note below) turned ++ off, enabling NV_CACHE could change nothing from data protection ++ point of view, since no data synchronization with media operations ++ will go from the initiator. This option overrides "write_through" ++ option. Disabled by default. ++ ++ - thin_provisioned - enables thin provisioning facility, when remote ++ initiators can unmap blocks of storage, if they don't need them ++ anymore. Backend storage also must support this facility. ++ ++ - removable - with this flag set the device is reported to remote ++ initiators as removable. ++ ++Handler vdisk_blockio provides BLOCKIO mode to create virtual devices. ++This mode performs direct block I/O with a block device, bypassing the ++page cache for all operations. This mode works ideally with high-end ++storage HBAs and for applications that either do not need caching ++between application and disk or need the large block throughput. See ++below for more info. ++ ++The following parameters possible for vdisk_blockio: filename, ++blocksize, nv_cache, read_only, removable, thin_provisioned. See ++vdisk_fileio above for description of those parameters. ++ ++Handler vdisk_nullio provides NULLIO mode to create virtual devices. In ++this mode no real I/O is done, but success returned to initiators. ++Intended to be used for performance measurements at the same way as ++"*_perf" handlers. The following parameters possible for vdisk_nullio: ++blocksize, read_only, removable. See vdisk_fileio above for description ++of those parameters. ++ ++Handler vcdrom allows emulation of a virtual CDROM device using an ISO ++file as backend. It doesn't have any parameters. ++ ++For example: ++ ++echo "add_device disk1 filename=/disk1; blocksize=4096; nv_cache=1" >/sys/kernel/scst_tgt/handlers/vdisk_fileio/mgmt ++ ++will create a FILEIO virtual device disk1 with backend file /disk1 ++with block size 4K and NV_CACHE enabled. ++ ++Each vdisk_fileio's device has the following attributes in ++/sys/kernel/scst_tgt/devices/device_name: ++ ++ - filename - contains path and file name of the backend file. ++ ++ - blocksize - contains block size used by this virtual device. ++ ++ - write_through - contains status of write back caching of this virtual ++ device. ++ ++ - read_only - contains read only status of this virtual device. ++ ++ - o_direct - contains O_DIRECT status of this virtual device. ++ ++ - nv_cache - contains NV_CACHE status of this virtual device. ++ ++ - thin_provisioned - contains thin provisioning status of this virtual ++ device ++ ++ - removable - contains removable status of this virtual device. ++ ++ - size_mb - contains size of this virtual device in MB. ++ ++ - t10_dev_id - contains and allows to set T10 vendor specific ++ identifier for Device Identification VPD page (0x83) of INQUIRY data. ++ By default VDISK handler always generates t10_dev_id for every new ++ created device at creation time based on the device name and ++ scst_vdisk_ID scst_vdisk.ko module parameter (see below). ++ ++ - usn - contains the virtual device's serial number of INQUIRY data. It ++ is created at the device creation time based on the device name and ++ scst_vdisk_ID scst_vdisk.ko module parameter (see below). ++ ++ - type - contains SCSI type of this virtual device. ++ ++ - resync_size - write only attribute, which makes vdisk_fileio to ++ rescan size of the backend file. It is useful if you changed it, for ++ instance, if you resized it. ++ ++For example: ++ ++/sys/kernel/scst_tgt/devices/disk1 ++|-- blocksize ++|-- exported ++| |-- export0 -> ../../../targets/iscsi/iqn.2006-10.net.vlnb:tgt/luns/0 ++| |-- export1 -> ../../../targets/iscsi/iqn.2006-10.net.vlnb:tgt/ini_groups/INI/luns/0 ++| |-- export2 -> ../../../targets/iscsi/iqn.2006-10.net.vlnb:tgt1/luns/0 ++| |-- export3 -> ../../../targets/iscsi/iqn.2006-10.net.vlnb:tgt1/ini_groups/INI1/luns/0 ++| |-- export4 -> ../../../targets/iscsi/iqn.2006-10.net.vlnb:tgt1/ini_groups/INI2/luns/0 ++|-- filename ++|-- handler -> ../../handlers/vdisk_fileio ++|-- nv_cache ++|-- o_direct ++|-- read_only ++|-- removable ++|-- resync_size ++|-- size_mb ++|-- t10_dev_id ++|-- thin_provisioned ++|-- threads_num ++|-- threads_pool_type ++|-- type ++|-- usn ++`-- write_through ++ ++Each vdisk_blockio's device has the following attributes in ++/sys/kernel/scst_tgt/devices/device_name: blocksize, filename, nv_cache, ++read_only, removable, resync_size, size_mb, t10_dev_id, ++thin_provisioned, threads_num, threads_pool_type, type, usn. See above ++description of those parameters. ++ ++Each vdisk_nullio's device has the following attributes in ++/sys/kernel/scst_tgt/devices/device_name: blocksize, read_only, ++removable, size_mb, t10_dev_id, threads_num, threads_pool_type, type, ++usn. See above description of those parameters. ++ ++Each vcdrom's device has the following attributes in ++/sys/kernel/scst_tgt/devices/device_name: filename, size_mb, ++t10_dev_id, threads_num, threads_pool_type, type, usn. See above ++description of those parameters. Exception is filename attribute. For ++vcdrom it is writable. Writing to it allows to virtually insert or ++change virtual CD media in the virtual CDROM device. For example: ++ ++ - echo "/image.iso" >/sys/kernel/scst_tgt/devices/cdrom/filename - will ++ insert file /image.iso as virtual media to the virtual CDROM cdrom. ++ ++ - echo "" >/sys/kernel/scst_tgt/devices/cdrom/filename - will remove ++ "media" from the virtual CDROM cdrom. ++ ++Additionally VDISK handler has module parameter "num_threads", which ++specifies count of I/O threads for each FILEIO VDISK's or VCDROM device. ++If you have a workload, which tends to produce rather random accesses ++(e.g. DB-like), you should increase this count to a bigger value, like ++32. If you have a rather sequential workload, you should decrease it to ++a lower value, like number of CPUs on the target or even 1. Due to some ++limitations of Linux I/O subsystem, increasing number of I/O threads too ++much leads to sequential performance drop, especially with deadline ++scheduler, so decreasing it can improve sequential performance. The ++default provides a good compromise between random and sequential ++accesses. ++ ++You shouldn't be afraid to have too many VDISK I/O threads if you have ++many VDISK devices. Kernel threads consume very little amount of ++resources (several KBs) and only necessary threads will be used by SCST, ++so the threads will not trash your system. ++ ++CAUTION: If you partitioned/formatted your device with block size X, *NEVER* ++======== ever try to export and then mount it (even accidentally) with another ++ block size. Otherwise you can *instantly* damage it pretty ++ badly as well as all your data on it. Messages on initiator ++ like: "attempt to access beyond end of device" is the sign of ++ such damage. ++ ++ Moreover, if you want to compare how well different block sizes ++ work for you, you **MUST** EVERY TIME AFTER CHANGING BLOCK SIZE ++ **COMPLETELY** **WIPE OFF** ALL THE DATA FROM THE DEVICE. In ++ other words, THE **WHOLE** DEVICE **MUST** HAVE ONLY **ZEROS** ++ AS THE DATA AFTER YOU SWITCH TO NEW BLOCK SIZE. Switching block ++ sizes isn't like switching between FILEIO and BLOCKIO, after ++ changing block size all previously written with another block ++ size data MUST BE ERASED. Otherwise you will have a full set of ++ very weird behaviors, because blocks addressing will be ++ changed, but initiators in most cases will not have a ++ possibility to detect that old addresses written on the device ++ in, e.g., partition table, don't refer anymore to what they are ++ intended to refer. ++ ++IMPORTANT: Some disk and partition table management utilities don't support ++========= block sizes >512 bytes, therefore make sure that your favorite one ++ supports it. Currently only cfdisk is known to work only with ++ 512 bytes blocks, other utilities like fdisk on Linux or ++ standard disk manager on Windows are proved to work well with ++ non-512 bytes blocks. Note, if you export a disk file or ++ device with some block size, different from one, with which ++ it was already partitioned, you could get various weird ++ things like utilities hang up or other unexpected behavior. ++ Hence, to be sure, zero the exported file or device before ++ the first access to it from the remote initiator with another ++ block size. On Window initiator make sure you "Set Signature" ++ in the disk manager on the imported from the target drive ++ before doing any other partitioning on it. After you ++ successfully mounted a file system over non-512 bytes block ++ size device, the block size stops matter, any program will ++ work with files on such file system. ++ ++ ++Dealing with massive logs ++------------------------- ++ ++If you want to enable using "trace_level" file logging levels, which ++produce a lot of events, like "debug", to not loose logged events you ++should also: ++ ++ * Increase in .config of your kernel CONFIG_LOG_BUF_SHIFT variable ++ to much bigger value, then recompile it. For example, value 25 will ++ provide good protection from logging overflow even under high volume ++ of logging events. To use it you will need to modify the maximum ++ allowed value for CONFIG_LOG_BUF_SHIFT in the corresponding Kconfig ++ file to 25 as well. ++ ++ * Change in your /etc/syslog.conf or other config file of your favorite ++ logging program to store kernel logs in async manner. For example, ++ you can add in rsyslog.conf line "kern.info -/var/log/kernel" and ++ add "kern.none" in line for /var/log/messages, so the resulting line ++ would looks like: ++ ++ "*.info;kern.none;mail.none;authpriv.none;cron.none /var/log/messages" ++ ++ ++Persistent Reservations ++----------------------- ++ ++SCST implements Persistent Reservations with full set of capabilities, ++including "Persistence Through Power Loss". ++ ++The "Persistence Through Power Loss" data are saved in /var/lib/scst/pr ++with files with names the same as the names of the corresponding ++devices. Also this directory contains backup versions of those files ++with suffix ".1". Those backup files are used in case of power or other ++failure to prevent Persistent Reservation information from corruption ++during update. ++ ++The Persistent Reservations available on all transports implementing ++get_initiator_port_transport_id() callback. Transports not implementing ++this callback will act in one of 2 possible scenarios ("all or ++nothing"): ++ ++1. If a device has such transport connected and doesn't have persistent ++reservations, it will refuse Persistent Reservations commands as if it ++doesn't support them. ++ ++2. If a device has persistent reservations, all initiators newly ++connecting via such transports will not see this device. After all ++persistent reservations from this device are released, upon reconnect ++the initiators will see it. ++ ++ ++Caching ++------- ++ ++By default for performance reasons VDISK FILEIO devices use write back ++caching policy. ++ ++Generally, write back caching is safe for use and danger of it is ++greatly overestimated, because most modern (especially, Enterprise ++level) applications are well prepared to work with write back cached ++storage. Particularly, such are all transactions-based applications. ++Those applications flush cache to completely avoid ANY data loss on a ++crash or power failure. For instance, journaled file systems flush cache ++on each meta data update, so they survive power/hardware/software ++failures pretty well. ++ ++Since locally on initiators write back caching is always on, if an ++application cares about its data consistency, it does flush the cache ++when necessary or on any write, if open files with O_SYNC. If it doesn't ++care, it doesn't flush the cache. As soon as the cache flushes ++propagated to the storage, write back caching on it doesn't make any ++difference. If application doesn't flush the cache, it's doomed to loose ++data in case of a crash or power failure doesn't matter where this cache ++located, locally or on the storage. ++ ++To illustrate that consider, for example, a user who wants to copy /src ++directory to /dst directory reliably, i.e. after the copy finished no ++power failure or software/hardware crash could lead to a loss of the ++data in /dst. There are 2 ways to achieve this. Let's suppose for ++simplicity cp opens files for writing with O_SYNC flag, hence bypassing ++the local cache. ++ ++1. Slow. Make the device behind /dst working in write through caching ++mode and then run "cp -a /src /dst". ++ ++2. Fast. Let the device behind /dst working in write back caching mode ++and then run "cp -a /src /dst; sync". The reliability of the result is ++the same, but it's much faster than (1). Nobody would care if a crash ++happens during the copy, because after recovery simply leftovers from ++the not completed attempt would be deleted and the operation would be ++restarted from the very beginning. ++ ++So, you can see in (2) there is no danger of ANY data loss from the ++write back caching. Moreover, since on practice cp doesn't open files ++for writing with O_SYNC flag, to get the copy done reliably, sync ++command must be called after cp anyway, so enabling write back caching ++wouldn't make any difference for reliability. ++ ++Also you can consider it from another side. Modern HDDs have at least ++16MB of cache working in write back mode by default, so for a 10 drives ++RAID it is 160MB of a write back cache. How many people are happy with ++it and how many disabled write back cache of their HDDs? Almost all and ++almost nobody correspondingly? Moreover, many HDDs lie about state of ++their cache and report write through while working in write back mode. ++They are also successfully used. ++ ++Note, Linux I/O subsystem guarantees to propagated cache flushes to the ++storage only using data protection barriers, which usually turned off by ++default (see http://lwn.net/Articles/283161). Without barriers enabled ++Linux doesn't provide a guarantee that after sync()/fsync() all written ++data really hit permanent storage. They can be stored in the cache of ++your backstorage devices and, hence, lost on a power failure event. ++Thus, ever with write-through cache mode, you still either need to ++enable barriers on your backend file system on the target (for direct ++/dev/sdX devices this is, indeed, impossible), or need a good UPS to ++protect yourself from not committed data loss. Some info about barriers ++from the XFS point of view could be found at ++http://oss.sgi.com/projects/xfs/faq.html#wcache. On Linux initiators for ++Ext3 and ReiserFS file systems the barrier protection could be turned on ++using "barrier=1" and "barrier=flush" mount options correspondingly. You ++can check if the barriers turn on or off by looking in /proc/mounts. ++Windows and, AFAIK, other UNIX'es don't need any special explicit ++options and do necessary barrier actions on write-back caching devices ++by default. ++ ++To limit this data loss with write back caching you can use files in ++/proc/sys/vm to limit amount of unflushed data in the system cache. ++ ++If you for some reason have to use VDISK FILEIO devices in write through ++caching mode, don't forget to disable internal caching on their backend ++devices or make sure they have additional battery or supercapacitors ++power supply on board. Otherwise, you still on a power failure would ++loose all the unsaved yet data in the devices internal cache. ++ ++Note, on some real-life workloads write through caching might perform ++better, than write back one with the barrier protection turned on. ++ ++ ++BLOCKIO VDISK mode ++------------------ ++ ++This module works best for these types of scenarios: ++ ++1) Data that are not aligned to 4K sector boundaries and <4K block sizes ++are used, which is normally found in virtualization environments where ++operating systems start partitions on odd sectors (Windows and it's ++sector 63). ++ ++2) Large block data transfers normally found in database loads/dumps and ++streaming media. ++ ++3) Advanced relational database systems that perform their own caching ++which prefer or demand direct IO access and, because of the nature of ++their data access, can actually see worse performance with ++non-discriminate caching. ++ ++4) Multiple layers of targets were the secondary and above layers need ++to have a consistent view of the primary targets in order to preserve ++data integrity which a page cache backed IO type might not provide ++reliably. ++ ++Also it has an advantage over FILEIO that it doesn't copy data between ++the system cache and the commands data buffers, so it saves a ++considerable amount of CPU power and memory bandwidth. ++ ++IMPORTANT: Since data in BLOCKIO and FILEIO modes are not consistent between ++========= each other, if you try to use a device in both those modes ++ simultaneously, you will almost instantly corrupt your data ++ on that device. ++ ++IMPORTANT: If SCST 1.x BLOCKIO worked by default in NV_CACHE mode, when ++========= each device reported to remote initiators as having write through ++ caching. But if your backend block device has internal write ++ back caching it might create a possibility for data loss of ++ the cached in the internal cache data in case of a power ++ failure. Starting from SCST 2.0 BLOCKIO works by default in ++ non-NV_CACHE mode, when each device reported to remote ++ initiators as having write back caching, and synchronizes the ++ internal device's cache on each SYNCHRONIZE_CACHE command ++ from the initiators. It might lead to some PERFORMANCE LOSS, ++ so if you are are sure in your power supply and want to ++ restore 1.x behavior, your should recreate your BLOCKIO ++ devices in NV_CACHE mode. ++ ++ ++Pass-through mode ++----------------- ++ ++In the pass-through mode (i.e. using the pass-through device handlers ++scst_disk, scst_tape, etc) SCSI commands, coming from remote initiators, ++are passed to local SCSI devices on target as is, without any ++modifications. ++ ++SCST supports 1 to many pass-through, when several initiators can safely ++connect a single pass-through device (a tape, for instance). For such ++cases SCST emulates all the necessary functionality. ++ ++In the sysfs interface all real SCSI devices are listed in ++/sys/kernel/scst_tgt/devices in form host:channel:id:lun numbers, for ++instance 1:0:0:0. The recommended way to match those numbers to your ++devices is use of lsscsi utility. ++ ++Each pass-through dev handler has in its root subdirectory ++/sys/kernel/scst_tgt/handlers/handler_name, e.g. ++/sys/kernel/scst_tgt/handlers/dev_disk, "mgmt" file. It allows the ++following commands. They can be sent to it using, e.g., echo command. ++ ++ - "add_device" - this command assigns SCSI device with ++host:channel:id:lun numbers to this dev handler. ++ ++echo "add_device 1:0:0:0" >/sys/kernel/scst_tgt/handlers/dev_disk/mgmt ++ ++will assign SCSI device 1:0:0:0 to this dev handler. ++ ++ - "del_device" - this command unassigns SCSI device with ++host:channel:id:lun numbers from this dev handler. ++ ++As usually, on read the "mgmt" file returns small help about available ++commands. ++ ++You need to manually assign each your real SCSI device to the ++corresponding pass-through dev handler using the "add_device" command, ++otherwise the real SCSI devices will not be visible remotely. The ++assignment isn't done automatically, because it could lead to the ++pass-through dev handlers load and initialization problems if any of the ++local real SCSI devices are malfunctioning. ++ ++As any other hardware, the local SCSI hardware can not handle commands ++with amount of data and/or segments count in scatter-gather array bigger ++some values. Therefore, when using the pass-through mode you should note ++that values for maximum number of segments and maximum amount of ++transferred data (max_sectors) for each SCSI command on devices on ++initiators can not be bigger, than corresponding values of the ++corresponding SCSI devices on the target. Otherwise you will see ++symptoms like small transfers work well, but large ones stall and ++messages like: "Unable to complete command due to SG IO count ++limitation" are printed in the kernel logs. ++ ++You can't control from the user space limit of the scatter-gather ++segments, but for block devices usually it is sufficient if you set on ++the initiators /sys/block/DEVICE_NAME/queue/max_sectors_kb in the same ++or lower value as in /sys/block/DEVICE_NAME/queue/max_hw_sectors_kb for ++the corresponding devices on the target. ++ ++For not-block devices SCSI commands are usually generated directly by ++applications, so, if you experience large transfers stalls, you should ++check documentation for your application how to limit the transfer ++sizes. ++ ++Another way to solve this issue is to build SG entries with more than 1 ++page each. See the following patch as an example: ++http://scst.sourceforge.net/sgv_big_order_alloc.diff ++ ++ ++Performance ++----------- ++ ++SCST from the very beginning has been designed and implemented to ++provide the best possible performance. Since there is no "one fit all" ++the best performance configuration for different setups and loads, SCST ++provides extensive set of settings to allow to tune it for the best ++performance in each particular case. You don't have to necessary use ++those settings. If you don't, SCST will do very good job to autotune for ++you, so the resulting performance will, in average, be better ++(sometimes, much better) than with other SCSI targets. But in some cases ++you can by manual tuning improve it even more. ++ ++Before doing any performance measurements note that performance results ++are very much dependent from your type of load, so it is crucial that ++you choose access mode (FILEIO, BLOCKIO, O_DIRECT, pass-through), which ++suits your needs the best. ++ ++In order to get the maximum performance you should: ++ ++1. For SCST: ++ ++ - Disable in Makefile CONFIG_SCST_STRICT_SERIALIZING, CONFIG_SCST_EXTRACHECKS, ++ CONFIG_SCST_TRACING, CONFIG_SCST_DEBUG*, CONFIG_SCST_STRICT_SECURITY, ++ CONFIG_SCST_MEASURE_LATENCY ++ ++2. For target drivers: ++ ++ - Disable in Makefiles CONFIG_SCST_EXTRACHECKS, CONFIG_SCST_TRACING, ++ CONFIG_SCST_DEBUG* ++ ++3. For device handlers, including VDISK: ++ ++ - Disable in Makefile CONFIG_SCST_TRACING and CONFIG_SCST_DEBUG. ++ ++4. Make sure you have io_grouping_type option set correctly, especially ++in the following cases: ++ ++ - Several initiators share your target's backstorage. It can be a ++ shared LU using some cluster FS, like VMFS, as well as can be ++ different LUs located on the same backstorage (RAID array). For ++ instance, if you have 3 initiators and each of them using its own ++ dedicated FILEIO device file from the same RAID-6 array on the ++ target. ++ ++ In this case for the best performance you should have ++ io_grouping_type option set in value "never" in all the LUNs' targets ++ and security groups. ++ ++ - Your initiator connected to your target in MPIO mode. In this case for ++ the best performance you should: ++ ++ * Either connect all the sessions from the initiator to a single ++ target or security group and have io_grouping_type option set in ++ value "this_group_only" in the target or security group, ++ ++ * Or, if it isn't possible to connect all the sessions from the ++ initiator to a single target or security group, assign the same ++ numeric io_grouping_type value for each target/security group this ++ initiator connected to. The exact value itself doesn't matter, ++ important only that all the targets/security groups use the same ++ value. ++ ++Don't forget, io_grouping_type makes sense only if you use CFQ I/O ++scheduler on the target and for devices with threads_num >= 0 and, if ++threads_num > 0, with threads_pool_type "per_initiator". ++ ++You can check if in your setup io_grouping_type set correctly as well as ++if the "auto" io_grouping_type value works for you by tests like the ++following: ++ ++ - For not MPIO case you can run single thread sequential reading, e.g. ++ using buffered dd, from one initiator, then run the same single ++ thread sequential reading from the second initiator in parallel. If ++ io_grouping_type is set correctly the aggregate throughput measured ++ on the target should only slightly decrease as well as all initiators ++ should have nearly equal share of it. If io_grouping_type is not set ++ correctly, the aggregate throughput and/or throughput on any ++ initiator will decrease significantly, in 2 times or even more. For ++ instance, you have 80MB/s single thread sequential reading from the ++ target on any initiator. When then both initiators are reading in ++ parallel you should see on the target aggregate throughput something ++ like 70-75MB/s with correct io_grouping_type and something like ++ 35-40MB/s or 8-10MB/s on any initiator with incorrect. ++ ++ - For the MPIO case it's quite easier. With incorrect io_grouping_type ++ you simply won't see performance increase from adding the second ++ session (assuming your hardware is capable to transfer data through ++ both sessions in parallel), or can even see a performance decrease. ++ ++5. If you are going to use your target in an VM environment, for ++instance as a shared storage with VMware, make sure all your VMs ++connected to the target via *separate* sessions. For instance, for iSCSI ++it means that each VM has own connection to the target, not all VMs ++connected using a single connection. You can check it using SCST sysfs ++interface. For other transports you should use available facilities, ++like NPIV for Fibre Channel, to make separate sessions for each VM. If ++you miss it, you can greatly loose performance of parallel access to ++your target from different VMs. This isn't related to the case if your ++VMs are using the same shared storage, like with VMFS, for instance. In ++this case all your VM hosts will be connected to the target via separate ++sessions, which is enough. ++ ++6. For other target and initiator software parts: ++ ++ - Make sure you applied on your kernel all available SCST patches. ++ If for your kernel version this patch doesn't exist, it is strongly ++ recommended to upgrade your kernel to version, for which this patch ++ exists. ++ ++ - Don't enable debug/hacking features in the kernel, i.e. use them as ++ they are by default. ++ ++ - The default kernel read-ahead and queuing settings are optimized ++ for locally attached disks, therefore they are not optimal if they ++ attached remotely (SCSI target case), which sometimes could lead to ++ unexpectedly low throughput. You should increase read-ahead size to at ++ least 512KB or even more on all initiators and the target. ++ ++ You should also limit on all initiators maximum amount of sectors per ++ SCSI command. This tuning is also recommended on targets with large ++ read-ahead values. To do it on Linux, run: ++ ++ echo “64” > /sys/block/sdX/queue/max_sectors_kb ++ ++ where specify instead of X your imported from target device letter, ++ like 'b', i.e. sdb. ++ ++ To increase read-ahead size on Linux, run: ++ ++ blockdev --setra N /dev/sdX ++ ++ where N is a read-ahead number in 512-byte sectors and X is a device ++ letter like above. ++ ++ Note: you need to set read-ahead setting for device sdX again after ++ you changed the maximum amount of sectors per SCSI command for that ++ device. ++ ++ Note2: you need to restart SCST after you changed read-ahead settings ++ on the target. It is a limitation of the Linux read ahead ++ implementation. It reads RA values for each file only when the file ++ is open and not updates them when the global RA parameters changed. ++ Hence, the need for vdisk to reopen all its files/devices. ++ ++ - You may need to increase amount of requests that OS on initiator ++ sends to the target device. To do it on Linux initiators, run ++ ++ echo “64” > /sys/block/sdX/queue/nr_requests ++ ++ where X is a device letter like above. ++ ++ You may also experiment with other parameters in /sys/block/sdX ++ directory, they also affect performance. If you find the best values, ++ please share them with us. ++ ++ - On the target use CFQ IO scheduler. In most cases it has performance ++ advantage over other IO schedulers, sometimes huge (2+ times ++ aggregate throughput increase). ++ ++ - It is recommended to turn the kernel preemption off, i.e. set ++ the kernel preemption model to "No Forced Preemption (Server)". ++ ++ - Looks like XFS is the best filesystem on the target to store device ++ files, because it allows considerably better linear write throughput, ++ than ext3. ++ ++7. For hardware on target. ++ ++ - Make sure that your target hardware (e.g. target FC or network card) ++ and underlaying IO hardware (e.g. IO card, like SATA, SCSI or RAID to ++ which your disks connected) don't share the same PCI bus. You can ++ check it using lspci utility. They have to work in parallel, so it ++ will be better if they don't compete for the bus. The problem is not ++ only in the bandwidth, which they have to share, but also in the ++ interaction between cards during that competition. This is very ++ important, because in some cases if target and backend storage ++ controllers share the same PCI bus, it could lead up to 5-10 times ++ less performance, than expected. Moreover, some motherboard (by ++ Supermicro, particularly) have serious stability issues if there are ++ several high speed devices on the same bus working in parallel. If ++ you have no choice, but PCI bus sharing, set in the BIOS PCI latency ++ as low as possible. ++ ++8. If you use VDISK IO module in FILEIO mode, NV_CACHE option will ++provide you the best performance. But using it make sure you use a good ++UPS with ability to shutdown the target on the power failure. ++ ++Baseline performance numbers you can find in those measurements: ++http://lkml.org/lkml/2009/3/30/283. ++ ++IMPORTANT: If you use on initiator some versions of Windows (at least W2K) ++========= you can't get good write performance for VDISK FILEIO devices with ++ default 512 bytes block sizes. You could get about 10% of the ++ expected one. This is because of the partition alignment, which ++ is (simplifying) incompatible with how Linux page cache ++ works, so for each write the corresponding block must be read ++ first. Use 4096 bytes block sizes for VDISK devices and you ++ will have the expected write performance. Actually, any OS on ++ initiators, not only Windows, will benefit from block size ++ max(PAGE_SIZE, BLOCK_SIZE_ON_UNDERLYING_FS), where PAGE_SIZE ++ is the page size, BLOCK_SIZE_ON_UNDERLYING_FS is block size ++ on the underlying FS, on which the device file located, or 0, ++ if a device node is used. Both values are from the target. ++ See also important notes about setting block sizes >512 bytes ++ for VDISK FILEIO devices above. ++ ++9. In some cases, for instance working with SSD devices, which consume ++100% of a single CPU load for data transfers in their internal threads, ++to maximize IOPS it can be needed to assign for those threads dedicated ++CPUs. Consider using cpu_mask attribute for devices with ++threads_pool_type "per_initiator" or Linux CPU affinity facilities for ++other threads_pool_types. No IRQ processing should be done on those ++CPUs. Check that using /proc/interrupts. See taskset command and ++Documentation/IRQ-affinity.txt in your kernel's source tree for how to ++assign IRQ affinity to tasks and IRQs. ++ ++The reason for that is that processing of coming commands in SIRQ ++context might be done on the same CPUs as SSD devices' threads doing data ++transfers. As the result, those threads won't receive all the processing ++power of those CPUs and perform worse. ++ ++ ++Work if target's backstorage or link is too slow ++------------------------------------------------ ++ ++Under high I/O load, when your target's backstorage gets overloaded, or ++working over a slow link between initiator and target, when the link ++can't serve all the queued commands on time, you can experience I/O ++stalls or see in the kernel log abort or reset messages. ++ ++At first, consider the case of too slow target's backstorage. On some ++seek intensive workloads even fast disks or RAIDs, which able to serve ++continuous data stream on 500+ MB/s speed, can be as slow as 0.3 MB/s. ++Another possible cause for that can be MD/LVM/RAID on your target as in ++http://lkml.org/lkml/2008/2/27/96 (check the whole thread as well). ++ ++Thus, in such situations simply processing of one or more commands takes ++too long time, hence initiator decides that they are stuck on the target ++and tries to recover. Particularly, it is known that the default amount ++of simultaneously queued commands (48) is sometimes too high if you do ++intensive writes from VMware on a target disk, which uses LVM in the ++snapshot mode. In this case value like 16 or even 8-10 depending of your ++backstorage speed could be more appropriate. ++ ++Unfortunately, currently SCST lacks dynamic I/O flow control, when the ++queue depth on the target is dynamically decreased/increased based on ++how slow/fast the backstorage speed comparing to the target link. So, ++there are 6 possible actions, which you can do to workaround or fix this ++issue in this case: ++ ++1. Ignore incoming task management (TM) commands. It's fine if there are ++not too many of them, so average performance isn't hurt and the ++corresponding device isn't getting put offline, i.e. if the backstorage ++isn't too slow. ++ ++2. Decrease /sys/block/sdX/device/queue_depth on the initiator in case ++if it's Linux (see below how) or/and SCST_MAX_TGT_DEV_COMMANDS constant ++in scst_priv.h file until you stop seeing incoming TM commands. ++ISCSI-SCST driver also has its own iSCSI specific parameter for that, ++see its README file. ++ ++To decrease device queue depth on Linux initiators you can run command: ++ ++# echo Y >/sys/block/sdX/device/queue_depth ++ ++where Y is the new number of simultaneously queued commands, X - your ++imported device letter, like 'a' for sda device. There are no special ++limitations for Y value, it can be any value from 1 to possible maximum ++(usually, 32), so start from dividing the current value on 2, i.e. set ++16, if /sys/block/sdX/device/queue_depth contains 32. ++ ++3. Increase the corresponding timeout on the initiator. For Linux it is ++located in ++/sys/devices/platform/host*/session*/target*:0:0/*:0:0:1/timeout. It can ++be done automatically by an udev rule. For instance, the following ++rule will increase it to 300 seconds: ++ ++SUBSYSTEM=="scsi", KERNEL=="[0-9]*:[0-9]*", ACTION=="add", ATTR{type}=="0|7|14", ATTR{timeout}="300" ++ ++By default, this timeout is 30 or 60 seconds, depending on your distribution. ++ ++4. Try to avoid such seek intensive workloads. ++ ++5. Increase speed of the target's backstorage. ++ ++6. Implement in SCST dynamic I/O flow control. This will be an ultimate ++solution. See "Dynamic I/O flow control" section on ++http://scst.sourceforge.net/contributing.html page for possible ++implementation idea. ++ ++Next, consider the case of too slow link between initiator and target, ++when the initiator tries to simultaneously push N commands to the target ++over it. In this case time to serve those commands, i.e. send or receive ++data for them over the link, can be more, than timeout for any single ++command, hence one or more commands in the tail of the queue can not be ++served on time less than the timeout, so the initiator will decide that ++they are stuck on the target and will try to recover. ++ ++To workaround/fix this issue in this case you can use ways 1, 2, 3, 6 ++above or (7): increase speed of the link between target and initiator. ++But for some initiators implementations for WRITE commands there might ++be cases when target has no way to detect the issue, so dynamic I/O flow ++control will not be able to help. In those cases you could also need on ++the initiator(s) to either decrease the queue depth (way 2), or increase ++the corresponding timeout (way 3). ++ ++Note, that logged messages about QUEUE_FULL status are quite different ++by nature. This is a normal work, just SCSI flow control in action. ++Simply don't enable "mgmt_minor" logging level, or, alternatively, if ++you are confident in the worst case performance of your back-end storage ++or initiator-target link, you can increase SCST_MAX_TGT_DEV_COMMANDS in ++scst_priv.h to 64. Usually initiators don't try to push more commands on ++the target. ++ ++ ++Credits ++------- ++ ++Thanks to: ++ ++ * Mark Buechler <mark.buechler@gmail.com> for a lot of useful ++ suggestions, bug reports and help in debugging. ++ ++ * Ming Zhang <mingz@ele.uri.edu> for fixes and comments. ++ ++ * Nathaniel Clark <nate@misrule.us> for fixes and comments. ++ ++ * Calvin Morrow <calvin.morrow@comcast.net> for testing and useful ++ suggestions. ++ ++ * Hu Gang <hugang@soulinfo.com> for the original version of the ++ LSI target driver. ++ ++ * Erik Habbinga <erikhabbinga@inphase-tech.com> for fixes and support ++ of the LSI target driver. ++ ++ * Ross S. W. Walker <rswwalker@hotmail.com> for BLOCKIO inspiration ++ and Vu Pham <huongvp@yahoo.com> who implemented it for VDISK dev handler. ++ ++ * Alessandro Premoli <a.premoli@andxor.it> for fixes ++ ++ * Nathan Bullock <nbullock@yottayotta.com> for fixes. ++ ++ * Terry Greeniaus <tgreeniaus@yottayotta.com> for fixes. ++ ++ * Krzysztof Blaszkowski <kb@sysmikro.com.pl> for many fixes and bug reports. ++ ++ * Jianxi Chen <pacers@users.sourceforge.net> for fixing problem with ++ devices >2TB in size ++ ++ * Bart Van Assche <bvanassche@acm.org> for a lot of help ++ ++ * Daniel Debonzi <debonzi@linux.vnet.ibm.com> for a big part of the ++ initial SCST sysfs tree implementation ++ ++ ++Vladislav Bolkhovitin <vst@vlnb.net>, http://scst.sourceforge.net +diff -uprN orig/linux-3.2/Documentation/scst/SysfsRules linux-3.2/Documentation/scst/SysfsRules +--- orig/linux-3.2/Documentation/scst/SysfsRules ++++ linux-3.2/Documentation/scst/SysfsRules +@@ -0,0 +1,942 @@ ++ SCST SYSFS interface rules ++ ========================== ++ ++This file describes SYSFS interface rules, which all SCST target ++drivers, dev handlers and management utilities MUST follow. This allows ++to have a simple, self-documented, target drivers and dev handlers ++independent management interface. ++ ++Words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", ++"SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this ++document are to be interpreted as described in RFC 2119. ++ ++In this document "key attribute" means a configuration attribute with ++not default value, which must be configured during the target driver's ++initialization. A key attribute MUST have in the last line keyword ++"[key]". If a default value set to a key attribute, it becomes a regular ++none-key attribute. For instance, iSCSI target has attribute DataDigest. ++Default value for this attribute is "None". It value "CRC32C" is set to ++this attribute, it will become a key attribute. If value "None" is again ++set, this attribute will become back to a none-key attribute. ++ ++Each user configurable attribute with a not default value MUST be marked ++as key attribute. ++ ++Key attributes SHOULD NOT have sysfs names finished on digits, because ++such names SHOULD be used to store several attributes with the same name ++on the sysfs tree where duplicated names are not allowed. For instance, ++iSCSI targets can have several incoming user names, so the corresponding ++attribute should have sysfs name "IncomingUser". If there are 2 user ++names, they should have sysfs names "IncomingUser" and "IncomingUser1". ++In other words, all "IncomingUser[0-9]*" names should be considered as ++different instances of the same "IncomingUser" attribute. ++ ++ ++I. Rules for target drivers ++=========================== ++ ++SCST core for each target driver (struct scst_tgt_template) creates a ++root subdirectory in /sys/kernel/scst_tgt/targets with name ++scst_tgt_template.name (called "target_driver_name" further in this ++document). ++ ++For each target (struct scst_tgt) SCST core creates a root subdirectory ++in /sys/kernel/scst_tgt/targets/target_driver_name with name ++scst_tgt.tgt_name (called "target_name" further in this document). ++ ++There are 2 type of targets possible: hardware and virtual targets. ++Hardware targets are targets corresponding to real hardware, for ++instance, a Fibre Channel adapter's port. Virtual targets are hardware ++independent targets, which can be dynamically added or removed, for ++instance, an iSCSI target, or NPIV Fibre Channel target. ++ ++A target driver supporting virtual targets MUST support "mgmt" attribute ++and "add_target"/"del_target" commands. ++ ++If target driver supports both hardware and virtual targets (for ++instance, an FC adapter supporting NPIV, which has hardware targets for ++its physical ports as well as virtual NPIV targets), it MUST create each ++hardware target with hw_target mark to make SCST core create "hw_target" ++attribute (see below). ++ ++Attributes for target drivers ++----------------------------- ++ ++A target driver MAY support in its root subdirectory the following ++optional attributes. Target drivers MAY also support there other ++read-only or read-writable attributes. ++ ++1. "enabled" - this attribute MUST allow to enable and disable target ++driver as a whole, i.e. if disabled, the target driver MUST NOT accept ++new connections. The goal of this attribute is to allow the target ++driver's initial configuration. For instance, iSCSI target may need to ++have discovery user names and passwords set before it starts serving ++discovery connections. ++ ++This attribute MUST have read and write permissions for superuser and be ++read-only for other users. ++ ++On read it MUST return 0, if the target driver is disabled, and 1, if it ++is enabled. ++ ++On write it MUST accept '0' character as request to disable and '1' as ++request to enable, but MAY also accept other driver specific commands. ++ ++During disabling the target driver MAY close already connected sessions ++in all targets, but this is OPTIONAL. ++ ++MUST be 0 by default. ++ ++2. "trace_level" - this attribute SHOULD allow to change log level of this ++driver. ++ ++This attribute SHOULD have read and write permissions for superuser and be ++read-only for other users. ++ ++On read it SHOULD return a help text about available command and log levels. ++ ++On write it SHOULD accept commands to change log levels according to the ++help text. ++ ++For example: ++ ++out_of_mem | minor | pid | line | function | special | mgmt | mgmt_dbg | flow_control | conn ++ ++Usage: ++ echo "all|none|default" >trace_level ++ echo "value DEC|0xHEX|0OCT" >trace_level ++ echo "add|del TOKEN" >trace_level ++ ++where TOKEN is one of [debug, function, line, pid, ++ entryexit, buff, mem, sg, out_of_mem, ++ special, scsi, mgmt, minor, ++ mgmt_dbg, scsi_serializing, ++ retry, recv_bot, send_bot, recv_top, ++ send_top, d_read, d_write, conn, conn_dbg, iov, pdu, net_page] ++ ++ ++3. "version" - this read-only for all attribute SHOULD return version of ++the target driver and some info about its enabled compile time facilities. ++ ++For example: ++ ++2.0.0 ++EXTRACHECKS ++DEBUG ++ ++4. "mgmt" - if supported this attribute MUST allow to add and delete ++targets, if virtual targets are supported by this driver, as well as it ++MAY allow to add and delete the target driver's or its targets' ++attributes. ++ ++This attribute MUST have read and write permissions for superuser and be ++read-only for other users. ++ ++On read it MUST return a help string describing available commands, ++parameters and attributes. ++ ++To achieve that the target driver should just set in its struct ++scst_tgt_template correctly the following fields: mgmt_cmd_help, ++add_target_parameters, tgtt_optional_attributes and ++tgt_optional_attributes. ++ ++For example: ++ ++Usage: echo "add_target target_name [parameters]" >mgmt ++ echo "del_target target_name" >mgmt ++ echo "add_attribute <attribute> <value>" >mgmt ++ echo "del_attribute <attribute> <value>" >mgmt ++ echo "add_target_attribute target_name <attribute> <value>" >mgmt ++ echo "del_target_attribute target_name <attribute> <value>" >mgmt ++ ++where parameters are one or more param_name=value pairs separated by ';' ++ ++The following target driver attributes available: IncomingUser, OutgoingUser ++The following target attributes available: IncomingUser, OutgoingUser, allowed_portal ++ ++4.1. "add_target" - if supported, this command MUST add new target with ++name "target_name" and specified optional or required parameters. Each ++parameter MUST be in form "parameter=value". All parameters MUST be ++separated by ';' symbol. ++ ++All target drivers supporting creation of virtual targets MUST support ++this command. ++ ++All target drivers supporting "add_target" command MUST support all ++read-only targets' key attributes as parameters to "add_target" command ++with the attributes' names as parameters' names and the attributes' ++values as parameters' values. ++ ++For example: ++ ++echo "add_target TARGET1 parameter1=1; parameter2=2" >mgmt ++ ++will add target with name "TARGET1" and parameters with names ++"parameter1" and "parameter2" with values 1 and 2 correspondingly. ++ ++4.2. "del_target" - if supported, this command MUST delete target with ++name "target_name". If "add_target" command is supported "del_target" ++MUST also be supported. ++ ++4.3. "add_attribute" - if supported, this command MUST add a target ++driver's attribute with the specified name and one or more values. ++ ++All target drivers supporting run time creation of the target driver's ++key attributes MUST support this command. ++ ++For example, for iSCSI target: ++ ++echo "add_attribute IncomingUser name password" >mgmt ++ ++will add for discovery sessions an incoming user (attribute ++/sys/kernel/scst_tgt/targets/iscsi/IncomingUser) with name "name" and ++password "password". ++ ++4.4. "del_attribute" - if supported, this command MUST delete target ++driver's attribute with the specified name and values. The values MUST ++be specified, because in some cases attributes MAY internally be ++distinguished by values. For instance, iSCSI target might have several ++incoming users. If not needed, target driver might ignore the values. ++ ++If "add_attribute" command is supported "del_attribute" MUST ++also be supported. ++ ++4.5. "add_target_attribute" - if supported, this command MUST add new ++attribute for the specified target with the specified name and one or ++more values. ++ ++All target drivers supporting run time creation of targets' key ++attributes MUST support this command. ++ ++For example: ++ ++echo "add_target_attribute iqn.2006-10.net.vlnb:tgt IncomingUser name password" >mgmt ++ ++will add for target with name "iqn.2006-10.net.vlnb:tgt" an incoming ++user (attribute ++/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/IncomingUser) ++with name "name" and password "password". ++ ++4.6. "del_target_attribute" - if supported, this command MUST delete ++target's attribute with the specified name and values. The values MUST ++be specified, because in some cases attributes MAY internally be ++distinguished by values. For instance, iSCSI target might have several ++incoming users. If not needed, target driver might ignore the values. ++ ++If "add_target_attribute" command is supported "del_target_attribute" ++MUST also be supported. ++ ++Attributes for targets ++---------------------- ++ ++Each target MAY support in its root subdirectory the following optional ++attributes. Target drivers MAY also support there other read-only or ++read-writable attributes. ++ ++1. "enabled" - this attribute MUST allow to enable and disable the ++corresponding target, i.e. if disabled, the target MUST NOT accept new ++connections. The goal of this attribute is to allow the target's initial ++configuration. For instance, each target needs to have its LUNs setup ++before it starts serving initiators. Another example is iSCSI target, ++which may need to have initialized a number of iSCSI parameters before ++it starts accepting new iSCSI connections. ++ ++This attribute MUST have read and write permissions for superuser and be ++read-only for other users. ++ ++On read it MUST return 0, if the target is disabled, and 1, if it is ++enabled. ++ ++On write it MUST accept '0' character as request to disable and '1' as ++request to enable. Other requests MUST be rejected. ++ ++SCST core provides some facilities, which MUST be used to implement this ++attribute. ++ ++During disabling the target driver MAY close already connected sessions ++to the target, but this is OPTIONAL. ++ ++MUST be 0 by default. ++ ++SCST core will automatically create for all targets the following ++attributes: ++ ++1. "rel_tgt_id" - allows to read or write SCSI Relative Target Port ++Identifier attribute. ++ ++2. "hw_target" - allows to distinguish hardware and virtual targets, if ++the target driver supports both. ++ ++To provide OPTIONAL force close session functionality target drivers ++MUST implement it using "force_close" write only session's attribute, ++which on write to it MUST close the corresponding session. ++ ++See SCST core's README for more info about those attributes. ++ ++ ++II. Rules for dev handlers ++========================== ++ ++There are 2 types of dev handlers: parent dev handlers and children dev ++handlers. The children dev handlers depend from the parent dev handlers. ++ ++SCST core for each parent dev handler (struct scst_dev_type with ++parent member with value NULL) creates a root subdirectory in ++/sys/kernel/scst_tgt/handlers with name scst_dev_type.name (called ++"dev_handler_name" further in this document). ++ ++Parent dev handlers can have one or more subdirectories for children dev ++handlers with names scst_dev_type.name of them. ++ ++Only one level of the dev handlers' parent/children hierarchy is ++allowed. Parent dev handlers, which support children dev handlers, MUST ++NOT handle devices and MUST be only placeholders for the children dev ++handlers. ++ ++Further in this document children dev handlers or parent dev handlers, ++which don't support children, will be called "end level dev handlers". ++ ++End level dev handlers can be recognized by existence of the "mgmt" ++attribute. ++ ++For each device (struct scst_device) SCST core creates a root ++subdirectory in /sys/kernel/scst_tgt/devices/device_name with name ++scst_device.virt_name (called "device_name" further in this document). ++ ++Attributes for dev handlers ++--------------------------- ++ ++Each dev handler MUST have it in its root subdirectory "mgmt" attribute, ++which MUST support "add_device" and "del_device" attributes as described ++below. ++ ++Parent dev handlers and end level dev handlers without parents MAY ++support in its root subdirectory the following optional attributes. They ++MAY also support there other read-only or read-writable attributes. ++ ++1. "trace_level" - this attribute SHOULD allow to change log level of this ++driver. ++ ++This attribute SHOULD have read and write permissions for superuser and be ++read-only for other users. ++ ++On read it SHOULD return a help text about available command and log levels. ++ ++On write it SHOULD accept commands to change log levels according to the ++help text. ++ ++For example: ++ ++out_of_mem | minor | pid | line | function | special | mgmt | mgmt_dbg ++ ++ ++Usage: ++ echo "all|none|default" >trace_level ++ echo "value DEC|0xHEX|0OCT" >trace_level ++ echo "add|del TOKEN" >trace_level ++ ++where TOKEN is one of [debug, function, line, pid, ++ entryexit, buff, mem, sg, out_of_mem, ++ special, scsi, mgmt, minor, ++ mgmt_dbg, scsi_serializing, ++ retry, recv_bot, send_bot, recv_top, ++ send_top] ++ ++2. "version" - this read-only for all attribute SHOULD return version of ++the dev handler and some info about its enabled compile time facilities. ++ ++For example: ++ ++2.0.0 ++EXTRACHECKS ++DEBUG ++ ++End level dev handlers in their root subdirectories MUST support "mgmt" ++attribute and MAY support other read-only or read-writable attributes. ++This attribute MUST have read and write permissions for superuser and be ++read-only for other users. ++ ++Attribute "mgmt" for virtual devices dev handlers ++~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ++ ++For virtual devices dev handlers "mgmt" attribute MUST allow to add and ++delete devices as well as it MAY allow to add and delete the dev ++handler's or its devices' attributes. ++ ++On read it MUST return a help string describing available commands and ++parameters. ++ ++To achieve that the dev handler should just set in its struct ++scst_dev_type correctly the following fields: mgmt_cmd_help, ++add_device_parameters, devt_optional_attributes and ++dev_optional_attributes. ++ ++For example: ++ ++Usage: echo "add_device device_name [parameters]" >mgmt ++ echo "del_device device_name" >mgmt ++ echo "add_attribute <attribute> <value>" >mgmt ++ echo "del_attribute <attribute> <value>" >mgmt ++ echo "add_device_attribute device_name <attribute> <value>" >mgmt ++ echo "del_device_attribute device_name <attribute> <value>" >mgmt ++ ++where parameters are one or more param_name=value pairs separated by ';' ++ ++The following parameters available: filename, blocksize, write_through, nv_cache, o_direct, read_only, removable ++The following device driver attributes available: AttributeX, AttributeY ++The following device attributes available: AttributeDX, AttributeDY ++ ++1. "add_device" - this command MUST add new device with name ++"device_name" and specified optional or required parameters. Each ++parameter MUST be in form "parameter=value". All parameters MUST be ++separated by ';' symbol. ++ ++All dev handlers supporting "add_device" command MUST support all ++read-only devices' key attributes as parameters to "add_device" command ++with the attributes' names as parameters' names and the attributes' ++values as parameters' values. ++ ++For example: ++ ++echo "add_device device1 parameter1=1; parameter2=2" >mgmt ++ ++will add device with name "device1" and parameters with names ++"parameter1" and "parameter2" with values 1 and 2 correspondingly. ++ ++2. "del_device" - this command MUST delete device with name ++"device_name". ++ ++3. "add_attribute" - if supported, this command MUST add a device ++driver's attribute with the specified name and one or more values. ++ ++All dev handlers supporting run time creation of the dev handler's ++key attributes MUST support this command. ++ ++For example: ++ ++echo "add_attribute AttributeX ValueX" >mgmt ++ ++will add attribute ++/sys/kernel/scst_tgt/handlers/dev_handler_name/AttributeX with value ValueX. ++ ++4. "del_attribute" - if supported, this command MUST delete device ++driver's attribute with the specified name and values. The values MUST ++be specified, because in some cases attributes MAY internally be ++distinguished by values. If not needed, dev handler might ignore the ++values. ++ ++If "add_attribute" command is supported "del_attribute" MUST also be ++supported. ++ ++5. "add_device_attribute" - if supported, this command MUST add new ++attribute for the specified device with the specified name and one or ++more values. ++ ++All dev handlers supporting run time creation of devices' key attributes ++MUST support this command. ++ ++For example: ++ ++echo "add_device_attribute device1 AttributeDX ValueDX" >mgmt ++ ++will add for device with name "device1" attribute ++/sys/kernel/scst_tgt/devices/device_name/AttributeDX) with value ++ValueDX. ++ ++6. "del_device_attribute" - if supported, this command MUST delete ++device's attribute with the specified name and values. The values MUST ++be specified, because in some cases attributes MAY internally be ++distinguished by values. If not needed, dev handler might ignore the ++values. ++ ++If "add_device_attribute" command is supported "del_device_attribute" ++MUST also be supported. ++ ++Attribute "mgmt" for pass-through devices dev handlers ++~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ++ ++For pass-through devices dev handlers "mgmt" attribute MUST allow to ++assign and unassign this dev handler to existing SCSI devices via ++"add_device" and "del_device" commands correspondingly. ++ ++On read it MUST return a help string describing available commands and ++parameters. ++ ++For example: ++ ++Usage: echo "add_device H:C:I:L" >mgmt ++ echo "del_device H:C:I:L" >mgmt ++ ++1. "add_device" - this command MUST assign SCSI device with ++host:channel:id:lun numbers to this dev handler. ++ ++All pass-through dev handlers MUST support this command. ++ ++For example: ++ ++echo "add_device 1:0:0:0" >mgmt ++ ++will assign SCSI device 1:0:0:0 to this dev handler. ++ ++2. "del_device" - this command MUST unassign SCSI device with ++host:channel:id:lun numbers from this dev handler. ++ ++SCST core will automatically create for all dev handlers the following ++attributes: ++ ++1. "type" - SCSI type of device this dev handler can handle. ++ ++See SCST core's README for more info about those attributes. ++ ++Attributes for devices ++---------------------- ++ ++Each device MAY support in its root subdirectory any read-only or ++read-writable attributes. ++ ++SCST core will automatically create for all devices the following ++attributes: ++ ++1. "type" - SCSI type of this device ++ ++See SCST core's README for more info about those attributes. ++ ++ ++III. Rules for management utilities ++=================================== ++ ++Rules summary ++------------- ++ ++A management utility (scstadmin) SHOULD NOT keep any knowledge specific ++to any device, dev handler, target or target driver. It SHOULD only know ++the common SCST SYSFS rules, which all dev handlers and target drivers ++MUST follow. Namely: ++ ++Common rules: ++~~~~~~~~~~~~~ ++ ++1. All key attributes MUST be marked by mark "[key]" in the last line of ++the attribute. ++ ++2. All not key attributes don't matter and SHOULD be ignored. ++ ++For target drivers and targets: ++~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ++ ++1. If target driver supports adding new targets, it MUST have "mgmt" ++attribute, which MUST support "add_target" and "del_target" commands as ++specified above. ++ ++2. If target driver supports run time adding new key attributes, it MUST ++have "mgmt" attribute, which MUST support "add_attribute" and ++"del_attribute" commands as specified above. ++ ++3. If target driver supports both hardware and virtual targets, all its ++hardware targets MUST have "hw_target" attribute with value 1. ++ ++4. If target has read-only key attributes, the add_target command MUST ++support them as parameters. ++ ++5. If target supports run time adding new key attributes, the target ++driver MUST have "mgmt" attribute, which MUST support ++"add_target_attribute" and "del_target_attribute" commands as specified ++above. ++ ++6. Both target drivers and targets MAY support "enable" attribute. If ++supported, after configuring the corresponding target driver or target ++"1" MUST be written to this attribute in the following order: at first, ++for all targets of the target driver, then for the target driver. ++ ++For devices and dev handlers: ++~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ++ ++1. Each dev handler in its root subdirectory MUST have "mgmt" attribute. ++ ++2. Each dev handler MUST support "add_device" and "del_device" commands ++to the "mgmt" attribute as specified above. ++ ++3. If dev handler driver supports run time adding new key attributes, it ++MUST support "add_attribute" and "del_attribute" commands to the "mgmt" ++attribute as specified above. ++ ++4. All device handlers have links in the root subdirectory pointing to ++their devices. ++ ++5. If device has read-only key attributes, the "add_device" command MUST ++support them as parameters. ++ ++6. If device supports run time adding new key attributes, its dev ++handler MUST support "add_device_attribute" and "del_device_attribute" ++commands to the "mgmt" attribute as specified above. ++ ++7. Each device has "handler" link to its dev handler's root ++subdirectory. ++ ++How to distinguish and process different types of attributes ++~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ++ ++Since management utilities only interested in key attributes, they ++should simply ignore all non-key attributes, like ++devices/device_name/type or targets/target_driver/target_name/version ++doesn't matter if they are read-only or writable. So, the word "key" ++will be omitted later in this section. ++ ++At first, any attribute can be a key attribute, doesn't matter how it's ++created. ++ ++All the existing on the configuration save time attributes should be ++treated the same. Management utilities shouldn't try to separate anyhow ++them in config files. ++ ++1. Always existing attributes ++----------------------------- ++ ++There are 2 type of them: ++ ++1.1. Writable, like devices/device_name/t10_dev_id or ++targets/qla2x00tgt/target_name/explicit_confirmation. They are the ++simplest and all the values can just be read and written from/to them. ++ ++On the configuration save time they can be distinguished as existing. ++ ++On the write configuration time they can be distinguished as existing ++and writable. ++ ++1.2. Read-only, like devices/fileio_device_name/filename or ++devices/fileio_device_name/block_size. They are also easy to distinguish ++looking at the permissions. ++ ++On the configuration save time they can be distinguished the same as for ++(1.1) as existing. ++ ++On the write configuration time they can be distinguished as existing ++and read-only. They all should be passed to "add_target" or ++"add_device" commands for virtual targets and devices correspondingly. ++To apply changes to them, the whole corresponding object ++(fileio_device_name in this example) should be removed then recreated. ++ ++2. Optional ++----------- ++ ++For instance, targets/iscsi/IncomingUser or ++targets/iscsi/target_name/IncomingUser. There are 4 types of them: ++ ++2.1. Global for target drivers and dev handlers ++----------------------------------------------- ++ ++For instance, targets/iscsi/IncomingUser or handlers/vdisk_fileio/XX ++(none at the moment). ++ ++On the configuration save time they can be distinguished the same as for ++(1.1). ++ ++On the write configuration time they can be distinguished as one of 4 ++choices: ++ ++2.1.1. Existing and writable. In this case they should be treated as ++(1.1) ++ ++2.1.2. Existing and read-only. In this case they should be treated as ++(1.2). ++ ++2.1.3. Not existing. In this case they should be added using ++"add_attribute" command. ++ ++2.1.4. Existing in the sysfs tree and not existing in the config file. ++In this case they should be deleted using "del_attribute" command. ++ ++2.2. Global for targets ++----------------------- ++ ++For instance, targets/iscsi/target_name/IncomingUser. ++ ++On the configuration save time they can be distinguished the same as (1.1). ++ ++On the write configuration time they can be distinguished as one of 4 ++choices: ++ ++2.2.1. Existing and writable. In this case they should be treated as ++(1.1). ++ ++2.2.2. Existing and read-only. In this case they should be treated as ++(1.2). ++ ++2.2.3. Not existing. In this case they should be added using ++"add_target_attribute" command. ++ ++2.2.4. Existing in the sysfs tree and not existing in the config file. ++In this case they should be deleted using "del_target_attribute" ++command. ++ ++2.3. Global for devices ++----------------------- ++ ++For instance, devices/nullio/t10_dev_id. ++ ++On the configuration save time they can be distinguished the same as (1.1). ++ ++On the write configuration time they can be distinguished as one of 4 ++choices: ++ ++2.3.1. Existing and writable. In this case they should be treated as ++(1.1) ++ ++2.3.2. Existing and read-only. In this case they should be treated as ++(1.2). ++ ++2.3.3. Not existing. In this case they should be added using ++"add_device_attribute" command for the corresponding handler, e.g. ++devices/nullio/handler/. ++ ++2.3.4. Existing in the sysfs tree and not existing in the config file. ++In this case they should be deleted using "del_device_attribute" ++command for the corresponding handler, e.g. devices/nullio/handler/. ++ ++Thus, management utility should implement only 8 procedures: (1.1), ++(1.2), (2.1.3), (2.1.4), (2.2.3), (2.2.4), (2.3.3), (2.3.4). ++ ++ ++How to distinguish hardware and virtual targets ++~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ++ ++A target is hardware: ++ ++ * if exist both "hw_target" attribute and "mgmt" management file ++ ++ * or if both don't exist ++ ++A target is virtual if there is "mgmt" file and "hw_target" attribute ++doesn't exist. ++ ++ ++Algorithm to convert current SCST configuration to config file ++-------------------------------------------------------------- ++ ++A management utility SHOULD use the following algorithm when converting ++current SCST configuration to a config file. ++ ++For all attributes with digits at the end the name, the digits part ++should be omitted from the attributes' names during the store. For ++instance, "IncomingUser1" should be stored as "IncomingUser". ++ ++1. Scan all attributes in /sys/kernel/scst_tgt (not recursive) and store ++all found key attributes. ++ ++2. Scan all subdirectories of /sys/kernel/scst_tgt/handlers. Each ++subdirectory with "mgmt" attribute is a root subdirectory of a dev ++handler with name the name of the subdirectory. For each found dev ++handler do the following: ++ ++2.1. Store the dev handler's name. Store also its path to the root ++subdirectory, if it isn't default (/sys/kernel/scst_tgt/handlers/handler_name). ++ ++2.2. Store all dev handler's key attributes. ++ ++2.3. Go through all links in the root subdirectory pointing to ++/sys/kernel/scst_tgt/devices and for each device: ++ ++2.3.1. For virtual devices dev handlers: ++ ++2.3.1.1. Store the name of the device. ++ ++2.3.1.2. Store all key attributes. Mark all read only key attributes ++during storing, they will be parameters for the device's creation. ++ ++2.3.2. For pass-through devices dev handlers: ++ ++2.3.2.1. Store the H:C:I:L name of the device. Optionally, instead of ++the name unique T10 vendor device ID found using command: ++ ++sg_inq -p 0x83 /dev/sdX ++ ++can be stored. It will allow to reliably find out this device if on the ++next reboot it will have another host:channel:id:lin numbers. The sdX ++device can be found as the last letters after ':' in ++/sys/kernel/scst_tgt/devices/H:C:I:L/scsi_device/device/block:sdX. ++ ++3. Go through all subdirectories in /sys/kernel/scst_tgt/targets. For ++each target driver: ++ ++3.1. Store the name of the target driver. ++ ++3.2. Store all its key attributes. ++ ++3.3. Go through all target's subdirectories. For each target: ++ ++3.3.1. Store the name of the target. ++ ++3.3.2. Mark if the target is hardware or virtual target. The target is a ++hardware target if it has "hw_target" attribute or its target driver ++doesn't have "mgmt" attribute. ++ ++3.3.3. Store all key attributes. Mark all read only key attributes ++during storing, they will be parameters for the target's creation. ++ ++3.3.4. Scan all "luns" subdirectory and store: ++ ++ - LUN. ++ ++ - LU's device name. ++ ++ - Key attributes. ++ ++3.3.5. Scan all "ini_groups" subdirectories. For each group store the following: ++ ++ - The group's name. ++ ++ - The group's LUNs (the same info as for 3.3.4). ++ ++ - The group's initiators. ++ ++3.3.6. Store value of "enabled" attribute, if it exists. ++ ++3.4. Store value of "enabled" attribute, if it exists. ++ ++ ++Algorithm to initialize SCST from config file ++--------------------------------------------- ++ ++A management utility SHOULD use the following algorithm when doing ++initial SCST configuration from a config file. All necessary kernel ++modules and user space programs supposed to be already loaded, hence all ++dev handlers' entries in /sys/kernel/scst_tgt/handlers as well as all ++entries for hardware targets already created. ++ ++1. Set stored values for all stored global (/sys/kernel/scst_tgt) ++attributes. ++ ++2. For each dev driver: ++ ++2.1. Set stored values for all already existing stored attributes. ++ ++2.2. Create not existing stored attributes using "add_attribute" command. ++ ++2.3. For virtual devices dev handlers for each stored device: ++ ++2.3.1. Create the device using "add_device" command using marked read ++only attributes as parameters. ++ ++2.3.2. Set stored values for all already existing stored attributes. ++ ++2.3.3. Create not existing stored attributes using ++"add_device_attribute" command. ++ ++2.4. For pass-through dev handlers for each stores device: ++ ++2.4.1. Assign the corresponding pass-through device to this dev handler ++using "add_device" command. ++ ++3. For each target driver: ++ ++3.1. Set stored values for all already existing stored attributes. ++ ++3.2. Create not existing stored attributes using "add_attribute" command. ++ ++3.3. For each target: ++ ++3.3.1. For virtual targets: ++ ++3.3.1.1. Create the target using "add_target" command using marked read ++only attributes as parameters. ++ ++3.3.1.2. Set stored values for all already existing stored attributes. ++ ++3.3.1.3. Create not existing stored attributes using ++"add_target_attribute" command. ++ ++3.3.2. For hardware targets for each target: ++ ++3.3.2.1. Set stored values for all already existing stored attributes. ++ ++3.3.2.2. Create not existing stored attributes using ++"add_target_attribute" command. ++ ++3.3.3. Setup LUNs ++ ++3.3.4. Setup ini_groups, their LUNs and initiators' names. ++ ++3.3.5. If this target supports enabling, enable it. ++ ++3.4. If this target driver supports enabling, enable it. ++ ++ ++Algorithm to apply changes in config file to currently running SCST ++------------------------------------------------------------------- ++ ++A management utility SHOULD use the following algorithm when applying ++changes in config file to currently running SCST. ++ ++Not all changes can be applied on enabled targets or enabled target ++drivers. From other side, for some target drivers enabling/disabling is ++a very long and disruptive operation, which should be performed as rare ++as possible. Thus, the management utility SHOULD support additional ++option, which, if set, will make it to disable all affected targets ++before doing any change with them. ++ ++1. Scan all attributes in /sys/kernel/scst_tgt (not recursive) and ++compare stored and actual key attributes. Apply all changes. ++ ++2. Scan all subdirectories of /sys/kernel/scst_tgt/handlers. Each ++subdirectory with "mgmt" attribute is a root subdirectory of a dev ++handler with name the name of the subdirectory. For each found dev ++handler do the following: ++ ++2.1. Compare stored and actual key attributes. Apply all changes. Create ++new attributes using "add_attribute" commands and delete not needed any ++more attributes using "del_attribute" command. ++ ++2.2. Compare existing devices (links in the root subdirectory pointing ++to /sys/kernel/scst_tgt/devices) and stored devices in the config file. ++Delete all not needed devices and create new devices. ++ ++2.3. For all existing devices: ++ ++2.3.1. Compare stored and actual key attributes. Apply all changes. ++Create new attributes using "add_device_attribute" commands and delete ++not needed any more attributes using "del_device_attribute" command. ++ ++2.3.2. If any read only key attribute for virtual device should be ++changed, delete the devices and recreate it. ++ ++3. Go through all subdirectories in /sys/kernel/scst_tgt/targets. For ++each target driver: ++ ++3.1. If this target driver should be disabled, disable it. ++ ++3.2. Compare stored and actual key attributes. Apply all changes. Create ++new attributes using "add_attribute" commands and delete not needed any ++more attributes using "del_attribute" command. ++ ++3.3. Go through all target's subdirectories. Compare existing and stored ++targets. Delete all not needed targets and create new targets. ++ ++3.4. For all existing targets: ++ ++3.4.1. If this target should be disabled, disable it. ++ ++3.4.2. Compare stored and actual key attributes. Apply all changes. ++Create new attributes using "add_target_attribute" commands and delete ++not needed any more attributes using "del_target_attribute" command. ++ ++3.4.3. If any read only key attribute for virtual target should be ++changed, delete the target and recreate it. ++ ++3.4.4. Scan all "luns" subdirectory and apply necessary changes, using ++"replace" commands to replace one LUN by another, if needed. ++ ++3.4.5. Scan all "ini_groups" subdirectories and apply necessary changes, ++using "replace" commands to replace one LUN by another and "move" ++command to move initiator from one group to another, if needed. It MUST ++be done in the following order: ++ ++ - Necessary initiators deleted, if they aren't going to be moved ++ ++ - LUNs updated ++ ++ - Necessary initiators added or moved ++ ++3.4.6. If this target should be enabled, enable it. ++ ++3.5. If this target driver should be enabled, enable it. ++ +diff -uprN orig/linux-3.2/drivers/scst/dev_handlers/Makefile linux-3.2/drivers/scst/dev_handlers/Makefile +--- orig/linux-3.2/drivers/scst/dev_handlers/Makefile ++++ linux-3.2/drivers/scst/dev_handlers/Makefile +@@ -0,0 +1,14 @@ ++ccflags-y += -Wno-unused-parameter ++ ++obj-m := scst_cdrom.o scst_changer.o scst_disk.o scst_modisk.o scst_tape.o \ ++ scst_vdisk.o scst_raid.o scst_processor.o scst_user.o ++ ++obj-$(CONFIG_SCST_DISK) += scst_disk.o ++obj-$(CONFIG_SCST_TAPE) += scst_tape.o ++obj-$(CONFIG_SCST_CDROM) += scst_cdrom.o ++obj-$(CONFIG_SCST_MODISK) += scst_modisk.o ++obj-$(CONFIG_SCST_CHANGER) += scst_changer.o ++obj-$(CONFIG_SCST_RAID) += scst_raid.o ++obj-$(CONFIG_SCST_PROCESSOR) += scst_processor.o ++obj-$(CONFIG_SCST_VDISK) += scst_vdisk.o ++obj-$(CONFIG_SCST_USER) += scst_user.o +diff -uprN orig/linux-3.2/drivers/scst/dev_handlers/scst_cdrom.c linux-3.2/drivers/scst/dev_handlers/scst_cdrom.c +--- orig/linux-3.2/drivers/scst/dev_handlers/scst_cdrom.c ++++ linux-3.2/drivers/scst/dev_handlers/scst_cdrom.c +@@ -0,0 +1,263 @@ ++/* ++ * scst_cdrom.c ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * SCSI CDROM (type 5) dev handler ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/cdrom.h> ++#include <scsi/scsi_host.h> ++#include <linux/slab.h> ++ ++#define LOG_PREFIX "dev_cdrom" ++ ++#include <scst/scst.h> ++#include "scst_dev_handler.h" ++ ++#define CDROM_NAME "dev_cdrom" ++ ++#define CDROM_DEF_BLOCK_SHIFT 11 ++ ++struct cdrom_params { ++ int block_shift; ++}; ++ ++static int cdrom_attach(struct scst_device *); ++static void cdrom_detach(struct scst_device *); ++static int cdrom_parse(struct scst_cmd *); ++static int cdrom_done(struct scst_cmd *); ++ ++static struct scst_dev_type cdrom_devtype = { ++ .name = CDROM_NAME, ++ .type = TYPE_ROM, ++ .threads_num = 1, ++ .parse_atomic = 1, ++ .dev_done_atomic = 1, ++ .attach = cdrom_attach, ++ .detach = cdrom_detach, ++ .parse = cdrom_parse, ++ .dev_done = cdrom_done, ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ .default_trace_flags = SCST_DEFAULT_DEV_LOG_FLAGS, ++ .trace_flags = &trace_flag, ++#endif ++}; ++ ++static int cdrom_attach(struct scst_device *dev) ++{ ++ int res, rc; ++ uint8_t cmd[10]; ++ const int buffer_size = 512; ++ uint8_t *buffer = NULL; ++ int retries; ++ unsigned char sense_buffer[SCSI_SENSE_BUFFERSIZE]; ++ enum dma_data_direction data_dir; ++ struct cdrom_params *params; ++ ++ TRACE_ENTRY(); ++ ++ if (dev->scsi_dev == NULL || ++ dev->scsi_dev->type != dev->type) { ++ PRINT_ERROR("%s", "SCSI device not define or illegal type"); ++ res = -ENODEV; ++ goto out; ++ } ++ ++ params = kzalloc(sizeof(*params), GFP_KERNEL); ++ if (params == NULL) { ++ PRINT_ERROR("Unable to allocate struct cdrom_params (size %zd)", ++ sizeof(*params)); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ buffer = kmalloc(buffer_size, GFP_KERNEL); ++ if (!buffer) { ++ PRINT_ERROR("Buffer memory allocation (size %d) failure", ++ buffer_size); ++ res = -ENOMEM; ++ goto out_free_params; ++ } ++ ++ /* Clear any existing UA's and get cdrom capacity (cdrom block size) */ ++ memset(cmd, 0, sizeof(cmd)); ++ cmd[0] = READ_CAPACITY; ++ cmd[1] = (dev->scsi_dev->scsi_level <= SCSI_2) ? ++ ((dev->scsi_dev->lun << 5) & 0xe0) : 0; ++ retries = SCST_DEV_UA_RETRIES; ++ while (1) { ++ memset(buffer, 0, buffer_size); ++ memset(sense_buffer, 0, sizeof(sense_buffer)); ++ data_dir = SCST_DATA_READ; ++ ++ TRACE_DBG("%s", "Doing READ_CAPACITY"); ++ rc = scsi_execute(dev->scsi_dev, cmd, data_dir, buffer, ++ buffer_size, sense_buffer, ++ SCST_GENERIC_CDROM_REG_TIMEOUT, 3, 0 ++ , NULL ++ ); ++ ++ TRACE_DBG("READ_CAPACITY done: %x", rc); ++ ++ if ((rc == 0) || ++ !scst_analyze_sense(sense_buffer, ++ sizeof(sense_buffer), SCST_SENSE_KEY_VALID, ++ UNIT_ATTENTION, 0, 0)) ++ break; ++ ++ if (!--retries) { ++ PRINT_ERROR("UA not cleared after %d retries", ++ SCST_DEV_UA_RETRIES); ++ params->block_shift = CDROM_DEF_BLOCK_SHIFT; ++ res = -ENODEV; ++ goto out_free_buf; ++ } ++ } ++ ++ if (rc == 0) { ++ int sector_size = ((buffer[4] << 24) | (buffer[5] << 16) | ++ (buffer[6] << 8) | (buffer[7] << 0)); ++ if (sector_size == 0) ++ params->block_shift = CDROM_DEF_BLOCK_SHIFT; ++ else ++ params->block_shift = ++ scst_calc_block_shift(sector_size); ++ TRACE_DBG("Sector size is %i scsi_level %d(SCSI_2 %d)", ++ sector_size, dev->scsi_dev->scsi_level, SCSI_2); ++ } else { ++ params->block_shift = CDROM_DEF_BLOCK_SHIFT; ++ TRACE(TRACE_MINOR, "Read capacity failed: %x, using default " ++ "sector size %d", rc, params->block_shift); ++ PRINT_BUFF_FLAG(TRACE_MINOR, "Returned sense", sense_buffer, ++ sizeof(sense_buffer)); ++ } ++ ++ res = scst_obtain_device_parameters(dev); ++ if (res != 0) { ++ PRINT_ERROR("Failed to obtain control parameters for device " ++ "%s", dev->virt_name); ++ goto out_free_buf; ++ } ++ ++out_free_buf: ++ kfree(buffer); ++ ++out_free_params: ++ if (res == 0) ++ dev->dh_priv = params; ++ else ++ kfree(params); ++ ++out: ++ TRACE_EXIT(); ++ return res; ++} ++ ++static void cdrom_detach(struct scst_device *dev) ++{ ++ struct cdrom_params *params = ++ (struct cdrom_params *)dev->dh_priv; ++ ++ TRACE_ENTRY(); ++ ++ kfree(params); ++ dev->dh_priv = NULL; ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int cdrom_get_block_shift(struct scst_cmd *cmd) ++{ ++ struct cdrom_params *params = (struct cdrom_params *)cmd->dev->dh_priv; ++ /* ++ * No need for locks here, since *_detach() can not be ++ * called, when there are existing commands. ++ */ ++ return params->block_shift; ++} ++ ++static int cdrom_parse(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_DEFAULT; ++ ++ scst_cdrom_generic_parse(cmd, cdrom_get_block_shift); ++ ++ cmd->retries = SCST_PASSTHROUGH_RETRIES; ++ ++ return res; ++} ++ ++static void cdrom_set_block_shift(struct scst_cmd *cmd, int block_shift) ++{ ++ struct cdrom_params *params = (struct cdrom_params *)cmd->dev->dh_priv; ++ /* ++ * No need for locks here, since *_detach() can not be ++ * called, when there are existing commands. ++ */ ++ if (block_shift != 0) ++ params->block_shift = block_shift; ++ else ++ params->block_shift = CDROM_DEF_BLOCK_SHIFT; ++ return; ++} ++ ++static int cdrom_done(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_DEFAULT; ++ ++ TRACE_ENTRY(); ++ ++ res = scst_block_generic_dev_done(cmd, cdrom_set_block_shift); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int __init cdrom_init(void) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ cdrom_devtype.module = THIS_MODULE; ++ ++ res = scst_register_dev_driver(&cdrom_devtype); ++ if (res < 0) ++ goto out; ++ ++out: ++ TRACE_EXIT(); ++ return res; ++ ++} ++ ++static void __exit cdrom_exit(void) ++{ ++ TRACE_ENTRY(); ++ scst_unregister_dev_driver(&cdrom_devtype); ++ TRACE_EXIT(); ++ return; ++} ++ ++module_init(cdrom_init); ++module_exit(cdrom_exit); ++ ++MODULE_LICENSE("GPL"); ++MODULE_AUTHOR("Vladislav Bolkhovitin & Leonid Stoljar"); ++MODULE_DESCRIPTION("SCSI CDROM (type 5) dev handler for SCST"); ++MODULE_VERSION(SCST_VERSION_STRING); +diff -uprN orig/linux-3.2/drivers/scst/dev_handlers/scst_changer.c linux-3.2/drivers/scst/dev_handlers/scst_changer.c +--- orig/linux-3.2/drivers/scst/dev_handlers/scst_changer.c ++++ linux-3.2/drivers/scst/dev_handlers/scst_changer.c +@@ -0,0 +1,183 @@ ++/* ++ * scst_changer.c ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * SCSI medium changer (type 8) dev handler ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <scsi/scsi_host.h> ++#include <linux/slab.h> ++ ++#define LOG_PREFIX "dev_changer" ++ ++#include <scst/scst.h> ++#include "scst_dev_handler.h" ++ ++#define CHANGER_NAME "dev_changer" ++ ++#define CHANGER_RETRIES 2 ++ ++static int changer_attach(struct scst_device *); ++/* static void changer_detach(struct scst_device *); */ ++static int changer_parse(struct scst_cmd *); ++/* static int changer_done(struct scst_cmd *); */ ++ ++static struct scst_dev_type changer_devtype = { ++ .name = CHANGER_NAME, ++ .type = TYPE_MEDIUM_CHANGER, ++ .threads_num = 1, ++ .parse_atomic = 1, ++/* .dev_done_atomic = 1, */ ++ .attach = changer_attach, ++/* .detach = changer_detach, */ ++ .parse = changer_parse, ++/* .dev_done = changer_done */ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ .default_trace_flags = SCST_DEFAULT_DEV_LOG_FLAGS, ++ .trace_flags = &trace_flag, ++#endif ++}; ++ ++static int changer_attach(struct scst_device *dev) ++{ ++ int res, rc; ++ int retries; ++ ++ TRACE_ENTRY(); ++ ++ if (dev->scsi_dev == NULL || ++ dev->scsi_dev->type != dev->type) { ++ PRINT_ERROR("%s", "SCSI device not define or illegal type"); ++ res = -ENODEV; ++ goto out; ++ } ++ ++ /* ++ * If the device is offline, don't try to read capacity or any ++ * of the other stuff ++ */ ++ if (dev->scsi_dev->sdev_state == SDEV_OFFLINE) { ++ TRACE_DBG("%s", "Device is offline"); ++ res = -ENODEV; ++ goto out; ++ } ++ ++ retries = SCST_DEV_UA_RETRIES; ++ do { ++ TRACE_DBG("%s", "Doing TEST_UNIT_READY"); ++ rc = scsi_test_unit_ready(dev->scsi_dev, ++ SCST_GENERIC_CHANGER_TIMEOUT, CHANGER_RETRIES ++ , NULL); ++ TRACE_DBG("TEST_UNIT_READY done: %x", rc); ++ } while ((--retries > 0) && rc); ++ ++ if (rc) { ++ PRINT_WARNING("Unit not ready: %x", rc); ++ /* Let's try not to be too smart and continue processing */ ++ } ++ ++ res = scst_obtain_device_parameters(dev); ++ if (res != 0) { ++ PRINT_ERROR("Failed to obtain control parameters for device " ++ "%s", dev->virt_name); ++ goto out; ++ } ++ ++out: ++ TRACE_EXIT_HRES(res); ++ return res; ++} ++ ++#if 0 ++void changer_detach(struct scst_device *dev) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_EXIT(); ++ return; ++} ++#endif ++ ++static int changer_parse(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_DEFAULT; ++ ++ scst_changer_generic_parse(cmd, NULL); ++ ++ cmd->retries = SCST_PASSTHROUGH_RETRIES; ++ ++ return res; ++} ++ ++#if 0 ++int changer_done(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_DEFAULT; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * SCST sets good defaults for cmd->is_send_status and ++ * cmd->resp_data_len based on cmd->status and cmd->data_direction, ++ * therefore change them only if necessary ++ */ ++ ++#if 0 ++ switch (cmd->cdb[0]) { ++ default: ++ /* It's all good */ ++ break; ++ } ++#endif ++ ++ TRACE_EXIT(); ++ return res; ++} ++#endif ++ ++static int __init changer_init(void) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ changer_devtype.module = THIS_MODULE; ++ ++ res = scst_register_dev_driver(&changer_devtype); ++ if (res < 0) ++ goto out; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void __exit changer_exit(void) ++{ ++ TRACE_ENTRY(); ++ scst_unregister_dev_driver(&changer_devtype); ++ TRACE_EXIT(); ++ return; ++} ++ ++module_init(changer_init); ++module_exit(changer_exit); ++ ++MODULE_AUTHOR("Vladislav Bolkhovitin & Leonid Stoljar"); ++MODULE_LICENSE("GPL"); ++MODULE_DESCRIPTION("SCSI medium changer (type 8) dev handler for SCST"); ++MODULE_VERSION(SCST_VERSION_STRING); +diff -uprN orig/linux-3.2/drivers/scst/dev_handlers/scst_dev_handler.h linux-3.2/drivers/scst/dev_handlers/scst_dev_handler.h +--- orig/linux-3.2/drivers/scst/dev_handlers/scst_dev_handler.h ++++ linux-3.2/drivers/scst/dev_handlers/scst_dev_handler.h +@@ -0,0 +1,27 @@ ++#ifndef __SCST_DEV_HANDLER_H ++#define __SCST_DEV_HANDLER_H ++ ++#include <linux/module.h> ++#include <scsi/scsi_eh.h> ++#include <scst/scst_debug.h> ++ ++#define SCST_DEV_UA_RETRIES 5 ++#define SCST_PASSTHROUGH_RETRIES 0 ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ ++#ifdef CONFIG_SCST_DEBUG ++#define SCST_DEFAULT_DEV_LOG_FLAGS (TRACE_OUT_OF_MEM | TRACE_PID | \ ++ TRACE_LINE | TRACE_FUNCTION | TRACE_MGMT | TRACE_MINOR | \ ++ TRACE_MGMT_DEBUG | TRACE_SPECIAL) ++#else ++#define SCST_DEFAULT_DEV_LOG_FLAGS (TRACE_OUT_OF_MEM | TRACE_MGMT | \ ++ TRACE_SPECIAL) ++#endif ++ ++static unsigned long dh_trace_flag = SCST_DEFAULT_DEV_LOG_FLAGS; ++#define trace_flag dh_trace_flag ++ ++#endif /* defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) */ ++ ++#endif /* __SCST_DEV_HANDLER_H */ +diff -uprN orig/linux-3.2/drivers/scst/dev_handlers/scst_disk.c linux-3.2/drivers/scst/dev_handlers/scst_disk.c +--- orig/linux-3.2/drivers/scst/dev_handlers/scst_disk.c ++++ linux-3.2/drivers/scst/dev_handlers/scst_disk.c +@@ -0,0 +1,692 @@ ++/* ++ * scst_disk.c ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * SCSI disk (type 0) dev handler ++ * & ++ * SCSI disk (type 0) "performance" device handler (skip all READ and WRITE ++ * operations). ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/module.h> ++#include <linux/init.h> ++#include <linux/blkdev.h> ++#include <scsi/scsi_host.h> ++#include <linux/slab.h> ++#include <asm/unaligned.h> ++ ++#define LOG_PREFIX "dev_disk" ++ ++#include <scst/scst.h> ++#include "scst_dev_handler.h" ++ ++# define DISK_NAME "dev_disk" ++# define DISK_PERF_NAME "dev_disk_perf" ++ ++#define DISK_DEF_BLOCK_SHIFT 9 ++ ++struct disk_params { ++ int block_shift; ++}; ++ ++static int disk_attach(struct scst_device *dev); ++static void disk_detach(struct scst_device *dev); ++static int disk_parse(struct scst_cmd *cmd); ++static int disk_perf_exec(struct scst_cmd *cmd); ++static int disk_done(struct scst_cmd *cmd); ++static int disk_exec(struct scst_cmd *cmd); ++static bool disk_on_sg_tablesize_low(struct scst_cmd *cmd); ++ ++static struct scst_dev_type disk_devtype = { ++ .name = DISK_NAME, ++ .type = TYPE_DISK, ++ .threads_num = 1, ++ .parse_atomic = 1, ++ .dev_done_atomic = 1, ++ .attach = disk_attach, ++ .detach = disk_detach, ++ .parse = disk_parse, ++ .exec = disk_exec, ++ .on_sg_tablesize_low = disk_on_sg_tablesize_low, ++ .dev_done = disk_done, ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ .default_trace_flags = SCST_DEFAULT_DEV_LOG_FLAGS, ++ .trace_flags = &trace_flag, ++#endif ++}; ++ ++static struct scst_dev_type disk_devtype_perf = { ++ .name = DISK_PERF_NAME, ++ .type = TYPE_DISK, ++ .parse_atomic = 1, ++ .dev_done_atomic = 1, ++ .attach = disk_attach, ++ .detach = disk_detach, ++ .parse = disk_parse, ++ .exec = disk_perf_exec, ++ .dev_done = disk_done, ++ .on_sg_tablesize_low = disk_on_sg_tablesize_low, ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ .default_trace_flags = SCST_DEFAULT_DEV_LOG_FLAGS, ++ .trace_flags = &trace_flag, ++#endif ++}; ++ ++static int __init init_scst_disk_driver(void) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ disk_devtype.module = THIS_MODULE; ++ ++ res = scst_register_dev_driver(&disk_devtype); ++ if (res < 0) ++ goto out; ++ ++ disk_devtype_perf.module = THIS_MODULE; ++ ++ res = scst_register_dev_driver(&disk_devtype_perf); ++ if (res < 0) ++ goto out_unreg; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_unreg: ++ scst_unregister_dev_driver(&disk_devtype); ++ goto out; ++} ++ ++static void __exit exit_scst_disk_driver(void) ++{ ++ TRACE_ENTRY(); ++ ++ scst_unregister_dev_driver(&disk_devtype_perf); ++ scst_unregister_dev_driver(&disk_devtype); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++module_init(init_scst_disk_driver); ++module_exit(exit_scst_disk_driver); ++ ++static int disk_attach(struct scst_device *dev) ++{ ++ int res, rc; ++ uint8_t cmd[10]; ++ const int buffer_size = 512; ++ uint8_t *buffer = NULL; ++ int retries; ++ unsigned char sense_buffer[SCSI_SENSE_BUFFERSIZE]; ++ enum dma_data_direction data_dir; ++ struct disk_params *params; ++ ++ TRACE_ENTRY(); ++ ++ if (dev->scsi_dev == NULL || ++ dev->scsi_dev->type != dev->type) { ++ PRINT_ERROR("%s", "SCSI device not define or illegal type"); ++ res = -ENODEV; ++ goto out; ++ } ++ ++ params = kzalloc(sizeof(*params), GFP_KERNEL); ++ if (params == NULL) { ++ PRINT_ERROR("Unable to allocate struct disk_params (size %zd)", ++ sizeof(*params)); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ buffer = kmalloc(buffer_size, GFP_KERNEL); ++ if (!buffer) { ++ PRINT_ERROR("Buffer memory allocation (size %d) failure", ++ buffer_size); ++ res = -ENOMEM; ++ goto out_free_params; ++ } ++ ++ /* Clear any existing UA's and get disk capacity (disk block size) */ ++ memset(cmd, 0, sizeof(cmd)); ++ cmd[0] = READ_CAPACITY; ++ cmd[1] = (dev->scsi_dev->scsi_level <= SCSI_2) ? ++ ((dev->scsi_dev->lun << 5) & 0xe0) : 0; ++ retries = SCST_DEV_UA_RETRIES; ++ while (1) { ++ memset(buffer, 0, buffer_size); ++ memset(sense_buffer, 0, sizeof(sense_buffer)); ++ data_dir = SCST_DATA_READ; ++ ++ TRACE_DBG("%s", "Doing READ_CAPACITY"); ++ rc = scsi_execute(dev->scsi_dev, cmd, data_dir, buffer, ++ buffer_size, sense_buffer, ++ SCST_GENERIC_DISK_REG_TIMEOUT, 3, 0 ++ , NULL ++ ); ++ ++ TRACE_DBG("READ_CAPACITY done: %x", rc); ++ ++ if ((rc == 0) || ++ !scst_analyze_sense(sense_buffer, ++ sizeof(sense_buffer), SCST_SENSE_KEY_VALID, ++ UNIT_ATTENTION, 0, 0)) ++ break; ++ if (!--retries) { ++ PRINT_ERROR("UA not clear after %d retries", ++ SCST_DEV_UA_RETRIES); ++ res = -ENODEV; ++ goto out_free_buf; ++ } ++ } ++ if (rc == 0) { ++ int sector_size = ((buffer[4] << 24) | (buffer[5] << 16) | ++ (buffer[6] << 8) | (buffer[7] << 0)); ++ if (sector_size == 0) ++ params->block_shift = DISK_DEF_BLOCK_SHIFT; ++ else ++ params->block_shift = ++ scst_calc_block_shift(sector_size); ++ } else { ++ params->block_shift = DISK_DEF_BLOCK_SHIFT; ++ TRACE(TRACE_MINOR, "Read capacity failed: %x, using default " ++ "sector size %d", rc, params->block_shift); ++ PRINT_BUFF_FLAG(TRACE_MINOR, "Returned sense", sense_buffer, ++ sizeof(sense_buffer)); ++ } ++ ++ res = scst_obtain_device_parameters(dev); ++ if (res != 0) { ++ PRINT_ERROR("Failed to obtain control parameters for device " ++ "%s", dev->virt_name); ++ goto out_free_buf; ++ } ++ ++out_free_buf: ++ kfree(buffer); ++ ++out_free_params: ++ if (res == 0) ++ dev->dh_priv = params; ++ else ++ kfree(params); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void disk_detach(struct scst_device *dev) ++{ ++ struct disk_params *params = ++ (struct disk_params *)dev->dh_priv; ++ ++ TRACE_ENTRY(); ++ ++ kfree(params); ++ dev->dh_priv = NULL; ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int disk_get_block_shift(struct scst_cmd *cmd) ++{ ++ struct disk_params *params = (struct disk_params *)cmd->dev->dh_priv; ++ /* ++ * No need for locks here, since *_detach() can not be ++ * called, when there are existing commands. ++ */ ++ return params->block_shift; ++} ++ ++static int disk_parse(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_DEFAULT; ++ ++ scst_sbc_generic_parse(cmd, disk_get_block_shift); ++ ++ cmd->retries = SCST_PASSTHROUGH_RETRIES; ++ ++ return res; ++} ++ ++static void disk_set_block_shift(struct scst_cmd *cmd, int block_shift) ++{ ++ struct disk_params *params = (struct disk_params *)cmd->dev->dh_priv; ++ /* ++ * No need for locks here, since *_detach() can not be ++ * called, when there are existing commands. ++ */ ++ if (block_shift != 0) ++ params->block_shift = block_shift; ++ else ++ params->block_shift = DISK_DEF_BLOCK_SHIFT; ++ return; ++} ++ ++static int disk_done(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_DEFAULT; ++ ++ TRACE_ENTRY(); ++ ++ res = scst_block_generic_dev_done(cmd, disk_set_block_shift); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static bool disk_on_sg_tablesize_low(struct scst_cmd *cmd) ++{ ++ bool res; ++ ++ TRACE_ENTRY(); ++ ++ switch (cmd->cdb[0]) { ++ case WRITE_6: ++ case READ_6: ++ case WRITE_10: ++ case READ_10: ++ case WRITE_VERIFY: ++ case WRITE_12: ++ case READ_12: ++ case WRITE_VERIFY_12: ++ case WRITE_16: ++ case READ_16: ++ case WRITE_VERIFY_16: ++ res = true; ++ /* See comment in disk_exec */ ++ cmd->inc_expected_sn_on_done = 1; ++ break; ++ default: ++ res = false; ++ break; ++ } ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++struct disk_work { ++ struct scst_cmd *cmd; ++ struct completion disk_work_cmpl; ++ int result; ++ unsigned int left; ++ uint64_t save_lba; ++ unsigned int save_len; ++ struct scatterlist *save_sg; ++ int save_sg_cnt; ++}; ++ ++static int disk_cdb_get_transfer_data(const uint8_t *cdb, ++ uint64_t *out_lba, unsigned int *out_length) ++{ ++ int res; ++ uint64_t lba; ++ unsigned int len; ++ ++ TRACE_ENTRY(); ++ ++ switch (cdb[0]) { ++ case WRITE_6: ++ case READ_6: ++ lba = be16_to_cpu(get_unaligned((__be16 *)&cdb[2])); ++ len = cdb[4]; ++ break; ++ case WRITE_10: ++ case READ_10: ++ case WRITE_VERIFY: ++ lba = be32_to_cpu(get_unaligned((__be32 *)&cdb[2])); ++ len = be16_to_cpu(get_unaligned((__be16 *)&cdb[7])); ++ break; ++ case WRITE_12: ++ case READ_12: ++ case WRITE_VERIFY_12: ++ lba = be32_to_cpu(get_unaligned((__be32 *)&cdb[2])); ++ len = be32_to_cpu(get_unaligned((__be32 *)&cdb[6])); ++ break; ++ case WRITE_16: ++ case READ_16: ++ case WRITE_VERIFY_16: ++ lba = be64_to_cpu(get_unaligned((__be64 *)&cdb[2])); ++ len = be32_to_cpu(get_unaligned((__be32 *)&cdb[10])); ++ break; ++ default: ++ res = -EINVAL; ++ goto out; ++ } ++ ++ res = 0; ++ *out_lba = lba; ++ *out_length = len; ++ ++ TRACE_DBG("LBA %lld, length %d", (unsigned long long)lba, len); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int disk_cdb_set_transfer_data(uint8_t *cdb, ++ uint64_t lba, unsigned int len) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ switch (cdb[0]) { ++ case WRITE_6: ++ case READ_6: ++ put_unaligned(cpu_to_be16(lba), (__be16 *)&cdb[2]); ++ cdb[4] = len; ++ break; ++ case WRITE_10: ++ case READ_10: ++ case WRITE_VERIFY: ++ put_unaligned(cpu_to_be32(lba), (__be32 *)&cdb[2]); ++ put_unaligned(cpu_to_be16(len), (__be16 *)&cdb[7]); ++ break; ++ case WRITE_12: ++ case READ_12: ++ case WRITE_VERIFY_12: ++ put_unaligned(cpu_to_be32(lba), (__be32 *)&cdb[2]); ++ put_unaligned(cpu_to_be32(len), (__be32 *)&cdb[6]); ++ break; ++ case WRITE_16: ++ case READ_16: ++ case WRITE_VERIFY_16: ++ put_unaligned(cpu_to_be64(lba), (__be64 *)&cdb[2]); ++ put_unaligned(cpu_to_be32(len), (__be32 *)&cdb[10]); ++ break; ++ default: ++ res = -EINVAL; ++ goto out; ++ } ++ ++ res = 0; ++ ++ TRACE_DBG("LBA %lld, length %d", (unsigned long long)lba, len); ++ TRACE_BUFFER("New CDB", cdb, SCST_MAX_CDB_SIZE); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void disk_restore_sg(struct disk_work *work) ++{ ++ disk_cdb_set_transfer_data(work->cmd->cdb, work->save_lba, work->save_len); ++ work->cmd->sg = work->save_sg; ++ work->cmd->sg_cnt = work->save_sg_cnt; ++ return; ++} ++ ++static void disk_cmd_done(void *data, char *sense, int result, int resid) ++{ ++ struct disk_work *work = data; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("work %p, cmd %p, left %d, result %d, sense %p, resid %d", ++ work, work->cmd, work->left, result, sense, resid); ++ ++ if (result == SAM_STAT_GOOD) ++ goto out_complete; ++ ++ work->result = result; ++ ++ disk_restore_sg(work); ++ ++ scst_pass_through_cmd_done(work->cmd, sense, result, resid + work->left); ++ ++out_complete: ++ complete_all(&work->disk_work_cmpl); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Executes command and split CDB, if necessary */ ++static int disk_exec(struct scst_cmd *cmd) ++{ ++ int res, rc; ++ struct disk_params *params = (struct disk_params *)cmd->dev->dh_priv; ++ struct disk_work work; ++ unsigned int offset, cur_len; /* in blocks */ ++ struct scatterlist *sg, *start_sg; ++ int cur_sg_cnt; ++ int sg_tablesize = cmd->dev->scsi_dev->host->sg_tablesize; ++ int max_sectors; ++ int num, j; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * For PC requests we are going to submit max_hw_sectors used instead ++ * of max_sectors. ++ */ ++ max_sectors = queue_max_hw_sectors(cmd->dev->scsi_dev->request_queue); ++ ++ if (unlikely(((max_sectors << params->block_shift) & ~PAGE_MASK) != 0)) { ++ int mlen = max_sectors << params->block_shift; ++ int pg = ((mlen >> PAGE_SHIFT) + ((mlen & ~PAGE_MASK) != 0)) - 1; ++ int adj_len = pg << PAGE_SHIFT; ++ max_sectors = adj_len >> params->block_shift; ++ if (max_sectors == 0) { ++ PRINT_ERROR("Too low max sectors %d", max_sectors); ++ goto out_error; ++ } ++ } ++ ++ if (unlikely((cmd->bufflen >> params->block_shift) > max_sectors)) { ++ if ((cmd->out_bufflen >> params->block_shift) > max_sectors) { ++ PRINT_ERROR("Too limited max_sectors %d for " ++ "bidirectional cmd %x (out_bufflen %d)", ++ max_sectors, cmd->cdb[0], cmd->out_bufflen); ++ /* Let lower level handle it */ ++ res = SCST_EXEC_NOT_COMPLETED; ++ goto out; ++ } ++ goto split; ++ } ++ ++ if (likely(cmd->sg_cnt <= sg_tablesize)) { ++ res = SCST_EXEC_NOT_COMPLETED; ++ goto out; ++ } ++ ++split: ++ BUG_ON(cmd->out_sg_cnt > sg_tablesize); ++ BUG_ON((cmd->out_bufflen >> params->block_shift) > max_sectors); ++ ++ /* ++ * We don't support changing BIDI CDBs (see disk_on_sg_tablesize_low()), ++ * so use only sg_cnt ++ */ ++ ++ memset(&work, 0, sizeof(work)); ++ work.cmd = cmd; ++ work.save_sg = cmd->sg; ++ work.save_sg_cnt = cmd->sg_cnt; ++ rc = disk_cdb_get_transfer_data(cmd->cdb, &work.save_lba, ++ &work.save_len); ++ if (rc != 0) ++ goto out_error; ++ ++ rc = scst_check_local_events(cmd); ++ if (unlikely(rc != 0)) ++ goto out_done; ++ ++ cmd->status = 0; ++ cmd->msg_status = 0; ++ cmd->host_status = DID_OK; ++ cmd->driver_status = 0; ++ ++ TRACE_DBG("cmd %p, save_sg %p, save_sg_cnt %d, save_lba %lld, " ++ "save_len %d (sg_tablesize %d, max_sectors %d, block_shift %d, " ++ "sizeof(*sg) 0x%zx)", cmd, work.save_sg, work.save_sg_cnt, ++ (unsigned long long)work.save_lba, work.save_len, ++ sg_tablesize, max_sectors, params->block_shift, sizeof(*sg)); ++ ++ /* ++ * If we submit all chunks async'ly, it will be very not trivial what ++ * to do if several of them finish with sense or residual. So, let's ++ * do it synchronously. ++ */ ++ ++ num = 1; ++ j = 0; ++ offset = 0; ++ cur_len = 0; ++ sg = work.save_sg; ++ start_sg = sg; ++ cur_sg_cnt = 0; ++ while (1) { ++ unsigned int l; ++ ++ if (unlikely(sg_is_chain(&sg[j]))) { ++ bool reset_start_sg = (start_sg == &sg[j]); ++ sg = sg_chain_ptr(&sg[j]); ++ j = 0; ++ if (reset_start_sg) ++ start_sg = sg; ++ } ++ ++ l = sg[j].length >> params->block_shift; ++ cur_len += l; ++ cur_sg_cnt++; ++ ++ TRACE_DBG("l %d, j %d, num %d, offset %d, cur_len %d, " ++ "cur_sg_cnt %d, start_sg %p", l, j, num, offset, ++ cur_len, cur_sg_cnt, start_sg); ++ ++ if (((num % sg_tablesize) == 0) || ++ (num == work.save_sg_cnt) || ++ (cur_len >= max_sectors)) { ++ TRACE_DBG("%s", "Execing..."); ++ ++ disk_cdb_set_transfer_data(cmd->cdb, ++ work.save_lba + offset, cur_len); ++ cmd->sg = start_sg; ++ cmd->sg_cnt = cur_sg_cnt; ++ ++ work.left = work.save_len - (offset + cur_len); ++ init_completion(&work.disk_work_cmpl); ++ ++ rc = scst_scsi_exec_async(cmd, &work, disk_cmd_done); ++ if (unlikely(rc != 0)) { ++ PRINT_ERROR("scst_scsi_exec_async() failed: %d", ++ rc); ++ goto out_err_restore; ++ } ++ ++ wait_for_completion(&work.disk_work_cmpl); ++ ++ if (work.result != SAM_STAT_GOOD) { ++ /* cmd can be already dead */ ++ res = SCST_EXEC_COMPLETED; ++ goto out; ++ } ++ ++ offset += cur_len; ++ cur_len = 0; ++ cur_sg_cnt = 0; ++ start_sg = &sg[j+1]; ++ ++ if (num == work.save_sg_cnt) ++ break; ++ } ++ num++; ++ j++; ++ } ++ ++ cmd->completed = 1; ++ ++out_restore: ++ disk_restore_sg(&work); ++ ++out_done: ++ res = SCST_EXEC_COMPLETED; ++ cmd->scst_cmd_done(cmd, SCST_CMD_STATE_DEFAULT, SCST_CONTEXT_SAME); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_err_restore: ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out_restore; ++ ++out_error: ++ scst_set_cmd_error(cmd, SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out_done; ++} ++ ++static int disk_perf_exec(struct scst_cmd *cmd) ++{ ++ int res, rc; ++ int opcode = cmd->cdb[0]; ++ ++ TRACE_ENTRY(); ++ ++ rc = scst_check_local_events(cmd); ++ if (unlikely(rc != 0)) ++ goto out_done; ++ ++ cmd->status = 0; ++ cmd->msg_status = 0; ++ cmd->host_status = DID_OK; ++ cmd->driver_status = 0; ++ ++ switch (opcode) { ++ case WRITE_6: ++ case WRITE_10: ++ case WRITE_12: ++ case WRITE_16: ++ case READ_6: ++ case READ_10: ++ case READ_12: ++ case READ_16: ++ case WRITE_VERIFY: ++ case WRITE_VERIFY_12: ++ case WRITE_VERIFY_16: ++ goto out_complete; ++ } ++ ++ res = SCST_EXEC_NOT_COMPLETED; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_complete: ++ cmd->completed = 1; ++ ++out_done: ++ res = SCST_EXEC_COMPLETED; ++ cmd->scst_cmd_done(cmd, SCST_CMD_STATE_DEFAULT, SCST_CONTEXT_SAME); ++ goto out; ++} ++ ++MODULE_AUTHOR("Vladislav Bolkhovitin & Leonid Stoljar"); ++MODULE_LICENSE("GPL"); ++MODULE_DESCRIPTION("SCSI disk (type 0) dev handler for SCST"); ++MODULE_VERSION(SCST_VERSION_STRING); ++ +diff -uprN orig/linux-3.2/drivers/scst/dev_handlers/scst_modisk.c linux-3.2/drivers/scst/dev_handlers/scst_modisk.c +--- orig/linux-3.2/drivers/scst/dev_handlers/scst_modisk.c ++++ linux-3.2/drivers/scst/dev_handlers/scst_modisk.c +@@ -0,0 +1,350 @@ ++/* ++ * scst_modisk.c ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * SCSI MO disk (type 7) dev handler ++ * & ++ * SCSI MO disk (type 7) "performance" device handler (skip all READ and WRITE ++ * operations). ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/module.h> ++#include <linux/init.h> ++#include <scsi/scsi_host.h> ++#include <linux/slab.h> ++ ++#define LOG_PREFIX "dev_modisk" ++ ++#include <scst/scst.h> ++#include "scst_dev_handler.h" ++ ++# define MODISK_NAME "dev_modisk" ++# define MODISK_PERF_NAME "dev_modisk_perf" ++ ++#define MODISK_DEF_BLOCK_SHIFT 10 ++ ++struct modisk_params { ++ int block_shift; ++}; ++ ++static int modisk_attach(struct scst_device *); ++static void modisk_detach(struct scst_device *); ++static int modisk_parse(struct scst_cmd *); ++static int modisk_done(struct scst_cmd *); ++static int modisk_perf_exec(struct scst_cmd *); ++ ++static struct scst_dev_type modisk_devtype = { ++ .name = MODISK_NAME, ++ .type = TYPE_MOD, ++ .threads_num = 1, ++ .parse_atomic = 1, ++ .dev_done_atomic = 1, ++ .attach = modisk_attach, ++ .detach = modisk_detach, ++ .parse = modisk_parse, ++ .dev_done = modisk_done, ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ .default_trace_flags = SCST_DEFAULT_DEV_LOG_FLAGS, ++ .trace_flags = &trace_flag, ++#endif ++}; ++ ++static struct scst_dev_type modisk_devtype_perf = { ++ .name = MODISK_PERF_NAME, ++ .type = TYPE_MOD, ++ .parse_atomic = 1, ++ .dev_done_atomic = 1, ++ .attach = modisk_attach, ++ .detach = modisk_detach, ++ .parse = modisk_parse, ++ .dev_done = modisk_done, ++ .exec = modisk_perf_exec, ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ .default_trace_flags = SCST_DEFAULT_DEV_LOG_FLAGS, ++ .trace_flags = &trace_flag, ++#endif ++}; ++ ++static int __init init_scst_modisk_driver(void) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ modisk_devtype.module = THIS_MODULE; ++ ++ res = scst_register_dev_driver(&modisk_devtype); ++ if (res < 0) ++ goto out; ++ ++ modisk_devtype_perf.module = THIS_MODULE; ++ ++ res = scst_register_dev_driver(&modisk_devtype_perf); ++ if (res < 0) ++ goto out_unreg; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_unreg: ++ scst_unregister_dev_driver(&modisk_devtype); ++ goto out; ++} ++ ++static void __exit exit_scst_modisk_driver(void) ++{ ++ TRACE_ENTRY(); ++ ++ scst_unregister_dev_driver(&modisk_devtype_perf); ++ scst_unregister_dev_driver(&modisk_devtype); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++module_init(init_scst_modisk_driver); ++module_exit(exit_scst_modisk_driver); ++ ++static int modisk_attach(struct scst_device *dev) ++{ ++ int res, rc; ++ uint8_t cmd[10]; ++ const int buffer_size = 512; ++ uint8_t *buffer = NULL; ++ int retries; ++ unsigned char sense_buffer[SCSI_SENSE_BUFFERSIZE]; ++ enum dma_data_direction data_dir; ++ struct modisk_params *params; ++ ++ TRACE_ENTRY(); ++ ++ if (dev->scsi_dev == NULL || ++ dev->scsi_dev->type != dev->type) { ++ PRINT_ERROR("%s", "SCSI device not define or illegal type"); ++ res = -ENODEV; ++ goto out; ++ } ++ ++ params = kzalloc(sizeof(*params), GFP_KERNEL); ++ if (params == NULL) { ++ PRINT_ERROR("Unable to allocate struct modisk_params (size %zd)", ++ sizeof(*params)); ++ res = -ENOMEM; ++ goto out; ++ } ++ params->block_shift = MODISK_DEF_BLOCK_SHIFT; ++ ++ /* ++ * If the device is offline, don't try to read capacity or any ++ * of the other stuff ++ */ ++ if (dev->scsi_dev->sdev_state == SDEV_OFFLINE) { ++ TRACE_DBG("%s", "Device is offline"); ++ res = -ENODEV; ++ goto out_free_params; ++ } ++ ++ buffer = kmalloc(buffer_size, GFP_KERNEL); ++ if (!buffer) { ++ PRINT_ERROR("Buffer memory allocation (size %d) failure", ++ buffer_size); ++ res = -ENOMEM; ++ goto out_free_params; ++ } ++ ++ /* ++ * Clear any existing UA's and get modisk capacity (modisk block ++ * size). ++ */ ++ memset(cmd, 0, sizeof(cmd)); ++ cmd[0] = READ_CAPACITY; ++ cmd[1] = (dev->scsi_dev->scsi_level <= SCSI_2) ? ++ ((dev->scsi_dev->lun << 5) & 0xe0) : 0; ++ retries = SCST_DEV_UA_RETRIES; ++ while (1) { ++ memset(buffer, 0, buffer_size); ++ memset(sense_buffer, 0, sizeof(sense_buffer)); ++ data_dir = SCST_DATA_READ; ++ ++ TRACE_DBG("%s", "Doing READ_CAPACITY"); ++ rc = scsi_execute(dev->scsi_dev, cmd, data_dir, buffer, ++ buffer_size, sense_buffer, ++ SCST_GENERIC_MODISK_REG_TIMEOUT, 3, 0 ++ , NULL ++ ); ++ ++ TRACE_DBG("READ_CAPACITY done: %x", rc); ++ ++ if (!rc || !scst_analyze_sense(sense_buffer, ++ sizeof(sense_buffer), SCST_SENSE_KEY_VALID, ++ UNIT_ATTENTION, 0, 0)) ++ break; ++ ++ if (!--retries) { ++ PRINT_ERROR("UA not cleared after %d retries", ++ SCST_DEV_UA_RETRIES); ++ res = -ENODEV; ++ goto out_free_buf; ++ } ++ } ++ ++ if (rc == 0) { ++ int sector_size = ((buffer[4] << 24) | (buffer[5] << 16) | ++ (buffer[6] << 8) | (buffer[7] << 0)); ++ if (sector_size == 0) ++ params->block_shift = MODISK_DEF_BLOCK_SHIFT; ++ else ++ params->block_shift = ++ scst_calc_block_shift(sector_size); ++ TRACE_DBG("Sector size is %i scsi_level %d(SCSI_2 %d)", ++ sector_size, dev->scsi_dev->scsi_level, SCSI_2); ++ } else { ++ params->block_shift = MODISK_DEF_BLOCK_SHIFT; ++ TRACE(TRACE_MINOR, "Read capacity failed: %x, using default " ++ "sector size %d", rc, params->block_shift); ++ PRINT_BUFF_FLAG(TRACE_MINOR, "Returned sense", sense_buffer, ++ sizeof(sense_buffer)); ++ } ++ ++ res = scst_obtain_device_parameters(dev); ++ if (res != 0) { ++ PRINT_ERROR("Failed to obtain control parameters for device " ++ "%s: %x", dev->virt_name, res); ++ goto out_free_buf; ++ } ++ ++out_free_buf: ++ kfree(buffer); ++ ++out_free_params: ++ if (res == 0) ++ dev->dh_priv = params; ++ else ++ kfree(params); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void modisk_detach(struct scst_device *dev) ++{ ++ struct modisk_params *params = ++ (struct modisk_params *)dev->dh_priv; ++ ++ TRACE_ENTRY(); ++ ++ kfree(params); ++ dev->dh_priv = NULL; ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int modisk_get_block_shift(struct scst_cmd *cmd) ++{ ++ struct modisk_params *params = ++ (struct modisk_params *)cmd->dev->dh_priv; ++ /* ++ * No need for locks here, since *_detach() can not be ++ * called, when there are existing commands. ++ */ ++ return params->block_shift; ++} ++ ++static int modisk_parse(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_DEFAULT; ++ ++ scst_modisk_generic_parse(cmd, modisk_get_block_shift); ++ ++ cmd->retries = SCST_PASSTHROUGH_RETRIES; ++ ++ return res; ++} ++ ++static void modisk_set_block_shift(struct scst_cmd *cmd, int block_shift) ++{ ++ struct modisk_params *params = ++ (struct modisk_params *)cmd->dev->dh_priv; ++ /* ++ * No need for locks here, since *_detach() can not be ++ * called, when there are existing commands. ++ */ ++ if (block_shift != 0) ++ params->block_shift = block_shift; ++ else ++ params->block_shift = MODISK_DEF_BLOCK_SHIFT; ++ return; ++} ++ ++static int modisk_done(struct scst_cmd *cmd) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ res = scst_block_generic_dev_done(cmd, modisk_set_block_shift); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int modisk_perf_exec(struct scst_cmd *cmd) ++{ ++ int res = SCST_EXEC_NOT_COMPLETED, rc; ++ int opcode = cmd->cdb[0]; ++ ++ TRACE_ENTRY(); ++ ++ rc = scst_check_local_events(cmd); ++ if (unlikely(rc != 0)) ++ goto out_done; ++ ++ cmd->status = 0; ++ cmd->msg_status = 0; ++ cmd->host_status = DID_OK; ++ cmd->driver_status = 0; ++ ++ switch (opcode) { ++ case WRITE_6: ++ case WRITE_10: ++ case WRITE_12: ++ case WRITE_16: ++ case READ_6: ++ case READ_10: ++ case READ_12: ++ case READ_16: ++ cmd->completed = 1; ++ goto out_done; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_done: ++ res = SCST_EXEC_COMPLETED; ++ cmd->scst_cmd_done(cmd, SCST_CMD_STATE_DEFAULT, SCST_CONTEXT_SAME); ++ goto out; ++} ++ ++MODULE_AUTHOR("Vladislav Bolkhovitin & Leonid Stoljar"); ++MODULE_LICENSE("GPL"); ++MODULE_DESCRIPTION("SCSI MO disk (type 7) dev handler for SCST"); ++MODULE_VERSION(SCST_VERSION_STRING); +diff -uprN orig/linux-3.2/drivers/scst/dev_handlers/scst_processor.c linux-3.2/drivers/scst/dev_handlers/scst_processor.c +--- orig/linux-3.2/drivers/scst/dev_handlers/scst_processor.c ++++ linux-3.2/drivers/scst/dev_handlers/scst_processor.c +@@ -0,0 +1,183 @@ ++/* ++ * scst_processor.c ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * SCSI medium processor (type 3) dev handler ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <scsi/scsi_host.h> ++#include <linux/slab.h> ++ ++#define LOG_PREFIX "dev_processor" ++ ++#include <scst/scst.h> ++#include "scst_dev_handler.h" ++ ++#define PROCESSOR_NAME "dev_processor" ++ ++#define PROCESSOR_RETRIES 2 ++ ++static int processor_attach(struct scst_device *); ++/*static void processor_detach(struct scst_device *);*/ ++static int processor_parse(struct scst_cmd *); ++/*static int processor_done(struct scst_cmd *);*/ ++ ++static struct scst_dev_type processor_devtype = { ++ .name = PROCESSOR_NAME, ++ .type = TYPE_PROCESSOR, ++ .threads_num = 1, ++ .parse_atomic = 1, ++/* .dev_done_atomic = 1,*/ ++ .attach = processor_attach, ++/* .detach = processor_detach,*/ ++ .parse = processor_parse, ++/* .dev_done = processor_done*/ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ .default_trace_flags = SCST_DEFAULT_DEV_LOG_FLAGS, ++ .trace_flags = &trace_flag, ++#endif ++}; ++ ++static int processor_attach(struct scst_device *dev) ++{ ++ int res, rc; ++ int retries; ++ ++ TRACE_ENTRY(); ++ ++ if (dev->scsi_dev == NULL || ++ dev->scsi_dev->type != dev->type) { ++ PRINT_ERROR("%s", "SCSI device not define or illegal type"); ++ res = -ENODEV; ++ goto out; ++ } ++ ++ /* ++ * If the device is offline, don't try to read capacity or any ++ * of the other stuff ++ */ ++ if (dev->scsi_dev->sdev_state == SDEV_OFFLINE) { ++ TRACE_DBG("%s", "Device is offline"); ++ res = -ENODEV; ++ goto out; ++ } ++ ++ retries = SCST_DEV_UA_RETRIES; ++ do { ++ TRACE_DBG("%s", "Doing TEST_UNIT_READY"); ++ rc = scsi_test_unit_ready(dev->scsi_dev, ++ SCST_GENERIC_PROCESSOR_TIMEOUT, PROCESSOR_RETRIES ++ , NULL); ++ TRACE_DBG("TEST_UNIT_READY done: %x", rc); ++ } while ((--retries > 0) && rc); ++ ++ if (rc) { ++ PRINT_WARNING("Unit not ready: %x", rc); ++ /* Let's try not to be too smart and continue processing */ ++ } ++ ++ res = scst_obtain_device_parameters(dev); ++ if (res != 0) { ++ PRINT_ERROR("Failed to obtain control parameters for device " ++ "%s", dev->virt_name); ++ goto out; ++ } ++ ++out: ++ TRACE_EXIT(); ++ return res; ++} ++ ++#if 0 ++void processor_detach(struct scst_device *dev) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_EXIT(); ++ return; ++} ++#endif ++ ++static int processor_parse(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_DEFAULT; ++ ++ scst_processor_generic_parse(cmd, NULL); ++ ++ cmd->retries = SCST_PASSTHROUGH_RETRIES; ++ ++ return res; ++} ++ ++#if 0 ++int processor_done(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_DEFAULT; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * SCST sets good defaults for cmd->is_send_status and ++ * cmd->resp_data_len based on cmd->status and cmd->data_direction, ++ * therefore change them only if necessary. ++ */ ++ ++#if 0 ++ switch (cmd->cdb[0]) { ++ default: ++ /* It's all good */ ++ break; ++ } ++#endif ++ ++ TRACE_EXIT(); ++ return res; ++} ++#endif ++ ++static int __init processor_init(void) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ processor_devtype.module = THIS_MODULE; ++ ++ res = scst_register_dev_driver(&processor_devtype); ++ if (res < 0) ++ goto out; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void __exit processor_exit(void) ++{ ++ TRACE_ENTRY(); ++ scst_unregister_dev_driver(&processor_devtype); ++ TRACE_EXIT(); ++ return; ++} ++ ++module_init(processor_init); ++module_exit(processor_exit); ++ ++MODULE_AUTHOR("Vladislav Bolkhovitin & Leonid Stoljar"); ++MODULE_LICENSE("GPL"); ++MODULE_DESCRIPTION("SCSI medium processor (type 3) dev handler for SCST"); ++MODULE_VERSION(SCST_VERSION_STRING); +diff -uprN orig/linux-3.2/drivers/scst/dev_handlers/scst_raid.c linux-3.2/drivers/scst/dev_handlers/scst_raid.c +--- orig/linux-3.2/drivers/scst/dev_handlers/scst_raid.c ++++ linux-3.2/drivers/scst/dev_handlers/scst_raid.c +@@ -0,0 +1,184 @@ ++/* ++ * scst_raid.c ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * SCSI raid(controller) (type 0xC) dev handler ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#define LOG_PREFIX "dev_raid" ++ ++#include <scsi/scsi_host.h> ++#include <linux/slab.h> ++ ++#include <scst/scst.h> ++#include "scst_dev_handler.h" ++ ++#define RAID_NAME "dev_raid" ++ ++#define RAID_RETRIES 2 ++ ++static int raid_attach(struct scst_device *); ++/* static void raid_detach(struct scst_device *); */ ++static int raid_parse(struct scst_cmd *); ++/* static int raid_done(struct scst_cmd *); */ ++ ++static struct scst_dev_type raid_devtype = { ++ .name = RAID_NAME, ++ .type = TYPE_RAID, ++ .threads_num = 1, ++ .parse_atomic = 1, ++/* .dev_done_atomic = 1,*/ ++ .attach = raid_attach, ++/* .detach = raid_detach,*/ ++ .parse = raid_parse, ++/* .dev_done = raid_done,*/ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ .default_trace_flags = SCST_DEFAULT_DEV_LOG_FLAGS, ++ .trace_flags = &trace_flag, ++#endif ++}; ++ ++static int raid_attach(struct scst_device *dev) ++{ ++ int res, rc; ++ int retries; ++ ++ TRACE_ENTRY(); ++ ++ if (dev->scsi_dev == NULL || ++ dev->scsi_dev->type != dev->type) { ++ PRINT_ERROR("%s", "SCSI device not define or illegal type"); ++ res = -ENODEV; ++ goto out; ++ } ++ ++ /* ++ * If the device is offline, don't try to read capacity or any ++ * of the other stuff ++ */ ++ if (dev->scsi_dev->sdev_state == SDEV_OFFLINE) { ++ TRACE_DBG("%s", "Device is offline"); ++ res = -ENODEV; ++ goto out; ++ } ++ ++ retries = SCST_DEV_UA_RETRIES; ++ do { ++ TRACE_DBG("%s", "Doing TEST_UNIT_READY"); ++ rc = scsi_test_unit_ready(dev->scsi_dev, ++ SCST_GENERIC_RAID_TIMEOUT, RAID_RETRIES ++ , NULL); ++ TRACE_DBG("TEST_UNIT_READY done: %x", rc); ++ } while ((--retries > 0) && rc); ++ ++ if (rc) { ++ PRINT_WARNING("Unit not ready: %x", rc); ++ /* Let's try not to be too smart and continue processing */ ++ } ++ ++ res = scst_obtain_device_parameters(dev); ++ if (res != 0) { ++ PRINT_ERROR("Failed to obtain control parameters for device " ++ "%s", dev->virt_name); ++ goto out; ++ } ++ ++out: ++ TRACE_EXIT(); ++ return res; ++} ++ ++#if 0 ++void raid_detach(struct scst_device *dev) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_EXIT(); ++ return; ++} ++#endif ++ ++static int raid_parse(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_DEFAULT; ++ ++ scst_raid_generic_parse(cmd, NULL); ++ ++ cmd->retries = SCST_PASSTHROUGH_RETRIES; ++ ++ return res; ++} ++ ++#if 0 ++int raid_done(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_DEFAULT; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * SCST sets good defaults for cmd->is_send_status and ++ * cmd->resp_data_len based on cmd->status and cmd->data_direction, ++ * therefore change them only if necessary. ++ */ ++ ++#if 0 ++ switch (cmd->cdb[0]) { ++ default: ++ /* It's all good */ ++ break; ++ } ++#endif ++ ++ TRACE_EXIT(); ++ return res; ++} ++#endif ++ ++static int __init raid_init(void) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ raid_devtype.module = THIS_MODULE; ++ ++ res = scst_register_dev_driver(&raid_devtype); ++ if (res < 0) ++ goto out; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++} ++ ++static void __exit raid_exit(void) ++{ ++ TRACE_ENTRY(); ++ scst_unregister_dev_driver(&raid_devtype); ++ TRACE_EXIT(); ++ return; ++} ++ ++module_init(raid_init); ++module_exit(raid_exit); ++ ++MODULE_AUTHOR("Vladislav Bolkhovitin & Leonid Stoljar"); ++MODULE_LICENSE("GPL"); ++MODULE_DESCRIPTION("SCSI raid(controller) (type 0xC) dev handler for SCST"); ++MODULE_VERSION(SCST_VERSION_STRING); +diff -uprN orig/linux-3.2/drivers/scst/dev_handlers/scst_tape.c linux-3.2/drivers/scst/dev_handlers/scst_tape.c +--- orig/linux-3.2/drivers/scst/dev_handlers/scst_tape.c ++++ linux-3.2/drivers/scst/dev_handlers/scst_tape.c +@@ -0,0 +1,383 @@ ++/* ++ * scst_tape.c ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * SCSI tape (type 1) dev handler ++ * & ++ * SCSI tape (type 1) "performance" device handler (skip all READ and WRITE ++ * operations). ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/module.h> ++#include <linux/init.h> ++#include <scsi/scsi_host.h> ++#include <linux/slab.h> ++ ++#define LOG_PREFIX "dev_tape" ++ ++#include <scst/scst.h> ++#include "scst_dev_handler.h" ++ ++# define TAPE_NAME "dev_tape" ++# define TAPE_PERF_NAME "dev_tape_perf" ++ ++#define TAPE_RETRIES 2 ++ ++#define TAPE_DEF_BLOCK_SIZE 512 ++ ++/* The fixed bit in READ/WRITE/VERIFY */ ++#define SILI_BIT 2 ++ ++struct tape_params { ++ int block_size; ++}; ++ ++static int tape_attach(struct scst_device *); ++static void tape_detach(struct scst_device *); ++static int tape_parse(struct scst_cmd *); ++static int tape_done(struct scst_cmd *); ++static int tape_perf_exec(struct scst_cmd *); ++ ++static struct scst_dev_type tape_devtype = { ++ .name = TAPE_NAME, ++ .type = TYPE_TAPE, ++ .threads_num = 1, ++ .parse_atomic = 1, ++ .dev_done_atomic = 1, ++ .attach = tape_attach, ++ .detach = tape_detach, ++ .parse = tape_parse, ++ .dev_done = tape_done, ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ .default_trace_flags = SCST_DEFAULT_DEV_LOG_FLAGS, ++ .trace_flags = &trace_flag, ++#endif ++}; ++ ++static struct scst_dev_type tape_devtype_perf = { ++ .name = TAPE_PERF_NAME, ++ .type = TYPE_TAPE, ++ .parse_atomic = 1, ++ .dev_done_atomic = 1, ++ .attach = tape_attach, ++ .detach = tape_detach, ++ .parse = tape_parse, ++ .dev_done = tape_done, ++ .exec = tape_perf_exec, ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ .default_trace_flags = SCST_DEFAULT_DEV_LOG_FLAGS, ++ .trace_flags = &trace_flag, ++#endif ++}; ++ ++static int __init init_scst_tape_driver(void) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ tape_devtype.module = THIS_MODULE; ++ ++ res = scst_register_dev_driver(&tape_devtype); ++ if (res < 0) ++ goto out; ++ ++ tape_devtype_perf.module = THIS_MODULE; ++ ++ res = scst_register_dev_driver(&tape_devtype_perf); ++ if (res < 0) ++ goto out_unreg; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_unreg: ++ scst_unregister_dev_driver(&tape_devtype); ++ goto out; ++} ++ ++static void __exit exit_scst_tape_driver(void) ++{ ++ TRACE_ENTRY(); ++ ++ scst_unregister_dev_driver(&tape_devtype_perf); ++ scst_unregister_dev_driver(&tape_devtype); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++module_init(init_scst_tape_driver); ++module_exit(exit_scst_tape_driver); ++ ++static int tape_attach(struct scst_device *dev) ++{ ++ int res, rc; ++ int retries; ++ struct scsi_mode_data data; ++ const int buffer_size = 512; ++ uint8_t *buffer = NULL; ++ struct tape_params *params; ++ ++ TRACE_ENTRY(); ++ ++ if (dev->scsi_dev == NULL || ++ dev->scsi_dev->type != dev->type) { ++ PRINT_ERROR("%s", "SCSI device not define or illegal type"); ++ res = -ENODEV; ++ goto out; ++ } ++ ++ params = kzalloc(sizeof(*params), GFP_KERNEL); ++ if (params == NULL) { ++ PRINT_ERROR("Unable to allocate struct tape_params (size %zd)", ++ sizeof(*params)); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ params->block_size = TAPE_DEF_BLOCK_SIZE; ++ ++ buffer = kmalloc(buffer_size, GFP_KERNEL); ++ if (!buffer) { ++ PRINT_ERROR("Buffer memory allocation (size %d) failure", ++ buffer_size); ++ res = -ENOMEM; ++ goto out_free_req; ++ } ++ ++ retries = SCST_DEV_UA_RETRIES; ++ do { ++ TRACE_DBG("%s", "Doing TEST_UNIT_READY"); ++ rc = scsi_test_unit_ready(dev->scsi_dev, ++ SCST_GENERIC_TAPE_SMALL_TIMEOUT, TAPE_RETRIES ++ , NULL); ++ TRACE_DBG("TEST_UNIT_READY done: %x", rc); ++ } while ((--retries > 0) && rc); ++ ++ if (rc) { ++ PRINT_WARNING("Unit not ready: %x", rc); ++ /* Let's try not to be too smart and continue processing */ ++ goto obtain; ++ } ++ ++ TRACE_DBG("%s", "Doing MODE_SENSE"); ++ rc = scsi_mode_sense(dev->scsi_dev, ++ ((dev->scsi_dev->scsi_level <= SCSI_2) ? ++ ((dev->scsi_dev->lun << 5) & 0xe0) : 0), ++ 0 /* Mode Page 0 */, ++ buffer, buffer_size, ++ SCST_GENERIC_TAPE_SMALL_TIMEOUT, TAPE_RETRIES, ++ &data, NULL); ++ TRACE_DBG("MODE_SENSE done: %x", rc); ++ ++ if (rc == 0) { ++ int medium_type, mode, speed, density; ++ if (buffer[3] == 8) { ++ params->block_size = ((buffer[9] << 16) | ++ (buffer[10] << 8) | ++ (buffer[11] << 0)); ++ } else ++ params->block_size = TAPE_DEF_BLOCK_SIZE; ++ medium_type = buffer[1]; ++ mode = (buffer[2] & 0x70) >> 4; ++ speed = buffer[2] & 0x0f; ++ density = buffer[4]; ++ TRACE_DBG("Tape: lun %d. bs %d. type 0x%02x mode 0x%02x " ++ "speed 0x%02x dens 0x%02x", dev->scsi_dev->lun, ++ params->block_size, medium_type, mode, speed, density); ++ } else { ++ PRINT_ERROR("MODE_SENSE failed: %x", rc); ++ res = -ENODEV; ++ goto out_free_buf; ++ } ++ ++obtain: ++ res = scst_obtain_device_parameters(dev); ++ if (res != 0) { ++ PRINT_ERROR("Failed to obtain control parameters for device " ++ "%s", dev->virt_name); ++ goto out_free_buf; ++ } ++ ++out_free_buf: ++ kfree(buffer); ++ ++out_free_req: ++ if (res == 0) ++ dev->dh_priv = params; ++ else ++ kfree(params); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void tape_detach(struct scst_device *dev) ++{ ++ struct tape_params *params = ++ (struct tape_params *)dev->dh_priv; ++ ++ TRACE_ENTRY(); ++ ++ kfree(params); ++ dev->dh_priv = NULL; ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int tape_get_block_size(struct scst_cmd *cmd) ++{ ++ struct tape_params *params = (struct tape_params *)cmd->dev->dh_priv; ++ /* ++ * No need for locks here, since *_detach() can not be called, ++ * when there are existing commands. ++ */ ++ return params->block_size; ++} ++ ++static int tape_parse(struct scst_cmd *cmd) ++{ ++ int res = SCST_CMD_STATE_DEFAULT; ++ ++ scst_tape_generic_parse(cmd, tape_get_block_size); ++ ++ cmd->retries = SCST_PASSTHROUGH_RETRIES; ++ ++ return res; ++} ++ ++static void tape_set_block_size(struct scst_cmd *cmd, int block_size) ++{ ++ struct tape_params *params = (struct tape_params *)cmd->dev->dh_priv; ++ /* ++ * No need for locks here, since *_detach() can not be called, when ++ * there are existing commands. ++ */ ++ params->block_size = block_size; ++ return; ++} ++ ++static int tape_done(struct scst_cmd *cmd) ++{ ++ int opcode = cmd->cdb[0]; ++ int status = cmd->status; ++ int res = SCST_CMD_STATE_DEFAULT; ++ ++ TRACE_ENTRY(); ++ ++ if ((status == SAM_STAT_GOOD) || (status == SAM_STAT_CONDITION_MET)) ++ res = scst_tape_generic_dev_done(cmd, tape_set_block_size); ++ else if ((status == SAM_STAT_CHECK_CONDITION) && ++ SCST_SENSE_VALID(cmd->sense)) { ++ struct tape_params *params; ++ ++ TRACE_DBG("Extended sense %x", cmd->sense[0] & 0x7F); ++ ++ if ((cmd->sense[0] & 0x7F) != 0x70) { ++ PRINT_ERROR("Sense format 0x%x is not supported", ++ cmd->sense[0] & 0x7F); ++ scst_set_cmd_error(cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ goto out; ++ } ++ ++ if (opcode == READ_6 && !(cmd->cdb[1] & SILI_BIT) && ++ (cmd->sense[2] & 0xe0)) { ++ /* EOF, EOM, or ILI */ ++ int TransferLength, Residue = 0; ++ if ((cmd->sense[2] & 0x0f) == BLANK_CHECK) ++ /* No need for EOM in this case */ ++ cmd->sense[2] &= 0xcf; ++ TransferLength = ((cmd->cdb[2] << 16) | ++ (cmd->cdb[3] << 8) | cmd->cdb[4]); ++ /* Compute the residual count */ ++ if ((cmd->sense[0] & 0x80) != 0) { ++ Residue = ((cmd->sense[3] << 24) | ++ (cmd->sense[4] << 16) | ++ (cmd->sense[5] << 8) | ++ cmd->sense[6]); ++ } ++ TRACE_DBG("Checking the sense key " ++ "sn[2]=%x cmd->cdb[0,1]=%x,%x TransLen/Resid" ++ " %d/%d", (int)cmd->sense[2], cmd->cdb[0], ++ cmd->cdb[1], TransferLength, Residue); ++ if (TransferLength > Residue) { ++ int resp_data_len = TransferLength - Residue; ++ if (cmd->cdb[1] & SCST_TRANSFER_LEN_TYPE_FIXED) { ++ /* ++ * No need for locks here, since ++ * *_detach() can not be called, when ++ * there are existing commands. ++ */ ++ params = (struct tape_params *) ++ cmd->dev->dh_priv; ++ resp_data_len *= params->block_size; ++ } ++ scst_set_resp_data_len(cmd, resp_data_len); ++ } ++ } ++ } ++ ++out: ++ TRACE_DBG("cmd->is_send_status=%x, cmd->resp_data_len=%d, " ++ "res=%d", cmd->is_send_status, cmd->resp_data_len, res); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int tape_perf_exec(struct scst_cmd *cmd) ++{ ++ int res = SCST_EXEC_NOT_COMPLETED, rc; ++ int opcode = cmd->cdb[0]; ++ ++ TRACE_ENTRY(); ++ ++ rc = scst_check_local_events(cmd); ++ if (unlikely(rc != 0)) ++ goto out_done; ++ ++ cmd->status = 0; ++ cmd->msg_status = 0; ++ cmd->host_status = DID_OK; ++ cmd->driver_status = 0; ++ ++ switch (opcode) { ++ case WRITE_6: ++ case READ_6: ++ cmd->completed = 1; ++ goto out_done; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_done: ++ res = SCST_EXEC_COMPLETED; ++ cmd->scst_cmd_done(cmd, SCST_CMD_STATE_DEFAULT, SCST_CONTEXT_SAME); ++ goto out; ++} ++ ++MODULE_AUTHOR("Vladislav Bolkhovitin & Leonid Stoljar"); ++MODULE_LICENSE("GPL"); ++MODULE_DESCRIPTION("SCSI tape (type 1) dev handler for SCST"); ++MODULE_VERSION(SCST_VERSION_STRING); +diff -uprN orig/linux-3.2/drivers/scst/fcst/Makefile linux-3.2/drivers/scst/fcst/Makefile +--- orig/linux-3.2/drivers/scst/fcst/Makefile ++++ linux-3.2/drivers/scst/fcst/Makefile +@@ -0,0 +1,7 @@ ++obj-$(CONFIG_FCST) += fcst.o ++ ++fcst-objs := \ ++ ft_cmd.o \ ++ ft_io.o \ ++ ft_scst.o \ ++ ft_sess.o +diff -uprN orig/linux-3.2/drivers/scst/fcst/Kconfig linux-3.2/drivers/scst/fcst/Kconfig +--- orig/linux-3.2/drivers/scst/fcst/Kconfig ++++ linux-3.2/drivers/scst/fcst/Kconfig +@@ -0,0 +1,5 @@ ++config FCST ++ tristate "SCST target module for Fibre Channel using libfc" ++ depends on LIBFC && SCST ++ ---help--- ++ Supports using libfc HBAs as target adapters with SCST +diff -uprN orig/linux-3.2/drivers/scst/fcst/fcst.h linux-3.2/drivers/scst/fcst/fcst.h +--- orig/linux-3.2/drivers/scst/fcst/fcst.h ++++ linux-3.2/drivers/scst/fcst/fcst.h +@@ -0,0 +1,151 @@ ++/* ++ * Copyright (c) 2010 Cisco Systems, Inc. ++ * ++ * This program is free software; you may redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; version 2 of the License. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ++ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ++ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS ++ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ++ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE ++ * SOFTWARE. ++ * ++ * $Id$ ++ */ ++#ifndef __SCSI_FCST_H__ ++#define __SCSI_FCST_H__ ++ ++#include <scst/scst.h> ++ ++#define FT_VERSION "0.3" ++#define FT_MODULE "fcst" ++ ++#define FT_MAX_HW_PENDING_TIME 20 /* max I/O time in seconds */ ++ ++/* ++ * Debug options. ++ */ ++#define FT_DEBUG_CONF 0x01 /* configuration messages */ ++#define FT_DEBUG_SESS 0x02 /* session messages */ ++#define FT_DEBUG_IO 0x04 /* I/O operations */ ++ ++extern unsigned int ft_debug_logging; /* debug options */ ++ ++#define FT_ERR(fmt, args...) \ ++ printk(KERN_ERR FT_MODULE ": %s: " fmt, __func__, ##args) ++ ++#define FT_DEBUG(mask, fmt, args...) \ ++ do { \ ++ if (ft_debug_logging & (mask)) \ ++ printk(KERN_INFO FT_MODULE ": %s: " fmt, \ ++ __func__, ##args); \ ++ } while (0) ++ ++#define FT_CONF_DBG(fmt, args...) FT_DEBUG(FT_DEBUG_CONF, fmt, ##args) ++#define FT_SESS_DBG(fmt, args...) FT_DEBUG(FT_DEBUG_SESS, fmt, ##args) ++#define FT_IO_DBG(fmt, args...) FT_DEBUG(FT_DEBUG_IO, fmt, ##args) ++ ++#define FT_NAMELEN 32 /* length of ASCI WWPNs including pad */ ++ ++/* ++ * Session (remote port). ++ */ ++struct ft_sess { ++ u32 port_id; /* for hash lookup use only */ ++ u32 params; ++ u16 max_payload; /* max transmitted payload size */ ++ u32 max_lso_payload; /* max offloaded payload size */ ++ u64 port_name; /* port name for transport ID */ ++ struct ft_tport *tport; ++ struct hlist_node hash; /* linkage in ft_sess_hash table */ ++ struct rcu_head rcu; ++ struct kref kref; /* ref for hash and outstanding I/Os */ ++ struct scst_session *scst_sess; ++}; ++ ++/* ++ * Hash table of sessions per local port. ++ * Hash lookup by remote port FC_ID. ++ */ ++#define FT_SESS_HASH_BITS 6 ++#define FT_SESS_HASH_SIZE (1 << FT_SESS_HASH_BITS) ++ ++/* ++ * Per local port data. ++ * This is created when the first session logs into the local port. ++ * Deleted when tpg is deleted or last session is logged off. ++ */ ++struct ft_tport { ++ u32 sess_count; /* number of sessions in hash */ ++ u8 enabled:1; ++ struct rcu_head rcu; ++ struct hlist_head hash[FT_SESS_HASH_SIZE]; /* list of sessions */ ++ struct fc_lport *lport; ++ struct scst_tgt *tgt; ++}; ++ ++/* ++ * Commands ++ */ ++struct ft_cmd { ++ int serial; /* order received, for debugging */ ++ struct fc_seq *seq; /* sequence in exchange mgr */ ++ struct fc_frame *req_frame; /* original request frame */ ++ u32 write_data_len; /* data received from initiator */ ++ u32 read_data_len; /* data sent to initiator */ ++ u32 xfer_rdy_len; /* max xfer ready offset */ ++ u32 max_lso_payload; /* max offloaded (LSO) data payload */ ++ u16 max_payload; /* max transmitted data payload */ ++ struct scst_cmd *scst_cmd; ++}; ++ ++extern struct list_head ft_lport_list; ++extern struct mutex ft_lport_lock; ++extern struct scst_tgt_template ft_scst_template; ++ ++/* ++ * libfc interface. ++ */ ++int ft_prli(struct fc_rport_priv *, u32 spp_len, ++ const struct fc_els_spp *, struct fc_els_spp *); ++void ft_prlo(struct fc_rport_priv *); ++void ft_recv(struct fc_lport *, struct fc_frame *); ++ ++/* ++ * SCST interface. ++ */ ++int ft_send_response(struct scst_cmd *); ++int ft_send_xfer_rdy(struct scst_cmd *); ++void ft_cmd_timeout(struct scst_cmd *); ++void ft_cmd_free(struct scst_cmd *); ++void ft_cmd_tm_done(struct scst_mgmt_cmd *); ++int ft_tgt_detect(struct scst_tgt_template *); ++int ft_tgt_release(struct scst_tgt *); ++int ft_tgt_enable(struct scst_tgt *, bool); ++bool ft_tgt_enabled(struct scst_tgt *); ++int ft_report_aen(struct scst_aen *); ++int ft_get_transport_id(struct scst_tgt *, struct scst_session *, uint8_t **); ++ ++/* ++ * Session interface. ++ */ ++int ft_lport_notify(struct notifier_block *, unsigned long, void *); ++void ft_lport_add(struct fc_lport *, void *); ++void ft_lport_del(struct fc_lport *, void *); ++ ++/* ++ * other internal functions. ++ */ ++int ft_thread(void *); ++void ft_recv_req(struct ft_sess *, struct fc_frame *); ++void ft_recv_write_data(struct scst_cmd *, struct fc_frame *); ++int ft_send_read_data(struct scst_cmd *); ++struct ft_tpg *ft_lport_find_tpg(struct fc_lport *); ++struct ft_node_acl *ft_acl_get(struct ft_tpg *, struct fc_rport_priv *); ++void ft_cmd_dump(struct scst_cmd *, const char *); ++ ++#endif /* __SCSI_FCST_H__ */ +diff -uprN orig/linux-3.2/drivers/scst/fcst/ft_cmd.c linux-3.2/drivers/scst/fcst/ft_cmd.c +--- orig/linux-3.2/drivers/scst/fcst/ft_cmd.c ++++ linux-3.2/drivers/scst/fcst/ft_cmd.c +@@ -0,0 +1,685 @@ ++/* ++ * Copyright (c) 2010 Cisco Systems, Inc. ++ * ++ * This program is free software; you may redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; version 2 of the License. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ++ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ++ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS ++ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ++ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE ++ * SOFTWARE. ++ */ ++#include <linux/kernel.h> ++#include <linux/types.h> ++#include <scsi/libfc.h> ++#include <scsi/fc_encode.h> ++#include "fcst.h" ++ ++/* ++ * Append string to buffer safely. ++ * Also prepends a space if there's already something the buf. ++ */ ++static void ft_cmd_flag(char *buf, size_t len, const char *desc) ++{ ++ if (buf[0]) ++ strlcat(buf, " ", len); ++ strlcat(buf, desc, len); ++} ++ ++/* ++ * Debug: dump command. ++ */ ++void ft_cmd_dump(struct scst_cmd *cmd, const char *caller) ++{ ++ static atomic_t serial; ++ struct ft_cmd *fcmd; ++ struct fc_frame_header *fh; ++ char prefix[30]; ++ char buf[150]; ++ ++ if (!(ft_debug_logging & FT_DEBUG_IO)) ++ return; ++ ++ fcmd = scst_cmd_get_tgt_priv(cmd); ++ fh = fc_frame_header_get(fcmd->req_frame); ++ snprintf(prefix, sizeof(prefix), FT_MODULE ": cmd %2x", ++ atomic_inc_return(&serial) & 0xff); ++ ++ printk(KERN_INFO "%s %s oid %x oxid %x resp_len %u\n", ++ prefix, caller, ntoh24(fh->fh_s_id), ntohs(fh->fh_ox_id), ++ scst_cmd_get_resp_data_len(cmd)); ++ printk(KERN_INFO "%s scst_cmd %p wlen %u rlen %u\n", ++ prefix, cmd, fcmd->write_data_len, fcmd->read_data_len); ++ printk(KERN_INFO "%s exp_dir %x exp_xfer_len %d exp_in_len %d\n", ++ prefix, cmd->expected_data_direction, ++ cmd->expected_transfer_len, cmd->expected_out_transfer_len); ++ printk(KERN_INFO "%s dir %x data_len %d bufflen %d out_bufflen %d\n", ++ prefix, cmd->data_direction, cmd->data_len, ++ cmd->bufflen, cmd->out_bufflen); ++ printk(KERN_INFO "%s sg_cnt reg %d in %d tgt %d tgt_in %d\n", ++ prefix, cmd->sg_cnt, cmd->out_sg_cnt, ++ cmd->tgt_sg_cnt, cmd->tgt_out_sg_cnt); ++ ++ buf[0] = '\0'; ++ if (cmd->sent_for_exec) ++ ft_cmd_flag(buf, sizeof(buf), "sent"); ++ if (cmd->completed) ++ ft_cmd_flag(buf, sizeof(buf), "comp"); ++ if (cmd->ua_ignore) ++ ft_cmd_flag(buf, sizeof(buf), "ua_ign"); ++ if (cmd->atomic) ++ ft_cmd_flag(buf, sizeof(buf), "atom"); ++ if (cmd->double_ua_possible) ++ ft_cmd_flag(buf, sizeof(buf), "dbl_ua_poss"); ++ if (cmd->is_send_status) ++ ft_cmd_flag(buf, sizeof(buf), "send_stat"); ++ if (cmd->retry) ++ ft_cmd_flag(buf, sizeof(buf), "retry"); ++ if (cmd->internal) ++ ft_cmd_flag(buf, sizeof(buf), "internal"); ++ if (cmd->unblock_dev) ++ ft_cmd_flag(buf, sizeof(buf), "unblock_dev"); ++ if (cmd->cmd_hw_pending) ++ ft_cmd_flag(buf, sizeof(buf), "hw_pend"); ++ if (cmd->tgt_need_alloc_data_buf) ++ ft_cmd_flag(buf, sizeof(buf), "tgt_need_alloc"); ++ if (cmd->tgt_data_buf_alloced) ++ ft_cmd_flag(buf, sizeof(buf), "tgt_alloced"); ++ if (cmd->dh_data_buf_alloced) ++ ft_cmd_flag(buf, sizeof(buf), "dh_alloced"); ++ if (cmd->expected_values_set) ++ ft_cmd_flag(buf, sizeof(buf), "exp_val"); ++ if (cmd->sg_buff_modified) ++ ft_cmd_flag(buf, sizeof(buf), "sg_buf_mod"); ++ if (cmd->preprocessing_only) ++ ft_cmd_flag(buf, sizeof(buf), "pre_only"); ++ if (cmd->sn_set) ++ ft_cmd_flag(buf, sizeof(buf), "sn_set"); ++ if (cmd->hq_cmd_inced) ++ ft_cmd_flag(buf, sizeof(buf), "hq_cmd_inc"); ++ if (cmd->set_sn_on_restart_cmd) ++ ft_cmd_flag(buf, sizeof(buf), "set_sn_on_restart"); ++ if (cmd->no_sgv) ++ ft_cmd_flag(buf, sizeof(buf), "no_sgv"); ++ if (cmd->may_need_dma_sync) ++ ft_cmd_flag(buf, sizeof(buf), "dma_sync"); ++ if (cmd->out_of_sn) ++ ft_cmd_flag(buf, sizeof(buf), "oo_sn"); ++ if (cmd->inc_expected_sn_on_done) ++ ft_cmd_flag(buf, sizeof(buf), "inc_sn_exp"); ++ if (cmd->done) ++ ft_cmd_flag(buf, sizeof(buf), "done"); ++ if (cmd->finished) ++ ft_cmd_flag(buf, sizeof(buf), "fin"); ++ ++ printk(KERN_INFO "%s flags %s\n", prefix, buf); ++ printk(KERN_INFO "%s lun %lld sn %d tag %lld cmd_flags %lx\n", ++ prefix, cmd->lun, cmd->sn, cmd->tag, cmd->cmd_flags); ++ printk(KERN_INFO "%s tgt_sn %d op_flags %x op %s\n", ++ prefix, cmd->tgt_sn, cmd->op_flags, cmd->op_name); ++ printk(KERN_INFO "%s status %x msg_status %x " ++ "host_status %x driver_status %x\n", ++ prefix, cmd->status, cmd->msg_status, ++ cmd->host_status, cmd->driver_status); ++ printk(KERN_INFO "%s cdb_len %d\n", prefix, cmd->cdb_len); ++ snprintf(buf, sizeof(buf), "%s cdb ", prefix); ++ print_hex_dump(KERN_INFO, buf, DUMP_PREFIX_NONE, ++ 16, 4, cmd->cdb, SCST_MAX_CDB_SIZE, 0); ++} ++ ++/* ++ * Debug: dump mgmt command. ++ */ ++static void ft_cmd_tm_dump(struct scst_mgmt_cmd *mcmd, const char *caller) ++{ ++ struct ft_cmd *fcmd; ++ struct fc_frame_header *fh; ++ char prefix[30]; ++ char buf[150]; ++ ++ if (!(ft_debug_logging & FT_DEBUG_IO)) ++ return; ++ fcmd = scst_mgmt_cmd_get_tgt_priv(mcmd); ++ fh = fc_frame_header_get(fcmd->req_frame); ++ ++ snprintf(prefix, sizeof(prefix), FT_MODULE ": mcmd"); ++ ++ printk(KERN_INFO "%s %s oid %x oxid %x lun %lld\n", ++ prefix, caller, ntoh24(fh->fh_s_id), ntohs(fh->fh_ox_id), ++ (unsigned long long)mcmd->lun); ++ printk(KERN_INFO "%s state %d fn %d fin_wait %d done_wait %d comp %d\n", ++ prefix, mcmd->state, mcmd->fn, ++ mcmd->cmd_finish_wait_count, mcmd->cmd_done_wait_count, ++ mcmd->completed_cmd_count); ++ buf[0] = '\0'; ++ if (mcmd->needs_unblocking) ++ ft_cmd_flag(buf, sizeof(buf), "needs_unblock"); ++ if (mcmd->lun_set) ++ ft_cmd_flag(buf, sizeof(buf), "lun_set"); ++ if (mcmd->cmd_sn_set) ++ ft_cmd_flag(buf, sizeof(buf), "cmd_sn_set"); ++ printk(KERN_INFO "%s flags %s\n", prefix, buf); ++ if (mcmd->cmd_to_abort) ++ ft_cmd_dump(mcmd->cmd_to_abort, caller); ++} ++ ++/* ++ * Free command and associated frame. ++ */ ++static void ft_cmd_done(struct ft_cmd *fcmd) ++{ ++ struct fc_frame *fp = fcmd->req_frame; ++ struct fc_lport *lport; ++ ++ lport = fr_dev(fp); ++ if (fr_seq(fp)) ++ lport->tt.seq_release(fr_seq(fp)); ++ ++ fc_frame_free(fp); ++ kfree(fcmd); ++} ++ ++/* ++ * Free command - callback from SCST. ++ */ ++void ft_cmd_free(struct scst_cmd *cmd) ++{ ++ struct ft_cmd *fcmd; ++ ++ fcmd = scst_cmd_get_tgt_priv(cmd); ++ if (fcmd) { ++ scst_cmd_set_tgt_priv(cmd, NULL); ++ ft_cmd_done(fcmd); ++ } ++} ++ ++/* ++ * Send response, after data if applicable. ++ */ ++int ft_send_response(struct scst_cmd *cmd) ++{ ++ struct ft_cmd *fcmd; ++ struct fc_frame *fp; ++ struct fcp_resp_with_ext *fcp; ++ struct fc_lport *lport; ++ struct fc_exch *ep; ++ unsigned int slen; ++ size_t len; ++ int resid = 0; ++ int bi_resid = 0; ++ int error; ++ int dir; ++ u32 status; ++ ++ ft_cmd_dump(cmd, __func__); ++ fcmd = scst_cmd_get_tgt_priv(cmd); ++ ep = fc_seq_exch(fcmd->seq); ++ lport = ep->lp; ++ ++ if (scst_cmd_aborted(cmd)) { ++ FT_IO_DBG("cmd aborted did %x oxid %x\n", ep->did, ep->oxid); ++ scst_set_delivery_status(cmd, SCST_CMD_DELIVERY_ABORTED); ++ goto done; ++ } ++ ++ if (!scst_cmd_get_is_send_status(cmd)) { ++ FT_IO_DBG("send status not set. feature not implemented\n"); ++ return SCST_TGT_RES_FATAL_ERROR; ++ } ++ ++ status = scst_cmd_get_status(cmd); ++ dir = scst_cmd_get_data_direction(cmd); ++ ++ slen = scst_cmd_get_sense_buffer_len(cmd); ++ len = sizeof(*fcp) + slen; ++ ++ /* ++ * Send read data and set underflow/overflow residual count. ++ * For bi-directional comands, the bi_resid is for the read direction. ++ */ ++ if (dir & SCST_DATA_WRITE) ++ resid = (signed)scst_cmd_get_bufflen(cmd) - ++ fcmd->write_data_len; ++ if (dir & SCST_DATA_READ) { ++ error = ft_send_read_data(cmd); ++ if (error) { ++ FT_ERR("ft_send_read_data returned %d\n", error); ++ return error; ++ } ++ ++ if (dir == SCST_DATA_BIDI) { ++ bi_resid = (signed)scst_cmd_get_out_bufflen(cmd) - ++ scst_cmd_get_resp_data_len(cmd); ++ if (bi_resid) ++ len += sizeof(__be32); ++ } else ++ resid = (signed)scst_cmd_get_bufflen(cmd) - ++ scst_cmd_get_resp_data_len(cmd); ++ } ++ ++ fp = fc_frame_alloc(lport, len); ++ if (!fp) ++ return SCST_TGT_RES_QUEUE_FULL; ++ ++ fcp = fc_frame_payload_get(fp, len); ++ memset(fcp, 0, sizeof(*fcp)); ++ fcp->resp.fr_status = status; ++ ++ if (slen) { ++ fcp->resp.fr_flags |= FCP_SNS_LEN_VAL; ++ fcp->ext.fr_sns_len = htonl(slen); ++ memcpy(fcp + 1, scst_cmd_get_sense_buffer(cmd), slen); ++ } ++ if (bi_resid) { ++ if (bi_resid < 0) { ++ fcp->resp.fr_flags |= FCP_BIDI_READ_OVER; ++ bi_resid = -bi_resid; ++ } else ++ fcp->resp.fr_flags |= FCP_BIDI_READ_UNDER; ++ *(__be32 *)((u8 *)(fcp + 1) + slen) = htonl(bi_resid); ++ } ++ if (resid) { ++ if (resid < 0) { ++ resid = -resid; ++ fcp->resp.fr_flags |= FCP_RESID_OVER; ++ } else ++ fcp->resp.fr_flags |= FCP_RESID_UNDER; ++ fcp->ext.fr_resid = htonl(resid); ++ } ++ FT_IO_DBG("response did %x oxid %x\n", ep->did, ep->oxid); ++ ++ /* ++ * Send response. ++ */ ++ fcmd->seq = lport->tt.seq_start_next(fcmd->seq); ++ fc_fill_fc_hdr(fp, FC_RCTL_DD_CMD_STATUS, ep->did, ep->sid, FC_TYPE_FCP, ++ FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ, 0); ++ ++ lport->tt.seq_send(lport, fcmd->seq, fp); ++done: ++ lport->tt.exch_done(fcmd->seq); ++ scst_tgt_cmd_done(cmd, SCST_CONTEXT_SAME); ++ return SCST_TGT_RES_SUCCESS; ++} ++ ++/* ++ * FC sequence response handler for follow-on sequences (data) and aborts. ++ */ ++static void ft_recv_seq(struct fc_seq *sp, struct fc_frame *fp, void *arg) ++{ ++ struct scst_cmd *cmd = arg; ++ struct fc_frame_header *fh; ++ ++ /* ++ * If an error is being reported, it must be FC_EX_CLOSED. ++ * Timeouts don't occur on incoming requests, and there are ++ * currently no other errors. ++ * The PRLO handler will be also called by libfc to delete ++ * the session and all pending commands, so we ignore this response. ++ */ ++ if (IS_ERR(fp)) { ++ FT_IO_DBG("exchange error %ld - not handled\n", -PTR_ERR(fp)); ++ return; ++ } ++ ++ fh = fc_frame_header_get(fp); ++ switch (fh->fh_r_ctl) { ++ case FC_RCTL_DD_SOL_DATA: /* write data */ ++ ft_recv_write_data(cmd, fp); ++ break; ++ case FC_RCTL_DD_UNSOL_CTL: /* command */ ++ case FC_RCTL_DD_SOL_CTL: /* transfer ready */ ++ case FC_RCTL_DD_DATA_DESC: /* transfer ready */ ++ default: ++ printk(KERN_INFO "%s: unhandled frame r_ctl %x\n", ++ __func__, fh->fh_r_ctl); ++ fc_frame_free(fp); ++ break; ++ } ++} ++ ++/* ++ * Command timeout. ++ * SCST calls this when the command has taken too long in the device handler. ++ */ ++void ft_cmd_timeout(struct scst_cmd *cmd) ++{ ++ FT_IO_DBG("timeout not implemented\n"); /* XXX TBD */ ++} ++ ++/* ++ * Send TX_RDY (transfer ready). ++ */ ++static int ft_send_xfer_rdy_off(struct scst_cmd *cmd, u32 offset, u32 len) ++{ ++ struct ft_cmd *fcmd; ++ struct fc_frame *fp; ++ struct fcp_txrdy *txrdy; ++ struct fc_lport *lport; ++ struct fc_exch *ep; ++ ++ fcmd = scst_cmd_get_tgt_priv(cmd); ++ if (fcmd->xfer_rdy_len < len + offset) ++ fcmd->xfer_rdy_len = len + offset; ++ ++ ep = fc_seq_exch(fcmd->seq); ++ lport = ep->lp; ++ fp = fc_frame_alloc(lport, sizeof(*txrdy)); ++ if (!fp) ++ return SCST_TGT_RES_QUEUE_FULL; ++ ++ txrdy = fc_frame_payload_get(fp, sizeof(*txrdy)); ++ memset(txrdy, 0, sizeof(*txrdy)); ++ txrdy->ft_data_ro = htonl(offset); ++ txrdy->ft_burst_len = htonl(len); ++ ++ fcmd->seq = lport->tt.seq_start_next(fcmd->seq); ++ fc_fill_fc_hdr(fp, FC_RCTL_DD_DATA_DESC, ep->did, ep->sid, FC_TYPE_FCP, ++ FC_FC_EX_CTX | FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0); ++ lport->tt.seq_send(lport, fcmd->seq, fp); ++ return SCST_TGT_RES_SUCCESS; ++} ++ ++/* ++ * Send TX_RDY (transfer ready). ++ */ ++int ft_send_xfer_rdy(struct scst_cmd *cmd) ++{ ++ return ft_send_xfer_rdy_off(cmd, 0, scst_cmd_get_bufflen(cmd)); ++} ++ ++/* ++ * Send a FCP response including SCSI status and optional FCP rsp_code. ++ * status is SAM_STAT_GOOD (zero) if code is valid. ++ * This is used in error cases, such as allocation failures. ++ */ ++static void ft_send_resp_status(struct fc_frame *rx_fp, u32 status, ++ enum fcp_resp_rsp_codes code) ++{ ++ struct fc_frame *fp; ++ struct fc_frame_header *fh; ++ size_t len; ++ struct fcp_resp_with_ext *fcp; ++ struct fcp_resp_rsp_info *info; ++ struct fc_lport *lport; ++ struct fc_seq *sp; ++ ++ sp = fr_seq(rx_fp); ++ fh = fc_frame_header_get(rx_fp); ++ FT_IO_DBG("FCP error response: did %x oxid %x status %x code %x\n", ++ ntoh24(fh->fh_s_id), ntohs(fh->fh_ox_id), status, code); ++ lport = fr_dev(rx_fp); ++ len = sizeof(*fcp); ++ if (status == SAM_STAT_GOOD) ++ len += sizeof(*info); ++ fp = fc_frame_alloc(lport, len); ++ if (!fp) ++ return; ++ fcp = fc_frame_payload_get(fp, len); ++ memset(fcp, 0, len); ++ fcp->resp.fr_status = status; ++ if (status == SAM_STAT_GOOD) { ++ fcp->ext.fr_rsp_len = htonl(sizeof(*info)); ++ fcp->resp.fr_flags |= FCP_RSP_LEN_VAL; ++ info = (struct fcp_resp_rsp_info *)(fcp + 1); ++ info->rsp_code = code; ++ } ++ ++ fc_fill_reply_hdr(fp, rx_fp, FC_RCTL_DD_CMD_STATUS, 0); ++ if (sp) ++ lport->tt.seq_send(lport, sp, fp); ++ else ++ lport->tt.frame_send(lport, fp); ++} ++ ++/* ++ * Send error or task management response. ++ * Always frees the fcmd and associated state. ++ */ ++static void ft_send_resp_code(struct ft_cmd *fcmd, enum fcp_resp_rsp_codes code) ++{ ++ ft_send_resp_status(fcmd->req_frame, SAM_STAT_GOOD, code); ++ ft_cmd_done(fcmd); ++} ++ ++void ft_cmd_tm_done(struct scst_mgmt_cmd *mcmd) ++{ ++ struct ft_cmd *fcmd; ++ enum fcp_resp_rsp_codes code; ++ ++ ft_cmd_tm_dump(mcmd, __func__); ++ fcmd = scst_mgmt_cmd_get_tgt_priv(mcmd); ++ switch (scst_mgmt_cmd_get_status(mcmd)) { ++ case SCST_MGMT_STATUS_SUCCESS: ++ code = FCP_TMF_CMPL; ++ break; ++ case SCST_MGMT_STATUS_REJECTED: ++ code = FCP_TMF_REJECTED; ++ break; ++ case SCST_MGMT_STATUS_LUN_NOT_EXIST: ++ code = FCP_TMF_INVALID_LUN; ++ break; ++ case SCST_MGMT_STATUS_TASK_NOT_EXIST: ++ case SCST_MGMT_STATUS_FN_NOT_SUPPORTED: ++ case SCST_MGMT_STATUS_FAILED: ++ default: ++ code = FCP_TMF_FAILED; ++ break; ++ } ++ FT_IO_DBG("tm cmd done fn %d code %d\n", mcmd->fn, code); ++ ft_send_resp_code(fcmd, code); ++} ++ ++/* ++ * Handle an incoming FCP task management command frame. ++ * Note that this may be called directly from the softirq context. ++ */ ++static void ft_recv_tm(struct scst_session *scst_sess, ++ struct ft_cmd *fcmd, struct fcp_cmnd *fcp) ++{ ++ struct scst_rx_mgmt_params params; ++ int ret; ++ ++ memset(¶ms, 0, sizeof(params)); ++ params.lun = fcp->fc_lun; ++ params.lun_len = sizeof(fcp->fc_lun); ++ params.lun_set = 1; ++ params.atomic = SCST_ATOMIC; ++ params.tgt_priv = fcmd; ++ ++ switch (fcp->fc_tm_flags) { ++ case FCP_TMF_LUN_RESET: ++ params.fn = SCST_LUN_RESET; ++ break; ++ case FCP_TMF_TGT_RESET: ++ params.fn = SCST_TARGET_RESET; ++ params.lun_set = 0; ++ break; ++ case FCP_TMF_CLR_TASK_SET: ++ params.fn = SCST_CLEAR_TASK_SET; ++ break; ++ case FCP_TMF_ABT_TASK_SET: ++ params.fn = SCST_ABORT_TASK_SET; ++ break; ++ case FCP_TMF_CLR_ACA: ++ params.fn = SCST_CLEAR_ACA; ++ break; ++ default: ++ /* ++ * FCP4r01 indicates having a combination of ++ * tm_flags set is invalid. ++ */ ++ FT_IO_DBG("invalid FCP tm_flags %x\n", fcp->fc_tm_flags); ++ ft_send_resp_code(fcmd, FCP_CMND_FIELDS_INVALID); ++ return; ++ } ++ FT_IO_DBG("submit tm cmd fn %d\n", params.fn); ++ ret = scst_rx_mgmt_fn(scst_sess, ¶ms); ++ FT_IO_DBG("scst_rx_mgmt_fn ret %d\n", ret); ++ if (ret) ++ ft_send_resp_code(fcmd, FCP_TMF_FAILED); ++} ++ ++/* ++ * Handle an incoming FCP command frame. ++ * Note that this may be called directly from the softirq context. ++ */ ++static void ft_recv_cmd(struct ft_sess *sess, struct fc_frame *fp) ++{ ++ static atomic_t serial; ++ struct fc_seq *sp; ++ struct scst_cmd *cmd; ++ struct ft_cmd *fcmd; ++ struct fcp_cmnd *fcp; ++ struct fc_lport *lport; ++ int data_dir; ++ u32 data_len; ++ int cdb_len; ++ ++ lport = sess->tport->lport; ++ fcmd = kzalloc(sizeof(*fcmd), GFP_ATOMIC); ++ if (!fcmd) ++ goto busy; ++ fcmd->serial = atomic_inc_return(&serial); /* debug only */ ++ fcmd->max_payload = sess->max_payload; ++ fcmd->max_lso_payload = sess->max_lso_payload; ++ fcmd->req_frame = fp; ++ ++ fcp = fc_frame_payload_get(fp, sizeof(*fcp)); ++ if (!fcp) ++ goto err; ++ if (fcp->fc_tm_flags) { ++ ft_recv_tm(sess->scst_sess, fcmd, fcp); ++ return; ++ } ++ ++ /* ++ * re-check length including specified CDB length. ++ * data_len is just after the CDB. ++ */ ++ cdb_len = fcp->fc_flags & FCP_CFL_LEN_MASK; ++ fcp = fc_frame_payload_get(fp, sizeof(*fcp) + cdb_len); ++ if (!fcp) ++ goto err; ++ cdb_len += sizeof(fcp->fc_cdb); ++ data_len = ntohl(*(__be32 *)(fcp->fc_cdb + cdb_len)); ++ ++ cmd = scst_rx_cmd(sess->scst_sess, fcp->fc_lun, sizeof(fcp->fc_lun), ++ fcp->fc_cdb, cdb_len, SCST_ATOMIC); ++ if (!cmd) ++ goto busy; ++ fcmd->scst_cmd = cmd; ++ scst_cmd_set_tgt_priv(cmd, fcmd); ++ ++ sp = lport->tt.seq_assign(lport, fp); ++ if (!sp) ++ goto busy; ++ fcmd->seq = sp; ++ lport->tt.seq_set_resp(sp, ft_recv_seq, cmd); ++ ++ switch (fcp->fc_flags & (FCP_CFL_RDDATA | FCP_CFL_WRDATA)) { ++ case 0: ++ default: ++ data_dir = SCST_DATA_NONE; ++ break; ++ case FCP_CFL_RDDATA: ++ data_dir = SCST_DATA_READ; ++ break; ++ case FCP_CFL_WRDATA: ++ data_dir = SCST_DATA_WRITE; ++ break; ++ case FCP_CFL_RDDATA | FCP_CFL_WRDATA: ++ data_dir = SCST_DATA_BIDI; ++ break; ++ } ++ scst_cmd_set_expected(cmd, data_dir, data_len); ++ ++ switch (fcp->fc_pri_ta & FCP_PTA_MASK) { ++ case FCP_PTA_SIMPLE: ++ scst_cmd_set_queue_type(cmd, SCST_CMD_QUEUE_SIMPLE); ++ break; ++ case FCP_PTA_HEADQ: ++ scst_cmd_set_queue_type(cmd, SCST_CMD_QUEUE_HEAD_OF_QUEUE); ++ break; ++ case FCP_PTA_ACA: ++ scst_cmd_set_queue_type(cmd, SCST_CMD_QUEUE_ACA); ++ break; ++ case FCP_PTA_ORDERED: ++ default: ++ scst_cmd_set_queue_type(cmd, SCST_CMD_QUEUE_ORDERED); ++ break; ++ } ++ ++ scst_cmd_init_done(cmd, SCST_CONTEXT_THREAD); ++ return; ++ ++err: ++ ft_send_resp_code(fcmd, FCP_CMND_FIELDS_INVALID); ++ return; ++ ++busy: ++ FT_IO_DBG("cmd allocation failure - sending BUSY\n"); ++ ft_send_resp_status(fp, SAM_STAT_BUSY, 0); ++ ft_cmd_done(fcmd); ++} ++ ++/* ++ * Send FCP ELS-4 Reject. ++ */ ++static void ft_cmd_ls_rjt(struct fc_frame *rx_fp, enum fc_els_rjt_reason reason, ++ enum fc_els_rjt_explan explan) ++{ ++ struct fc_seq_els_data rjt_data; ++ struct fc_lport *lport; ++ ++ lport = fr_dev(rx_fp); ++ rjt_data.reason = reason; ++ rjt_data.explan = explan; ++ lport->tt.seq_els_rsp_send(rx_fp, ELS_LS_RJT, &rjt_data); ++} ++ ++/* ++ * Handle an incoming FCP ELS-4 command frame. ++ * Note that this may be called directly from the softirq context. ++ */ ++static void ft_recv_els4(struct ft_sess *sess, struct fc_frame *fp) ++{ ++ u8 op = fc_frame_payload_op(fp); ++ ++ switch (op) { ++ case ELS_SRR: /* TBD */ ++ default: ++ FT_IO_DBG("unsupported ELS-4 op %x\n", op); ++ ft_cmd_ls_rjt(fp, ELS_RJT_INVAL, ELS_EXPL_NONE); ++ fc_frame_free(fp); ++ break; ++ } ++} ++ ++/* ++ * Handle an incoming FCP frame. ++ * Note that this may be called directly from the softirq context. ++ */ ++void ft_recv_req(struct ft_sess *sess, struct fc_frame *fp) ++{ ++ struct fc_frame_header *fh = fc_frame_header_get(fp); ++ ++ switch (fh->fh_r_ctl) { ++ case FC_RCTL_DD_UNSOL_CMD: ++ ft_recv_cmd(sess, fp); ++ break; ++ case FC_RCTL_ELS4_REQ: ++ ft_recv_els4(sess, fp); ++ break; ++ default: ++ printk(KERN_INFO "%s: unhandled frame r_ctl %x\n", ++ __func__, fh->fh_r_ctl); ++ fc_frame_free(fp); ++ break; ++ } ++} +diff -uprN orig/linux-3.2/drivers/scst/fcst/ft_io.c linux-3.2/drivers/scst/fcst/ft_io.c +--- orig/linux-3.2/drivers/scst/fcst/ft_io.c ++++ linux-3.2/drivers/scst/fcst/ft_io.c +@@ -0,0 +1,276 @@ ++/* ++ * Copyright (c) 2010 Cisco Systems, Inc. ++ * ++ * Portions based on drivers/scsi/libfc/fc_fcp.c and subject to the following: ++ * ++ * Copyright (c) 2007 Intel Corporation. All rights reserved. ++ * Copyright (c) 2008 Red Hat, Inc. All rights reserved. ++ * Copyright (c) 2008 Mike Christie ++ * ++ * This program is free software; you can redistribute it and/or modify it ++ * under the terms and conditions of the GNU General Public License, ++ * version 2, as published by the Free Software Foundation. ++ * ++ * This program is distributed in the hope 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., ++ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. ++ */ ++#include <linux/kernel.h> ++#include <linux/types.h> ++#include <scsi/libfc.h> ++#include <scsi/fc_encode.h> ++#include "fcst.h" ++ ++/* ++ * Receive write data frame. ++ */ ++void ft_recv_write_data(struct scst_cmd *cmd, struct fc_frame *fp) ++{ ++ struct ft_cmd *fcmd; ++ struct fc_frame_header *fh; ++ unsigned int bufflen; ++ u32 rel_off; ++ size_t frame_len; ++ size_t mem_len; ++ size_t tlen; ++ void *from; ++ void *to; ++ int dir; ++ u8 *buf; ++ ++ dir = scst_cmd_get_data_direction(cmd); ++ if (dir == SCST_DATA_BIDI) { ++ mem_len = scst_get_out_buf_first(cmd, &buf); ++ bufflen = scst_cmd_get_out_bufflen(cmd); ++ } else { ++ mem_len = scst_get_buf_first(cmd, &buf); ++ bufflen = scst_cmd_get_bufflen(cmd); ++ } ++ to = buf; ++ ++ fcmd = scst_cmd_get_tgt_priv(cmd); ++ fh = fc_frame_header_get(fp); ++ frame_len = fr_len(fp); ++ rel_off = ntohl(fh->fh_parm_offset); ++ ++ FT_IO_DBG("sid %x oxid %x payload_len %zd rel_off %x\n", ++ ntoh24(fh->fh_s_id), ntohs(fh->fh_ox_id), ++ frame_len - sizeof(*fh), rel_off); ++ ++ if (!(ntoh24(fh->fh_f_ctl) & FC_FC_REL_OFF)) ++ goto drop; ++ if (frame_len <= sizeof(*fh)) ++ goto drop; ++ frame_len -= sizeof(*fh); ++ from = fc_frame_payload_get(fp, 0); ++ ++ if (rel_off >= bufflen) ++ goto drop; ++ if (frame_len + rel_off > bufflen) ++ frame_len = bufflen - rel_off; ++ ++ while (frame_len) { ++ if (!mem_len) { ++ if (dir == SCST_DATA_BIDI) { ++ scst_put_out_buf(cmd, buf); ++ mem_len = scst_get_out_buf_next(cmd, &buf); ++ } else { ++ scst_put_buf(cmd, buf); ++ mem_len = scst_get_buf_next(cmd, &buf); ++ } ++ to = buf; ++ if (!mem_len) ++ break; ++ } ++ if (rel_off) { ++ if (rel_off >= mem_len) { ++ rel_off -= mem_len; ++ mem_len = 0; ++ continue; ++ } ++ mem_len -= rel_off; ++ to += rel_off; ++ rel_off = 0; ++ } ++ ++ tlen = min(mem_len, frame_len); ++ memcpy(to, from, tlen); ++ ++ from += tlen; ++ frame_len -= tlen; ++ mem_len -= tlen; ++ to += tlen; ++ fcmd->write_data_len += tlen; ++ } ++ if (mem_len) { ++ if (dir == SCST_DATA_BIDI) ++ scst_put_out_buf(cmd, buf); ++ else ++ scst_put_buf(cmd, buf); ++ } ++ if (fcmd->write_data_len == cmd->data_len) ++ scst_rx_data(cmd, SCST_RX_STATUS_SUCCESS, SCST_CONTEXT_THREAD); ++drop: ++ fc_frame_free(fp); ++} ++ ++/* ++ * Send read data back to initiator. ++ */ ++int ft_send_read_data(struct scst_cmd *cmd) ++{ ++ struct ft_cmd *fcmd; ++ struct fc_frame *fp = NULL; ++ struct fc_exch *ep; ++ struct fc_lport *lport; ++ size_t remaining; ++ u32 fh_off = 0; ++ u32 frame_off; ++ size_t frame_len = 0; ++ size_t mem_len; ++ u32 mem_off; ++ size_t tlen; ++ struct page *page; ++ int use_sg; ++ int error; ++ void *to = NULL; ++ u8 *from = NULL; ++ int loop_limit = 10000; ++ ++ fcmd = scst_cmd_get_tgt_priv(cmd); ++ ep = fc_seq_exch(fcmd->seq); ++ lport = ep->lp; ++ ++ frame_off = fcmd->read_data_len; ++ tlen = scst_cmd_get_resp_data_len(cmd); ++ FT_IO_DBG("oid %x oxid %x resp_len %zd frame_off %u\n", ++ ep->oid, ep->oxid, tlen, frame_off); ++ if (tlen <= frame_off) ++ return SCST_TGT_RES_SUCCESS; ++ remaining = tlen - frame_off; ++ if (remaining > UINT_MAX) ++ FT_ERR("oid %x oxid %x resp_len %zd frame_off %u\n", ++ ep->oid, ep->oxid, tlen, frame_off); ++ ++ mem_len = scst_get_buf_first(cmd, &from); ++ mem_off = 0; ++ if (!mem_len) { ++ FT_IO_DBG("mem_len 0\n"); ++ return SCST_TGT_RES_SUCCESS; ++ } ++ FT_IO_DBG("sid %x oxid %x mem_len %zd frame_off %u remaining %zd\n", ++ ep->sid, ep->oxid, mem_len, frame_off, remaining); ++ ++ /* ++ * If we've already transferred some of the data, skip through ++ * the buffer over the data already sent and continue with the ++ * same sequence. Otherwise, get a new sequence for the data. ++ */ ++ if (frame_off) { ++ tlen = frame_off; ++ while (mem_len <= tlen) { ++ tlen -= mem_len; ++ scst_put_buf(cmd, from); ++ mem_len = scst_get_buf_next(cmd, &from); ++ if (!mem_len) ++ return SCST_TGT_RES_SUCCESS; ++ } ++ mem_len -= tlen; ++ mem_off = tlen; ++ } else ++ fcmd->seq = lport->tt.seq_start_next(fcmd->seq); ++ ++ /* no scatter/gather in skb for odd word length due to fc_seq_send() */ ++ use_sg = !(remaining % 4) && lport->sg_supp; ++ ++ while (remaining) { ++ if (!loop_limit) { ++ FT_ERR("hit loop limit. remaining %zx mem_len %zx " ++ "frame_len %zx tlen %zx\n", ++ remaining, mem_len, frame_len, tlen); ++ break; ++ } ++ loop_limit--; ++ if (!mem_len) { ++ scst_put_buf(cmd, from); ++ mem_len = scst_get_buf_next(cmd, &from); ++ mem_off = 0; ++ if (!mem_len) { ++ FT_ERR("mem_len 0 from get_buf_next\n"); ++ break; ++ } ++ } ++ if (!frame_len) { ++ frame_len = fcmd->max_lso_payload; ++ frame_len = min(frame_len, remaining); ++ fp = fc_frame_alloc(lport, use_sg ? 0 : frame_len); ++ if (!fp) { ++ FT_IO_DBG("frame_alloc failed. " ++ "use_sg %d frame_len %zd\n", ++ use_sg, frame_len); ++ break; ++ } ++ fr_max_payload(fp) = fcmd->max_payload; ++ to = fc_frame_payload_get(fp, 0); ++ fh_off = frame_off; ++ } ++ tlen = min(mem_len, frame_len); ++ BUG_ON(!tlen); ++ BUG_ON(tlen > remaining); ++ BUG_ON(tlen > mem_len); ++ BUG_ON(tlen > frame_len); ++ ++ if (use_sg) { ++ page = virt_to_page(from + mem_off); ++ get_page(page); ++ tlen = min_t(size_t, tlen, ++ PAGE_SIZE - (mem_off & ~PAGE_MASK)); ++ skb_fill_page_desc(fp_skb(fp), ++ skb_shinfo(fp_skb(fp))->nr_frags, ++ page, offset_in_page(from + mem_off), ++ tlen); ++ fr_len(fp) += tlen; ++ fp_skb(fp)->data_len += tlen; ++ fp_skb(fp)->truesize += ++ PAGE_SIZE << compound_order(page); ++ frame_len -= tlen; ++ if (skb_shinfo(fp_skb(fp))->nr_frags >= FC_FRAME_SG_LEN) ++ frame_len = 0; ++ } else { ++ memcpy(to, from + mem_off, tlen); ++ to += tlen; ++ frame_len -= tlen; ++ } ++ ++ mem_len -= tlen; ++ mem_off += tlen; ++ remaining -= tlen; ++ frame_off += tlen; ++ ++ if (frame_len) ++ continue; ++ fc_fill_fc_hdr(fp, FC_RCTL_DD_SOL_DATA, ep->did, ep->sid, ++ FC_TYPE_FCP, ++ remaining ? (FC_FC_EX_CTX | FC_FC_REL_OFF) : ++ (FC_FC_EX_CTX | FC_FC_REL_OFF | FC_FC_END_SEQ), ++ fh_off); ++ error = lport->tt.seq_send(lport, fcmd->seq, fp); ++ if (error) { ++ WARN_ON(1); ++ /* XXX For now, initiator will retry */ ++ } else ++ fcmd->read_data_len = frame_off; ++ } ++ if (mem_len) ++ scst_put_buf(cmd, from); ++ if (remaining) { ++ FT_IO_DBG("remaining read data %zd\n", remaining); ++ return SCST_TGT_RES_QUEUE_FULL; ++ } ++ return SCST_TGT_RES_SUCCESS; ++} +diff -uprN orig/linux-3.2/drivers/scst/fcst/ft_scst.c linux-3.2/drivers/scst/fcst/ft_scst.c +--- orig/linux-3.2/drivers/scst/fcst/ft_scst.c ++++ linux-3.2/drivers/scst/fcst/ft_scst.c +@@ -0,0 +1,96 @@ ++/* ++ * Copyright (c) 2010 Cisco Systems, Inc. ++ * ++ * This program is free software; you may redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; version 2 of the License. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ++ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ++ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS ++ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ++ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE ++ * SOFTWARE. ++ */ ++#include <linux/kernel.h> ++#include <linux/types.h> ++#include <scsi/libfc.h> ++#include "fcst.h" ++ ++MODULE_AUTHOR("Joe Eykholt <jeykholt@cisco.com>"); ++MODULE_DESCRIPTION("Fibre-Channel SCST target"); ++MODULE_LICENSE("GPL v2"); ++ ++unsigned int ft_debug_logging; ++module_param_named(debug_logging, ft_debug_logging, int, S_IRUGO | S_IWUSR); ++MODULE_PARM_DESC(debug_logging, "log levels bigmask"); ++ ++DEFINE_MUTEX(ft_lport_lock); ++ ++/* ++ * Provider ops for libfc. ++ */ ++static struct fc4_prov ft_prov = { ++ .prli = ft_prli, ++ .prlo = ft_prlo, ++ .recv = ft_recv, ++ .module = THIS_MODULE, ++}; ++ ++static struct notifier_block ft_notifier = { ++ .notifier_call = ft_lport_notify ++}; ++ ++/* ++ * SCST target ops and configuration. ++ * XXX - re-check uninitialized fields ++ */ ++struct scst_tgt_template ft_scst_template = { ++ .sg_tablesize = 128, /* XXX get true limit from libfc */ ++ .xmit_response_atomic = 1, ++ .rdy_to_xfer_atomic = 1, ++ .xmit_response = ft_send_response, ++ .rdy_to_xfer = ft_send_xfer_rdy, ++ .on_hw_pending_cmd_timeout = ft_cmd_timeout, ++ .on_free_cmd = ft_cmd_free, ++ .task_mgmt_fn_done = ft_cmd_tm_done, ++ .detect = ft_tgt_detect, ++ .release = ft_tgt_release, ++ .report_aen = ft_report_aen, ++ .enable_target = ft_tgt_enable, ++ .is_target_enabled = ft_tgt_enabled, ++ .get_initiator_port_transport_id = ft_get_transport_id, ++ .max_hw_pending_time = FT_MAX_HW_PENDING_TIME, ++ .name = FT_MODULE, ++}; ++ ++static int __init ft_module_init(void) ++{ ++ int err; ++ ++ err = scst_register_target_template(&ft_scst_template); ++ if (err) ++ return err; ++ err = fc_fc4_register_provider(FC_TYPE_FCP, &ft_prov); ++ if (err) { ++ scst_unregister_target_template(&ft_scst_template); ++ return err; ++ } ++ blocking_notifier_chain_register(&fc_lport_notifier_head, &ft_notifier); ++ fc_lport_iterate(ft_lport_add, NULL); ++ return 0; ++} ++module_init(ft_module_init); ++ ++static void __exit ft_module_exit(void) ++{ ++ blocking_notifier_chain_unregister(&fc_lport_notifier_head, ++ &ft_notifier); ++ fc_fc4_deregister_provider(FC_TYPE_FCP, &ft_prov); ++ fc_lport_iterate(ft_lport_del, NULL); ++ scst_unregister_target_template(&ft_scst_template); ++ synchronize_rcu(); ++} ++module_exit(ft_module_exit); +diff -uprN orig/linux-3.2/drivers/scst/fcst/ft_sess.c linux-3.2/drivers/scst/fcst/ft_sess.c +--- orig/linux-3.2/drivers/scst/fcst/ft_sess.c ++++ linux-3.2/drivers/scst/fcst/ft_sess.c +@@ -0,0 +1,585 @@ ++/* ++ * Copyright (c) 2010 Cisco Systems, Inc. ++ * ++ * This program is free software; you may redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; version 2 of the License. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ++ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ++ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS ++ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ++ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE ++ * SOFTWARE. ++ */ ++#include <linux/kernel.h> ++#include <linux/types.h> ++#include <linux/mutex.h> ++#include <linux/hash.h> ++#include <asm/unaligned.h> ++#include <scsi/libfc.h> ++#include <scsi/fc/fc_els.h> ++#include "fcst.h" ++ ++static int ft_tport_count; ++ ++static ssize_t ft_format_wwn(char *buf, size_t len, u64 wwn) ++{ ++ u8 b[8]; ++ ++ put_unaligned_be64(wwn, b); ++ return snprintf(buf, len, ++ "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x", ++ b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]); ++} ++ ++/* ++ * Lookup or allocate target local port. ++ * Caller holds ft_lport_lock. ++ */ ++static struct ft_tport *ft_tport_create(struct fc_lport *lport) ++{ ++ struct ft_tport *tport; ++ char name[FT_NAMELEN]; ++ int i; ++ ++ ft_format_wwn(name, sizeof(name), lport->wwpn); ++ FT_SESS_DBG("create %s\n", name); ++ ++ tport = rcu_dereference(lport->prov[FC_TYPE_FCP]); ++ if (tport) { ++ FT_SESS_DBG("tport alloc %s - already setup\n", name); ++ return tport; ++ } ++ ++ tport = kzalloc(sizeof(*tport), GFP_KERNEL); ++ if (!tport) { ++ FT_SESS_DBG("tport alloc %s failed\n", name); ++ return NULL; ++ } ++ ++ tport->tgt = scst_register_target(&ft_scst_template, name); ++ if (!tport->tgt) { ++ FT_SESS_DBG("register_target %s failed\n", name); ++ kfree(tport); ++ return NULL; ++ } ++ scst_tgt_set_tgt_priv(tport->tgt, tport); ++ ft_tport_count++; ++ ++ tport->lport = lport; ++ for (i = 0; i < FT_SESS_HASH_SIZE; i++) ++ INIT_HLIST_HEAD(&tport->hash[i]); ++ ++ rcu_assign_pointer(lport->prov[FC_TYPE_FCP], tport); ++ FT_SESS_DBG("register_target %s succeeded\n", name); ++ return tport; ++} ++ ++/* ++ * Free tport via RCU. ++ */ ++static void ft_tport_rcu_free(struct rcu_head *rcu) ++{ ++ struct ft_tport *tport = container_of(rcu, struct ft_tport, rcu); ++ ++ kfree(tport); ++} ++ ++/* ++ * Delete target local port, if any, associated with the local port. ++ * Caller holds ft_lport_lock. ++ */ ++static void ft_tport_delete(struct ft_tport *tport) ++{ ++ struct fc_lport *lport; ++ struct scst_tgt *tgt; ++ ++ tgt = tport->tgt; ++ BUG_ON(!tgt); ++ FT_SESS_DBG("delete %s\n", scst_get_tgt_name(tgt)); ++ scst_unregister_target(tgt); ++ lport = tport->lport; ++ BUG_ON(tport != lport->prov[FC_TYPE_FCP]); ++ rcu_assign_pointer(lport->prov[FC_TYPE_FCP], NULL); ++ tport->lport = NULL; ++ call_rcu(&tport->rcu, ft_tport_rcu_free); ++ ft_tport_count--; ++} ++ ++/* ++ * Add local port. ++ * Called thru fc_lport_iterate(). ++ */ ++void ft_lport_add(struct fc_lport *lport, void *arg) ++{ ++ mutex_lock(&ft_lport_lock); ++ ft_tport_create(lport); ++ mutex_unlock(&ft_lport_lock); ++} ++ ++/* ++ * Delete local port. ++ * Called thru fc_lport_iterate(). ++ */ ++void ft_lport_del(struct fc_lport *lport, void *arg) ++{ ++ struct ft_tport *tport; ++ ++ mutex_lock(&ft_lport_lock); ++ tport = lport->prov[FC_TYPE_FCP]; ++ if (tport) ++ ft_tport_delete(tport); ++ mutex_unlock(&ft_lport_lock); ++} ++ ++/* ++ * Notification of local port change from libfc. ++ * Create or delete local port and associated tport. ++ */ ++int ft_lport_notify(struct notifier_block *nb, unsigned long event, void *arg) ++{ ++ struct fc_lport *lport = arg; ++ ++ switch (event) { ++ case FC_LPORT_EV_ADD: ++ ft_lport_add(lport, NULL); ++ break; ++ case FC_LPORT_EV_DEL: ++ ft_lport_del(lport, NULL); ++ break; ++ } ++ return NOTIFY_DONE; ++} ++ ++/* ++ * Find session in local port. ++ * Sessions and hash lists are RCU-protected. ++ * A reference is taken which must be eventually freed. ++ */ ++static struct ft_sess *ft_sess_get(struct fc_lport *lport, u32 port_id) ++{ ++ struct ft_tport *tport; ++ struct hlist_head *head; ++ struct hlist_node *pos; ++ struct ft_sess *sess = NULL; ++ ++ rcu_read_lock(); ++ tport = rcu_dereference(lport->prov[FC_TYPE_FCP]); ++ if (!tport) ++ goto out; ++ ++ head = &tport->hash[hash_32(port_id, FT_SESS_HASH_BITS)]; ++ hlist_for_each_entry_rcu(sess, pos, head, hash) { ++ if (sess->port_id == port_id) { ++ kref_get(&sess->kref); ++ rcu_read_unlock(); ++ FT_SESS_DBG("port_id %x found %p\n", port_id, sess); ++ return sess; ++ } ++ } ++out: ++ rcu_read_unlock(); ++ FT_SESS_DBG("port_id %x not found\n", port_id); ++ return NULL; ++} ++ ++/* ++ * Allocate session and enter it in the hash for the local port. ++ * Caller holds ft_lport_lock. ++ */ ++static int ft_sess_create(struct ft_tport *tport, struct fc_rport_priv *rdata, ++ u32 fcp_parm) ++{ ++ struct ft_sess *sess; ++ struct scst_session *scst_sess; ++ struct hlist_head *head; ++ struct hlist_node *pos; ++ u32 port_id; ++ char name[FT_NAMELEN]; ++ ++ port_id = rdata->ids.port_id; ++ if (!rdata->maxframe_size) { ++ FT_SESS_DBG("port_id %x maxframe_size 0\n", port_id); ++ return FC_SPP_RESP_CONF; ++ } ++ ++ head = &tport->hash[hash_32(port_id, FT_SESS_HASH_BITS)]; ++ hlist_for_each_entry_rcu(sess, pos, head, hash) { ++ if (sess->port_id == port_id) { ++ sess->params = fcp_parm; ++ return 0; ++ } ++ } ++ ++ sess = kzalloc(sizeof(*sess), GFP_KERNEL); ++ if (!sess) ++ return FC_SPP_RESP_RES; /* out of resources */ ++ ++ sess->port_name = rdata->ids.port_name; ++ sess->max_payload = rdata->maxframe_size; ++ sess->max_lso_payload = rdata->maxframe_size; ++ if (tport->lport->seq_offload) ++ sess->max_lso_payload = tport->lport->lso_max; ++ sess->params = fcp_parm; ++ sess->tport = tport; ++ sess->port_id = port_id; ++ kref_init(&sess->kref); /* ref for table entry */ ++ ++ ft_format_wwn(name, sizeof(name), rdata->ids.port_name); ++ FT_SESS_DBG("register %s\n", name); ++ scst_sess = scst_register_session(tport->tgt, 0, name, sess, NULL, ++ NULL); ++ if (!scst_sess) { ++ kfree(sess); ++ return FC_SPP_RESP_RES; /* out of resources */ ++ } ++ sess->scst_sess = scst_sess; ++ hlist_add_head_rcu(&sess->hash, head); ++ tport->sess_count++; ++ ++ FT_SESS_DBG("port_id %x sess %p\n", port_id, sess); ++ ++ rdata->prli_count++; ++ return 0; ++} ++ ++/* ++ * Unhash the session. ++ * Caller holds ft_lport_lock. ++ */ ++static void ft_sess_unhash(struct ft_sess *sess) ++{ ++ struct ft_tport *tport = sess->tport; ++ ++ hlist_del_rcu(&sess->hash); ++ BUG_ON(!tport->sess_count); ++ tport->sess_count--; ++ sess->port_id = -1; ++ sess->params = 0; ++} ++ ++/* ++ * Delete session from hash. ++ * Caller holds ft_lport_lock. ++ */ ++static struct ft_sess *ft_sess_delete(struct ft_tport *tport, u32 port_id) ++{ ++ struct hlist_head *head; ++ struct hlist_node *pos; ++ struct ft_sess *sess; ++ ++ head = &tport->hash[hash_32(port_id, FT_SESS_HASH_BITS)]; ++ hlist_for_each_entry_rcu(sess, pos, head, hash) { ++ if (sess->port_id == port_id) { ++ ft_sess_unhash(sess); ++ return sess; ++ } ++ } ++ return NULL; ++} ++ ++/* ++ * Remove session and send PRLO. ++ * This is called when the target is being deleted. ++ * Caller holds ft_lport_lock. ++ */ ++static void ft_sess_close(struct ft_sess *sess) ++{ ++ struct fc_lport *lport; ++ u32 port_id; ++ ++ lport = sess->tport->lport; ++ port_id = sess->port_id; ++ if (port_id == -1) ++ return; ++ FT_SESS_DBG("port_id %x\n", port_id); ++ ft_sess_unhash(sess); ++ /* XXX should send LOGO or PRLO to rport */ ++} ++ ++/* ++ * Allocate and fill in the SPC Transport ID for persistent reservations. ++ */ ++int ft_get_transport_id(struct scst_tgt *tgt, struct scst_session *scst_sess, ++ uint8_t **result) ++{ ++ struct ft_sess *sess; ++ struct { ++ u8 format_proto; /* format and protocol ID (0 for FC) */ ++ u8 __resv1[7]; ++ __be64 port_name; /* N_Port Name */ ++ u8 __resv2[8]; ++ } __attribute__((__packed__)) *id; ++ ++ if (!scst_sess) ++ return SCSI_TRANSPORTID_PROTOCOLID_FCP2; ++ ++ id = kzalloc(sizeof(*id), GFP_KERNEL); ++ if (!id) ++ return -ENOMEM; ++ ++ sess = scst_sess_get_tgt_priv(scst_sess); ++ id->port_name = cpu_to_be64(sess->port_name); ++ id->format_proto = SCSI_TRANSPORTID_PROTOCOLID_FCP2; ++ *result = (uint8_t *)id; ++ return 0; ++} ++ ++/* ++ * libfc ops involving sessions. ++ */ ++ ++/* ++ * Handle PRLI (process login) request. ++ * This could be a PRLI we're sending or receiving. ++ * Caller holds ft_lport_lock. ++ */ ++static int ft_prli_locked(struct fc_rport_priv *rdata, u32 spp_len, ++ const struct fc_els_spp *rspp, struct fc_els_spp *spp) ++{ ++ struct ft_tport *tport; ++ u32 fcp_parm; ++ int ret; ++ ++ if (!rspp) ++ goto fill; ++ ++ if (rspp->spp_flags & (FC_SPP_OPA_VAL | FC_SPP_RPA_VAL)) ++ return FC_SPP_RESP_NO_PA; ++ ++ /* ++ * If both target and initiator bits are off, the SPP is invalid. ++ */ ++ fcp_parm = ntohl(rspp->spp_params); /* requested parameters */ ++ if (!(fcp_parm & (FCP_SPPF_INIT_FCN | FCP_SPPF_TARG_FCN))) ++ return FC_SPP_RESP_INVL; ++ ++ /* ++ * Create session (image pair) only if requested by ++ * EST_IMG_PAIR flag and if the requestor is an initiator. ++ */ ++ if (rspp->spp_flags & FC_SPP_EST_IMG_PAIR) { ++ spp->spp_flags |= FC_SPP_EST_IMG_PAIR; ++ ++ if (!(fcp_parm & FCP_SPPF_INIT_FCN)) ++ return FC_SPP_RESP_CONF; ++ tport = rcu_dereference(rdata->local_port->prov[FC_TYPE_FCP]); ++ if (!tport) { ++ /* not a target for this local port */ ++ return FC_SPP_RESP_CONF; ++ } ++ if (!tport->enabled) { ++ pr_err("Refused login from %#x because target port %s" ++ " not yet enabled", rdata->ids.port_id, ++ tport->tgt->tgt_name); ++ return FC_SPP_RESP_CONF; ++ } ++ ret = ft_sess_create(tport, rdata, fcp_parm); ++ if (ret) ++ return ret; ++ } ++ ++ /* ++ * OR in our service parameters with other provider (initiator), if any. ++ * If the initiator indicates RETRY, we must support that, too. ++ * Don't force RETRY on the initiator, though. ++ */ ++fill: ++ fcp_parm = ntohl(spp->spp_params); /* response parameters */ ++ spp->spp_params = htonl(fcp_parm | FCP_SPPF_TARG_FCN); ++ return FC_SPP_RESP_ACK; ++} ++ ++/** ++ * tcm_fcp_prli() - Handle incoming or outgoing PRLI for the FCP target ++ * @rdata: remote port private ++ * @spp_len: service parameter page length ++ * @rspp: received service parameter page (NULL for outgoing PRLI) ++ * @spp: response service parameter page ++ * ++ * Returns spp response code. ++ */ ++int ft_prli(struct fc_rport_priv *rdata, u32 spp_len, ++ const struct fc_els_spp *rspp, struct fc_els_spp *spp) ++{ ++ int ret; ++ ++ FT_SESS_DBG("starting PRLI port_id %x\n", rdata->ids.port_id); ++ mutex_lock(&ft_lport_lock); ++ ret = ft_prli_locked(rdata, spp_len, rspp, spp); ++ mutex_unlock(&ft_lport_lock); ++ FT_SESS_DBG("port_id %x flags %x parms %x ret %x\n", rdata->ids.port_id, ++ rspp ? rspp->spp_flags : 0, ntohl(spp->spp_params), ret); ++ return ret; ++} ++ ++static void ft_sess_rcu_free(struct rcu_head *rcu) ++{ ++ struct ft_sess *sess = container_of(rcu, struct ft_sess, rcu); ++ ++ kfree(sess); ++} ++ ++static void ft_sess_free(struct kref *kref) ++{ ++ struct ft_sess *sess = container_of(kref, struct ft_sess, kref); ++ struct scst_session *scst_sess; ++ ++ scst_sess = sess->scst_sess; ++ FT_SESS_DBG("unregister %s\n", scst_sess->initiator_name); ++ scst_unregister_session(scst_sess, 0, NULL); ++ call_rcu(&sess->rcu, ft_sess_rcu_free); ++} ++ ++static void ft_sess_put(struct ft_sess *sess) ++{ ++ int sess_held = atomic_read(&sess->kref.refcount); ++ ++ BUG_ON(!sess_held); ++ kref_put(&sess->kref, ft_sess_free); ++} ++ ++/* ++ * Delete ft_sess for PRLO. ++ * Called with ft_lport_lock held. ++ */ ++static struct ft_sess *ft_sess_lookup_delete(struct fc_rport_priv *rdata) ++{ ++ struct ft_sess *sess; ++ struct ft_tport *tport; ++ ++ tport = rcu_dereference(rdata->local_port->prov[FC_TYPE_FCP]); ++ if (!tport) ++ return NULL; ++ sess = ft_sess_delete(tport, rdata->ids.port_id); ++ if (sess) ++ sess->params = 0; ++ return sess; ++} ++ ++/* ++ * Handle PRLO. ++ */ ++void ft_prlo(struct fc_rport_priv *rdata) ++{ ++ struct ft_sess *sess; ++ ++ mutex_lock(&ft_lport_lock); ++ sess = ft_sess_lookup_delete(rdata); ++ mutex_unlock(&ft_lport_lock); ++ if (!sess) ++ return; ++ ++ /* ++ * Release the session hold from the table. ++ * When all command-starting threads have returned, ++ * kref will call ft_sess_free which will unregister ++ * the session. ++ * fcmds referencing the session are safe. ++ */ ++ ft_sess_put(sess); /* release from table */ ++ rdata->prli_count--; ++} ++ ++/* ++ * Handle incoming FCP request. ++ * ++ * Caller has verified that the frame is type FCP. ++ * Note that this may be called directly from the softirq context. ++ */ ++void ft_recv(struct fc_lport *lport, struct fc_frame *fp) ++{ ++ struct ft_sess *sess; ++ struct fc_frame_header *fh; ++ u32 sid; ++ ++ fh = fc_frame_header_get(fp); ++ sid = ntoh24(fh->fh_s_id); ++ ++ FT_SESS_DBG("sid %x preempt %x\n", sid, preempt_count()); ++ ++ sess = ft_sess_get(lport, sid); ++ if (!sess) { ++ FT_SESS_DBG("sid %x sess lookup failed\n", sid); ++ /* TBD XXX - if FCP_CMND, send LOGO */ ++ fc_frame_free(fp); ++ return; ++ } ++ FT_SESS_DBG("sid %x sess lookup returned %p preempt %x\n", ++ sid, sess, preempt_count()); ++ ft_recv_req(sess, fp); ++ ft_sess_put(sess); ++} ++ ++/* ++ * Release all sessions for a target. ++ * Called through scst_unregister_target() as well as directly. ++ * Caller holds ft_lport_lock. ++ */ ++int ft_tgt_release(struct scst_tgt *tgt) ++{ ++ struct ft_tport *tport; ++ struct hlist_head *head; ++ struct hlist_node *pos; ++ struct ft_sess *sess; ++ ++ tport = scst_tgt_get_tgt_priv(tgt); ++ tport->enabled = 0; ++ tport->lport->service_params &= ~FCP_SPPF_TARG_FCN; ++ ++ for (head = tport->hash; head < &tport->hash[FT_SESS_HASH_SIZE]; head++) ++ hlist_for_each_entry_rcu(sess, pos, head, hash) ++ ft_sess_close(sess); ++ ++ synchronize_rcu(); ++ return 0; ++} ++ ++int ft_tgt_enable(struct scst_tgt *tgt, bool enable) ++{ ++ struct ft_tport *tport; ++ int ret = 0; ++ ++ mutex_lock(&ft_lport_lock); ++ if (enable) { ++ FT_SESS_DBG("enable tgt %s\n", tgt->tgt_name); ++ tport = scst_tgt_get_tgt_priv(tgt); ++ tport->enabled = 1; ++ tport->lport->service_params |= FCP_SPPF_TARG_FCN; ++ } else { ++ FT_SESS_DBG("disable tgt %s\n", tgt->tgt_name); ++ ft_tgt_release(tgt); ++ } ++ mutex_unlock(&ft_lport_lock); ++ return ret; ++} ++ ++bool ft_tgt_enabled(struct scst_tgt *tgt) ++{ ++ struct ft_tport *tport; ++ ++ tport = scst_tgt_get_tgt_priv(tgt); ++ return tport->enabled; ++} ++ ++int ft_tgt_detect(struct scst_tgt_template *tt) ++{ ++ return ft_tport_count; ++} ++ ++/* ++ * Report AEN (Asynchronous Event Notification) from device to initiator. ++ * See notes in scst.h. ++ */ ++int ft_report_aen(struct scst_aen *aen) ++{ ++ struct ft_sess *sess; ++ ++ sess = scst_sess_get_tgt_priv(scst_aen_get_sess(aen)); ++ FT_SESS_DBG("AEN event %d sess to %x lun %lld\n", ++ aen->event_fn, sess->port_id, scst_aen_get_lun(aen)); ++ return SCST_AEN_RES_FAILED; /* XXX TBD */ ++} +diff -uprN orig/linux-3.2/Documentation/scst/README.fcst linux-3.2/Documentation/scst/README.fcst +--- orig/linux-3.2/Documentation/scst/README.fcst ++++ linux-3.2/Documentation/scst/README.fcst +@@ -0,0 +1,114 @@ ++About fcst ++========== ++ ++The fcst kernel module implements an SCST target driver for the FCoE protocol. ++FCoE or Fibre Channel over Ethernet is a protocol that allows to communicate ++fibre channel frames over an Ethernet network. Since the FCoE protocol ++requires a lossless Ethernet network, special network adapters and switches ++are required. Ethernet network adapters that support FCoE are called ++Converged Network Adapters (CNA). The standard that makes lossless Ethernet ++communication possible is called DCB or Data Center Bridging. ++ ++Since FCoE frames are a kind of Ethernet frames, communication between FCoE ++clients and servers is limited to a single Ethernet broadcast domain. ++ ++ ++Building and Installing ++======================= ++ ++FCST is a kernel module that depends on libfc and SCST to provide FC target ++support. ++ ++To build for linux-2.6.34, do: ++ ++1. Get the kernel source: ++ ++ KERNEL=linux-2.6.34 ++ ++ cd /usr/src/kernels ++ URL_DIR=http://www.kernel.org/pub/linux/kernel/v2.6 ++ TARFILE=$KERNEL.tar.bz2 ++ wget -o $TARFILE $URL_DIR/$TARFILE ++ tar xfj $TARFILE ++ cd $KERNEL ++ ++2. Apply patches needed for libfc target hooks and point-to-point fixes: ++ ++ KDIR=/usr/src/kernels/$KERNEL ++ PDIR=/usr/src/scst/trunk/fcst/linux-patches # use your dir here ++ ++ cd $PDIR ++ for patch in `grep -v '^#' series-2.6.34` ++ do ++ (cd $KDIR; patch -p1) < $patch ++ done ++ ++3. Apply SCST patches to the kernel ++ See trunk/scst/README ++ The readahead patches are not needed in 2.6.33 or later. ++ ++4. Configure, make, and install your kernel ++ ++5. Install SCST ++ See trunk/scst/README. Make sure you are building sysfs SCST build, ++ because FCST supports only it. You need to do ++ ++ cd trunk/scst ++ make ++ make install ++ ++6. Make FCST ++ In the directory containing this README, just do ++ make ++ make install ++ ++7. Install the FCoE admin tools, including dcbd and fcoeadm. ++ Some distros may have these. ++ You should be able to use the source at ++ http://www.open-fcoe.org/openfc/downloads/2.6.34/open-fcoe-2.6.34.tar.gz ++ ++8. Bring up SCST and configure the devices. ++ ++9. Bring up an FCoE initiator (we'll enable target mode on it later): ++ modprobe fcoe ++ fcoeadm -c eth3 ++ ++ The other end can be an initiator as well, in point-to-point mode ++ over a full-duplex loss-less link (enable pause on both sides). ++ Alternatively, the other end can be an FCoE switch. ++ ++10. Use fcc (part of the open-fcoe contrib tools in step 7) to see the ++ initiator setup. To get the FCoE port name for eth3 ++ ++ # fcc ++ FC HBAs: ++ HBA Port Name Port ID State Device ++ host4 20:00:00:1b:21:06:58:21 01:01:02 Online eth3 ++ ++ host4 Remote Ports: ++ Path Port Name Port ID State Roles ++ 4:0-0 10:00:50:41:4c:4f:3b:00 01:01:01 Online FCP Initiator ++ ++ In the above example, there's one local host on eth3, and it's in ++ a point-to-point connection with the remote initiator with Port_id 010101. ++ ++11. Load fcst ++ ++ modprobe fcst ++ ++12. Add any disks (configured in step 8) you want to export ++ Note that you must have a LUN 0. ++ ++ LPORT=20:00:00:1b:21:06:58:21 # the local Port_Name ++ ++ cd /sys/kernel/scst_tgt/targets/fcst/$LPORT ++ echo add disk-name 0 > luns/mgmt ++ echo add disk-name 1 > luns/mgmt ++ ++13. Enable the initiator: ++ ++ echo 1 > $LPORT/enabled ++ ++14. As a temporary workaround, you may need to reset the interface ++ on the initiator side so it sees the SCST device as a target and ++ discovers LUNs. You can avoid this by bringing up the initiator last. +diff -uprN orig/linux-3.2/include/scst/iscsi_scst.h linux-3.2/include/scst/iscsi_scst.h +--- orig/linux-3.2/include/scst/iscsi_scst.h ++++ linux-3.2/include/scst/iscsi_scst.h +@@ -0,0 +1,226 @@ ++/* ++ * Copyright (C) 2007 - 2011 Vladislav Bolkhovitin ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#ifndef _ISCSI_SCST_U_H ++#define _ISCSI_SCST_U_H ++ ++#ifndef __KERNEL__ ++#include <sys/uio.h> ++#endif ++ ++#include "iscsi_scst_ver.h" ++#include "iscsi_scst_itf_ver.h" ++ ++/* The maximum length of 223 bytes in the RFC. */ ++#define ISCSI_NAME_LEN 256 ++ ++#define ISCSI_PORTAL_LEN 64 ++ ++/* Full name is iSCSI name + connected portal */ ++#define ISCSI_FULL_NAME_LEN (ISCSI_NAME_LEN + ISCSI_PORTAL_LEN) ++ ++#define ISCSI_LISTEN_PORT 3260 ++ ++#define SCSI_ID_LEN 24 ++ ++#ifndef aligned_u64 ++#define aligned_u64 uint64_t __attribute__((aligned(8))) ++#endif ++ ++#define ISCSI_MAX_ATTR_NAME_LEN 50 ++#define ISCSI_MAX_ATTR_VALUE_LEN 512 ++ ++enum { ++ key_initial_r2t, ++ key_immediate_data, ++ key_max_connections, ++ key_max_recv_data_length, ++ key_max_xmit_data_length, ++ key_max_burst_length, ++ key_first_burst_length, ++ key_default_wait_time, ++ key_default_retain_time, ++ key_max_outstanding_r2t, ++ key_data_pdu_inorder, ++ key_data_sequence_inorder, ++ key_error_recovery_level, ++ key_header_digest, ++ key_data_digest, ++ key_ofmarker, ++ key_ifmarker, ++ key_ofmarkint, ++ key_ifmarkint, ++ session_key_last, ++}; ++ ++enum { ++ key_queued_cmnds, ++ key_rsp_timeout, ++ key_nop_in_interval, ++ key_nop_in_timeout, ++ key_max_sessions, ++ target_key_last, ++}; ++ ++enum { ++ key_session, ++ key_target, ++}; ++ ++struct iscsi_kern_target_info { ++ u32 tid; ++ u32 cookie; ++ char name[ISCSI_NAME_LEN]; ++ u32 attrs_num; ++ aligned_u64 attrs_ptr; ++}; ++ ++struct iscsi_kern_session_info { ++ u32 tid; ++ aligned_u64 sid; ++ char initiator_name[ISCSI_NAME_LEN]; ++ char full_initiator_name[ISCSI_FULL_NAME_LEN]; ++ u32 exp_cmd_sn; ++ s32 session_params[session_key_last]; ++ s32 target_params[target_key_last]; ++}; ++ ++#define DIGEST_ALL (DIGEST_NONE | DIGEST_CRC32C) ++#define DIGEST_NONE (1 << 0) ++#define DIGEST_CRC32C (1 << 1) ++ ++struct iscsi_kern_conn_info { ++ u32 tid; ++ aligned_u64 sid; ++ ++ u32 cid; ++ u32 stat_sn; ++ u32 exp_stat_sn; ++ int fd; ++}; ++ ++struct iscsi_kern_attr { ++ u32 mode; ++ char name[ISCSI_MAX_ATTR_NAME_LEN]; ++}; ++ ++struct iscsi_kern_mgmt_cmd_res_info { ++ u32 tid; ++ u32 cookie; ++ u32 req_cmd; ++ u32 result; ++ char value[ISCSI_MAX_ATTR_VALUE_LEN]; ++}; ++ ++struct iscsi_kern_params_info { ++ u32 tid; ++ aligned_u64 sid; ++ ++ u32 params_type; ++ u32 partial; ++ ++ s32 session_params[session_key_last]; ++ s32 target_params[target_key_last]; ++}; ++ ++enum iscsi_kern_event_code { ++ E_ADD_TARGET, ++ E_DEL_TARGET, ++ E_MGMT_CMD, ++ E_ENABLE_TARGET, ++ E_DISABLE_TARGET, ++ E_GET_ATTR_VALUE, ++ E_SET_ATTR_VALUE, ++ E_CONN_CLOSE, ++}; ++ ++struct iscsi_kern_event { ++ u32 tid; ++ aligned_u64 sid; ++ u32 cid; ++ u32 code; ++ u32 cookie; ++ char target_name[ISCSI_NAME_LEN]; ++ u32 param1_size; ++ u32 param2_size; ++}; ++ ++struct iscsi_kern_register_info { ++ union { ++ aligned_u64 version; ++ struct { ++ int max_data_seg_len; ++ int max_queued_cmds; ++ }; ++ }; ++}; ++ ++struct iscsi_kern_attr_info { ++ u32 tid; ++ u32 cookie; ++ struct iscsi_kern_attr attr; ++}; ++ ++struct iscsi_kern_initiator_info { ++ u32 tid; ++ char full_initiator_name[ISCSI_FULL_NAME_LEN]; ++}; ++ ++#define DEFAULT_NR_QUEUED_CMNDS 32 ++#define MIN_NR_QUEUED_CMNDS 1 ++#define MAX_NR_QUEUED_CMNDS 256 ++ ++#define DEFAULT_RSP_TIMEOUT 90 ++#define MIN_RSP_TIMEOUT 2 ++#define MAX_RSP_TIMEOUT 65535 ++ ++#define DEFAULT_NOP_IN_INTERVAL 30 ++#define MIN_NOP_IN_INTERVAL 0 ++#define MAX_NOP_IN_INTERVAL 65535 ++ ++#define DEFAULT_NOP_IN_TIMEOUT 30 ++#define MIN_NOP_IN_TIMEOUT 2 ++#define MAX_NOP_IN_TIMEOUT 65535 ++ ++#define NETLINK_ISCSI_SCST 25 ++ ++#define REGISTER_USERD _IOWR('s', 0, struct iscsi_kern_register_info) ++#define ADD_TARGET _IOW('s', 1, struct iscsi_kern_target_info) ++#define DEL_TARGET _IOW('s', 2, struct iscsi_kern_target_info) ++#define ADD_SESSION _IOW('s', 3, struct iscsi_kern_session_info) ++#define DEL_SESSION _IOW('s', 4, struct iscsi_kern_session_info) ++#define ADD_CONN _IOW('s', 5, struct iscsi_kern_conn_info) ++#define DEL_CONN _IOW('s', 6, struct iscsi_kern_conn_info) ++#define ISCSI_PARAM_SET _IOW('s', 7, struct iscsi_kern_params_info) ++#define ISCSI_PARAM_GET _IOWR('s', 8, struct iscsi_kern_params_info) ++ ++#define ISCSI_ATTR_ADD _IOW('s', 9, struct iscsi_kern_attr_info) ++#define ISCSI_ATTR_DEL _IOW('s', 10, struct iscsi_kern_attr_info) ++#define MGMT_CMD_CALLBACK _IOW('s', 11, struct iscsi_kern_mgmt_cmd_res_info) ++ ++#define ISCSI_INITIATOR_ALLOWED _IOW('s', 12, struct iscsi_kern_initiator_info) ++ ++static inline int iscsi_is_key_internal(int key) ++{ ++ switch (key) { ++ case key_max_xmit_data_length: ++ return 1; ++ default: ++ return 0; ++ } ++} ++ ++#endif +diff -uprN orig/linux-3.2/include/scst/iscsi_scst_ver.h linux-3.2/include/scst/iscsi_scst_ver.h +--- orig/linux-3.2/include/scst/iscsi_scst_ver.h ++++ linux-3.2/include/scst/iscsi_scst_ver.h +@@ -0,0 +1,20 @@ ++/* ++ * Copyright (C) 2007 - 2011 Vladislav Bolkhovitin ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++ ++#define ISCSI_VERSION_STRING_SUFFIX ++ ++#define ISCSI_VERSION_STRING "2.2.0-pre" ISCSI_VERSION_STRING_SUFFIX +diff -uprN orig/linux-3.2/include/scst/iscsi_scst_itf_ver.h linux-3.2/include/scst/iscsi_scst_itf_ver.h +--- orig/linux-3.2/include/scst/iscsi_scst_itf_ver.h ++++ linux-3.2/include/scst/iscsi_scst_itf_ver.h +@@ -0,0 +1,3 @@ ++/* Autogenerated, don't edit */ ++ ++#define ISCSI_SCST_INTERFACE_VERSION ISCSI_VERSION_STRING "_" "6e5293bf78ac2fa099a12c932a10afb091dc7731" +diff -uprN orig/linux-3.2/drivers/scst/iscsi-scst/Makefile linux-3.2/drivers/scst/iscsi-scst/Makefile +--- orig/linux-3.2/drivers/scst/iscsi-scst/Makefile ++++ linux-3.2/drivers/scst/iscsi-scst/Makefile +@@ -0,0 +1,4 @@ ++iscsi-scst-y := iscsi.o nthread.o config.o digest.o \ ++ conn.o session.o target.o event.o param.o ++ ++obj-$(CONFIG_SCST_ISCSI) += iscsi-scst.o +diff -uprN orig/linux-3.2/drivers/scst/iscsi-scst/Kconfig linux-3.2/drivers/scst/iscsi-scst/Kconfig +--- orig/linux-3.2/drivers/scst/iscsi-scst/Kconfig ++++ linux-3.2/drivers/scst/iscsi-scst/Kconfig +@@ -0,0 +1,25 @@ ++config SCST_ISCSI ++ tristate "ISCSI Target" ++ depends on SCST && INET && LIBCRC32C ++ default SCST ++ help ++ ISCSI target driver for SCST framework. The iSCSI protocol has been ++ defined in RFC 3720. To use it you should download from ++ http://scst.sourceforge.net the user space part of it. ++ ++config SCST_ISCSI_DEBUG_DIGEST_FAILURES ++ bool "Simulate iSCSI digest failures" ++ depends on SCST_ISCSI ++ help ++ Simulates iSCSI digest failures in random places. Even when iSCSI ++ traffic is sent over a TCP connection, the 16-bit TCP checksum is too ++ weak for the requirements of a storage protocol. Furthermore, there ++ are also instances where the TCP checksum does not protect iSCSI ++ data, as when data is corrupted while being transferred on a PCI bus ++ or while in memory. The iSCSI protocol therefore defines a 32-bit CRC ++ digest on iSCSI packets in order to detect data corruption on an ++ end-to-end basis. CRCs can be used on iSCSI PDU headers and/or data. ++ Enabling this option allows to test digest failure recovery in the ++ iSCSI initiator that is talking to SCST. ++ ++ If unsure, say "N". +diff -uprN orig/linux-3.2/drivers/scst/iscsi-scst/config.c linux-3.2/drivers/scst/iscsi-scst/config.c +--- orig/linux-3.2/drivers/scst/iscsi-scst/config.c ++++ linux-3.2/drivers/scst/iscsi-scst/config.c +@@ -0,0 +1,1034 @@ ++/* ++ * Copyright (C) 2004 - 2005 FUJITA Tomonori <tomof@acm.org> ++ * Copyright (C) 2007 - 2011 Vladislav Bolkhovitin ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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. ++ * ++ * 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. ++ */ ++ ++#include <linux/module.h> ++#include "iscsi.h" ++ ++/* Protected by target_mgmt_mutex */ ++int ctr_open_state; ++ ++/* Protected by target_mgmt_mutex */ ++static LIST_HEAD(iscsi_attrs_list); ++ ++static ssize_t iscsi_version_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ TRACE_ENTRY(); ++ ++ sprintf(buf, "%s\n", ISCSI_VERSION_STRING); ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ strcat(buf, "EXTRACHECKS\n"); ++#endif ++ ++#ifdef CONFIG_SCST_TRACING ++ strcat(buf, "TRACING\n"); ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG ++ strcat(buf, "DEBUG\n"); ++#endif ++ ++#ifdef CONFIG_SCST_ISCSI_DEBUG_DIGEST_FAILURES ++ strcat(buf, "DEBUG_DIGEST_FAILURES\n"); ++#endif ++ ++ TRACE_EXIT(); ++ return strlen(buf); ++} ++ ++static struct kobj_attribute iscsi_version_attr = ++ __ATTR(version, S_IRUGO, iscsi_version_show, NULL); ++ ++static ssize_t iscsi_open_state_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ switch (ctr_open_state) { ++ case ISCSI_CTR_OPEN_STATE_CLOSED: ++ sprintf(buf, "%s\n", "closed"); ++ break; ++ case ISCSI_CTR_OPEN_STATE_OPEN: ++ sprintf(buf, "%s\n", "open"); ++ break; ++ case ISCSI_CTR_OPEN_STATE_CLOSING: ++ sprintf(buf, "%s\n", "closing"); ++ break; ++ default: ++ sprintf(buf, "%s\n", "unknown"); ++ break; ++ } ++ ++ return strlen(buf); ++} ++ ++static struct kobj_attribute iscsi_open_state_attr = ++ __ATTR(open_state, S_IRUGO, iscsi_open_state_show, NULL); ++ ++const struct attribute *iscsi_attrs[] = { ++ &iscsi_version_attr.attr, ++ &iscsi_open_state_attr.attr, ++ NULL, ++}; ++ ++/* target_mgmt_mutex supposed to be locked */ ++static int add_conn(void __user *ptr) ++{ ++ int err, rc; ++ struct iscsi_session *session; ++ struct iscsi_kern_conn_info info; ++ struct iscsi_target *target; ++ ++ TRACE_ENTRY(); ++ ++ rc = copy_from_user(&info, ptr, sizeof(info)); ++ if (rc != 0) { ++ PRINT_ERROR("Failed to copy %d user's bytes", rc); ++ err = -EFAULT; ++ goto out; ++ } ++ ++ target = target_lookup_by_id(info.tid); ++ if (target == NULL) { ++ PRINT_ERROR("Target %d not found", info.tid); ++ err = -ENOENT; ++ goto out; ++ } ++ ++ mutex_lock(&target->target_mutex); ++ ++ session = session_lookup(target, info.sid); ++ if (!session) { ++ PRINT_ERROR("Session %lld not found", ++ (long long unsigned int)info.tid); ++ err = -ENOENT; ++ goto out_unlock; ++ } ++ ++ err = __add_conn(session, &info); ++ ++out_unlock: ++ mutex_unlock(&target->target_mutex); ++ ++out: ++ TRACE_EXIT_RES(err); ++ return err; ++} ++ ++/* target_mgmt_mutex supposed to be locked */ ++static int del_conn(void __user *ptr) ++{ ++ int err, rc; ++ struct iscsi_session *session; ++ struct iscsi_kern_conn_info info; ++ struct iscsi_target *target; ++ ++ TRACE_ENTRY(); ++ ++ rc = copy_from_user(&info, ptr, sizeof(info)); ++ if (rc != 0) { ++ PRINT_ERROR("Failed to copy %d user's bytes", rc); ++ err = -EFAULT; ++ goto out; ++ } ++ ++ target = target_lookup_by_id(info.tid); ++ if (target == NULL) { ++ PRINT_ERROR("Target %d not found", info.tid); ++ err = -ENOENT; ++ goto out; ++ } ++ ++ mutex_lock(&target->target_mutex); ++ ++ session = session_lookup(target, info.sid); ++ if (!session) { ++ PRINT_ERROR("Session %llx not found", ++ (long long unsigned int)info.sid); ++ err = -ENOENT; ++ goto out_unlock; ++ } ++ ++ err = __del_conn(session, &info); ++ ++out_unlock: ++ mutex_unlock(&target->target_mutex); ++ ++out: ++ TRACE_EXIT_RES(err); ++ return err; ++} ++ ++/* target_mgmt_mutex supposed to be locked */ ++static int add_session(void __user *ptr) ++{ ++ int err, rc; ++ struct iscsi_kern_session_info *info; ++ struct iscsi_target *target; ++ ++ TRACE_ENTRY(); ++ ++ info = kzalloc(sizeof(*info), GFP_KERNEL); ++ if (info == NULL) { ++ PRINT_ERROR("Can't alloc info (size %zd)", sizeof(*info)); ++ err = -ENOMEM; ++ goto out; ++ } ++ ++ rc = copy_from_user(info, ptr, sizeof(*info)); ++ if (rc != 0) { ++ PRINT_ERROR("Failed to copy %d user's bytes", rc); ++ err = -EFAULT; ++ goto out_free; ++ } ++ ++ info->initiator_name[sizeof(info->initiator_name)-1] = '\0'; ++ info->full_initiator_name[sizeof(info->full_initiator_name)-1] = '\0'; ++ ++ target = target_lookup_by_id(info->tid); ++ if (target == NULL) { ++ PRINT_ERROR("Target %d not found", info->tid); ++ err = -ENOENT; ++ goto out_free; ++ } ++ ++ err = __add_session(target, info); ++ ++out_free: ++ kfree(info); ++ ++out: ++ TRACE_EXIT_RES(err); ++ return err; ++} ++ ++/* target_mgmt_mutex supposed to be locked */ ++static int del_session(void __user *ptr) ++{ ++ int err, rc; ++ struct iscsi_kern_session_info *info; ++ struct iscsi_target *target; ++ ++ TRACE_ENTRY(); ++ ++ info = kzalloc(sizeof(*info), GFP_KERNEL); ++ if (info == NULL) { ++ PRINT_ERROR("Can't alloc info (size %zd)", sizeof(*info)); ++ err = -ENOMEM; ++ goto out; ++ } ++ ++ rc = copy_from_user(info, ptr, sizeof(*info)); ++ if (rc != 0) { ++ PRINT_ERROR("Failed to copy %d user's bytes", rc); ++ err = -EFAULT; ++ goto out_free; ++ } ++ ++ info->initiator_name[sizeof(info->initiator_name)-1] = '\0'; ++ ++ target = target_lookup_by_id(info->tid); ++ if (target == NULL) { ++ PRINT_ERROR("Target %d not found", info->tid); ++ err = -ENOENT; ++ goto out_free; ++ } ++ ++ mutex_lock(&target->target_mutex); ++ err = __del_session(target, info->sid); ++ mutex_unlock(&target->target_mutex); ++ ++out_free: ++ kfree(info); ++ ++out: ++ TRACE_EXIT_RES(err); ++ return err; ++} ++ ++/* target_mgmt_mutex supposed to be locked */ ++static int iscsi_params_config(void __user *ptr, int set) ++{ ++ int err, rc; ++ struct iscsi_kern_params_info info; ++ struct iscsi_target *target; ++ ++ TRACE_ENTRY(); ++ ++ rc = copy_from_user(&info, ptr, sizeof(info)); ++ if (rc != 0) { ++ PRINT_ERROR("Failed to copy %d user's bytes", rc); ++ err = -EFAULT; ++ goto out; ++ } ++ ++ target = target_lookup_by_id(info.tid); ++ if (target == NULL) { ++ PRINT_ERROR("Target %d not found", info.tid); ++ err = -ENOENT; ++ goto out; ++ } ++ ++ mutex_lock(&target->target_mutex); ++ err = iscsi_params_set(target, &info, set); ++ mutex_unlock(&target->target_mutex); ++ ++ if (err < 0) ++ goto out; ++ ++ if (!set) { ++ rc = copy_to_user(ptr, &info, sizeof(info)); ++ if (rc != 0) { ++ PRINT_ERROR("Failed to copy to user %d bytes", rc); ++ err = -EFAULT; ++ goto out; ++ } ++ } ++ ++out: ++ TRACE_EXIT_RES(err); ++ return err; ++} ++ ++/* target_mgmt_mutex supposed to be locked */ ++static int iscsi_initiator_allowed(void __user *ptr) ++{ ++ int err = 0, rc; ++ struct iscsi_kern_initiator_info cinfo; ++ struct iscsi_target *target; ++ ++ TRACE_ENTRY(); ++ ++ rc = copy_from_user(&cinfo, ptr, sizeof(cinfo)); ++ if (rc != 0) { ++ PRINT_ERROR("Failed to copy %d user's bytes", rc); ++ err = -EFAULT; ++ goto out; ++ } ++ ++ cinfo.full_initiator_name[sizeof(cinfo.full_initiator_name)-1] = '\0'; ++ ++ target = target_lookup_by_id(cinfo.tid); ++ if (target == NULL) { ++ PRINT_ERROR("Target %d not found", cinfo.tid); ++ err = -ENOENT; ++ goto out; ++ } ++ ++ err = scst_initiator_has_luns(target->scst_tgt, ++ cinfo.full_initiator_name); ++ ++out: ++ TRACE_EXIT_RES(err); ++ return err; ++} ++ ++/* target_mgmt_mutex supposed to be locked */ ++static int mgmt_cmd_callback(void __user *ptr) ++{ ++ int err = 0, rc; ++ struct iscsi_kern_mgmt_cmd_res_info cinfo; ++ struct scst_sysfs_user_info *info; ++ ++ TRACE_ENTRY(); ++ ++ rc = copy_from_user(&cinfo, ptr, sizeof(cinfo)); ++ if (rc != 0) { ++ PRINT_ERROR("Failed to copy %d user's bytes", rc); ++ err = -EFAULT; ++ goto out; ++ } ++ ++ cinfo.value[sizeof(cinfo.value)-1] = '\0'; ++ ++ info = scst_sysfs_user_get_info(cinfo.cookie); ++ TRACE_DBG("cookie %u, info %p, result %d", cinfo.cookie, info, ++ cinfo.result); ++ if (info == NULL) { ++ err = -EINVAL; ++ goto out; ++ } ++ ++ info->info_status = 0; ++ ++ if (cinfo.result != 0) { ++ info->info_status = cinfo.result; ++ goto out_complete; ++ } ++ ++ switch (cinfo.req_cmd) { ++ case E_ENABLE_TARGET: ++ case E_DISABLE_TARGET: ++ { ++ struct iscsi_target *target; ++ ++ target = target_lookup_by_id(cinfo.tid); ++ if (target == NULL) { ++ PRINT_ERROR("Target %d not found", cinfo.tid); ++ err = -ENOENT; ++ goto out_status; ++ } ++ ++ target->tgt_enabled = (cinfo.req_cmd == E_ENABLE_TARGET) ? 1 : 0; ++ break; ++ } ++ ++ case E_GET_ATTR_VALUE: ++ info->data = kstrdup(cinfo.value, GFP_KERNEL); ++ if (info->data == NULL) { ++ PRINT_ERROR("Can't dublicate value %s", cinfo.value); ++ info->info_status = -ENOMEM; ++ goto out_complete; ++ } ++ break; ++ } ++ ++out_complete: ++ complete(&info->info_completion); ++ ++out: ++ TRACE_EXIT_RES(err); ++ return err; ++ ++out_status: ++ info->info_status = err; ++ goto out_complete; ++} ++ ++static ssize_t iscsi_attr_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos; ++ struct iscsi_attr *tgt_attr; ++ void *value; ++ ++ TRACE_ENTRY(); ++ ++ tgt_attr = container_of(attr, struct iscsi_attr, attr); ++ ++ pos = iscsi_sysfs_send_event( ++ (tgt_attr->target != NULL) ? tgt_attr->target->tid : 0, ++ E_GET_ATTR_VALUE, tgt_attr->name, NULL, &value); ++ ++ if (pos != 0) ++ goto out; ++ ++ pos = scnprintf(buf, SCST_SYSFS_BLOCK_SIZE, "%s\n", (char *)value); ++ ++ kfree(value); ++ ++out: ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static ssize_t iscsi_attr_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ char *buffer; ++ struct iscsi_attr *tgt_attr; ++ ++ TRACE_ENTRY(); ++ ++ buffer = kzalloc(count+1, GFP_KERNEL); ++ if (buffer == NULL) { ++ res = -ENOMEM; ++ goto out; ++ } ++ memcpy(buffer, buf, count); ++ buffer[count] = '\0'; ++ ++ tgt_attr = container_of(attr, struct iscsi_attr, attr); ++ ++ TRACE_DBG("attr %s, buffer %s", tgt_attr->attr.attr.name, buffer); ++ ++ res = iscsi_sysfs_send_event( ++ (tgt_attr->target != NULL) ? tgt_attr->target->tid : 0, ++ E_SET_ATTR_VALUE, tgt_attr->name, buffer, NULL); ++ ++ kfree(buffer); ++ ++ if (res == 0) ++ res = count; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* ++ * target_mgmt_mutex supposed to be locked. If target != 0, target_mutex ++ * supposed to be locked as well. ++ */ ++int iscsi_add_attr(struct iscsi_target *target, ++ const struct iscsi_kern_attr *attr_info) ++{ ++ int res = 0; ++ struct iscsi_attr *tgt_attr; ++ struct list_head *attrs_list; ++ const char *name; ++#ifdef CONFIG_DEBUG_LOCK_ALLOC ++ static struct lock_class_key __key; ++#endif ++ ++ TRACE_ENTRY(); ++ ++ if (target != NULL) { ++ attrs_list = &target->attrs_list; ++ name = target->name; ++ } else { ++ attrs_list = &iscsi_attrs_list; ++ name = "global"; ++ } ++ ++ list_for_each_entry(tgt_attr, attrs_list, attrs_list_entry) { ++ /* Both for sure NULL-terminated */ ++ if (strcmp(tgt_attr->name, attr_info->name) == 0) { ++ PRINT_ERROR("Attribute %s for %s already exist", ++ attr_info->name, name); ++ res = -EEXIST; ++ goto out; ++ } ++ } ++ ++ TRACE_DBG("Adding %s's attr %s with mode %x", name, ++ attr_info->name, attr_info->mode); ++ ++ tgt_attr = kzalloc(sizeof(*tgt_attr), GFP_KERNEL); ++ if (tgt_attr == NULL) { ++ PRINT_ERROR("Unable to allocate user (size %zd)", ++ sizeof(*tgt_attr)); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ tgt_attr->target = target; ++ ++ tgt_attr->name = kstrdup(attr_info->name, GFP_KERNEL); ++ if (tgt_attr->name == NULL) { ++ PRINT_ERROR("Unable to allocate attr %s name/value (target %s)", ++ attr_info->name, name); ++ res = -ENOMEM; ++ goto out_free; ++ } ++ ++ list_add(&tgt_attr->attrs_list_entry, attrs_list); ++ ++ tgt_attr->attr.attr.name = tgt_attr->name; ++#ifdef CONFIG_DEBUG_LOCK_ALLOC ++ tgt_attr->attr.attr.key = &__key; ++#endif ++ tgt_attr->attr.attr.mode = attr_info->mode & (S_IRUGO | S_IWUGO); ++ tgt_attr->attr.show = iscsi_attr_show; ++ tgt_attr->attr.store = iscsi_attr_store; ++ ++ TRACE_DBG("tgt_attr %p, attr %p", tgt_attr, &tgt_attr->attr.attr); ++ ++ res = sysfs_create_file( ++ (target != NULL) ? scst_sysfs_get_tgt_kobj(target->scst_tgt) : ++ scst_sysfs_get_tgtt_kobj(&iscsi_template), ++ &tgt_attr->attr.attr); ++ if (res != 0) { ++ PRINT_ERROR("Unable to create file '%s' for target '%s'", ++ tgt_attr->attr.attr.name, name); ++ goto out_del; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_del: ++ list_del(&tgt_attr->attrs_list_entry); ++ ++out_free: ++ kfree(tgt_attr->name); ++ kfree(tgt_attr); ++ goto out; ++} ++ ++void __iscsi_del_attr(struct iscsi_target *target, ++ struct iscsi_attr *tgt_attr) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Deleting attr %s (target %s, tgt_attr %p, attr %p)", ++ tgt_attr->name, (target != NULL) ? target->name : "global", ++ tgt_attr, &tgt_attr->attr.attr); ++ ++ list_del(&tgt_attr->attrs_list_entry); ++ ++ sysfs_remove_file((target != NULL) ? ++ scst_sysfs_get_tgt_kobj(target->scst_tgt) : ++ scst_sysfs_get_tgtt_kobj(&iscsi_template), ++ &tgt_attr->attr.attr); ++ ++ kfree(tgt_attr->name); ++ kfree(tgt_attr); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * target_mgmt_mutex supposed to be locked. If target != 0, target_mutex ++ * supposed to be locked as well. ++ */ ++static int iscsi_del_attr(struct iscsi_target *target, ++ const char *attr_name) ++{ ++ int res = 0; ++ struct iscsi_attr *tgt_attr, *a; ++ struct list_head *attrs_list; ++ ++ TRACE_ENTRY(); ++ ++ if (target != NULL) ++ attrs_list = &target->attrs_list; ++ else ++ attrs_list = &iscsi_attrs_list; ++ ++ tgt_attr = NULL; ++ list_for_each_entry(a, attrs_list, attrs_list_entry) { ++ /* Both for sure NULL-terminated */ ++ if (strcmp(a->name, attr_name) == 0) { ++ tgt_attr = a; ++ break; ++ } ++ } ++ ++ if (tgt_attr == NULL) { ++ PRINT_ERROR("attr %s not found (target %s)", attr_name, ++ (target != NULL) ? target->name : "global"); ++ res = -ENOENT; ++ goto out; ++ } ++ ++ __iscsi_del_attr(target, tgt_attr); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* target_mgmt_mutex supposed to be locked */ ++static int iscsi_attr_cmd(void __user *ptr, unsigned int cmd) ++{ ++ int rc, err = 0; ++ struct iscsi_kern_attr_info info; ++ struct iscsi_target *target; ++ struct scst_sysfs_user_info *i = NULL; ++ ++ TRACE_ENTRY(); ++ ++ rc = copy_from_user(&info, ptr, sizeof(info)); ++ if (rc != 0) { ++ PRINT_ERROR("Failed to copy %d user's bytes", rc); ++ err = -EFAULT; ++ goto out; ++ } ++ ++ info.attr.name[sizeof(info.attr.name)-1] = '\0'; ++ ++ if (info.cookie != 0) { ++ i = scst_sysfs_user_get_info(info.cookie); ++ TRACE_DBG("cookie %u, uinfo %p", info.cookie, i); ++ if (i == NULL) { ++ err = -EINVAL; ++ goto out; ++ } ++ } ++ ++ target = target_lookup_by_id(info.tid); ++ ++ if (target != NULL) ++ mutex_lock(&target->target_mutex); ++ ++ switch (cmd) { ++ case ISCSI_ATTR_ADD: ++ err = iscsi_add_attr(target, &info.attr); ++ break; ++ case ISCSI_ATTR_DEL: ++ err = iscsi_del_attr(target, info.attr.name); ++ break; ++ default: ++ BUG(); ++ } ++ ++ if (target != NULL) ++ mutex_unlock(&target->target_mutex); ++ ++ if (i != NULL) { ++ i->info_status = err; ++ complete(&i->info_completion); ++ } ++ ++out: ++ TRACE_EXIT_RES(err); ++ return err; ++} ++ ++/* target_mgmt_mutex supposed to be locked */ ++static int add_target(void __user *ptr) ++{ ++ int err, rc; ++ struct iscsi_kern_target_info *info; ++ struct scst_sysfs_user_info *uinfo; ++ ++ TRACE_ENTRY(); ++ ++ info = kzalloc(sizeof(*info), GFP_KERNEL); ++ if (info == NULL) { ++ PRINT_ERROR("Can't alloc info (size %zd)", sizeof(*info)); ++ err = -ENOMEM; ++ goto out; ++ } ++ ++ rc = copy_from_user(info, ptr, sizeof(*info)); ++ if (rc != 0) { ++ PRINT_ERROR("Failed to copy %d user's bytes", rc); ++ err = -EFAULT; ++ goto out_free; ++ } ++ ++ if (target_lookup_by_id(info->tid) != NULL) { ++ PRINT_ERROR("Target %u already exist!", info->tid); ++ err = -EEXIST; ++ goto out_free; ++ } ++ ++ info->name[sizeof(info->name)-1] = '\0'; ++ ++ if (info->cookie != 0) { ++ uinfo = scst_sysfs_user_get_info(info->cookie); ++ TRACE_DBG("cookie %u, uinfo %p", info->cookie, uinfo); ++ if (uinfo == NULL) { ++ err = -EINVAL; ++ goto out_free; ++ } ++ } else ++ uinfo = NULL; ++ ++ err = __add_target(info); ++ ++ if (uinfo != NULL) { ++ uinfo->info_status = err; ++ complete(&uinfo->info_completion); ++ } ++ ++out_free: ++ kfree(info); ++ ++out: ++ TRACE_EXIT_RES(err); ++ return err; ++} ++ ++/* target_mgmt_mutex supposed to be locked */ ++static int del_target(void __user *ptr) ++{ ++ int err, rc; ++ struct iscsi_kern_target_info info; ++ struct scst_sysfs_user_info *uinfo; ++ ++ TRACE_ENTRY(); ++ ++ rc = copy_from_user(&info, ptr, sizeof(info)); ++ if (rc != 0) { ++ PRINT_ERROR("Failed to copy %d user's bytes", rc); ++ err = -EFAULT; ++ goto out; ++ } ++ ++ info.name[sizeof(info.name)-1] = '\0'; ++ ++ if (info.cookie != 0) { ++ uinfo = scst_sysfs_user_get_info(info.cookie); ++ TRACE_DBG("cookie %u, uinfo %p", info.cookie, uinfo); ++ if (uinfo == NULL) { ++ err = -EINVAL; ++ goto out; ++ } ++ } else ++ uinfo = NULL; ++ ++ err = __del_target(info.tid); ++ ++ if (uinfo != NULL) { ++ uinfo->info_status = err; ++ complete(&uinfo->info_completion); ++ } ++ ++out: ++ TRACE_EXIT_RES(err); ++ return err; ++} ++ ++static int iscsi_register(void __user *arg) ++{ ++ struct iscsi_kern_register_info reg; ++ char ver[sizeof(ISCSI_SCST_INTERFACE_VERSION)+1]; ++ int res, rc; ++ ++ TRACE_ENTRY(); ++ ++ rc = copy_from_user(®, arg, sizeof(reg)); ++ if (rc != 0) { ++ PRINT_ERROR("%s", "Unable to get register info"); ++ res = -EFAULT; ++ goto out; ++ } ++ ++ rc = copy_from_user(ver, (void __user *)(unsigned long)reg.version, ++ sizeof(ver)); ++ if (rc != 0) { ++ PRINT_ERROR("%s", "Unable to get version string"); ++ res = -EFAULT; ++ goto out; ++ } ++ ver[sizeof(ver)-1] = '\0'; ++ ++ if (strcmp(ver, ISCSI_SCST_INTERFACE_VERSION) != 0) { ++ PRINT_ERROR("Incorrect version of user space %s (expected %s)", ++ ver, ISCSI_SCST_INTERFACE_VERSION); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ memset(®, 0, sizeof(reg)); ++ reg.max_data_seg_len = ISCSI_CONN_IOV_MAX << PAGE_SHIFT; ++ reg.max_queued_cmds = scst_get_max_lun_commands(NULL, NO_SUCH_LUN); ++ ++ res = 0; ++ ++ rc = copy_to_user(arg, ®, sizeof(reg)); ++ if (rc != 0) { ++ PRINT_ERROR("Failed to copy to user %d bytes", rc); ++ res = -EFAULT; ++ goto out; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static long ioctl(struct file *file, unsigned int cmd, unsigned long arg) ++{ ++ long err; ++ ++ TRACE_ENTRY(); ++ ++ if (cmd == REGISTER_USERD) { ++ err = iscsi_register((void __user *)arg); ++ goto out; ++ } ++ ++ err = mutex_lock_interruptible(&target_mgmt_mutex); ++ if (err < 0) ++ goto out; ++ ++ switch (cmd) { ++ case ADD_TARGET: ++ err = add_target((void __user *)arg); ++ break; ++ ++ case DEL_TARGET: ++ err = del_target((void __user *)arg); ++ break; ++ ++ case ISCSI_ATTR_ADD: ++ case ISCSI_ATTR_DEL: ++ err = iscsi_attr_cmd((void __user *)arg, cmd); ++ break; ++ ++ case MGMT_CMD_CALLBACK: ++ err = mgmt_cmd_callback((void __user *)arg); ++ break; ++ ++ case ISCSI_INITIATOR_ALLOWED: ++ err = iscsi_initiator_allowed((void __user *)arg); ++ break; ++ ++ case ADD_SESSION: ++ err = add_session((void __user *)arg); ++ break; ++ ++ case DEL_SESSION: ++ err = del_session((void __user *)arg); ++ break; ++ ++ case ISCSI_PARAM_SET: ++ err = iscsi_params_config((void __user *)arg, 1); ++ break; ++ ++ case ISCSI_PARAM_GET: ++ err = iscsi_params_config((void __user *)arg, 0); ++ break; ++ ++ case ADD_CONN: ++ err = add_conn((void __user *)arg); ++ break; ++ ++ case DEL_CONN: ++ err = del_conn((void __user *)arg); ++ break; ++ ++ default: ++ PRINT_ERROR("Invalid ioctl cmd %x", cmd); ++ err = -EINVAL; ++ goto out_unlock; ++ } ++ ++out_unlock: ++ mutex_unlock(&target_mgmt_mutex); ++ ++out: ++ TRACE_EXIT_RES(err); ++ return err; ++} ++ ++static int open(struct inode *inode, struct file *file) ++{ ++ bool already; ++ ++ mutex_lock(&target_mgmt_mutex); ++ already = (ctr_open_state != ISCSI_CTR_OPEN_STATE_CLOSED); ++ if (!already) ++ ctr_open_state = ISCSI_CTR_OPEN_STATE_OPEN; ++ mutex_unlock(&target_mgmt_mutex); ++ ++ if (already) { ++ PRINT_WARNING("%s", "Attempt to second open the control " ++ "device!"); ++ return -EBUSY; ++ } else ++ return 0; ++} ++ ++static int release(struct inode *inode, struct file *filp) ++{ ++ struct iscsi_attr *attr, *t; ++ ++ TRACE(TRACE_MGMT, "%s", "Releasing allocated resources"); ++ ++ mutex_lock(&target_mgmt_mutex); ++ ctr_open_state = ISCSI_CTR_OPEN_STATE_CLOSING; ++ mutex_unlock(&target_mgmt_mutex); ++ ++ target_del_all(); ++ ++ mutex_lock(&target_mgmt_mutex); ++ ++ list_for_each_entry_safe(attr, t, &iscsi_attrs_list, ++ attrs_list_entry) { ++ __iscsi_del_attr(NULL, attr); ++ } ++ ++ ctr_open_state = ISCSI_CTR_OPEN_STATE_CLOSED; ++ ++ mutex_unlock(&target_mgmt_mutex); ++ ++ return 0; ++} ++ ++const struct file_operations ctr_fops = { ++ .owner = THIS_MODULE, ++ .unlocked_ioctl = ioctl, ++ .compat_ioctl = ioctl, ++ .open = open, ++ .release = release, ++}; ++ ++#ifdef CONFIG_SCST_DEBUG ++static void iscsi_dump_char(int ch, unsigned char *text, int *pos) ++{ ++ int i = *pos; ++ ++ if (ch < 0) { ++ while ((i % 16) != 0) { ++ printk(KERN_CONT " "); ++ text[i] = ' '; ++ i++; ++ if ((i % 16) == 0) ++ printk(KERN_CONT " | %.16s |\n", text); ++ else if ((i % 4) == 0) ++ printk(KERN_CONT " |"); ++ } ++ i = 0; ++ goto out; ++ } ++ ++ text[i] = (ch < 0x20 || (ch >= 0x80 && ch <= 0xa0)) ? ' ' : ch; ++ printk(KERN_CONT " %02x", ch); ++ i++; ++ if ((i % 16) == 0) { ++ printk(KERN_CONT " | %.16s |\n", text); ++ i = 0; ++ } else if ((i % 4) == 0) ++ printk(KERN_CONT " |"); ++ ++out: ++ *pos = i; ++ return; ++} ++ ++void iscsi_dump_pdu(struct iscsi_pdu *pdu) ++{ ++ unsigned char text[16]; ++ int pos = 0; ++ ++ if (trace_flag & TRACE_D_DUMP_PDU) { ++ unsigned char *buf; ++ int i; ++ ++ buf = (void *)&pdu->bhs; ++ printk(KERN_DEBUG "BHS: (%p,%zd)\n", buf, sizeof(pdu->bhs)); ++ for (i = 0; i < (int)sizeof(pdu->bhs); i++) ++ iscsi_dump_char(*buf++, text, &pos); ++ iscsi_dump_char(-1, text, &pos); ++ ++ buf = (void *)pdu->ahs; ++ printk(KERN_DEBUG "AHS: (%p,%d)\n", buf, pdu->ahssize); ++ for (i = 0; i < pdu->ahssize; i++) ++ iscsi_dump_char(*buf++, text, &pos); ++ iscsi_dump_char(-1, text, &pos); ++ ++ printk(KERN_DEBUG "Data: (%d)\n", pdu->datasize); ++ } ++} ++ ++unsigned long iscsi_get_flow_ctrl_or_mgmt_dbg_log_flag(struct iscsi_cmnd *cmnd) ++{ ++ unsigned long flag; ++ ++ if (cmnd->cmd_req != NULL) ++ cmnd = cmnd->cmd_req; ++ ++ if (cmnd->scst_cmd == NULL) ++ flag = TRACE_MGMT_DEBUG; ++ else { ++ int status = scst_cmd_get_status(cmnd->scst_cmd); ++ if ((status == SAM_STAT_TASK_SET_FULL) || ++ (status == SAM_STAT_BUSY)) ++ flag = TRACE_FLOW_CONTROL; ++ else ++ flag = TRACE_MGMT_DEBUG; ++ } ++ return flag; ++} ++ ++#endif /* CONFIG_SCST_DEBUG */ +diff -uprN orig/linux-3.2/drivers/scst/iscsi-scst/conn.c linux-3.2/drivers/scst/iscsi-scst/conn.c +--- orig/linux-3.2/drivers/scst/iscsi-scst/conn.c ++++ linux-3.2/drivers/scst/iscsi-scst/conn.c +@@ -0,0 +1,945 @@ ++/* ++ * Copyright (C) 2002 - 2003 Ardis Technolgies <roman@ardistech.com> ++ * Copyright (C) 2007 - 2011 Vladislav Bolkhovitin ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/file.h> ++#include <linux/ip.h> ++#include <net/tcp.h> ++ ++#include "iscsi.h" ++#include "digest.h" ++ ++static int print_conn_state(char *p, size_t size, struct iscsi_conn *conn) ++{ ++ int pos = 0; ++ ++ if (conn->closing) { ++ pos += scnprintf(p, size, "%s", "closing"); ++ goto out; ++ } ++ ++ switch (conn->rd_state) { ++ case ISCSI_CONN_RD_STATE_PROCESSING: ++ pos += scnprintf(&p[pos], size - pos, "%s", "read_processing "); ++ break; ++ case ISCSI_CONN_RD_STATE_IN_LIST: ++ pos += scnprintf(&p[pos], size - pos, "%s", "in_read_list "); ++ break; ++ } ++ ++ switch (conn->wr_state) { ++ case ISCSI_CONN_WR_STATE_PROCESSING: ++ pos += scnprintf(&p[pos], size - pos, "%s", "write_processing "); ++ break; ++ case ISCSI_CONN_WR_STATE_IN_LIST: ++ pos += scnprintf(&p[pos], size - pos, "%s", "in_write_list "); ++ break; ++ case ISCSI_CONN_WR_STATE_SPACE_WAIT: ++ pos += scnprintf(&p[pos], size - pos, "%s", "space_waiting "); ++ break; ++ } ++ ++ if (test_bit(ISCSI_CONN_REINSTATING, &conn->conn_aflags)) ++ pos += scnprintf(&p[pos], size - pos, "%s", "reinstating "); ++ else if (pos == 0) ++ pos += scnprintf(&p[pos], size - pos, "%s", "established idle "); ++ ++out: ++ return pos; ++} ++ ++static void iscsi_conn_release(struct kobject *kobj) ++{ ++ struct iscsi_conn *conn; ++ ++ TRACE_ENTRY(); ++ ++ conn = container_of(kobj, struct iscsi_conn, conn_kobj); ++ if (conn->conn_kobj_release_cmpl != NULL) ++ complete_all(conn->conn_kobj_release_cmpl); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++struct kobj_type iscsi_conn_ktype = { ++ .release = iscsi_conn_release, ++}; ++ ++static ssize_t iscsi_get_initiator_ip(struct iscsi_conn *conn, ++ char *buf, int size) ++{ ++ int pos; ++ struct sock *sk; ++ ++ TRACE_ENTRY(); ++ ++ sk = conn->sock->sk; ++ switch (sk->sk_family) { ++ case AF_INET: ++ pos = scnprintf(buf, size, ++ "%pI4", &inet_sk(sk)->inet_daddr); ++ break; ++ case AF_INET6: ++ pos = scnprintf(buf, size, "[%p6]", ++ &inet6_sk(sk)->daddr); ++ break; ++ default: ++ pos = scnprintf(buf, size, "Unknown family %d", ++ sk->sk_family); ++ break; ++ } ++ ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static ssize_t iscsi_conn_ip_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos; ++ struct iscsi_conn *conn; ++ ++ TRACE_ENTRY(); ++ ++ conn = container_of(kobj, struct iscsi_conn, conn_kobj); ++ ++ pos = iscsi_get_initiator_ip(conn, buf, SCST_SYSFS_BLOCK_SIZE); ++ ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static struct kobj_attribute iscsi_conn_ip_attr = ++ __ATTR(ip, S_IRUGO, iscsi_conn_ip_show, NULL); ++ ++static ssize_t iscsi_conn_cid_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos; ++ struct iscsi_conn *conn; ++ ++ TRACE_ENTRY(); ++ ++ conn = container_of(kobj, struct iscsi_conn, conn_kobj); ++ ++ pos = sprintf(buf, "%u", conn->cid); ++ ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static struct kobj_attribute iscsi_conn_cid_attr = ++ __ATTR(cid, S_IRUGO, iscsi_conn_cid_show, NULL); ++ ++static ssize_t iscsi_conn_state_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos; ++ struct iscsi_conn *conn; ++ ++ TRACE_ENTRY(); ++ ++ conn = container_of(kobj, struct iscsi_conn, conn_kobj); ++ ++ pos = print_conn_state(buf, SCST_SYSFS_BLOCK_SIZE, conn); ++ ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static struct kobj_attribute iscsi_conn_state_attr = ++ __ATTR(state, S_IRUGO, iscsi_conn_state_show, NULL); ++ ++static void conn_sysfs_del(struct iscsi_conn *conn) ++{ ++ int rc; ++ DECLARE_COMPLETION_ONSTACK(c); ++ ++ TRACE_ENTRY(); ++ ++ conn->conn_kobj_release_cmpl = &c; ++ ++ kobject_del(&conn->conn_kobj); ++ kobject_put(&conn->conn_kobj); ++ ++ rc = wait_for_completion_timeout(conn->conn_kobj_release_cmpl, HZ); ++ if (rc == 0) { ++ PRINT_INFO("Waiting for releasing sysfs entry " ++ "for conn %p (%d refs)...", conn, ++ atomic_read(&conn->conn_kobj.kref.refcount)); ++ wait_for_completion(conn->conn_kobj_release_cmpl); ++ PRINT_INFO("Done waiting for releasing sysfs " ++ "entry for conn %p", conn); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int conn_sysfs_add(struct iscsi_conn *conn) ++{ ++ int res; ++ struct iscsi_session *session = conn->session; ++ struct iscsi_conn *c; ++ int n = 1; ++ char addr[64]; ++ ++ TRACE_ENTRY(); ++ ++ iscsi_get_initiator_ip(conn, addr, sizeof(addr)); ++ ++restart: ++ list_for_each_entry(c, &session->conn_list, conn_list_entry) { ++ if (strcmp(addr, kobject_name(&conn->conn_kobj)) == 0) { ++ char c_addr[64]; ++ ++ iscsi_get_initiator_ip(conn, c_addr, sizeof(c_addr)); ++ ++ TRACE_DBG("Duplicated conn from the same initiator " ++ "%s found", c_addr); ++ ++ snprintf(addr, sizeof(addr), "%s_%d", c_addr, n); ++ n++; ++ goto restart; ++ } ++ } ++ ++ res = kobject_init_and_add(&conn->conn_kobj, &iscsi_conn_ktype, ++ scst_sysfs_get_sess_kobj(session->scst_sess), addr); ++ if (res != 0) { ++ PRINT_ERROR("Unable create sysfs entries for conn %s", ++ addr); ++ goto out; ++ } ++ ++ TRACE_DBG("conn %p, conn_kobj %p", conn, &conn->conn_kobj); ++ ++ res = sysfs_create_file(&conn->conn_kobj, ++ &iscsi_conn_state_attr.attr); ++ if (res != 0) { ++ PRINT_ERROR("Unable create sysfs attribute %s for conn %s", ++ iscsi_conn_state_attr.attr.name, addr); ++ goto out_err; ++ } ++ ++ res = sysfs_create_file(&conn->conn_kobj, ++ &iscsi_conn_cid_attr.attr); ++ if (res != 0) { ++ PRINT_ERROR("Unable create sysfs attribute %s for conn %s", ++ iscsi_conn_cid_attr.attr.name, addr); ++ goto out_err; ++ } ++ ++ res = sysfs_create_file(&conn->conn_kobj, ++ &iscsi_conn_ip_attr.attr); ++ if (res != 0) { ++ PRINT_ERROR("Unable create sysfs attribute %s for conn %s", ++ iscsi_conn_ip_attr.attr.name, addr); ++ goto out_err; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_err: ++ conn_sysfs_del(conn); ++ goto out; ++} ++ ++/* target_mutex supposed to be locked */ ++struct iscsi_conn *conn_lookup(struct iscsi_session *session, u16 cid) ++{ ++ struct iscsi_conn *conn; ++ ++ /* ++ * We need to find the latest conn to correctly handle ++ * multi-reinstatements ++ */ ++ list_for_each_entry_reverse(conn, &session->conn_list, ++ conn_list_entry) { ++ if (conn->cid == cid) ++ return conn; ++ } ++ return NULL; ++} ++ ++void iscsi_make_conn_rd_active(struct iscsi_conn *conn) ++{ ++ struct iscsi_thread_pool *p = conn->conn_thr_pool; ++ ++ TRACE_ENTRY(); ++ ++ spin_lock_bh(&p->rd_lock); ++ ++ TRACE_DBG("conn %p, rd_state %x, rd_data_ready %d", conn, ++ conn->rd_state, conn->rd_data_ready); ++ ++ /* ++ * Let's start processing ASAP not waiting for all the being waited ++ * data be received, even if we need several wakup iteration to receive ++ * them all, because starting ASAP, i.e. in parallel, is better for ++ * performance, especially on multi-CPU/core systems. ++ */ ++ ++ conn->rd_data_ready = 1; ++ ++ if (conn->rd_state == ISCSI_CONN_RD_STATE_IDLE) { ++ list_add_tail(&conn->rd_list_entry, &p->rd_list); ++ conn->rd_state = ISCSI_CONN_RD_STATE_IN_LIST; ++ wake_up(&p->rd_waitQ); ++ } ++ ++ spin_unlock_bh(&p->rd_lock); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++void iscsi_make_conn_wr_active(struct iscsi_conn *conn) ++{ ++ struct iscsi_thread_pool *p = conn->conn_thr_pool; ++ ++ TRACE_ENTRY(); ++ ++ spin_lock_bh(&p->wr_lock); ++ ++ TRACE_DBG("conn %p, wr_state %x, wr_space_ready %d", conn, ++ conn->wr_state, conn->wr_space_ready); ++ ++ /* ++ * Let's start sending waiting to be sent data ASAP, even if there's ++ * still not all the needed buffers ready and we need several wakup ++ * iteration to send them all, because starting ASAP, i.e. in parallel, ++ * is better for performance, especially on multi-CPU/core systems. ++ */ ++ ++ if (conn->wr_state == ISCSI_CONN_WR_STATE_IDLE) { ++ list_add_tail(&conn->wr_list_entry, &p->wr_list); ++ conn->wr_state = ISCSI_CONN_WR_STATE_IN_LIST; ++ wake_up(&p->wr_waitQ); ++ } ++ ++ spin_unlock_bh(&p->wr_lock); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++void __mark_conn_closed(struct iscsi_conn *conn, int flags) ++{ ++ spin_lock_bh(&conn->conn_thr_pool->rd_lock); ++ conn->closing = 1; ++ if (flags & ISCSI_CONN_ACTIVE_CLOSE) ++ conn->active_close = 1; ++ if (flags & ISCSI_CONN_DELETING) ++ conn->deleting = 1; ++ spin_unlock_bh(&conn->conn_thr_pool->rd_lock); ++ ++ iscsi_make_conn_rd_active(conn); ++} ++ ++void mark_conn_closed(struct iscsi_conn *conn) ++{ ++ __mark_conn_closed(conn, ISCSI_CONN_ACTIVE_CLOSE); ++} ++ ++static void __iscsi_state_change(struct sock *sk) ++{ ++ struct iscsi_conn *conn = sk->sk_user_data; ++ ++ TRACE_ENTRY(); ++ ++ if (unlikely(sk->sk_state != TCP_ESTABLISHED)) { ++ if (!conn->closing) { ++ PRINT_ERROR("Connection with initiator %s " ++ "unexpectedly closed!", ++ conn->session->initiator_name); ++ TRACE_MGMT_DBG("conn %p, sk state %d", conn, ++ sk->sk_state); ++ __mark_conn_closed(conn, 0); ++ } ++ } else ++ iscsi_make_conn_rd_active(conn); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void iscsi_state_change(struct sock *sk) ++{ ++ struct iscsi_conn *conn = sk->sk_user_data; ++ ++ __iscsi_state_change(sk); ++ conn->old_state_change(sk); ++ ++ return; ++} ++ ++static void iscsi_data_ready(struct sock *sk, int len) ++{ ++ struct iscsi_conn *conn = sk->sk_user_data; ++ ++ TRACE_ENTRY(); ++ ++ iscsi_make_conn_rd_active(conn); ++ ++ conn->old_data_ready(sk, len); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++void __iscsi_write_space_ready(struct iscsi_conn *conn) ++{ ++ struct iscsi_thread_pool *p = conn->conn_thr_pool; ++ ++ TRACE_ENTRY(); ++ ++ spin_lock_bh(&p->wr_lock); ++ conn->wr_space_ready = 1; ++ if ((conn->wr_state == ISCSI_CONN_WR_STATE_SPACE_WAIT)) { ++ TRACE_DBG("wr space ready (conn %p)", conn); ++ list_add_tail(&conn->wr_list_entry, &p->wr_list); ++ conn->wr_state = ISCSI_CONN_WR_STATE_IN_LIST; ++ wake_up(&p->wr_waitQ); ++ } ++ spin_unlock_bh(&p->wr_lock); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void iscsi_write_space_ready(struct sock *sk) ++{ ++ struct iscsi_conn *conn = sk->sk_user_data; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Write space ready for conn %p", conn); ++ ++ __iscsi_write_space_ready(conn); ++ ++ conn->old_write_space(sk); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void conn_rsp_timer_fn(unsigned long arg) ++{ ++ struct iscsi_conn *conn = (struct iscsi_conn *)arg; ++ struct iscsi_cmnd *cmnd; ++ unsigned long j = jiffies; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Timer (conn %p)", conn); ++ ++ spin_lock_bh(&conn->write_list_lock); ++ ++ if (!list_empty(&conn->write_timeout_list)) { ++ unsigned long timeout_time; ++ cmnd = list_entry(conn->write_timeout_list.next, ++ struct iscsi_cmnd, write_timeout_list_entry); ++ ++ timeout_time = j + iscsi_get_timeout(cmnd) + ISCSI_ADD_SCHED_TIME; ++ ++ if (unlikely(time_after_eq(j, iscsi_get_timeout_time(cmnd)))) { ++ if (!conn->closing) { ++ PRINT_ERROR("Timeout %ld sec sending data/waiting " ++ "for reply to/from initiator " ++ "%s (SID %llx), closing connection", ++ iscsi_get_timeout(cmnd)/HZ, ++ conn->session->initiator_name, ++ (long long unsigned int) ++ conn->session->sid); ++ /* ++ * We must call mark_conn_closed() outside of ++ * write_list_lock or we will have a circular ++ * locking dependency with rd_lock. ++ */ ++ spin_unlock_bh(&conn->write_list_lock); ++ mark_conn_closed(conn); ++ goto out; ++ } ++ } else if (!timer_pending(&conn->rsp_timer) || ++ time_after(conn->rsp_timer.expires, timeout_time)) { ++ TRACE_DBG("Restarting timer on %ld (conn %p)", ++ timeout_time, conn); ++ /* ++ * Timer might have been restarted while we were ++ * entering here. ++ * ++ * Since we have not empty write_timeout_list, we are ++ * safe to restart the timer, because we not race with ++ * del_timer_sync() in conn_free(). ++ */ ++ mod_timer(&conn->rsp_timer, timeout_time); ++ } ++ } ++ ++ spin_unlock_bh(&conn->write_list_lock); ++ ++ if (unlikely(conn->conn_tm_active)) { ++ TRACE_MGMT_DBG("TM active: making conn %p RD active", conn); ++ iscsi_make_conn_rd_active(conn); ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static void conn_nop_in_delayed_work_fn(struct delayed_work *work) ++{ ++ struct iscsi_conn *conn = container_of(work, struct iscsi_conn, ++ nop_in_delayed_work); ++ ++ TRACE_ENTRY(); ++ ++ if (time_after_eq(jiffies, conn->last_rcv_time + ++ conn->nop_in_interval)) { ++ iscsi_send_nop_in(conn); ++ } ++ ++ if ((conn->nop_in_interval > 0) && ++ !test_bit(ISCSI_CONN_SHUTTINGDOWN, &conn->conn_aflags)) { ++ TRACE_DBG("Reschedule Nop-In work for conn %p", conn); ++ schedule_delayed_work(&conn->nop_in_delayed_work, ++ conn->nop_in_interval + ISCSI_ADD_SCHED_TIME); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Must be called from rd thread only */ ++void iscsi_check_tm_data_wait_timeouts(struct iscsi_conn *conn, bool force) ++{ ++ struct iscsi_cmnd *cmnd; ++ unsigned long j = jiffies; ++ bool aborted_cmds_pending; ++ unsigned long timeout_time = j + ISCSI_TM_DATA_WAIT_TIMEOUT + ++ ISCSI_ADD_SCHED_TIME; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG_FLAG(TRACE_MGMT_DEBUG, "conn %p, read_cmnd %p, read_state " ++ "%d, j %ld (TIMEOUT %d, force %d)", conn, conn->read_cmnd, ++ conn->read_state, j, ++ ISCSI_TM_DATA_WAIT_TIMEOUT + ISCSI_ADD_SCHED_TIME, force); ++ ++ iscsi_extracheck_is_rd_thread(conn); ++ ++again: ++ spin_lock_bh(&conn->conn_thr_pool->rd_lock); ++ spin_lock(&conn->write_list_lock); ++ ++ aborted_cmds_pending = false; ++ list_for_each_entry(cmnd, &conn->write_timeout_list, ++ write_timeout_list_entry) { ++ /* ++ * This should not happen, because DATA OUT commands can't get ++ * into write_timeout_list. ++ */ ++ BUG_ON(cmnd->cmd_req != NULL); ++ ++ if (test_bit(ISCSI_CMD_ABORTED, &cmnd->prelim_compl_flags)) { ++ TRACE_MGMT_DBG("Checking aborted cmnd %p (scst_state " ++ "%d, on_write_timeout_list %d, write_start " ++ "%ld, r2t_len_to_receive %d)", cmnd, ++ cmnd->scst_state, cmnd->on_write_timeout_list, ++ cmnd->write_start, cmnd->r2t_len_to_receive); ++ if ((cmnd == conn->read_cmnd) || ++ cmnd->data_out_in_data_receiving) { ++ BUG_ON((cmnd == conn->read_cmnd) && force); ++ /* ++ * We can't abort command waiting for data from ++ * the net, because otherwise we are risking to ++ * get out of sync with the sender, so we have ++ * to wait until the timeout timer gets into the ++ * action and close this connection. ++ */ ++ TRACE_MGMT_DBG("Aborted cmnd %p is %s, " ++ "keep waiting", cmnd, ++ (cmnd == conn->read_cmnd) ? "RX cmnd" : ++ "waiting for DATA OUT data"); ++ goto cont; ++ } ++ if ((cmnd->r2t_len_to_receive != 0) && ++ (time_after_eq(j, cmnd->write_start + ISCSI_TM_DATA_WAIT_TIMEOUT) || ++ force)) { ++ spin_unlock(&conn->write_list_lock); ++ spin_unlock_bh(&conn->conn_thr_pool->rd_lock); ++ iscsi_fail_data_waiting_cmnd(cmnd); ++ goto again; ++ } ++cont: ++ aborted_cmds_pending = true; ++ } ++ } ++ ++ if (aborted_cmds_pending) { ++ if (!force && ++ (!timer_pending(&conn->rsp_timer) || ++ time_after(conn->rsp_timer.expires, timeout_time))) { ++ TRACE_MGMT_DBG("Mod timer on %ld (conn %p)", ++ timeout_time, conn); ++ mod_timer(&conn->rsp_timer, timeout_time); ++ } ++ } else { ++ TRACE_MGMT_DBG("Clearing conn_tm_active for conn %p", conn); ++ conn->conn_tm_active = 0; ++ } ++ ++ spin_unlock(&conn->write_list_lock); ++ spin_unlock_bh(&conn->conn_thr_pool->rd_lock); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* target_mutex supposed to be locked */ ++void conn_reinst_finished(struct iscsi_conn *conn) ++{ ++ struct iscsi_cmnd *cmnd, *t; ++ ++ TRACE_ENTRY(); ++ ++ clear_bit(ISCSI_CONN_REINSTATING, &conn->conn_aflags); ++ ++ list_for_each_entry_safe(cmnd, t, &conn->reinst_pending_cmd_list, ++ reinst_pending_cmd_list_entry) { ++ TRACE_MGMT_DBG("Restarting reinst pending cmnd %p", ++ cmnd); ++ ++ list_del(&cmnd->reinst_pending_cmd_list_entry); ++ ++ /* Restore the state for preliminary completion/cmnd_done() */ ++ cmnd->scst_state = ISCSI_CMD_STATE_AFTER_PREPROC; ++ ++ iscsi_restart_cmnd(cmnd); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void conn_activate(struct iscsi_conn *conn) ++{ ++ TRACE_MGMT_DBG("Enabling conn %p", conn); ++ ++ /* Catch double bind */ ++ BUG_ON(conn->sock->sk->sk_state_change == iscsi_state_change); ++ ++ write_lock_bh(&conn->sock->sk->sk_callback_lock); ++ ++ conn->old_state_change = conn->sock->sk->sk_state_change; ++ conn->sock->sk->sk_state_change = iscsi_state_change; ++ ++ conn->old_data_ready = conn->sock->sk->sk_data_ready; ++ conn->sock->sk->sk_data_ready = iscsi_data_ready; ++ ++ conn->old_write_space = conn->sock->sk->sk_write_space; ++ conn->sock->sk->sk_write_space = iscsi_write_space_ready; ++ ++ write_unlock_bh(&conn->sock->sk->sk_callback_lock); ++ ++ /* ++ * Check, if conn was closed while we were initializing it. ++ * This function will make conn rd_active, if necessary. ++ */ ++ __iscsi_state_change(conn->sock->sk); ++ ++ return; ++} ++ ++/* ++ * Note: the code below passes a kernel space pointer (&opt) to setsockopt() ++ * while the declaration of setsockopt specifies that it expects a user space ++ * pointer. This seems to work fine, and this approach is also used in some ++ * other parts of the Linux kernel (see e.g. fs/ocfs2/cluster/tcp.c). ++ */ ++static int conn_setup_sock(struct iscsi_conn *conn) ++{ ++ int res = 0; ++ int opt = 1; ++ mm_segment_t oldfs; ++ struct iscsi_session *session = conn->session; ++ ++ TRACE_DBG("%llx", (long long unsigned int)session->sid); ++ ++ conn->sock = SOCKET_I(conn->file->f_dentry->d_inode); ++ ++ if (conn->sock->ops->sendpage == NULL) { ++ PRINT_ERROR("Socket for sid %llx doesn't support sendpage()", ++ (long long unsigned int)session->sid); ++ res = -EINVAL; ++ goto out; ++ } ++ ++#if 0 ++ conn->sock->sk->sk_allocation = GFP_NOIO; ++#endif ++ conn->sock->sk->sk_user_data = conn; ++ ++ oldfs = get_fs(); ++ set_fs(get_ds()); ++ conn->sock->ops->setsockopt(conn->sock, SOL_TCP, TCP_NODELAY, ++ (void __force __user *)&opt, sizeof(opt)); ++ set_fs(oldfs); ++ ++out: ++ return res; ++} ++ ++/* target_mutex supposed to be locked */ ++int conn_free(struct iscsi_conn *conn) ++{ ++ struct iscsi_session *session = conn->session; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Freeing conn %p (sess=%p, %#Lx %u)", conn, ++ session, (long long unsigned int)session->sid, conn->cid); ++ ++ del_timer_sync(&conn->rsp_timer); ++ ++ conn_sysfs_del(conn); ++ ++ BUG_ON(atomic_read(&conn->conn_ref_cnt) != 0); ++ BUG_ON(!list_empty(&conn->cmd_list)); ++ BUG_ON(!list_empty(&conn->write_list)); ++ BUG_ON(!list_empty(&conn->write_timeout_list)); ++ BUG_ON(conn->conn_reinst_successor != NULL); ++ BUG_ON(!test_bit(ISCSI_CONN_SHUTTINGDOWN, &conn->conn_aflags)); ++ ++ /* Just in case if new conn gets freed before the old one */ ++ if (test_bit(ISCSI_CONN_REINSTATING, &conn->conn_aflags)) { ++ struct iscsi_conn *c; ++ TRACE_MGMT_DBG("Freeing being reinstated conn %p", conn); ++ list_for_each_entry(c, &session->conn_list, ++ conn_list_entry) { ++ if (c->conn_reinst_successor == conn) { ++ c->conn_reinst_successor = NULL; ++ break; ++ } ++ } ++ } ++ ++ list_del(&conn->conn_list_entry); ++ ++ fput(conn->file); ++ conn->file = NULL; ++ conn->sock = NULL; ++ ++ free_page((unsigned long)conn->read_iov); ++ ++ kfree(conn); ++ ++ if (list_empty(&session->conn_list)) { ++ BUG_ON(session->sess_reinst_successor != NULL); ++ session_free(session, true); ++ } ++ ++ return 0; ++} ++ ++/* target_mutex supposed to be locked */ ++static int iscsi_conn_alloc(struct iscsi_session *session, ++ struct iscsi_kern_conn_info *info, struct iscsi_conn **new_conn) ++{ ++ struct iscsi_conn *conn; ++ int res = 0; ++ ++ conn = kzalloc(sizeof(*conn), GFP_KERNEL); ++ if (!conn) { ++ res = -ENOMEM; ++ goto out_err; ++ } ++ ++ TRACE_MGMT_DBG("Creating connection %p for sid %#Lx, cid %u", conn, ++ (long long unsigned int)session->sid, info->cid); ++ ++ /* Changing it, change ISCSI_CONN_IOV_MAX as well !! */ ++ conn->read_iov = (struct iovec *)get_zeroed_page(GFP_KERNEL); ++ if (conn->read_iov == NULL) { ++ res = -ENOMEM; ++ goto out_err_free_conn; ++ } ++ ++ atomic_set(&conn->conn_ref_cnt, 0); ++ conn->session = session; ++ if (session->sess_reinstating) ++ __set_bit(ISCSI_CONN_REINSTATING, &conn->conn_aflags); ++ conn->cid = info->cid; ++ conn->stat_sn = info->stat_sn; ++ conn->exp_stat_sn = info->exp_stat_sn; ++ conn->rd_state = ISCSI_CONN_RD_STATE_IDLE; ++ conn->wr_state = ISCSI_CONN_WR_STATE_IDLE; ++ ++ conn->hdigest_type = session->sess_params.header_digest; ++ conn->ddigest_type = session->sess_params.data_digest; ++ res = digest_init(conn); ++ if (res != 0) ++ goto out_free_iov; ++ ++ conn->target = session->target; ++ spin_lock_init(&conn->cmd_list_lock); ++ INIT_LIST_HEAD(&conn->cmd_list); ++ spin_lock_init(&conn->write_list_lock); ++ INIT_LIST_HEAD(&conn->write_list); ++ INIT_LIST_HEAD(&conn->write_timeout_list); ++ setup_timer(&conn->rsp_timer, conn_rsp_timer_fn, (unsigned long)conn); ++ init_waitqueue_head(&conn->read_state_waitQ); ++ init_completion(&conn->ready_to_free); ++ INIT_LIST_HEAD(&conn->reinst_pending_cmd_list); ++ INIT_LIST_HEAD(&conn->nop_req_list); ++ spin_lock_init(&conn->nop_req_list_lock); ++ ++ conn->conn_thr_pool = session->sess_thr_pool; ++ ++ conn->nop_in_ttt = 0; ++ INIT_DELAYED_WORK(&conn->nop_in_delayed_work, ++ (void (*)(struct work_struct *))conn_nop_in_delayed_work_fn); ++ conn->last_rcv_time = jiffies; ++ conn->data_rsp_timeout = session->tgt_params.rsp_timeout * HZ; ++ conn->nop_in_interval = session->tgt_params.nop_in_interval * HZ; ++ conn->nop_in_timeout = session->tgt_params.nop_in_timeout * HZ; ++ if (conn->nop_in_interval > 0) { ++ TRACE_DBG("Schedule Nop-In work for conn %p", conn); ++ schedule_delayed_work(&conn->nop_in_delayed_work, ++ conn->nop_in_interval + ISCSI_ADD_SCHED_TIME); ++ } ++ ++ conn->file = fget(info->fd); ++ ++ res = conn_setup_sock(conn); ++ if (res != 0) ++ goto out_fput; ++ ++ res = conn_sysfs_add(conn); ++ if (res != 0) ++ goto out_fput; ++ ++ list_add_tail(&conn->conn_list_entry, &session->conn_list); ++ ++ *new_conn = conn; ++ ++out: ++ return res; ++ ++out_fput: ++ fput(conn->file); ++ ++out_free_iov: ++ free_page((unsigned long)conn->read_iov); ++ ++out_err_free_conn: ++ kfree(conn); ++ ++out_err: ++ goto out; ++} ++ ++/* target_mutex supposed to be locked */ ++int __add_conn(struct iscsi_session *session, struct iscsi_kern_conn_info *info) ++{ ++ struct iscsi_conn *conn, *new_conn = NULL; ++ int err; ++ bool reinstatement = false; ++ ++ conn = conn_lookup(session, info->cid); ++ if ((conn != NULL) && ++ !test_bit(ISCSI_CONN_SHUTTINGDOWN, &conn->conn_aflags)) { ++ /* conn reinstatement */ ++ reinstatement = true; ++ } else if (!list_empty(&session->conn_list)) { ++ err = -EEXIST; ++ goto out; ++ } ++ ++ err = iscsi_conn_alloc(session, info, &new_conn); ++ if (err != 0) ++ goto out; ++ ++ if (reinstatement) { ++ TRACE_MGMT_DBG("Reinstating conn (old %p, new %p)", conn, ++ new_conn); ++ conn->conn_reinst_successor = new_conn; ++ __set_bit(ISCSI_CONN_REINSTATING, &new_conn->conn_aflags); ++ __mark_conn_closed(conn, 0); ++ } ++ ++ conn_activate(new_conn); ++ ++out: ++ return err; ++} ++ ++/* target_mutex supposed to be locked */ ++int __del_conn(struct iscsi_session *session, struct iscsi_kern_conn_info *info) ++{ ++ struct iscsi_conn *conn; ++ int err = -EEXIST; ++ ++ conn = conn_lookup(session, info->cid); ++ if (!conn) { ++ PRINT_WARNING("Connection %d not found", info->cid); ++ return err; ++ } ++ ++ PRINT_INFO("Deleting connection with initiator %s (%p)", ++ conn->session->initiator_name, conn); ++ ++ __mark_conn_closed(conn, ISCSI_CONN_ACTIVE_CLOSE|ISCSI_CONN_DELETING); ++ ++ return 0; ++} ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ ++void iscsi_extracheck_is_rd_thread(struct iscsi_conn *conn) ++{ ++ if (unlikely(current != conn->rd_task)) { ++ printk(KERN_EMERG "conn %p rd_task != current %p (pid %d)\n", ++ conn, current, current->pid); ++ while (in_softirq()) ++ local_bh_enable(); ++ printk(KERN_EMERG "rd_state %x\n", conn->rd_state); ++ printk(KERN_EMERG "rd_task %p\n", conn->rd_task); ++ printk(KERN_EMERG "rd_task->pid %d\n", conn->rd_task->pid); ++ BUG(); ++ } ++} ++ ++void iscsi_extracheck_is_wr_thread(struct iscsi_conn *conn) ++{ ++ if (unlikely(current != conn->wr_task)) { ++ printk(KERN_EMERG "conn %p wr_task != current %p (pid %d)\n", ++ conn, current, current->pid); ++ while (in_softirq()) ++ local_bh_enable(); ++ printk(KERN_EMERG "wr_state %x\n", conn->wr_state); ++ printk(KERN_EMERG "wr_task %p\n", conn->wr_task); ++ printk(KERN_EMERG "wr_task->pid %d\n", conn->wr_task->pid); ++ BUG(); ++ } ++} ++ ++#endif /* CONFIG_SCST_EXTRACHECKS */ +diff -uprN orig/linux-3.2/drivers/scst/iscsi-scst/digest.c linux-3.2/drivers/scst/iscsi-scst/digest.c +--- orig/linux-3.2/drivers/scst/iscsi-scst/digest.c ++++ linux-3.2/drivers/scst/iscsi-scst/digest.c +@@ -0,0 +1,245 @@ ++/* ++ * iSCSI digest handling. ++ * ++ * Copyright (C) 2004 - 2006 Xiranet Communications GmbH ++ * <arne.redlich@xiranet.com> ++ * Copyright (C) 2007 - 2011 Vladislav Bolkhovitin ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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. ++ * ++ * 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. ++ */ ++ ++#include <linux/types.h> ++#include <linux/scatterlist.h> ++ ++#include "iscsi.h" ++#include "digest.h" ++#include <linux/crc32c.h> ++ ++void digest_alg_available(int *val) ++{ ++#if defined(CONFIG_LIBCRC32C_MODULE) || defined(CONFIG_LIBCRC32C) ++ int crc32c = 1; ++#else ++ int crc32c = 0; ++#endif ++ ++ if ((*val & DIGEST_CRC32C) && !crc32c) { ++ PRINT_ERROR("%s", "CRC32C digest algorithm not available " ++ "in kernel"); ++ *val |= ~DIGEST_CRC32C; ++ } ++} ++ ++/** ++ * initialize support for digest calculation. ++ * ++ * digest_init - ++ * @conn: ptr to connection to make use of digests ++ * ++ * @return: 0 on success, < 0 on error ++ */ ++int digest_init(struct iscsi_conn *conn) ++{ ++ if (!(conn->hdigest_type & DIGEST_ALL)) ++ conn->hdigest_type = DIGEST_NONE; ++ ++ if (!(conn->ddigest_type & DIGEST_ALL)) ++ conn->ddigest_type = DIGEST_NONE; ++ ++ return 0; ++} ++ ++static __be32 evaluate_crc32_from_sg(struct scatterlist *sg, int nbytes, ++ uint32_t padding) ++{ ++ u32 crc = ~0; ++ int pad_bytes = ((nbytes + 3) & -4) - nbytes; ++ ++#ifdef CONFIG_SCST_ISCSI_DEBUG_DIGEST_FAILURES ++ if (((scst_random() % 100000) == 752)) { ++ PRINT_INFO("%s", "Simulating digest failure"); ++ return 0; ++ } ++#endif ++ ++#if defined(CONFIG_LIBCRC32C_MODULE) || defined(CONFIG_LIBCRC32C) ++ while (nbytes > 0) { ++ int d = min(nbytes, (int)(sg->length)); ++ crc = crc32c(crc, sg_virt(sg), d); ++ nbytes -= d; ++ sg++; ++ } ++ ++ if (pad_bytes) ++ crc = crc32c(crc, (u8 *)&padding, pad_bytes); ++#endif ++ ++ return (__force __be32)~cpu_to_le32(crc); ++} ++ ++static __be32 digest_header(struct iscsi_pdu *pdu) ++{ ++ struct scatterlist sg[2]; ++ unsigned int nbytes = sizeof(struct iscsi_hdr); ++ int asize = (pdu->ahssize + 3) & -4; ++ ++ sg_init_table(sg, 2); ++ ++ sg_set_buf(&sg[0], &pdu->bhs, nbytes); ++ if (pdu->ahssize) { ++ sg_set_buf(&sg[1], pdu->ahs, asize); ++ nbytes += asize; ++ } ++ EXTRACHECKS_BUG_ON((nbytes & 3) != 0); ++ return evaluate_crc32_from_sg(sg, nbytes, 0); ++} ++ ++static __be32 digest_data(struct iscsi_cmnd *cmd, u32 size, u32 offset, ++ uint32_t padding) ++{ ++ struct scatterlist *sg = cmd->sg; ++ int idx, count; ++ struct scatterlist saved_sg; ++ __be32 crc; ++ ++ offset += sg[0].offset; ++ idx = offset >> PAGE_SHIFT; ++ offset &= ~PAGE_MASK; ++ ++ count = get_pgcnt(size, offset); ++ ++ TRACE_DBG("req %p, idx %d, count %d, sg_cnt %d, size %d, " ++ "offset %d", cmd, idx, count, cmd->sg_cnt, size, offset); ++ BUG_ON(idx + count > cmd->sg_cnt); ++ ++ saved_sg = sg[idx]; ++ sg[idx].offset = offset; ++ sg[idx].length -= offset - saved_sg.offset; ++ ++ crc = evaluate_crc32_from_sg(sg + idx, size, padding); ++ ++ sg[idx] = saved_sg; ++ return crc; ++} ++ ++int digest_rx_header(struct iscsi_cmnd *cmnd) ++{ ++ __be32 crc; ++ ++ crc = digest_header(&cmnd->pdu); ++ if (unlikely(crc != cmnd->hdigest)) { ++ PRINT_ERROR("%s", "RX header digest failed"); ++ return -EIO; ++ } else ++ TRACE_DBG("RX header digest OK for cmd %p", cmnd); ++ ++ return 0; ++} ++ ++void digest_tx_header(struct iscsi_cmnd *cmnd) ++{ ++ cmnd->hdigest = digest_header(&cmnd->pdu); ++ TRACE_DBG("TX header digest for cmd %p: %x", cmnd, cmnd->hdigest); ++} ++ ++int digest_rx_data(struct iscsi_cmnd *cmnd) ++{ ++ struct iscsi_cmnd *req; ++ struct iscsi_data_out_hdr *req_hdr; ++ u32 offset; ++ __be32 crc; ++ int res = 0; ++ ++ switch (cmnd_opcode(cmnd)) { ++ case ISCSI_OP_SCSI_DATA_OUT: ++ req = cmnd->cmd_req; ++ if (unlikely(req == NULL)) { ++ /* It can be for prelim completed commands */ ++ req = cmnd; ++ goto out; ++ } ++ req_hdr = (struct iscsi_data_out_hdr *)&cmnd->pdu.bhs; ++ offset = be32_to_cpu(req_hdr->buffer_offset); ++ break; ++ ++ default: ++ req = cmnd; ++ offset = 0; ++ } ++ ++ /* ++ * We need to skip the digest check for prelim completed commands, ++ * because we use shared data buffer for them, so, most likely, the ++ * check will fail. Plus, for such commands we sometimes don't have ++ * sg_cnt set correctly (cmnd_prepare_get_rejected_cmd_data() doesn't ++ * do it). ++ */ ++ if (unlikely(req->prelim_compl_flags != 0)) ++ goto out; ++ ++ /* ++ * Temporary to not crash with write residual overflows. ToDo. Until ++ * that let's always have succeeded data digests for such overflows. ++ * In ideal, we should allocate additional one or more sg's for the ++ * overflowed data and free them here or on req release. It's quite ++ * not trivial for such virtually never used case, so let's do it, ++ * when it gets needed. ++ */ ++ if (unlikely(offset + cmnd->pdu.datasize > req->bufflen)) { ++ PRINT_WARNING("Skipping RX data digest check for residual " ++ "overflow command op %x (data size %d, buffer size %d)", ++ cmnd_hdr(req)->scb[0], offset + cmnd->pdu.datasize, ++ req->bufflen); ++ goto out; ++ } ++ ++ crc = digest_data(req, cmnd->pdu.datasize, offset, ++ cmnd->conn->rpadding); ++ ++ if (unlikely(crc != cmnd->ddigest)) { ++ TRACE(TRACE_MINOR|TRACE_MGMT_DEBUG, "%s", "RX data digest " ++ "failed"); ++ TRACE_MGMT_DBG("Calculated crc %x, ddigest %x, offset %d", crc, ++ cmnd->ddigest, offset); ++ iscsi_dump_pdu(&cmnd->pdu); ++ res = -EIO; ++ } else ++ TRACE_DBG("RX data digest OK for cmd %p", cmnd); ++ ++out: ++ return res; ++} ++ ++void digest_tx_data(struct iscsi_cmnd *cmnd) ++{ ++ struct iscsi_data_in_hdr *hdr; ++ u32 offset; ++ ++ TRACE_DBG("%s:%d req %p, own_sg %d, sg %p, sgcnt %d cmnd %p, " ++ "own_sg %d, sg %p, sgcnt %d", __func__, __LINE__, ++ cmnd->parent_req, cmnd->parent_req->own_sg, ++ cmnd->parent_req->sg, cmnd->parent_req->sg_cnt, ++ cmnd, cmnd->own_sg, cmnd->sg, cmnd->sg_cnt); ++ ++ switch (cmnd_opcode(cmnd)) { ++ case ISCSI_OP_SCSI_DATA_IN: ++ hdr = (struct iscsi_data_in_hdr *)&cmnd->pdu.bhs; ++ offset = be32_to_cpu(hdr->buffer_offset); ++ break; ++ default: ++ offset = 0; ++ } ++ ++ cmnd->ddigest = digest_data(cmnd, cmnd->pdu.datasize, offset, 0); ++ TRACE_DBG("TX data digest for cmd %p: %x (offset %d, opcode %x)", cmnd, ++ cmnd->ddigest, offset, cmnd_opcode(cmnd)); ++} +diff -uprN orig/linux-3.2/drivers/scst/iscsi-scst/digest.h linux-3.2/drivers/scst/iscsi-scst/digest.h +--- orig/linux-3.2/drivers/scst/iscsi-scst/digest.h ++++ linux-3.2/drivers/scst/iscsi-scst/digest.h +@@ -0,0 +1,32 @@ ++/* ++ * iSCSI digest handling. ++ * ++ * Copyright (C) 2004 Xiranet Communications GmbH <arne.redlich@xiranet.com> ++ * Copyright (C) 2007 - 2011 Vladislav Bolkhovitin ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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. ++ * ++ * 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. ++ */ ++ ++#ifndef __ISCSI_DIGEST_H__ ++#define __ISCSI_DIGEST_H__ ++ ++extern void digest_alg_available(int *val); ++ ++extern int digest_init(struct iscsi_conn *conn); ++ ++extern int digest_rx_header(struct iscsi_cmnd *cmnd); ++extern int digest_rx_data(struct iscsi_cmnd *cmnd); ++ ++extern void digest_tx_header(struct iscsi_cmnd *cmnd); ++extern void digest_tx_data(struct iscsi_cmnd *cmnd); ++ ++#endif /* __ISCSI_DIGEST_H__ */ +diff -uprN orig/linux-3.2/drivers/scst/iscsi-scst/event.c linux-3.2/drivers/scst/iscsi-scst/event.c +--- orig/linux-3.2/drivers/scst/iscsi-scst/event.c ++++ linux-3.2/drivers/scst/iscsi-scst/event.c +@@ -0,0 +1,163 @@ ++/* ++ * Event notification code. ++ * ++ * Copyright (C) 2005 FUJITA Tomonori <tomof@acm.org> ++ * Copyright (C) 2007 - 2011 Vladislav Bolkhovitin ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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. ++ * ++ * 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. ++ * ++ */ ++ ++#include <linux/module.h> ++#include <net/tcp.h> ++#include <scst/iscsi_scst.h> ++#include "iscsi.h" ++ ++static struct sock *nl; ++static u32 iscsid_pid; ++ ++static int event_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh) ++{ ++ u32 pid; ++ ++ pid = NETLINK_CB(skb).pid; ++ WARN_ON(pid == 0); ++ ++ iscsid_pid = pid; ++ ++ return 0; ++} ++ ++static void event_recv_skb(struct sk_buff *skb) ++{ ++ int err; ++ struct nlmsghdr *nlh; ++ u32 rlen; ++ ++ while (skb->len >= NLMSG_SPACE(0)) { ++ nlh = (struct nlmsghdr *)skb->data; ++ if (nlh->nlmsg_len < sizeof(*nlh) || skb->len < nlh->nlmsg_len) ++ goto out; ++ rlen = NLMSG_ALIGN(nlh->nlmsg_len); ++ if (rlen > skb->len) ++ rlen = skb->len; ++ err = event_recv_msg(skb, nlh); ++ if (err) ++ netlink_ack(skb, nlh, -err); ++ else if (nlh->nlmsg_flags & NLM_F_ACK) ++ netlink_ack(skb, nlh, 0); ++ skb_pull(skb, rlen); ++ } ++ ++out: ++ return; ++} ++ ++/* event_mutex supposed to be held */ ++static int __event_send(const void *buf, int buf_len) ++{ ++ int res = 0, len; ++ struct sk_buff *skb; ++ struct nlmsghdr *nlh; ++ static u32 seq; /* protected by event_mutex */ ++ ++ TRACE_ENTRY(); ++ ++ if (ctr_open_state != ISCSI_CTR_OPEN_STATE_OPEN) ++ goto out; ++ ++ len = NLMSG_SPACE(buf_len); ++ ++ skb = alloc_skb(len, GFP_KERNEL); ++ if (skb == NULL) { ++ PRINT_ERROR("alloc_skb() failed (len %d)", len); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ nlh = __nlmsg_put(skb, iscsid_pid, seq++, NLMSG_DONE, buf_len, 0); ++ ++ memcpy(NLMSG_DATA(nlh), buf, buf_len); ++ res = netlink_unicast(nl, skb, iscsid_pid, 0); ++ if (res <= 0) { ++ if (res != -ECONNREFUSED) ++ PRINT_ERROR("netlink_unicast() failed: %d", res); ++ else ++ TRACE(TRACE_MINOR, "netlink_unicast() failed: %s. " ++ "Not functioning user space?", ++ "Connection refused"); ++ goto out; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++int event_send(u32 tid, u64 sid, u32 cid, u32 cookie, ++ enum iscsi_kern_event_code code, ++ const char *param1, const char *param2) ++{ ++ int err; ++ static DEFINE_MUTEX(event_mutex); ++ struct iscsi_kern_event event; ++ int param1_size, param2_size; ++ ++ param1_size = (param1 != NULL) ? strlen(param1) : 0; ++ param2_size = (param2 != NULL) ? strlen(param2) : 0; ++ ++ event.tid = tid; ++ event.sid = sid; ++ event.cid = cid; ++ event.code = code; ++ event.cookie = cookie; ++ event.param1_size = param1_size; ++ event.param2_size = param2_size; ++ ++ mutex_lock(&event_mutex); ++ ++ err = __event_send(&event, sizeof(event)); ++ if (err <= 0) ++ goto out_unlock; ++ ++ if (param1_size > 0) { ++ err = __event_send(param1, param1_size); ++ if (err <= 0) ++ goto out_unlock; ++ } ++ ++ if (param2_size > 0) { ++ err = __event_send(param2, param2_size); ++ if (err <= 0) ++ goto out_unlock; ++ } ++ ++out_unlock: ++ mutex_unlock(&event_mutex); ++ return err; ++} ++ ++int __init event_init(void) ++{ ++ nl = netlink_kernel_create(&init_net, NETLINK_ISCSI_SCST, 1, ++ event_recv_skb, NULL, THIS_MODULE); ++ if (!nl) { ++ PRINT_ERROR("%s", "netlink_kernel_create() failed"); ++ return -ENOMEM; ++ } else ++ return 0; ++} ++ ++void event_exit(void) ++{ ++ netlink_kernel_release(nl); ++} +diff -uprN orig/linux-3.2/drivers/scst/iscsi-scst/iscsi.c linux-3.2/drivers/scst/iscsi-scst/iscsi.c +--- orig/linux-3.2/drivers/scst/iscsi-scst/iscsi.c ++++ linux-3.2/drivers/scst/iscsi-scst/iscsi.c +@@ -0,0 +1,4137 @@ ++/* ++ * Copyright (C) 2002 - 2003 Ardis Technolgies <roman@ardistech.com> ++ * Copyright (C) 2007 - 2011 Vladislav Bolkhovitin ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/module.h> ++#include <linux/hash.h> ++#include <linux/kthread.h> ++#include <linux/scatterlist.h> ++#include <linux/ctype.h> ++#include <net/tcp.h> ++#include <scsi/scsi.h> ++#include <asm/byteorder.h> ++#include <asm/unaligned.h> ++ ++#include "iscsi.h" ++#include "digest.h" ++ ++#ifndef GENERATING_UPSTREAM_PATCH ++#if !defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++#warning Patch put_page_callback-<kernel-version>.patch not applied on your \ ++kernel or CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION \ ++config option not set. ISCSI-SCST will be working with not the best \ ++performance. Refer README file for details. ++#endif ++#endif ++ ++#define ISCSI_INIT_WRITE_WAKE 0x1 ++ ++static int ctr_major; ++static const char ctr_name[] = "iscsi-scst-ctl"; ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++unsigned long iscsi_trace_flag = ISCSI_DEFAULT_LOG_FLAGS; ++#endif ++ ++static struct kmem_cache *iscsi_cmnd_cache; ++ ++static DEFINE_MUTEX(iscsi_threads_pool_mutex); ++static LIST_HEAD(iscsi_thread_pools_list); ++ ++static struct iscsi_thread_pool *iscsi_main_thread_pool; ++ ++static struct page *dummy_page; ++static struct scatterlist dummy_sg; ++ ++static void cmnd_remove_data_wait_hash(struct iscsi_cmnd *cmnd); ++static void iscsi_send_task_mgmt_resp(struct iscsi_cmnd *req, int status); ++static void iscsi_check_send_delayed_tm_resp(struct iscsi_session *sess); ++static void req_cmnd_release(struct iscsi_cmnd *req); ++static int cmnd_insert_data_wait_hash(struct iscsi_cmnd *cmnd); ++static void iscsi_cmnd_init_write(struct iscsi_cmnd *rsp, int flags); ++static void iscsi_set_resid_no_scst_cmd(struct iscsi_cmnd *rsp); ++static void iscsi_set_resid(struct iscsi_cmnd *rsp); ++ ++static void iscsi_set_not_received_data_len(struct iscsi_cmnd *req, ++ unsigned int not_received) ++{ ++ req->not_received_data_len = not_received; ++ if (req->scst_cmd != NULL) ++ scst_cmd_set_write_not_received_data_len(req->scst_cmd, ++ not_received); ++ return; ++} ++ ++static void req_del_from_write_timeout_list(struct iscsi_cmnd *req) ++{ ++ struct iscsi_conn *conn; ++ ++ TRACE_ENTRY(); ++ ++ if (!req->on_write_timeout_list) ++ goto out; ++ ++ conn = req->conn; ++ ++ TRACE_DBG("Deleting cmd %p from conn %p write_timeout_list", ++ req, conn); ++ ++ spin_lock_bh(&conn->write_list_lock); ++ ++ /* Recheck, since it can be changed behind us */ ++ if (unlikely(!req->on_write_timeout_list)) ++ goto out_unlock; ++ ++ list_del(&req->write_timeout_list_entry); ++ req->on_write_timeout_list = 0; ++ ++out_unlock: ++ spin_unlock_bh(&conn->write_list_lock); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static inline u32 cmnd_write_size(struct iscsi_cmnd *cmnd) ++{ ++ struct iscsi_scsi_cmd_hdr *hdr = cmnd_hdr(cmnd); ++ ++ if (hdr->flags & ISCSI_CMD_WRITE) ++ return be32_to_cpu(hdr->data_length); ++ return 0; ++} ++ ++static inline int cmnd_read_size(struct iscsi_cmnd *cmnd) ++{ ++ struct iscsi_scsi_cmd_hdr *hdr = cmnd_hdr(cmnd); ++ ++ if (hdr->flags & ISCSI_CMD_READ) { ++ struct iscsi_ahs_hdr *ahdr; ++ ++ if (!(hdr->flags & ISCSI_CMD_WRITE)) ++ return be32_to_cpu(hdr->data_length); ++ ++ ahdr = (struct iscsi_ahs_hdr *)cmnd->pdu.ahs; ++ if (ahdr != NULL) { ++ uint8_t *p = (uint8_t *)ahdr; ++ unsigned int size = 0; ++ do { ++ int s; ++ ++ ahdr = (struct iscsi_ahs_hdr *)p; ++ ++ if (ahdr->ahstype == ISCSI_AHSTYPE_RLENGTH) { ++ struct iscsi_rlength_ahdr *rh = ++ (struct iscsi_rlength_ahdr *)ahdr; ++ return be32_to_cpu(rh->read_length); ++ } ++ ++ s = 3 + be16_to_cpu(ahdr->ahslength); ++ s = (s + 3) & -4; ++ size += s; ++ p += s; ++ } while (size < cmnd->pdu.ahssize); ++ } ++ return -1; ++ } ++ return 0; ++} ++ ++void iscsi_restart_cmnd(struct iscsi_cmnd *cmnd) ++{ ++ int status; ++ ++ TRACE_ENTRY(); ++ ++ EXTRACHECKS_BUG_ON(cmnd->r2t_len_to_receive != 0); ++ EXTRACHECKS_BUG_ON(cmnd->r2t_len_to_send != 0); ++ ++ req_del_from_write_timeout_list(cmnd); ++ ++ /* ++ * Let's remove cmnd from the hash earlier to keep it smaller. ++ * Also we have to remove hashed req from the hash before sending ++ * response. Otherwise we can have a race, when for some reason cmd's ++ * release (and, hence, removal from the hash) is delayed after the ++ * transmission and initiator sends cmd with the same ITT, hence ++ * the new command will be erroneously rejected as a duplicate. ++ */ ++ if (cmnd->hashed) ++ cmnd_remove_data_wait_hash(cmnd); ++ ++ if (unlikely(test_bit(ISCSI_CONN_REINSTATING, ++ &cmnd->conn->conn_aflags))) { ++ struct iscsi_target *target = cmnd->conn->session->target; ++ bool get_out; ++ ++ mutex_lock(&target->target_mutex); ++ ++ get_out = test_bit(ISCSI_CONN_REINSTATING, ++ &cmnd->conn->conn_aflags); ++ /* Let's don't look dead */ ++ if (scst_cmd_get_cdb(cmnd->scst_cmd)[0] == TEST_UNIT_READY) ++ get_out = false; ++ ++ if (!get_out) ++ goto unlock_cont; ++ ++ TRACE_MGMT_DBG("Pending cmnd %p, because conn %p is " ++ "reinstated", cmnd, cmnd->conn); ++ ++ cmnd->scst_state = ISCSI_CMD_STATE_REINST_PENDING; ++ list_add_tail(&cmnd->reinst_pending_cmd_list_entry, ++ &cmnd->conn->reinst_pending_cmd_list); ++ ++unlock_cont: ++ mutex_unlock(&target->target_mutex); ++ ++ if (get_out) ++ goto out; ++ } ++ ++ if (unlikely(cmnd->prelim_compl_flags != 0)) { ++ if (test_bit(ISCSI_CMD_ABORTED, &cmnd->prelim_compl_flags)) { ++ TRACE_MGMT_DBG("cmnd %p (scst_cmd %p) aborted", cmnd, ++ cmnd->scst_cmd); ++ req_cmnd_release_force(cmnd); ++ goto out; ++ } ++ ++ if (cmnd->scst_cmd == NULL) { ++ TRACE_MGMT_DBG("Finishing preliminary completed cmd %p " ++ "with NULL scst_cmd", cmnd); ++ req_cmnd_release(cmnd); ++ goto out; ++ } ++ ++ status = SCST_PREPROCESS_STATUS_ERROR_SENSE_SET; ++ } else ++ status = SCST_PREPROCESS_STATUS_SUCCESS; ++ ++ cmnd->scst_state = ISCSI_CMD_STATE_RESTARTED; ++ ++ scst_restart_cmd(cmnd->scst_cmd, status, SCST_CONTEXT_THREAD); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static struct iscsi_cmnd *iscsi_create_tm_clone(struct iscsi_cmnd *cmnd) ++{ ++ struct iscsi_cmnd *tm_clone; ++ ++ TRACE_ENTRY(); ++ ++ tm_clone = cmnd_alloc(cmnd->conn, NULL); ++ if (tm_clone != NULL) { ++ set_bit(ISCSI_CMD_ABORTED, &tm_clone->prelim_compl_flags); ++ tm_clone->pdu = cmnd->pdu; ++ ++ TRACE_MGMT_DBG("TM clone %p for cmnd %p created", ++ tm_clone, cmnd); ++ } else ++ PRINT_ERROR("Failed to create TM clone for cmnd %p", cmnd); ++ ++ TRACE_EXIT_HRES((unsigned long)tm_clone); ++ return tm_clone; ++} ++ ++void iscsi_fail_data_waiting_cmnd(struct iscsi_cmnd *cmnd) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Failing data waiting cmnd %p (data_out_in_data_receiving %d)", ++ cmnd, cmnd->data_out_in_data_receiving); ++ ++ /* ++ * There is no race with conn_abort(), since all functions ++ * called from single read thread ++ */ ++ iscsi_extracheck_is_rd_thread(cmnd->conn); ++ ++ /* This cmnd is going to die without response */ ++ cmnd->r2t_len_to_receive = 0; ++ cmnd->r2t_len_to_send = 0; ++ ++ if (cmnd->pending) { ++ struct iscsi_session *session = cmnd->conn->session; ++ struct iscsi_cmnd *tm_clone; ++ ++ TRACE_MGMT_DBG("Unpending cmnd %p (sn %u, exp_cmd_sn %u)", cmnd, ++ cmnd->pdu.bhs.sn, session->exp_cmd_sn); ++ ++ /* ++ * If cmnd is pending, then the next command, if any, must be ++ * pending too. So, just insert a clone instead of cmnd to ++ * fill the hole in SNs. Then we can release cmnd. ++ */ ++ ++ tm_clone = iscsi_create_tm_clone(cmnd); ++ ++ spin_lock(&session->sn_lock); ++ ++ if (tm_clone != NULL) { ++ TRACE_MGMT_DBG("Adding tm_clone %p after its cmnd", ++ tm_clone); ++ list_add(&tm_clone->pending_list_entry, ++ &cmnd->pending_list_entry); ++ } ++ ++ list_del(&cmnd->pending_list_entry); ++ cmnd->pending = 0; ++ ++ spin_unlock(&session->sn_lock); ++ } ++ ++ req_cmnd_release_force(cmnd); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++struct iscsi_cmnd *cmnd_alloc(struct iscsi_conn *conn, ++ struct iscsi_cmnd *parent) ++{ ++ struct iscsi_cmnd *cmnd; ++ ++ /* ToDo: __GFP_NOFAIL?? */ ++ cmnd = kmem_cache_zalloc(iscsi_cmnd_cache, GFP_KERNEL|__GFP_NOFAIL); ++ ++ atomic_set(&cmnd->ref_cnt, 1); ++ cmnd->scst_state = ISCSI_CMD_STATE_NEW; ++ cmnd->conn = conn; ++ cmnd->parent_req = parent; ++ ++ if (parent == NULL) { ++ conn_get(conn); ++ ++#if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++ atomic_set(&cmnd->net_ref_cnt, 0); ++#endif ++ INIT_LIST_HEAD(&cmnd->rsp_cmd_list); ++ INIT_LIST_HEAD(&cmnd->rx_ddigest_cmd_list); ++ cmnd->target_task_tag = ISCSI_RESERVED_TAG_CPU32; ++ ++ spin_lock_bh(&conn->cmd_list_lock); ++ list_add_tail(&cmnd->cmd_list_entry, &conn->cmd_list); ++ spin_unlock_bh(&conn->cmd_list_lock); ++ } ++ ++ TRACE_DBG("conn %p, parent %p, cmnd %p", conn, parent, cmnd); ++ return cmnd; ++} ++ ++/* Frees a command. Also frees the additional header. */ ++static void cmnd_free(struct iscsi_cmnd *cmnd) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("cmnd %p", cmnd); ++ ++ if (unlikely(test_bit(ISCSI_CMD_ABORTED, &cmnd->prelim_compl_flags))) { ++ TRACE_MGMT_DBG("Free aborted cmd %p (scst cmd %p, state %d, " ++ "parent_req %p)", cmnd, cmnd->scst_cmd, ++ cmnd->scst_state, cmnd->parent_req); ++ } ++ ++ /* Catch users from cmd_list or rsp_cmd_list */ ++ EXTRACHECKS_BUG_ON(atomic_read(&cmnd->ref_cnt) != 0); ++ ++ kfree(cmnd->pdu.ahs); ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ if (unlikely(cmnd->on_write_list || cmnd->on_write_timeout_list)) { ++ struct iscsi_scsi_cmd_hdr *req = cmnd_hdr(cmnd); ++ ++ PRINT_CRIT_ERROR("cmnd %p still on some list?, %x, %x, %x, " ++ "%x, %x, %x, %x", cmnd, req->opcode, req->scb[0], ++ req->flags, req->itt, be32_to_cpu(req->data_length), ++ req->cmd_sn, be32_to_cpu((__force __be32)(cmnd->pdu.datasize))); ++ ++ if (unlikely(cmnd->parent_req)) { ++ struct iscsi_scsi_cmd_hdr *preq = ++ cmnd_hdr(cmnd->parent_req); ++ PRINT_CRIT_ERROR("%p %x %u", preq, preq->opcode, ++ preq->scb[0]); ++ } ++ BUG(); ++ } ++#endif ++ ++ kmem_cache_free(iscsi_cmnd_cache, cmnd); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void iscsi_dec_active_cmds(struct iscsi_cmnd *req) ++{ ++ struct iscsi_session *sess = req->conn->session; ++ ++ TRACE_DBG("Decrementing active_cmds (req %p, sess %p, " ++ "new value %d)", req, sess, ++ atomic_read(&sess->active_cmds)-1); ++ ++ EXTRACHECKS_BUG_ON(!req->dec_active_cmds); ++ ++ atomic_dec(&sess->active_cmds); ++ smp_mb__after_atomic_dec(); ++ req->dec_active_cmds = 0; ++#ifdef CONFIG_SCST_EXTRACHECKS ++ if (unlikely(atomic_read(&sess->active_cmds) < 0)) { ++ PRINT_CRIT_ERROR("active_cmds < 0 (%d)!!", ++ atomic_read(&sess->active_cmds)); ++ BUG(); ++ } ++#endif ++ return; ++} ++ ++/* Might be called under some lock and on SIRQ */ ++void cmnd_done(struct iscsi_cmnd *cmnd) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("cmnd %p", cmnd); ++ ++ if (unlikely(test_bit(ISCSI_CMD_ABORTED, &cmnd->prelim_compl_flags))) { ++ TRACE_MGMT_DBG("Done aborted cmd %p (scst cmd %p, state %d, " ++ "parent_req %p)", cmnd, cmnd->scst_cmd, ++ cmnd->scst_state, cmnd->parent_req); ++ } ++ ++ EXTRACHECKS_BUG_ON(cmnd->on_rx_digest_list); ++ EXTRACHECKS_BUG_ON(cmnd->hashed); ++ EXTRACHECKS_BUG_ON(cmnd->cmd_req); ++ EXTRACHECKS_BUG_ON(cmnd->data_out_in_data_receiving); ++ ++ req_del_from_write_timeout_list(cmnd); ++ ++ if (cmnd->parent_req == NULL) { ++ struct iscsi_conn *conn = cmnd->conn; ++ struct iscsi_cmnd *rsp, *t; ++ ++ TRACE_DBG("Deleting req %p from conn %p", cmnd, conn); ++ ++ spin_lock_bh(&conn->cmd_list_lock); ++ list_del(&cmnd->cmd_list_entry); ++ spin_unlock_bh(&conn->cmd_list_lock); ++ ++ conn_put(conn); ++ ++ EXTRACHECKS_BUG_ON(!list_empty(&cmnd->rx_ddigest_cmd_list)); ++ ++ /* Order between above and below code is important! */ ++ ++ if ((cmnd->scst_cmd != NULL) || (cmnd->scst_aen != NULL)) { ++ switch (cmnd->scst_state) { ++ case ISCSI_CMD_STATE_PROCESSED: ++ TRACE_DBG("cmd %p PROCESSED", cmnd); ++ scst_tgt_cmd_done(cmnd->scst_cmd, ++ SCST_CONTEXT_DIRECT_ATOMIC); ++ break; ++ ++ case ISCSI_CMD_STATE_AFTER_PREPROC: ++ { ++ /* It can be for some aborted commands */ ++ struct scst_cmd *scst_cmd = cmnd->scst_cmd; ++ TRACE_DBG("cmd %p AFTER_PREPROC", cmnd); ++ cmnd->scst_state = ISCSI_CMD_STATE_RESTARTED; ++ cmnd->scst_cmd = NULL; ++ scst_restart_cmd(scst_cmd, ++ SCST_PREPROCESS_STATUS_ERROR_FATAL, ++ SCST_CONTEXT_THREAD); ++ break; ++ } ++ ++ case ISCSI_CMD_STATE_AEN: ++ TRACE_DBG("cmd %p AEN PROCESSED", cmnd); ++ scst_aen_done(cmnd->scst_aen); ++ break; ++ ++ case ISCSI_CMD_STATE_OUT_OF_SCST_PRELIM_COMPL: ++ break; ++ ++ default: ++ PRINT_CRIT_ERROR("Unexpected cmnd scst state " ++ "%d", cmnd->scst_state); ++ BUG(); ++ break; ++ } ++ } ++ ++ if (cmnd->own_sg) { ++ TRACE_DBG("own_sg for req %p", cmnd); ++ if (cmnd->sg != &dummy_sg) ++ scst_free(cmnd->sg, cmnd->sg_cnt); ++#ifdef CONFIG_SCST_DEBUG ++ cmnd->own_sg = 0; ++ cmnd->sg = NULL; ++ cmnd->sg_cnt = -1; ++#endif ++ } ++ ++ if (unlikely(cmnd->dec_active_cmds)) ++ iscsi_dec_active_cmds(cmnd); ++ ++ list_for_each_entry_safe(rsp, t, &cmnd->rsp_cmd_list, ++ rsp_cmd_list_entry) { ++ cmnd_free(rsp); ++ } ++ ++ cmnd_free(cmnd); ++ } else { ++ struct iscsi_cmnd *parent = cmnd->parent_req; ++ ++ if (cmnd->own_sg) { ++ TRACE_DBG("own_sg for rsp %p", cmnd); ++ if ((cmnd->sg != &dummy_sg) && (cmnd->sg != cmnd->rsp_sg)) ++ scst_free(cmnd->sg, cmnd->sg_cnt); ++#ifdef CONFIG_SCST_DEBUG ++ cmnd->own_sg = 0; ++ cmnd->sg = NULL; ++ cmnd->sg_cnt = -1; ++#endif ++ } ++ ++ EXTRACHECKS_BUG_ON(cmnd->dec_active_cmds); ++ ++ if (cmnd == parent->main_rsp) { ++ TRACE_DBG("Finishing main rsp %p (req %p)", cmnd, ++ parent); ++ parent->main_rsp = NULL; ++ } ++ ++ cmnd_put(parent); ++ /* ++ * cmnd will be freed on the last parent's put and can already ++ * be freed!! ++ */ ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * Corresponding conn may also get destroyed after this function, except only ++ * if it's called from the read thread! ++ * ++ * It can't be called in parallel with iscsi_cmnds_init_write()! ++ */ ++void req_cmnd_release_force(struct iscsi_cmnd *req) ++{ ++ struct iscsi_cmnd *rsp, *t; ++ struct iscsi_conn *conn = req->conn; ++ LIST_HEAD(cmds_list); ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("req %p", req); ++ ++ BUG_ON(req == conn->read_cmnd); ++ ++ spin_lock_bh(&conn->write_list_lock); ++ list_for_each_entry_safe(rsp, t, &conn->write_list, write_list_entry) { ++ if (rsp->parent_req != req) ++ continue; ++ ++ cmd_del_from_write_list(rsp); ++ ++ list_add_tail(&rsp->write_list_entry, &cmds_list); ++ } ++ spin_unlock_bh(&conn->write_list_lock); ++ ++ list_for_each_entry_safe(rsp, t, &cmds_list, write_list_entry) { ++ TRACE_MGMT_DBG("Putting write rsp %p", rsp); ++ list_del(&rsp->write_list_entry); ++ cmnd_put(rsp); ++ } ++ ++ /* Supposed nobody can add responses in the list anymore */ ++ list_for_each_entry_reverse(rsp, &req->rsp_cmd_list, ++ rsp_cmd_list_entry) { ++ bool r; ++ ++ if (rsp->force_cleanup_done) ++ continue; ++ ++ rsp->force_cleanup_done = 1; ++ ++ if (cmnd_get_check(rsp)) ++ continue; ++ ++ spin_lock_bh(&conn->write_list_lock); ++ r = rsp->on_write_list || rsp->write_processing_started; ++ spin_unlock_bh(&conn->write_list_lock); ++ ++ cmnd_put(rsp); ++ ++ if (r) ++ continue; ++ ++ /* ++ * If both on_write_list and write_processing_started not set, ++ * we can safely put() rsp. ++ */ ++ TRACE_MGMT_DBG("Putting rsp %p", rsp); ++ cmnd_put(rsp); ++ } ++ ++ if (req->main_rsp != NULL) { ++ TRACE_MGMT_DBG("Putting main rsp %p", req->main_rsp); ++ cmnd_put(req->main_rsp); ++ req->main_rsp = NULL; ++ } ++ ++ req_cmnd_release(req); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void req_cmnd_pre_release(struct iscsi_cmnd *req) ++{ ++ struct iscsi_cmnd *c, *t; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("req %p", req); ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ BUG_ON(req->release_called); ++ req->release_called = 1; ++#endif ++ ++ if (unlikely(test_bit(ISCSI_CMD_ABORTED, &req->prelim_compl_flags))) { ++ TRACE_MGMT_DBG("Release aborted req cmd %p (scst cmd %p, " ++ "state %d)", req, req->scst_cmd, req->scst_state); ++ } ++ ++ BUG_ON(req->parent_req != NULL); ++ ++ if (unlikely(req->hashed)) { ++ /* It sometimes can happen during errors recovery */ ++ TRACE_MGMT_DBG("Removing req %p from hash", req); ++ cmnd_remove_data_wait_hash(req); ++ } ++ ++ if (unlikely(req->cmd_req)) { ++ /* It sometimes can happen during errors recovery */ ++ TRACE_MGMT_DBG("Putting cmd_req %p (req %p)", req->cmd_req, req); ++ req->cmd_req->data_out_in_data_receiving = 0; ++ cmnd_put(req->cmd_req); ++ req->cmd_req = NULL; ++ } ++ ++ if (unlikely(req->main_rsp != NULL)) { ++ TRACE_DBG("Sending main rsp %p", req->main_rsp); ++ if (cmnd_opcode(req) == ISCSI_OP_SCSI_CMD) { ++ if (req->scst_cmd != NULL) ++ iscsi_set_resid(req->main_rsp); ++ else ++ iscsi_set_resid_no_scst_cmd(req->main_rsp); ++ } ++ iscsi_cmnd_init_write(req->main_rsp, ISCSI_INIT_WRITE_WAKE); ++ req->main_rsp = NULL; ++ } ++ ++ list_for_each_entry_safe(c, t, &req->rx_ddigest_cmd_list, ++ rx_ddigest_cmd_list_entry) { ++ cmd_del_from_rx_ddigest_list(c); ++ cmnd_put(c); ++ } ++ ++ EXTRACHECKS_BUG_ON(req->pending); ++ ++ if (unlikely(req->dec_active_cmds)) ++ iscsi_dec_active_cmds(req); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * Corresponding conn may also get destroyed after this function, except only ++ * if it's called from the read thread! ++ */ ++static void req_cmnd_release(struct iscsi_cmnd *req) ++{ ++ TRACE_ENTRY(); ++ ++ req_cmnd_pre_release(req); ++ cmnd_put(req); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * Corresponding conn may also get destroyed after this function, except only ++ * if it's called from the read thread! ++ */ ++void rsp_cmnd_release(struct iscsi_cmnd *cmnd) ++{ ++ TRACE_DBG("%p", cmnd); ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ BUG_ON(cmnd->release_called); ++ cmnd->release_called = 1; ++#endif ++ ++ EXTRACHECKS_BUG_ON(cmnd->parent_req == NULL); ++ ++ cmnd_put(cmnd); ++ return; ++} ++ ++static struct iscsi_cmnd *iscsi_alloc_rsp(struct iscsi_cmnd *parent) ++{ ++ struct iscsi_cmnd *rsp; ++ ++ TRACE_ENTRY(); ++ ++ rsp = cmnd_alloc(parent->conn, parent); ++ ++ TRACE_DBG("Adding rsp %p to parent %p", rsp, parent); ++ list_add_tail(&rsp->rsp_cmd_list_entry, &parent->rsp_cmd_list); ++ ++ cmnd_get(parent); ++ ++ TRACE_EXIT_HRES((unsigned long)rsp); ++ return rsp; ++} ++ ++static inline struct iscsi_cmnd *iscsi_alloc_main_rsp(struct iscsi_cmnd *parent) ++{ ++ struct iscsi_cmnd *rsp; ++ ++ TRACE_ENTRY(); ++ ++ EXTRACHECKS_BUG_ON(parent->main_rsp != NULL); ++ ++ rsp = iscsi_alloc_rsp(parent); ++ parent->main_rsp = rsp; ++ ++ TRACE_EXIT_HRES((unsigned long)rsp); ++ return rsp; ++} ++ ++static void iscsi_cmnds_init_write(struct list_head *send, int flags) ++{ ++ struct iscsi_cmnd *rsp = list_entry(send->next, struct iscsi_cmnd, ++ write_list_entry); ++ struct iscsi_conn *conn = rsp->conn; ++ struct list_head *pos, *next; ++ ++ BUG_ON(list_empty(send)); ++ ++ if (!(conn->ddigest_type & DIGEST_NONE)) { ++ list_for_each(pos, send) { ++ rsp = list_entry(pos, struct iscsi_cmnd, ++ write_list_entry); ++ ++ if (rsp->pdu.datasize != 0) { ++ TRACE_DBG("Doing data digest (%p:%x)", rsp, ++ cmnd_opcode(rsp)); ++ digest_tx_data(rsp); ++ } ++ } ++ } ++ ++ spin_lock_bh(&conn->write_list_lock); ++ list_for_each_safe(pos, next, send) { ++ rsp = list_entry(pos, struct iscsi_cmnd, write_list_entry); ++ ++ TRACE_DBG("%p:%x", rsp, cmnd_opcode(rsp)); ++ ++ BUG_ON(conn != rsp->conn); ++ ++ list_del(&rsp->write_list_entry); ++ cmd_add_on_write_list(conn, rsp); ++ } ++ spin_unlock_bh(&conn->write_list_lock); ++ ++ if (flags & ISCSI_INIT_WRITE_WAKE) ++ iscsi_make_conn_wr_active(conn); ++ ++ return; ++} ++ ++static void iscsi_cmnd_init_write(struct iscsi_cmnd *rsp, int flags) ++{ ++ LIST_HEAD(head); ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ if (unlikely(rsp->on_write_list)) { ++ PRINT_CRIT_ERROR("cmd already on write list (%x %x %x " ++ "%u %u %d %d", rsp->pdu.bhs.itt, ++ cmnd_opcode(rsp), cmnd_scsicode(rsp), ++ rsp->hdigest, rsp->ddigest, ++ list_empty(&rsp->rsp_cmd_list), rsp->hashed); ++ BUG(); ++ } ++#endif ++ list_add_tail(&rsp->write_list_entry, &head); ++ iscsi_cmnds_init_write(&head, flags); ++ return; ++} ++ ++static void iscsi_set_resid_no_scst_cmd(struct iscsi_cmnd *rsp) ++{ ++ struct iscsi_cmnd *req = rsp->parent_req; ++ struct iscsi_scsi_cmd_hdr *req_hdr = cmnd_hdr(req); ++ struct iscsi_scsi_rsp_hdr *rsp_hdr = (struct iscsi_scsi_rsp_hdr *)&rsp->pdu.bhs; ++ int resid, out_resid; ++ ++ TRACE_ENTRY(); ++ ++ BUG_ON(req->scst_cmd != NULL); ++ ++ TRACE_DBG("req %p, rsp %p, outstanding_r2t %d, r2t_len_to_receive %d, " ++ "r2t_len_to_send %d, not_received_data_len %d", req, rsp, ++ req->outstanding_r2t, req->r2t_len_to_receive, ++ req->r2t_len_to_send, req->not_received_data_len); ++ ++ if ((req_hdr->flags & ISCSI_CMD_READ) && ++ (req_hdr->flags & ISCSI_CMD_WRITE)) { ++ out_resid = req->not_received_data_len; ++ if (out_resid > 0) { ++ rsp_hdr->flags |= ISCSI_FLG_RESIDUAL_UNDERFLOW; ++ rsp_hdr->residual_count = cpu_to_be32(out_resid); ++ } else if (out_resid < 0) { ++ out_resid = -out_resid; ++ rsp_hdr->flags |= ISCSI_FLG_RESIDUAL_OVERFLOW; ++ rsp_hdr->residual_count = cpu_to_be32(out_resid); ++ } ++ ++ resid = cmnd_read_size(req); ++ if (resid > 0) { ++ rsp_hdr->flags |= ISCSI_FLG_BIRESIDUAL_UNDERFLOW; ++ rsp_hdr->bi_residual_count = cpu_to_be32(resid); ++ } else if (resid < 0) { ++ resid = -resid; ++ rsp_hdr->flags |= ISCSI_FLG_BIRESIDUAL_OVERFLOW; ++ rsp_hdr->bi_residual_count = cpu_to_be32(resid); ++ } ++ } else if (req_hdr->flags & ISCSI_CMD_READ) { ++ resid = be32_to_cpu(req_hdr->data_length); ++ if (resid > 0) { ++ rsp_hdr->flags |= ISCSI_FLG_RESIDUAL_UNDERFLOW; ++ rsp_hdr->residual_count = cpu_to_be32(resid); ++ } ++ } else if (req_hdr->flags & ISCSI_CMD_WRITE) { ++ resid = req->not_received_data_len; ++ if (resid > 0) { ++ rsp_hdr->flags |= ISCSI_FLG_RESIDUAL_UNDERFLOW; ++ rsp_hdr->residual_count = cpu_to_be32(resid); ++ } ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void iscsi_set_resid(struct iscsi_cmnd *rsp) ++{ ++ struct iscsi_cmnd *req = rsp->parent_req; ++ struct scst_cmd *scst_cmd = req->scst_cmd; ++ struct iscsi_scsi_cmd_hdr *req_hdr; ++ struct iscsi_scsi_rsp_hdr *rsp_hdr; ++ int resid, out_resid; ++ ++ TRACE_ENTRY(); ++ ++ if (likely(!scst_get_resid(scst_cmd, &resid, &out_resid))) { ++ TRACE_DBG("No residuals for req %p", req); ++ goto out; ++ } ++ ++ TRACE_DBG("req %p, resid %d, out_resid %d", req, resid, out_resid); ++ ++ req_hdr = cmnd_hdr(req); ++ rsp_hdr = (struct iscsi_scsi_rsp_hdr *)&rsp->pdu.bhs; ++ ++ if ((req_hdr->flags & ISCSI_CMD_READ) && ++ (req_hdr->flags & ISCSI_CMD_WRITE)) { ++ if (out_resid > 0) { ++ rsp_hdr->flags |= ISCSI_FLG_RESIDUAL_UNDERFLOW; ++ rsp_hdr->residual_count = cpu_to_be32(out_resid); ++ } else if (out_resid < 0) { ++ out_resid = -out_resid; ++ rsp_hdr->flags |= ISCSI_FLG_RESIDUAL_OVERFLOW; ++ rsp_hdr->residual_count = cpu_to_be32(out_resid); ++ } ++ ++ if (resid > 0) { ++ rsp_hdr->flags |= ISCSI_FLG_BIRESIDUAL_UNDERFLOW; ++ rsp_hdr->bi_residual_count = cpu_to_be32(resid); ++ } else if (resid < 0) { ++ resid = -resid; ++ rsp_hdr->flags |= ISCSI_FLG_BIRESIDUAL_OVERFLOW; ++ rsp_hdr->bi_residual_count = cpu_to_be32(resid); ++ } ++ } else { ++ if (resid > 0) { ++ rsp_hdr->flags |= ISCSI_FLG_RESIDUAL_UNDERFLOW; ++ rsp_hdr->residual_count = cpu_to_be32(resid); ++ } else if (resid < 0) { ++ resid = -resid; ++ rsp_hdr->flags |= ISCSI_FLG_RESIDUAL_OVERFLOW; ++ rsp_hdr->residual_count = cpu_to_be32(resid); ++ } ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static void send_data_rsp(struct iscsi_cmnd *req, u8 status, int send_status) ++{ ++ struct iscsi_cmnd *rsp; ++ struct iscsi_scsi_cmd_hdr *req_hdr = cmnd_hdr(req); ++ struct iscsi_data_in_hdr *rsp_hdr; ++ u32 pdusize, size, offset, sn; ++ LIST_HEAD(send); ++ ++ TRACE_DBG("req %p", req); ++ ++ pdusize = req->conn->session->sess_params.max_xmit_data_length; ++ size = req->bufflen; ++ offset = 0; ++ sn = 0; ++ ++ while (1) { ++ rsp = iscsi_alloc_rsp(req); ++ TRACE_DBG("rsp %p", rsp); ++ rsp->sg = req->sg; ++ rsp->sg_cnt = req->sg_cnt; ++ rsp->bufflen = req->bufflen; ++ rsp_hdr = (struct iscsi_data_in_hdr *)&rsp->pdu.bhs; ++ ++ rsp_hdr->opcode = ISCSI_OP_SCSI_DATA_IN; ++ rsp_hdr->itt = req_hdr->itt; ++ rsp_hdr->ttt = ISCSI_RESERVED_TAG; ++ rsp_hdr->buffer_offset = cpu_to_be32(offset); ++ rsp_hdr->data_sn = cpu_to_be32(sn); ++ ++ if (size <= pdusize) { ++ TRACE_DBG("offset %d, size %d", offset, size); ++ rsp->pdu.datasize = size; ++ if (send_status) { ++ TRACE_DBG("status %x", status); ++ ++ EXTRACHECKS_BUG_ON((cmnd_hdr(req)->flags & ISCSI_CMD_WRITE) != 0); ++ ++ rsp_hdr->flags = ISCSI_FLG_FINAL | ISCSI_FLG_STATUS; ++ rsp_hdr->cmd_status = status; ++ ++ iscsi_set_resid(rsp); ++ } ++ list_add_tail(&rsp->write_list_entry, &send); ++ break; ++ } ++ ++ TRACE_DBG("pdusize %d, offset %d, size %d", pdusize, offset, ++ size); ++ ++ rsp->pdu.datasize = pdusize; ++ ++ size -= pdusize; ++ offset += pdusize; ++ sn++; ++ ++ list_add_tail(&rsp->write_list_entry, &send); ++ } ++ iscsi_cmnds_init_write(&send, 0); ++ return; ++} ++ ++static void iscsi_init_status_rsp(struct iscsi_cmnd *rsp, ++ int status, const u8 *sense_buf, int sense_len) ++{ ++ struct iscsi_cmnd *req = rsp->parent_req; ++ struct iscsi_scsi_rsp_hdr *rsp_hdr; ++ struct scatterlist *sg; ++ ++ TRACE_ENTRY(); ++ ++ rsp_hdr = (struct iscsi_scsi_rsp_hdr *)&rsp->pdu.bhs; ++ rsp_hdr->opcode = ISCSI_OP_SCSI_RSP; ++ rsp_hdr->flags = ISCSI_FLG_FINAL; ++ rsp_hdr->response = ISCSI_RESPONSE_COMMAND_COMPLETED; ++ rsp_hdr->cmd_status = status; ++ rsp_hdr->itt = cmnd_hdr(req)->itt; ++ ++ if (SCST_SENSE_VALID(sense_buf)) { ++ TRACE_DBG("%s", "SENSE VALID"); ++ ++ sg = rsp->sg = rsp->rsp_sg; ++ rsp->sg_cnt = 2; ++ rsp->own_sg = 1; ++ ++ sg_init_table(sg, 2); ++ sg_set_buf(&sg[0], &rsp->sense_hdr, sizeof(rsp->sense_hdr)); ++ sg_set_buf(&sg[1], sense_buf, sense_len); ++ ++ rsp->sense_hdr.length = cpu_to_be16(sense_len); ++ ++ rsp->pdu.datasize = sizeof(rsp->sense_hdr) + sense_len; ++ rsp->bufflen = rsp->pdu.datasize; ++ } else { ++ rsp->pdu.datasize = 0; ++ rsp->bufflen = 0; ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static inline struct iscsi_cmnd *create_status_rsp(struct iscsi_cmnd *req, ++ int status, const u8 *sense_buf, int sense_len) ++{ ++ struct iscsi_cmnd *rsp; ++ ++ TRACE_ENTRY(); ++ ++ rsp = iscsi_alloc_rsp(req); ++ TRACE_DBG("rsp %p", rsp); ++ ++ iscsi_init_status_rsp(rsp, status, sense_buf, sense_len); ++ iscsi_set_resid(rsp); ++ ++ TRACE_EXIT_HRES((unsigned long)rsp); ++ return rsp; ++} ++ ++/* ++ * Initializes data receive fields. Can be called only when they have not been ++ * initialized yet. ++ */ ++static int iscsi_set_prelim_r2t_len_to_receive(struct iscsi_cmnd *req) ++{ ++ struct iscsi_scsi_cmd_hdr *req_hdr = (struct iscsi_scsi_cmd_hdr *)&req->pdu.bhs; ++ int res = 0; ++ unsigned int not_received; ++ ++ TRACE_ENTRY(); ++ ++ if (req_hdr->flags & ISCSI_CMD_FINAL) { ++ if (req_hdr->flags & ISCSI_CMD_WRITE) ++ iscsi_set_not_received_data_len(req, ++ be32_to_cpu(req_hdr->data_length) - ++ req->pdu.datasize); ++ goto out; ++ } ++ ++ BUG_ON(req->outstanding_r2t != 0); ++ ++ res = cmnd_insert_data_wait_hash(req); ++ if (res != 0) { ++ /* ++ * We have to close connection, because otherwise a data ++ * corruption is possible if we allow to receive data ++ * for this request in another request with dublicated ITT. ++ */ ++ mark_conn_closed(req->conn); ++ goto out; ++ } ++ ++ /* ++ * We need to wait for one or more PDUs. Let's simplify ++ * other code and pretend we need to receive 1 byte. ++ * In data_out_start() we will correct it. ++ */ ++ req->outstanding_r2t = 1; ++ req_add_to_write_timeout_list(req); ++ req->r2t_len_to_receive = 1; ++ req->r2t_len_to_send = 0; ++ ++ not_received = be32_to_cpu(req_hdr->data_length) - req->pdu.datasize; ++ not_received -= min_t(unsigned int, not_received, ++ req->conn->session->sess_params.first_burst_length); ++ iscsi_set_not_received_data_len(req, not_received); ++ ++ TRACE_DBG("req %p, op %x, outstanding_r2t %d, r2t_len_to_receive %d, " ++ "r2t_len_to_send %d, not_received_data_len %d", req, ++ cmnd_opcode(req), req->outstanding_r2t, req->r2t_len_to_receive, ++ req->r2t_len_to_send, req->not_received_data_len); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int create_preliminary_no_scst_rsp(struct iscsi_cmnd *req, ++ int status, const u8 *sense_buf, int sense_len) ++{ ++ struct iscsi_cmnd *rsp; ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ if (req->prelim_compl_flags != 0) { ++ TRACE_MGMT_DBG("req %p already prelim completed", req); ++ goto out; ++ } ++ ++ req->scst_state = ISCSI_CMD_STATE_OUT_OF_SCST_PRELIM_COMPL; ++ ++ BUG_ON(req->scst_cmd != NULL); ++ ++ res = iscsi_preliminary_complete(req, req, true); ++ ++ rsp = iscsi_alloc_main_rsp(req); ++ TRACE_DBG("main rsp %p", rsp); ++ ++ iscsi_init_status_rsp(rsp, status, sense_buf, sense_len); ++ ++ /* Resid will be set in req_cmnd_release() */ ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++int set_scst_preliminary_status_rsp(struct iscsi_cmnd *req, ++ bool get_data, int key, int asc, int ascq) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ if (req->scst_cmd == NULL) { ++ /* There must be already error set */ ++ goto complete; ++ } ++ ++ scst_set_cmd_error(req->scst_cmd, key, asc, ascq); ++ ++complete: ++ res = iscsi_preliminary_complete(req, req, get_data); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int create_reject_rsp(struct iscsi_cmnd *req, int reason, bool get_data) ++{ ++ int res = 0; ++ struct iscsi_cmnd *rsp; ++ struct iscsi_reject_hdr *rsp_hdr; ++ struct scatterlist *sg; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Reject: req %p, reason %x", req, reason); ++ ++ if (cmnd_opcode(req) == ISCSI_OP_SCSI_CMD) { ++ if (req->scst_cmd == NULL) { ++ /* BUSY status must be already set */ ++ struct iscsi_scsi_rsp_hdr *rsp_hdr1; ++ rsp_hdr1 = (struct iscsi_scsi_rsp_hdr *)&req->main_rsp->pdu.bhs; ++ BUG_ON(rsp_hdr1->cmd_status == 0); ++ /* ++ * Let's not send REJECT here. The initiator will retry ++ * and, hopefully, next time we will not fail allocating ++ * scst_cmd, so we will then send the REJECT. ++ */ ++ goto out; ++ } else { ++ /* ++ * "In all the cases in which a pre-instantiated SCSI ++ * task is terminated because of the reject, the target ++ * MUST issue a proper SCSI command response with CHECK ++ * CONDITION as described in Section 10.4.3 Response" - ++ * RFC 3720. ++ */ ++ set_scst_preliminary_status_rsp(req, get_data, ++ SCST_LOAD_SENSE(scst_sense_invalid_message)); ++ } ++ } ++ ++ rsp = iscsi_alloc_main_rsp(req); ++ rsp_hdr = (struct iscsi_reject_hdr *)&rsp->pdu.bhs; ++ ++ rsp_hdr->opcode = ISCSI_OP_REJECT; ++ rsp_hdr->ffffffff = ISCSI_RESERVED_TAG; ++ rsp_hdr->reason = reason; ++ ++ sg = rsp->sg = rsp->rsp_sg; ++ rsp->sg_cnt = 1; ++ rsp->own_sg = 1; ++ sg_init_one(sg, &req->pdu.bhs, sizeof(struct iscsi_hdr)); ++ rsp->bufflen = rsp->pdu.datasize = sizeof(struct iscsi_hdr); ++ ++ res = iscsi_preliminary_complete(req, req, true); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static inline int iscsi_get_allowed_cmds(struct iscsi_session *sess) ++{ ++ int res = max(-1, (int)sess->tgt_params.queued_cmnds - ++ atomic_read(&sess->active_cmds)-1); ++ TRACE_DBG("allowed cmds %d (sess %p, active_cmds %d)", res, ++ sess, atomic_read(&sess->active_cmds)); ++ return res; ++} ++ ++static __be32 cmnd_set_sn(struct iscsi_cmnd *cmnd, int set_stat_sn) ++{ ++ struct iscsi_conn *conn = cmnd->conn; ++ struct iscsi_session *sess = conn->session; ++ __be32 res; ++ ++ spin_lock(&sess->sn_lock); ++ ++ if (set_stat_sn) ++ cmnd->pdu.bhs.sn = (__force u32)cpu_to_be32(conn->stat_sn++); ++ cmnd->pdu.bhs.exp_sn = (__force u32)cpu_to_be32(sess->exp_cmd_sn); ++ cmnd->pdu.bhs.max_sn = (__force u32)cpu_to_be32(sess->exp_cmd_sn + ++ iscsi_get_allowed_cmds(sess)); ++ ++ res = cpu_to_be32(conn->stat_sn); ++ ++ spin_unlock(&sess->sn_lock); ++ return res; ++} ++ ++/* Called under sn_lock */ ++static void update_stat_sn(struct iscsi_cmnd *cmnd) ++{ ++ struct iscsi_conn *conn = cmnd->conn; ++ u32 exp_stat_sn; ++ ++ cmnd->pdu.bhs.exp_sn = exp_stat_sn = be32_to_cpu((__force __be32)cmnd->pdu.bhs.exp_sn); ++ TRACE_DBG("%x,%x", cmnd_opcode(cmnd), exp_stat_sn); ++ if ((int)(exp_stat_sn - conn->exp_stat_sn) > 0 && ++ (int)(exp_stat_sn - conn->stat_sn) <= 0) { ++ /* free pdu resources */ ++ cmnd->conn->exp_stat_sn = exp_stat_sn; ++ } ++ return; ++} ++ ++static struct iscsi_cmnd *cmnd_find_itt_get(struct iscsi_conn *conn, __be32 itt) ++{ ++ struct iscsi_cmnd *cmnd, *found_cmnd = NULL; ++ ++ spin_lock_bh(&conn->cmd_list_lock); ++ list_for_each_entry(cmnd, &conn->cmd_list, cmd_list_entry) { ++ if ((cmnd->pdu.bhs.itt == itt) && !cmnd_get_check(cmnd)) { ++ found_cmnd = cmnd; ++ break; ++ } ++ } ++ spin_unlock_bh(&conn->cmd_list_lock); ++ ++ return found_cmnd; ++} ++ ++/** ++ ** We use the ITT hash only to find original request PDU for subsequent ++ ** Data-Out PDUs. ++ **/ ++ ++/* Must be called under cmnd_data_wait_hash_lock */ ++static struct iscsi_cmnd *__cmnd_find_data_wait_hash(struct iscsi_conn *conn, ++ __be32 itt) ++{ ++ struct list_head *head; ++ struct iscsi_cmnd *cmnd; ++ ++ head = &conn->session->cmnd_data_wait_hash[cmnd_hashfn((__force u32)itt)]; ++ ++ list_for_each_entry(cmnd, head, hash_list_entry) { ++ if (cmnd->pdu.bhs.itt == itt) ++ return cmnd; ++ } ++ return NULL; ++} ++ ++static struct iscsi_cmnd *cmnd_find_data_wait_hash(struct iscsi_conn *conn, ++ __be32 itt) ++{ ++ struct iscsi_cmnd *res; ++ struct iscsi_session *session = conn->session; ++ ++ spin_lock(&session->cmnd_data_wait_hash_lock); ++ res = __cmnd_find_data_wait_hash(conn, itt); ++ spin_unlock(&session->cmnd_data_wait_hash_lock); ++ ++ return res; ++} ++ ++static inline u32 get_next_ttt(struct iscsi_conn *conn) ++{ ++ u32 ttt; ++ struct iscsi_session *session = conn->session; ++ ++ /* Not compatible with MC/S! */ ++ ++ iscsi_extracheck_is_rd_thread(conn); ++ ++ if (unlikely(session->next_ttt == ISCSI_RESERVED_TAG_CPU32)) ++ session->next_ttt++; ++ ttt = session->next_ttt++; ++ ++ return ttt; ++} ++ ++static int cmnd_insert_data_wait_hash(struct iscsi_cmnd *cmnd) ++{ ++ struct iscsi_session *session = cmnd->conn->session; ++ struct iscsi_cmnd *tmp; ++ struct list_head *head; ++ int err = 0; ++ __be32 itt = cmnd->pdu.bhs.itt; ++ ++ if (unlikely(cmnd->hashed)) { ++ /* ++ * It can be for preliminary completed commands, when this ++ * function already failed. ++ */ ++ goto out; ++ } ++ ++ /* ++ * We don't need TTT, because ITT/buffer_offset pair is sufficient ++ * to find out the original request and buffer for Data-Out PDUs, but ++ * crazy iSCSI spec requires us to send this superfluous field in ++ * R2T PDUs and some initiators may rely on it. ++ */ ++ cmnd->target_task_tag = get_next_ttt(cmnd->conn); ++ ++ TRACE_DBG("%p:%x", cmnd, itt); ++ if (unlikely(itt == ISCSI_RESERVED_TAG)) { ++ PRINT_ERROR("%s", "ITT is RESERVED_TAG"); ++ PRINT_BUFFER("Incorrect BHS", &cmnd->pdu.bhs, ++ sizeof(cmnd->pdu.bhs)); ++ err = -ISCSI_REASON_PROTOCOL_ERROR; ++ goto out; ++ } ++ ++ spin_lock(&session->cmnd_data_wait_hash_lock); ++ ++ head = &session->cmnd_data_wait_hash[cmnd_hashfn((__force u32)itt)]; ++ ++ tmp = __cmnd_find_data_wait_hash(cmnd->conn, itt); ++ if (likely(!tmp)) { ++ TRACE_DBG("Adding cmnd %p to the hash (ITT %x)", cmnd, ++ cmnd->pdu.bhs.itt); ++ list_add_tail(&cmnd->hash_list_entry, head); ++ cmnd->hashed = 1; ++ } else { ++ PRINT_ERROR("Task %x in progress, cmnd %p", itt, cmnd); ++ err = -ISCSI_REASON_TASK_IN_PROGRESS; ++ } ++ ++ spin_unlock(&session->cmnd_data_wait_hash_lock); ++ ++out: ++ return err; ++} ++ ++static void cmnd_remove_data_wait_hash(struct iscsi_cmnd *cmnd) ++{ ++ struct iscsi_session *session = cmnd->conn->session; ++ struct iscsi_cmnd *tmp; ++ ++ spin_lock(&session->cmnd_data_wait_hash_lock); ++ ++ tmp = __cmnd_find_data_wait_hash(cmnd->conn, cmnd->pdu.bhs.itt); ++ ++ if (likely(tmp && tmp == cmnd)) { ++ TRACE_DBG("Deleting cmnd %p from the hash (ITT %x)", cmnd, ++ cmnd->pdu.bhs.itt); ++ list_del(&cmnd->hash_list_entry); ++ cmnd->hashed = 0; ++ } else ++ PRINT_ERROR("%p:%x not found", cmnd, cmnd->pdu.bhs.itt); ++ ++ spin_unlock(&session->cmnd_data_wait_hash_lock); ++ ++ return; ++} ++ ++static void cmnd_prepare_get_rejected_immed_data(struct iscsi_cmnd *cmnd) ++{ ++ struct iscsi_conn *conn = cmnd->conn; ++ struct scatterlist *sg = cmnd->sg; ++ char __user *addr; ++ u32 size; ++ unsigned int i; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG_FLAG(iscsi_get_flow_ctrl_or_mgmt_dbg_log_flag(cmnd), ++ "Skipping (cmnd %p, ITT %x, op %x, cmd op %x, " ++ "datasize %u, scst_cmd %p, scst state %d)", cmnd, ++ cmnd->pdu.bhs.itt, cmnd_opcode(cmnd), cmnd_hdr(cmnd)->scb[0], ++ cmnd->pdu.datasize, cmnd->scst_cmd, cmnd->scst_state); ++ ++ iscsi_extracheck_is_rd_thread(conn); ++ ++ size = cmnd->pdu.datasize; ++ if (!size) ++ goto out; ++ ++ /* We already checked pdu.datasize in check_segment_length() */ ++ ++ /* ++ * There are no problems with the safety from concurrent ++ * accesses to dummy_page in dummy_sg, since data only ++ * will be read and then discarded. ++ */ ++ sg = &dummy_sg; ++ if (cmnd->sg == NULL) { ++ /* just in case */ ++ cmnd->sg = sg; ++ cmnd->bufflen = PAGE_SIZE; ++ cmnd->own_sg = 1; ++ } ++ ++ addr = (char __force __user *)(page_address(sg_page(&sg[0]))); ++ conn->read_size = size; ++ for (i = 0; size > PAGE_SIZE; i++, size -= PAGE_SIZE) { ++ /* We already checked pdu.datasize in check_segment_length() */ ++ BUG_ON(i >= ISCSI_CONN_IOV_MAX); ++ conn->read_iov[i].iov_base = addr; ++ conn->read_iov[i].iov_len = PAGE_SIZE; ++ } ++ conn->read_iov[i].iov_base = addr; ++ conn->read_iov[i].iov_len = size; ++ conn->read_msg.msg_iov = conn->read_iov; ++ conn->read_msg.msg_iovlen = ++i; ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++int iscsi_preliminary_complete(struct iscsi_cmnd *req, ++ struct iscsi_cmnd *orig_req, bool get_data) ++{ ++ int res = 0; ++ bool set_r2t_len; ++ struct iscsi_hdr *orig_req_hdr = &orig_req->pdu.bhs; ++ ++ TRACE_ENTRY(); ++ ++#ifdef CONFIG_SCST_DEBUG ++ { ++ struct iscsi_hdr *req_hdr = &req->pdu.bhs; ++ TRACE_DBG_FLAG(iscsi_get_flow_ctrl_or_mgmt_dbg_log_flag(orig_req), ++ "Prelim completed req %p, orig_req %p (FINAL %x, " ++ "outstanding_r2t %d)", req, orig_req, ++ (req_hdr->flags & ISCSI_CMD_FINAL), ++ orig_req->outstanding_r2t); ++ } ++#endif ++ ++ iscsi_extracheck_is_rd_thread(req->conn); ++ BUG_ON(req->parent_req != NULL); ++ ++ if (test_bit(ISCSI_CMD_PRELIM_COMPLETED, &req->prelim_compl_flags)) { ++ TRACE_MGMT_DBG("req %p already prelim completed", req); ++ /* To not try to get data twice */ ++ get_data = false; ++ } ++ ++ /* ++ * We need to receive all outstanding PDUs, even if direction isn't ++ * WRITE. Test of PRELIM_COMPLETED is needed, because ++ * iscsi_set_prelim_r2t_len_to_receive() could also have failed before. ++ */ ++ set_r2t_len = !orig_req->hashed && ++ (cmnd_opcode(orig_req) == ISCSI_OP_SCSI_CMD) && ++ !test_bit(ISCSI_CMD_PRELIM_COMPLETED, ++ &orig_req->prelim_compl_flags); ++ ++ TRACE_DBG("get_data %d, set_r2t_len %d", get_data, set_r2t_len); ++ ++ if (get_data) ++ cmnd_prepare_get_rejected_immed_data(req); ++ ++ if (test_bit(ISCSI_CMD_PRELIM_COMPLETED, &orig_req->prelim_compl_flags)) ++ goto out_set; ++ ++ if (set_r2t_len) ++ res = iscsi_set_prelim_r2t_len_to_receive(orig_req); ++ else if (orig_req_hdr->flags & ISCSI_CMD_WRITE) { ++ /* ++ * We will get here if orig_req prelim completed in the middle ++ * of data receiving. We won't send more R2T's, so ++ * r2t_len_to_send is final and won't be updated anymore in ++ * future. ++ */ ++ iscsi_set_not_received_data_len(orig_req, ++ orig_req->r2t_len_to_send); ++ } ++ ++out_set: ++ set_bit(ISCSI_CMD_PRELIM_COMPLETED, &orig_req->prelim_compl_flags); ++ set_bit(ISCSI_CMD_PRELIM_COMPLETED, &req->prelim_compl_flags); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int cmnd_prepare_recv_pdu(struct iscsi_conn *conn, ++ struct iscsi_cmnd *cmd, u32 offset, u32 size) ++{ ++ struct scatterlist *sg = cmd->sg; ++ unsigned int bufflen = cmd->bufflen; ++ unsigned int idx, i, buff_offs; ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("cmd %p, sg %p, offset %u, size %u", cmd, cmd->sg, ++ offset, size); ++ ++ iscsi_extracheck_is_rd_thread(conn); ++ ++ buff_offs = offset; ++ idx = (offset + sg[0].offset) >> PAGE_SHIFT; ++ offset &= ~PAGE_MASK; ++ ++ conn->read_msg.msg_iov = conn->read_iov; ++ conn->read_size = size; ++ ++ i = 0; ++ while (1) { ++ unsigned int sg_len; ++ char __user *addr; ++ ++ if (unlikely(buff_offs >= bufflen)) { ++ TRACE_DBG("Residual overflow (cmd %p, buff_offs %d, " ++ "bufflen %d)", cmd, buff_offs, bufflen); ++ idx = 0; ++ sg = &dummy_sg; ++ offset = 0; ++ } ++ ++ addr = (char __force __user *)(sg_virt(&sg[idx])); ++ EXTRACHECKS_BUG_ON(addr == NULL); ++ sg_len = sg[idx].length - offset; ++ ++ conn->read_iov[i].iov_base = addr + offset; ++ ++ if (size <= sg_len) { ++ TRACE_DBG("idx=%d, i=%d, offset=%u, size=%d, addr=%p", ++ idx, i, offset, size, addr); ++ conn->read_iov[i].iov_len = size; ++ conn->read_msg.msg_iovlen = i+1; ++ break; ++ } ++ conn->read_iov[i].iov_len = sg_len; ++ ++ TRACE_DBG("idx=%d, i=%d, offset=%u, size=%d, sg_len=%u, " ++ "addr=%p", idx, i, offset, size, sg_len, addr); ++ ++ size -= sg_len; ++ buff_offs += sg_len; ++ ++ i++; ++ if (unlikely(i >= ISCSI_CONN_IOV_MAX)) { ++ PRINT_ERROR("Initiator %s violated negotiated " ++ "parameters by sending too much data (size " ++ "left %d)", conn->session->initiator_name, ++ size); ++ mark_conn_closed(conn); ++ res = -EINVAL; ++ break; ++ } ++ ++ idx++; ++ offset = 0; ++ } ++ ++ TRACE_DBG("msg_iov=%p, msg_iovlen=%zd", ++ conn->read_msg.msg_iov, conn->read_msg.msg_iovlen); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void send_r2t(struct iscsi_cmnd *req) ++{ ++ struct iscsi_session *sess = req->conn->session; ++ struct iscsi_cmnd *rsp; ++ struct iscsi_r2t_hdr *rsp_hdr; ++ u32 offset, burst; ++ LIST_HEAD(send); ++ ++ TRACE_ENTRY(); ++ ++ EXTRACHECKS_BUG_ON(req->r2t_len_to_send == 0); ++ ++ /* ++ * There is no race with data_out_start() and conn_abort(), since ++ * all functions called from single read thread ++ */ ++ iscsi_extracheck_is_rd_thread(req->conn); ++ ++ /* ++ * We don't need to check for PRELIM_COMPLETED here, because for such ++ * commands we set r2t_len_to_send = 0, hence made sure we won't be ++ * called here. ++ */ ++ ++ EXTRACHECKS_BUG_ON(req->outstanding_r2t > ++ sess->sess_params.max_outstanding_r2t); ++ ++ if (req->outstanding_r2t == sess->sess_params.max_outstanding_r2t) ++ goto out; ++ ++ burst = sess->sess_params.max_burst_length; ++ offset = be32_to_cpu(cmnd_hdr(req)->data_length) - ++ req->r2t_len_to_send; ++ ++ do { ++ rsp = iscsi_alloc_rsp(req); ++ rsp->pdu.bhs.ttt = (__force __be32)req->target_task_tag; ++ rsp_hdr = (struct iscsi_r2t_hdr *)&rsp->pdu.bhs; ++ rsp_hdr->opcode = ISCSI_OP_R2T; ++ rsp_hdr->flags = ISCSI_FLG_FINAL; ++ rsp_hdr->lun = cmnd_hdr(req)->lun; ++ rsp_hdr->itt = cmnd_hdr(req)->itt; ++ rsp_hdr->r2t_sn = (__force u32)cpu_to_be32(req->r2t_sn++); ++ rsp_hdr->buffer_offset = cpu_to_be32(offset); ++ if (req->r2t_len_to_send > burst) { ++ rsp_hdr->data_length = cpu_to_be32(burst); ++ req->r2t_len_to_send -= burst; ++ offset += burst; ++ } else { ++ rsp_hdr->data_length = cpu_to_be32(req->r2t_len_to_send); ++ req->r2t_len_to_send = 0; ++ } ++ ++ TRACE_WRITE("req %p, data_length %u, buffer_offset %u, " ++ "r2t_sn %u, outstanding_r2t %u", req, ++ be32_to_cpu(rsp_hdr->data_length), ++ be32_to_cpu(rsp_hdr->buffer_offset), ++ be32_to_cpu((__force __be32)rsp_hdr->r2t_sn), req->outstanding_r2t); ++ ++ list_add_tail(&rsp->write_list_entry, &send); ++ req->outstanding_r2t++; ++ ++ } while ((req->outstanding_r2t < sess->sess_params.max_outstanding_r2t) && ++ (req->r2t_len_to_send != 0)); ++ ++ iscsi_cmnds_init_write(&send, ISCSI_INIT_WRITE_WAKE); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static int iscsi_pre_exec(struct scst_cmd *scst_cmd) ++{ ++ int res = SCST_PREPROCESS_STATUS_SUCCESS; ++ struct iscsi_cmnd *req = (struct iscsi_cmnd *) ++ scst_cmd_get_tgt_priv(scst_cmd); ++ struct iscsi_cmnd *c, *t; ++ ++ TRACE_ENTRY(); ++ ++ EXTRACHECKS_BUG_ON(scst_cmd_atomic(scst_cmd)); ++ ++ /* If data digest isn't used this list will be empty */ ++ list_for_each_entry_safe(c, t, &req->rx_ddigest_cmd_list, ++ rx_ddigest_cmd_list_entry) { ++ TRACE_DBG("Checking digest of RX ddigest cmd %p", c); ++ if (digest_rx_data(c) != 0) { ++ scst_set_cmd_error(scst_cmd, ++ SCST_LOAD_SENSE(iscsi_sense_crc_error)); ++ res = SCST_PREPROCESS_STATUS_ERROR_SENSE_SET; ++ /* ++ * The rest of rx_ddigest_cmd_list will be freed ++ * in req_cmnd_release() ++ */ ++ goto out; ++ } ++ cmd_del_from_rx_ddigest_list(c); ++ cmnd_put(c); ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int nop_out_start(struct iscsi_cmnd *cmnd) ++{ ++ struct iscsi_conn *conn = cmnd->conn; ++ struct iscsi_hdr *req_hdr = &cmnd->pdu.bhs; ++ u32 size, tmp; ++ int i, err = 0; ++ ++ TRACE_DBG("%p", cmnd); ++ ++ iscsi_extracheck_is_rd_thread(conn); ++ ++ if (!(req_hdr->flags & ISCSI_FLG_FINAL)) { ++ PRINT_ERROR("%s", "Initiator sent Nop-Out with not a single " ++ "PDU"); ++ err = -ISCSI_REASON_PROTOCOL_ERROR; ++ goto out; ++ } ++ ++ if (cmnd->pdu.bhs.itt == ISCSI_RESERVED_TAG) { ++ if (unlikely(!(cmnd->pdu.bhs.opcode & ISCSI_OP_IMMEDIATE))) ++ PRINT_ERROR("%s", "Initiator sent RESERVED tag for " ++ "non-immediate Nop-Out command"); ++ } ++ ++ update_stat_sn(cmnd); ++ ++ size = cmnd->pdu.datasize; ++ ++ if (size) { ++ conn->read_msg.msg_iov = conn->read_iov; ++ if (cmnd->pdu.bhs.itt != ISCSI_RESERVED_TAG) { ++ struct scatterlist *sg; ++ ++ cmnd->sg = sg = scst_alloc(size, GFP_KERNEL, ++ &cmnd->sg_cnt); ++ if (sg == NULL) { ++ TRACE(TRACE_OUT_OF_MEM, "Allocation of buffer " ++ "for %d Nop-Out payload failed", size); ++ err = -ISCSI_REASON_OUT_OF_RESOURCES; ++ goto out; ++ } ++ ++ /* We already checked it in check_segment_length() */ ++ BUG_ON(cmnd->sg_cnt > (signed)ISCSI_CONN_IOV_MAX); ++ ++ cmnd->own_sg = 1; ++ cmnd->bufflen = size; ++ ++ for (i = 0; i < cmnd->sg_cnt; i++) { ++ conn->read_iov[i].iov_base = ++ (void __force __user *)(page_address(sg_page(&sg[i]))); ++ tmp = min_t(u32, size, PAGE_SIZE); ++ conn->read_iov[i].iov_len = tmp; ++ conn->read_size += tmp; ++ size -= tmp; ++ } ++ BUG_ON(size != 0); ++ } else { ++ /* ++ * There are no problems with the safety from concurrent ++ * accesses to dummy_page, since for ISCSI_RESERVED_TAG ++ * the data only read and then discarded. ++ */ ++ for (i = 0; i < (signed)ISCSI_CONN_IOV_MAX; i++) { ++ conn->read_iov[i].iov_base = ++ (void __force __user *)(page_address(dummy_page)); ++ tmp = min_t(u32, size, PAGE_SIZE); ++ conn->read_iov[i].iov_len = tmp; ++ conn->read_size += tmp; ++ size -= tmp; ++ } ++ ++ /* We already checked size in check_segment_length() */ ++ BUG_ON(size != 0); ++ } ++ ++ conn->read_msg.msg_iovlen = i; ++ TRACE_DBG("msg_iov=%p, msg_iovlen=%zd", conn->read_msg.msg_iov, ++ conn->read_msg.msg_iovlen); ++ } ++ ++out: ++ return err; ++} ++ ++int cmnd_rx_continue(struct iscsi_cmnd *req) ++{ ++ struct iscsi_conn *conn = req->conn; ++ struct iscsi_session *session = conn->session; ++ struct iscsi_scsi_cmd_hdr *req_hdr = cmnd_hdr(req); ++ struct scst_cmd *scst_cmd = req->scst_cmd; ++ scst_data_direction dir; ++ bool unsolicited_data_expected = false; ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("scsi command: %x", req_hdr->scb[0]); ++ ++ EXTRACHECKS_BUG_ON(req->scst_state != ISCSI_CMD_STATE_AFTER_PREPROC); ++ ++ dir = scst_cmd_get_data_direction(scst_cmd); ++ ++ /* ++ * Check for preliminary completion here to save R2Ts. For TASK QUEUE ++ * FULL statuses that might be a big performance win. ++ */ ++ if (unlikely(scst_cmd_prelim_completed(scst_cmd) || ++ unlikely(req->prelim_compl_flags != 0))) { ++ /* ++ * If necessary, ISCSI_CMD_ABORTED will be set by ++ * iscsi_xmit_response(). ++ */ ++ res = iscsi_preliminary_complete(req, req, true); ++ goto trace; ++ } ++ ++ /* For prelim completed commands sg & K can be already set! */ ++ ++ if (dir & SCST_DATA_WRITE) { ++ req->bufflen = scst_cmd_get_write_fields(scst_cmd, &req->sg, ++ &req->sg_cnt); ++ unsolicited_data_expected = !(req_hdr->flags & ISCSI_CMD_FINAL); ++ ++ if (unlikely(session->sess_params.initial_r2t && ++ unsolicited_data_expected)) { ++ PRINT_ERROR("Initiator %s violated negotiated " ++ "parameters: initial R2T is required (ITT %x, " ++ "op %x)", session->initiator_name, ++ req->pdu.bhs.itt, req_hdr->scb[0]); ++ goto out_close; ++ } ++ ++ if (unlikely(!session->sess_params.immediate_data && ++ req->pdu.datasize)) { ++ PRINT_ERROR("Initiator %s violated negotiated " ++ "parameters: forbidden immediate data sent " ++ "(ITT %x, op %x)", session->initiator_name, ++ req->pdu.bhs.itt, req_hdr->scb[0]); ++ goto out_close; ++ } ++ ++ if (unlikely(session->sess_params.first_burst_length < req->pdu.datasize)) { ++ PRINT_ERROR("Initiator %s violated negotiated " ++ "parameters: immediate data len (%d) > " ++ "first_burst_length (%d) (ITT %x, op %x)", ++ session->initiator_name, ++ req->pdu.datasize, ++ session->sess_params.first_burst_length, ++ req->pdu.bhs.itt, req_hdr->scb[0]); ++ goto out_close; ++ } ++ ++ req->r2t_len_to_receive = be32_to_cpu(req_hdr->data_length) - ++ req->pdu.datasize; ++ ++ /* ++ * In case of residual overflow req->r2t_len_to_receive and ++ * req->pdu.datasize might be > req->bufflen ++ */ ++ ++ res = cmnd_insert_data_wait_hash(req); ++ if (unlikely(res != 0)) { ++ /* ++ * We have to close connection, because otherwise a data ++ * corruption is possible if we allow to receive data ++ * for this request in another request with dublicated ++ * ITT. ++ */ ++ goto out_close; ++ } ++ ++ if (unsolicited_data_expected) { ++ req->outstanding_r2t = 1; ++ req->r2t_len_to_send = req->r2t_len_to_receive - ++ min_t(unsigned int, ++ session->sess_params.first_burst_length - ++ req->pdu.datasize, ++ req->r2t_len_to_receive); ++ } else ++ req->r2t_len_to_send = req->r2t_len_to_receive; ++ ++ req_add_to_write_timeout_list(req); ++ ++ if (req->pdu.datasize) { ++ res = cmnd_prepare_recv_pdu(conn, req, 0, req->pdu.datasize); ++ /* For performance better to send R2Ts ASAP */ ++ if (likely(res == 0) && (req->r2t_len_to_send != 0)) ++ send_r2t(req); ++ } ++ } else { ++ req->sg = scst_cmd_get_sg(scst_cmd); ++ req->sg_cnt = scst_cmd_get_sg_cnt(scst_cmd); ++ req->bufflen = scst_cmd_get_bufflen(scst_cmd); ++ ++ if (unlikely(!(req_hdr->flags & ISCSI_CMD_FINAL) || ++ req->pdu.datasize)) { ++ PRINT_ERROR("Unexpected unsolicited data (ITT %x " ++ "CDB %x)", req->pdu.bhs.itt, req_hdr->scb[0]); ++ set_scst_preliminary_status_rsp(req, true, ++ SCST_LOAD_SENSE(iscsi_sense_unexpected_unsolicited_data)); ++ } ++ } ++ ++trace: ++ TRACE_DBG("req=%p, dir=%d, unsolicited_data_expected=%d, " ++ "r2t_len_to_receive=%d, r2t_len_to_send=%d, bufflen=%d, " ++ "own_sg %d", req, dir, unsolicited_data_expected, ++ req->r2t_len_to_receive, req->r2t_len_to_send, req->bufflen, ++ req->own_sg); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_close: ++ mark_conn_closed(conn); ++ res = -EINVAL; ++ goto out; ++} ++ ++static int scsi_cmnd_start(struct iscsi_cmnd *req) ++{ ++ struct iscsi_conn *conn = req->conn; ++ struct iscsi_session *session = conn->session; ++ struct iscsi_scsi_cmd_hdr *req_hdr = cmnd_hdr(req); ++ struct scst_cmd *scst_cmd; ++ scst_data_direction dir; ++ struct iscsi_ahs_hdr *ahdr; ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("scsi command: %x", req_hdr->scb[0]); ++ ++ TRACE_DBG("Incrementing active_cmds (cmd %p, sess %p, " ++ "new value %d)", req, session, ++ atomic_read(&session->active_cmds)+1); ++ atomic_inc(&session->active_cmds); ++ req->dec_active_cmds = 1; ++ ++ scst_cmd = scst_rx_cmd(session->scst_sess, ++ (uint8_t *)&req_hdr->lun, sizeof(req_hdr->lun), ++ req_hdr->scb, sizeof(req_hdr->scb), SCST_NON_ATOMIC); ++ if (scst_cmd == NULL) { ++ res = create_preliminary_no_scst_rsp(req, SAM_STAT_BUSY, ++ NULL, 0); ++ goto out; ++ } ++ ++ req->scst_cmd = scst_cmd; ++ scst_cmd_set_tag(scst_cmd, (__force u32)req_hdr->itt); ++ scst_cmd_set_tgt_priv(scst_cmd, req); ++ ++ if ((req_hdr->flags & ISCSI_CMD_READ) && ++ (req_hdr->flags & ISCSI_CMD_WRITE)) { ++ int sz = cmnd_read_size(req); ++ if (unlikely(sz < 0)) { ++ PRINT_ERROR("%s", "BIDI data transfer, but initiator " ++ "not supplied Bidirectional Read Expected Data " ++ "Transfer Length AHS"); ++ set_scst_preliminary_status_rsp(req, true, ++ SCST_LOAD_SENSE(scst_sense_parameter_value_invalid)); ++ } else { ++ dir = SCST_DATA_BIDI; ++ scst_cmd_set_expected(scst_cmd, dir, sz); ++ scst_cmd_set_expected_out_transfer_len(scst_cmd, ++ be32_to_cpu(req_hdr->data_length)); ++#if !defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++ scst_cmd_set_tgt_need_alloc_data_buf(scst_cmd); ++#endif ++ } ++ } else if (req_hdr->flags & ISCSI_CMD_READ) { ++ dir = SCST_DATA_READ; ++ scst_cmd_set_expected(scst_cmd, dir, ++ be32_to_cpu(req_hdr->data_length)); ++#if !defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++ scst_cmd_set_tgt_need_alloc_data_buf(scst_cmd); ++#endif ++ } else if (req_hdr->flags & ISCSI_CMD_WRITE) { ++ dir = SCST_DATA_WRITE; ++ scst_cmd_set_expected(scst_cmd, dir, ++ be32_to_cpu(req_hdr->data_length)); ++ } else { ++ dir = SCST_DATA_NONE; ++ scst_cmd_set_expected(scst_cmd, dir, 0); ++ } ++ ++ switch (req_hdr->flags & ISCSI_CMD_ATTR_MASK) { ++ case ISCSI_CMD_SIMPLE: ++ scst_cmd_set_queue_type(scst_cmd, SCST_CMD_QUEUE_SIMPLE); ++ break; ++ case ISCSI_CMD_HEAD_OF_QUEUE: ++ scst_cmd_set_queue_type(scst_cmd, SCST_CMD_QUEUE_HEAD_OF_QUEUE); ++ break; ++ case ISCSI_CMD_ORDERED: ++ scst_cmd_set_queue_type(scst_cmd, SCST_CMD_QUEUE_ORDERED); ++ break; ++ case ISCSI_CMD_ACA: ++ scst_cmd_set_queue_type(scst_cmd, SCST_CMD_QUEUE_ACA); ++ break; ++ case ISCSI_CMD_UNTAGGED: ++ scst_cmd_set_queue_type(scst_cmd, SCST_CMD_QUEUE_UNTAGGED); ++ break; ++ default: ++ PRINT_ERROR("Unknown task code %x, use ORDERED instead", ++ req_hdr->flags & ISCSI_CMD_ATTR_MASK); ++ scst_cmd_set_queue_type(scst_cmd, SCST_CMD_QUEUE_ORDERED); ++ break; ++ } ++ ++ scst_cmd_set_tgt_sn(scst_cmd, req_hdr->cmd_sn); ++ ++ ahdr = (struct iscsi_ahs_hdr *)req->pdu.ahs; ++ if (ahdr != NULL) { ++ uint8_t *p = (uint8_t *)ahdr; ++ unsigned int size = 0; ++ do { ++ int s; ++ ++ ahdr = (struct iscsi_ahs_hdr *)p; ++ ++ if (ahdr->ahstype == ISCSI_AHSTYPE_CDB) { ++ struct iscsi_cdb_ahdr *eca = ++ (struct iscsi_cdb_ahdr *)ahdr; ++ scst_cmd_set_ext_cdb(scst_cmd, eca->cdb, ++ be16_to_cpu(ahdr->ahslength) - 1, ++ GFP_KERNEL); ++ break; ++ } ++ s = 3 + be16_to_cpu(ahdr->ahslength); ++ s = (s + 3) & -4; ++ size += s; ++ p += s; ++ } while (size < req->pdu.ahssize); ++ } ++ ++ TRACE_DBG("START Command (itt %x, queue_type %d)", ++ req_hdr->itt, scst_cmd_get_queue_type(scst_cmd)); ++ req->scst_state = ISCSI_CMD_STATE_RX_CMD; ++ conn->rx_task = current; ++ scst_cmd_init_stage1_done(scst_cmd, SCST_CONTEXT_DIRECT, 0); ++ ++ if (req->scst_state != ISCSI_CMD_STATE_RX_CMD) ++ res = cmnd_rx_continue(req); ++ else { ++ TRACE_DBG("Delaying req %p post processing (scst_state %d)", ++ req, req->scst_state); ++ res = 1; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int data_out_start(struct iscsi_cmnd *cmnd) ++{ ++ struct iscsi_conn *conn = cmnd->conn; ++ struct iscsi_data_out_hdr *req_hdr = ++ (struct iscsi_data_out_hdr *)&cmnd->pdu.bhs; ++ struct iscsi_cmnd *orig_req; ++#if 0 ++ struct iscsi_hdr *orig_req_hdr; ++#endif ++ u32 offset = be32_to_cpu(req_hdr->buffer_offset); ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * There is no race with send_r2t(), conn_abort() and ++ * iscsi_check_tm_data_wait_timeouts(), since ++ * all the functions called from single read thread ++ */ ++ iscsi_extracheck_is_rd_thread(cmnd->conn); ++ ++ update_stat_sn(cmnd); ++ ++ orig_req = cmnd_find_data_wait_hash(conn, req_hdr->itt); ++ cmnd->cmd_req = orig_req; ++ if (unlikely(orig_req == NULL)) { ++ /* ++ * It shouldn't happen, since we don't abort any request until ++ * we received all related PDUs from the initiator or timeout ++ * them. Let's quietly drop such PDUs. ++ */ ++ TRACE_MGMT_DBG("Unable to find scsi task ITT %x", ++ cmnd->pdu.bhs.itt); ++ res = iscsi_preliminary_complete(cmnd, cmnd, true); ++ goto out; ++ } ++ ++ cmnd_get(orig_req); ++ ++ if (unlikely(orig_req->r2t_len_to_receive < cmnd->pdu.datasize)) { ++ if (orig_req->prelim_compl_flags != 0) { ++ /* We can have fake r2t_len_to_receive */ ++ goto go; ++ } ++ PRINT_ERROR("Data size (%d) > R2T length to receive (%d)", ++ cmnd->pdu.datasize, orig_req->r2t_len_to_receive); ++ set_scst_preliminary_status_rsp(orig_req, false, ++ SCST_LOAD_SENSE(iscsi_sense_incorrect_amount_of_data)); ++ goto go; ++ } ++ ++ /* Crazy iSCSI spec requires us to make this unneeded check */ ++#if 0 /* ...but some initiators (Windows) don't care to correctly set it */ ++ orig_req_hdr = &orig_req->pdu.bhs; ++ if (unlikely(orig_req_hdr->lun != req_hdr->lun)) { ++ PRINT_ERROR("Wrong LUN (%lld) in Data-Out PDU (expected %lld), " ++ "orig_req %p, cmnd %p", (unsigned long long)req_hdr->lun, ++ (unsigned long long)orig_req_hdr->lun, orig_req, cmnd); ++ create_reject_rsp(orig_req, ISCSI_REASON_PROTOCOL_ERROR, false); ++ goto go; ++ } ++#endif ++ ++go: ++ if (req_hdr->flags & ISCSI_FLG_FINAL) ++ orig_req->outstanding_r2t--; ++ ++ EXTRACHECKS_BUG_ON(orig_req->data_out_in_data_receiving); ++ orig_req->data_out_in_data_receiving = 1; ++ ++ TRACE_WRITE("cmnd %p, orig_req %p, offset %u, datasize %u", cmnd, ++ orig_req, offset, cmnd->pdu.datasize); ++ ++ if (unlikely(orig_req->prelim_compl_flags != 0)) ++ res = iscsi_preliminary_complete(cmnd, orig_req, true); ++ else ++ res = cmnd_prepare_recv_pdu(conn, orig_req, offset, cmnd->pdu.datasize); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static void data_out_end(struct iscsi_cmnd *cmnd) ++{ ++ struct iscsi_data_out_hdr *req_hdr = ++ (struct iscsi_data_out_hdr *)&cmnd->pdu.bhs; ++ struct iscsi_cmnd *req; ++ ++ TRACE_ENTRY(); ++ ++ EXTRACHECKS_BUG_ON(cmnd == NULL); ++ req = cmnd->cmd_req; ++ if (unlikely(req == NULL)) ++ goto out; ++ ++ TRACE_DBG("cmnd %p, req %p", cmnd, req); ++ ++ iscsi_extracheck_is_rd_thread(cmnd->conn); ++ ++ req->data_out_in_data_receiving = 0; ++ ++ if (!(cmnd->conn->ddigest_type & DIGEST_NONE) && ++ !cmnd->ddigest_checked) { ++ cmd_add_on_rx_ddigest_list(req, cmnd); ++ cmnd_get(cmnd); ++ } ++ ++ /* ++ * Now we received the data and can adjust r2t_len_to_receive of the ++ * orig req. We couldn't do it earlier, because it will break data ++ * receiving errors recovery (calls of iscsi_fail_data_waiting_cmnd()). ++ */ ++ req->r2t_len_to_receive -= cmnd->pdu.datasize; ++ ++ if (unlikely(req->prelim_compl_flags != 0)) { ++ /* ++ * We need to call iscsi_preliminary_complete() again ++ * to handle the case if we just been aborted. This call must ++ * be done before zeroing r2t_len_to_send to correctly calc. ++ * residual. ++ */ ++ iscsi_preliminary_complete(cmnd, req, false); ++ ++ /* ++ * We might need to wait for one or more PDUs. Let's simplify ++ * other code and not perform exact r2t_len_to_receive ++ * calculation. ++ */ ++ req->r2t_len_to_receive = req->outstanding_r2t; ++ req->r2t_len_to_send = 0; ++ } ++ ++ TRACE_DBG("req %p, FINAL %x, outstanding_r2t %d, r2t_len_to_receive %d," ++ " r2t_len_to_send %d", req, req_hdr->flags & ISCSI_FLG_FINAL, ++ req->outstanding_r2t, req->r2t_len_to_receive, ++ req->r2t_len_to_send); ++ ++ if (!(req_hdr->flags & ISCSI_FLG_FINAL)) ++ goto out_put; ++ ++ if (req->r2t_len_to_receive == 0) { ++ if (!req->pending) ++ iscsi_restart_cmnd(req); ++ } else if (req->r2t_len_to_send != 0) ++ send_r2t(req); ++ ++out_put: ++ cmnd_put(req); ++ cmnd->cmd_req = NULL; ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Might be called under target_mutex and cmd_list_lock */ ++static void __cmnd_abort(struct iscsi_cmnd *cmnd) ++{ ++ unsigned long timeout_time = jiffies + ISCSI_TM_DATA_WAIT_TIMEOUT + ++ ISCSI_ADD_SCHED_TIME; ++ struct iscsi_conn *conn = cmnd->conn; ++ ++ TRACE_MGMT_DBG("Aborting cmd %p, scst_cmd %p (scst state %x, " ++ "ref_cnt %d, on_write_timeout_list %d, write_start %ld, ITT %x, " ++ "sn %u, op %x, r2t_len_to_receive %d, r2t_len_to_send %d, " ++ "CDB op %x, size to write %u, outstanding_r2t %d, " ++ "sess->exp_cmd_sn %u, conn %p, rd_task %p, read_cmnd %p, " ++ "read_state %d)", cmnd, cmnd->scst_cmd, cmnd->scst_state, ++ atomic_read(&cmnd->ref_cnt), cmnd->on_write_timeout_list, ++ cmnd->write_start, cmnd->pdu.bhs.itt, cmnd->pdu.bhs.sn, ++ cmnd_opcode(cmnd), cmnd->r2t_len_to_receive, ++ cmnd->r2t_len_to_send, cmnd_scsicode(cmnd), ++ cmnd_write_size(cmnd), cmnd->outstanding_r2t, ++ cmnd->conn->session->exp_cmd_sn, cmnd->conn, ++ cmnd->conn->rd_task, cmnd->conn->read_cmnd, ++ cmnd->conn->read_state); ++ ++#if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++ TRACE_MGMT_DBG("net_ref_cnt %d", atomic_read(&cmnd->net_ref_cnt)); ++#endif ++ ++ /* ++ * Lock to sync with iscsi_check_tm_data_wait_timeouts(), including ++ * CMD_ABORTED bit set. ++ */ ++ spin_lock_bh(&conn->conn_thr_pool->rd_lock); ++ ++ /* ++ * We suppose that preliminary commands completion is tested by ++ * comparing prelim_compl_flags with 0. Otherwise a race is possible, ++ * like sending command in SCST core as PRELIM_COMPLETED, while it ++ * wasn't aborted in it yet and have as the result a wrong success ++ * status sent to the initiator. ++ */ ++ set_bit(ISCSI_CMD_ABORTED, &cmnd->prelim_compl_flags); ++ ++ TRACE_MGMT_DBG("Setting conn_tm_active for conn %p", conn); ++ conn->conn_tm_active = 1; ++ ++ spin_unlock_bh(&conn->conn_thr_pool->rd_lock); ++ ++ /* ++ * We need the lock to sync with req_add_to_write_timeout_list() and ++ * close races for rsp_timer.expires. ++ */ ++ spin_lock_bh(&conn->write_list_lock); ++ if (!timer_pending(&conn->rsp_timer) || ++ time_after(conn->rsp_timer.expires, timeout_time)) { ++ TRACE_MGMT_DBG("Mod timer on %ld (conn %p)", timeout_time, ++ conn); ++ mod_timer(&conn->rsp_timer, timeout_time); ++ } else ++ TRACE_MGMT_DBG("Timer for conn %p is going to fire on %ld " ++ "(timeout time %ld)", conn, conn->rsp_timer.expires, ++ timeout_time); ++ spin_unlock_bh(&conn->write_list_lock); ++ ++ return; ++} ++ ++/* Must be called from the read or conn close thread */ ++static int cmnd_abort_pre_checks(struct iscsi_cmnd *req, int *status) ++{ ++ struct iscsi_task_mgt_hdr *req_hdr = ++ (struct iscsi_task_mgt_hdr *)&req->pdu.bhs; ++ struct iscsi_cmnd *cmnd; ++ int res = -1; ++ ++ req_hdr->ref_cmd_sn = be32_to_cpu((__force __be32)req_hdr->ref_cmd_sn); ++ ++ if (!before(req_hdr->ref_cmd_sn, req_hdr->cmd_sn)) { ++ TRACE(TRACE_MGMT, "ABORT TASK: RefCmdSN(%u) > CmdSN(%u)", ++ req_hdr->ref_cmd_sn, req_hdr->cmd_sn); ++ *status = ISCSI_RESPONSE_UNKNOWN_TASK; ++ goto out; ++ } ++ ++ cmnd = cmnd_find_itt_get(req->conn, req_hdr->rtt); ++ if (cmnd) { ++ struct iscsi_scsi_cmd_hdr *hdr = cmnd_hdr(cmnd); ++ ++ if (req_hdr->lun != hdr->lun) { ++ PRINT_ERROR("ABORT TASK: LUN mismatch: req LUN " ++ "%llx, cmd LUN %llx, rtt %u", ++ (long long unsigned)be64_to_cpu(req_hdr->lun), ++ (long long unsigned)be64_to_cpu(hdr->lun), ++ req_hdr->rtt); ++ *status = ISCSI_RESPONSE_FUNCTION_REJECTED; ++ goto out_put; ++ } ++ ++ if (cmnd->pdu.bhs.opcode & ISCSI_OP_IMMEDIATE) { ++ if (req_hdr->ref_cmd_sn != req_hdr->cmd_sn) { ++ PRINT_ERROR("ABORT TASK: RefCmdSN(%u) != TM " ++ "cmd CmdSN(%u) for immediate command " ++ "%p", req_hdr->ref_cmd_sn, ++ req_hdr->cmd_sn, cmnd); ++ *status = ISCSI_RESPONSE_FUNCTION_REJECTED; ++ goto out_put; ++ } ++ } else { ++ if (req_hdr->ref_cmd_sn != hdr->cmd_sn) { ++ PRINT_ERROR("ABORT TASK: RefCmdSN(%u) != " ++ "CmdSN(%u) for command %p", ++ req_hdr->ref_cmd_sn, req_hdr->cmd_sn, ++ cmnd); ++ *status = ISCSI_RESPONSE_FUNCTION_REJECTED; ++ goto out_put; ++ } ++ } ++ ++ if (before(req_hdr->cmd_sn, hdr->cmd_sn) || ++ (req_hdr->cmd_sn == hdr->cmd_sn)) { ++ PRINT_ERROR("ABORT TASK: SN mismatch: req SN %x, " ++ "cmd SN %x, rtt %u", req_hdr->cmd_sn, ++ hdr->cmd_sn, req_hdr->rtt); ++ *status = ISCSI_RESPONSE_FUNCTION_REJECTED; ++ goto out_put; ++ } ++ ++ cmnd_put(cmnd); ++ res = 0; ++ } else { ++ TRACE_MGMT_DBG("cmd RTT %x not found", req_hdr->rtt); ++ /* ++ * iSCSI RFC: ++ * ++ * b) If the Referenced Task Tag does not identify an existing task, ++ * but if the CmdSN indicated by the RefCmdSN field in the Task ++ * Management function request is within the valid CmdSN window ++ * and less than the CmdSN of the Task Management function ++ * request itself, then targets must consider the CmdSN received ++ * and return the "Function complete" response. ++ * ++ * c) If the Referenced Task Tag does not identify an existing task ++ * and if the CmdSN indicated by the RefCmdSN field in the Task ++ * Management function request is outside the valid CmdSN window, ++ * then targets must return the "Task does not exist" response. ++ * ++ * 128 seems to be a good "window". ++ */ ++ if (between(req_hdr->ref_cmd_sn, req_hdr->cmd_sn - 128, ++ req_hdr->cmd_sn)) { ++ *status = ISCSI_RESPONSE_FUNCTION_COMPLETE; ++ res = 0; ++ } else ++ *status = ISCSI_RESPONSE_UNKNOWN_TASK; ++ } ++ ++out: ++ return res; ++ ++out_put: ++ cmnd_put(cmnd); ++ goto out; ++} ++ ++struct iscsi_cmnd_abort_params { ++ struct work_struct iscsi_cmnd_abort_work; ++ struct scst_cmd *scst_cmd; ++}; ++ ++static mempool_t *iscsi_cmnd_abort_mempool; ++ ++static void iscsi_cmnd_abort_fn(struct work_struct *work) ++{ ++ struct iscsi_cmnd_abort_params *params = container_of(work, ++ struct iscsi_cmnd_abort_params, iscsi_cmnd_abort_work); ++ struct scst_cmd *scst_cmd = params->scst_cmd; ++ struct iscsi_session *session = scst_sess_get_tgt_priv(scst_cmd->sess); ++ struct iscsi_conn *conn; ++ struct iscsi_cmnd *cmnd = scst_cmd_get_tgt_priv(scst_cmd); ++ bool done = false; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Checking aborted scst_cmd %p (cmnd %p)", scst_cmd, cmnd); ++ ++ mutex_lock(&session->target->target_mutex); ++ ++ /* ++ * cmnd pointer is valid only under cmd_list_lock, but we can't know the ++ * corresponding conn without dereferencing cmnd at first, so let's ++ * check all conns and cmnds to find out if our cmnd is still valid ++ * under lock. ++ */ ++ list_for_each_entry(conn, &session->conn_list, conn_list_entry) { ++ struct iscsi_cmnd *c; ++ spin_lock_bh(&conn->cmd_list_lock); ++ list_for_each_entry(c, &conn->cmd_list, cmd_list_entry) { ++ if (c == cmnd) { ++ __cmnd_abort(cmnd); ++ done = true; ++ break; ++ } ++ } ++ spin_unlock_bh(&conn->cmd_list_lock); ++ if (done) ++ break; ++ } ++ ++ mutex_unlock(&session->target->target_mutex); ++ ++ scst_cmd_put(scst_cmd); ++ ++ mempool_free(params, iscsi_cmnd_abort_mempool); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void iscsi_on_abort_cmd(struct scst_cmd *scst_cmd) ++{ ++ struct iscsi_cmnd_abort_params *params; ++ ++ TRACE_ENTRY(); ++ ++ params = mempool_alloc(iscsi_cmnd_abort_mempool, GFP_ATOMIC); ++ if (params == NULL) { ++ PRINT_CRIT_ERROR("Unable to create iscsi_cmnd_abort_params, " ++ "iSCSI cmnd for scst_cmd %p may not be aborted", ++ scst_cmd); ++ goto out; ++ } ++ ++ memset(params, 0, sizeof(*params)); ++ INIT_WORK(¶ms->iscsi_cmnd_abort_work, iscsi_cmnd_abort_fn); ++ params->scst_cmd = scst_cmd; ++ ++ scst_cmd_get(scst_cmd); ++ ++ TRACE_MGMT_DBG("Scheduling abort check for scst_cmd %p", scst_cmd); ++ ++ schedule_work(¶ms->iscsi_cmnd_abort_work); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Must be called from the read or conn close thread */ ++void conn_abort(struct iscsi_conn *conn) ++{ ++ struct iscsi_cmnd *cmnd, *r, *t; ++ ++ TRACE_MGMT_DBG("Aborting conn %p", conn); ++ ++ iscsi_extracheck_is_rd_thread(conn); ++ ++ cancel_delayed_work_sync(&conn->nop_in_delayed_work); ++ ++ /* No locks, we are the only user */ ++ list_for_each_entry_safe(r, t, &conn->nop_req_list, ++ nop_req_list_entry) { ++ list_del(&r->nop_req_list_entry); ++ cmnd_put(r); ++ } ++ ++ spin_lock_bh(&conn->cmd_list_lock); ++again: ++ list_for_each_entry(cmnd, &conn->cmd_list, cmd_list_entry) { ++ __cmnd_abort(cmnd); ++ if (cmnd->r2t_len_to_receive != 0) { ++ if (!cmnd_get_check(cmnd)) { ++ spin_unlock_bh(&conn->cmd_list_lock); ++ ++ /* ToDo: this is racy for MC/S */ ++ iscsi_fail_data_waiting_cmnd(cmnd); ++ ++ cmnd_put(cmnd); ++ ++ /* ++ * We are in the read thread, so we may not ++ * worry that after cmnd release conn gets ++ * released as well. ++ */ ++ spin_lock_bh(&conn->cmd_list_lock); ++ goto again; ++ } ++ } ++ } ++ spin_unlock_bh(&conn->cmd_list_lock); ++ ++ return; ++} ++ ++static void execute_task_management(struct iscsi_cmnd *req) ++{ ++ struct iscsi_conn *conn = req->conn; ++ struct iscsi_session *sess = conn->session; ++ struct iscsi_task_mgt_hdr *req_hdr = ++ (struct iscsi_task_mgt_hdr *)&req->pdu.bhs; ++ int rc, status = ISCSI_RESPONSE_FUNCTION_REJECTED; ++ int function = req_hdr->function & ISCSI_FUNCTION_MASK; ++ struct scst_rx_mgmt_params params; ++ ++ TRACE(TRACE_MGMT, "iSCSI TM fn %d", function); ++ ++ TRACE_MGMT_DBG("TM req %p, ITT %x, RTT %x, sn %u, con %p", req, ++ req->pdu.bhs.itt, req_hdr->rtt, req_hdr->cmd_sn, conn); ++ ++ iscsi_extracheck_is_rd_thread(conn); ++ ++ spin_lock(&sess->sn_lock); ++ sess->tm_active++; ++ sess->tm_sn = req_hdr->cmd_sn; ++ if (sess->tm_rsp != NULL) { ++ struct iscsi_cmnd *tm_rsp = sess->tm_rsp; ++ ++ TRACE_MGMT_DBG("Dropping delayed TM rsp %p", tm_rsp); ++ ++ sess->tm_rsp = NULL; ++ sess->tm_active--; ++ ++ spin_unlock(&sess->sn_lock); ++ ++ BUG_ON(sess->tm_active < 0); ++ ++ rsp_cmnd_release(tm_rsp); ++ } else ++ spin_unlock(&sess->sn_lock); ++ ++ memset(¶ms, 0, sizeof(params)); ++ params.atomic = SCST_NON_ATOMIC; ++ params.tgt_priv = req; ++ ++ if ((function != ISCSI_FUNCTION_ABORT_TASK) && ++ (req_hdr->rtt != ISCSI_RESERVED_TAG)) { ++ PRINT_ERROR("Invalid RTT %x (TM fn %d)", req_hdr->rtt, ++ function); ++ rc = -1; ++ status = ISCSI_RESPONSE_FUNCTION_REJECTED; ++ goto reject; ++ } ++ ++ /* cmd_sn is already in CPU format converted in cmnd_rx_start() */ ++ ++ switch (function) { ++ case ISCSI_FUNCTION_ABORT_TASK: ++ rc = cmnd_abort_pre_checks(req, &status); ++ if (rc == 0) { ++ params.fn = SCST_ABORT_TASK; ++ params.tag = (__force u32)req_hdr->rtt; ++ params.tag_set = 1; ++ params.lun = (uint8_t *)&req_hdr->lun; ++ params.lun_len = sizeof(req_hdr->lun); ++ params.lun_set = 1; ++ params.cmd_sn = req_hdr->cmd_sn; ++ params.cmd_sn_set = 1; ++ rc = scst_rx_mgmt_fn(conn->session->scst_sess, ++ ¶ms); ++ status = ISCSI_RESPONSE_FUNCTION_REJECTED; ++ } ++ break; ++ case ISCSI_FUNCTION_ABORT_TASK_SET: ++ params.fn = SCST_ABORT_TASK_SET; ++ params.lun = (uint8_t *)&req_hdr->lun; ++ params.lun_len = sizeof(req_hdr->lun); ++ params.lun_set = 1; ++ params.cmd_sn = req_hdr->cmd_sn; ++ params.cmd_sn_set = 1; ++ rc = scst_rx_mgmt_fn(conn->session->scst_sess, ++ ¶ms); ++ status = ISCSI_RESPONSE_FUNCTION_REJECTED; ++ break; ++ case ISCSI_FUNCTION_CLEAR_TASK_SET: ++ params.fn = SCST_CLEAR_TASK_SET; ++ params.lun = (uint8_t *)&req_hdr->lun; ++ params.lun_len = sizeof(req_hdr->lun); ++ params.lun_set = 1; ++ params.cmd_sn = req_hdr->cmd_sn; ++ params.cmd_sn_set = 1; ++ rc = scst_rx_mgmt_fn(conn->session->scst_sess, ++ ¶ms); ++ status = ISCSI_RESPONSE_FUNCTION_REJECTED; ++ break; ++ case ISCSI_FUNCTION_CLEAR_ACA: ++ params.fn = SCST_CLEAR_ACA; ++ params.lun = (uint8_t *)&req_hdr->lun; ++ params.lun_len = sizeof(req_hdr->lun); ++ params.lun_set = 1; ++ params.cmd_sn = req_hdr->cmd_sn; ++ params.cmd_sn_set = 1; ++ rc = scst_rx_mgmt_fn(conn->session->scst_sess, ++ ¶ms); ++ status = ISCSI_RESPONSE_FUNCTION_REJECTED; ++ break; ++ case ISCSI_FUNCTION_TARGET_COLD_RESET: ++ case ISCSI_FUNCTION_TARGET_WARM_RESET: ++ params.fn = SCST_TARGET_RESET; ++ params.cmd_sn = req_hdr->cmd_sn; ++ params.cmd_sn_set = 1; ++ rc = scst_rx_mgmt_fn(conn->session->scst_sess, ++ ¶ms); ++ status = ISCSI_RESPONSE_FUNCTION_REJECTED; ++ break; ++ case ISCSI_FUNCTION_LOGICAL_UNIT_RESET: ++ params.fn = SCST_LUN_RESET; ++ params.lun = (uint8_t *)&req_hdr->lun; ++ params.lun_len = sizeof(req_hdr->lun); ++ params.lun_set = 1; ++ params.cmd_sn = req_hdr->cmd_sn; ++ params.cmd_sn_set = 1; ++ rc = scst_rx_mgmt_fn(conn->session->scst_sess, ++ ¶ms); ++ status = ISCSI_RESPONSE_FUNCTION_REJECTED; ++ break; ++ case ISCSI_FUNCTION_TASK_REASSIGN: ++ rc = -1; ++ status = ISCSI_RESPONSE_ALLEGIANCE_REASSIGNMENT_UNSUPPORTED; ++ break; ++ default: ++ PRINT_ERROR("Unknown TM function %d", function); ++ rc = -1; ++ status = ISCSI_RESPONSE_FUNCTION_REJECTED; ++ break; ++ } ++ ++reject: ++ if (rc != 0) ++ iscsi_send_task_mgmt_resp(req, status); ++ ++ return; ++} ++ ++static void nop_out_exec(struct iscsi_cmnd *req) ++{ ++ struct iscsi_cmnd *rsp; ++ struct iscsi_nop_in_hdr *rsp_hdr; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("%p", req); ++ ++ if (req->pdu.bhs.itt != ISCSI_RESERVED_TAG) { ++ rsp = iscsi_alloc_main_rsp(req); ++ ++ rsp_hdr = (struct iscsi_nop_in_hdr *)&rsp->pdu.bhs; ++ rsp_hdr->opcode = ISCSI_OP_NOP_IN; ++ rsp_hdr->flags = ISCSI_FLG_FINAL; ++ rsp_hdr->itt = req->pdu.bhs.itt; ++ rsp_hdr->ttt = ISCSI_RESERVED_TAG; ++ ++ if (req->pdu.datasize) ++ BUG_ON(req->sg == NULL); ++ else ++ BUG_ON(req->sg != NULL); ++ ++ if (req->sg) { ++ rsp->sg = req->sg; ++ rsp->sg_cnt = req->sg_cnt; ++ rsp->bufflen = req->bufflen; ++ } ++ ++ /* We already checked it in check_segment_length() */ ++ BUG_ON(get_pgcnt(req->pdu.datasize, 0) > ISCSI_CONN_IOV_MAX); ++ ++ rsp->pdu.datasize = req->pdu.datasize; ++ } else { ++ bool found = false; ++ struct iscsi_cmnd *r; ++ struct iscsi_conn *conn = req->conn; ++ ++ TRACE_DBG("Receive Nop-In response (ttt 0x%08x)", ++ be32_to_cpu(req->pdu.bhs.ttt)); ++ ++ spin_lock_bh(&conn->nop_req_list_lock); ++ list_for_each_entry(r, &conn->nop_req_list, ++ nop_req_list_entry) { ++ if (req->pdu.bhs.ttt == r->pdu.bhs.ttt) { ++ list_del(&r->nop_req_list_entry); ++ found = true; ++ break; ++ } ++ } ++ spin_unlock_bh(&conn->nop_req_list_lock); ++ ++ if (found) ++ cmnd_put(r); ++ else ++ TRACE_MGMT_DBG("%s", "Got Nop-out response without " ++ "corresponding Nop-In request"); ++ } ++ ++ req_cmnd_release(req); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void logout_exec(struct iscsi_cmnd *req) ++{ ++ struct iscsi_logout_req_hdr *req_hdr; ++ struct iscsi_cmnd *rsp; ++ struct iscsi_logout_rsp_hdr *rsp_hdr; ++ ++ PRINT_INFO("Logout received from initiator %s", ++ req->conn->session->initiator_name); ++ TRACE_DBG("%p", req); ++ ++ req_hdr = (struct iscsi_logout_req_hdr *)&req->pdu.bhs; ++ rsp = iscsi_alloc_main_rsp(req); ++ rsp_hdr = (struct iscsi_logout_rsp_hdr *)&rsp->pdu.bhs; ++ rsp_hdr->opcode = ISCSI_OP_LOGOUT_RSP; ++ rsp_hdr->flags = ISCSI_FLG_FINAL; ++ rsp_hdr->itt = req_hdr->itt; ++ rsp->should_close_conn = 1; ++ ++ req_cmnd_release(req); ++ ++ return; ++} ++ ++static void iscsi_cmnd_exec(struct iscsi_cmnd *cmnd) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("cmnd %p, op %x, SN %u", cmnd, cmnd_opcode(cmnd), ++ cmnd->pdu.bhs.sn); ++ ++ iscsi_extracheck_is_rd_thread(cmnd->conn); ++ ++ if (cmnd_opcode(cmnd) == ISCSI_OP_SCSI_CMD) { ++ if (cmnd->r2t_len_to_receive == 0) ++ iscsi_restart_cmnd(cmnd); ++ else if (cmnd->r2t_len_to_send != 0) ++ send_r2t(cmnd); ++ goto out; ++ } ++ ++ if (cmnd->prelim_compl_flags != 0) { ++ TRACE_MGMT_DBG("Terminating prelim completed non-SCSI cmnd %p " ++ "(op %x)", cmnd, cmnd_opcode(cmnd)); ++ req_cmnd_release(cmnd); ++ goto out; ++ } ++ ++ switch (cmnd_opcode(cmnd)) { ++ case ISCSI_OP_NOP_OUT: ++ nop_out_exec(cmnd); ++ break; ++ case ISCSI_OP_SCSI_TASK_MGT_MSG: ++ execute_task_management(cmnd); ++ break; ++ case ISCSI_OP_LOGOUT_CMD: ++ logout_exec(cmnd); ++ break; ++ default: ++ PRINT_CRIT_ERROR("Unexpected cmnd op %x", cmnd_opcode(cmnd)); ++ BUG(); ++ break; ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static void set_cork(struct socket *sock, int on) ++{ ++ int opt = on; ++ mm_segment_t oldfs; ++ ++ oldfs = get_fs(); ++ set_fs(get_ds()); ++ sock->ops->setsockopt(sock, SOL_TCP, TCP_CORK, ++ (void __force __user *)&opt, sizeof(opt)); ++ set_fs(oldfs); ++ return; ++} ++ ++void cmnd_tx_start(struct iscsi_cmnd *cmnd) ++{ ++ struct iscsi_conn *conn = cmnd->conn; ++ ++ TRACE_DBG("conn %p, cmnd %p, opcode %x", conn, cmnd, cmnd_opcode(cmnd)); ++ iscsi_cmnd_set_length(&cmnd->pdu); ++ ++ iscsi_extracheck_is_wr_thread(conn); ++ ++ set_cork(conn->sock, 1); ++ ++ conn->write_iop = conn->write_iov; ++ conn->write_iop->iov_base = (void __force __user *)(&cmnd->pdu.bhs); ++ conn->write_iop->iov_len = sizeof(cmnd->pdu.bhs); ++ conn->write_iop_used = 1; ++ conn->write_size = sizeof(cmnd->pdu.bhs) + cmnd->pdu.datasize; ++ conn->write_offset = 0; ++ ++ switch (cmnd_opcode(cmnd)) { ++ case ISCSI_OP_NOP_IN: ++ if (cmnd->pdu.bhs.itt == ISCSI_RESERVED_TAG) ++ cmnd->pdu.bhs.sn = (__force u32)cmnd_set_sn(cmnd, 0); ++ else ++ cmnd_set_sn(cmnd, 1); ++ break; ++ case ISCSI_OP_SCSI_RSP: ++ cmnd_set_sn(cmnd, 1); ++ break; ++ case ISCSI_OP_SCSI_TASK_MGT_RSP: ++ cmnd_set_sn(cmnd, 1); ++ break; ++ case ISCSI_OP_TEXT_RSP: ++ cmnd_set_sn(cmnd, 1); ++ break; ++ case ISCSI_OP_SCSI_DATA_IN: ++ { ++ struct iscsi_data_in_hdr *rsp = ++ (struct iscsi_data_in_hdr *)&cmnd->pdu.bhs; ++ u32 offset = be32_to_cpu(rsp->buffer_offset); ++ ++ TRACE_DBG("cmnd %p, offset %u, datasize %u, bufflen %u", cmnd, ++ offset, cmnd->pdu.datasize, cmnd->bufflen); ++ ++ BUG_ON(offset > cmnd->bufflen); ++ BUG_ON(offset + cmnd->pdu.datasize > cmnd->bufflen); ++ ++ conn->write_offset = offset; ++ ++ cmnd_set_sn(cmnd, (rsp->flags & ISCSI_FLG_FINAL) ? 1 : 0); ++ break; ++ } ++ case ISCSI_OP_LOGOUT_RSP: ++ cmnd_set_sn(cmnd, 1); ++ break; ++ case ISCSI_OP_R2T: ++ cmnd->pdu.bhs.sn = (__force u32)cmnd_set_sn(cmnd, 0); ++ break; ++ case ISCSI_OP_ASYNC_MSG: ++ cmnd_set_sn(cmnd, 1); ++ break; ++ case ISCSI_OP_REJECT: ++ cmnd_set_sn(cmnd, 1); ++ break; ++ default: ++ PRINT_ERROR("Unexpected cmnd op %x", cmnd_opcode(cmnd)); ++ break; ++ } ++ ++ iscsi_dump_pdu(&cmnd->pdu); ++ return; ++} ++ ++void cmnd_tx_end(struct iscsi_cmnd *cmnd) ++{ ++ struct iscsi_conn *conn = cmnd->conn; ++ ++ TRACE_DBG("%p:%x (should_close_conn %d, should_close_all_conn %d)", ++ cmnd, cmnd_opcode(cmnd), cmnd->should_close_conn, ++ cmnd->should_close_all_conn); ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ switch (cmnd_opcode(cmnd)) { ++ case ISCSI_OP_NOP_IN: ++ case ISCSI_OP_SCSI_RSP: ++ case ISCSI_OP_SCSI_TASK_MGT_RSP: ++ case ISCSI_OP_TEXT_RSP: ++ case ISCSI_OP_R2T: ++ case ISCSI_OP_ASYNC_MSG: ++ case ISCSI_OP_REJECT: ++ case ISCSI_OP_SCSI_DATA_IN: ++ case ISCSI_OP_LOGOUT_RSP: ++ break; ++ default: ++ PRINT_CRIT_ERROR("unexpected cmnd op %x", cmnd_opcode(cmnd)); ++ BUG(); ++ break; ++ } ++#endif ++ ++ if (unlikely(cmnd->should_close_conn)) { ++ if (cmnd->should_close_all_conn) { ++ PRINT_INFO("Closing all connections for target %x at " ++ "initiator's %s request", ++ cmnd->conn->session->target->tid, ++ conn->session->initiator_name); ++ target_del_all_sess(cmnd->conn->session->target, 0); ++ } else { ++ PRINT_INFO("Closing connection at initiator's %s " ++ "request", conn->session->initiator_name); ++ mark_conn_closed(conn); ++ } ++ } ++ ++ set_cork(cmnd->conn->sock, 0); ++ return; ++} ++ ++/* ++ * Push the command for execution. This functions reorders the commands. ++ * Called from the read thread. ++ * ++ * Basically, since we don't support MC/S and TCP guarantees data delivery ++ * order, all that SN's stuff isn't needed at all (commands delivery order is ++ * a natural commands execution order), but insane iSCSI spec requires ++ * us to check it and we have to, because some crazy initiators can rely ++ * on the SN's based order and reorder requests during sending. For all other ++ * normal initiators all that code is a NOP. ++ */ ++static void iscsi_push_cmnd(struct iscsi_cmnd *cmnd) ++{ ++ struct iscsi_session *session = cmnd->conn->session; ++ struct list_head *entry; ++ u32 cmd_sn; ++ ++ TRACE_DBG("cmnd %p, iSCSI opcode %x, sn %u, exp sn %u", cmnd, ++ cmnd_opcode(cmnd), cmnd->pdu.bhs.sn, session->exp_cmd_sn); ++ ++ iscsi_extracheck_is_rd_thread(cmnd->conn); ++ ++ BUG_ON(cmnd->parent_req != NULL); ++ ++ if (cmnd->pdu.bhs.opcode & ISCSI_OP_IMMEDIATE) { ++ TRACE_DBG("Immediate cmd %p (cmd_sn %u)", cmnd, ++ cmnd->pdu.bhs.sn); ++ iscsi_cmnd_exec(cmnd); ++ goto out; ++ } ++ ++ spin_lock(&session->sn_lock); ++ ++ cmd_sn = cmnd->pdu.bhs.sn; ++ if (cmd_sn == session->exp_cmd_sn) { ++ while (1) { ++ session->exp_cmd_sn = ++cmd_sn; ++ ++ if (unlikely(session->tm_active > 0)) { ++ if (before(cmd_sn, session->tm_sn)) { ++ struct iscsi_conn *conn = cmnd->conn; ++ ++ spin_unlock(&session->sn_lock); ++ ++ spin_lock_bh(&conn->cmd_list_lock); ++ __cmnd_abort(cmnd); ++ spin_unlock_bh(&conn->cmd_list_lock); ++ ++ spin_lock(&session->sn_lock); ++ } ++ iscsi_check_send_delayed_tm_resp(session); ++ } ++ ++ spin_unlock(&session->sn_lock); ++ ++ iscsi_cmnd_exec(cmnd); ++ ++ spin_lock(&session->sn_lock); ++ ++ if (list_empty(&session->pending_list)) ++ break; ++ cmnd = list_entry(session->pending_list.next, ++ struct iscsi_cmnd, ++ pending_list_entry); ++ if (cmnd->pdu.bhs.sn != cmd_sn) ++ break; ++ ++ list_del(&cmnd->pending_list_entry); ++ cmnd->pending = 0; ++ ++ TRACE_MGMT_DBG("Processing pending cmd %p (cmd_sn %u)", ++ cmnd, cmd_sn); ++ } ++ } else { ++ int drop = 0; ++ ++ TRACE_DBG("Pending cmd %p (cmd_sn %u, exp_cmd_sn %u)", ++ cmnd, cmd_sn, session->exp_cmd_sn); ++ ++ /* ++ * iSCSI RFC 3720: "The target MUST silently ignore any ++ * non-immediate command outside of [from ExpCmdSN to MaxCmdSN ++ * inclusive] range". But we won't honor the MaxCmdSN ++ * requirement, because, since we adjust MaxCmdSN from the ++ * separate write thread, rarely it is possible that initiator ++ * can legally send command with CmdSN>MaxSN. But it won't ++ * hurt anything, in the worst case it will lead to ++ * additional QUEUE FULL status. ++ */ ++ ++ if (unlikely(before(cmd_sn, session->exp_cmd_sn))) { ++ TRACE_MGMT_DBG("Ignoring out of expected range cmd_sn " ++ "(sn %u, exp_sn %u, cmd %p, op %x, CDB op %x)", ++ cmd_sn, session->exp_cmd_sn, cmnd, ++ cmnd_opcode(cmnd), cmnd_scsicode(cmnd)); ++ drop = 1; ++ } ++ ++#if 0 ++ if (unlikely(after(cmd_sn, session->exp_cmd_sn + ++ iscsi_get_allowed_cmds(session)))) { ++ TRACE_MGMT_DBG("Too large cmd_sn %u (exp_cmd_sn %u, " ++ "max_sn %u)", cmd_sn, session->exp_cmd_sn, ++ iscsi_get_allowed_cmds(session)); ++ drop = 1; ++ } ++#endif ++ ++ spin_unlock(&session->sn_lock); ++ ++ if (unlikely(drop)) { ++ req_cmnd_release_force(cmnd); ++ goto out; ++ } ++ ++ if (unlikely(test_bit(ISCSI_CMD_ABORTED, ++ &cmnd->prelim_compl_flags))) { ++ struct iscsi_cmnd *tm_clone; ++ ++ TRACE_MGMT_DBG("Aborted pending cmnd %p, creating TM " ++ "clone (scst cmd %p, state %d)", cmnd, ++ cmnd->scst_cmd, cmnd->scst_state); ++ ++ tm_clone = iscsi_create_tm_clone(cmnd); ++ if (tm_clone != NULL) { ++ iscsi_cmnd_exec(cmnd); ++ cmnd = tm_clone; ++ } ++ } ++ ++ TRACE_MGMT_DBG("Pending cmnd %p (op %x, sn %u, exp sn %u)", ++ cmnd, cmnd_opcode(cmnd), cmd_sn, session->exp_cmd_sn); ++ ++ spin_lock(&session->sn_lock); ++ list_for_each(entry, &session->pending_list) { ++ struct iscsi_cmnd *tmp = ++ list_entry(entry, struct iscsi_cmnd, ++ pending_list_entry); ++ if (before(cmd_sn, tmp->pdu.bhs.sn)) ++ break; ++ } ++ list_add_tail(&cmnd->pending_list_entry, entry); ++ cmnd->pending = 1; ++ } ++ ++ spin_unlock(&session->sn_lock); ++out: ++ return; ++} ++ ++static int check_segment_length(struct iscsi_cmnd *cmnd) ++{ ++ struct iscsi_conn *conn = cmnd->conn; ++ struct iscsi_session *session = conn->session; ++ ++ if (unlikely(cmnd->pdu.datasize > session->sess_params.max_recv_data_length)) { ++ PRINT_ERROR("Initiator %s violated negotiated parameters: " ++ "data too long (ITT %x, datasize %u, " ++ "max_recv_data_length %u", session->initiator_name, ++ cmnd->pdu.bhs.itt, cmnd->pdu.datasize, ++ session->sess_params.max_recv_data_length); ++ mark_conn_closed(conn); ++ return -EINVAL; ++ } ++ return 0; ++} ++ ++int cmnd_rx_start(struct iscsi_cmnd *cmnd) ++{ ++ int res, rc = 0; ++ ++ iscsi_dump_pdu(&cmnd->pdu); ++ ++ res = check_segment_length(cmnd); ++ if (res != 0) ++ goto out; ++ ++ cmnd->pdu.bhs.sn = be32_to_cpu((__force __be32)cmnd->pdu.bhs.sn); ++ ++ switch (cmnd_opcode(cmnd)) { ++ case ISCSI_OP_SCSI_CMD: ++ res = scsi_cmnd_start(cmnd); ++ if (unlikely(res < 0)) ++ goto out; ++ update_stat_sn(cmnd); ++ break; ++ case ISCSI_OP_SCSI_DATA_OUT: ++ res = data_out_start(cmnd); ++ goto out; ++ case ISCSI_OP_NOP_OUT: ++ rc = nop_out_start(cmnd); ++ break; ++ case ISCSI_OP_SCSI_TASK_MGT_MSG: ++ case ISCSI_OP_LOGOUT_CMD: ++ update_stat_sn(cmnd); ++ break; ++ case ISCSI_OP_TEXT_CMD: ++ case ISCSI_OP_SNACK_CMD: ++ default: ++ rc = -ISCSI_REASON_UNSUPPORTED_COMMAND; ++ break; ++ } ++ ++ if (unlikely(rc < 0)) { ++ PRINT_ERROR("Error %d (iSCSI opcode %x, ITT %x)", rc, ++ cmnd_opcode(cmnd), cmnd->pdu.bhs.itt); ++ res = create_reject_rsp(cmnd, -rc, true); ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++void cmnd_rx_end(struct iscsi_cmnd *cmnd) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("cmnd %p, opcode %x", cmnd, cmnd_opcode(cmnd)); ++ ++ cmnd->conn->last_rcv_time = jiffies; ++ TRACE_DBG("Updated last_rcv_time %ld", cmnd->conn->last_rcv_time); ++ ++ switch (cmnd_opcode(cmnd)) { ++ case ISCSI_OP_SCSI_CMD: ++ case ISCSI_OP_NOP_OUT: ++ case ISCSI_OP_SCSI_TASK_MGT_MSG: ++ case ISCSI_OP_LOGOUT_CMD: ++ iscsi_push_cmnd(cmnd); ++ goto out; ++ case ISCSI_OP_SCSI_DATA_OUT: ++ data_out_end(cmnd); ++ break; ++ default: ++ PRINT_ERROR("Unexpected cmnd op %x", cmnd_opcode(cmnd)); ++ break; ++ } ++ ++ req_cmnd_release(cmnd); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++#if !defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++static int iscsi_alloc_data_buf(struct scst_cmd *cmd) ++{ ++ /* ++ * sock->ops->sendpage() is async zero copy operation, ++ * so we must be sure not to free and reuse ++ * the command's buffer before the sending was completed ++ * by the network layers. It is possible only if we ++ * don't use SGV cache. ++ */ ++ EXTRACHECKS_BUG_ON(!(scst_cmd_get_data_direction(cmd) & SCST_DATA_READ)); ++ scst_cmd_set_no_sgv(cmd); ++ return 1; ++} ++#endif ++ ++static void iscsi_preprocessing_done(struct scst_cmd *scst_cmd) ++{ ++ struct iscsi_cmnd *req = (struct iscsi_cmnd *) ++ scst_cmd_get_tgt_priv(scst_cmd); ++ ++ TRACE_DBG("req %p", req); ++ ++ if (req->conn->rx_task == current) ++ req->scst_state = ISCSI_CMD_STATE_AFTER_PREPROC; ++ else { ++ /* ++ * We wait for the state change without any protection, so ++ * without cmnd_get() it is possible that req will die ++ * "immediately" after the state assignment and ++ * iscsi_make_conn_rd_active() will operate on dead data. ++ * We use the ordered version of cmnd_get(), because "get" ++ * must be done before the state assignment. ++ * ++ * We protected from the race on calling cmnd_rx_continue(), ++ * because there can be only one read thread processing ++ * connection. ++ */ ++ cmnd_get(req); ++ req->scst_state = ISCSI_CMD_STATE_AFTER_PREPROC; ++ iscsi_make_conn_rd_active(req->conn); ++ if (unlikely(req->conn->closing)) { ++ TRACE_DBG("Waking up closing conn %p", req->conn); ++ wake_up(&req->conn->read_state_waitQ); ++ } ++ cmnd_put(req); ++ } ++ ++ return; ++} ++ ++/* No locks */ ++static void iscsi_try_local_processing(struct iscsi_cmnd *req) ++{ ++ struct iscsi_conn *conn = req->conn; ++ struct iscsi_thread_pool *p = conn->conn_thr_pool; ++ bool local; ++ ++ TRACE_ENTRY(); ++ ++ spin_lock_bh(&p->wr_lock); ++ switch (conn->wr_state) { ++ case ISCSI_CONN_WR_STATE_IN_LIST: ++ list_del(&conn->wr_list_entry); ++ /* go through */ ++ case ISCSI_CONN_WR_STATE_IDLE: ++#ifdef CONFIG_SCST_EXTRACHECKS ++ conn->wr_task = current; ++#endif ++ conn->wr_state = ISCSI_CONN_WR_STATE_PROCESSING; ++ conn->wr_space_ready = 0; ++ local = true; ++ break; ++ default: ++ local = false; ++ break; ++ } ++ spin_unlock_bh(&p->wr_lock); ++ ++ if (local) { ++ int rc = 1; ++ ++ do { ++ rc = iscsi_send(conn); ++ if (rc <= 0) ++ break; ++ } while (req->not_processed_rsp_cnt != 0); ++ ++ spin_lock_bh(&p->wr_lock); ++#ifdef CONFIG_SCST_EXTRACHECKS ++ conn->wr_task = NULL; ++#endif ++ if ((rc == -EAGAIN) && !conn->wr_space_ready) { ++ TRACE_DBG("EAGAIN, setting WR_STATE_SPACE_WAIT " ++ "(conn %p)", conn); ++ conn->wr_state = ISCSI_CONN_WR_STATE_SPACE_WAIT; ++ } else if (test_write_ready(conn)) { ++ list_add_tail(&conn->wr_list_entry, &p->wr_list); ++ conn->wr_state = ISCSI_CONN_WR_STATE_IN_LIST; ++ wake_up(&p->wr_waitQ); ++ } else ++ conn->wr_state = ISCSI_CONN_WR_STATE_IDLE; ++ spin_unlock_bh(&p->wr_lock); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int iscsi_xmit_response(struct scst_cmd *scst_cmd) ++{ ++ int is_send_status = scst_cmd_get_is_send_status(scst_cmd); ++ struct iscsi_cmnd *req = (struct iscsi_cmnd *) ++ scst_cmd_get_tgt_priv(scst_cmd); ++ struct iscsi_conn *conn = req->conn; ++ int status = scst_cmd_get_status(scst_cmd); ++ u8 *sense = scst_cmd_get_sense_buffer(scst_cmd); ++ int sense_len = scst_cmd_get_sense_buffer_len(scst_cmd); ++ struct iscsi_cmnd *wr_rsp, *our_rsp; ++ ++ EXTRACHECKS_BUG_ON(scst_cmd_atomic(scst_cmd)); ++ ++ scst_cmd_set_tgt_priv(scst_cmd, NULL); ++ ++ EXTRACHECKS_BUG_ON(req->scst_state != ISCSI_CMD_STATE_RESTARTED); ++ ++ if (unlikely(scst_cmd_aborted(scst_cmd))) ++ set_bit(ISCSI_CMD_ABORTED, &req->prelim_compl_flags); ++ ++ if (unlikely(req->prelim_compl_flags != 0)) { ++ if (test_bit(ISCSI_CMD_ABORTED, &req->prelim_compl_flags)) { ++ TRACE_MGMT_DBG("req %p (scst_cmd %p) aborted", req, ++ req->scst_cmd); ++ scst_set_delivery_status(req->scst_cmd, ++ SCST_CMD_DELIVERY_ABORTED); ++ req->scst_state = ISCSI_CMD_STATE_PROCESSED; ++ req_cmnd_release_force(req); ++ goto out; ++ } ++ ++ TRACE_DBG("Prelim completed req %p", req); ++ ++ /* ++ * We could preliminary have finished req before we ++ * knew its device, so check if we return correct sense ++ * format. ++ */ ++ scst_check_convert_sense(scst_cmd); ++ ++ if (!req->own_sg) { ++ req->sg = scst_cmd_get_sg(scst_cmd); ++ req->sg_cnt = scst_cmd_get_sg_cnt(scst_cmd); ++ } ++ } else { ++ EXTRACHECKS_BUG_ON(req->own_sg); ++ req->sg = scst_cmd_get_sg(scst_cmd); ++ req->sg_cnt = scst_cmd_get_sg_cnt(scst_cmd); ++ } ++ ++ req->bufflen = scst_cmd_get_adjusted_resp_data_len(scst_cmd); ++ ++ req->scst_state = ISCSI_CMD_STATE_PROCESSED; ++ ++ TRACE_DBG("req %p, is_send_status=%x, req->bufflen=%d, req->sg=%p, " ++ "req->sg_cnt %d", req, is_send_status, req->bufflen, req->sg, ++ req->sg_cnt); ++ ++ EXTRACHECKS_BUG_ON(req->hashed); ++ if (req->main_rsp != NULL) ++ EXTRACHECKS_BUG_ON(cmnd_opcode(req->main_rsp) != ISCSI_OP_REJECT); ++ ++ if (unlikely((req->bufflen != 0) && !is_send_status)) { ++ PRINT_CRIT_ERROR("%s", "Sending DATA without STATUS is " ++ "unsupported"); ++ scst_set_cmd_error(scst_cmd, ++ SCST_LOAD_SENSE(scst_sense_hardw_error)); ++ BUG(); /* ToDo */ ++ } ++ ++ /* ++ * We need to decrement active_cmds before adding any responses into ++ * the write queue to eliminate a race, when all responses sent ++ * with wrong MaxCmdSN. ++ */ ++ if (likely(req->dec_active_cmds)) ++ iscsi_dec_active_cmds(req); ++ ++ if (req->bufflen != 0) { ++ /* ++ * Check above makes sure that is_send_status is set, ++ * so status is valid here, but in future that could change. ++ * ToDo ++ */ ++ if ((status != SAM_STAT_CHECK_CONDITION) && ++ ((cmnd_hdr(req)->flags & (ISCSI_CMD_WRITE|ISCSI_CMD_READ)) != ++ (ISCSI_CMD_WRITE|ISCSI_CMD_READ))) { ++ send_data_rsp(req, status, is_send_status); ++ } else { ++ struct iscsi_cmnd *rsp; ++ send_data_rsp(req, 0, 0); ++ if (is_send_status) { ++ rsp = create_status_rsp(req, status, sense, ++ sense_len); ++ iscsi_cmnd_init_write(rsp, 0); ++ } ++ } ++ } else if (is_send_status) { ++ struct iscsi_cmnd *rsp; ++ rsp = create_status_rsp(req, status, sense, sense_len); ++ iscsi_cmnd_init_write(rsp, 0); ++ } ++#ifdef CONFIG_SCST_EXTRACHECKS ++ else ++ BUG(); ++#endif ++ ++ /* ++ * There's no need for protection, since we are not going to ++ * dereference them. ++ */ ++ wr_rsp = list_entry(conn->write_list.next, struct iscsi_cmnd, ++ write_list_entry); ++ our_rsp = list_entry(req->rsp_cmd_list.next, struct iscsi_cmnd, ++ rsp_cmd_list_entry); ++ if (wr_rsp == our_rsp) { ++ /* ++ * This is our rsp, so let's try to process it locally to ++ * decrease latency. We need to call pre_release before ++ * processing to handle some error recovery cases. ++ */ ++ if (scst_get_active_cmd_count(scst_cmd) <= 2) { ++ req_cmnd_pre_release(req); ++ iscsi_try_local_processing(req); ++ cmnd_put(req); ++ } else { ++ /* ++ * There's too much backend activity, so it could be ++ * better to push it to the write thread. ++ */ ++ goto out_push_to_wr_thread; ++ } ++ } else ++ goto out_push_to_wr_thread; ++ ++out: ++ return SCST_TGT_RES_SUCCESS; ++ ++out_push_to_wr_thread: ++ TRACE_DBG("Waking up write thread (conn %p)", conn); ++ req_cmnd_release(req); ++ iscsi_make_conn_wr_active(conn); ++ goto out; ++} ++ ++/* Called under sn_lock */ ++static bool iscsi_is_delay_tm_resp(struct iscsi_cmnd *rsp) ++{ ++ bool res = 0; ++ struct iscsi_task_mgt_hdr *req_hdr = ++ (struct iscsi_task_mgt_hdr *)&rsp->parent_req->pdu.bhs; ++ int function = req_hdr->function & ISCSI_FUNCTION_MASK; ++ struct iscsi_session *sess = rsp->conn->session; ++ ++ TRACE_ENTRY(); ++ ++ /* This should be checked for immediate TM commands as well */ ++ ++ switch (function) { ++ default: ++ if (before(sess->exp_cmd_sn, req_hdr->cmd_sn)) ++ res = 1; ++ break; ++ } ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* Called under sn_lock, but might drop it inside, then reacquire */ ++static void iscsi_check_send_delayed_tm_resp(struct iscsi_session *sess) ++ __acquires(&sn_lock) ++ __releases(&sn_lock) ++{ ++ struct iscsi_cmnd *tm_rsp = sess->tm_rsp; ++ ++ TRACE_ENTRY(); ++ ++ if (tm_rsp == NULL) ++ goto out; ++ ++ if (iscsi_is_delay_tm_resp(tm_rsp)) ++ goto out; ++ ++ TRACE_MGMT_DBG("Sending delayed rsp %p", tm_rsp); ++ ++ sess->tm_rsp = NULL; ++ sess->tm_active--; ++ ++ spin_unlock(&sess->sn_lock); ++ ++ BUG_ON(sess->tm_active < 0); ++ ++ iscsi_cmnd_init_write(tm_rsp, ISCSI_INIT_WRITE_WAKE); ++ ++ spin_lock(&sess->sn_lock); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static void iscsi_send_task_mgmt_resp(struct iscsi_cmnd *req, int status) ++{ ++ struct iscsi_cmnd *rsp; ++ struct iscsi_task_mgt_hdr *req_hdr = ++ (struct iscsi_task_mgt_hdr *)&req->pdu.bhs; ++ struct iscsi_task_rsp_hdr *rsp_hdr; ++ struct iscsi_session *sess = req->conn->session; ++ int fn = req_hdr->function & ISCSI_FUNCTION_MASK; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("TM req %p finished", req); ++ TRACE(TRACE_MGMT, "iSCSI TM fn %d finished, status %d", fn, status); ++ ++ rsp = iscsi_alloc_rsp(req); ++ rsp_hdr = (struct iscsi_task_rsp_hdr *)&rsp->pdu.bhs; ++ ++ rsp_hdr->opcode = ISCSI_OP_SCSI_TASK_MGT_RSP; ++ rsp_hdr->flags = ISCSI_FLG_FINAL; ++ rsp_hdr->itt = req_hdr->itt; ++ rsp_hdr->response = status; ++ ++ if (fn == ISCSI_FUNCTION_TARGET_COLD_RESET) { ++ rsp->should_close_conn = 1; ++ rsp->should_close_all_conn = 1; ++ } ++ ++ BUG_ON(sess->tm_rsp != NULL); ++ ++ spin_lock(&sess->sn_lock); ++ if (iscsi_is_delay_tm_resp(rsp)) { ++ TRACE_MGMT_DBG("Delaying TM fn %d response %p " ++ "(req %p), because not all affected commands " ++ "received (TM cmd sn %u, exp sn %u)", ++ req_hdr->function & ISCSI_FUNCTION_MASK, rsp, req, ++ req_hdr->cmd_sn, sess->exp_cmd_sn); ++ sess->tm_rsp = rsp; ++ spin_unlock(&sess->sn_lock); ++ goto out_release; ++ } ++ sess->tm_active--; ++ spin_unlock(&sess->sn_lock); ++ ++ BUG_ON(sess->tm_active < 0); ++ ++ iscsi_cmnd_init_write(rsp, ISCSI_INIT_WRITE_WAKE); ++ ++out_release: ++ req_cmnd_release(req); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static inline int iscsi_get_mgmt_response(int status) ++{ ++ switch (status) { ++ case SCST_MGMT_STATUS_SUCCESS: ++ return ISCSI_RESPONSE_FUNCTION_COMPLETE; ++ ++ case SCST_MGMT_STATUS_TASK_NOT_EXIST: ++ return ISCSI_RESPONSE_UNKNOWN_TASK; ++ ++ case SCST_MGMT_STATUS_LUN_NOT_EXIST: ++ return ISCSI_RESPONSE_UNKNOWN_LUN; ++ ++ case SCST_MGMT_STATUS_FN_NOT_SUPPORTED: ++ return ISCSI_RESPONSE_FUNCTION_UNSUPPORTED; ++ ++ case SCST_MGMT_STATUS_REJECTED: ++ case SCST_MGMT_STATUS_FAILED: ++ default: ++ return ISCSI_RESPONSE_FUNCTION_REJECTED; ++ } ++} ++ ++static void iscsi_task_mgmt_fn_done(struct scst_mgmt_cmd *scst_mcmd) ++{ ++ int fn = scst_mgmt_cmd_get_fn(scst_mcmd); ++ struct iscsi_cmnd *req = (struct iscsi_cmnd *) ++ scst_mgmt_cmd_get_tgt_priv(scst_mcmd); ++ int status = ++ iscsi_get_mgmt_response(scst_mgmt_cmd_get_status(scst_mcmd)); ++ ++ if ((status == ISCSI_RESPONSE_UNKNOWN_TASK) && ++ (fn == SCST_ABORT_TASK)) { ++ /* If we are here, we found the task, so must succeed */ ++ status = ISCSI_RESPONSE_FUNCTION_COMPLETE; ++ } ++ ++ TRACE_MGMT_DBG("req %p, scst_mcmd %p, fn %d, scst status %d, status %d", ++ req, scst_mcmd, fn, scst_mgmt_cmd_get_status(scst_mcmd), ++ status); ++ ++ switch (fn) { ++ case SCST_NEXUS_LOSS_SESS: ++ case SCST_ABORT_ALL_TASKS_SESS: ++ /* They are internal */ ++ break; ++ default: ++ iscsi_send_task_mgmt_resp(req, status); ++ scst_mgmt_cmd_set_tgt_priv(scst_mcmd, NULL); ++ break; ++ } ++ return; ++} ++ ++static int iscsi_scsi_aen(struct scst_aen *aen) ++{ ++ int res = SCST_AEN_RES_SUCCESS; ++ __be64 lun = scst_aen_get_lun(aen); ++ const uint8_t *sense = scst_aen_get_sense(aen); ++ int sense_len = scst_aen_get_sense_len(aen); ++ struct iscsi_session *sess = scst_sess_get_tgt_priv( ++ scst_aen_get_sess(aen)); ++ struct iscsi_conn *conn; ++ bool found; ++ struct iscsi_cmnd *fake_req, *rsp; ++ struct iscsi_async_msg_hdr *rsp_hdr; ++ struct scatterlist *sg; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("SCSI AEN to sess %p (initiator %s)", sess, ++ sess->initiator_name); ++ ++ mutex_lock(&sess->target->target_mutex); ++ ++ found = false; ++ list_for_each_entry_reverse(conn, &sess->conn_list, conn_list_entry) { ++ if (!test_bit(ISCSI_CONN_SHUTTINGDOWN, &conn->conn_aflags) && ++ (conn->conn_reinst_successor == NULL)) { ++ found = true; ++ break; ++ } ++ } ++ if (!found) { ++ TRACE_MGMT_DBG("Unable to find alive conn for sess %p", sess); ++ goto out_err; ++ } ++ ++ /* Create a fake request */ ++ fake_req = cmnd_alloc(conn, NULL); ++ if (fake_req == NULL) { ++ PRINT_ERROR("%s", "Unable to alloc fake AEN request"); ++ goto out_err; ++ } ++ ++ mutex_unlock(&sess->target->target_mutex); ++ ++ rsp = iscsi_alloc_main_rsp(fake_req); ++ if (rsp == NULL) { ++ PRINT_ERROR("%s", "Unable to alloc AEN rsp"); ++ goto out_err_free_req; ++ } ++ ++ fake_req->scst_state = ISCSI_CMD_STATE_AEN; ++ fake_req->scst_aen = aen; ++ ++ rsp_hdr = (struct iscsi_async_msg_hdr *)&rsp->pdu.bhs; ++ ++ rsp_hdr->opcode = ISCSI_OP_ASYNC_MSG; ++ rsp_hdr->flags = ISCSI_FLG_FINAL; ++ rsp_hdr->lun = lun; /* it's already in SCSI form */ ++ rsp_hdr->ffffffff = __constant_cpu_to_be32(0xffffffff); ++ rsp_hdr->async_event = ISCSI_ASYNC_SCSI; ++ ++ sg = rsp->sg = rsp->rsp_sg; ++ rsp->sg_cnt = 2; ++ rsp->own_sg = 1; ++ ++ sg_init_table(sg, 2); ++ sg_set_buf(&sg[0], &rsp->sense_hdr, sizeof(rsp->sense_hdr)); ++ sg_set_buf(&sg[1], sense, sense_len); ++ ++ rsp->sense_hdr.length = cpu_to_be16(sense_len); ++ rsp->pdu.datasize = sizeof(rsp->sense_hdr) + sense_len; ++ rsp->bufflen = rsp->pdu.datasize; ++ ++ req_cmnd_release(fake_req); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_err_free_req: ++ req_cmnd_release(fake_req); ++ ++out_err: ++ mutex_unlock(&sess->target->target_mutex); ++ res = SCST_AEN_RES_FAILED; ++ goto out; ++} ++ ++static int iscsi_cpu_mask_changed_aen(struct scst_aen *aen) ++{ ++ int res = SCST_AEN_RES_SUCCESS; ++ struct scst_session *scst_sess = scst_aen_get_sess(aen); ++ struct iscsi_session *sess = scst_sess_get_tgt_priv(scst_sess); ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("CPU mask changed AEN to sess %p (initiator %s)", sess, ++ sess->initiator_name); ++ ++ mutex_lock(&sess->target->target_mutex); ++ iscsi_sess_force_close(sess); ++ mutex_unlock(&sess->target->target_mutex); ++ ++ scst_aen_done(aen); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int iscsi_report_aen(struct scst_aen *aen) ++{ ++ int res; ++ int event_fn = scst_aen_get_event_fn(aen); ++ ++ TRACE_ENTRY(); ++ ++ switch (event_fn) { ++ case SCST_AEN_SCSI: ++ res = iscsi_scsi_aen(aen); ++ break; ++ case SCST_AEN_CPU_MASK_CHANGED: ++ res = iscsi_cpu_mask_changed_aen(aen); ++ break; ++ default: ++ TRACE_MGMT_DBG("Unsupported AEN %d", event_fn); ++ res = SCST_AEN_RES_NOT_SUPPORTED; ++ break; ++ } ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int iscsi_get_initiator_port_transport_id(struct scst_tgt *tgt, ++ struct scst_session *scst_sess, uint8_t **transport_id) ++{ ++ struct iscsi_session *sess; ++ int res = 0; ++ union iscsi_sid sid; ++ int tr_id_size; ++ uint8_t *tr_id; ++ uint8_t q; ++ ++ TRACE_ENTRY(); ++ ++ if (scst_sess == NULL) { ++ res = SCSI_TRANSPORTID_PROTOCOLID_ISCSI; ++ goto out; ++ } ++ ++ sess = (struct iscsi_session *)scst_sess_get_tgt_priv(scst_sess); ++ ++ sid = *(union iscsi_sid *)&sess->sid; ++ sid.id.tsih = 0; ++ ++ tr_id_size = 4 + strlen(sess->initiator_name) + 5 + ++ snprintf(&q, sizeof(q), "%llx", sid.id64) + 1; ++ tr_id_size = (tr_id_size + 3) & -4; ++ ++ tr_id = kzalloc(tr_id_size, GFP_KERNEL); ++ if (tr_id == NULL) { ++ PRINT_ERROR("Allocation of TransportID (size %d) failed", ++ tr_id_size); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ tr_id[0] = 0x40 | SCSI_TRANSPORTID_PROTOCOLID_ISCSI; ++ sprintf(&tr_id[4], "%s,i,0x%llx", sess->initiator_name, sid.id64); ++ ++ put_unaligned(cpu_to_be16(tr_id_size - 4), ++ (__be16 *)&tr_id[2]); ++ ++ *transport_id = tr_id; ++ ++ TRACE_DBG("Created tid '%s'", &tr_id[4]); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++void iscsi_send_nop_in(struct iscsi_conn *conn) ++{ ++ struct iscsi_cmnd *req, *rsp; ++ struct iscsi_nop_in_hdr *rsp_hdr; ++ ++ TRACE_ENTRY(); ++ ++ req = cmnd_alloc(conn, NULL); ++ if (req == NULL) { ++ PRINT_ERROR("%s", "Unable to alloc fake Nop-In request"); ++ goto out_err; ++ } ++ ++ rsp = iscsi_alloc_main_rsp(req); ++ if (rsp == NULL) { ++ PRINT_ERROR("%s", "Unable to alloc Nop-In rsp"); ++ goto out_err_free_req; ++ } ++ ++ cmnd_get(rsp); ++ ++ rsp_hdr = (struct iscsi_nop_in_hdr *)&rsp->pdu.bhs; ++ rsp_hdr->opcode = ISCSI_OP_NOP_IN; ++ rsp_hdr->flags = ISCSI_FLG_FINAL; ++ rsp_hdr->itt = ISCSI_RESERVED_TAG; ++ rsp_hdr->ttt = (__force __be32)conn->nop_in_ttt++; ++ ++ if (conn->nop_in_ttt == ISCSI_RESERVED_TAG_CPU32) ++ conn->nop_in_ttt = 0; ++ ++ /* Supposed that all other fields are zeroed */ ++ ++ TRACE_DBG("Sending Nop-In request (ttt 0x%08x)", rsp_hdr->ttt); ++ spin_lock_bh(&conn->nop_req_list_lock); ++ list_add_tail(&rsp->nop_req_list_entry, &conn->nop_req_list); ++ spin_unlock_bh(&conn->nop_req_list_lock); ++ ++out_err_free_req: ++ req_cmnd_release(req); ++ ++out_err: ++ TRACE_EXIT(); ++ return; ++} ++ ++static int iscsi_target_detect(struct scst_tgt_template *templ) ++{ ++ /* Nothing to do */ ++ return 0; ++} ++ ++static int iscsi_target_release(struct scst_tgt *scst_tgt) ++{ ++ /* Nothing to do */ ++ return 0; ++} ++ ++static struct scst_trace_log iscsi_local_trace_tbl[] = { ++ { TRACE_D_WRITE, "d_write" }, ++ { TRACE_CONN_OC, "conn" }, ++ { TRACE_CONN_OC_DBG, "conn_dbg" }, ++ { TRACE_D_IOV, "iov" }, ++ { TRACE_D_DUMP_PDU, "pdu" }, ++ { TRACE_NET_PG, "net_page" }, ++ { 0, NULL } ++}; ++ ++#define ISCSI_TRACE_TBL_HELP ", d_write, conn, conn_dbg, iov, pdu, net_page" ++ ++static uint16_t iscsi_get_scsi_transport_version(struct scst_tgt *scst_tgt) ++{ ++ return 0x0960; /* iSCSI */ ++} ++ ++struct scst_tgt_template iscsi_template = { ++ .name = "iscsi", ++ .sg_tablesize = 0xFFFF /* no limit */, ++ .threads_num = 0, ++ .no_clustering = 1, ++ .xmit_response_atomic = 0, ++ .tgtt_attrs = iscsi_attrs, ++ .tgt_attrs = iscsi_tgt_attrs, ++ .sess_attrs = iscsi_sess_attrs, ++ .enable_target = iscsi_enable_target, ++ .is_target_enabled = iscsi_is_target_enabled, ++ .add_target = iscsi_sysfs_add_target, ++ .del_target = iscsi_sysfs_del_target, ++ .mgmt_cmd = iscsi_sysfs_mgmt_cmd, ++ .tgtt_optional_attributes = "IncomingUser, OutgoingUser", ++ .tgt_optional_attributes = "IncomingUser, OutgoingUser, allowed_portal", ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ .default_trace_flags = ISCSI_DEFAULT_LOG_FLAGS, ++ .trace_flags = &trace_flag, ++ .trace_tbl = iscsi_local_trace_tbl, ++ .trace_tbl_help = ISCSI_TRACE_TBL_HELP, ++#endif ++ .detect = iscsi_target_detect, ++ .release = iscsi_target_release, ++ .xmit_response = iscsi_xmit_response, ++#if !defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++ .alloc_data_buf = iscsi_alloc_data_buf, ++#endif ++ .preprocessing_done = iscsi_preprocessing_done, ++ .pre_exec = iscsi_pre_exec, ++ .task_mgmt_affected_cmds_done = iscsi_task_mgmt_affected_cmds_done, ++ .task_mgmt_fn_done = iscsi_task_mgmt_fn_done, ++ .on_abort_cmd = iscsi_on_abort_cmd, ++ .report_aen = iscsi_report_aen, ++ .get_initiator_port_transport_id = iscsi_get_initiator_port_transport_id, ++ .get_scsi_transport_version = iscsi_get_scsi_transport_version, ++}; ++ ++int iscsi_threads_pool_get(const cpumask_t *cpu_mask, ++ struct iscsi_thread_pool **out_pool) ++{ ++ int res; ++ struct iscsi_thread_pool *p; ++ struct iscsi_thread *t, *tt; ++ int i, j, count; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&iscsi_threads_pool_mutex); ++ ++ list_for_each_entry(p, &iscsi_thread_pools_list, ++ thread_pools_list_entry) { ++ if ((cpu_mask == NULL) || ++ __cpus_equal(cpu_mask, &p->cpu_mask, nr_cpumask_bits)) { ++ p->thread_pool_ref++; ++ TRACE_DBG("iSCSI thread pool %p found (new ref %d)", ++ p, p->thread_pool_ref); ++ res = 0; ++ goto out_unlock; ++ } ++ } ++ ++ TRACE_DBG("%s", "Creating new iSCSI thread pool"); ++ ++ p = kzalloc(sizeof(*p), GFP_KERNEL); ++ if (p == NULL) { ++ PRINT_ERROR("Unable to allocate iSCSI thread pool (size %zd)", ++ sizeof(*p)); ++ res = -ENOMEM; ++ if (!list_empty(&iscsi_thread_pools_list)) { ++ PRINT_WARNING("%s", "Using global iSCSI thread pool " ++ "instead"); ++ p = list_entry(iscsi_thread_pools_list.next, ++ struct iscsi_thread_pool, ++ thread_pools_list_entry); ++ } else ++ res = -ENOMEM; ++ goto out_unlock; ++ } ++ ++ spin_lock_init(&p->rd_lock); ++ INIT_LIST_HEAD(&p->rd_list); ++ init_waitqueue_head(&p->rd_waitQ); ++ spin_lock_init(&p->wr_lock); ++ INIT_LIST_HEAD(&p->wr_list); ++ init_waitqueue_head(&p->wr_waitQ); ++ if (cpu_mask == NULL) ++ cpus_setall(p->cpu_mask); ++ else { ++ cpus_clear(p->cpu_mask); ++ for_each_cpu(i, cpu_mask) ++ cpu_set(i, p->cpu_mask); ++ } ++ p->thread_pool_ref = 1; ++ INIT_LIST_HEAD(&p->threads_list); ++ ++ if (cpu_mask == NULL) ++ count = max((int)num_online_cpus(), 2); ++ else { ++ count = 0; ++ for_each_cpu(i, cpu_mask) ++ count++; ++ } ++ ++ for (j = 0; j < 2; j++) { ++ int (*fn)(void *); ++ char name[25]; ++ static int major; ++ ++ if (j == 0) ++ fn = istrd; ++ else ++ fn = istwr; ++ ++ for (i = 0; i < count; i++) { ++ if (j == 0) { ++ major++; ++ if (cpu_mask == NULL) ++ snprintf(name, sizeof(name), "iscsird%d", i); ++ else ++ snprintf(name, sizeof(name), "iscsird%d_%d", ++ major, i); ++ } else { ++ if (cpu_mask == NULL) ++ snprintf(name, sizeof(name), "iscsiwr%d", i); ++ else ++ snprintf(name, sizeof(name), "iscsiwr%d_%d", ++ major, i); ++ } ++ ++ t = kmalloc(sizeof(*t), GFP_KERNEL); ++ if (t == NULL) { ++ res = -ENOMEM; ++ PRINT_ERROR("Failed to allocate thread %s " ++ "(size %zd)", name, sizeof(*t)); ++ goto out_free; ++ } ++ ++ t->thr = kthread_run(fn, p, name); ++ if (IS_ERR(t->thr)) { ++ res = PTR_ERR(t->thr); ++ PRINT_ERROR("kthread_run() for thread %s failed: %d", ++ name, res); ++ kfree(t); ++ goto out_free; ++ } ++ list_add_tail(&t->threads_list_entry, &p->threads_list); ++ } ++ } ++ ++ list_add_tail(&p->thread_pools_list_entry, &iscsi_thread_pools_list); ++ res = 0; ++ ++ TRACE_DBG("Created iSCSI thread pool %p", p); ++ ++out_unlock: ++ mutex_unlock(&iscsi_threads_pool_mutex); ++ ++ if (out_pool != NULL) ++ *out_pool = p; ++ ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free: ++ list_for_each_entry_safe(t, tt, &p->threads_list, threads_list_entry) { ++ kthread_stop(t->thr); ++ list_del(&t->threads_list_entry); ++ kfree(t); ++ } ++ goto out_unlock; ++} ++ ++void iscsi_threads_pool_put(struct iscsi_thread_pool *p) ++{ ++ struct iscsi_thread *t, *tt; ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&iscsi_threads_pool_mutex); ++ ++ p->thread_pool_ref--; ++ if (p->thread_pool_ref > 0) { ++ TRACE_DBG("iSCSI thread pool %p still has %d references)", ++ p, p->thread_pool_ref); ++ goto out_unlock; ++ } ++ ++ TRACE_DBG("Freeing iSCSI thread pool %p", p); ++ ++ list_for_each_entry_safe(t, tt, &p->threads_list, threads_list_entry) { ++ kthread_stop(t->thr); ++ list_del(&t->threads_list_entry); ++ kfree(t); ++ } ++ ++ list_del(&p->thread_pools_list_entry); ++ ++ kfree(p); ++ ++out_unlock: ++ mutex_unlock(&iscsi_threads_pool_mutex); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int __init iscsi_init(void) ++{ ++ int err = 0; ++ ++ PRINT_INFO("iSCSI SCST Target - version %s", ISCSI_VERSION_STRING); ++ ++ dummy_page = alloc_pages(GFP_KERNEL, 0); ++ if (dummy_page == NULL) { ++ PRINT_ERROR("%s", "Dummy page allocation failed"); ++ goto out; ++ } ++ ++ sg_init_table(&dummy_sg, 1); ++ sg_set_page(&dummy_sg, dummy_page, PAGE_SIZE, 0); ++ ++ iscsi_cmnd_abort_mempool = mempool_create_kmalloc_pool(2500, ++ sizeof(struct iscsi_cmnd_abort_params)); ++ if (iscsi_cmnd_abort_mempool == NULL) { ++ err = -ENOMEM; ++ goto out_free_dummy; ++ } ++ ++#if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++ err = net_set_get_put_page_callbacks(iscsi_get_page_callback, ++ iscsi_put_page_callback); ++ if (err != 0) { ++ PRINT_INFO("Unable to set page callbackes: %d", err); ++ goto out_destroy_mempool; ++ } ++#else ++#ifndef GENERATING_UPSTREAM_PATCH ++ PRINT_WARNING("%s", ++ "CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION " ++ "not enabled in your kernel. ISCSI-SCST will be working with " ++ "not the best performance. Refer README file for details."); ++#endif ++#endif ++ ++ ctr_major = register_chrdev(0, ctr_name, &ctr_fops); ++ if (ctr_major < 0) { ++ PRINT_ERROR("failed to register the control device %d", ++ ctr_major); ++ err = ctr_major; ++ goto out_callb; ++ } ++ ++ err = event_init(); ++ if (err < 0) ++ goto out_reg; ++ ++ iscsi_cmnd_cache = KMEM_CACHE(iscsi_cmnd, SCST_SLAB_FLAGS); ++ if (!iscsi_cmnd_cache) { ++ err = -ENOMEM; ++ goto out_event; ++ } ++ ++ err = scst_register_target_template(&iscsi_template); ++ if (err < 0) ++ goto out_kmem; ++ ++ iscsi_conn_ktype.sysfs_ops = scst_sysfs_get_sysfs_ops(); ++ ++ err = iscsi_threads_pool_get(NULL, &iscsi_main_thread_pool); ++ if (err != 0) ++ goto out_thr; ++ ++out: ++ return err; ++ ++out_thr: ++ ++ scst_unregister_target_template(&iscsi_template); ++ ++out_kmem: ++ kmem_cache_destroy(iscsi_cmnd_cache); ++ ++out_event: ++ event_exit(); ++ ++out_reg: ++ unregister_chrdev(ctr_major, ctr_name); ++ ++out_callb: ++#if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++ net_set_get_put_page_callbacks(NULL, NULL); ++ ++out_destroy_mempool: ++ mempool_destroy(iscsi_cmnd_abort_mempool); ++#endif ++ ++out_free_dummy: ++ __free_pages(dummy_page, 0); ++ goto out; ++} ++ ++static void __exit iscsi_exit(void) ++{ ++ iscsi_threads_pool_put(iscsi_main_thread_pool); ++ ++ BUG_ON(!list_empty(&iscsi_thread_pools_list)); ++ ++ unregister_chrdev(ctr_major, ctr_name); ++ ++ event_exit(); ++ ++ kmem_cache_destroy(iscsi_cmnd_cache); ++ ++ scst_unregister_target_template(&iscsi_template); ++ ++#if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++ net_set_get_put_page_callbacks(NULL, NULL); ++#endif ++ ++ mempool_destroy(iscsi_cmnd_abort_mempool); ++ ++ __free_pages(dummy_page, 0); ++ return; ++} ++ ++module_init(iscsi_init); ++module_exit(iscsi_exit); ++ ++MODULE_VERSION(ISCSI_VERSION_STRING); ++MODULE_LICENSE("GPL"); ++MODULE_DESCRIPTION("SCST iSCSI Target"); +diff -uprN orig/linux-3.2/drivers/scst/iscsi-scst/iscsi.h linux-3.2/drivers/scst/iscsi-scst/iscsi.h +--- orig/linux-3.2/drivers/scst/iscsi-scst/iscsi.h ++++ linux-3.2/drivers/scst/iscsi-scst/iscsi.h +@@ -0,0 +1,789 @@ ++/* ++ * Copyright (C) 2002 - 2003 Ardis Technolgies <roman@ardistech.com> ++ * Copyright (C) 2007 - 2011 Vladislav Bolkhovitin ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#ifndef __ISCSI_H__ ++#define __ISCSI_H__ ++ ++#include <linux/pagemap.h> ++#include <linux/mm.h> ++#include <linux/net.h> ++#include <linux/module.h> ++#include <net/sock.h> ++ ++#include <scst/scst.h> ++#include <scst/iscsi_scst.h> ++#include "iscsi_hdr.h" ++#include "iscsi_dbg.h" ++ ++#define iscsi_sense_crc_error ABORTED_COMMAND, 0x47, 0x05 ++#define iscsi_sense_unexpected_unsolicited_data ABORTED_COMMAND, 0x0C, 0x0C ++#define iscsi_sense_incorrect_amount_of_data ABORTED_COMMAND, 0x0C, 0x0D ++ ++struct iscsi_sess_params { ++ int initial_r2t; ++ int immediate_data; ++ int max_connections; ++ unsigned int max_recv_data_length; ++ unsigned int max_xmit_data_length; ++ unsigned int max_burst_length; ++ unsigned int first_burst_length; ++ int default_wait_time; ++ int default_retain_time; ++ unsigned int max_outstanding_r2t; ++ int data_pdu_inorder; ++ int data_sequence_inorder; ++ int error_recovery_level; ++ int header_digest; ++ int data_digest; ++ int ofmarker; ++ int ifmarker; ++ int ofmarkint; ++ int ifmarkint; ++}; ++ ++struct iscsi_tgt_params { ++ int queued_cmnds; ++ unsigned int rsp_timeout; ++ unsigned int nop_in_interval; ++ unsigned int nop_in_timeout; ++}; ++ ++struct iscsi_thread { ++ struct task_struct *thr; ++ struct list_head threads_list_entry; ++}; ++ ++struct iscsi_thread_pool { ++ spinlock_t rd_lock; ++ struct list_head rd_list; ++ wait_queue_head_t rd_waitQ; ++ ++ spinlock_t wr_lock; ++ struct list_head wr_list; ++ wait_queue_head_t wr_waitQ; ++ ++ cpumask_t cpu_mask; ++ ++ int thread_pool_ref; ++ ++ struct list_head threads_list; ++ ++ struct list_head thread_pools_list_entry; ++}; ++ ++struct iscsi_target; ++struct iscsi_cmnd; ++ ++struct iscsi_attr { ++ struct list_head attrs_list_entry; ++ struct kobj_attribute attr; ++ struct iscsi_target *target; ++ const char *name; ++}; ++ ++struct iscsi_target { ++ struct scst_tgt *scst_tgt; ++ ++ struct mutex target_mutex; ++ ++ struct list_head session_list; /* protected by target_mutex */ ++ ++ struct list_head target_list_entry; ++ u32 tid; ++ ++ unsigned int tgt_enabled:1; ++ ++ /* Protected by target_mutex */ ++ struct list_head attrs_list; ++ ++ char name[ISCSI_NAME_LEN]; ++}; ++ ++#define ISCSI_HASH_ORDER 8 ++#define cmnd_hashfn(itt) hash_32(itt, ISCSI_HASH_ORDER) ++ ++struct iscsi_session { ++ struct iscsi_target *target; ++ struct scst_session *scst_sess; ++ ++ struct list_head pending_list; /* protected by sn_lock */ ++ ++ /* Unprotected, since accessed only from a single read thread */ ++ u32 next_ttt; ++ ++ /* Read only, if there are connection(s) */ ++ struct iscsi_tgt_params tgt_params; ++ atomic_t active_cmds; ++ ++ spinlock_t sn_lock; ++ u32 exp_cmd_sn; /* protected by sn_lock */ ++ ++ /* All 3 protected by sn_lock */ ++ int tm_active; ++ u32 tm_sn; ++ struct iscsi_cmnd *tm_rsp; ++ ++ /* Read only, if there are connection(s) */ ++ struct iscsi_sess_params sess_params; ++ ++ /* ++ * In some corner cases commands can be deleted from the hash ++ * not from the corresponding read thread. So, let's simplify ++ * errors recovery and have this lock. ++ */ ++ spinlock_t cmnd_data_wait_hash_lock; ++ struct list_head cmnd_data_wait_hash[1 << ISCSI_HASH_ORDER]; ++ ++ struct list_head conn_list; /* protected by target_mutex */ ++ ++ struct list_head session_list_entry; ++ ++ /* All protected by target_mutex, where necessary */ ++ struct iscsi_session *sess_reinst_successor; ++ unsigned int sess_reinstating:1; ++ unsigned int sess_shutting_down:1; ++ ++ struct iscsi_thread_pool *sess_thr_pool; ++ ++ /* All don't need any protection */ ++ char *initiator_name; ++ u64 sid; ++}; ++ ++#define ISCSI_CONN_IOV_MAX (PAGE_SIZE/sizeof(struct iovec)) ++ ++#define ISCSI_CONN_RD_STATE_IDLE 0 ++#define ISCSI_CONN_RD_STATE_IN_LIST 1 ++#define ISCSI_CONN_RD_STATE_PROCESSING 2 ++ ++#define ISCSI_CONN_WR_STATE_IDLE 0 ++#define ISCSI_CONN_WR_STATE_IN_LIST 1 ++#define ISCSI_CONN_WR_STATE_SPACE_WAIT 2 ++#define ISCSI_CONN_WR_STATE_PROCESSING 3 ++ ++struct iscsi_conn { ++ struct iscsi_session *session; /* owning session */ ++ ++ /* Both protected by session->sn_lock */ ++ u32 stat_sn; ++ u32 exp_stat_sn; ++ ++#define ISCSI_CONN_REINSTATING 1 ++#define ISCSI_CONN_SHUTTINGDOWN 2 ++ unsigned long conn_aflags; ++ ++ spinlock_t cmd_list_lock; /* BH lock */ ++ ++ /* Protected by cmd_list_lock */ ++ struct list_head cmd_list; /* in/outcoming pdus */ ++ ++ atomic_t conn_ref_cnt; ++ ++ spinlock_t write_list_lock; ++ /* List of data pdus to be sent. Protected by write_list_lock */ ++ struct list_head write_list; ++ /* List of data pdus being sent. Protected by write_list_lock */ ++ struct list_head write_timeout_list; ++ ++ /* Protected by write_list_lock */ ++ struct timer_list rsp_timer; ++ unsigned int data_rsp_timeout; /* in jiffies */ ++ ++ /* ++ * All 2 protected by wr_lock. Modified independently to the ++ * above field, hence the alignment. ++ */ ++ unsigned short wr_state __attribute__((aligned(sizeof(long)))); ++ unsigned short wr_space_ready:1; ++ ++ struct list_head wr_list_entry; ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ struct task_struct *wr_task; ++#endif ++ ++ /* ++ * All are unprotected, since accessed only from a single write ++ * thread. ++ */ ++ struct iscsi_cmnd *write_cmnd; ++ struct iovec *write_iop; ++ int write_iop_used; ++ struct iovec write_iov[2]; ++ u32 write_size; ++ u32 write_offset; ++ int write_state; ++ ++ /* Both don't need any protection */ ++ struct file *file; ++ struct socket *sock; ++ ++ void (*old_state_change)(struct sock *); ++ void (*old_data_ready)(struct sock *, int); ++ void (*old_write_space)(struct sock *); ++ ++ /* Both read only. Stay here for better CPU cache locality. */ ++ int hdigest_type; ++ int ddigest_type; ++ ++ struct iscsi_thread_pool *conn_thr_pool; ++ ++ /* All 6 protected by rd_lock */ ++ unsigned short rd_state; ++ unsigned short rd_data_ready:1; ++ /* Let's save some cache footprint by putting them here */ ++ unsigned short closing:1; ++ unsigned short active_close:1; ++ unsigned short deleting:1; ++ unsigned short conn_tm_active:1; ++ ++ struct list_head rd_list_entry; ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ struct task_struct *rd_task; ++#endif ++ ++ unsigned long last_rcv_time; ++ ++ /* ++ * All are unprotected, since accessed only from a single read ++ * thread. ++ */ ++ struct iscsi_cmnd *read_cmnd; ++ struct msghdr read_msg; ++ u32 read_size; ++ int read_state; ++ struct iovec *read_iov; ++ struct task_struct *rx_task; ++ uint32_t rpadding; ++ ++ struct iscsi_target *target; ++ ++ struct list_head conn_list_entry; /* list entry in session conn_list */ ++ ++ /* All protected by target_mutex, where necessary */ ++ struct iscsi_conn *conn_reinst_successor; ++ struct list_head reinst_pending_cmd_list; ++ ++ wait_queue_head_t read_state_waitQ; ++ struct completion ready_to_free; ++ ++ /* Doesn't need any protection */ ++ u16 cid; ++ ++ struct delayed_work nop_in_delayed_work; ++ unsigned int nop_in_interval; /* in jiffies */ ++ unsigned int nop_in_timeout; /* in jiffies */ ++ struct list_head nop_req_list; ++ spinlock_t nop_req_list_lock; ++ u32 nop_in_ttt; ++ ++ /* Don't need any protection */ ++ struct kobject conn_kobj; ++ struct completion *conn_kobj_release_cmpl; ++}; ++ ++struct iscsi_pdu { ++ struct iscsi_hdr bhs; ++ void *ahs; ++ unsigned int ahssize; ++ unsigned int datasize; ++}; ++ ++typedef void (iscsi_show_info_t)(struct seq_file *seq, ++ struct iscsi_target *target); ++ ++/** Commands' states **/ ++ ++/* New command and SCST processes it */ ++#define ISCSI_CMD_STATE_NEW 0 ++ ++/* SCST processes cmd after scst_rx_cmd() */ ++#define ISCSI_CMD_STATE_RX_CMD 1 ++ ++/* The command returned from preprocessing_done() */ ++#define ISCSI_CMD_STATE_AFTER_PREPROC 2 ++ ++/* The command is waiting for session or connection reinstatement finished */ ++#define ISCSI_CMD_STATE_REINST_PENDING 3 ++ ++/* scst_restart_cmd() called and SCST processing it */ ++#define ISCSI_CMD_STATE_RESTARTED 4 ++ ++/* SCST done processing */ ++#define ISCSI_CMD_STATE_PROCESSED 5 ++ ++/* AEN processing */ ++#define ISCSI_CMD_STATE_AEN 6 ++ ++/* Out of SCST core preliminary completed */ ++#define ISCSI_CMD_STATE_OUT_OF_SCST_PRELIM_COMPL 7 ++ ++/* ++ * Most of the fields don't need any protection, since accessed from only a ++ * single thread, except where noted. ++ * ++ * ToDo: Eventually divide request and response structures in 2 separate ++ * structures and stop this IET-derived garbage. ++ */ ++struct iscsi_cmnd { ++ struct iscsi_conn *conn; ++ ++ /* ++ * Some flags used under conn->write_list_lock, but all modified only ++ * from single read thread or when there are no references to cmd. ++ */ ++ unsigned int hashed:1; ++ unsigned int should_close_conn:1; ++ unsigned int should_close_all_conn:1; ++ unsigned int pending:1; ++ unsigned int own_sg:1; ++ unsigned int on_write_list:1; ++ unsigned int write_processing_started:1; ++ unsigned int force_cleanup_done:1; ++ unsigned int dec_active_cmds:1; ++ unsigned int ddigest_checked:1; ++ /* ++ * Used to prevent release of original req while its related DATA OUT ++ * cmd is receiving data, i.e. stays between data_out_start() and ++ * data_out_end(). Ref counting can't be used for that, because ++ * req_cmnd_release() supposed to be called only once. ++ */ ++ unsigned int data_out_in_data_receiving:1; ++#ifdef CONFIG_SCST_EXTRACHECKS ++ unsigned int on_rx_digest_list:1; ++ unsigned int release_called:1; ++#endif ++ ++ /* ++ * We suppose that preliminary commands completion is tested by ++ * comparing prelim_compl_flags with 0. Otherwise, because of the ++ * gap between setting different flags a race is possible, ++ * like sending command in SCST core as PRELIM_COMPLETED, while it ++ * wasn't aborted in it yet and have as the result a wrong success ++ * status sent to the initiator. ++ */ ++#define ISCSI_CMD_ABORTED 0 ++#define ISCSI_CMD_PRELIM_COMPLETED 1 ++ unsigned long prelim_compl_flags; ++ ++ struct list_head hash_list_entry; ++ ++ /* ++ * Unions are for readability and grepability and to save some ++ * cache footprint. ++ */ ++ ++ union { ++ /* ++ * Used only to abort not yet sent responses. Usage in ++ * cmnd_done() is only a side effect to have a lockless ++ * accesss to this list from always only a single thread ++ * at any time. So, all responses live in the parent ++ * until it has the last reference put. ++ */ ++ struct list_head rsp_cmd_list; ++ struct list_head rsp_cmd_list_entry; ++ }; ++ ++ union { ++ struct list_head pending_list_entry; ++ struct list_head reinst_pending_cmd_list_entry; ++ }; ++ ++ union { ++ struct list_head write_list_entry; ++ struct list_head write_timeout_list_entry; ++ }; ++ ++ /* Both protected by conn->write_list_lock */ ++ unsigned int on_write_timeout_list:1; ++ unsigned long write_start; ++ ++ /* ++ * All unprotected, since could be accessed from only a single ++ * thread at time ++ */ ++ struct iscsi_cmnd *parent_req; ++ struct iscsi_cmnd *cmd_req; ++ ++ /* ++ * All unprotected, since could be accessed from only a single ++ * thread at time ++ */ ++ union { ++ /* Request only fields */ ++ struct { ++ struct list_head rx_ddigest_cmd_list; ++ struct list_head rx_ddigest_cmd_list_entry; ++ ++ int scst_state; ++ union { ++ struct scst_cmd *scst_cmd; ++ struct scst_aen *scst_aen; ++ }; ++ ++ struct iscsi_cmnd *main_rsp; ++ ++ /* ++ * Protected on modify by conn->write_list_lock, hence ++ * modified independently to the above field, hence the ++ * alignment. ++ */ ++ int not_processed_rsp_cnt ++ __attribute__((aligned(sizeof(long)))); ++ }; ++ ++ /* Response only fields */ ++ struct { ++ struct scatterlist rsp_sg[2]; ++ struct iscsi_sense_data sense_hdr; ++ }; ++ }; ++ ++ atomic_t ref_cnt; ++#if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++ atomic_t net_ref_cnt; ++#endif ++ ++ struct iscsi_pdu pdu; ++ ++ struct scatterlist *sg; ++ int sg_cnt; ++ unsigned int bufflen; ++ u32 r2t_sn; ++ unsigned int r2t_len_to_receive; ++ unsigned int r2t_len_to_send; ++ unsigned int outstanding_r2t; ++ u32 target_task_tag; ++ __be32 hdigest; ++ __be32 ddigest; ++ ++ struct list_head cmd_list_entry; ++ struct list_head nop_req_list_entry; ++ ++ unsigned int not_received_data_len; ++}; ++ ++/* Max time to wait for our response satisfied for aborted commands */ ++#define ISCSI_TM_DATA_WAIT_TIMEOUT (10 * HZ) ++ ++/* ++ * Needed addition to all timeouts to complete a burst of commands at once. ++ * Otherwise, a part of the burst can be timeouted only in double timeout time. ++ */ ++#define ISCSI_ADD_SCHED_TIME HZ ++ ++#define ISCSI_CTR_OPEN_STATE_CLOSED 0 ++#define ISCSI_CTR_OPEN_STATE_OPEN 1 ++#define ISCSI_CTR_OPEN_STATE_CLOSING 2 ++ ++extern struct mutex target_mgmt_mutex; ++ ++extern int ctr_open_state; ++extern const struct file_operations ctr_fops; ++ ++/* iscsi.c */ ++extern struct iscsi_cmnd *cmnd_alloc(struct iscsi_conn *, ++ struct iscsi_cmnd *parent); ++extern int cmnd_rx_start(struct iscsi_cmnd *); ++extern int cmnd_rx_continue(struct iscsi_cmnd *req); ++extern void cmnd_rx_end(struct iscsi_cmnd *); ++extern void cmnd_tx_start(struct iscsi_cmnd *); ++extern void cmnd_tx_end(struct iscsi_cmnd *); ++extern void req_cmnd_release_force(struct iscsi_cmnd *req); ++extern void rsp_cmnd_release(struct iscsi_cmnd *); ++extern void cmnd_done(struct iscsi_cmnd *cmnd); ++extern void conn_abort(struct iscsi_conn *conn); ++extern void iscsi_restart_cmnd(struct iscsi_cmnd *cmnd); ++extern void iscsi_fail_data_waiting_cmnd(struct iscsi_cmnd *cmnd); ++extern void iscsi_send_nop_in(struct iscsi_conn *conn); ++extern int iscsi_preliminary_complete(struct iscsi_cmnd *req, ++ struct iscsi_cmnd *orig_req, bool get_data); ++extern int set_scst_preliminary_status_rsp(struct iscsi_cmnd *req, ++ bool get_data, int key, int asc, int ascq); ++extern int iscsi_threads_pool_get(const cpumask_t *cpu_mask, ++ struct iscsi_thread_pool **out_pool); ++extern void iscsi_threads_pool_put(struct iscsi_thread_pool *p); ++ ++/* conn.c */ ++extern struct kobj_type iscsi_conn_ktype; ++extern struct iscsi_conn *conn_lookup(struct iscsi_session *, u16); ++extern void conn_reinst_finished(struct iscsi_conn *); ++extern int __add_conn(struct iscsi_session *, struct iscsi_kern_conn_info *); ++extern int __del_conn(struct iscsi_session *, struct iscsi_kern_conn_info *); ++extern int conn_free(struct iscsi_conn *); ++extern void iscsi_make_conn_rd_active(struct iscsi_conn *conn); ++#define ISCSI_CONN_ACTIVE_CLOSE 1 ++#define ISCSI_CONN_DELETING 2 ++extern void __mark_conn_closed(struct iscsi_conn *, int); ++extern void mark_conn_closed(struct iscsi_conn *); ++extern void iscsi_make_conn_wr_active(struct iscsi_conn *); ++extern void iscsi_check_tm_data_wait_timeouts(struct iscsi_conn *conn, ++ bool force); ++extern void __iscsi_write_space_ready(struct iscsi_conn *conn); ++ ++/* nthread.c */ ++extern int iscsi_send(struct iscsi_conn *conn); ++#if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++extern void iscsi_get_page_callback(struct page *page); ++extern void iscsi_put_page_callback(struct page *page); ++#endif ++extern int istrd(void *arg); ++extern int istwr(void *arg); ++extern void iscsi_task_mgmt_affected_cmds_done(struct scst_mgmt_cmd *scst_mcmd); ++extern void req_add_to_write_timeout_list(struct iscsi_cmnd *req); ++ ++/* target.c */ ++extern const struct attribute *iscsi_tgt_attrs[]; ++extern int iscsi_enable_target(struct scst_tgt *scst_tgt, bool enable); ++extern bool iscsi_is_target_enabled(struct scst_tgt *scst_tgt); ++extern ssize_t iscsi_sysfs_send_event(uint32_t tid, ++ enum iscsi_kern_event_code code, ++ const char *param1, const char *param2, void **data); ++extern struct iscsi_target *target_lookup_by_id(u32); ++extern int __add_target(struct iscsi_kern_target_info *); ++extern int __del_target(u32 id); ++extern ssize_t iscsi_sysfs_add_target(const char *target_name, char *params); ++extern ssize_t iscsi_sysfs_del_target(const char *target_name); ++extern ssize_t iscsi_sysfs_mgmt_cmd(char *cmd); ++extern void target_del_session(struct iscsi_target *target, ++ struct iscsi_session *session, int flags); ++extern void target_del_all_sess(struct iscsi_target *target, int flags); ++extern void target_del_all(void); ++ ++/* config.c */ ++extern const struct attribute *iscsi_attrs[]; ++extern int iscsi_add_attr(struct iscsi_target *target, ++ const struct iscsi_kern_attr *user_info); ++extern void __iscsi_del_attr(struct iscsi_target *target, ++ struct iscsi_attr *tgt_attr); ++ ++/* session.c */ ++extern const struct attribute *iscsi_sess_attrs[]; ++extern const struct file_operations session_seq_fops; ++extern struct iscsi_session *session_lookup(struct iscsi_target *, u64); ++extern void sess_reinst_finished(struct iscsi_session *); ++extern int __add_session(struct iscsi_target *, ++ struct iscsi_kern_session_info *); ++extern int __del_session(struct iscsi_target *, u64); ++extern int session_free(struct iscsi_session *session, bool del); ++extern void iscsi_sess_force_close(struct iscsi_session *sess); ++ ++/* params.c */ ++extern const char *iscsi_get_digest_name(int val, char *res); ++extern const char *iscsi_get_bool_value(int val); ++extern int iscsi_params_set(struct iscsi_target *, ++ struct iscsi_kern_params_info *, int); ++ ++/* event.c */ ++extern int event_send(u32, u64, u32, u32, enum iscsi_kern_event_code, ++ const char *param1, const char *param2); ++extern int event_init(void); ++extern void event_exit(void); ++ ++#define get_pgcnt(size, offset) \ ++ ((((size) + ((offset) & ~PAGE_MASK)) + PAGE_SIZE - 1) >> PAGE_SHIFT) ++ ++static inline void iscsi_cmnd_get_length(struct iscsi_pdu *pdu) ++{ ++#if defined(__BIG_ENDIAN) ++ pdu->ahssize = pdu->bhs.length.ahslength * 4; ++ pdu->datasize = pdu->bhs.length.datalength; ++#elif defined(__LITTLE_ENDIAN) ++ pdu->ahssize = ((__force __u32)pdu->bhs.length & 0xff) * 4; ++ pdu->datasize = be32_to_cpu((__force __be32)((__force __u32)pdu->bhs.length & ~0xff)); ++#else ++#error ++#endif ++} ++ ++static inline void iscsi_cmnd_set_length(struct iscsi_pdu *pdu) ++{ ++#if defined(__BIG_ENDIAN) ++ pdu->bhs.length.ahslength = pdu->ahssize / 4; ++ pdu->bhs.length.datalength = pdu->datasize; ++#elif defined(__LITTLE_ENDIAN) ++ pdu->bhs.length = cpu_to_be32(pdu->datasize) | (__force __be32)(pdu->ahssize / 4); ++#else ++#error ++#endif ++} ++ ++extern struct scst_tgt_template iscsi_template; ++ ++/* ++ * Skip this command if result is true. Must be called under ++ * corresponding lock. ++ */ ++static inline bool cmnd_get_check(struct iscsi_cmnd *cmnd) ++{ ++ int r = atomic_inc_return(&cmnd->ref_cnt); ++ int res; ++ if (unlikely(r == 1)) { ++ TRACE_DBG("cmnd %p is being destroyed", cmnd); ++ atomic_dec(&cmnd->ref_cnt); ++ res = 1; ++ /* Necessary code is serialized by locks in cmnd_done() */ ++ } else { ++ TRACE_DBG("cmnd %p, new ref_cnt %d", cmnd, ++ atomic_read(&cmnd->ref_cnt)); ++ res = 0; ++ } ++ return res; ++} ++ ++static inline void cmnd_get(struct iscsi_cmnd *cmnd) ++{ ++ atomic_inc(&cmnd->ref_cnt); ++ TRACE_DBG("cmnd %p, new cmnd->ref_cnt %d", cmnd, ++ atomic_read(&cmnd->ref_cnt)); ++ /* ++ * For the same reason as in kref_get(). Let's be safe and ++ * always do it. ++ */ ++ smp_mb__after_atomic_inc(); ++} ++ ++static inline void cmnd_put(struct iscsi_cmnd *cmnd) ++{ ++ TRACE_DBG("cmnd %p, new ref_cnt %d", cmnd, ++ atomic_read(&cmnd->ref_cnt)-1); ++ ++ EXTRACHECKS_BUG_ON(atomic_read(&cmnd->ref_cnt) == 0); ++ ++ if (atomic_dec_and_test(&cmnd->ref_cnt)) ++ cmnd_done(cmnd); ++} ++ ++/* conn->write_list_lock supposed to be locked and BHs off */ ++static inline void cmd_add_on_write_list(struct iscsi_conn *conn, ++ struct iscsi_cmnd *cmnd) ++{ ++ struct iscsi_cmnd *parent = cmnd->parent_req; ++ ++ TRACE_DBG("cmnd %p", cmnd); ++ /* See comment in iscsi_restart_cmnd() */ ++ EXTRACHECKS_BUG_ON(cmnd->parent_req->hashed && ++ (cmnd_opcode(cmnd) != ISCSI_OP_R2T)); ++ list_add_tail(&cmnd->write_list_entry, &conn->write_list); ++ cmnd->on_write_list = 1; ++ ++ parent->not_processed_rsp_cnt++; ++ TRACE_DBG("not processed rsp cnt %d (parent %p)", ++ parent->not_processed_rsp_cnt, parent); ++} ++ ++/* conn->write_list_lock supposed to be locked and BHs off */ ++static inline void cmd_del_from_write_list(struct iscsi_cmnd *cmnd) ++{ ++ struct iscsi_cmnd *parent = cmnd->parent_req; ++ ++ TRACE_DBG("%p", cmnd); ++ list_del(&cmnd->write_list_entry); ++ cmnd->on_write_list = 0; ++ ++ parent->not_processed_rsp_cnt--; ++ TRACE_DBG("not processed rsp cnt %d (parent %p)", ++ parent->not_processed_rsp_cnt, parent); ++ EXTRACHECKS_BUG_ON(parent->not_processed_rsp_cnt < 0); ++} ++ ++static inline void cmd_add_on_rx_ddigest_list(struct iscsi_cmnd *req, ++ struct iscsi_cmnd *cmnd) ++{ ++ TRACE_DBG("Adding RX ddigest cmd %p to digest list " ++ "of req %p", cmnd, req); ++ list_add_tail(&cmnd->rx_ddigest_cmd_list_entry, ++ &req->rx_ddigest_cmd_list); ++#ifdef CONFIG_SCST_EXTRACHECKS ++ cmnd->on_rx_digest_list = 1; ++#endif ++} ++ ++static inline void cmd_del_from_rx_ddigest_list(struct iscsi_cmnd *cmnd) ++{ ++ TRACE_DBG("Deleting RX digest cmd %p from digest list", cmnd); ++ list_del(&cmnd->rx_ddigest_cmd_list_entry); ++#ifdef CONFIG_SCST_EXTRACHECKS ++ cmnd->on_rx_digest_list = 0; ++#endif ++} ++ ++static inline unsigned long iscsi_get_timeout(struct iscsi_cmnd *req) ++{ ++ unsigned long res; ++ ++ res = (cmnd_opcode(req) == ISCSI_OP_NOP_OUT) ? ++ req->conn->nop_in_timeout : req->conn->data_rsp_timeout; ++ ++ if (unlikely(test_bit(ISCSI_CMD_ABORTED, &req->prelim_compl_flags))) ++ res = min_t(unsigned long, res, ISCSI_TM_DATA_WAIT_TIMEOUT); ++ ++ return res; ++} ++ ++static inline unsigned long iscsi_get_timeout_time(struct iscsi_cmnd *req) ++{ ++ return req->write_start + iscsi_get_timeout(req); ++} ++ ++static inline int test_write_ready(struct iscsi_conn *conn) ++{ ++ /* ++ * No need for write_list protection, in the worst case we will be ++ * restarted again. ++ */ ++ return !list_empty(&conn->write_list) || conn->write_cmnd; ++} ++ ++static inline void conn_get(struct iscsi_conn *conn) ++{ ++ atomic_inc(&conn->conn_ref_cnt); ++ TRACE_DBG("conn %p, new conn_ref_cnt %d", conn, ++ atomic_read(&conn->conn_ref_cnt)); ++ /* ++ * For the same reason as in kref_get(). Let's be safe and ++ * always do it. ++ */ ++ smp_mb__after_atomic_inc(); ++} ++ ++static inline void conn_put(struct iscsi_conn *conn) ++{ ++ TRACE_DBG("conn %p, new conn_ref_cnt %d", conn, ++ atomic_read(&conn->conn_ref_cnt)-1); ++ BUG_ON(atomic_read(&conn->conn_ref_cnt) == 0); ++ ++ /* ++ * Make it always ordered to protect from undesired side effects like ++ * accessing just destroyed by close_conn() conn caused by reordering ++ * of this atomic_dec(). ++ */ ++ smp_mb__before_atomic_dec(); ++ atomic_dec(&conn->conn_ref_cnt); ++} ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++extern void iscsi_extracheck_is_rd_thread(struct iscsi_conn *conn); ++extern void iscsi_extracheck_is_wr_thread(struct iscsi_conn *conn); ++#else ++static inline void iscsi_extracheck_is_rd_thread(struct iscsi_conn *conn) {} ++static inline void iscsi_extracheck_is_wr_thread(struct iscsi_conn *conn) {} ++#endif ++ ++#endif /* __ISCSI_H__ */ +diff -uprN orig/linux-3.2/drivers/scst/iscsi-scst/iscsi_dbg.h linux-3.2/drivers/scst/iscsi-scst/iscsi_dbg.h +--- orig/linux-3.2/drivers/scst/iscsi-scst/iscsi_dbg.h ++++ linux-3.2/drivers/scst/iscsi-scst/iscsi_dbg.h +@@ -0,0 +1,61 @@ ++/* ++ * Copyright (C) 2007 - 2011 Vladislav Bolkhovitin ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#ifndef ISCSI_DBG_H ++#define ISCSI_DBG_H ++ ++#define LOG_PREFIX "iscsi-scst" ++ ++#include <scst/scst_debug.h> ++ ++#define TRACE_D_WRITE 0x80000000 ++#define TRACE_CONN_OC 0x40000000 ++#define TRACE_D_IOV 0x20000000 ++#define TRACE_D_DUMP_PDU 0x10000000 ++#define TRACE_NET_PG 0x08000000 ++#define TRACE_CONN_OC_DBG 0x04000000 ++ ++#ifdef CONFIG_SCST_DEBUG ++#define ISCSI_DEFAULT_LOG_FLAGS (TRACE_FUNCTION | TRACE_LINE | TRACE_PID | \ ++ TRACE_OUT_OF_MEM | TRACE_MGMT | TRACE_MGMT_DEBUG | \ ++ TRACE_MINOR | TRACE_SPECIAL | TRACE_CONN_OC) ++#else ++#define ISCSI_DEFAULT_LOG_FLAGS (TRACE_OUT_OF_MEM | TRACE_MGMT | \ ++ TRACE_SPECIAL) ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG ++struct iscsi_pdu; ++struct iscsi_cmnd; ++extern void iscsi_dump_pdu(struct iscsi_pdu *pdu); ++extern unsigned long iscsi_get_flow_ctrl_or_mgmt_dbg_log_flag( ++ struct iscsi_cmnd *cmnd); ++#else ++#define iscsi_dump_pdu(x) do {} while (0) ++#define iscsi_get_flow_ctrl_or_mgmt_dbg_log_flag(x) do {} while (0) ++#endif ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++extern unsigned long iscsi_trace_flag; ++#define trace_flag iscsi_trace_flag ++#endif ++ ++#define TRACE_CONN_CLOSE(args...) TRACE_DBG_FLAG(TRACE_DEBUG|TRACE_CONN_OC, args) ++#define TRACE_CONN_CLOSE_DBG(args...) TRACE(TRACE_CONN_OC_DBG, args) ++#define TRACE_NET_PAGE(args...) TRACE_DBG_FLAG(TRACE_NET_PG, args) ++#define TRACE_WRITE(args...) TRACE_DBG_FLAG(TRACE_DEBUG|TRACE_D_WRITE, args) ++ ++#endif +diff -uprN orig/linux-3.2/drivers/scst/iscsi-scst/iscsi_hdr.h linux-3.2/drivers/scst/iscsi-scst/iscsi_hdr.h +--- orig/linux-3.2/drivers/scst/iscsi-scst/iscsi_hdr.h ++++ linux-3.2/drivers/scst/iscsi-scst/iscsi_hdr.h +@@ -0,0 +1,526 @@ ++/* ++ * Copyright (C) 2002 - 2003 Ardis Technolgies <roman@ardistech.com> ++ * Copyright (C) 2007 - 2011 Vladislav Bolkhovitin ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#ifndef __ISCSI_HDR_H__ ++#define __ISCSI_HDR_H__ ++ ++#include <linux/types.h> ++#include <asm/byteorder.h> ++ ++#define ISCSI_VERSION 0 ++ ++#ifndef __packed ++#define __packed __attribute__ ((packed)) ++#endif ++ ++/* iSCSI command PDU header. See also section 10.3 in RFC 3720. */ ++struct iscsi_hdr { ++ u8 opcode; /* 0 */ ++ u8 flags; ++ u8 spec1[2]; ++#if defined(__BIG_ENDIAN_BITFIELD) ++ struct { /* 4 */ ++ unsigned ahslength:8; ++ unsigned datalength:24; ++ } length; ++#elif defined(__LITTLE_ENDIAN_BITFIELD) ++ __be32 length; /* 4 */ ++#endif ++ __be64 lun; /* 8 */ ++ __be32 itt; /* 16 */ ++ __be32 ttt; /* 20 */ ++ ++ /* ++ * SN fields most time stay converted to the CPU form and only received ++ * and send in the BE form. ++ */ ++ u32 sn; /* 24 */ ++ u32 exp_sn; /* 28 */ ++ u32 max_sn; /* 32 */ ++ ++ __be32 spec3[3]; /* 36 */ ++} __packed; /* 48 */ ++ ++/* Opcode encoding bits */ ++#define ISCSI_OP_RETRY 0x80 ++#define ISCSI_OP_IMMEDIATE 0x40 ++#define ISCSI_OPCODE_MASK 0x3F ++ ++/* Client to Server Message Opcode values */ ++#define ISCSI_OP_NOP_OUT 0x00 ++#define ISCSI_OP_SCSI_CMD 0x01 ++#define ISCSI_OP_SCSI_TASK_MGT_MSG 0x02 ++#define ISCSI_OP_LOGIN_CMD 0x03 ++#define ISCSI_OP_TEXT_CMD 0x04 ++#define ISCSI_OP_SCSI_DATA_OUT 0x05 ++#define ISCSI_OP_LOGOUT_CMD 0x06 ++#define ISCSI_OP_SNACK_CMD 0x10 ++ ++/* Server to Client Message Opcode values */ ++#define ISCSI_OP_NOP_IN 0x20 ++#define ISCSI_OP_SCSI_RSP 0x21 ++#define ISCSI_OP_SCSI_TASK_MGT_RSP 0x22 ++#define ISCSI_OP_LOGIN_RSP 0x23 ++#define ISCSI_OP_TEXT_RSP 0x24 ++#define ISCSI_OP_SCSI_DATA_IN 0x25 ++#define ISCSI_OP_LOGOUT_RSP 0x26 ++#define ISCSI_OP_R2T 0x31 ++#define ISCSI_OP_ASYNC_MSG 0x32 ++#define ISCSI_OP_REJECT 0x3f ++ ++struct iscsi_ahs_hdr { ++ __be16 ahslength; ++ u8 ahstype; ++} __packed; ++ ++#define ISCSI_AHSTYPE_CDB 1 ++#define ISCSI_AHSTYPE_RLENGTH 2 ++ ++union iscsi_sid { ++ struct { ++ u8 isid[6]; /* Initiator Session ID */ ++ __be16 tsih; /* Target Session ID */ ++ } id; ++ __be64 id64; ++} __packed; ++ ++struct iscsi_scsi_cmd_hdr { ++ u8 opcode; ++ u8 flags; ++ __be16 rsvd1; ++ u8 ahslength; ++ u8 datalength[3]; ++ __be64 lun; ++ __be32 itt; ++ __be32 data_length; ++ u32 cmd_sn; ++ u32 exp_stat_sn; ++ u8 scb[16]; ++} __packed; ++ ++#define ISCSI_CMD_FINAL 0x80 ++#define ISCSI_CMD_READ 0x40 ++#define ISCSI_CMD_WRITE 0x20 ++#define ISCSI_CMD_ATTR_MASK 0x07 ++#define ISCSI_CMD_UNTAGGED 0x00 ++#define ISCSI_CMD_SIMPLE 0x01 ++#define ISCSI_CMD_ORDERED 0x02 ++#define ISCSI_CMD_HEAD_OF_QUEUE 0x03 ++#define ISCSI_CMD_ACA 0x04 ++ ++struct iscsi_cdb_ahdr { ++ __be16 ahslength; ++ u8 ahstype; ++ u8 reserved; ++ u8 cdb[0]; ++} __packed; ++ ++struct iscsi_rlength_ahdr { ++ __be16 ahslength; ++ u8 ahstype; ++ u8 reserved; ++ __be32 read_length; ++} __packed; ++ ++struct iscsi_scsi_rsp_hdr { ++ u8 opcode; ++ u8 flags; ++ u8 response; ++ u8 cmd_status; ++ u8 ahslength; ++ u8 datalength[3]; ++ u32 rsvd1[2]; ++ __be32 itt; ++ __be32 snack; ++ u32 stat_sn; ++ u32 exp_cmd_sn; ++ u32 max_cmd_sn; ++ u32 exp_data_sn; ++ __be32 bi_residual_count; ++ __be32 residual_count; ++} __packed; ++ ++#define ISCSI_FLG_RESIDUAL_UNDERFLOW 0x02 ++#define ISCSI_FLG_RESIDUAL_OVERFLOW 0x04 ++#define ISCSI_FLG_BIRESIDUAL_UNDERFLOW 0x08 ++#define ISCSI_FLG_BIRESIDUAL_OVERFLOW 0x10 ++ ++#define ISCSI_RESPONSE_COMMAND_COMPLETED 0x00 ++#define ISCSI_RESPONSE_TARGET_FAILURE 0x01 ++ ++struct iscsi_sense_data { ++ __be16 length; ++ u8 data[0]; ++} __packed; ++ ++struct iscsi_task_mgt_hdr { ++ u8 opcode; ++ u8 function; ++ __be16 rsvd1; ++ u8 ahslength; ++ u8 datalength[3]; ++ __be64 lun; ++ __be32 itt; ++ __be32 rtt; ++ u32 cmd_sn; ++ u32 exp_stat_sn; ++ u32 ref_cmd_sn; ++ u32 exp_data_sn; ++ u32 rsvd2[2]; ++} __packed; ++ ++#define ISCSI_FUNCTION_MASK 0x7f ++ ++#define ISCSI_FUNCTION_ABORT_TASK 1 ++#define ISCSI_FUNCTION_ABORT_TASK_SET 2 ++#define ISCSI_FUNCTION_CLEAR_ACA 3 ++#define ISCSI_FUNCTION_CLEAR_TASK_SET 4 ++#define ISCSI_FUNCTION_LOGICAL_UNIT_RESET 5 ++#define ISCSI_FUNCTION_TARGET_WARM_RESET 6 ++#define ISCSI_FUNCTION_TARGET_COLD_RESET 7 ++#define ISCSI_FUNCTION_TASK_REASSIGN 8 ++ ++struct iscsi_task_rsp_hdr { ++ u8 opcode; ++ u8 flags; ++ u8 response; ++ u8 rsvd1; ++ u8 ahslength; ++ u8 datalength[3]; ++ u32 rsvd2[2]; ++ __be32 itt; ++ u32 rsvd3; ++ u32 stat_sn; ++ u32 exp_cmd_sn; ++ u32 max_cmd_sn; ++ u32 rsvd4[3]; ++} __packed; ++ ++#define ISCSI_RESPONSE_FUNCTION_COMPLETE 0 ++#define ISCSI_RESPONSE_UNKNOWN_TASK 1 ++#define ISCSI_RESPONSE_UNKNOWN_LUN 2 ++#define ISCSI_RESPONSE_TASK_ALLEGIANT 3 ++#define ISCSI_RESPONSE_ALLEGIANCE_REASSIGNMENT_UNSUPPORTED 4 ++#define ISCSI_RESPONSE_FUNCTION_UNSUPPORTED 5 ++#define ISCSI_RESPONSE_NO_AUTHORIZATION 6 ++#define ISCSI_RESPONSE_FUNCTION_REJECTED 255 ++ ++struct iscsi_data_out_hdr { ++ u8 opcode; ++ u8 flags; ++ u16 rsvd1; ++ u8 ahslength; ++ u8 datalength[3]; ++ __be64 lun; ++ __be32 itt; ++ __be32 ttt; ++ u32 rsvd2; ++ u32 exp_stat_sn; ++ u32 rsvd3; ++ __be32 data_sn; ++ __be32 buffer_offset; ++ u32 rsvd4; ++} __packed; ++ ++struct iscsi_data_in_hdr { ++ u8 opcode; ++ u8 flags; ++ u8 rsvd1; ++ u8 cmd_status; ++ u8 ahslength; ++ u8 datalength[3]; ++ u32 rsvd2[2]; ++ __be32 itt; ++ __be32 ttt; ++ u32 stat_sn; ++ u32 exp_cmd_sn; ++ u32 max_cmd_sn; ++ __be32 data_sn; ++ __be32 buffer_offset; ++ __be32 residual_count; ++} __packed; ++ ++#define ISCSI_FLG_STATUS 0x01 ++ ++struct iscsi_r2t_hdr { ++ u8 opcode; ++ u8 flags; ++ u16 rsvd1; ++ u8 ahslength; ++ u8 datalength[3]; ++ __be64 lun; ++ __be32 itt; ++ __be32 ttt; ++ u32 stat_sn; ++ u32 exp_cmd_sn; ++ u32 max_cmd_sn; ++ u32 r2t_sn; ++ __be32 buffer_offset; ++ __be32 data_length; ++} __packed; ++ ++struct iscsi_async_msg_hdr { ++ u8 opcode; ++ u8 flags; ++ u16 rsvd1; ++ u8 ahslength; ++ u8 datalength[3]; ++ __be64 lun; ++ __be32 ffffffff; ++ u32 rsvd2; ++ u32 stat_sn; ++ u32 exp_cmd_sn; ++ u32 max_cmd_sn; ++ u8 async_event; ++ u8 async_vcode; ++ __be16 param1; ++ __be16 param2; ++ __be16 param3; ++ u32 rsvd3; ++} __packed; ++ ++#define ISCSI_ASYNC_SCSI 0 ++#define ISCSI_ASYNC_LOGOUT 1 ++#define ISCSI_ASYNC_DROP_CONNECTION 2 ++#define ISCSI_ASYNC_DROP_SESSION 3 ++#define ISCSI_ASYNC_PARAM_REQUEST 4 ++#define ISCSI_ASYNC_VENDOR 255 ++ ++struct iscsi_text_req_hdr { ++ u8 opcode; ++ u8 flags; ++ u16 rsvd1; ++ u8 ahslength; ++ u8 datalength[3]; ++ u32 rsvd2[2]; ++ __be32 itt; ++ __be32 ttt; ++ u32 cmd_sn; ++ u32 exp_stat_sn; ++ u32 rsvd3[4]; ++} __packed; ++ ++struct iscsi_text_rsp_hdr { ++ u8 opcode; ++ u8 flags; ++ u16 rsvd1; ++ u8 ahslength; ++ u8 datalength[3]; ++ u32 rsvd2[2]; ++ __be32 itt; ++ __be32 ttt; ++ u32 stat_sn; ++ u32 exp_cmd_sn; ++ u32 max_cmd_sn; ++ u32 rsvd3[3]; ++} __packed; ++ ++struct iscsi_login_req_hdr { ++ u8 opcode; ++ u8 flags; ++ u8 max_version; /* Max. version supported */ ++ u8 min_version; /* Min. version supported */ ++ u8 ahslength; ++ u8 datalength[3]; ++ union iscsi_sid sid; ++ __be32 itt; /* Initiator Task Tag */ ++ __be16 cid; /* Connection ID */ ++ u16 rsvd1; ++ u32 cmd_sn; ++ u32 exp_stat_sn; ++ u32 rsvd2[4]; ++} __packed; ++ ++struct iscsi_login_rsp_hdr { ++ u8 opcode; ++ u8 flags; ++ u8 max_version; /* Max. version supported */ ++ u8 active_version; /* Active version */ ++ u8 ahslength; ++ u8 datalength[3]; ++ union iscsi_sid sid; ++ __be32 itt; /* Initiator Task Tag */ ++ u32 rsvd1; ++ u32 stat_sn; ++ u32 exp_cmd_sn; ++ u32 max_cmd_sn; ++ u8 status_class; /* see Login RSP Status classes below */ ++ u8 status_detail; /* see Login RSP Status details below */ ++ u8 rsvd2[10]; ++} __packed; ++ ++#define ISCSI_FLG_FINAL 0x80 ++#define ISCSI_FLG_TRANSIT 0x80 ++#define ISCSI_FLG_CSG_SECURITY 0x00 ++#define ISCSI_FLG_CSG_LOGIN 0x04 ++#define ISCSI_FLG_CSG_FULL_FEATURE 0x0c ++#define ISCSI_FLG_CSG_MASK 0x0c ++#define ISCSI_FLG_NSG_SECURITY 0x00 ++#define ISCSI_FLG_NSG_LOGIN 0x01 ++#define ISCSI_FLG_NSG_FULL_FEATURE 0x03 ++#define ISCSI_FLG_NSG_MASK 0x03 ++ ++/* Login Status response classes */ ++#define ISCSI_STATUS_SUCCESS 0x00 ++#define ISCSI_STATUS_REDIRECT 0x01 ++#define ISCSI_STATUS_INITIATOR_ERR 0x02 ++#define ISCSI_STATUS_TARGET_ERR 0x03 ++ ++/* Login Status response detail codes */ ++/* Class-0 (Success) */ ++#define ISCSI_STATUS_ACCEPT 0x00 ++ ++/* Class-1 (Redirection) */ ++#define ISCSI_STATUS_TGT_MOVED_TEMP 0x01 ++#define ISCSI_STATUS_TGT_MOVED_PERM 0x02 ++ ++/* Class-2 (Initiator Error) */ ++#define ISCSI_STATUS_INIT_ERR 0x00 ++#define ISCSI_STATUS_AUTH_FAILED 0x01 ++#define ISCSI_STATUS_TGT_FORBIDDEN 0x02 ++#define ISCSI_STATUS_TGT_NOT_FOUND 0x03 ++#define ISCSI_STATUS_TGT_REMOVED 0x04 ++#define ISCSI_STATUS_NO_VERSION 0x05 ++#define ISCSI_STATUS_TOO_MANY_CONN 0x06 ++#define ISCSI_STATUS_MISSING_FIELDS 0x07 ++#define ISCSI_STATUS_CONN_ADD_FAILED 0x08 ++#define ISCSI_STATUS_INV_SESSION_TYPE 0x09 ++#define ISCSI_STATUS_SESSION_NOT_FOUND 0x0a ++#define ISCSI_STATUS_INV_REQ_TYPE 0x0b ++ ++/* Class-3 (Target Error) */ ++#define ISCSI_STATUS_TARGET_ERROR 0x00 ++#define ISCSI_STATUS_SVC_UNAVAILABLE 0x01 ++#define ISCSI_STATUS_NO_RESOURCES 0x02 ++ ++struct iscsi_logout_req_hdr { ++ u8 opcode; ++ u8 flags; ++ u16 rsvd1; ++ u8 ahslength; ++ u8 datalength[3]; ++ u32 rsvd2[2]; ++ __be32 itt; ++ __be16 cid; ++ u16 rsvd3; ++ u32 cmd_sn; ++ u32 exp_stat_sn; ++ u32 rsvd4[4]; ++} __packed; ++ ++struct iscsi_logout_rsp_hdr { ++ u8 opcode; ++ u8 flags; ++ u8 response; ++ u8 rsvd1; ++ u8 ahslength; ++ u8 datalength[3]; ++ u32 rsvd2[2]; ++ __be32 itt; ++ u32 rsvd3; ++ u32 stat_sn; ++ u32 exp_cmd_sn; ++ u32 max_cmd_sn; ++ u32 rsvd4; ++ __be16 time2wait; ++ __be16 time2retain; ++ u32 rsvd5; ++} __packed; ++ ++struct iscsi_snack_req_hdr { ++ u8 opcode; ++ u8 flags; ++ u16 rsvd1; ++ u8 ahslength; ++ u8 datalength[3]; ++ u32 rsvd2[2]; ++ __be32 itt; ++ __be32 ttt; ++ u32 rsvd3; ++ u32 exp_stat_sn; ++ u32 rsvd4[2]; ++ __be32 beg_run; ++ __be32 run_length; ++} __packed; ++ ++struct iscsi_reject_hdr { ++ u8 opcode; ++ u8 flags; ++ u8 reason; ++ u8 rsvd1; ++ u8 ahslength; ++ u8 datalength[3]; ++ u32 rsvd2[2]; ++ __be32 ffffffff; ++ __be32 rsvd3; ++ u32 stat_sn; ++ u32 exp_cmd_sn; ++ u32 max_cmd_sn; ++ __be32 data_sn; ++ u32 rsvd4[2]; ++} __packed; ++ ++#define ISCSI_REASON_RESERVED 0x01 ++#define ISCSI_REASON_DATA_DIGEST_ERROR 0x02 ++#define ISCSI_REASON_DATA_SNACK_REJECT 0x03 ++#define ISCSI_REASON_PROTOCOL_ERROR 0x04 ++#define ISCSI_REASON_UNSUPPORTED_COMMAND 0x05 ++#define ISCSI_REASON_IMMEDIATE_COMMAND_REJECT 0x06 ++#define ISCSI_REASON_TASK_IN_PROGRESS 0x07 ++#define ISCSI_REASON_INVALID_DATA_ACK 0x08 ++#define ISCSI_REASON_INVALID_PDU_FIELD 0x09 ++#define ISCSI_REASON_OUT_OF_RESOURCES 0x0a ++#define ISCSI_REASON_NEGOTIATION_RESET 0x0b ++#define ISCSI_REASON_WAITING_LOGOUT 0x0c ++ ++struct iscsi_nop_out_hdr { ++ u8 opcode; ++ u8 flags; ++ u16 rsvd1; ++ u8 ahslength; ++ u8 datalength[3]; ++ __be64 lun; ++ __be32 itt; ++ __be32 ttt; ++ u32 cmd_sn; ++ u32 exp_stat_sn; ++ u32 rsvd2[4]; ++} __packed; ++ ++struct iscsi_nop_in_hdr { ++ u8 opcode; ++ u8 flags; ++ u16 rsvd1; ++ u8 ahslength; ++ u8 datalength[3]; ++ __be64 lun; ++ __be32 itt; ++ __be32 ttt; ++ u32 stat_sn; ++ u32 exp_cmd_sn; ++ u32 max_cmd_sn; ++ u32 rsvd2[3]; ++} __packed; ++ ++#define ISCSI_RESERVED_TAG_CPU32 (0xffffffffU) ++#define ISCSI_RESERVED_TAG (__constant_cpu_to_be32(ISCSI_RESERVED_TAG_CPU32)) ++ ++#define cmnd_hdr(cmnd) ((struct iscsi_scsi_cmd_hdr *) (&((cmnd)->pdu.bhs))) ++#define cmnd_opcode(cmnd) ((cmnd)->pdu.bhs.opcode & ISCSI_OPCODE_MASK) ++#define cmnd_scsicode(cmnd) (cmnd_hdr((cmnd))->scb[0]) ++ ++#endif /* __ISCSI_HDR_H__ */ +diff -uprN orig/linux-3.2/drivers/scst/iscsi-scst/nthread.c linux-3.2/drivers/scst/iscsi-scst/nthread.c +--- orig/linux-3.2/drivers/scst/iscsi-scst/nthread.c ++++ linux-3.2/drivers/scst/iscsi-scst/nthread.c +@@ -0,0 +1,1891 @@ ++/* ++ * Network threads. ++ * ++ * Copyright (C) 2004 - 2005 FUJITA Tomonori <tomof@acm.org> ++ * Copyright (C) 2007 - 2011 Vladislav Bolkhovitin ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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. ++ * ++ * 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. ++ */ ++ ++#include <linux/sched.h> ++#include <linux/file.h> ++#include <linux/kthread.h> ++#include <linux/delay.h> ++#include <net/tcp.h> ++ ++#include "iscsi.h" ++#include "digest.h" ++ ++/* Read data states */ ++enum rx_state { ++ RX_INIT_BHS, /* Must be zero for better "switch" optimization. */ ++ RX_BHS, ++ RX_CMD_START, ++ RX_DATA, ++ RX_END, ++ ++ RX_CMD_CONTINUE, ++ RX_INIT_HDIGEST, ++ RX_CHECK_HDIGEST, ++ RX_INIT_DDIGEST, ++ RX_CHECK_DDIGEST, ++ RX_AHS, ++ RX_PADDING, ++}; ++ ++enum tx_state { ++ TX_INIT = 0, /* Must be zero for better "switch" optimization. */ ++ TX_BHS_DATA, ++ TX_INIT_PADDING, ++ TX_PADDING, ++ TX_INIT_DDIGEST, ++ TX_DDIGEST, ++ TX_END, ++}; ++ ++#if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++static void iscsi_check_closewait(struct iscsi_conn *conn) ++{ ++ struct iscsi_cmnd *cmnd; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_CONN_CLOSE_DBG("conn %p, sk_state %d", conn, ++ conn->sock->sk->sk_state); ++ ++ if (conn->sock->sk->sk_state != TCP_CLOSE) { ++ TRACE_CONN_CLOSE_DBG("conn %p, skipping", conn); ++ goto out; ++ } ++ ++ /* ++ * No data are going to be sent, so all queued buffers can be freed ++ * now. In many cases TCP does that only in close(), but we can't rely ++ * on user space on calling it. ++ */ ++ ++again: ++ spin_lock_bh(&conn->cmd_list_lock); ++ list_for_each_entry(cmnd, &conn->cmd_list, cmd_list_entry) { ++ struct iscsi_cmnd *rsp; ++ int restart = 0; ++ ++ TRACE_CONN_CLOSE_DBG("cmd %p, scst_state %x, " ++ "r2t_len_to_receive %d, ref_cnt %d, parent_req %p, " ++ "net_ref_cnt %d, sg %p", cmnd, cmnd->scst_state, ++ cmnd->r2t_len_to_receive, atomic_read(&cmnd->ref_cnt), ++ cmnd->parent_req, atomic_read(&cmnd->net_ref_cnt), ++ cmnd->sg); ++ ++ BUG_ON(cmnd->parent_req != NULL); ++ ++ if (cmnd->sg != NULL) { ++ int i; ++ ++ if (cmnd_get_check(cmnd)) ++ continue; ++ ++ for (i = 0; i < cmnd->sg_cnt; i++) { ++ struct page *page = sg_page(&cmnd->sg[i]); ++ TRACE_CONN_CLOSE_DBG("page %p, net_priv %p, " ++ "_count %d", page, page->net_priv, ++ atomic_read(&page->_count)); ++ ++ if (page->net_priv != NULL) { ++ if (restart == 0) { ++ spin_unlock_bh(&conn->cmd_list_lock); ++ restart = 1; ++ } ++ while (page->net_priv != NULL) ++ iscsi_put_page_callback(page); ++ } ++ } ++ cmnd_put(cmnd); ++ ++ if (restart) ++ goto again; ++ } ++ ++ list_for_each_entry(rsp, &cmnd->rsp_cmd_list, ++ rsp_cmd_list_entry) { ++ TRACE_CONN_CLOSE_DBG(" rsp %p, ref_cnt %d, " ++ "net_ref_cnt %d, sg %p", ++ rsp, atomic_read(&rsp->ref_cnt), ++ atomic_read(&rsp->net_ref_cnt), rsp->sg); ++ ++ if ((rsp->sg != cmnd->sg) && (rsp->sg != NULL)) { ++ int i; ++ ++ if (cmnd_get_check(rsp)) ++ continue; ++ ++ for (i = 0; i < rsp->sg_cnt; i++) { ++ struct page *page = ++ sg_page(&rsp->sg[i]); ++ TRACE_CONN_CLOSE_DBG( ++ " page %p, net_priv %p, " ++ "_count %d", ++ page, page->net_priv, ++ atomic_read(&page->_count)); ++ ++ if (page->net_priv != NULL) { ++ if (restart == 0) { ++ spin_unlock_bh(&conn->cmd_list_lock); ++ restart = 1; ++ } ++ while (page->net_priv != NULL) ++ iscsi_put_page_callback(page); ++ } ++ } ++ cmnd_put(rsp); ++ ++ if (restart) ++ goto again; ++ } ++ } ++ } ++ spin_unlock_bh(&conn->cmd_list_lock); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++#else ++static inline void iscsi_check_closewait(struct iscsi_conn *conn) {}; ++#endif ++ ++static void free_pending_commands(struct iscsi_conn *conn) ++{ ++ struct iscsi_session *session = conn->session; ++ struct list_head *pending_list = &session->pending_list; ++ int req_freed; ++ struct iscsi_cmnd *cmnd; ++ ++ spin_lock(&session->sn_lock); ++ do { ++ req_freed = 0; ++ list_for_each_entry(cmnd, pending_list, pending_list_entry) { ++ TRACE_CONN_CLOSE_DBG("Pending cmd %p" ++ "(conn %p, cmd_sn %u, exp_cmd_sn %u)", ++ cmnd, conn, cmnd->pdu.bhs.sn, ++ session->exp_cmd_sn); ++ if ((cmnd->conn == conn) && ++ (session->exp_cmd_sn == cmnd->pdu.bhs.sn)) { ++ TRACE_MGMT_DBG("Freeing pending cmd %p " ++ "(cmd_sn %u, exp_cmd_sn %u)", ++ cmnd, cmnd->pdu.bhs.sn, ++ session->exp_cmd_sn); ++ ++ list_del(&cmnd->pending_list_entry); ++ cmnd->pending = 0; ++ ++ session->exp_cmd_sn++; ++ ++ spin_unlock(&session->sn_lock); ++ ++ req_cmnd_release_force(cmnd); ++ ++ req_freed = 1; ++ spin_lock(&session->sn_lock); ++ break; ++ } ++ } ++ } while (req_freed); ++ spin_unlock(&session->sn_lock); ++ ++ return; ++} ++ ++static void free_orphaned_pending_commands(struct iscsi_conn *conn) ++{ ++ struct iscsi_session *session = conn->session; ++ struct list_head *pending_list = &session->pending_list; ++ int req_freed; ++ struct iscsi_cmnd *cmnd; ++ ++ spin_lock(&session->sn_lock); ++ do { ++ req_freed = 0; ++ list_for_each_entry(cmnd, pending_list, pending_list_entry) { ++ TRACE_CONN_CLOSE_DBG("Pending cmd %p" ++ "(conn %p, cmd_sn %u, exp_cmd_sn %u)", ++ cmnd, conn, cmnd->pdu.bhs.sn, ++ session->exp_cmd_sn); ++ if (cmnd->conn == conn) { ++ TRACE_MGMT_DBG("Freeing orphaned pending " ++ "cmnd %p (cmd_sn %u, exp_cmd_sn %u)", ++ cmnd, cmnd->pdu.bhs.sn, ++ session->exp_cmd_sn); ++ ++ list_del(&cmnd->pending_list_entry); ++ cmnd->pending = 0; ++ ++ if (session->exp_cmd_sn == cmnd->pdu.bhs.sn) ++ session->exp_cmd_sn++; ++ ++ spin_unlock(&session->sn_lock); ++ ++ req_cmnd_release_force(cmnd); ++ ++ req_freed = 1; ++ spin_lock(&session->sn_lock); ++ break; ++ } ++ } ++ } while (req_freed); ++ spin_unlock(&session->sn_lock); ++ ++ return; ++} ++ ++#ifdef CONFIG_SCST_DEBUG ++static void trace_conn_close(struct iscsi_conn *conn) ++{ ++ struct iscsi_cmnd *cmnd; ++#if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++ struct iscsi_cmnd *rsp; ++#endif ++ ++#if 0 ++ if (time_after(jiffies, start_waiting + 10*HZ)) ++ trace_flag |= TRACE_CONN_OC_DBG; ++#endif ++ ++ spin_lock_bh(&conn->cmd_list_lock); ++ list_for_each_entry(cmnd, &conn->cmd_list, ++ cmd_list_entry) { ++ TRACE_CONN_CLOSE_DBG( ++ "cmd %p, scst_cmd %p, scst_state %x, scst_cmd state " ++ "%d, r2t_len_to_receive %d, ref_cnt %d, sn %u, " ++ "parent_req %p, pending %d", ++ cmnd, cmnd->scst_cmd, cmnd->scst_state, ++ ((cmnd->parent_req == NULL) && cmnd->scst_cmd) ? ++ cmnd->scst_cmd->state : -1, ++ cmnd->r2t_len_to_receive, atomic_read(&cmnd->ref_cnt), ++ cmnd->pdu.bhs.sn, cmnd->parent_req, cmnd->pending); ++#if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++ TRACE_CONN_CLOSE_DBG("net_ref_cnt %d, sg %p", ++ atomic_read(&cmnd->net_ref_cnt), ++ cmnd->sg); ++ if (cmnd->sg != NULL) { ++ int i; ++ for (i = 0; i < cmnd->sg_cnt; i++) { ++ struct page *page = sg_page(&cmnd->sg[i]); ++ TRACE_CONN_CLOSE_DBG("page %p, " ++ "net_priv %p, _count %d", ++ page, page->net_priv, ++ atomic_read(&page->_count)); ++ } ++ } ++ ++ BUG_ON(cmnd->parent_req != NULL); ++ ++ list_for_each_entry(rsp, &cmnd->rsp_cmd_list, ++ rsp_cmd_list_entry) { ++ TRACE_CONN_CLOSE_DBG(" rsp %p, " ++ "ref_cnt %d, net_ref_cnt %d, sg %p", ++ rsp, atomic_read(&rsp->ref_cnt), ++ atomic_read(&rsp->net_ref_cnt), rsp->sg); ++ if (rsp->sg != cmnd->sg && rsp->sg) { ++ int i; ++ for (i = 0; i < rsp->sg_cnt; i++) { ++ TRACE_CONN_CLOSE_DBG(" page %p, " ++ "net_priv %p, _count %d", ++ sg_page(&rsp->sg[i]), ++ sg_page(&rsp->sg[i])->net_priv, ++ atomic_read(&sg_page(&rsp->sg[i])-> ++ _count)); ++ } ++ } ++ } ++#endif /* CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION */ ++ } ++ spin_unlock_bh(&conn->cmd_list_lock); ++ return; ++} ++#else /* CONFIG_SCST_DEBUG */ ++static void trace_conn_close(struct iscsi_conn *conn) {} ++#endif /* CONFIG_SCST_DEBUG */ ++ ++void iscsi_task_mgmt_affected_cmds_done(struct scst_mgmt_cmd *scst_mcmd) ++{ ++ int fn = scst_mgmt_cmd_get_fn(scst_mcmd); ++ void *priv = scst_mgmt_cmd_get_tgt_priv(scst_mcmd); ++ ++ TRACE_MGMT_DBG("scst_mcmd %p, fn %d, priv %p", scst_mcmd, fn, priv); ++ ++ switch (fn) { ++ case SCST_NEXUS_LOSS_SESS: ++ case SCST_ABORT_ALL_TASKS_SESS: ++ { ++ struct iscsi_conn *conn = (struct iscsi_conn *)priv; ++ struct iscsi_session *sess = conn->session; ++ struct iscsi_conn *c; ++ ++ if (sess->sess_reinst_successor != NULL) ++ scst_reassign_persistent_sess_states( ++ sess->sess_reinst_successor->scst_sess, ++ sess->scst_sess); ++ ++ mutex_lock(&sess->target->target_mutex); ++ ++ /* ++ * We can't mark sess as shutting down earlier, because until ++ * now it might have pending commands. Otherwise, in case of ++ * reinstatement, it might lead to data corruption, because ++ * commands in being reinstated session can be executed ++ * after commands in the new session. ++ */ ++ sess->sess_shutting_down = 1; ++ list_for_each_entry(c, &sess->conn_list, conn_list_entry) { ++ if (!test_bit(ISCSI_CONN_SHUTTINGDOWN, &c->conn_aflags)) { ++ sess->sess_shutting_down = 0; ++ break; ++ } ++ } ++ ++ if (conn->conn_reinst_successor != NULL) { ++ BUG_ON(!test_bit(ISCSI_CONN_REINSTATING, ++ &conn->conn_reinst_successor->conn_aflags)); ++ conn_reinst_finished(conn->conn_reinst_successor); ++ conn->conn_reinst_successor = NULL; ++ } else if (sess->sess_reinst_successor != NULL) { ++ sess_reinst_finished(sess->sess_reinst_successor); ++ sess->sess_reinst_successor = NULL; ++ } ++ mutex_unlock(&sess->target->target_mutex); ++ ++ complete_all(&conn->ready_to_free); ++ break; ++ } ++ default: ++ /* Nothing to do */ ++ break; ++ } ++ ++ return; ++} ++ ++/* No locks */ ++static void close_conn(struct iscsi_conn *conn) ++{ ++ struct iscsi_session *session = conn->session; ++ struct iscsi_target *target = conn->target; ++ typeof(jiffies) start_waiting = jiffies; ++ typeof(jiffies) shut_start_waiting = start_waiting; ++ bool pending_reported = 0, wait_expired = 0, shut_expired = 0; ++ bool reinst; ++ uint32_t tid, cid; ++ uint64_t sid; ++ ++#define CONN_PENDING_TIMEOUT ((typeof(jiffies))10*HZ) ++#define CONN_WAIT_TIMEOUT ((typeof(jiffies))10*HZ) ++#define CONN_REG_SHUT_TIMEOUT ((typeof(jiffies))125*HZ) ++#define CONN_DEL_SHUT_TIMEOUT ((typeof(jiffies))10*HZ) ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Closing connection %p (conn_ref_cnt=%d)", conn, ++ atomic_read(&conn->conn_ref_cnt)); ++ ++ iscsi_extracheck_is_rd_thread(conn); ++ ++ BUG_ON(!conn->closing); ++ ++ if (conn->active_close) { ++ /* We want all our already send operations to complete */ ++ conn->sock->ops->shutdown(conn->sock, RCV_SHUTDOWN); ++ } else { ++ conn->sock->ops->shutdown(conn->sock, ++ RCV_SHUTDOWN|SEND_SHUTDOWN); ++ } ++ ++ mutex_lock(&session->target->target_mutex); ++ ++ set_bit(ISCSI_CONN_SHUTTINGDOWN, &conn->conn_aflags); ++ reinst = (conn->conn_reinst_successor != NULL); ++ ++ mutex_unlock(&session->target->target_mutex); ++ ++ if (reinst) { ++ int rc; ++ int lun = 0; ++ ++ /* Abort all outstanding commands */ ++ rc = scst_rx_mgmt_fn_lun(session->scst_sess, ++ SCST_ABORT_ALL_TASKS_SESS, (uint8_t *)&lun, sizeof(lun), ++ SCST_NON_ATOMIC, conn); ++ if (rc != 0) ++ PRINT_ERROR("SCST_ABORT_ALL_TASKS_SESS failed %d", rc); ++ } else { ++ int rc; ++ int lun = 0; ++ ++ rc = scst_rx_mgmt_fn_lun(session->scst_sess, ++ SCST_NEXUS_LOSS_SESS, (uint8_t *)&lun, sizeof(lun), ++ SCST_NON_ATOMIC, conn); ++ if (rc != 0) ++ PRINT_ERROR("SCST_NEXUS_LOSS_SESS failed %d", rc); ++ } ++ ++ if (conn->read_state != RX_INIT_BHS) { ++ struct iscsi_cmnd *cmnd = conn->read_cmnd; ++ ++ if (cmnd->scst_state == ISCSI_CMD_STATE_RX_CMD) { ++ TRACE_CONN_CLOSE_DBG("Going to wait for cmnd %p to " ++ "change state from RX_CMD", cmnd); ++ } ++ wait_event(conn->read_state_waitQ, ++ cmnd->scst_state != ISCSI_CMD_STATE_RX_CMD); ++ ++ TRACE_CONN_CLOSE_DBG("Releasing conn->read_cmnd %p (conn %p)", ++ conn->read_cmnd, conn); ++ ++ conn->read_cmnd = NULL; ++ conn->read_state = RX_INIT_BHS; ++ req_cmnd_release_force(cmnd); ++ } ++ ++ conn_abort(conn); ++ ++ /* ToDo: not the best way to wait */ ++ while (atomic_read(&conn->conn_ref_cnt) != 0) { ++ if (conn->conn_tm_active) ++ iscsi_check_tm_data_wait_timeouts(conn, true); ++ ++ mutex_lock(&target->target_mutex); ++ spin_lock(&session->sn_lock); ++ if (session->tm_rsp && session->tm_rsp->conn == conn) { ++ struct iscsi_cmnd *tm_rsp = session->tm_rsp; ++ TRACE_MGMT_DBG("Dropping delayed TM rsp %p", tm_rsp); ++ session->tm_rsp = NULL; ++ session->tm_active--; ++ WARN_ON(session->tm_active < 0); ++ spin_unlock(&session->sn_lock); ++ mutex_unlock(&target->target_mutex); ++ ++ rsp_cmnd_release(tm_rsp); ++ } else { ++ spin_unlock(&session->sn_lock); ++ mutex_unlock(&target->target_mutex); ++ } ++ ++ /* It's safe to check it without sn_lock */ ++ if (!list_empty(&session->pending_list)) { ++ TRACE_CONN_CLOSE_DBG("Disposing pending commands on " ++ "connection %p (conn_ref_cnt=%d)", conn, ++ atomic_read(&conn->conn_ref_cnt)); ++ ++ free_pending_commands(conn); ++ ++ if (time_after(jiffies, ++ start_waiting + CONN_PENDING_TIMEOUT)) { ++ if (!pending_reported) { ++ TRACE_CONN_CLOSE("%s", ++ "Pending wait time expired"); ++ pending_reported = 1; ++ } ++ free_orphaned_pending_commands(conn); ++ } ++ } ++ ++ iscsi_make_conn_wr_active(conn); ++ ++ /* That's for active close only, actually */ ++ if (time_after(jiffies, start_waiting + CONN_WAIT_TIMEOUT) && ++ !wait_expired) { ++ TRACE_CONN_CLOSE("Wait time expired (conn %p, " ++ "sk_state %d)", ++ conn, conn->sock->sk->sk_state); ++ conn->sock->ops->shutdown(conn->sock, SEND_SHUTDOWN); ++ wait_expired = 1; ++ shut_start_waiting = jiffies; ++ } ++ ++ if (wait_expired && !shut_expired && ++ time_after(jiffies, shut_start_waiting + ++ conn->deleting ? CONN_DEL_SHUT_TIMEOUT : ++ CONN_REG_SHUT_TIMEOUT)) { ++ TRACE_CONN_CLOSE("Wait time after shutdown expired " ++ "(conn %p, sk_state %d)", conn, ++ conn->sock->sk->sk_state); ++ conn->sock->sk->sk_prot->disconnect(conn->sock->sk, 0); ++ shut_expired = 1; ++ } ++ ++ if (conn->deleting) ++ msleep(200); ++ else ++ msleep(1000); ++ ++ TRACE_CONN_CLOSE_DBG("conn %p, conn_ref_cnt %d left, " ++ "wr_state %d, exp_cmd_sn %u", ++ conn, atomic_read(&conn->conn_ref_cnt), ++ conn->wr_state, session->exp_cmd_sn); ++ ++ trace_conn_close(conn); ++ ++ /* It might never be called for being closed conn */ ++ __iscsi_write_space_ready(conn); ++ ++ iscsi_check_closewait(conn); ++ } ++ ++ write_lock_bh(&conn->sock->sk->sk_callback_lock); ++ conn->sock->sk->sk_state_change = conn->old_state_change; ++ conn->sock->sk->sk_data_ready = conn->old_data_ready; ++ conn->sock->sk->sk_write_space = conn->old_write_space; ++ write_unlock_bh(&conn->sock->sk->sk_callback_lock); ++ ++ while (1) { ++ bool t; ++ ++ spin_lock_bh(&conn->conn_thr_pool->wr_lock); ++ t = (conn->wr_state == ISCSI_CONN_WR_STATE_IDLE); ++ spin_unlock_bh(&conn->conn_thr_pool->wr_lock); ++ ++ if (t && (atomic_read(&conn->conn_ref_cnt) == 0)) ++ break; ++ ++ TRACE_CONN_CLOSE_DBG("Waiting for wr thread (conn %p), " ++ "wr_state %x", conn, conn->wr_state); ++ msleep(50); ++ } ++ ++ wait_for_completion(&conn->ready_to_free); ++ ++ tid = target->tid; ++ sid = session->sid; ++ cid = conn->cid; ++ ++ mutex_lock(&target->target_mutex); ++ conn_free(conn); ++ mutex_unlock(&target->target_mutex); ++ ++ /* ++ * We can't send E_CONN_CLOSE earlier, because otherwise we would have ++ * a race, when the user space tried to destroy session, which still ++ * has connections. ++ * ++ * !! All target, session and conn can be already dead here !! ++ */ ++ TRACE_CONN_CLOSE("Notifying user space about closing connection %p", ++ conn); ++ event_send(tid, sid, cid, 0, E_CONN_CLOSE, NULL, NULL); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int close_conn_thr(void *arg) ++{ ++ struct iscsi_conn *conn = (struct iscsi_conn *)arg; ++ ++ TRACE_ENTRY(); ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ /* ++ * To satisfy iscsi_extracheck_is_rd_thread() in functions called ++ * on the connection close. It is safe, because at this point conn ++ * can't be used by any other thread. ++ */ ++ conn->rd_task = current; ++#endif ++ close_conn(conn); ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++/* No locks */ ++static void start_close_conn(struct iscsi_conn *conn) ++{ ++ struct task_struct *t; ++ ++ TRACE_ENTRY(); ++ ++ t = kthread_run(close_conn_thr, conn, "iscsi_conn_cleanup"); ++ if (IS_ERR(t)) { ++ PRINT_ERROR("kthread_run() failed (%ld), closing conn %p " ++ "directly", PTR_ERR(t), conn); ++ close_conn(conn); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static inline void iscsi_conn_init_read(struct iscsi_conn *conn, ++ void __user *data, size_t len) ++{ ++ conn->read_iov[0].iov_base = data; ++ conn->read_iov[0].iov_len = len; ++ conn->read_msg.msg_iov = conn->read_iov; ++ conn->read_msg.msg_iovlen = 1; ++ conn->read_size = len; ++ return; ++} ++ ++static void iscsi_conn_prepare_read_ahs(struct iscsi_conn *conn, ++ struct iscsi_cmnd *cmnd) ++{ ++ int asize = (cmnd->pdu.ahssize + 3) & -4; ++ ++ /* ToDo: __GFP_NOFAIL ?? */ ++ cmnd->pdu.ahs = kmalloc(asize, __GFP_NOFAIL|GFP_KERNEL); ++ BUG_ON(cmnd->pdu.ahs == NULL); ++ iscsi_conn_init_read(conn, (void __force __user *)cmnd->pdu.ahs, asize); ++ return; ++} ++ ++static struct iscsi_cmnd *iscsi_get_send_cmnd(struct iscsi_conn *conn) ++{ ++ struct iscsi_cmnd *cmnd = NULL; ++ ++ spin_lock_bh(&conn->write_list_lock); ++ if (!list_empty(&conn->write_list)) { ++ cmnd = list_entry(conn->write_list.next, struct iscsi_cmnd, ++ write_list_entry); ++ cmd_del_from_write_list(cmnd); ++ cmnd->write_processing_started = 1; ++ } else { ++ spin_unlock_bh(&conn->write_list_lock); ++ goto out; ++ } ++ spin_unlock_bh(&conn->write_list_lock); ++ ++ if (unlikely(test_bit(ISCSI_CMD_ABORTED, ++ &cmnd->parent_req->prelim_compl_flags))) { ++ TRACE_MGMT_DBG("Going to send acmd %p (scst cmd %p, " ++ "state %d, parent_req %p)", cmnd, cmnd->scst_cmd, ++ cmnd->scst_state, cmnd->parent_req); ++ } ++ ++ if (unlikely(cmnd_opcode(cmnd) == ISCSI_OP_SCSI_TASK_MGT_RSP)) { ++#ifdef CONFIG_SCST_DEBUG ++ struct iscsi_task_mgt_hdr *req_hdr = ++ (struct iscsi_task_mgt_hdr *)&cmnd->parent_req->pdu.bhs; ++ struct iscsi_task_rsp_hdr *rsp_hdr = ++ (struct iscsi_task_rsp_hdr *)&cmnd->pdu.bhs; ++ TRACE_MGMT_DBG("Going to send TM response %p (status %d, " ++ "fn %d, parent_req %p)", cmnd, rsp_hdr->response, ++ req_hdr->function & ISCSI_FUNCTION_MASK, ++ cmnd->parent_req); ++#endif ++ } ++ ++out: ++ return cmnd; ++} ++ ++/* Returns number of bytes left to receive or <0 for error */ ++static int do_recv(struct iscsi_conn *conn) ++{ ++ int res; ++ mm_segment_t oldfs; ++ struct msghdr msg; ++ int first_len; ++ ++ EXTRACHECKS_BUG_ON(conn->read_cmnd == NULL); ++ ++ if (unlikely(conn->closing)) { ++ res = -EIO; ++ goto out; ++ } ++ ++ /* ++ * We suppose that if sock_recvmsg() returned less data than requested, ++ * then next time it will return -EAGAIN, so there's no point to call ++ * it again. ++ */ ++ ++restart: ++ memset(&msg, 0, sizeof(msg)); ++ msg.msg_iov = conn->read_msg.msg_iov; ++ msg.msg_iovlen = conn->read_msg.msg_iovlen; ++ first_len = msg.msg_iov->iov_len; ++ ++ oldfs = get_fs(); ++ set_fs(get_ds()); ++ res = sock_recvmsg(conn->sock, &msg, conn->read_size, ++ MSG_DONTWAIT | MSG_NOSIGNAL); ++ set_fs(oldfs); ++ ++ TRACE_DBG("msg_iovlen %zd, first_len %d, read_size %d, res %d", ++ msg.msg_iovlen, first_len, conn->read_size, res); ++ ++ if (res > 0) { ++ /* ++ * To save some considerable effort and CPU power we ++ * suppose that TCP functions adjust ++ * conn->read_msg.msg_iov and conn->read_msg.msg_iovlen ++ * on amount of copied data. This BUG_ON is intended ++ * to catch if it is changed in the future. ++ */ ++ BUG_ON((res >= first_len) && ++ (conn->read_msg.msg_iov->iov_len != 0)); ++ conn->read_size -= res; ++ if (conn->read_size != 0) { ++ if (res >= first_len) { ++ int done = 1 + ((res - first_len) >> PAGE_SHIFT); ++ TRACE_DBG("done %d", done); ++ conn->read_msg.msg_iov += done; ++ conn->read_msg.msg_iovlen -= done; ++ } ++ } ++ res = conn->read_size; ++ } else { ++ switch (res) { ++ case -EAGAIN: ++ TRACE_DBG("EAGAIN received for conn %p", conn); ++ res = conn->read_size; ++ break; ++ case -ERESTARTSYS: ++ TRACE_DBG("ERESTARTSYS received for conn %p", conn); ++ goto restart; ++ default: ++ if (!conn->closing) { ++ PRINT_ERROR("sock_recvmsg() failed: %d", res); ++ mark_conn_closed(conn); ++ } ++ if (res == 0) ++ res = -EIO; ++ break; ++ } ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int iscsi_rx_check_ddigest(struct iscsi_conn *conn) ++{ ++ struct iscsi_cmnd *cmnd = conn->read_cmnd; ++ int res; ++ ++ res = do_recv(conn); ++ if (res == 0) { ++ conn->read_state = RX_END; ++ ++ if (cmnd->pdu.datasize <= 16*1024) { ++ /* ++ * It's cache hot, so let's compute it inline. The ++ * choice here about what will expose more latency: ++ * possible cache misses or the digest calculation. ++ */ ++ TRACE_DBG("cmnd %p, opcode %x: checking RX " ++ "ddigest inline", cmnd, cmnd_opcode(cmnd)); ++ cmnd->ddigest_checked = 1; ++ res = digest_rx_data(cmnd); ++ if (unlikely(res != 0)) { ++ struct iscsi_cmnd *orig_req; ++ if (cmnd_opcode(cmnd) == ISCSI_OP_SCSI_DATA_OUT) ++ orig_req = cmnd->cmd_req; ++ else ++ orig_req = cmnd; ++ if (unlikely(orig_req->scst_cmd == NULL)) { ++ /* Just drop it */ ++ iscsi_preliminary_complete(cmnd, orig_req, false); ++ } else { ++ set_scst_preliminary_status_rsp(orig_req, false, ++ SCST_LOAD_SENSE(iscsi_sense_crc_error)); ++ /* ++ * Let's prelim complete cmnd too to ++ * handle the DATA OUT case ++ */ ++ iscsi_preliminary_complete(cmnd, orig_req, false); ++ } ++ res = 0; ++ } ++ } else if (cmnd_opcode(cmnd) == ISCSI_OP_SCSI_CMD) { ++ cmd_add_on_rx_ddigest_list(cmnd, cmnd); ++ cmnd_get(cmnd); ++ } else if (cmnd_opcode(cmnd) != ISCSI_OP_SCSI_DATA_OUT) { ++ /* ++ * We could get here only for Nop-Out. ISCSI RFC ++ * doesn't specify how to deal with digest errors in ++ * this case. Let's just drop the command. ++ */ ++ TRACE_DBG("cmnd %p, opcode %x: checking NOP RX " ++ "ddigest", cmnd, cmnd_opcode(cmnd)); ++ res = digest_rx_data(cmnd); ++ if (unlikely(res != 0)) { ++ iscsi_preliminary_complete(cmnd, cmnd, false); ++ res = 0; ++ } ++ } ++ } ++ ++ return res; ++} ++ ++/* No locks, conn is rd processing */ ++static int process_read_io(struct iscsi_conn *conn, int *closed) ++{ ++ struct iscsi_cmnd *cmnd = conn->read_cmnd; ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ /* In case of error cmnd will be freed in close_conn() */ ++ ++ do { ++ switch (conn->read_state) { ++ case RX_INIT_BHS: ++ EXTRACHECKS_BUG_ON(conn->read_cmnd != NULL); ++ cmnd = cmnd_alloc(conn, NULL); ++ conn->read_cmnd = cmnd; ++ iscsi_conn_init_read(cmnd->conn, ++ (void __force __user *)&cmnd->pdu.bhs, ++ sizeof(cmnd->pdu.bhs)); ++ conn->read_state = RX_BHS; ++ /* go through */ ++ ++ case RX_BHS: ++ res = do_recv(conn); ++ if (res == 0) { ++ /* ++ * This command not yet received on the aborted ++ * time, so shouldn't be affected by any abort. ++ */ ++ EXTRACHECKS_BUG_ON(cmnd->prelim_compl_flags != 0); ++ ++ iscsi_cmnd_get_length(&cmnd->pdu); ++ ++ if (cmnd->pdu.ahssize == 0) { ++ if ((conn->hdigest_type & DIGEST_NONE) == 0) ++ conn->read_state = RX_INIT_HDIGEST; ++ else ++ conn->read_state = RX_CMD_START; ++ } else { ++ iscsi_conn_prepare_read_ahs(conn, cmnd); ++ conn->read_state = RX_AHS; ++ } ++ } ++ break; ++ ++ case RX_CMD_START: ++ res = cmnd_rx_start(cmnd); ++ if (res == 0) { ++ if (cmnd->pdu.datasize == 0) ++ conn->read_state = RX_END; ++ else ++ conn->read_state = RX_DATA; ++ } else if (res > 0) ++ conn->read_state = RX_CMD_CONTINUE; ++ else ++ BUG_ON(!conn->closing); ++ break; ++ ++ case RX_CMD_CONTINUE: ++ if (cmnd->scst_state == ISCSI_CMD_STATE_RX_CMD) { ++ TRACE_DBG("cmnd %p is still in RX_CMD state", ++ cmnd); ++ res = 1; ++ break; ++ } ++ res = cmnd_rx_continue(cmnd); ++ if (unlikely(res != 0)) ++ BUG_ON(!conn->closing); ++ else { ++ if (cmnd->pdu.datasize == 0) ++ conn->read_state = RX_END; ++ else ++ conn->read_state = RX_DATA; ++ } ++ break; ++ ++ case RX_DATA: ++ res = do_recv(conn); ++ if (res == 0) { ++ int psz = ((cmnd->pdu.datasize + 3) & -4) - cmnd->pdu.datasize; ++ if (psz != 0) { ++ TRACE_DBG("padding %d bytes", psz); ++ iscsi_conn_init_read(conn, ++ (void __force __user *)&conn->rpadding, psz); ++ conn->read_state = RX_PADDING; ++ } else if ((conn->ddigest_type & DIGEST_NONE) != 0) ++ conn->read_state = RX_END; ++ else ++ conn->read_state = RX_INIT_DDIGEST; ++ } ++ break; ++ ++ case RX_END: ++ if (unlikely(conn->read_size != 0)) { ++ PRINT_CRIT_ERROR("conn read_size !=0 on RX_END " ++ "(conn %p, op %x, read_size %d)", conn, ++ cmnd_opcode(cmnd), conn->read_size); ++ BUG(); ++ } ++ conn->read_cmnd = NULL; ++ conn->read_state = RX_INIT_BHS; ++ ++ cmnd_rx_end(cmnd); ++ ++ EXTRACHECKS_BUG_ON(conn->read_size != 0); ++ ++ /* ++ * To maintain fairness. Res must be 0 here anyway, the ++ * assignment is only to remove compiler warning about ++ * uninitialized variable. ++ */ ++ res = 0; ++ goto out; ++ ++ case RX_INIT_HDIGEST: ++ iscsi_conn_init_read(conn, ++ (void __force __user *)&cmnd->hdigest, sizeof(u32)); ++ conn->read_state = RX_CHECK_HDIGEST; ++ /* go through */ ++ ++ case RX_CHECK_HDIGEST: ++ res = do_recv(conn); ++ if (res == 0) { ++ res = digest_rx_header(cmnd); ++ if (unlikely(res != 0)) { ++ PRINT_ERROR("rx header digest for " ++ "initiator %s failed (%d)", ++ conn->session->initiator_name, ++ res); ++ mark_conn_closed(conn); ++ } else ++ conn->read_state = RX_CMD_START; ++ } ++ break; ++ ++ case RX_INIT_DDIGEST: ++ iscsi_conn_init_read(conn, ++ (void __force __user *)&cmnd->ddigest, ++ sizeof(u32)); ++ conn->read_state = RX_CHECK_DDIGEST; ++ /* go through */ ++ ++ case RX_CHECK_DDIGEST: ++ res = iscsi_rx_check_ddigest(conn); ++ break; ++ ++ case RX_AHS: ++ res = do_recv(conn); ++ if (res == 0) { ++ if ((conn->hdigest_type & DIGEST_NONE) == 0) ++ conn->read_state = RX_INIT_HDIGEST; ++ else ++ conn->read_state = RX_CMD_START; ++ } ++ break; ++ ++ case RX_PADDING: ++ res = do_recv(conn); ++ if (res == 0) { ++ if ((conn->ddigest_type & DIGEST_NONE) == 0) ++ conn->read_state = RX_INIT_DDIGEST; ++ else ++ conn->read_state = RX_END; ++ } ++ break; ++ ++ default: ++ PRINT_CRIT_ERROR("%d %x", conn->read_state, cmnd_opcode(cmnd)); ++ res = -1; /* to keep compiler happy */ ++ BUG(); ++ } ++ } while (res == 0); ++ ++ if (unlikely(conn->closing)) { ++ start_close_conn(conn); ++ *closed = 1; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* ++ * Called under rd_lock and BHs disabled, but will drop it inside, ++ * then reacquire. ++ */ ++static void scst_do_job_rd(struct iscsi_thread_pool *p) ++ __acquires(&rd_lock) ++ __releases(&rd_lock) ++{ ++ TRACE_ENTRY(); ++ ++ /* ++ * We delete/add to tail connections to maintain fairness between them. ++ */ ++ ++ while (!list_empty(&p->rd_list)) { ++ int closed = 0, rc; ++ struct iscsi_conn *conn = list_entry(p->rd_list.next, ++ typeof(*conn), rd_list_entry); ++ ++ list_del(&conn->rd_list_entry); ++ ++ BUG_ON(conn->rd_state == ISCSI_CONN_RD_STATE_PROCESSING); ++ conn->rd_data_ready = 0; ++ conn->rd_state = ISCSI_CONN_RD_STATE_PROCESSING; ++#ifdef CONFIG_SCST_EXTRACHECKS ++ conn->rd_task = current; ++#endif ++ spin_unlock_bh(&p->rd_lock); ++ ++ rc = process_read_io(conn, &closed); ++ ++ spin_lock_bh(&p->rd_lock); ++ ++ if (unlikely(closed)) ++ continue; ++ ++ if (unlikely(conn->conn_tm_active)) { ++ spin_unlock_bh(&p->rd_lock); ++ iscsi_check_tm_data_wait_timeouts(conn, false); ++ spin_lock_bh(&p->rd_lock); ++ } ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ conn->rd_task = NULL; ++#endif ++ if ((rc == 0) || conn->rd_data_ready) { ++ list_add_tail(&conn->rd_list_entry, &p->rd_list); ++ conn->rd_state = ISCSI_CONN_RD_STATE_IN_LIST; ++ } else ++ conn->rd_state = ISCSI_CONN_RD_STATE_IDLE; ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static inline int test_rd_list(struct iscsi_thread_pool *p) ++{ ++ int res = !list_empty(&p->rd_list) || ++ unlikely(kthread_should_stop()); ++ return res; ++} ++ ++int istrd(void *arg) ++{ ++ struct iscsi_thread_pool *p = arg; ++ int rc; ++ ++ TRACE_ENTRY(); ++ ++ PRINT_INFO("Read thread for pool %p started, PID %d", p, current->pid); ++ ++ current->flags |= PF_NOFREEZE; ++ rc = set_cpus_allowed_ptr(current, &p->cpu_mask); ++ if (rc != 0) ++ PRINT_ERROR("Setting CPU affinity failed: %d", rc); ++ ++ spin_lock_bh(&p->rd_lock); ++ while (!kthread_should_stop()) { ++ wait_queue_t wait; ++ init_waitqueue_entry(&wait, current); ++ ++ if (!test_rd_list(p)) { ++ add_wait_queue_exclusive_head(&p->rd_waitQ, &wait); ++ for (;;) { ++ set_current_state(TASK_INTERRUPTIBLE); ++ if (test_rd_list(p)) ++ break; ++ spin_unlock_bh(&p->rd_lock); ++ schedule(); ++ spin_lock_bh(&p->rd_lock); ++ } ++ set_current_state(TASK_RUNNING); ++ remove_wait_queue(&p->rd_waitQ, &wait); ++ } ++ scst_do_job_rd(p); ++ } ++ spin_unlock_bh(&p->rd_lock); ++ ++ /* ++ * If kthread_should_stop() is true, we are guaranteed to be ++ * on the module unload, so rd_list must be empty. ++ */ ++ BUG_ON(!list_empty(&p->rd_list)); ++ ++ PRINT_INFO("Read thread for PID %d for pool %p finished", current->pid, p); ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++#if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++static inline void __iscsi_get_page_callback(struct iscsi_cmnd *cmd) ++{ ++ int v; ++ ++ TRACE_NET_PAGE("cmd %p, new net_ref_cnt %d", ++ cmd, atomic_read(&cmd->net_ref_cnt)+1); ++ ++ v = atomic_inc_return(&cmd->net_ref_cnt); ++ if (v == 1) { ++ TRACE_NET_PAGE("getting cmd %p", cmd); ++ cmnd_get(cmd); ++ } ++ return; ++} ++ ++void iscsi_get_page_callback(struct page *page) ++{ ++ struct iscsi_cmnd *cmd = (struct iscsi_cmnd *)page->net_priv; ++ ++ TRACE_NET_PAGE("page %p, _count %d", page, ++ atomic_read(&page->_count)); ++ ++ __iscsi_get_page_callback(cmd); ++ return; ++} ++ ++static inline void __iscsi_put_page_callback(struct iscsi_cmnd *cmd) ++{ ++ TRACE_NET_PAGE("cmd %p, new net_ref_cnt %d", cmd, ++ atomic_read(&cmd->net_ref_cnt)-1); ++ ++ if (atomic_dec_and_test(&cmd->net_ref_cnt)) { ++ int i, sg_cnt = cmd->sg_cnt; ++ for (i = 0; i < sg_cnt; i++) { ++ struct page *page = sg_page(&cmd->sg[i]); ++ TRACE_NET_PAGE("Clearing page %p", page); ++ if (page->net_priv == cmd) ++ page->net_priv = NULL; ++ } ++ cmnd_put(cmd); ++ } ++ return; ++} ++ ++void iscsi_put_page_callback(struct page *page) ++{ ++ struct iscsi_cmnd *cmd = (struct iscsi_cmnd *)page->net_priv; ++ ++ TRACE_NET_PAGE("page %p, _count %d", page, ++ atomic_read(&page->_count)); ++ ++ __iscsi_put_page_callback(cmd); ++ return; ++} ++ ++static void check_net_priv(struct iscsi_cmnd *cmd, struct page *page) ++{ ++ if ((atomic_read(&cmd->net_ref_cnt) == 1) && (page->net_priv == cmd)) { ++ TRACE_DBG("sendpage() not called get_page(), zeroing net_priv " ++ "%p (page %p)", page->net_priv, page); ++ page->net_priv = NULL; ++ } ++ return; ++} ++#else ++static inline void check_net_priv(struct iscsi_cmnd *cmd, struct page *page) {} ++static inline void __iscsi_get_page_callback(struct iscsi_cmnd *cmd) {} ++static inline void __iscsi_put_page_callback(struct iscsi_cmnd *cmd) {} ++#endif ++ ++void req_add_to_write_timeout_list(struct iscsi_cmnd *req) ++{ ++ struct iscsi_conn *conn; ++ bool set_conn_tm_active = false; ++ ++ TRACE_ENTRY(); ++ ++ if (req->on_write_timeout_list) ++ goto out; ++ ++ conn = req->conn; ++ ++ TRACE_DBG("Adding req %p to conn %p write_timeout_list", ++ req, conn); ++ ++ spin_lock_bh(&conn->write_list_lock); ++ ++ /* Recheck, since it can be changed behind us */ ++ if (unlikely(req->on_write_timeout_list)) { ++ spin_unlock_bh(&conn->write_list_lock); ++ goto out; ++ } ++ ++ req->on_write_timeout_list = 1; ++ req->write_start = jiffies; ++ ++ if (unlikely(cmnd_opcode(req) == ISCSI_OP_NOP_OUT)) { ++ unsigned long req_tt = iscsi_get_timeout_time(req); ++ struct iscsi_cmnd *r; ++ bool inserted = false; ++ list_for_each_entry(r, &conn->write_timeout_list, ++ write_timeout_list_entry) { ++ unsigned long tt = iscsi_get_timeout_time(r); ++ if (time_after(tt, req_tt)) { ++ TRACE_DBG("Add NOP IN req %p (tt %ld) before " ++ "req %p (tt %ld)", req, req_tt, r, tt); ++ list_add_tail(&req->write_timeout_list_entry, ++ &r->write_timeout_list_entry); ++ inserted = true; ++ break; ++ } else ++ TRACE_DBG("Skipping op %x req %p (tt %ld)", ++ cmnd_opcode(r), r, tt); ++ } ++ if (!inserted) { ++ TRACE_DBG("Add NOP IN req %p in the tail", req); ++ list_add_tail(&req->write_timeout_list_entry, ++ &conn->write_timeout_list); ++ } ++ ++ /* We suppose that nop_in_timeout must be <= data_rsp_timeout */ ++ req_tt += ISCSI_ADD_SCHED_TIME; ++ if (timer_pending(&conn->rsp_timer) && ++ time_after(conn->rsp_timer.expires, req_tt)) { ++ TRACE_DBG("Timer adjusted for sooner expired NOP IN " ++ "req %p", req); ++ mod_timer(&conn->rsp_timer, req_tt); ++ } ++ } else ++ list_add_tail(&req->write_timeout_list_entry, ++ &conn->write_timeout_list); ++ ++ if (!timer_pending(&conn->rsp_timer)) { ++ unsigned long timeout_time; ++ if (unlikely(conn->conn_tm_active || ++ test_bit(ISCSI_CMD_ABORTED, ++ &req->prelim_compl_flags))) { ++ set_conn_tm_active = true; ++ timeout_time = req->write_start + ++ ISCSI_TM_DATA_WAIT_TIMEOUT; ++ } else ++ timeout_time = iscsi_get_timeout_time(req); ++ ++ timeout_time += ISCSI_ADD_SCHED_TIME; ++ ++ TRACE_DBG("Starting timer on %ld (con %p, write_start %ld)", ++ timeout_time, conn, req->write_start); ++ ++ conn->rsp_timer.expires = timeout_time; ++ add_timer(&conn->rsp_timer); ++ } else if (unlikely(test_bit(ISCSI_CMD_ABORTED, ++ &req->prelim_compl_flags))) { ++ unsigned long timeout_time = jiffies + ++ ISCSI_TM_DATA_WAIT_TIMEOUT + ISCSI_ADD_SCHED_TIME; ++ set_conn_tm_active = true; ++ if (time_after(conn->rsp_timer.expires, timeout_time)) { ++ TRACE_MGMT_DBG("Mod timer on %ld (conn %p)", ++ timeout_time, conn); ++ mod_timer(&conn->rsp_timer, timeout_time); ++ } ++ } ++ ++ spin_unlock_bh(&conn->write_list_lock); ++ ++ /* ++ * conn_tm_active can be already cleared by ++ * iscsi_check_tm_data_wait_timeouts(). write_list_lock is an inner ++ * lock for rd_lock. ++ */ ++ if (unlikely(set_conn_tm_active)) { ++ spin_lock_bh(&conn->conn_thr_pool->rd_lock); ++ TRACE_MGMT_DBG("Setting conn_tm_active for conn %p", conn); ++ conn->conn_tm_active = 1; ++ spin_unlock_bh(&conn->conn_thr_pool->rd_lock); ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static int write_data(struct iscsi_conn *conn) ++{ ++ mm_segment_t oldfs; ++ struct file *file; ++ struct iovec *iop; ++ struct socket *sock; ++ ssize_t (*sock_sendpage)(struct socket *, struct page *, int, size_t, ++ int); ++ ssize_t (*sendpage)(struct socket *, struct page *, int, size_t, int); ++ struct iscsi_cmnd *write_cmnd = conn->write_cmnd; ++ struct iscsi_cmnd *ref_cmd; ++ struct page *page; ++ struct scatterlist *sg; ++ int saved_size, size, sendsize; ++ int length, offset, idx; ++ int flags, res, count, sg_size; ++ bool do_put = false, ref_cmd_to_parent; ++ ++ TRACE_ENTRY(); ++ ++ iscsi_extracheck_is_wr_thread(conn); ++ ++ if (!write_cmnd->own_sg) { ++ ref_cmd = write_cmnd->parent_req; ++ ref_cmd_to_parent = true; ++ } else { ++ ref_cmd = write_cmnd; ++ ref_cmd_to_parent = false; ++ } ++ ++ req_add_to_write_timeout_list(write_cmnd->parent_req); ++ ++ file = conn->file; ++ size = conn->write_size; ++ saved_size = size; ++ iop = conn->write_iop; ++ count = conn->write_iop_used; ++ ++ if (iop) { ++ while (1) { ++ loff_t off = 0; ++ int rest; ++ ++ BUG_ON(count > (signed)(sizeof(conn->write_iov) / ++ sizeof(conn->write_iov[0]))); ++retry: ++ oldfs = get_fs(); ++ set_fs(KERNEL_DS); ++ res = vfs_writev(file, ++ (struct iovec __force __user *)iop, ++ count, &off); ++ set_fs(oldfs); ++ TRACE_WRITE("sid %#Lx, cid %u, res %d, iov_len %ld", ++ (long long unsigned int)conn->session->sid, ++ conn->cid, res, (long)iop->iov_len); ++ if (unlikely(res <= 0)) { ++ if (res == -EAGAIN) { ++ conn->write_iop = iop; ++ conn->write_iop_used = count; ++ goto out_iov; ++ } else if (res == -EINTR) ++ goto retry; ++ goto out_err; ++ } ++ ++ rest = res; ++ size -= res; ++ while ((typeof(rest))iop->iov_len <= rest && rest) { ++ rest -= iop->iov_len; ++ iop++; ++ count--; ++ } ++ if (count == 0) { ++ conn->write_iop = NULL; ++ conn->write_iop_used = 0; ++ if (size) ++ break; ++ goto out_iov; ++ } ++ BUG_ON(iop > conn->write_iov + sizeof(conn->write_iov) ++ /sizeof(conn->write_iov[0])); ++ iop->iov_base += rest; ++ iop->iov_len -= rest; ++ } ++ } ++ ++ sg = write_cmnd->sg; ++ if (unlikely(sg == NULL)) { ++ PRINT_INFO("WARNING: Data missed (cmd %p)!", write_cmnd); ++ res = 0; ++ goto out; ++ } ++ ++ /* To protect from too early transfer completion race */ ++ __iscsi_get_page_callback(ref_cmd); ++ do_put = true; ++ ++ sock = conn->sock; ++ ++#if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++ sock_sendpage = sock->ops->sendpage; ++#else ++ if ((write_cmnd->parent_req->scst_cmd != NULL) && ++ scst_cmd_get_dh_data_buff_alloced(write_cmnd->parent_req->scst_cmd)) ++ sock_sendpage = sock_no_sendpage; ++ else ++ sock_sendpage = sock->ops->sendpage; ++#endif ++ ++ flags = MSG_DONTWAIT; ++ sg_size = size; ++ ++ if (sg != write_cmnd->rsp_sg) { ++ offset = conn->write_offset + sg[0].offset; ++ idx = offset >> PAGE_SHIFT; ++ offset &= ~PAGE_MASK; ++ length = min(size, (int)PAGE_SIZE - offset); ++ TRACE_WRITE("write_offset %d, sg_size %d, idx %d, offset %d, " ++ "length %d", conn->write_offset, sg_size, idx, offset, ++ length); ++ } else { ++ idx = 0; ++ offset = conn->write_offset; ++ while (offset >= sg[idx].length) { ++ offset -= sg[idx].length; ++ idx++; ++ } ++ length = sg[idx].length - offset; ++ offset += sg[idx].offset; ++ sock_sendpage = sock_no_sendpage; ++ TRACE_WRITE("rsp_sg: write_offset %d, sg_size %d, idx %d, " ++ "offset %d, length %d", conn->write_offset, sg_size, ++ idx, offset, length); ++ } ++ page = sg_page(&sg[idx]); ++ ++ while (1) { ++ sendpage = sock_sendpage; ++ ++#if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION) ++ { ++ static DEFINE_SPINLOCK(net_priv_lock); ++ spin_lock(&net_priv_lock); ++ if (unlikely(page->net_priv != NULL)) { ++ if (page->net_priv != ref_cmd) { ++ /* ++ * This might happen if user space ++ * supplies to scst_user the same ++ * pages in different commands or in ++ * case of zero-copy FILEIO, when ++ * several initiators request the same ++ * data simultaneously. ++ */ ++ TRACE_DBG("net_priv isn't NULL and != " ++ "ref_cmd (write_cmnd %p, ref_cmd " ++ "%p, sg %p, idx %d, page %p, " ++ "net_priv %p)", ++ write_cmnd, ref_cmd, sg, idx, ++ page, page->net_priv); ++ sendpage = sock_no_sendpage; ++ } ++ } else ++ page->net_priv = ref_cmd; ++ spin_unlock(&net_priv_lock); ++ } ++#endif ++ sendsize = min(size, length); ++ if (size <= sendsize) { ++retry2: ++ res = sendpage(sock, page, offset, size, flags); ++ TRACE_WRITE("Final %s sid %#Lx, cid %u, res %d (page " ++ "index %lu, offset %u, size %u, cmd %p, " ++ "page %p)", (sendpage != sock_no_sendpage) ? ++ "sendpage" : "sock_no_sendpage", ++ (long long unsigned int)conn->session->sid, ++ conn->cid, res, page->index, ++ offset, size, write_cmnd, page); ++ if (unlikely(res <= 0)) { ++ if (res == -EINTR) ++ goto retry2; ++ else ++ goto out_res; ++ } ++ ++ check_net_priv(ref_cmd, page); ++ if (res == size) { ++ conn->write_size = 0; ++ res = saved_size; ++ goto out_put; ++ } ++ ++ offset += res; ++ size -= res; ++ goto retry2; ++ } ++ ++retry1: ++ res = sendpage(sock, page, offset, sendsize, flags | MSG_MORE); ++ TRACE_WRITE("%s sid %#Lx, cid %u, res %d (page index %lu, " ++ "offset %u, sendsize %u, size %u, cmd %p, page %p)", ++ (sendpage != sock_no_sendpage) ? "sendpage" : ++ "sock_no_sendpage", ++ (unsigned long long)conn->session->sid, conn->cid, ++ res, page->index, offset, sendsize, size, ++ write_cmnd, page); ++ if (unlikely(res <= 0)) { ++ if (res == -EINTR) ++ goto retry1; ++ else ++ goto out_res; ++ } ++ ++ check_net_priv(ref_cmd, page); ++ ++ size -= res; ++ ++ if (res == sendsize) { ++ idx++; ++ EXTRACHECKS_BUG_ON(idx >= ref_cmd->sg_cnt); ++ page = sg_page(&sg[idx]); ++ length = sg[idx].length; ++ offset = sg[idx].offset; ++ } else { ++ offset += res; ++ sendsize -= res; ++ goto retry1; ++ } ++ } ++ ++out_off: ++ conn->write_offset += sg_size - size; ++ ++out_iov: ++ conn->write_size = size; ++ if ((saved_size == size) && res == -EAGAIN) ++ goto out_put; ++ ++ res = saved_size - size; ++ ++out_put: ++ if (do_put) ++ __iscsi_put_page_callback(ref_cmd); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_res: ++ check_net_priv(ref_cmd, page); ++ if (res == -EAGAIN) ++ goto out_off; ++ /* else go through */ ++ ++out_err: ++#ifndef CONFIG_SCST_DEBUG ++ if (!conn->closing) ++#endif ++ { ++ PRINT_ERROR("error %d at sid:cid %#Lx:%u, cmnd %p", res, ++ (long long unsigned int)conn->session->sid, ++ conn->cid, conn->write_cmnd); ++ } ++ if (ref_cmd_to_parent && ++ ((ref_cmd->scst_cmd != NULL) || (ref_cmd->scst_aen != NULL))) { ++ if (ref_cmd->scst_state == ISCSI_CMD_STATE_AEN) ++ scst_set_aen_delivery_status(ref_cmd->scst_aen, ++ SCST_AEN_RES_FAILED); ++ else ++ scst_set_delivery_status(ref_cmd->scst_cmd, ++ SCST_CMD_DELIVERY_FAILED); ++ } ++ goto out_put; ++} ++ ++static int exit_tx(struct iscsi_conn *conn, int res) ++{ ++ iscsi_extracheck_is_wr_thread(conn); ++ ++ switch (res) { ++ case -EAGAIN: ++ case -ERESTARTSYS: ++ break; ++ default: ++#ifndef CONFIG_SCST_DEBUG ++ if (!conn->closing) ++#endif ++ { ++ PRINT_ERROR("Sending data failed: initiator %s, " ++ "write_size %d, write_state %d, res %d", ++ conn->session->initiator_name, ++ conn->write_size, ++ conn->write_state, res); ++ } ++ conn->write_state = TX_END; ++ conn->write_size = 0; ++ mark_conn_closed(conn); ++ break; ++ } ++ return res; ++} ++ ++static int tx_ddigest(struct iscsi_cmnd *cmnd, int state) ++{ ++ int res, rest = cmnd->conn->write_size; ++ struct msghdr msg = {.msg_flags = MSG_NOSIGNAL | MSG_DONTWAIT}; ++ struct kvec iov; ++ ++ iscsi_extracheck_is_wr_thread(cmnd->conn); ++ ++ TRACE_DBG("Sending data digest %x (cmd %p)", cmnd->ddigest, cmnd); ++ ++ iov.iov_base = (char *)(&cmnd->ddigest) + (sizeof(u32) - rest); ++ iov.iov_len = rest; ++ ++ res = kernel_sendmsg(cmnd->conn->sock, &msg, &iov, 1, rest); ++ if (res > 0) { ++ cmnd->conn->write_size -= res; ++ if (!cmnd->conn->write_size) ++ cmnd->conn->write_state = state; ++ } else ++ res = exit_tx(cmnd->conn, res); ++ ++ return res; ++} ++ ++static void init_tx_hdigest(struct iscsi_cmnd *cmnd) ++{ ++ struct iscsi_conn *conn = cmnd->conn; ++ struct iovec *iop; ++ ++ iscsi_extracheck_is_wr_thread(conn); ++ ++ digest_tx_header(cmnd); ++ ++ BUG_ON(conn->write_iop_used >= ++ (signed)(sizeof(conn->write_iov)/sizeof(conn->write_iov[0]))); ++ ++ iop = &conn->write_iop[conn->write_iop_used]; ++ conn->write_iop_used++; ++ iop->iov_base = (void __force __user *)&(cmnd->hdigest); ++ iop->iov_len = sizeof(u32); ++ conn->write_size += sizeof(u32); ++ ++ return; ++} ++ ++static int tx_padding(struct iscsi_cmnd *cmnd, int state) ++{ ++ int res, rest = cmnd->conn->write_size; ++ struct msghdr msg = {.msg_flags = MSG_NOSIGNAL | MSG_DONTWAIT}; ++ struct kvec iov; ++ static const uint32_t padding; ++ ++ iscsi_extracheck_is_wr_thread(cmnd->conn); ++ ++ TRACE_DBG("Sending %d padding bytes (cmd %p)", rest, cmnd); ++ ++ iov.iov_base = (char *)(&padding) + (sizeof(uint32_t) - rest); ++ iov.iov_len = rest; ++ ++ res = kernel_sendmsg(cmnd->conn->sock, &msg, &iov, 1, rest); ++ if (res > 0) { ++ cmnd->conn->write_size -= res; ++ if (!cmnd->conn->write_size) ++ cmnd->conn->write_state = state; ++ } else ++ res = exit_tx(cmnd->conn, res); ++ ++ return res; ++} ++ ++static int iscsi_do_send(struct iscsi_conn *conn, int state) ++{ ++ int res; ++ ++ iscsi_extracheck_is_wr_thread(conn); ++ ++ res = write_data(conn); ++ if (res > 0) { ++ if (!conn->write_size) ++ conn->write_state = state; ++ } else ++ res = exit_tx(conn, res); ++ ++ return res; ++} ++ ++/* ++ * No locks, conn is wr processing. ++ * ++ * IMPORTANT! Connection conn must be protected by additional conn_get() ++ * upon entrance in this function, because otherwise it could be destroyed ++ * inside as a result of cmnd release. ++ */ ++int iscsi_send(struct iscsi_conn *conn) ++{ ++ struct iscsi_cmnd *cmnd = conn->write_cmnd; ++ int ddigest, res = 0; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("conn %p, write_cmnd %p", conn, cmnd); ++ ++ iscsi_extracheck_is_wr_thread(conn); ++ ++ ddigest = conn->ddigest_type != DIGEST_NONE ? 1 : 0; ++ ++ switch (conn->write_state) { ++ case TX_INIT: ++ BUG_ON(cmnd != NULL); ++ cmnd = conn->write_cmnd = iscsi_get_send_cmnd(conn); ++ if (!cmnd) ++ goto out; ++ cmnd_tx_start(cmnd); ++ if (!(conn->hdigest_type & DIGEST_NONE)) ++ init_tx_hdigest(cmnd); ++ conn->write_state = TX_BHS_DATA; ++ case TX_BHS_DATA: ++ res = iscsi_do_send(conn, cmnd->pdu.datasize ? ++ TX_INIT_PADDING : TX_END); ++ if (res <= 0 || conn->write_state != TX_INIT_PADDING) ++ break; ++ case TX_INIT_PADDING: ++ cmnd->conn->write_size = ((cmnd->pdu.datasize + 3) & -4) - ++ cmnd->pdu.datasize; ++ if (cmnd->conn->write_size != 0) ++ conn->write_state = TX_PADDING; ++ else if (ddigest) ++ conn->write_state = TX_INIT_DDIGEST; ++ else ++ conn->write_state = TX_END; ++ break; ++ case TX_PADDING: ++ res = tx_padding(cmnd, ddigest ? TX_INIT_DDIGEST : TX_END); ++ if (res <= 0 || conn->write_state != TX_INIT_DDIGEST) ++ break; ++ case TX_INIT_DDIGEST: ++ cmnd->conn->write_size = sizeof(u32); ++ conn->write_state = TX_DDIGEST; ++ case TX_DDIGEST: ++ res = tx_ddigest(cmnd, TX_END); ++ break; ++ default: ++ PRINT_CRIT_ERROR("%d %d %x", res, conn->write_state, ++ cmnd_opcode(cmnd)); ++ BUG(); ++ } ++ ++ if (res == 0) ++ goto out; ++ ++ if (conn->write_state != TX_END) ++ goto out; ++ ++ if (unlikely(conn->write_size)) { ++ PRINT_CRIT_ERROR("%d %x %u", res, cmnd_opcode(cmnd), ++ conn->write_size); ++ BUG(); ++ } ++ cmnd_tx_end(cmnd); ++ ++ rsp_cmnd_release(cmnd); ++ ++ conn->write_cmnd = NULL; ++ conn->write_state = TX_INIT; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* ++ * Called under wr_lock and BHs disabled, but will drop it inside, ++ * then reacquire. ++ */ ++static void scst_do_job_wr(struct iscsi_thread_pool *p) ++ __acquires(&wr_lock) ++ __releases(&wr_lock) ++{ ++ TRACE_ENTRY(); ++ ++ /* ++ * We delete/add to tail connections to maintain fairness between them. ++ */ ++ ++ while (!list_empty(&p->wr_list)) { ++ int rc; ++ struct iscsi_conn *conn = list_entry(p->wr_list.next, ++ typeof(*conn), wr_list_entry); ++ ++ TRACE_DBG("conn %p, wr_state %x, wr_space_ready %d, " ++ "write ready %d", conn, conn->wr_state, ++ conn->wr_space_ready, test_write_ready(conn)); ++ ++ list_del(&conn->wr_list_entry); ++ ++ BUG_ON(conn->wr_state == ISCSI_CONN_WR_STATE_PROCESSING); ++ ++ conn->wr_state = ISCSI_CONN_WR_STATE_PROCESSING; ++ conn->wr_space_ready = 0; ++#ifdef CONFIG_SCST_EXTRACHECKS ++ conn->wr_task = current; ++#endif ++ spin_unlock_bh(&p->wr_lock); ++ ++ conn_get(conn); ++ ++ rc = iscsi_send(conn); ++ ++ spin_lock_bh(&p->wr_lock); ++#ifdef CONFIG_SCST_EXTRACHECKS ++ conn->wr_task = NULL; ++#endif ++ if ((rc == -EAGAIN) && !conn->wr_space_ready) { ++ TRACE_DBG("EAGAIN, setting WR_STATE_SPACE_WAIT " ++ "(conn %p)", conn); ++ conn->wr_state = ISCSI_CONN_WR_STATE_SPACE_WAIT; ++ } else if (test_write_ready(conn)) { ++ list_add_tail(&conn->wr_list_entry, &p->wr_list); ++ conn->wr_state = ISCSI_CONN_WR_STATE_IN_LIST; ++ } else ++ conn->wr_state = ISCSI_CONN_WR_STATE_IDLE; ++ ++ conn_put(conn); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static inline int test_wr_list(struct iscsi_thread_pool *p) ++{ ++ int res = !list_empty(&p->wr_list) || ++ unlikely(kthread_should_stop()); ++ return res; ++} ++ ++int istwr(void *arg) ++{ ++ struct iscsi_thread_pool *p = arg; ++ int rc; ++ ++ TRACE_ENTRY(); ++ ++ PRINT_INFO("Write thread for pool %p started, PID %d", p, current->pid); ++ ++ current->flags |= PF_NOFREEZE; ++ rc = set_cpus_allowed_ptr(current, &p->cpu_mask); ++ if (rc != 0) ++ PRINT_ERROR("Setting CPU affinity failed: %d", rc); ++ ++ spin_lock_bh(&p->wr_lock); ++ while (!kthread_should_stop()) { ++ wait_queue_t wait; ++ init_waitqueue_entry(&wait, current); ++ ++ if (!test_wr_list(p)) { ++ add_wait_queue_exclusive_head(&p->wr_waitQ, &wait); ++ for (;;) { ++ set_current_state(TASK_INTERRUPTIBLE); ++ if (test_wr_list(p)) ++ break; ++ spin_unlock_bh(&p->wr_lock); ++ schedule(); ++ spin_lock_bh(&p->wr_lock); ++ } ++ set_current_state(TASK_RUNNING); ++ remove_wait_queue(&p->wr_waitQ, &wait); ++ } ++ scst_do_job_wr(p); ++ } ++ spin_unlock_bh(&p->wr_lock); ++ ++ /* ++ * If kthread_should_stop() is true, we are guaranteed to be ++ * on the module unload, so wr_list must be empty. ++ */ ++ BUG_ON(!list_empty(&p->wr_list)); ++ ++ PRINT_INFO("Write thread PID %d for pool %p finished", current->pid, p); ++ ++ TRACE_EXIT(); ++ return 0; ++} +diff -uprN orig/linux-3.2/drivers/scst/iscsi-scst/param.c linux-3.2/drivers/scst/iscsi-scst/param.c +--- orig/linux-3.2/drivers/scst/iscsi-scst/param.c ++++ linux-3.2/drivers/scst/iscsi-scst/param.c +@@ -0,0 +1,342 @@ ++/* ++ * Copyright (C) 2005 FUJITA Tomonori <tomof@acm.org> ++ * Copyright (C) 2007 - 2011 Vladislav Bolkhovitin ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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. ++ * ++ * 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. ++ */ ++ ++#include "iscsi.h" ++#include "digest.h" ++ ++#define CHECK_PARAM(info, iparams, word, min, max) \ ++do { \ ++ if (!(info)->partial || ((info)->partial & 1 << key_##word)) { \ ++ TRACE_DBG("%s: %u", #word, (iparams)[key_##word]); \ ++ if ((iparams)[key_##word] < (min) || \ ++ (iparams)[key_##word] > (max)) { \ ++ if ((iparams)[key_##word] < (min)) { \ ++ (iparams)[key_##word] = (min); \ ++ PRINT_WARNING("%s: %u is too small, resetting " \ ++ "it to allowed min %u", \ ++ #word, (iparams)[key_##word], (min)); \ ++ } else { \ ++ PRINT_WARNING("%s: %u is too big, resetting " \ ++ "it to allowed max %u", \ ++ #word, (iparams)[key_##word], (max)); \ ++ (iparams)[key_##word] = (max); \ ++ } \ ++ } \ ++ } \ ++} while (0) ++ ++#define SET_PARAM(params, info, iparams, word) \ ++({ \ ++ int changed = 0; \ ++ if (!(info)->partial || ((info)->partial & 1 << key_##word)) { \ ++ if ((params)->word != (iparams)[key_##word]) \ ++ changed = 1; \ ++ (params)->word = (iparams)[key_##word]; \ ++ TRACE_DBG("%s set to %u", #word, (params)->word); \ ++ } \ ++ changed; \ ++}) ++ ++#define GET_PARAM(params, info, iparams, word) \ ++do { \ ++ (iparams)[key_##word] = (params)->word; \ ++} while (0) ++ ++const char *iscsi_get_bool_value(int val) ++{ ++ if (val) ++ return "Yes"; ++ else ++ return "No"; ++} ++ ++const char *iscsi_get_digest_name(int val, char *res) ++{ ++ int pos = 0; ++ ++ if (val & DIGEST_NONE) ++ pos = sprintf(&res[pos], "%s", "None"); ++ ++ if (val & DIGEST_CRC32C) ++ pos += sprintf(&res[pos], "%s%s", (pos != 0) ? ", " : "", ++ "CRC32C"); ++ ++ if (pos == 0) ++ sprintf(&res[pos], "%s", "Unknown"); ++ ++ return res; ++} ++ ++static void log_params(struct iscsi_sess_params *params) ++{ ++ char digest_name[64]; ++ ++ PRINT_INFO("Negotiated parameters: InitialR2T %s, ImmediateData %s, " ++ "MaxConnections %d, MaxRecvDataSegmentLength %d, " ++ "MaxXmitDataSegmentLength %d, ", ++ iscsi_get_bool_value(params->initial_r2t), ++ iscsi_get_bool_value(params->immediate_data), params->max_connections, ++ params->max_recv_data_length, params->max_xmit_data_length); ++ PRINT_INFO(" MaxBurstLength %d, FirstBurstLength %d, " ++ "DefaultTime2Wait %d, DefaultTime2Retain %d, ", ++ params->max_burst_length, params->first_burst_length, ++ params->default_wait_time, params->default_retain_time); ++ PRINT_INFO(" MaxOutstandingR2T %d, DataPDUInOrder %s, " ++ "DataSequenceInOrder %s, ErrorRecoveryLevel %d, ", ++ params->max_outstanding_r2t, ++ iscsi_get_bool_value(params->data_pdu_inorder), ++ iscsi_get_bool_value(params->data_sequence_inorder), ++ params->error_recovery_level); ++ PRINT_INFO(" HeaderDigest %s, DataDigest %s, OFMarker %s, " ++ "IFMarker %s, OFMarkInt %d, IFMarkInt %d", ++ iscsi_get_digest_name(params->header_digest, digest_name), ++ iscsi_get_digest_name(params->data_digest, digest_name), ++ iscsi_get_bool_value(params->ofmarker), ++ iscsi_get_bool_value(params->ifmarker), ++ params->ofmarkint, params->ifmarkint); ++} ++ ++/* target_mutex supposed to be locked */ ++static void sess_params_check(struct iscsi_kern_params_info *info) ++{ ++ int32_t *iparams = info->session_params; ++ const int max_len = ISCSI_CONN_IOV_MAX * PAGE_SIZE; ++ ++ /* ++ * This is only kernel sanity check. Actual data validity checks ++ * performed in the user space. ++ */ ++ ++ CHECK_PARAM(info, iparams, initial_r2t, 0, 1); ++ CHECK_PARAM(info, iparams, immediate_data, 0, 1); ++ CHECK_PARAM(info, iparams, max_connections, 1, 1); ++ CHECK_PARAM(info, iparams, max_recv_data_length, 512, max_len); ++ CHECK_PARAM(info, iparams, max_xmit_data_length, 512, max_len); ++ CHECK_PARAM(info, iparams, max_burst_length, 512, max_len); ++ CHECK_PARAM(info, iparams, first_burst_length, 512, max_len); ++ CHECK_PARAM(info, iparams, max_outstanding_r2t, 1, 65535); ++ CHECK_PARAM(info, iparams, error_recovery_level, 0, 0); ++ CHECK_PARAM(info, iparams, data_pdu_inorder, 0, 1); ++ CHECK_PARAM(info, iparams, data_sequence_inorder, 0, 1); ++ ++ digest_alg_available(&iparams[key_header_digest]); ++ digest_alg_available(&iparams[key_data_digest]); ++ ++ CHECK_PARAM(info, iparams, ofmarker, 0, 0); ++ CHECK_PARAM(info, iparams, ifmarker, 0, 0); ++ ++ return; ++} ++ ++/* target_mutex supposed to be locked */ ++static void sess_params_set(struct iscsi_sess_params *params, ++ struct iscsi_kern_params_info *info) ++{ ++ int32_t *iparams = info->session_params; ++ ++ SET_PARAM(params, info, iparams, initial_r2t); ++ SET_PARAM(params, info, iparams, immediate_data); ++ SET_PARAM(params, info, iparams, max_connections); ++ SET_PARAM(params, info, iparams, max_recv_data_length); ++ SET_PARAM(params, info, iparams, max_xmit_data_length); ++ SET_PARAM(params, info, iparams, max_burst_length); ++ SET_PARAM(params, info, iparams, first_burst_length); ++ SET_PARAM(params, info, iparams, default_wait_time); ++ SET_PARAM(params, info, iparams, default_retain_time); ++ SET_PARAM(params, info, iparams, max_outstanding_r2t); ++ SET_PARAM(params, info, iparams, data_pdu_inorder); ++ SET_PARAM(params, info, iparams, data_sequence_inorder); ++ SET_PARAM(params, info, iparams, error_recovery_level); ++ SET_PARAM(params, info, iparams, header_digest); ++ SET_PARAM(params, info, iparams, data_digest); ++ SET_PARAM(params, info, iparams, ofmarker); ++ SET_PARAM(params, info, iparams, ifmarker); ++ SET_PARAM(params, info, iparams, ofmarkint); ++ SET_PARAM(params, info, iparams, ifmarkint); ++ return; ++} ++ ++static void sess_params_get(struct iscsi_sess_params *params, ++ struct iscsi_kern_params_info *info) ++{ ++ int32_t *iparams = info->session_params; ++ ++ GET_PARAM(params, info, iparams, initial_r2t); ++ GET_PARAM(params, info, iparams, immediate_data); ++ GET_PARAM(params, info, iparams, max_connections); ++ GET_PARAM(params, info, iparams, max_recv_data_length); ++ GET_PARAM(params, info, iparams, max_xmit_data_length); ++ GET_PARAM(params, info, iparams, max_burst_length); ++ GET_PARAM(params, info, iparams, first_burst_length); ++ GET_PARAM(params, info, iparams, default_wait_time); ++ GET_PARAM(params, info, iparams, default_retain_time); ++ GET_PARAM(params, info, iparams, max_outstanding_r2t); ++ GET_PARAM(params, info, iparams, data_pdu_inorder); ++ GET_PARAM(params, info, iparams, data_sequence_inorder); ++ GET_PARAM(params, info, iparams, error_recovery_level); ++ GET_PARAM(params, info, iparams, header_digest); ++ GET_PARAM(params, info, iparams, data_digest); ++ GET_PARAM(params, info, iparams, ofmarker); ++ GET_PARAM(params, info, iparams, ifmarker); ++ GET_PARAM(params, info, iparams, ofmarkint); ++ GET_PARAM(params, info, iparams, ifmarkint); ++ return; ++} ++ ++/* target_mutex supposed to be locked */ ++static void tgt_params_check(struct iscsi_session *session, ++ struct iscsi_kern_params_info *info) ++{ ++ int32_t *iparams = info->target_params; ++ unsigned int rsp_timeout, nop_in_timeout; ++ ++ /* ++ * This is only kernel sanity check. Actual data validity checks ++ * performed in the user space. ++ */ ++ ++ CHECK_PARAM(info, iparams, queued_cmnds, MIN_NR_QUEUED_CMNDS, ++ min_t(int, MAX_NR_QUEUED_CMNDS, ++ scst_get_max_lun_commands(session->scst_sess, NO_SUCH_LUN))); ++ CHECK_PARAM(info, iparams, rsp_timeout, MIN_RSP_TIMEOUT, ++ MAX_RSP_TIMEOUT); ++ CHECK_PARAM(info, iparams, nop_in_interval, MIN_NOP_IN_INTERVAL, ++ MAX_NOP_IN_INTERVAL); ++ CHECK_PARAM(info, iparams, nop_in_timeout, MIN_NOP_IN_TIMEOUT, ++ MAX_NOP_IN_TIMEOUT); ++ ++ /* ++ * We adjust too long timeout in req_add_to_write_timeout_list() ++ * only for NOPs, so check and warn if this assumption isn't honored. ++ */ ++ if (!info->partial || (info->partial & 1 << key_rsp_timeout)) ++ rsp_timeout = iparams[key_rsp_timeout]; ++ else ++ rsp_timeout = session->tgt_params.rsp_timeout; ++ if (!info->partial || (info->partial & 1 << key_nop_in_timeout)) ++ nop_in_timeout = iparams[key_nop_in_timeout]; ++ else ++ nop_in_timeout = session->tgt_params.nop_in_timeout; ++ if (nop_in_timeout > rsp_timeout) ++ PRINT_WARNING("%s", "RspTimeout should be >= NopInTimeout, " ++ "otherwise data transfer failure could take up to " ++ "NopInTimeout long to detect"); ++ ++ return; ++} ++ ++/* target_mutex supposed to be locked */ ++static int iscsi_tgt_params_set(struct iscsi_session *session, ++ struct iscsi_kern_params_info *info, int set) ++{ ++ struct iscsi_tgt_params *params = &session->tgt_params; ++ int32_t *iparams = info->target_params; ++ ++ if (set) { ++ struct iscsi_conn *conn; ++ ++ tgt_params_check(session, info); ++ ++ SET_PARAM(params, info, iparams, queued_cmnds); ++ SET_PARAM(params, info, iparams, rsp_timeout); ++ SET_PARAM(params, info, iparams, nop_in_interval); ++ SET_PARAM(params, info, iparams, nop_in_timeout); ++ ++ PRINT_INFO("Target parameters set for session %llx: " ++ "QueuedCommands %d, Response timeout %d, Nop-In " ++ "interval %d, Nop-In timeout %d", session->sid, ++ params->queued_cmnds, params->rsp_timeout, ++ params->nop_in_interval, params->nop_in_timeout); ++ ++ list_for_each_entry(conn, &session->conn_list, ++ conn_list_entry) { ++ conn->data_rsp_timeout = session->tgt_params.rsp_timeout * HZ; ++ conn->nop_in_interval = session->tgt_params.nop_in_interval * HZ; ++ conn->nop_in_timeout = session->tgt_params.nop_in_timeout * HZ; ++ spin_lock_bh(&conn->conn_thr_pool->rd_lock); ++ if (!conn->closing && (conn->nop_in_interval > 0)) { ++ TRACE_DBG("Schedule Nop-In work for conn %p", conn); ++ schedule_delayed_work(&conn->nop_in_delayed_work, ++ conn->nop_in_interval + ISCSI_ADD_SCHED_TIME); ++ } ++ spin_unlock_bh(&conn->conn_thr_pool->rd_lock); ++ } ++ } else { ++ GET_PARAM(params, info, iparams, queued_cmnds); ++ GET_PARAM(params, info, iparams, rsp_timeout); ++ GET_PARAM(params, info, iparams, nop_in_interval); ++ GET_PARAM(params, info, iparams, nop_in_timeout); ++ } ++ ++ return 0; ++} ++ ++/* target_mutex supposed to be locked */ ++static int iscsi_sess_params_set(struct iscsi_session *session, ++ struct iscsi_kern_params_info *info, int set) ++{ ++ struct iscsi_sess_params *params; ++ ++ if (set) ++ sess_params_check(info); ++ ++ params = &session->sess_params; ++ ++ if (set) { ++ sess_params_set(params, info); ++ log_params(params); ++ } else ++ sess_params_get(params, info); ++ ++ return 0; ++} ++ ++/* target_mutex supposed to be locked */ ++int iscsi_params_set(struct iscsi_target *target, ++ struct iscsi_kern_params_info *info, int set) ++{ ++ int err; ++ struct iscsi_session *session; ++ ++ if (info->sid == 0) { ++ PRINT_ERROR("sid must not be %d", 0); ++ err = -EINVAL; ++ goto out; ++ } ++ ++ session = session_lookup(target, info->sid); ++ if (session == NULL) { ++ PRINT_ERROR("Session for sid %llx not found", info->sid); ++ err = -ENOENT; ++ goto out; ++ } ++ ++ if (set && !list_empty(&session->conn_list) && ++ (info->params_type != key_target)) { ++ err = -EBUSY; ++ goto out; ++ } ++ ++ if (info->params_type == key_session) ++ err = iscsi_sess_params_set(session, info, set); ++ else if (info->params_type == key_target) ++ err = iscsi_tgt_params_set(session, info, set); ++ else ++ err = -EINVAL; ++ ++out: ++ return err; ++} +diff -uprN orig/linux-3.2/drivers/scst/iscsi-scst/session.c linux-3.2/drivers/scst/iscsi-scst/session.c +--- orig/linux-3.2/drivers/scst/iscsi-scst/session.c ++++ linux-3.2/drivers/scst/iscsi-scst/session.c +@@ -0,0 +1,527 @@ ++/* ++ * Copyright (C) 2002 - 2003 Ardis Technolgies <roman@ardistech.com> ++ * Copyright (C) 2007 - 2011 Vladislav Bolkhovitin ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include "iscsi.h" ++ ++#include <linux/export.h> ++ ++/* target_mutex supposed to be locked */ ++struct iscsi_session *session_lookup(struct iscsi_target *target, u64 sid) ++{ ++ struct iscsi_session *session; ++ ++ list_for_each_entry(session, &target->session_list, ++ session_list_entry) { ++ if (session->sid == sid) ++ return session; ++ } ++ return NULL; ++} ++ ++/* target_mgmt_mutex supposed to be locked */ ++static int iscsi_session_alloc(struct iscsi_target *target, ++ struct iscsi_kern_session_info *info, struct iscsi_session **result) ++{ ++ int err; ++ unsigned int i; ++ struct iscsi_session *session; ++ char *name = NULL; ++ ++ session = kzalloc(sizeof(*session), GFP_KERNEL); ++ if (!session) ++ return -ENOMEM; ++ ++ session->target = target; ++ session->sid = info->sid; ++ atomic_set(&session->active_cmds, 0); ++ session->exp_cmd_sn = info->exp_cmd_sn; ++ ++ session->initiator_name = kstrdup(info->initiator_name, GFP_KERNEL); ++ if (!session->initiator_name) { ++ err = -ENOMEM; ++ goto err; ++ } ++ ++ name = info->full_initiator_name; ++ ++ INIT_LIST_HEAD(&session->conn_list); ++ INIT_LIST_HEAD(&session->pending_list); ++ ++ spin_lock_init(&session->sn_lock); ++ ++ spin_lock_init(&session->cmnd_data_wait_hash_lock); ++ for (i = 0; i < ARRAY_SIZE(session->cmnd_data_wait_hash); i++) ++ INIT_LIST_HEAD(&session->cmnd_data_wait_hash[i]); ++ ++ session->next_ttt = 1; ++ ++ session->scst_sess = scst_register_session(target->scst_tgt, 0, ++ name, session, NULL, NULL); ++ if (session->scst_sess == NULL) { ++ PRINT_ERROR("%s", "scst_register_session() failed"); ++ err = -ENOMEM; ++ goto err; ++ } ++ ++ err = iscsi_threads_pool_get(&session->scst_sess->acg->acg_cpu_mask, ++ &session->sess_thr_pool); ++ if (err != 0) ++ goto err_unreg; ++ ++ TRACE_MGMT_DBG("Session %p created: target %p, tid %u, sid %#Lx", ++ session, target, target->tid, info->sid); ++ ++ *result = session; ++ return 0; ++ ++err_unreg: ++ scst_unregister_session(session->scst_sess, 1, NULL); ++ ++err: ++ if (session) { ++ kfree(session->initiator_name); ++ kfree(session); ++ } ++ return err; ++} ++ ++/* target_mutex supposed to be locked */ ++void sess_reinst_finished(struct iscsi_session *sess) ++{ ++ struct iscsi_conn *c; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Enabling reinstate successor sess %p", sess); ++ ++ BUG_ON(!sess->sess_reinstating); ++ ++ list_for_each_entry(c, &sess->conn_list, conn_list_entry) { ++ conn_reinst_finished(c); ++ } ++ sess->sess_reinstating = 0; ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* target_mgmt_mutex supposed to be locked */ ++int __add_session(struct iscsi_target *target, ++ struct iscsi_kern_session_info *info) ++{ ++ struct iscsi_session *new_sess = NULL, *sess, *old_sess; ++ int err = 0, i; ++ union iscsi_sid sid; ++ bool reinstatement = false; ++ struct iscsi_kern_params_info *params_info; ++ ++ TRACE_MGMT_DBG("Adding session SID %llx", info->sid); ++ ++ err = iscsi_session_alloc(target, info, &new_sess); ++ if (err != 0) ++ goto out; ++ ++ mutex_lock(&target->target_mutex); ++ ++ sess = session_lookup(target, info->sid); ++ if (sess != NULL) { ++ PRINT_ERROR("Attempt to add session with existing SID %llx", ++ info->sid); ++ err = -EEXIST; ++ goto out_err_unlock; ++ } ++ ++ params_info = kmalloc(sizeof(*params_info), GFP_KERNEL); ++ if (params_info == NULL) { ++ PRINT_ERROR("Unable to allocate params info (size %zd)", ++ sizeof(*params_info)); ++ err = -ENOMEM; ++ goto out_err_unlock; ++ } ++ ++ sid = *(union iscsi_sid *)&info->sid; ++ sid.id.tsih = 0; ++ old_sess = NULL; ++ ++ /* ++ * We need to find the latest session to correctly handle ++ * multi-reinstatements ++ */ ++ list_for_each_entry_reverse(sess, &target->session_list, ++ session_list_entry) { ++ union iscsi_sid s = *(union iscsi_sid *)&sess->sid; ++ s.id.tsih = 0; ++ if ((sid.id64 == s.id64) && ++ (strcmp(info->initiator_name, sess->initiator_name) == 0)) { ++ if (!sess->sess_shutting_down) { ++ /* session reinstatement */ ++ old_sess = sess; ++ } ++ break; ++ } ++ } ++ sess = NULL; ++ ++ list_add_tail(&new_sess->session_list_entry, &target->session_list); ++ ++ memset(params_info, 0, sizeof(*params_info)); ++ params_info->tid = target->tid; ++ params_info->sid = info->sid; ++ params_info->params_type = key_session; ++ for (i = 0; i < session_key_last; i++) ++ params_info->session_params[i] = info->session_params[i]; ++ ++ err = iscsi_params_set(target, params_info, 1); ++ if (err != 0) ++ goto out_del; ++ ++ memset(params_info, 0, sizeof(*params_info)); ++ params_info->tid = target->tid; ++ params_info->sid = info->sid; ++ params_info->params_type = key_target; ++ for (i = 0; i < target_key_last; i++) ++ params_info->target_params[i] = info->target_params[i]; ++ ++ err = iscsi_params_set(target, params_info, 1); ++ if (err != 0) ++ goto out_del; ++ ++ kfree(params_info); ++ params_info = NULL; ++ ++ if (old_sess != NULL) { ++ reinstatement = true; ++ ++ TRACE_MGMT_DBG("Reinstating sess %p with SID %llx (old %p, " ++ "SID %llx)", new_sess, new_sess->sid, old_sess, ++ old_sess->sid); ++ ++ new_sess->sess_reinstating = 1; ++ old_sess->sess_reinst_successor = new_sess; ++ ++ target_del_session(old_sess->target, old_sess, 0); ++ } ++ ++ mutex_unlock(&target->target_mutex); ++ ++ if (reinstatement) { ++ /* ++ * Mutex target_mgmt_mutex won't allow to add connections to ++ * the new session after target_mutex was dropped, so it's safe ++ * to replace the initial UA without it. We can't do it under ++ * target_mutex, because otherwise we can establish a ++ * circular locking dependency between target_mutex and ++ * scst_mutex in SCST core (iscsi_report_aen() called by ++ * SCST core under scst_mutex). ++ */ ++ scst_set_initial_UA(new_sess->scst_sess, ++ SCST_LOAD_SENSE(scst_sense_nexus_loss_UA)); ++ } ++ ++out: ++ return err; ++ ++out_del: ++ list_del(&new_sess->session_list_entry); ++ kfree(params_info); ++ ++out_err_unlock: ++ mutex_unlock(&target->target_mutex); ++ ++ scst_unregister_session(new_sess->scst_sess, 1, NULL); ++ new_sess->scst_sess = NULL; ++ ++ mutex_lock(&target->target_mutex); ++ session_free(new_sess, false); ++ mutex_unlock(&target->target_mutex); ++ goto out; ++} ++ ++static void __session_free(struct iscsi_session *session) ++{ ++ kfree(session->initiator_name); ++ kfree(session); ++} ++ ++static void iscsi_unreg_sess_done(struct scst_session *scst_sess) ++{ ++ struct iscsi_session *session; ++ ++ TRACE_ENTRY(); ++ ++ session = (struct iscsi_session *)scst_sess_get_tgt_priv(scst_sess); ++ ++ session->scst_sess = NULL; ++ __session_free(session); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* target_mutex supposed to be locked */ ++int session_free(struct iscsi_session *session, bool del) ++{ ++ unsigned int i; ++ ++ TRACE_MGMT_DBG("Freeing session %p (SID %llx)", ++ session, session->sid); ++ ++ BUG_ON(!list_empty(&session->conn_list)); ++ if (unlikely(atomic_read(&session->active_cmds) != 0)) { ++ PRINT_CRIT_ERROR("active_cmds not 0 (%d)!!", ++ atomic_read(&session->active_cmds)); ++ BUG(); ++ } ++ ++ for (i = 0; i < ARRAY_SIZE(session->cmnd_data_wait_hash); i++) ++ BUG_ON(!list_empty(&session->cmnd_data_wait_hash[i])); ++ ++ if (session->sess_reinst_successor != NULL) ++ sess_reinst_finished(session->sess_reinst_successor); ++ ++ if (session->sess_reinstating) { ++ struct iscsi_session *s; ++ TRACE_MGMT_DBG("Freeing being reinstated sess %p", session); ++ list_for_each_entry(s, &session->target->session_list, ++ session_list_entry) { ++ if (s->sess_reinst_successor == session) { ++ s->sess_reinst_successor = NULL; ++ break; ++ } ++ } ++ } ++ ++ if (del) ++ list_del(&session->session_list_entry); ++ ++ if (session->sess_thr_pool != NULL) { ++ iscsi_threads_pool_put(session->sess_thr_pool); ++ session->sess_thr_pool = NULL; ++ } ++ ++ if (session->scst_sess != NULL) { ++ /* ++ * We must NOT call scst_unregister_session() in the waiting ++ * mode, since we are under target_mutex. Otherwise we can ++ * establish a circular locking dependency between target_mutex ++ * and scst_mutex in SCST core (iscsi_report_aen() called by ++ * SCST core under scst_mutex). ++ */ ++ scst_unregister_session(session->scst_sess, 0, ++ iscsi_unreg_sess_done); ++ } else ++ __session_free(session); ++ ++ return 0; ++} ++ ++/* target_mutex supposed to be locked */ ++int __del_session(struct iscsi_target *target, u64 sid) ++{ ++ struct iscsi_session *session; ++ ++ session = session_lookup(target, sid); ++ if (!session) ++ return -ENOENT; ++ ++ if (!list_empty(&session->conn_list)) { ++ PRINT_ERROR("%llx still have connections", ++ (long long unsigned int)session->sid); ++ return -EBUSY; ++ } ++ ++ return session_free(session, true); ++} ++ ++/* Must be called under target_mutex */ ++void iscsi_sess_force_close(struct iscsi_session *sess) ++{ ++ struct iscsi_conn *conn; ++ ++ TRACE_ENTRY(); ++ ++ PRINT_INFO("Deleting session %llx with initiator %s (%p)", ++ (long long unsigned int)sess->sid, sess->initiator_name, sess); ++ ++ list_for_each_entry(conn, &sess->conn_list, conn_list_entry) { ++ TRACE_MGMT_DBG("Deleting connection with initiator %p", conn); ++ __mark_conn_closed(conn, ISCSI_CONN_ACTIVE_CLOSE|ISCSI_CONN_DELETING); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++#define ISCSI_SESS_BOOL_PARAM_ATTR(name, exported_name) \ ++static ssize_t iscsi_sess_show_##name(struct kobject *kobj, \ ++ struct kobj_attribute *attr, char *buf) \ ++{ \ ++ int pos; \ ++ struct scst_session *scst_sess; \ ++ struct iscsi_session *sess; \ ++ \ ++ scst_sess = container_of(kobj, struct scst_session, sess_kobj); \ ++ sess = (struct iscsi_session *)scst_sess_get_tgt_priv(scst_sess); \ ++ \ ++ pos = sprintf(buf, "%s\n", \ ++ iscsi_get_bool_value(sess->sess_params.name)); \ ++ \ ++ return pos; \ ++} \ ++ \ ++static struct kobj_attribute iscsi_sess_attr_##name = \ ++ __ATTR(exported_name, S_IRUGO, iscsi_sess_show_##name, NULL); ++ ++#define ISCSI_SESS_INT_PARAM_ATTR(name, exported_name) \ ++static ssize_t iscsi_sess_show_##name(struct kobject *kobj, \ ++ struct kobj_attribute *attr, char *buf) \ ++{ \ ++ int pos; \ ++ struct scst_session *scst_sess; \ ++ struct iscsi_session *sess; \ ++ \ ++ scst_sess = container_of(kobj, struct scst_session, sess_kobj); \ ++ sess = (struct iscsi_session *)scst_sess_get_tgt_priv(scst_sess); \ ++ \ ++ pos = sprintf(buf, "%d\n", sess->sess_params.name); \ ++ \ ++ return pos; \ ++} \ ++ \ ++static struct kobj_attribute iscsi_sess_attr_##name = \ ++ __ATTR(exported_name, S_IRUGO, iscsi_sess_show_##name, NULL); ++ ++#define ISCSI_SESS_DIGEST_PARAM_ATTR(name, exported_name) \ ++static ssize_t iscsi_sess_show_##name(struct kobject *kobj, \ ++ struct kobj_attribute *attr, char *buf) \ ++{ \ ++ int pos; \ ++ struct scst_session *scst_sess; \ ++ struct iscsi_session *sess; \ ++ char digest_name[64]; \ ++ \ ++ scst_sess = container_of(kobj, struct scst_session, sess_kobj); \ ++ sess = (struct iscsi_session *)scst_sess_get_tgt_priv(scst_sess); \ ++ \ ++ pos = sprintf(buf, "%s\n", iscsi_get_digest_name( \ ++ sess->sess_params.name, digest_name)); \ ++ \ ++ return pos; \ ++} \ ++ \ ++static struct kobj_attribute iscsi_sess_attr_##name = \ ++ __ATTR(exported_name, S_IRUGO, iscsi_sess_show_##name, NULL); ++ ++ISCSI_SESS_BOOL_PARAM_ATTR(initial_r2t, InitialR2T); ++ISCSI_SESS_BOOL_PARAM_ATTR(immediate_data, ImmediateData); ++ISCSI_SESS_INT_PARAM_ATTR(max_recv_data_length, MaxRecvDataSegmentLength); ++ISCSI_SESS_INT_PARAM_ATTR(max_xmit_data_length, MaxXmitDataSegmentLength); ++ISCSI_SESS_INT_PARAM_ATTR(max_burst_length, MaxBurstLength); ++ISCSI_SESS_INT_PARAM_ATTR(first_burst_length, FirstBurstLength); ++ISCSI_SESS_INT_PARAM_ATTR(max_outstanding_r2t, MaxOutstandingR2T); ++ISCSI_SESS_DIGEST_PARAM_ATTR(header_digest, HeaderDigest); ++ISCSI_SESS_DIGEST_PARAM_ATTR(data_digest, DataDigest); ++ ++static ssize_t iscsi_sess_sid_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos; ++ struct scst_session *scst_sess; ++ struct iscsi_session *sess; ++ ++ TRACE_ENTRY(); ++ ++ scst_sess = container_of(kobj, struct scst_session, sess_kobj); ++ sess = (struct iscsi_session *)scst_sess_get_tgt_priv(scst_sess); ++ ++ pos = sprintf(buf, "%llx\n", sess->sid); ++ ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static struct kobj_attribute iscsi_attr_sess_sid = ++ __ATTR(sid, S_IRUGO, iscsi_sess_sid_show, NULL); ++ ++static ssize_t iscsi_sess_reinstating_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos; ++ struct scst_session *scst_sess; ++ struct iscsi_session *sess; ++ ++ TRACE_ENTRY(); ++ ++ scst_sess = container_of(kobj, struct scst_session, sess_kobj); ++ sess = (struct iscsi_session *)scst_sess_get_tgt_priv(scst_sess); ++ ++ pos = sprintf(buf, "%d\n", sess->sess_reinstating ? 1 : 0); ++ ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static struct kobj_attribute iscsi_sess_attr_reinstating = ++ __ATTR(reinstating, S_IRUGO, iscsi_sess_reinstating_show, NULL); ++ ++static ssize_t iscsi_sess_force_close_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buf, size_t count) ++{ ++ int res; ++ struct scst_session *scst_sess; ++ struct iscsi_session *sess; ++ ++ TRACE_ENTRY(); ++ ++ scst_sess = container_of(kobj, struct scst_session, sess_kobj); ++ sess = (struct iscsi_session *)scst_sess_get_tgt_priv(scst_sess); ++ ++ if (mutex_lock_interruptible(&sess->target->target_mutex) != 0) { ++ res = -EINTR; ++ goto out; ++ } ++ ++ iscsi_sess_force_close(sess); ++ ++ mutex_unlock(&sess->target->target_mutex); ++ ++ res = count; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static struct kobj_attribute iscsi_sess_attr_force_close = ++ __ATTR(force_close, S_IWUSR, NULL, iscsi_sess_force_close_store); ++ ++const struct attribute *iscsi_sess_attrs[] = { ++ &iscsi_sess_attr_initial_r2t.attr, ++ &iscsi_sess_attr_immediate_data.attr, ++ &iscsi_sess_attr_max_recv_data_length.attr, ++ &iscsi_sess_attr_max_xmit_data_length.attr, ++ &iscsi_sess_attr_max_burst_length.attr, ++ &iscsi_sess_attr_first_burst_length.attr, ++ &iscsi_sess_attr_max_outstanding_r2t.attr, ++ &iscsi_sess_attr_header_digest.attr, ++ &iscsi_sess_attr_data_digest.attr, ++ &iscsi_attr_sess_sid.attr, ++ &iscsi_sess_attr_reinstating.attr, ++ &iscsi_sess_attr_force_close.attr, ++ NULL, ++}; ++ +diff -uprN orig/linux-3.2/drivers/scst/iscsi-scst/target.c linux-3.2/drivers/scst/iscsi-scst/target.c +--- orig/linux-3.2/drivers/scst/iscsi-scst/target.c ++++ linux-3.2/drivers/scst/iscsi-scst/target.c +@@ -0,0 +1,533 @@ ++/* ++ * Copyright (C) 2002 - 2003 Ardis Technolgies <roman@ardistech.com> ++ * Copyright (C) 2007 - 2011 Vladislav Bolkhovitin ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/delay.h> ++#include <linux/module.h> ++ ++#include "iscsi.h" ++#include "digest.h" ++ ++#define MAX_NR_TARGETS (1UL << 30) ++ ++DEFINE_MUTEX(target_mgmt_mutex); ++ ++/* All 3 protected by target_mgmt_mutex */ ++static LIST_HEAD(target_list); ++static u32 next_target_id; ++static u32 nr_targets; ++ ++/* target_mgmt_mutex supposed to be locked */ ++struct iscsi_target *target_lookup_by_id(u32 id) ++{ ++ struct iscsi_target *target; ++ ++ list_for_each_entry(target, &target_list, target_list_entry) { ++ if (target->tid == id) ++ return target; ++ } ++ return NULL; ++} ++ ++/* target_mgmt_mutex supposed to be locked */ ++static struct iscsi_target *target_lookup_by_name(const char *name) ++{ ++ struct iscsi_target *target; ++ ++ list_for_each_entry(target, &target_list, target_list_entry) { ++ if (!strcmp(target->name, name)) ++ return target; ++ } ++ return NULL; ++} ++ ++/* target_mgmt_mutex supposed to be locked */ ++static int iscsi_target_create(struct iscsi_kern_target_info *info, u32 tid, ++ struct iscsi_target **out_target) ++{ ++ int err = -EINVAL, len; ++ char *name = info->name; ++ struct iscsi_target *target; ++ ++ TRACE_MGMT_DBG("Creating target tid %u, name %s", tid, name); ++ ++ len = strlen(name); ++ if (!len) { ++ PRINT_ERROR("The length of the target name is zero %u", tid); ++ goto out; ++ } ++ ++ if (!try_module_get(THIS_MODULE)) { ++ PRINT_ERROR("Fail to get module %u", tid); ++ goto out; ++ } ++ ++ target = kzalloc(sizeof(*target), GFP_KERNEL); ++ if (!target) { ++ err = -ENOMEM; ++ goto out_put; ++ } ++ ++ target->tid = info->tid = tid; ++ ++ strlcpy(target->name, name, sizeof(target->name)); ++ ++ mutex_init(&target->target_mutex); ++ INIT_LIST_HEAD(&target->session_list); ++ INIT_LIST_HEAD(&target->attrs_list); ++ ++ target->scst_tgt = scst_register_target(&iscsi_template, target->name); ++ if (!target->scst_tgt) { ++ PRINT_ERROR("%s", "scst_register_target() failed"); ++ err = -EBUSY; ++ goto out_free; ++ } ++ ++ scst_tgt_set_tgt_priv(target->scst_tgt, target); ++ ++ list_add_tail(&target->target_list_entry, &target_list); ++ ++ *out_target = target; ++ ++ return 0; ++ ++out_free: ++ kfree(target); ++ ++out_put: ++ module_put(THIS_MODULE); ++ ++out: ++ return err; ++} ++ ++/* target_mgmt_mutex supposed to be locked */ ++int __add_target(struct iscsi_kern_target_info *info) ++{ ++ int err; ++ u32 tid = info->tid; ++ struct iscsi_target *target = NULL; /* to calm down sparse */ ++ struct iscsi_kern_attr *attr_info; ++ union add_info_union { ++ struct iscsi_kern_params_info params_info; ++ struct iscsi_kern_attr attr_info; ++ } *add_info; ++ int i, rc; ++ unsigned long attrs_ptr_long; ++ struct iscsi_kern_attr __user *attrs_ptr; ++ ++ if (nr_targets > MAX_NR_TARGETS) { ++ err = -EBUSY; ++ goto out; ++ } ++ ++ if (target_lookup_by_name(info->name)) { ++ PRINT_ERROR("Target %s already exist!", info->name); ++ err = -EEXIST; ++ goto out; ++ } ++ ++ if (tid && target_lookup_by_id(tid)) { ++ PRINT_ERROR("Target %u already exist!", tid); ++ err = -EEXIST; ++ goto out; ++ } ++ ++ add_info = kmalloc(sizeof(*add_info), GFP_KERNEL); ++ if (add_info == NULL) { ++ PRINT_ERROR("Unable to allocate additional info (size %zd)", ++ sizeof(*add_info)); ++ err = -ENOMEM; ++ goto out; ++ } ++ attr_info = (struct iscsi_kern_attr *)add_info; ++ ++ if (tid == 0) { ++ do { ++ if (!++next_target_id) ++ ++next_target_id; ++ } while (target_lookup_by_id(next_target_id)); ++ ++ tid = next_target_id; ++ } ++ ++ err = iscsi_target_create(info, tid, &target); ++ if (err != 0) ++ goto out_free; ++ ++ nr_targets++; ++ ++ mutex_lock(&target->target_mutex); ++ ++ attrs_ptr_long = info->attrs_ptr; ++ attrs_ptr = (struct iscsi_kern_attr __user *)attrs_ptr_long; ++ for (i = 0; i < info->attrs_num; i++) { ++ memset(attr_info, 0, sizeof(*attr_info)); ++ ++ rc = copy_from_user(attr_info, attrs_ptr, sizeof(*attr_info)); ++ if (rc != 0) { ++ PRINT_ERROR("Failed to copy users of target %s " ++ "failed", info->name); ++ err = -EFAULT; ++ goto out_del_unlock; ++ } ++ ++ attr_info->name[sizeof(attr_info->name)-1] = '\0'; ++ ++ err = iscsi_add_attr(target, attr_info); ++ if (err != 0) ++ goto out_del_unlock; ++ ++ attrs_ptr++; ++ } ++ ++ mutex_unlock(&target->target_mutex); ++ ++ err = tid; ++ ++out_free: ++ kfree(add_info); ++ ++out: ++ return err; ++ ++out_del_unlock: ++ mutex_unlock(&target->target_mutex); ++ __del_target(tid); ++ goto out_free; ++} ++ ++static void target_destroy(struct iscsi_target *target) ++{ ++ struct iscsi_attr *attr, *t; ++ ++ TRACE_MGMT_DBG("Destroying target tid %u", target->tid); ++ ++ list_for_each_entry_safe(attr, t, &target->attrs_list, ++ attrs_list_entry) { ++ __iscsi_del_attr(target, attr); ++ } ++ ++ scst_unregister_target(target->scst_tgt); ++ ++ kfree(target); ++ ++ module_put(THIS_MODULE); ++ return; ++} ++ ++/* target_mgmt_mutex supposed to be locked */ ++int __del_target(u32 id) ++{ ++ struct iscsi_target *target; ++ int err; ++ ++ target = target_lookup_by_id(id); ++ if (!target) { ++ err = -ENOENT; ++ goto out; ++ } ++ ++ mutex_lock(&target->target_mutex); ++ ++ if (!list_empty(&target->session_list)) { ++ err = -EBUSY; ++ goto out_unlock; ++ } ++ ++ list_del(&target->target_list_entry); ++ nr_targets--; ++ ++ mutex_unlock(&target->target_mutex); ++ ++ target_destroy(target); ++ return 0; ++ ++out_unlock: ++ mutex_unlock(&target->target_mutex); ++ ++out: ++ return err; ++} ++ ++/* target_mutex supposed to be locked */ ++void target_del_session(struct iscsi_target *target, ++ struct iscsi_session *session, int flags) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Deleting session %p", session); ++ ++ if (!list_empty(&session->conn_list)) { ++ struct iscsi_conn *conn, *tc; ++ list_for_each_entry_safe(conn, tc, &session->conn_list, ++ conn_list_entry) { ++ TRACE_MGMT_DBG("Mark conn %p closing", conn); ++ __mark_conn_closed(conn, flags); ++ } ++ } else { ++ TRACE_MGMT_DBG("Freeing session %p without connections", ++ session); ++ __del_session(target, session->sid); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* target_mutex supposed to be locked */ ++void target_del_all_sess(struct iscsi_target *target, int flags) ++{ ++ struct iscsi_session *session, *ts; ++ ++ TRACE_ENTRY(); ++ ++ if (!list_empty(&target->session_list)) { ++ TRACE_MGMT_DBG("Deleting all sessions from target %p", target); ++ list_for_each_entry_safe(session, ts, &target->session_list, ++ session_list_entry) { ++ target_del_session(target, session, flags); ++ } ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++void target_del_all(void) ++{ ++ struct iscsi_target *target, *t; ++ bool first = true; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("%s", "Deleting all targets"); ++ ++ /* Not the best, ToDo */ ++ while (1) { ++ mutex_lock(&target_mgmt_mutex); ++ ++ if (list_empty(&target_list)) ++ break; ++ ++ /* ++ * In the first iteration we won't delete targets to go at ++ * first through all sessions of all targets and close their ++ * connections. Otherwise we can stuck for noticeable time ++ * waiting during a target's unregistration for the activities ++ * suspending over active connection. This can especially got ++ * bad if any being wait connection itself stuck waiting for ++ * something and can be recovered only by connection close. ++ * Let's for such cases not wait while such connection recover ++ * theyself, but act in advance. ++ */ ++ ++ list_for_each_entry_safe(target, t, &target_list, ++ target_list_entry) { ++ mutex_lock(&target->target_mutex); ++ ++ if (!list_empty(&target->session_list)) { ++ target_del_all_sess(target, ++ ISCSI_CONN_ACTIVE_CLOSE | ++ ISCSI_CONN_DELETING); ++ } else if (!first) { ++ TRACE_MGMT_DBG("Deleting target %p", target); ++ list_del(&target->target_list_entry); ++ nr_targets--; ++ mutex_unlock(&target->target_mutex); ++ target_destroy(target); ++ continue; ++ } ++ ++ mutex_unlock(&target->target_mutex); ++ } ++ mutex_unlock(&target_mgmt_mutex); ++ msleep(100); ++ ++ first = false; ++ } ++ ++ mutex_unlock(&target_mgmt_mutex); ++ ++ TRACE_MGMT_DBG("%s", "Deleting all targets finished"); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static ssize_t iscsi_tgt_tid_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ int pos; ++ struct scst_tgt *scst_tgt; ++ struct iscsi_target *tgt; ++ ++ TRACE_ENTRY(); ++ ++ scst_tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ tgt = (struct iscsi_target *)scst_tgt_get_tgt_priv(scst_tgt); ++ ++ pos = sprintf(buf, "%u\n", tgt->tid); ++ ++ TRACE_EXIT_RES(pos); ++ return pos; ++} ++ ++static struct kobj_attribute iscsi_tgt_attr_tid = ++ __ATTR(tid, S_IRUGO, iscsi_tgt_tid_show, NULL); ++ ++const struct attribute *iscsi_tgt_attrs[] = { ++ &iscsi_tgt_attr_tid.attr, ++ NULL, ++}; ++ ++ssize_t iscsi_sysfs_send_event(uint32_t tid, enum iscsi_kern_event_code code, ++ const char *param1, const char *param2, void **data) ++{ ++ int res; ++ struct scst_sysfs_user_info *info; ++ ++ TRACE_ENTRY(); ++ ++ if (ctr_open_state != ISCSI_CTR_OPEN_STATE_OPEN) { ++ PRINT_ERROR("%s", "User space process not connected"); ++ res = -EPERM; ++ goto out; ++ } ++ ++ res = scst_sysfs_user_add_info(&info); ++ if (res != 0) ++ goto out; ++ ++ TRACE_DBG("Sending event %d (tid %d, param1 %s, param2 %s, cookie %d, " ++ "info %p)", tid, code, param1, param2, info->info_cookie, info); ++ ++ res = event_send(tid, 0, 0, info->info_cookie, code, param1, param2); ++ if (res <= 0) { ++ PRINT_ERROR("event_send() failed: %d", res); ++ if (res == 0) ++ res = -EFAULT; ++ goto out_free; ++ } ++ ++ /* ++ * It may wait 30 secs in blocking connect to an unreacheable ++ * iSNS server. It must be fixed, but not now. ToDo. ++ */ ++ res = scst_wait_info_completion(info, 31 * HZ); ++ ++ if (data != NULL) ++ *data = info->data; ++ ++out_free: ++ scst_sysfs_user_del_info(info); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++int iscsi_enable_target(struct scst_tgt *scst_tgt, bool enable) ++{ ++ struct iscsi_target *tgt = ++ (struct iscsi_target *)scst_tgt_get_tgt_priv(scst_tgt); ++ int res; ++ uint32_t type; ++ ++ TRACE_ENTRY(); ++ ++ if (enable) ++ type = E_ENABLE_TARGET; ++ else ++ type = E_DISABLE_TARGET; ++ ++ TRACE_DBG("%s target %d", enable ? "Enabling" : "Disabling", tgt->tid); ++ ++ res = iscsi_sysfs_send_event(tgt->tid, type, NULL, NULL, NULL); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++bool iscsi_is_target_enabled(struct scst_tgt *scst_tgt) ++{ ++ struct iscsi_target *tgt = ++ (struct iscsi_target *)scst_tgt_get_tgt_priv(scst_tgt); ++ ++ return tgt->tgt_enabled; ++} ++ ++ssize_t iscsi_sysfs_add_target(const char *target_name, char *params) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ res = iscsi_sysfs_send_event(0, E_ADD_TARGET, target_name, ++ params, NULL); ++ if (res > 0) { ++ /* It's tid */ ++ res = 0; ++ } ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++ssize_t iscsi_sysfs_del_target(const char *target_name) ++{ ++ int res = 0, tid; ++ ++ TRACE_ENTRY(); ++ ++ /* We don't want to have tgt visible after the mutex unlock */ ++ { ++ struct iscsi_target *tgt; ++ mutex_lock(&target_mgmt_mutex); ++ tgt = target_lookup_by_name(target_name); ++ if (tgt == NULL) { ++ PRINT_ERROR("Target %s not found", target_name); ++ mutex_unlock(&target_mgmt_mutex); ++ res = -ENOENT; ++ goto out; ++ } ++ tid = tgt->tid; ++ mutex_unlock(&target_mgmt_mutex); ++ } ++ ++ TRACE_DBG("Deleting target %s (tid %d)", target_name, tid); ++ ++ res = iscsi_sysfs_send_event(tid, E_DEL_TARGET, NULL, NULL, NULL); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++ssize_t iscsi_sysfs_mgmt_cmd(char *cmd) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Sending mgmt cmd %s", cmd); ++ ++ res = iscsi_sysfs_send_event(0, E_MGMT_CMD, cmd, NULL, NULL); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ +diff -uprN orig/linux-3.2/Documentation/scst/README.iscsi linux-3.2/Documentation/scst/README.iscsi +--- orig/linux-3.2/Documentation/scst/README.iscsi ++++ linux-3.2/Documentation/scst/README.iscsi +@@ -0,0 +1,748 @@ ++iSCSI SCST target driver ++======================== ++ ++ISCSI-SCST is a deeply reworked fork of iSCSI Enterprise Target (IET) ++(http://iscsitarget.sourceforge.net). Reasons of the fork were: ++ ++ - To be able to use full power of SCST core. ++ ++ - To fix all the problems, corner cases issues and iSCSI standard ++ violations which IET has. ++ ++See for more info http://iscsi-scst.sourceforge.net. ++ ++Usage ++----- ++ ++See in http://iscsi-scst.sourceforge.net/iscsi-scst-howto.txt how to ++configure iSCSI-SCST. ++ ++If you want to use Intel CRC32 offload and have corresponding hardware, ++you should load crc32c-intel module. Then iSCSI-SCST will do all digest ++calculations using this facility. ++ ++In 2.0.0 usage of iscsi-scstd.conf as well as iscsi-scst-adm utility is ++obsolete. Use the sysfs interface facilities instead. ++ ++The flow of iSCSI-SCST inialization should be as the following: ++ ++1. Load of SCST and iSCSI-SCST kernel modules with necessary module ++parameters, if needed. ++ ++2. Start iSCSI-SCST service. ++ ++3. Configure targets, devices, LUNs, etc. either using scstadmin ++(recommended), or using the sysfs interface directly as described below. ++ ++It is recommended to use TEST UNIT READY ("tur") command to check if ++iSCSI-SCST target is alive in MPIO configurations. ++ ++Also see SCST README file how to tune for the best performance. ++ ++CAUTION: Working of target and initiator on the same host isn't fully ++======= supported. See SCST README file for details. ++ ++ ++Sysfs interface ++--------------- ++ ++Root of SCST sysfs interface is /sys/kernel/scst_tgt. Root of iSCSI-SCST ++is /sys/kernel/scst_tgt/targets/iscsi. It has the following entries: ++ ++ - None, one or more subdirectories for targets with name equal to names ++ of the corresponding targets. ++ ++ - IncomingUser[num] - optional one or more attributes containing user ++ name and password for incoming discovery user name. Not exist by ++ default and can be added through "mgmt" entry, see below. ++ ++ - OutgoingUser - optional attribute containing user name and password ++ for outgoing discovery user name. Not exist by default and can be ++ added through "mgmt" entry, see below. ++ ++ - iSNSServer - contains name or IP address of iSNS server with optional ++ "AccessControl" attribute, which allows to enable iSNS access ++ control. Empty by default. ++ ++ - allowed_portal[num] - optional attribute, which specifies, on which ++ portals (target's IP addresses) this target will be available. If not ++ specified (default) the target will be available on all all portals. ++ As soon as at least one allowed_portal specified, the target will be ++ accessible for initiators only on the specified portals. There might ++ be any number of the allowed_portal attributes. The portals ++ specification in the allowed_portal attributes can be a simple ++ DOS-type patterns, containing '*' and '?' symbols. '*' means match ++ all any symbols, '?' means match only any single symbol. For ++ instance, "10.170.77.2" will match "10.170.7?.*". Additionally, you ++ can use negative sign '!' to revert the value of the pattern. For ++ instance, "10.170.67.2" will match "!10.170.7?.*". See examples ++ below. ++ ++ - enabled - using this attribute you can enable or disable iSCSI-SCST ++ accept new connections. It allows to finish configuring global ++ iSCSI-SCST attributes before it starts accepting new connections. 0 ++ by default. ++ ++ - open_state - read-only attribute, which allows to see if the user ++ space part of iSCSI-SCST connected to the kernel part. ++ ++ - per_portal_acl - if set, makes iSCSI-SCST work in the per-portal ++ access control mode. In this mode iSCSI-SCST registers all initiators ++ in SCST core as "initiator_name#portal_IP_address" pattern, like ++ "iqn.2006-10.net.vlnb:ini#10.170.77.2" for initiator ++ iqn.2006-10.net.vlnb connected through portal 10.170.77.2. This mode ++ allows to make particular initiators be able to use only particular ++ portals on the target and don't see/be able to connect through ++ others. See below for more details. ++ ++ - trace_level - allows to enable and disable various tracing ++ facilities. See content of this file for help how to use it. ++ ++ - version - read-only attribute, which allows to see version of ++ iSCSI-SCST and enabled optional features. ++ ++ - mgmt - main management entry, which allows to configure iSCSI-SCST. ++ Namely, add/delete targets as well as add/delete optional global and ++ per-target attributes. See content of this file for help how to use ++ it. ++ ++Each iSCSI-SCST sysfs file (attribute) can contain in the last line mark ++"[key]". It is automatically added mark used to allow scstadmin to see ++which attributes it should save in the config file. You can ignore it. ++ ++Each target subdirectory contains the following entries: ++ ++ - ini_groups - subdirectory defining initiator groups for this target, ++ used to define per-initiator access control. See SCST core README for ++ more details. ++ ++ - luns - subdirectory defining LUNs of this target. See SCST core ++ README for more details. ++ ++ - sessions - subdirectory containing connected to this target sessions. ++ ++ - IncomingUser[num] - optional one or more attributes containing user ++ name and password for incoming user name. Not exist by default and can ++ be added through the "mgmt" entry, see above. ++ ++ - OutgoingUser - optional attribute containing user name and password ++ for outgoing user name. Not exist by default and can be added through ++ the "mgmt" entry, see above. ++ ++ - Entries defining default iSCSI parameters values used during iSCSI ++ parameters negotiation. Only entries which can be changed or make ++ sense are listed there. ++ ++ - QueuedCommands - defines maximum number of commands queued to any ++ session of this target. Default is 32 commands. ++ ++ - NopInInterval - defines interval between NOP-In requests, which the ++ target will send on idle connections to check if the initiator is ++ still alive. If there is no NOP-Out reply from the initiator in ++ RspTimeout time, the corresponding connection will be closed. Default ++ is 30 seconds. If it's set to 0, then NOP-In requests are disabled. ++ ++ - NopInTimeout - defines the maximum time in seconds a NOP-In request ++ can wait for response from initiator, otherwise the corresponding ++ connection will be closed. Default is 30 seconds. ++ ++ - RspTimeout - defines the maximum time in seconds a command can wait for ++ response from initiator, otherwise the corresponding connection will ++ be closed. Default is 90 seconds. ++ ++ - enabled - using this attribute you can enable or disable iSCSI-SCST ++ accept new connections to this target. It allows to finish ++ configuring it before it starts accepting new connections. 0 by ++ default. ++ ++ - redirect - allows to temporarily or permanently redirect login to the ++ target to another portal. Discovery sessions will not be impacted, ++ but normal sessions will be redirected before security negotiation. ++ The destination should be specified using format "<ip_addr>[:port] temp|perm". ++ IPv6 addresses need to be enclosed in [] brackets. To remove ++ redirection, provide an empty string. For example: ++ echo "10.170.77.2:32600 temp" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/redirect ++ will temporarily redirect login to portal 10.170.77.2 and port 32600. ++ ++ - tid - TID of this target. ++ ++Subdirectory "sessions" contains one subdirectory for each connected ++session with name equal to name of the connected initiator. ++ ++Each session subdirectory contains the following entries: ++ ++ - One subdirectory for each TCP connection in this session. ISCSI-SCST ++ supports 1 connection per session, but the session subdirectory can ++ contain several connections: one active and other being closed. ++ ++ - Entries defining negotiated iSCSI parameters. Only parameters which ++ can be changed or make sense are listed there. ++ ++ - initiator_name - contains initiator name ++ ++ - sid - contains SID of this session ++ ++ - reinstating - contains reinstatement state of this session ++ ++ - force_close - write-only attribute, which allows to force close this ++ session. This is the only writable session attribute. ++ ++ - active_commands - contains number of active, i.e. not yet or being ++ executed, SCSI commands in this session. ++ ++ - commands - contains overall number of SCSI commands in this session. ++ ++Each connection subdirectory contains the following entries: ++ ++ - cid - contains CID of this connection. ++ ++ - ip - contains IP address of the connected initiator. ++ ++ - state - contains processing state of this connection. ++ ++See SCST README for info about other attributes. ++ ++Below is a sample script, which configures 1 virtual disk "disk1" using ++/disk1 image and one target iqn.2006-10.net.vlnb:tgt with all default ++parameters: ++ ++#!/bin/bash ++ ++modprobe scst ++modprobe scst_vdisk ++ ++echo "add_device disk1 filename=/disk1; nv_cache=1" >/sys/kernel/scst_tgt/handlers/vdisk_fileio/mgmt ++ ++service iscsi-scst start ++ ++echo "add_target iqn.2006-10.net.vlnb:tgt" >/sys/kernel/scst_tgt/targets/iscsi/mgmt ++echo "add disk1 0" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/luns/mgmt ++ ++echo 1 >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/enabled ++echo 1 >/sys/kernel/scst_tgt/targets/iscsi/enabled ++ ++Below is another sample script, which configures 1 real local SCSI disk ++0:0:1:0 and one target iqn.2006-10.net.vlnb:tgt with all default parameters: ++ ++#!/bin/bash ++ ++modprobe scst ++modprobe scst_disk ++ ++echo "add_device 0:0:1:0" >/sys/kernel/scst_tgt/handlers/dev_disk/mgmt ++ ++service iscsi-scst start ++ ++echo "add_target iqn.2006-10.net.vlnb:tgt" >/sys/kernel/scst_tgt/targets/iscsi/mgmt ++echo "add 0:0:1:0 0" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/luns/mgmt ++ ++echo 1 >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/enabled ++echo 1 >/sys/kernel/scst_tgt/targets/iscsi/enabled ++ ++Below is an advanced sample script, which configures more virtual ++devices of various types, including virtual CDROM and 2 targets, one ++with all default parameters, another one with some not default ++parameters, incoming and outgoing user names for CHAP authentification, ++and special permissions for initiator iqn.2005-03.org.open-iscsi:cacdcd2520, ++which will see another set of devices. Also this sample configures CHAP ++authentication for discovery sessions and iSNS server with access ++control. ++ ++#!/bin/bash ++ ++modprobe scst ++modprobe scst_vdisk ++ ++echo "add_device disk1 filename=/disk1; nv_cache=1" >/sys/kernel/scst_tgt/handlers/vdisk_fileio/mgmt ++echo "add_device disk2 filename=/disk2; blocksize=4096; nv_cache=1" >/sys/kernel/scst_tgt/handlers/vdisk_fileio/mgmt ++echo "add_device blockio filename=/dev/sda5" >/sys/kernel/scst_tgt/handlers/vdisk_blockio/mgmt ++echo "add_device nullio" >/sys/kernel/scst_tgt/handlers/vdisk_nullio/mgmt ++echo "add_device cdrom" >/sys/kernel/scst_tgt/handlers/vcdrom/mgmt ++ ++service iscsi-scst start ++ ++echo "192.168.1.16 AccessControl" >/sys/kernel/scst_tgt/targets/iscsi/iSNSServer ++echo "add_attribute IncomingUser joeD 12charsecret" >/sys/kernel/scst_tgt/targets/iscsi/mgmt ++echo "add_attribute OutgoingUser jackD 12charsecret1" >/sys/kernel/scst_tgt/targets/iscsi/mgmt ++ ++echo "add_target iqn.2006-10.net.vlnb:tgt" >/sys/kernel/scst_tgt/targets/iscsi/mgmt ++ ++echo "add disk1 0" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/luns/mgmt ++echo "add cdrom 1" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/luns/mgmt ++ ++echo "add_target iqn.2006-10.net.vlnb:tgt1" >/sys/kernel/scst_tgt/targets/iscsi/mgmt ++echo "add_target_attribute iqn.2006-10.net.vlnb:tgt1 IncomingUser1 joe2 12charsecret2" >/sys/kernel/scst_tgt/targets/iscsi/mgmt ++echo "add_target_attribute iqn.2006-10.net.vlnb:tgt1 IncomingUser joe 12charsecret" >/sys/kernel/scst_tgt/targets/iscsi/mgmt ++echo "add_target_attribute iqn.2006-10.net.vlnb:tgt1 OutgoingUser jim1 12charpasswd" >/sys/kernel/scst_tgt/targets/iscsi/mgmt ++echo "No" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt1/InitialR2T ++echo "Yes" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt1/ImmediateData ++echo "8192" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt1/MaxRecvDataSegmentLength ++echo "8192" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt1/MaxXmitDataSegmentLength ++echo "131072" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt1/MaxBurstLength ++echo "32768" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt1/FirstBurstLength ++echo "1" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt1/MaxOutstandingR2T ++echo "CRC32C,None" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt1/HeaderDigest ++echo "CRC32C,None" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt1/DataDigest ++echo "32" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt1/QueuedCommands ++ ++echo "add disk2 0" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt1/luns/mgmt ++echo "add nullio 26" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt1/luns/mgmt ++ ++echo "create special_ini" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt1/ini_groups/mgmt ++echo "add blockio 0 read_only=1" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt1/ini_groups/special_ini/luns/mgmt ++echo "add iqn.2005-03.org.open-iscsi:cacdcd2520" >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt1/ini_groups/special_ini/initiators/mgmt ++ ++echo 1 >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/enabled ++echo 1 >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt1/enabled ++ ++echo 1 >/sys/kernel/scst_tgt/targets/iscsi/enabled ++ ++The resulting overall SCST sysfs hierarchy with an initiator connected to ++both iSCSI-SCST targets will look like: ++ ++/sys/kernel/scst_tgt ++|-- devices ++| |-- blockio ++| | |-- blocksize ++| | |-- exported ++| | | `-- export0 -> ../../../targets/iscsi/iqn.2006-10.net.vlnb:tgt1/ini_groups/special_ini/luns/0 ++| | |-- filename ++| | |-- handler -> ../../handlers/vdisk_blockio ++| | |-- nv_cache ++| | |-- read_only ++| | |-- removable ++| | |-- resync_size ++| | |-- size_mb ++| | |-- t10_dev_id ++| | |-- threads_num ++| | |-- threads_pool_type ++| | |-- type ++| | `-- usn ++| |-- cdrom ++| | |-- exported ++| | | `-- export0 -> ../../../targets/iscsi/iqn.2006-10.net.vlnb:tgt/luns/1 ++| | |-- filename ++| | |-- handler -> ../../handlers/vcdrom ++| | |-- size_mb ++| | |-- t10_dev_id ++| | |-- threads_num ++| | |-- threads_pool_type ++| | |-- type ++| | `-- usn ++| |-- disk1 ++| | |-- blocksize ++| | |-- exported ++| | | `-- export0 -> ../../../targets/iscsi/iqn.2006-10.net.vlnb:tgt/luns/0 ++| | |-- filename ++| | |-- handler -> ../../handlers/vdisk_fileio ++| | |-- nv_cache ++| | |-- o_direct ++| | |-- read_only ++| | |-- removable ++| | |-- resync_size ++| | |-- size_mb ++| | |-- t10_dev_id ++| | |-- type ++| | |-- usn ++| | `-- write_through ++| |-- disk2 ++| | |-- blocksize ++| | |-- exported ++| | | `-- export0 -> ../../../targets/iscsi/iqn.2006-10.net.vlnb:tgt1/luns/0 ++| | |-- filename ++| | |-- handler -> ../../handlers/vdisk_fileio ++| | |-- nv_cache ++| | |-- o_direct ++| | |-- read_only ++| | |-- removable ++| | |-- resync_size ++| | |-- size_mb ++| | |-- t10_dev_id ++| | |-- threads_num ++| | |-- threads_pool_type ++| | |-- threads_num ++| | |-- threads_pool_type ++| | |-- type ++| | |-- usn ++| | `-- write_through ++| `-- nullio ++| |-- blocksize ++| |-- exported ++| | `-- export0 -> ../../../targets/iscsi/iqn.2006-10.net.vlnb:tgt1/luns/26 ++| |-- handler -> ../../handlers/vdisk_nullio ++| |-- read_only ++| |-- removable ++| |-- size_mb ++| |-- t10_dev_id ++| |-- threads_num ++| |-- threads_pool_type ++| |-- type ++| `-- usn ++|-- handlers ++| |-- vcdrom ++| | |-- cdrom -> ../../devices/cdrom ++| | |-- mgmt ++| | |-- trace_level ++| | `-- type ++| |-- vdisk_blockio ++| | |-- blockio -> ../../devices/blockio ++| | |-- mgmt ++| | |-- trace_level ++| | `-- type ++| |-- vdisk_fileio ++| | |-- disk1 -> ../../devices/disk1 ++| | |-- disk2 -> ../../devices/disk2 ++| | |-- mgmt ++| | |-- trace_level ++| | `-- type ++| `-- vdisk_nullio ++| |-- mgmt ++| |-- nullio -> ../../devices/nullio ++| |-- trace_level ++| `-- type ++|-- sgv ++| |-- global_stats ++| |-- sgv ++| | `-- stats ++| |-- sgv-clust ++| | `-- stats ++| `-- sgv-dma ++| `-- stats ++|-- targets ++| `-- iscsi ++| |-- IncomingUser ++| |-- OutgoingUser ++| |-- enabled ++| |-- iSNSServer ++| |-- iqn.2006-10.net.vlnb:tgt ++| | |-- DataDigest ++| | |-- FirstBurstLength ++| | |-- HeaderDigest ++| | |-- ImmediateData ++| | |-- InitialR2T ++| | |-- MaxBurstLength ++| | |-- MaxOutstandingR2T ++| | |-- MaxRecvDataSegmentLength ++| | |-- MaxXmitDataSegmentLength ++| | |-- NopInInterval ++| | |-- QueuedCommands ++| | |-- RspTimeout ++| | |-- enabled ++| | |-- ini_groups ++| | | `-- mgmt ++| | |-- luns ++| | | |-- 0 ++| | | | |-- device -> ../../../../../devices/disk1 ++| | | | `-- read_only ++| | | |-- 1 ++| | | | |-- device -> ../../../../../devices/cdrom ++| | | | `-- read_only ++| | | `-- mgmt ++| | |-- per_portal_acl ++| | |-- redirect ++| | |-- rel_tgt_id ++| | |-- sessions ++| | | `-- iqn.2005-03.org.open-iscsi:cacdcd2520 ++| | | |-- 10.170.75.2 ++| | | | |-- cid ++| | | | |-- ip ++| | | | `-- state ++| | | |-- DataDigest ++| | | |-- FirstBurstLength ++| | | |-- HeaderDigest ++| | | |-- ImmediateData ++| | | |-- InitialR2T ++| | | |-- MaxBurstLength ++| | | |-- MaxOutstandingR2T ++| | | |-- MaxRecvDataSegmentLength ++| | | |-- MaxXmitDataSegmentLength ++| | | |-- active_commands ++| | | |-- commands ++| | | |-- force_close ++| | | |-- initiator_name ++| | | |-- luns -> ../../luns ++| | | |-- reinstating ++| | | `-- sid ++| | `-- tid ++| |-- iqn.2006-10.net.vlnb:tgt1 ++| | |-- DataDigest ++| | |-- FirstBurstLength ++| | |-- HeaderDigest ++| | |-- ImmediateData ++| | |-- IncomingUser ++| | |-- IncomingUser1 ++| | |-- InitialR2T ++| | |-- MaxBurstLength ++| | |-- MaxOutstandingR2T ++| | |-- MaxRecvDataSegmentLength ++| | |-- MaxXmitDataSegmentLength ++| | |-- OutgoingUser ++| | |-- NopInInterval ++| | |-- QueuedCommands ++| | |-- RspTimeout ++| | |-- enabled ++| | |-- ini_groups ++| | | |-- mgmt ++| | | `-- special_ini ++| | | |-- initiators ++| | | | |-- iqn.2005-03.org.open-iscsi:cacdcd2520 ++| | | | `-- mgmt ++| | | `-- luns ++| | | |-- 0 ++| | | | |-- device -> ../../../../../../../devices/blockio ++| | | | `-- read_only ++| | | `-- mgmt ++| | |-- luns ++| | | |-- 0 ++| | | | |-- device -> ../../../../../devices/disk2 ++| | | | `-- read_only ++| | | |-- 26 ++| | | | |-- device -> ../../../../../devices/nullio ++| | | | `-- read_only ++| | | `-- mgmt ++| | |-- per_portal_acl ++| | |-- redirect ++| | |-- rel_tgt_id ++| | |-- sessions ++| | | `-- iqn.2005-03.org.open-iscsi:cacdcd2520 ++| | | |-- 10.170.75.2 ++| | | | |-- cid ++| | | | |-- ip ++| | | | `-- state ++| | | |-- DataDigest ++| | | |-- FirstBurstLength ++| | | |-- HeaderDigest ++| | | |-- ImmediateData ++| | | |-- InitialR2T ++| | | |-- MaxBurstLength ++| | | |-- MaxOutstandingR2T ++| | | |-- MaxRecvDataSegmentLength ++| | | |-- MaxXmitDataSegmentLength ++| | | |-- active_commands ++| | | |-- commands ++| | | |-- force_close ++| | | |-- initiator_name ++| | | |-- luns -> ../../ini_groups/special_ini/luns ++| | | |-- reinstating ++| | | `-- sid ++| | `-- tid ++| |-- mgmt ++| |-- open_state ++| |-- trace_level ++| `-- version ++|-- threads ++|-- trace_level ++`-- version ++ ++ ++Advanced initiators access control ++---------------------------------- ++ ++ISCSI-SCST allows you to optionally control visibility and accessibility ++of your target and its portals (IP addresses) to remote initiators. This ++control includes both the target's portals SendTargets discovery as well ++as regular LUNs access. ++ ++This facility supersedes the obsolete initiators.[allow,deny] method, ++which is going to be removed in one of the future versions. ++ ++This facility is available only in the sysfs build of iSCSI-SCST. ++ ++By default, all portals are available for the initiators. ++ ++1. If you want to enable/disable one or more target's portals for all ++initiators, you should define one ore more allowed_portal attributes. ++For example: ++ ++echo 'add_target_attribute iqn.2006-10.net.vlnb:tgt allowed_portal 10.170.77.2' >/sys/kernel/scst_tgt/targets/iscsi/mgmt ++ ++will enable only portal 10.170.77.2 and disable all other portals ++ ++echo 'add_target_attribute iqn.2006-10.net.vlnb:tgt allowed_portal 10.170.77.2' >/sys/kernel/scst_tgt/targets/iscsi/mgmt ++echo 'add_target_attribute iqn.2006-10.net.vlnb:tgt allowed_portal 10.170.75.2' >/sys/kernel/scst_tgt/targets/iscsi/mgmt ++ ++will enable only portals 10.170.77.2 and 10.170.75.2 and disable all ++other portals. ++ ++echo 'add_target_attribute iqn.2006-10.net.vlnb:tgt allowed_portal 10.170.7?.2' >/sys/kernel/scst_tgt/targets/iscsi/mgmt ++ ++will enable only portals 10.170.7x.2 and disable all other portals. ++ ++echo 'add_target_attribute iqn.2006-10.net.vlnb:tgt allowed_portal !*' >/sys/kernel/scst_tgt/targets/iscsi/mgmt ++ ++will disable all portals. ++ ++2. If you want to want to allow only only specific set of initiators be ++able to connect to your target, you should don't add any default LUNs ++for the target and create for allowed initiators a security group to ++which they will be assigned. ++ ++For example, we want initiator iqn.2005-03.org.vlnb:cacdcd2520 and only ++it be able to access target iqn.2006-10.net.vlnb:tgt: ++ ++echo 'add_target iqn.2006-10.net.vlnb:tgt' >/sys/kernel/scst_tgt/targets/iscsi/mgmt ++echo 'create allowed_ini' >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/ini_groups/mgmt ++echo 'add dev1 0' >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/ini_groups/allowed_ini/luns/mgmt ++echo 'add iqn.2005-03.org.vlnb:cacdcd2520' >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/ini_groups/allowed_ini/initiators/mgmt ++echo 1 >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/enabled ++ ++Since there will be no default LUNs for the target, all initiators other ++than iqn.2005-03.org.vlnb:cacdcd2520 will be blocked from accessing it. ++ ++Alternatively, you can create an empty security group and filter out in ++it all initiators except the allowed one: ++ ++echo 'add_target iqn.2006-10.net.vlnb:tgt' >/sys/kernel/scst_tgt/targets/iscsi/mgmt ++echo 'add dev1 0' >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/luns/mgmt ++echo 'create denied_inis' >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/ini_groups/mgmt ++echo 'add !iqn.2005-03.org.vlnb:cacdcd2520' >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/ini_groups/denied_inis/initiators/mgmt ++echo 1 >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/enabled ++ ++3. If you want to enable/disable one or more target's portals for ++particular initiators, you should set per_portal_acl attribute to 1 and ++specify SCST access control to those initiators. If an SCST security ++group doesn't have any LUNs, all the initiator, which should be assigned ++to it, will not see this target and/or its portal. For example: ++ ++(We assume that an empty group "BLOCKING_GROUP" is already created by for ++target iqn.2006-10.net.vlnb:tgt by command (see above for more information): ++"echo 'create BLOCKING_GROUP' >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/ini_groups/mgmt) ++ ++echo 'add iqn.2005-03.org.vlnb:cacdcd2520#10.170.77.2' >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/ini_groups/BLOCKING_GROUP/initiators/mgmt ++ ++will block access of initiator iqn.2005-03.org.vlnb:cacdcd2520 to ++target iqn.2006-10.net.vlnb:tgt portal 10.170.77.2. ++ ++Another example: ++ ++echo 'add iqn.2005-03.org.vlnb:cacdcd2520*' >/sys/kernel/scst_tgt/targets/iscsi/iqn.2006-10.net.vlnb:tgt/ini_groups/BLOCKING_GROUP/initiators/mgmt ++ ++will block access of initiator iqn.2005-03.org.vlnb:cacdcd2520 to ++all target iqn.2006-10.net.vlnb:tgt portals. ++ ++ ++Troubleshooting ++--------------- ++ ++If you have any problems, start troubleshooting from looking at the ++kernel and system logs. In the kernel log iSCSI-SCST and SCST core send ++their messages, in the system log iscsi-scstd sends its messages. In ++most Linux distributions both those logs are put to /var/log/messages ++file. ++ ++Then, it might be helpful to increase level of logging. For kernel ++modules you should make the debug build by enabling CONFIG_SCST_DEBUG. ++ ++If after looking on the logs the reason of your problem is still unclear ++for you, report to SCST mailing list scst-devel@lists.sourceforge.net. ++ ++ ++Work if target's backstorage or link is too slow ++------------------------------------------------ ++ ++In some cases you can experience I/O stalls or see in the kernel log ++abort or reset messages. It can happen under high I/O load, when your ++target's backstorage gets overloaded, or working over a slow link, when ++the link can't serve all the queued commands on time, ++ ++To workaround it you can reduce QueuedCommands parameter for the ++corresponding target to some lower value, like 8 (default is 32). ++ ++Also see SCST README file for more details about that issue and ways to ++prevent it. ++ ++ ++Performance advices ++------------------- ++ ++1. If you use Windows XP or Windows 2003+ as initiators, you can ++consider to decrease TcpAckFrequency parameter to 1. See ++http://support.microsoft.com/kb/328890/ or google for "TcpAckFrequency" ++for more details. ++ ++2. See how to get the maximum throughput from iSCSI, for instance, at ++http://virtualgeek.typepad.com/virtual_geek/2009/01/a-multivendor-post-to-help-our-mutual-iscsi-customers-using-vmware.html. ++It's about VMware, but its recommendations apply to other environments ++as well. ++ ++3. ISCSI initiators built in pre-CentOS/RHEL 5 reported to have some ++performance problems. If you use it, it is strongly advised to upgrade. ++ ++4. If you are going to use your target in an VM environment, for ++instance as a shared storage with VMware, make sure all your VMs ++connected to the target via *separate* sessions, i.e. each VM has own ++connection to the target, not all VMs connected using a single ++connection. You can check it using SCST sysfs interface. If you ++miss it, you can greatly loose performance of parallel access to your ++target from different VMs. This isn't related to the case if your VMs ++are using the same shared storage, like with VMFS, for instance. In this ++case all your VM hosts will be connected to the target via separate ++sessions, which is enough. ++ ++5. Many dual port network adapters are not able to transfer data ++simultaneously on both ports, i.e. they transfer data via both ports on ++the same speed as via any single port. Thus, using such adapters in MPIO ++configuration can't improve performance. To allow MPIO to have double ++performance you should either use separate network adapters, or find a ++dual-port adapter capable to to transfer data simultaneously on both ++ports. You can check it by running 2 iperf's through both ports in ++parallel. ++ ++6. Since network offload works much better in the write direction, than ++for reading (simplifying, in the read direction often there's additional ++data copy) in many cases with 10GbE in a single initiator-target pair ++the initiator's CPU is a bottleneck, so you can see the initiator can ++read data on much slower rate, than write. You can check it by watching ++*each particular* CPU load to find out if any of them is close to 100% ++load, including IRQ processing load. Note, many tools like vmstat give ++aggregate load on all CPUs, so with 4 cores 25% corresponds to 100% load ++of any single CPU. ++ ++7. For high speed network adapters it can be better if you configure ++them to serve connections, e.g., from initiator on CPU0 and from ++initiator Y on CPU1. Then you can bind threads processing them also to ++CPU0 and CPU1 correspondingly using cpu_mask attribute of their targets ++or security groups. In NUMA-like configurations it can signficantly ++boost IOPS performance. ++ ++8. See SCST core's README for more advices. Especially pay attention to ++have io_grouping_type option set correctly. ++ ++ ++Compilation options ++------------------- ++ ++There are the following compilation options, that could be commented ++in/out in the kernel's module Makefile: ++ ++ - CONFIG_SCST_DEBUG - turns on some debugging code, including some logging. ++ Makes the driver considerably bigger and slower, producing large amount of ++ log data. ++ ++ - CONFIG_SCST_TRACING - turns on ability to log events. Makes the driver ++ considerably bigger and leads to some performance loss. ++ ++ - CONFIG_SCST_EXTRACHECKS - adds extra validity checks in the various places. ++ ++ - CONFIG_SCST_ISCSI_DEBUG_DIGEST_FAILURES - simulates digest failures in ++ random places. ++ ++ ++Credits ++------- ++ ++Thanks to: ++ ++ * Ming Zhang <blackmagic02881@gmail.com> for fixes ++ ++ * Krzysztof Blaszkowski <kb@sysmikro.com.pl> for many fixes ++ ++ * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru> for comments and help in ++ debugging ++ ++ * Tomasz Chmielewski <mangoo@wpkg.org> for testing and suggestions ++ ++ * Bart Van Assche <bvanassche@acm.org> for a lot of help ++ ++Vladislav Bolkhovitin <vst@vlnb.net>, http://scst.sourceforge.net ++ +diff -uprN orig/linux-3.2/drivers/scsi/qla2xxx/qla2x_tgt.h linux-3.2/drivers/scsi/qla2xxx/qla2x_tgt.h +--- orig/linux-3.2/drivers/scsi/qla2xxx/qla2x_tgt.h ++++ linux-3.2/drivers/scsi/qla2xxx/qla2x_tgt.h +@@ -0,0 +1,137 @@ ++/* ++ * qla2x_tgt.h ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2006 Nathaniel Clark <nate@misrule.us> ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * Additional file for the target driver support. ++ * ++ * 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. ++ */ ++/* ++ * This should be included only from within qla2xxx module. ++ */ ++ ++#ifndef __QLA2X_TGT_H ++#define __QLA2X_TGT_H ++ ++#include <linux/version.h> ++ ++extern request_t *qla2x00_req_pkt(scsi_qla_host_t *ha); ++ ++#ifdef CONFIG_SCSI_QLA2XXX_TARGET ++ ++#include "qla2x_tgt_def.h" ++ ++extern struct qla_tgt_data qla_target; ++ ++void qla_set_tgt_mode(scsi_qla_host_t *ha); ++void qla_clear_tgt_mode(scsi_qla_host_t *ha); ++ ++static inline bool qla_tgt_mode_enabled(scsi_qla_host_t *ha) ++{ ++ return ha->host->active_mode & MODE_TARGET; ++} ++ ++static inline bool qla_ini_mode_enabled(scsi_qla_host_t *ha) ++{ ++ return ha->host->active_mode & MODE_INITIATOR; ++} ++ ++static inline void qla_reverse_ini_mode(scsi_qla_host_t *ha) ++{ ++ if (ha->host->active_mode & MODE_INITIATOR) ++ ha->host->active_mode &= ~MODE_INITIATOR; ++ else ++ ha->host->active_mode |= MODE_INITIATOR; ++} ++ ++/********************************************************************\ ++ * ISP Queue types left out of new QLogic driver (from old version) ++\********************************************************************/ ++ ++/* ++ * qla2x00_do_en_dis_lun ++ * Issue enable or disable LUN entry IOCB. ++ * ++ * Input: ++ * ha = adapter block pointer. ++ * ++ * Caller MUST have hardware lock held. This function might release it, ++ * then reacquire. ++ */ ++static inline void ++__qla2x00_send_enable_lun(scsi_qla_host_t *ha, int enable) ++{ ++ elun_entry_t *pkt; ++ ++ BUG_ON(IS_FWI2_CAPABLE(ha)); ++ ++ pkt = (elun_entry_t *)qla2x00_req_pkt(ha); ++ if (pkt != NULL) { ++ pkt->entry_type = ENABLE_LUN_TYPE; ++ if (enable) { ++ pkt->command_count = QLA2X00_COMMAND_COUNT_INIT; ++ pkt->immed_notify_count = QLA2X00_IMMED_NOTIFY_COUNT_INIT; ++ pkt->timeout = 0xffff; ++ } else { ++ pkt->command_count = 0; ++ pkt->immed_notify_count = 0; ++ pkt->timeout = 0; ++ } ++ DEBUG2(printk(KERN_DEBUG ++ "scsi%lu:ENABLE_LUN IOCB imm %u cmd %u timeout %u\n", ++ ha->host_no, pkt->immed_notify_count, ++ pkt->command_count, pkt->timeout)); ++ ++ /* Issue command to ISP */ ++ qla2x00_isp_cmd(ha); ++ ++ } else ++ qla_clear_tgt_mode(ha); ++#if defined(QL_DEBUG_LEVEL_2) || defined(QL_DEBUG_LEVEL_3) ++ if (!pkt) ++ printk(KERN_ERR "%s: **** FAILED ****\n", __func__); ++#endif ++ ++ return; ++} ++ ++/* ++ * qla2x00_send_enable_lun ++ * Issue enable LUN entry IOCB. ++ * ++ * Input: ++ * ha = adapter block pointer. ++ * enable = enable/disable flag. ++ */ ++static inline void ++qla2x00_send_enable_lun(scsi_qla_host_t *ha, bool enable) ++{ ++ if (!IS_FWI2_CAPABLE(ha)) { ++ unsigned long flags; ++ spin_lock_irqsave(&ha->hardware_lock, flags); ++ __qla2x00_send_enable_lun(ha, enable); ++ spin_unlock_irqrestore(&ha->hardware_lock, flags); ++ } ++} ++ ++extern void qla2xxx_add_targets(void); ++extern size_t ++qla2xxx_add_vtarget(u64 *port_name, u64 *node_name, u64 *parent_host); ++extern size_t qla2xxx_del_vtarget(u64 *port_name); ++ ++#endif /* CONFIG_SCSI_QLA2XXX_TARGET */ ++ ++#endif /* __QLA2X_TGT_H */ +diff -uprN orig/linux-3.2/drivers/scsi/qla2xxx/qla2x_tgt_def.h linux-3.2/drivers/scsi/qla2xxx/qla2x_tgt_def.h +--- orig/linux-3.2/drivers/scsi/qla2xxx/qla2x_tgt_def.h ++++ linux-3.2/drivers/scsi/qla2xxx/qla2x_tgt_def.h +@@ -0,0 +1,771 @@ ++/* ++ * qla2x_tgt_def.h ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2006 Nathaniel Clark <nate@misrule.us> ++ * Copyright (C) 2007 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * Additional file for the target driver support. ++ * ++ * 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. ++ */ ++/* ++ * This is the global def file that is useful for including from the ++ * target portion. ++ */ ++ ++#ifndef __QLA2X_TGT_DEF_H ++#define __QLA2X_TGT_DEF_H ++ ++#include "qla_def.h" ++ ++#ifndef CONFIG_SCSI_QLA2XXX_TARGET ++#error __FILE__ " included without CONFIG_SCSI_QLA2XXX_TARGET" ++#endif ++ ++#ifndef ENTER ++#define ENTER(a) ++#endif ++ ++#ifndef LEAVE ++#define LEAVE(a) ++#endif ++ ++/* ++ * Must be changed on any change in any initiator visible interfaces or ++ * data in the target add-on ++ */ ++#define QLA2X_TARGET_MAGIC 270 ++ ++/* ++ * Must be changed on any change in any target visible interfaces or ++ * data in the initiator ++ */ ++#define QLA2X_INITIATOR_MAGIC 57224 ++ ++#define QLA2X_INI_MODE_STR_EXCLUSIVE "exclusive" ++#define QLA2X_INI_MODE_STR_DISABLED "disabled" ++#define QLA2X_INI_MODE_STR_ENABLED "enabled" ++ ++#define QLA2X_INI_MODE_EXCLUSIVE 0 ++#define QLA2X_INI_MODE_DISABLED 1 ++#define QLA2X_INI_MODE_ENABLED 2 ++ ++#define QLA2X00_COMMAND_COUNT_INIT 250 ++#define QLA2X00_IMMED_NOTIFY_COUNT_INIT 250 ++ ++/* ++ * Used to mark which completion handles (for RIO Status's) are for CTIO's ++ * vs. regular (non-target) info. This is checked for in ++ * qla2x00_process_response_queue() to see if a handle coming back in a ++ * multi-complete should come to the tgt driver or be handled there by qla2xxx ++ */ ++#define CTIO_COMPLETION_HANDLE_MARK BIT_29 ++#if (CTIO_COMPLETION_HANDLE_MARK <= MAX_OUTSTANDING_COMMANDS) ++#error "Hackish CTIO_COMPLETION_HANDLE_MARK no longer larger than MAX_OUTSTANDING_COMMANDS" ++#endif ++#define HANDLE_IS_CTIO_COMP(h) (h & CTIO_COMPLETION_HANDLE_MARK) ++ ++/* Used to mark CTIO as intermediate */ ++#define CTIO_INTERMEDIATE_HANDLE_MARK BIT_30 ++ ++#ifndef OF_SS_MODE_0 ++/* ++ * ISP target entries - Flags bit definitions. ++ */ ++#define OF_SS_MODE_0 0 ++#define OF_SS_MODE_1 1 ++#define OF_SS_MODE_2 2 ++#define OF_SS_MODE_3 3 ++ ++#define OF_EXPL_CONF BIT_5 /* Explicit Confirmation Requested */ ++#define OF_DATA_IN BIT_6 /* Data in to initiator */ ++ /* (data from target to initiator) */ ++#define OF_DATA_OUT BIT_7 /* Data out from initiator */ ++ /* (data from initiator to target) */ ++#define OF_NO_DATA (BIT_7 | BIT_6) ++#define OF_INC_RC BIT_8 /* Increment command resource count */ ++#define OF_FAST_POST BIT_9 /* Enable mailbox fast posting. */ ++#define OF_CONF_REQ BIT_13 /* Confirmation Requested */ ++#define OF_TERM_EXCH BIT_14 /* Terminate exchange */ ++#define OF_SSTS BIT_15 /* Send SCSI status */ ++#endif ++ ++#ifndef DATASEGS_PER_COMMAND32 ++#define DATASEGS_PER_COMMAND32 3 ++#define DATASEGS_PER_CONT32 7 ++#define QLA_MAX_SG32(ql) \ ++ (((ql) > 0) ? \ ++ (DATASEGS_PER_COMMAND32 + DATASEGS_PER_CONT32 * ((ql) - 1)) : 0) ++ ++#define DATASEGS_PER_COMMAND64 2 ++#define DATASEGS_PER_CONT64 5 ++#define QLA_MAX_SG64(ql) \ ++ (((ql) > 0) ? \ ++ (DATASEGS_PER_COMMAND64 + DATASEGS_PER_CONT64 * ((ql) - 1)) : 0) ++#endif ++ ++#ifndef DATASEGS_PER_COMMAND_24XX ++#define DATASEGS_PER_COMMAND_24XX 1 ++#define DATASEGS_PER_CONT_24XX 5 ++#define QLA_MAX_SG_24XX(ql) \ ++ (min(1270, ((ql) > 0) ? \ ++ (DATASEGS_PER_COMMAND_24XX + DATASEGS_PER_CONT_24XX * ((ql) - 1)) : 0)) ++#endif ++ ++/********************************************************************\ ++ * ISP Queue types left out of new QLogic driver (from old version) ++\********************************************************************/ ++ ++#ifndef ENABLE_LUN_TYPE ++#define ENABLE_LUN_TYPE 0x0B /* Enable LUN entry. */ ++/* ++ * ISP queue - enable LUN entry structure definition. ++ */ ++typedef struct { ++ uint8_t entry_type; /* Entry type. */ ++ uint8_t entry_count; /* Entry count. */ ++ uint8_t sys_define; /* System defined. */ ++ uint8_t entry_status; /* Entry Status. */ ++ uint32_t sys_define_2; /* System defined. */ ++ uint8_t reserved_8; ++ uint8_t reserved_1; ++ uint16_t reserved_2; ++ uint32_t reserved_3; ++ uint8_t status; ++ uint8_t reserved_4; ++ uint8_t command_count; /* Number of ATIOs allocated. */ ++ uint8_t immed_notify_count; /* Number of Immediate Notify entries allocated. */ ++ uint16_t reserved_5; ++ uint16_t timeout; /* 0 = 30 seconds, 0xFFFF = disable */ ++ uint16_t reserved_6[20]; ++} __attribute__((packed)) elun_entry_t; ++#define ENABLE_LUN_SUCCESS 0x01 ++#define ENABLE_LUN_RC_NONZERO 0x04 ++#define ENABLE_LUN_INVALID_REQUEST 0x06 ++#define ENABLE_LUN_ALREADY_ENABLED 0x3E ++#endif ++ ++#ifndef MODIFY_LUN_TYPE ++#define MODIFY_LUN_TYPE 0x0C /* Modify LUN entry. */ ++/* ++ * ISP queue - modify LUN entry structure definition. ++ */ ++typedef struct { ++ uint8_t entry_type; /* Entry type. */ ++ uint8_t entry_count; /* Entry count. */ ++ uint8_t sys_define; /* System defined. */ ++ uint8_t entry_status; /* Entry Status. */ ++ uint32_t sys_define_2; /* System defined. */ ++ uint8_t reserved_8; ++ uint8_t reserved_1; ++ uint8_t operators; ++ uint8_t reserved_2; ++ uint32_t reserved_3; ++ uint8_t status; ++ uint8_t reserved_4; ++ uint8_t command_count; /* Number of ATIOs allocated. */ ++ uint8_t immed_notify_count; /* Number of Immediate Notify */ ++ /* entries allocated. */ ++ uint16_t reserved_5; ++ uint16_t timeout; /* 0 = 30 seconds, 0xFFFF = disable */ ++ uint16_t reserved_7[20]; ++} __attribute__((packed)) modify_lun_entry_t; ++#define MODIFY_LUN_SUCCESS 0x01 ++#define MODIFY_LUN_CMD_ADD BIT_0 ++#define MODIFY_LUN_CMD_SUB BIT_1 ++#define MODIFY_LUN_IMM_ADD BIT_2 ++#define MODIFY_LUN_IMM_SUB BIT_3 ++#endif ++ ++#define GET_TARGET_ID(ha, iocb) ((HAS_EXTENDED_IDS(ha)) \ ++ ? le16_to_cpu((iocb)->target.extended) \ ++ : (uint16_t)(iocb)->target.id.standard) ++ ++#ifndef IMMED_NOTIFY_TYPE ++#define IMMED_NOTIFY_TYPE 0x0D /* Immediate notify entry. */ ++/* ++ * ISP queue - immediate notify entry structure definition. ++ */ ++typedef struct { ++ uint8_t entry_type; /* Entry type. */ ++ uint8_t entry_count; /* Entry count. */ ++ uint8_t sys_define; /* System defined. */ ++ uint8_t entry_status; /* Entry Status. */ ++ uint32_t sys_define_2; /* System defined. */ ++ target_id_t target; ++ uint16_t lun; ++ uint8_t target_id; ++ uint8_t reserved_1; ++ uint16_t status_modifier; ++ uint16_t status; ++ uint16_t task_flags; ++ uint16_t seq_id; ++ uint16_t srr_rx_id; ++ uint32_t srr_rel_offs; ++ uint16_t srr_ui; ++#define SRR_IU_DATA_IN 0x1 ++#define SRR_IU_DATA_OUT 0x5 ++#define SRR_IU_STATUS 0x7 ++ uint16_t srr_ox_id; ++ uint8_t reserved_2[30]; ++ uint16_t ox_id; ++} __attribute__((packed)) notify_entry_t; ++#endif ++ ++#ifndef NOTIFY_ACK_TYPE ++#define NOTIFY_ACK_TYPE 0x0E /* Notify acknowledge entry. */ ++/* ++ * ISP queue - notify acknowledge entry structure definition. ++ */ ++typedef struct { ++ uint8_t entry_type; /* Entry type. */ ++ uint8_t entry_count; /* Entry count. */ ++ uint8_t sys_define; /* System defined. */ ++ uint8_t entry_status; /* Entry Status. */ ++ uint32_t sys_define_2; /* System defined. */ ++ target_id_t target; ++ uint8_t target_id; ++ uint8_t reserved_1; ++ uint16_t flags; ++ uint16_t resp_code; ++ uint16_t status; ++ uint16_t task_flags; ++ uint16_t seq_id; ++ uint16_t srr_rx_id; ++ uint32_t srr_rel_offs; ++ uint16_t srr_ui; ++ uint16_t srr_flags; ++ uint16_t srr_reject_code; ++ uint8_t srr_reject_vendor_uniq; ++ uint8_t srr_reject_code_expl; ++ uint8_t reserved_2[26]; ++ uint16_t ox_id; ++} __attribute__((packed)) nack_entry_t; ++#define NOTIFY_ACK_SRR_FLAGS_ACCEPT 0 ++#define NOTIFY_ACK_SRR_FLAGS_REJECT 1 ++ ++#define NOTIFY_ACK_SRR_REJECT_REASON_UNABLE_TO_PERFORM 0x9 ++ ++#define NOTIFY_ACK_SRR_FLAGS_REJECT_EXPL_NO_EXPL 0 ++#define NOTIFY_ACK_SRR_FLAGS_REJECT_EXPL_UNABLE_TO_SUPPLY_DATA 0x2a ++ ++#define NOTIFY_ACK_SUCCESS 0x01 ++#endif ++ ++#ifndef ACCEPT_TGT_IO_TYPE ++#define ACCEPT_TGT_IO_TYPE 0x16 /* Accept target I/O entry. */ ++/* ++ * ISP queue - Accept Target I/O (ATIO) entry structure definition. ++ */ ++typedef struct { ++ uint8_t entry_type; /* Entry type. */ ++ uint8_t entry_count; /* Entry count. */ ++ uint8_t sys_define; /* System defined. */ ++ uint8_t entry_status; /* Entry Status. */ ++ uint32_t sys_define_2; /* System defined. */ ++ target_id_t target; ++ uint16_t rx_id; ++ uint16_t flags; ++ uint16_t status; ++ uint8_t command_ref; ++ uint8_t task_codes; ++ uint8_t task_flags; ++ uint8_t execution_codes; ++ uint8_t cdb[MAX_CMDSZ]; ++ uint32_t data_length; ++ uint16_t lun; ++ uint8_t initiator_port_name[WWN_SIZE]; /* on qla23xx */ ++ uint16_t reserved_32[6]; ++ uint16_t ox_id; ++} __attribute__((packed)) atio_entry_t; ++#endif ++ ++#ifndef CONTINUE_TGT_IO_TYPE ++#define CONTINUE_TGT_IO_TYPE 0x17 ++/* ++ * ISP queue - Continue Target I/O (CTIO) entry for status mode 0 ++ * structure definition. ++ */ ++typedef struct { ++ uint8_t entry_type; /* Entry type. */ ++ uint8_t entry_count; /* Entry count. */ ++ uint8_t sys_define; /* System defined. */ ++ uint8_t entry_status; /* Entry Status. */ ++ uint32_t handle; /* System defined handle */ ++ target_id_t target; ++ uint16_t rx_id; ++ uint16_t flags; ++ uint16_t status; ++ uint16_t timeout; /* 0 = 30 seconds, 0xFFFF = disable */ ++ uint16_t dseg_count; /* Data segment count. */ ++ uint32_t relative_offset; ++ uint32_t residual; ++ uint16_t reserved_1[3]; ++ uint16_t scsi_status; ++ uint32_t transfer_length; ++ uint32_t dseg_0_address[0]; ++} __attribute__((packed)) ctio_common_entry_t; ++#define ATIO_PATH_INVALID 0x07 ++#define ATIO_CANT_PROV_CAP 0x16 ++#define ATIO_CDB_VALID 0x3D ++ ++#define ATIO_EXEC_READ BIT_1 ++#define ATIO_EXEC_WRITE BIT_0 ++#endif ++ ++#ifndef CTIO_A64_TYPE ++#define CTIO_A64_TYPE 0x1F ++typedef struct { ++ ctio_common_entry_t common; ++ uint32_t dseg_0_address; /* Data segment 0 address. */ ++ uint32_t dseg_0_length; /* Data segment 0 length. */ ++ uint32_t dseg_1_address; /* Data segment 1 address. */ ++ uint32_t dseg_1_length; /* Data segment 1 length. */ ++ uint32_t dseg_2_address; /* Data segment 2 address. */ ++ uint32_t dseg_2_length; /* Data segment 2 length. */ ++} __attribute__((packed)) ctio_entry_t; ++#define CTIO_SUCCESS 0x01 ++#define CTIO_ABORTED 0x02 ++#define CTIO_INVALID_RX_ID 0x08 ++#define CTIO_TIMEOUT 0x0B ++#define CTIO_LIP_RESET 0x0E ++#define CTIO_TARGET_RESET 0x17 ++#define CTIO_PORT_UNAVAILABLE 0x28 ++#define CTIO_PORT_LOGGED_OUT 0x29 ++#define CTIO_PORT_CONF_CHANGED 0x2A ++#define CTIO_SRR_RECEIVED 0x45 ++ ++#endif ++ ++#ifndef CTIO_RET_TYPE ++#define CTIO_RET_TYPE 0x17 /* CTIO return entry */ ++/* ++ * ISP queue - CTIO returned entry structure definition. ++ */ ++typedef struct { ++ uint8_t entry_type; /* Entry type. */ ++ uint8_t entry_count; /* Entry count. */ ++ uint8_t sys_define; /* System defined. */ ++ uint8_t entry_status; /* Entry Status. */ ++ uint32_t handle; /* System defined handle. */ ++ target_id_t target; ++ uint16_t rx_id; ++ uint16_t flags; ++ uint16_t status; ++ uint16_t timeout; /* 0 = 30 seconds, 0xFFFF = disable */ ++ uint16_t dseg_count; /* Data segment count. */ ++ uint32_t relative_offset; ++ uint32_t residual; ++ uint16_t reserved_1[2]; ++ uint16_t sense_length; ++ uint16_t scsi_status; ++ uint16_t response_length; ++ uint8_t sense_data[26]; ++} __attribute__((packed)) ctio_ret_entry_t; ++#endif ++ ++#define ATIO_TYPE7 0x06 /* Accept target I/O entry for 24xx */ ++ ++typedef struct { ++ uint8_t r_ctl; ++ uint8_t d_id[3]; ++ uint8_t cs_ctl; ++ uint8_t s_id[3]; ++ uint8_t type; ++ uint8_t f_ctl[3]; ++ uint8_t seq_id; ++ uint8_t df_ctl; ++ uint16_t seq_cnt; ++ uint16_t ox_id; ++ uint16_t rx_id; ++ uint32_t parameter; ++} __attribute__((packed)) fcp_hdr_t; ++ ++typedef struct { ++ uint8_t d_id[3]; ++ uint8_t r_ctl; ++ uint8_t s_id[3]; ++ uint8_t cs_ctl; ++ uint8_t f_ctl[3]; ++ uint8_t type; ++ uint16_t seq_cnt; ++ uint8_t df_ctl; ++ uint8_t seq_id; ++ uint16_t rx_id; ++ uint16_t ox_id; ++ uint32_t parameter; ++} __attribute__((packed)) fcp_hdr_le_t; ++ ++#define F_CTL_EXCH_CONTEXT_RESP BIT_23 ++#define F_CTL_SEQ_CONTEXT_RESIP BIT_22 ++#define F_CTL_LAST_SEQ BIT_20 ++#define F_CTL_END_SEQ BIT_19 ++#define F_CTL_SEQ_INITIATIVE BIT_16 ++ ++#define R_CTL_BASIC_LINK_SERV 0x80 ++#define R_CTL_B_ACC 0x4 ++#define R_CTL_B_RJT 0x5 ++ ++typedef struct { ++ uint64_t lun; ++ uint8_t cmnd_ref; ++#ifdef __LITTLE_ENDIAN ++ uint8_t task_attr:3; ++ uint8_t reserved:5; ++#else ++ uint8_t reserved:5; ++ uint8_t task_attr:3; ++#endif ++ uint8_t task_mgmt_flags; ++#define FCP_CMND_TASK_MGMT_CLEAR_ACA 6 ++#define FCP_CMND_TASK_MGMT_TARGET_RESET 5 ++#define FCP_CMND_TASK_MGMT_LU_RESET 4 ++#define FCP_CMND_TASK_MGMT_CLEAR_TASK_SET 2 ++#define FCP_CMND_TASK_MGMT_ABORT_TASK_SET 1 ++#ifdef __LITTLE_ENDIAN ++ uint8_t wrdata:1; ++ uint8_t rddata:1; ++ uint8_t add_cdb_len:6; ++#else ++ uint8_t add_cdb_len:6; ++ uint8_t rddata:1; ++ uint8_t wrdata:1; ++#endif ++ uint8_t cdb[16]; ++ /* ++ * add_cdb is optional and can absent from fcp_cmnd_t. Size 4 only to ++ * make sizeof(fcp_cmnd_t) be as expected by BUILD_BUG_ON() in ++ * q2t_init(). ++ */ ++ uint8_t add_cdb[4]; ++ /* uint32_t data_length; */ ++} __attribute__((packed)) fcp_cmnd_t; ++ ++/* ++ * ISP queue - Accept Target I/O (ATIO) type 7 entry for 24xx structure ++ * definition. ++ */ ++typedef struct { ++ uint8_t entry_type; /* Entry type. */ ++ uint8_t entry_count; /* Entry count. */ ++ uint8_t fcp_cmnd_len_low; ++#ifdef __LITTLE_ENDIAN ++ uint8_t fcp_cmnd_len_high:4; ++ uint8_t attr:4; ++#else ++ uint8_t attr:4; ++ uint8_t fcp_cmnd_len_high:4; ++#endif ++ uint32_t exchange_addr; ++#define ATIO_EXCHANGE_ADDRESS_UNKNOWN 0xFFFFFFFF ++ fcp_hdr_t fcp_hdr; ++ fcp_cmnd_t fcp_cmnd; ++} __attribute__((packed)) atio7_entry_t; ++ ++#define CTIO_TYPE7 0x12 /* Continue target I/O entry (for 24xx) */ ++ ++/* ++ * ISP queue - Continue Target I/O (ATIO) type 7 entry (for 24xx) structure ++ * definition. ++ */ ++ ++typedef struct { ++ uint8_t entry_type; /* Entry type. */ ++ uint8_t entry_count; /* Entry count. */ ++ uint8_t sys_define; /* System defined. */ ++ uint8_t entry_status; /* Entry Status. */ ++ uint32_t handle; /* System defined handle */ ++ uint16_t nport_handle; ++#define CTIO7_NHANDLE_UNRECOGNIZED 0xFFFF ++ uint16_t timeout; ++ uint16_t dseg_count; /* Data segment count. */ ++ uint8_t vp_index; ++ uint8_t add_flags; ++ uint8_t initiator_id[3]; ++ uint8_t reserved; ++ uint32_t exchange_addr; ++} __attribute__((packed)) ctio7_common_entry_t; ++ ++typedef struct { ++ ctio7_common_entry_t common; ++ uint16_t reserved1; ++ uint16_t flags; ++ uint32_t residual; ++ uint16_t ox_id; ++ uint16_t scsi_status; ++ uint32_t relative_offset; ++ uint32_t reserved2; ++ uint32_t transfer_length; ++ uint32_t reserved3; ++ uint32_t dseg_0_address[2]; /* Data segment 0 address. */ ++ uint32_t dseg_0_length; /* Data segment 0 length. */ ++} __attribute__((packed)) ctio7_status0_entry_t; ++ ++typedef struct { ++ ctio7_common_entry_t common; ++ uint16_t sense_length; ++ uint16_t flags; ++ uint32_t residual; ++ uint16_t ox_id; ++ uint16_t scsi_status; ++ uint16_t response_len; ++ uint16_t reserved; ++ uint8_t sense_data[24]; ++} __attribute__((packed)) ctio7_status1_entry_t; ++ ++typedef struct { ++ uint8_t entry_type; /* Entry type. */ ++ uint8_t entry_count; /* Entry count. */ ++ uint8_t sys_define; /* System defined. */ ++ uint8_t entry_status; /* Entry Status. */ ++ uint32_t handle; /* System defined handle */ ++ uint16_t status; ++ uint16_t timeout; ++ uint16_t dseg_count; /* Data segment count. */ ++ uint8_t vp_index; ++ uint8_t reserved1[5]; ++ uint32_t exchange_address; ++ uint16_t reserved2; ++ uint16_t flags; ++ uint32_t residual; ++ uint16_t ox_id; ++ uint16_t reserved3; ++ uint32_t relative_offset; ++ uint8_t reserved4[24]; ++} __attribute__((packed)) ctio7_fw_entry_t; ++ ++/* CTIO7 flags values */ ++#define CTIO7_FLAGS_SEND_STATUS BIT_15 ++#define CTIO7_FLAGS_TERMINATE BIT_14 ++#define CTIO7_FLAGS_CONFORM_REQ BIT_13 ++#define CTIO7_FLAGS_DONT_RET_CTIO BIT_8 ++#define CTIO7_FLAGS_STATUS_MODE_0 0 ++#define CTIO7_FLAGS_STATUS_MODE_1 BIT_6 ++#define CTIO7_FLAGS_EXPLICIT_CONFORM BIT_5 ++#define CTIO7_FLAGS_CONFIRM_SATISF BIT_4 ++#define CTIO7_FLAGS_DSD_PTR BIT_2 ++#define CTIO7_FLAGS_DATA_IN BIT_1 ++#define CTIO7_FLAGS_DATA_OUT BIT_0 ++ ++/* ++ * ISP queue - immediate notify entry structure definition for 24xx. ++ */ ++typedef struct { ++ uint8_t entry_type; /* Entry type. */ ++ uint8_t entry_count; /* Entry count. */ ++ uint8_t sys_define; /* System defined. */ ++ uint8_t entry_status; /* Entry Status. */ ++ uint32_t reserved; ++ uint16_t nport_handle; ++ uint16_t reserved_2; ++ uint16_t flags; ++#define NOTIFY24XX_FLAGS_GLOBAL_TPRLO BIT_1 ++#define NOTIFY24XX_FLAGS_PUREX_IOCB BIT_0 ++ uint16_t srr_rx_id; ++ uint16_t status; ++ uint8_t status_subcode; ++ uint8_t reserved_3; ++ uint32_t exchange_address; ++ uint32_t srr_rel_offs; ++ uint16_t srr_ui; ++ uint16_t srr_ox_id; ++ uint8_t reserved_4[19]; ++ uint8_t vp_index; ++ uint32_t reserved_5; ++ uint8_t port_id[3]; ++ uint8_t reserved_6; ++ uint16_t reserved_7; ++ uint16_t ox_id; ++} __attribute__((packed)) notify24xx_entry_t; ++ ++#define ELS_PLOGI 0x3 ++#define ELS_FLOGI 0x4 ++#define ELS_LOGO 0x5 ++#define ELS_PRLI 0x20 ++#define ELS_PRLO 0x21 ++#define ELS_TPRLO 0x24 ++#define ELS_PDISC 0x50 ++#define ELS_ADISC 0x52 ++ ++/* ++ * ISP queue - notify acknowledge entry structure definition for 24xx. ++ */ ++typedef struct { ++ uint8_t entry_type; /* Entry type. */ ++ uint8_t entry_count; /* Entry count. */ ++ uint8_t sys_define; /* System defined. */ ++ uint8_t entry_status; /* Entry Status. */ ++ uint32_t handle; ++ uint16_t nport_handle; ++ uint16_t reserved_1; ++ uint16_t flags; ++ uint16_t srr_rx_id; ++ uint16_t status; ++ uint8_t status_subcode; ++ uint8_t reserved_3; ++ uint32_t exchange_address; ++ uint32_t srr_rel_offs; ++ uint16_t srr_ui; ++ uint16_t srr_flags; ++ uint8_t reserved_4[19]; ++ uint8_t vp_index; ++ uint8_t srr_reject_vendor_uniq; ++ uint8_t srr_reject_code_expl; ++ uint8_t srr_reject_code; ++ uint8_t reserved_5[7]; ++ uint16_t ox_id; ++} __attribute__((packed)) nack24xx_entry_t; ++ ++/* ++ * ISP queue - ABTS received/response entries structure definition for 24xx. ++ */ ++#define ABTS_RECV_24XX 0x54 /* ABTS received (for 24xx) */ ++#define ABTS_RESP_24XX 0x55 /* ABTS responce (for 24xx) */ ++ ++typedef struct { ++ uint8_t entry_type; /* Entry type. */ ++ uint8_t entry_count; /* Entry count. */ ++ uint8_t sys_define; /* System defined. */ ++ uint8_t entry_status; /* Entry Status. */ ++ uint8_t reserved_1[6]; ++ uint16_t nport_handle; ++ uint8_t reserved_2[2]; ++ uint8_t vp_index; ++#ifdef __LITTLE_ENDIAN ++ uint8_t reserved_3:4; ++ uint8_t sof_type:4; ++#else ++ uint8_t sof_type:4; ++ uint8_t reserved_3:4; ++#endif ++ uint32_t exchange_address; ++ fcp_hdr_le_t fcp_hdr_le; ++ uint8_t reserved_4[16]; ++ uint32_t exchange_addr_to_abort; ++} __attribute__((packed)) abts24_recv_entry_t; ++ ++#define ABTS_PARAM_ABORT_SEQ BIT_0 ++ ++typedef struct { ++ uint16_t reserved; ++ uint8_t seq_id_last; ++ uint8_t seq_id_valid; ++#define SEQ_ID_VALID 0x80 ++#define SEQ_ID_INVALID 0x00 ++ uint16_t rx_id; ++ uint16_t ox_id; ++ uint16_t high_seq_cnt; ++ uint16_t low_seq_cnt; ++} __attribute__((packed)) ba_acc_le_t; ++ ++typedef struct { ++ uint8_t vendor_uniq; ++ uint8_t reason_expl; ++ uint8_t reason_code; ++#define BA_RJT_REASON_CODE_INVALID_COMMAND 0x1 ++#define BA_RJT_REASON_CODE_UNABLE_TO_PERFORM 0x9 ++ uint8_t reserved; ++} __attribute__((packed)) ba_rjt_le_t; ++ ++typedef struct { ++ uint8_t entry_type; /* Entry type. */ ++ uint8_t entry_count; /* Entry count. */ ++ uint8_t sys_define; /* System defined. */ ++ uint8_t entry_status; /* Entry Status. */ ++ uint32_t handle; ++ uint16_t reserved_1; ++ uint16_t nport_handle; ++ uint16_t control_flags; ++#define ABTS_CONTR_FLG_TERM_EXCHG BIT_0 ++ uint8_t vp_index; ++#ifdef __LITTLE_ENDIAN ++ uint8_t reserved_3:4; ++ uint8_t sof_type:4; ++#else ++ uint8_t sof_type:4; ++ uint8_t reserved_3:4; ++#endif ++ uint32_t exchange_address; ++ fcp_hdr_le_t fcp_hdr_le; ++ union { ++ ba_acc_le_t ba_acct; ++ ba_rjt_le_t ba_rjt; ++ } __attribute__((packed)) payload; ++ uint32_t reserved_4; ++ uint32_t exchange_addr_to_abort; ++} __attribute__((packed)) abts24_resp_entry_t; ++ ++typedef struct { ++ uint8_t entry_type; /* Entry type. */ ++ uint8_t entry_count; /* Entry count. */ ++ uint8_t sys_define; /* System defined. */ ++ uint8_t entry_status; /* Entry Status. */ ++ uint32_t handle; ++ uint16_t compl_status; ++#define ABTS_RESP_COMPL_SUCCESS 0 ++#define ABTS_RESP_COMPL_SUBCODE_ERROR 0x31 ++ uint16_t nport_handle; ++ uint16_t reserved_1; ++ uint8_t reserved_2; ++#ifdef __LITTLE_ENDIAN ++ uint8_t reserved_3:4; ++ uint8_t sof_type:4; ++#else ++ uint8_t sof_type:4; ++ uint8_t reserved_3:4; ++#endif ++ uint32_t exchange_address; ++ fcp_hdr_le_t fcp_hdr_le; ++ uint8_t reserved_4[8]; ++ uint32_t error_subcode1; ++#define ABTS_RESP_SUBCODE_ERR_ABORTED_EXCH_NOT_TERM 0x1E ++ uint32_t error_subcode2; ++ uint32_t exchange_addr_to_abort; ++} __attribute__((packed)) abts24_resp_fw_entry_t; ++ ++/********************************************************************\ ++ * Type Definitions used by initiator & target halves ++\********************************************************************/ ++ ++typedef enum { ++ ADD_TARGET = 0, ++ REMOVE_TARGET, ++ DISABLE_TARGET_MODE, ++ ENABLE_TARGET_MODE, ++} qla2x_tgt_host_action_t; ++ ++/* Changing it don't forget to change QLA2X_TARGET_MAGIC! */ ++struct qla_tgt_data { ++ int magic; ++ ++ /* Callbacks */ ++ void (*tgt24_atio_pkt)(scsi_qla_host_t *ha, atio7_entry_t *pkt); ++ void (*tgt_response_pkt)(scsi_qla_host_t *ha, response_t *pkt); ++ void (*tgt2x_ctio_completion)(scsi_qla_host_t *ha, uint32_t handle); ++ void (*tgt_async_event)(uint16_t code, scsi_qla_host_t *ha, ++ uint16_t *mailbox); ++ int (*tgt_host_action)(scsi_qla_host_t *ha, qla2x_tgt_host_action_t ++ action); ++ void (*tgt_fc_port_added)(scsi_qla_host_t *ha, fc_port_t *fcport); ++ void (*tgt_fc_port_deleted)(scsi_qla_host_t *ha, fc_port_t *fcport); ++}; ++ ++int qla2xxx_tgt_register_driver(struct qla_tgt_data *tgt); ++ ++void qla2xxx_tgt_unregister_driver(void); ++ ++int qla2x00_wait_for_loop_ready(scsi_qla_host_t *ha); ++int qla2x00_wait_for_hba_online(scsi_qla_host_t *ha); ++ ++#endif /* __QLA2X_TGT_DEF_H */ +diff -uprN orig/linux-3.2/drivers/scst/qla2xxx-target/Makefile linux-3.2/drivers/scst/qla2xxx-target/Makefile +--- orig/linux-3.2/drivers/scst/qla2xxx-target/Makefile ++++ linux-3.2/drivers/scst/qla2xxx-target/Makefile +@@ -0,0 +1,5 @@ ++ccflags-y += -Idrivers/scsi/qla2xxx ++ ++qla2x00tgt-y := qla2x00t.o ++ ++obj-$(CONFIG_SCST_QLA_TGT_ADDON) += qla2x00tgt.o +diff -uprN orig/linux-3.2/drivers/scst/qla2xxx-target/Kconfig linux-3.2/drivers/scst/qla2xxx-target/Kconfig +--- orig/linux-3.2/drivers/scst/qla2xxx-target/Kconfig ++++ linux-3.2/drivers/scst/qla2xxx-target/Kconfig +@@ -0,0 +1,30 @@ ++config SCST_QLA_TGT_ADDON ++ tristate "QLogic 2XXX Target Mode Add-On" ++ depends on SCST && SCSI_QLA_FC && SCSI_QLA2XXX_TARGET ++ default SCST ++ help ++ Target mode add-on driver for QLogic 2xxx Fibre Channel host adapters. ++ Visit http://scst.sourceforge.net for more info about this driver. ++ ++config QLA_TGT_DEBUG_WORK_IN_THREAD ++ bool "Use threads context only" ++ depends on SCST_QLA_TGT_ADDON ++ help ++ Makes SCST process incoming commands from the qla2x00t target ++ driver and call the driver's callbacks in internal SCST ++ threads context instead of SIRQ context, where thise commands ++ were received. Useful for debugging and lead to some ++ performance loss. ++ ++ If unsure, say "N". ++ ++config QLA_TGT_DEBUG_SRR ++ bool "SRR debugging" ++ depends on SCST_QLA_TGT_ADDON ++ help ++ Turns on retransmitting packets (SRR) ++ debugging. In this mode some CTIOs will be "broken" to force the ++ initiator to issue a retransmit request. Useful for debugging and lead to big ++ performance loss. ++ ++ If unsure, say "N". +diff -uprN orig/linux-3.2/drivers/scst/qla2xxx-target/qla2x00t.c linux-3.2/drivers/scst/qla2xxx-target/qla2x00t.c +--- orig/linux-3.2/drivers/scst/qla2xxx-target/qla2x00t.c ++++ linux-3.2/drivers/scst/qla2xxx-target/qla2x00t.c +@@ -0,0 +1,6448 @@ ++/* ++ * qla2x00t.c ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2006 Nathaniel Clark <nate@misrule.us> ++ * Copyright (C) 2006 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * QLogic 22xx/23xx/24xx/25xx FC target driver. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#include <linux/module.h> ++#include <linux/init.h> ++#include <linux/types.h> ++#include <linux/version.h> ++#include <linux/blkdev.h> ++#include <linux/interrupt.h> ++#include <scsi/scsi.h> ++#include <scsi/scsi_host.h> ++#include <linux/pci.h> ++#include <linux/delay.h> ++#include <linux/list.h> ++#include <asm/unaligned.h> ++ ++#include <scst/scst.h> ++ ++#include "qla2x00t.h" ++ ++/* ++ * This driver calls qla2x00_req_pkt() and qla2x00_issue_marker(), which ++ * must be called under HW lock and could unlock/lock it inside. ++ * It isn't an issue, since in the current implementation on the time when ++ * those functions are called: ++ * ++ * - Either context is IRQ and only IRQ handler can modify HW data, ++ * including rings related fields, ++ * ++ * - Or access to target mode variables from struct q2t_tgt doesn't ++ * cross those functions boundaries, except tgt_stop, which ++ * additionally protected by irq_cmd_count. ++ */ ++ ++#ifndef CONFIG_SCSI_QLA2XXX_TARGET ++#error "CONFIG_SCSI_QLA2XXX_TARGET is NOT DEFINED" ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG ++#define Q2T_DEFAULT_LOG_FLAGS (TRACE_FUNCTION | TRACE_LINE | TRACE_PID | \ ++ TRACE_OUT_OF_MEM | TRACE_MGMT | TRACE_MGMT_DEBUG | \ ++ TRACE_MINOR | TRACE_SPECIAL) ++#else ++# ifdef CONFIG_SCST_TRACING ++#define Q2T_DEFAULT_LOG_FLAGS (TRACE_OUT_OF_MEM | TRACE_MGMT | \ ++ TRACE_SPECIAL) ++# endif ++#endif ++ ++static int q2t_target_detect(struct scst_tgt_template *templ); ++static int q2t_target_release(struct scst_tgt *scst_tgt); ++static int q2x_xmit_response(struct scst_cmd *scst_cmd); ++static int __q24_xmit_response(struct q2t_cmd *cmd, int xmit_type); ++static int q2t_rdy_to_xfer(struct scst_cmd *scst_cmd); ++static void q2t_on_free_cmd(struct scst_cmd *scst_cmd); ++static void q2t_task_mgmt_fn_done(struct scst_mgmt_cmd *mcmd); ++static int q2t_get_initiator_port_transport_id(struct scst_tgt *tgt, ++ struct scst_session *scst_sess, uint8_t **transport_id); ++ ++/* Predefs for callbacks handed to qla2xxx(target) */ ++static void q24_atio_pkt(scsi_qla_host_t *ha, atio7_entry_t *pkt); ++static void q2t_response_pkt(scsi_qla_host_t *ha, response_t *pkt); ++static void q2t_async_event(uint16_t code, scsi_qla_host_t *ha, ++ uint16_t *mailbox); ++static void q2x_ctio_completion(scsi_qla_host_t *ha, uint32_t handle); ++static int q2t_host_action(scsi_qla_host_t *ha, ++ qla2x_tgt_host_action_t action); ++static void q2t_fc_port_added(scsi_qla_host_t *ha, fc_port_t *fcport); ++static void q2t_fc_port_deleted(scsi_qla_host_t *ha, fc_port_t *fcport); ++static int q2t_issue_task_mgmt(struct q2t_sess *sess, uint8_t *lun, ++ int lun_size, int fn, void *iocb, int flags); ++static void q2x_send_term_exchange(scsi_qla_host_t *ha, struct q2t_cmd *cmd, ++ atio_entry_t *atio, int ha_locked); ++static void q24_send_term_exchange(scsi_qla_host_t *ha, struct q2t_cmd *cmd, ++ atio7_entry_t *atio, int ha_locked); ++static void q2t_reject_free_srr_imm(scsi_qla_host_t *ha, struct srr_imm *imm, ++ int ha_lock); ++static int q2t_cut_cmd_data_head(struct q2t_cmd *cmd, unsigned int offset); ++static void q2t_clear_tgt_db(struct q2t_tgt *tgt, bool local_only); ++static void q2t_on_hw_pending_cmd_timeout(struct scst_cmd *scst_cmd); ++static int q2t_unreg_sess(struct q2t_sess *sess); ++static uint16_t q2t_get_scsi_transport_version(struct scst_tgt *scst_tgt); ++static uint16_t q2t_get_phys_transport_version(struct scst_tgt *scst_tgt); ++ ++/** SYSFS **/ ++ ++static ssize_t q2t_version_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf); ++ ++struct kobj_attribute q2t_version_attr = ++ __ATTR(version, S_IRUGO, q2t_version_show, NULL); ++ ++static const struct attribute *q2t_attrs[] = { ++ &q2t_version_attr.attr, ++ NULL, ++}; ++ ++static ssize_t q2t_show_expl_conf_enabled(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buffer); ++static ssize_t q2t_store_expl_conf_enabled(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buffer, size_t size); ++ ++struct kobj_attribute q2t_expl_conf_attr = ++ __ATTR(explicit_confirmation, S_IRUGO|S_IWUSR, ++ q2t_show_expl_conf_enabled, q2t_store_expl_conf_enabled); ++ ++static ssize_t q2t_abort_isp_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buffer, size_t size); ++ ++struct kobj_attribute q2t_abort_isp_attr = ++ __ATTR(abort_isp, S_IWUSR, NULL, q2t_abort_isp_store); ++ ++static ssize_t q2t_hw_target_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf); ++ ++static struct kobj_attribute q2t_hw_target_attr = ++ __ATTR(hw_target, S_IRUGO, q2t_hw_target_show, NULL); ++ ++static ssize_t q2t_node_name_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf); ++ ++static struct kobj_attribute q2t_vp_node_name_attr = ++ __ATTR(node_name, S_IRUGO, q2t_node_name_show, NULL); ++ ++static ssize_t q2t_node_name_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buffer, size_t size); ++ ++static struct kobj_attribute q2t_hw_node_name_attr = ++ __ATTR(node_name, S_IRUGO|S_IWUSR, q2t_node_name_show, ++ q2t_node_name_store); ++ ++static ssize_t q2t_vp_parent_host_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf); ++ ++static struct kobj_attribute q2t_vp_parent_host_attr = ++ __ATTR(parent_host, S_IRUGO, q2t_vp_parent_host_show, NULL); ++ ++static const struct attribute *q2t_tgt_attrs[] = { ++ &q2t_expl_conf_attr.attr, ++ &q2t_abort_isp_attr.attr, ++ NULL, ++}; ++ ++static int q2t_enable_tgt(struct scst_tgt *tgt, bool enable); ++static bool q2t_is_tgt_enabled(struct scst_tgt *tgt); ++static ssize_t q2t_add_vtarget(const char *target_name, char *params); ++static ssize_t q2t_del_vtarget(const char *target_name); ++ ++/* ++ * Global Variables ++ */ ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++#define trace_flag q2t_trace_flag ++static unsigned long q2t_trace_flag = Q2T_DEFAULT_LOG_FLAGS; ++#endif ++ ++static struct scst_tgt_template tgt2x_template = { ++ .name = "qla2x00t", ++ .sg_tablesize = 0, ++ .use_clustering = 1, ++#ifdef CONFIG_QLA_TGT_DEBUG_WORK_IN_THREAD ++ .xmit_response_atomic = 0, ++ .rdy_to_xfer_atomic = 0, ++#else ++ .xmit_response_atomic = 1, ++ .rdy_to_xfer_atomic = 1, ++#endif ++ .max_hw_pending_time = Q2T_MAX_HW_PENDING_TIME, ++ .detect = q2t_target_detect, ++ .release = q2t_target_release, ++ .xmit_response = q2x_xmit_response, ++ .rdy_to_xfer = q2t_rdy_to_xfer, ++ .on_free_cmd = q2t_on_free_cmd, ++ .task_mgmt_fn_done = q2t_task_mgmt_fn_done, ++ .get_initiator_port_transport_id = q2t_get_initiator_port_transport_id, ++ .get_scsi_transport_version = q2t_get_scsi_transport_version, ++ .get_phys_transport_version = q2t_get_phys_transport_version, ++ .on_hw_pending_cmd_timeout = q2t_on_hw_pending_cmd_timeout, ++ .enable_target = q2t_enable_tgt, ++ .is_target_enabled = q2t_is_tgt_enabled, ++ .add_target = q2t_add_vtarget, ++ .del_target = q2t_del_vtarget, ++ .add_target_parameters = "node_name, parent_host", ++ .tgtt_attrs = q2t_attrs, ++ .tgt_attrs = q2t_tgt_attrs, ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ .default_trace_flags = Q2T_DEFAULT_LOG_FLAGS, ++ .trace_flags = &trace_flag, ++#endif ++}; ++ ++static struct kmem_cache *q2t_cmd_cachep; ++static struct kmem_cache *q2t_mgmt_cmd_cachep; ++static mempool_t *q2t_mgmt_cmd_mempool; ++ ++static DECLARE_RWSEM(q2t_unreg_rwsem); ++ ++/* It's not yet supported */ ++static inline int scst_cmd_get_ppl_offset(struct scst_cmd *scst_cmd) ++{ ++ return 0; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static inline void q2t_sess_get(struct q2t_sess *sess) ++{ ++ sess->sess_ref++; ++ TRACE_DBG("sess %p, new sess_ref %d", sess, sess->sess_ref); ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static inline void q2t_sess_put(struct q2t_sess *sess) ++{ ++ TRACE_DBG("sess %p, new sess_ref %d", sess, sess->sess_ref-1); ++ BUG_ON(sess->sess_ref == 0); ++ ++ sess->sess_ref--; ++ if (sess->sess_ref == 0) ++ q2t_unreg_sess(sess); ++} ++ ++/* pha->hardware_lock supposed to be held on entry (to protect tgt->sess_list) */ ++static inline struct q2t_sess *q2t_find_sess_by_loop_id(struct q2t_tgt *tgt, ++ uint16_t loop_id) ++{ ++ struct q2t_sess *sess; ++ list_for_each_entry(sess, &tgt->sess_list, sess_list_entry) { ++ if ((loop_id == sess->loop_id) && !sess->deleted) ++ return sess; ++ } ++ return NULL; ++} ++ ++/* pha->hardware_lock supposed to be held on entry (to protect tgt->sess_list) */ ++static inline struct q2t_sess *q2t_find_sess_by_s_id_include_deleted( ++ struct q2t_tgt *tgt, const uint8_t *s_id) ++{ ++ struct q2t_sess *sess; ++ list_for_each_entry(sess, &tgt->sess_list, sess_list_entry) { ++ if ((sess->s_id.b.al_pa == s_id[2]) && ++ (sess->s_id.b.area == s_id[1]) && ++ (sess->s_id.b.domain == s_id[0])) ++ return sess; ++ } ++ return NULL; ++} ++ ++/* pha->hardware_lock supposed to be held on entry (to protect tgt->sess_list) */ ++static inline struct q2t_sess *q2t_find_sess_by_s_id(struct q2t_tgt *tgt, ++ const uint8_t *s_id) ++{ ++ struct q2t_sess *sess; ++ list_for_each_entry(sess, &tgt->sess_list, sess_list_entry) { ++ if ((sess->s_id.b.al_pa == s_id[2]) && ++ (sess->s_id.b.area == s_id[1]) && ++ (sess->s_id.b.domain == s_id[0]) && ++ !sess->deleted) ++ return sess; ++ } ++ return NULL; ++} ++ ++/* pha->hardware_lock supposed to be held on entry (to protect tgt->sess_list) */ ++static inline struct q2t_sess *q2t_find_sess_by_s_id_le(struct q2t_tgt *tgt, ++ const uint8_t *s_id) ++{ ++ struct q2t_sess *sess; ++ list_for_each_entry(sess, &tgt->sess_list, sess_list_entry) { ++ if ((sess->s_id.b.al_pa == s_id[0]) && ++ (sess->s_id.b.area == s_id[1]) && ++ (sess->s_id.b.domain == s_id[2]) && ++ !sess->deleted) ++ return sess; ++ } ++ return NULL; ++} ++ ++/* pha->hardware_lock supposed to be held on entry (to protect tgt->sess_list) */ ++static inline struct q2t_sess *q2t_find_sess_by_port_name(struct q2t_tgt *tgt, ++ const uint8_t *port_name) ++{ ++ struct q2t_sess *sess; ++ list_for_each_entry(sess, &tgt->sess_list, sess_list_entry) { ++ if ((sess->port_name[0] == port_name[0]) && ++ (sess->port_name[1] == port_name[1]) && ++ (sess->port_name[2] == port_name[2]) && ++ (sess->port_name[3] == port_name[3]) && ++ (sess->port_name[4] == port_name[4]) && ++ (sess->port_name[5] == port_name[5]) && ++ (sess->port_name[6] == port_name[6]) && ++ (sess->port_name[7] == port_name[7])) ++ return sess; ++ } ++ return NULL; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static inline void q2t_exec_queue(scsi_qla_host_t *ha) ++{ ++ qla2x00_isp_cmd(to_qla_parent(ha)); ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static inline request_t *q2t_req_pkt(scsi_qla_host_t *ha) ++{ ++ return qla2x00_req_pkt(to_qla_parent(ha)); ++} ++ ++/* Might release hw lock, then reacquire!! */ ++static inline int q2t_issue_marker(scsi_qla_host_t *ha, int ha_locked) ++{ ++ /* Send marker if required */ ++ if (unlikely(to_qla_parent(ha)->marker_needed != 0)) { ++ int rc = qla2x00_issue_marker(ha, ha_locked); ++ if (rc != QLA_SUCCESS) { ++ PRINT_ERROR("qla2x00t(%ld): issue_marker() " ++ "failed", ha->instance); ++ } ++ return rc; ++ } ++ return QLA_SUCCESS; ++} ++ ++static inline ++scsi_qla_host_t *q2t_find_host_by_d_id(scsi_qla_host_t *ha, uint8_t *d_id) ++{ ++ if ((ha->d_id.b.area != d_id[1]) || (ha->d_id.b.domain != d_id[0])) ++ return NULL; ++ ++ if (ha->d_id.b.al_pa == d_id[2]) ++ return ha; ++ ++ if (IS_FWI2_CAPABLE(ha)) { ++ uint8_t vp_idx; ++ BUG_ON(ha->tgt_vp_map == NULL); ++ vp_idx = ha->tgt_vp_map[d_id[2]].idx; ++ if (likely(test_bit(vp_idx, ha->vp_idx_map))) ++ return ha->tgt_vp_map[vp_idx].vha; ++ } ++ ++ return NULL; ++} ++ ++static inline ++scsi_qla_host_t *q2t_find_host_by_vp_idx(scsi_qla_host_t *ha, uint16_t vp_idx) ++{ ++ if (ha->vp_idx == vp_idx) ++ return ha; ++ ++ if (IS_FWI2_CAPABLE(ha)) { ++ BUG_ON(ha->tgt_vp_map == NULL); ++ if (likely(test_bit(vp_idx, ha->vp_idx_map))) ++ return ha->tgt_vp_map[vp_idx].vha; ++ } ++ ++ return NULL; ++} ++ ++static void q24_atio_pkt_all_vps(scsi_qla_host_t *ha, atio7_entry_t *atio) ++{ ++ TRACE_ENTRY(); ++ ++ BUG_ON(ha == NULL); ++ ++ switch (atio->entry_type) { ++ case ATIO_TYPE7: ++ { ++ scsi_qla_host_t *host = q2t_find_host_by_d_id(ha, atio->fcp_hdr.d_id); ++ if (unlikely(NULL == host)) { ++ /* ++ * It might happen, because there is a small gap between ++ * requesting the DPC thread to update loop and actual ++ * update. It is harmless and on the next retry should ++ * work well. ++ */ ++ PRINT_WARNING("qla2x00t(%ld): Received ATIO_TYPE7 " ++ "with unknown d_id %x:%x:%x", ha->instance, ++ atio->fcp_hdr.d_id[0], atio->fcp_hdr.d_id[1], ++ atio->fcp_hdr.d_id[2]); ++ break; ++ } ++ q24_atio_pkt(host, atio); ++ break; ++ } ++ ++ case IMMED_NOTIFY_TYPE: ++ { ++ scsi_qla_host_t *host = ha; ++ if (IS_FWI2_CAPABLE(ha)) { ++ notify24xx_entry_t *entry = (notify24xx_entry_t *)atio; ++ if ((entry->vp_index != 0xFF) && ++ (entry->nport_handle != 0xFFFF)) { ++ host = q2t_find_host_by_vp_idx(ha, ++ entry->vp_index); ++ if (unlikely(!host)) { ++ PRINT_ERROR("qla2x00t(%ld): Received " ++ "ATIO (IMMED_NOTIFY_TYPE) " ++ "with unknown vp_index %d", ++ ha->instance, entry->vp_index); ++ break; ++ } ++ } ++ } ++ q24_atio_pkt(host, atio); ++ break; ++ } ++ ++ default: ++ PRINT_ERROR("qla2x00t(%ld): Received unknown ATIO atio " ++ "type %x", ha->instance, atio->entry_type); ++ break; ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void q2t_response_pkt_all_vps(scsi_qla_host_t *ha, response_t *pkt) ++{ ++ TRACE_ENTRY(); ++ ++ BUG_ON(ha == NULL); ++ ++ switch (pkt->entry_type) { ++ case CTIO_TYPE7: ++ { ++ ctio7_fw_entry_t *entry = (ctio7_fw_entry_t *)pkt; ++ scsi_qla_host_t *host = q2t_find_host_by_vp_idx(ha, ++ entry->vp_index); ++ if (unlikely(!host)) { ++ PRINT_ERROR("qla2x00t(%ld): Response pkt (CTIO_TYPE7) " ++ "received, with unknown vp_index %d", ++ ha->instance, entry->vp_index); ++ break; ++ } ++ q2t_response_pkt(host, pkt); ++ break; ++ } ++ ++ case IMMED_NOTIFY_TYPE: ++ { ++ scsi_qla_host_t *host = ha; ++ if (IS_FWI2_CAPABLE(ha)) { ++ notify24xx_entry_t *entry = (notify24xx_entry_t *)pkt; ++ host = q2t_find_host_by_vp_idx(ha, entry->vp_index); ++ if (unlikely(!host)) { ++ PRINT_ERROR("qla2x00t(%ld): Response pkt " ++ "(IMMED_NOTIFY_TYPE) received, " ++ "with unknown vp_index %d", ++ ha->instance, entry->vp_index); ++ break; ++ } ++ } ++ q2t_response_pkt(host, pkt); ++ break; ++ } ++ ++ case NOTIFY_ACK_TYPE: ++ { ++ scsi_qla_host_t *host = ha; ++ if (IS_FWI2_CAPABLE(ha)) { ++ nack24xx_entry_t *entry = (nack24xx_entry_t *)pkt; ++ if (0xFF != entry->vp_index) { ++ host = q2t_find_host_by_vp_idx(ha, ++ entry->vp_index); ++ if (unlikely(!host)) { ++ PRINT_ERROR("qla2x00t(%ld): Response " ++ "pkt (NOTIFY_ACK_TYPE) " ++ "received, with unknown " ++ "vp_index %d", ha->instance, ++ entry->vp_index); ++ break; ++ } ++ } ++ } ++ q2t_response_pkt(host, pkt); ++ break; ++ } ++ ++ case ABTS_RECV_24XX: ++ { ++ abts24_recv_entry_t *entry = (abts24_recv_entry_t *)pkt; ++ scsi_qla_host_t *host = q2t_find_host_by_vp_idx(ha, ++ entry->vp_index); ++ if (unlikely(!host)) { ++ PRINT_ERROR("qla2x00t(%ld): Response pkt " ++ "(ABTS_RECV_24XX) received, with unknown " ++ "vp_index %d", ha->instance, entry->vp_index); ++ break; ++ } ++ q2t_response_pkt(host, pkt); ++ break; ++ } ++ ++ case ABTS_RESP_24XX: ++ { ++ abts24_resp_entry_t *entry = (abts24_resp_entry_t *)pkt; ++ scsi_qla_host_t *host = q2t_find_host_by_vp_idx(ha, ++ entry->vp_index); ++ if (unlikely(!host)) { ++ PRINT_ERROR("qla2x00t(%ld): Response pkt " ++ "(ABTS_RECV_24XX) received, with unknown " ++ "vp_index %d", ha->instance, entry->vp_index); ++ break; ++ } ++ q2t_response_pkt(host, pkt); ++ break; ++ } ++ ++ default: ++ q2t_response_pkt(ha, pkt); ++ break; ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++/* ++ * Registers with initiator driver (but target mode isn't enabled till ++ * it's turned on via sysfs) ++ */ ++static int q2t_target_detect(struct scst_tgt_template *tgtt) ++{ ++ int res, rc; ++ struct qla_tgt_data t = { ++ .magic = QLA2X_TARGET_MAGIC, ++ .tgt24_atio_pkt = q24_atio_pkt_all_vps, ++ .tgt_response_pkt = q2t_response_pkt_all_vps, ++ .tgt2x_ctio_completion = q2x_ctio_completion, ++ .tgt_async_event = q2t_async_event, ++ .tgt_host_action = q2t_host_action, ++ .tgt_fc_port_added = q2t_fc_port_added, ++ .tgt_fc_port_deleted = q2t_fc_port_deleted, ++ }; ++ ++ TRACE_ENTRY(); ++ ++ rc = qla2xxx_tgt_register_driver(&t); ++ if (rc < 0) { ++ res = rc; ++ PRINT_ERROR("qla2x00t: Unable to register driver: %d", res); ++ goto out; ++ } ++ ++ if (rc != QLA2X_INITIATOR_MAGIC) { ++ PRINT_ERROR("qla2x00t: Wrong version of the initiator part: " ++ "%d", rc); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ qla2xxx_add_targets(); ++ ++ res = 0; ++ ++ PRINT_INFO("qla2x00t: %s", "Target mode driver for QLogic 2x00 controller " ++ "registered successfully"); ++ ++out: ++ TRACE_EXIT(); ++ return res; ++} ++ ++static void q2t_free_session_done(struct scst_session *scst_sess) ++{ ++ struct q2t_sess *sess; ++ struct q2t_tgt *tgt; ++ scsi_qla_host_t *ha, *pha; ++ unsigned long flags; ++ ++ TRACE_ENTRY(); ++ ++ BUG_ON(scst_sess == NULL); ++ sess = (struct q2t_sess *)scst_sess_get_tgt_priv(scst_sess); ++ BUG_ON(sess == NULL); ++ tgt = sess->tgt; ++ ++ TRACE_MGMT_DBG("Unregistration of sess %p finished", sess); ++ ++ kfree(sess); ++ ++ if (tgt == NULL) ++ goto out; ++ ++ TRACE_DBG("empty(sess_list) %d sess_count %d", ++ list_empty(&tgt->sess_list), tgt->sess_count); ++ ++ ha = tgt->ha; ++ pha = to_qla_parent(ha); ++ ++ /* ++ * We need to protect against race, when tgt is freed before or ++ * inside wake_up() ++ */ ++ spin_lock_irqsave(&pha->hardware_lock, flags); ++ tgt->sess_count--; ++ if (tgt->sess_count == 0) ++ wake_up_all(&tgt->waitQ); ++ spin_unlock_irqrestore(&pha->hardware_lock, flags); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static int q2t_unreg_sess(struct q2t_sess *sess) ++{ ++ int res = 1; ++ ++ TRACE_ENTRY(); ++ ++ BUG_ON(sess == NULL); ++ BUG_ON(sess->sess_ref != 0); ++ ++ TRACE_MGMT_DBG("Deleting sess %p from tgt %p", sess, sess->tgt); ++ list_del(&sess->sess_list_entry); ++ ++ if (sess->deleted) ++ list_del(&sess->del_list_entry); ++ ++ PRINT_INFO("qla2x00t(%ld): %ssession for loop_id %d deleted", ++ sess->tgt->ha->instance, sess->local ? "local " : "", ++ sess->loop_id); ++ ++ scst_unregister_session(sess->scst_sess, 0, q2t_free_session_done); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static int q2t_reset(scsi_qla_host_t *ha, void *iocb, int mcmd) ++{ ++ struct q2t_sess *sess; ++ int loop_id; ++ uint16_t lun = 0; ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ if (IS_FWI2_CAPABLE(ha)) { ++ notify24xx_entry_t *n = (notify24xx_entry_t *)iocb; ++ loop_id = le16_to_cpu(n->nport_handle); ++ } else ++ loop_id = GET_TARGET_ID(ha, (notify_entry_t *)iocb); ++ ++ if (loop_id == 0xFFFF) { ++ /* Global event */ ++ atomic_inc(&ha->tgt->tgt_global_resets_count); ++ q2t_clear_tgt_db(ha->tgt, 1); ++ if (!list_empty(&ha->tgt->sess_list)) { ++ sess = list_entry(ha->tgt->sess_list.next, ++ typeof(*sess), sess_list_entry); ++ switch (mcmd) { ++ case Q2T_NEXUS_LOSS_SESS: ++ mcmd = Q2T_NEXUS_LOSS; ++ break; ++ ++ case Q2T_ABORT_ALL_SESS: ++ mcmd = Q2T_ABORT_ALL; ++ break; ++ ++ case Q2T_NEXUS_LOSS: ++ case Q2T_ABORT_ALL: ++ break; ++ ++ default: ++ PRINT_ERROR("qla2x00t(%ld): Not allowed " ++ "command %x in %s", ha->instance, ++ mcmd, __func__); ++ sess = NULL; ++ break; ++ } ++ } else ++ sess = NULL; ++ } else ++ sess = q2t_find_sess_by_loop_id(ha->tgt, loop_id); ++ ++ if (sess == NULL) { ++ res = -ESRCH; ++ ha->tgt->tm_to_unknown = 1; ++ goto out; ++ } ++ ++ TRACE_MGMT_DBG("scsi(%ld): resetting (session %p from port " ++ "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x, " ++ "mcmd %x, loop_id %d)", ha->host_no, sess, ++ sess->port_name[0], sess->port_name[1], ++ sess->port_name[2], sess->port_name[3], ++ sess->port_name[4], sess->port_name[5], ++ sess->port_name[6], sess->port_name[7], ++ mcmd, loop_id); ++ ++ res = q2t_issue_task_mgmt(sess, (uint8_t *)&lun, sizeof(lun), ++ mcmd, iocb, Q24_MGMT_SEND_NACK); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static void q2t_schedule_sess_for_deletion(struct q2t_sess *sess) ++{ ++ struct q2t_tgt *tgt = sess->tgt; ++ uint32_t dev_loss_tmo = tgt->ha->port_down_retry_count + 5; ++ bool schedule; ++ ++ TRACE_ENTRY(); ++ ++ if (sess->deleted) ++ goto out; ++ ++ /* ++ * If the list is empty, then, most likely, the work isn't ++ * scheduled. ++ */ ++ schedule = list_empty(&tgt->del_sess_list); ++ ++ TRACE_MGMT_DBG("Scheduling sess %p for deletion (schedule %d)", sess, ++ schedule); ++ list_add_tail(&sess->del_list_entry, &tgt->del_sess_list); ++ sess->deleted = 1; ++ sess->expires = jiffies + dev_loss_tmo * HZ; ++ ++ PRINT_INFO("qla2x00t(%ld): session for port %02x:%02x:%02x:" ++ "%02x:%02x:%02x:%02x:%02x (loop ID %d) scheduled for " ++ "deletion in %d secs", tgt->ha->instance, ++ sess->port_name[0], sess->port_name[1], ++ sess->port_name[2], sess->port_name[3], ++ sess->port_name[4], sess->port_name[5], ++ sess->port_name[6], sess->port_name[7], ++ sess->loop_id, dev_loss_tmo); ++ ++ if (schedule) ++ schedule_delayed_work(&tgt->sess_del_work, ++ jiffies - sess->expires); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static void q2t_clear_tgt_db(struct q2t_tgt *tgt, bool local_only) ++{ ++ struct q2t_sess *sess, *sess_tmp; ++ ++ TRACE_ENTRY(); ++ ++ TRACE(TRACE_MGMT, "qla2x00t: Clearing targets DB for target %p", tgt); ++ ++ list_for_each_entry_safe(sess, sess_tmp, &tgt->sess_list, ++ sess_list_entry) { ++ if (local_only) { ++ if (!sess->local) ++ continue; ++ q2t_schedule_sess_for_deletion(sess); ++ } else ++ q2t_sess_put(sess); ++ } ++ ++ /* At this point tgt could be already dead */ ++ ++ TRACE_MGMT_DBG("Finished clearing tgt %p DB", tgt); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Called in a thread context */ ++static void q2t_alloc_session_done(struct scst_session *scst_sess, ++ void *data, int result) ++{ ++ TRACE_ENTRY(); ++ ++ if (result != 0) { ++ struct q2t_sess *sess = (struct q2t_sess *)data; ++ struct q2t_tgt *tgt = sess->tgt; ++ scsi_qla_host_t *ha = tgt->ha; ++ scsi_qla_host_t *pha = to_qla_parent(ha); ++ unsigned long flags; ++ ++ PRINT_INFO("qla2x00t(%ld): Session initialization failed", ++ ha->instance); ++ ++ spin_lock_irqsave(&pha->hardware_lock, flags); ++ q2t_sess_put(sess); ++ spin_unlock_irqrestore(&pha->hardware_lock, flags); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int q24_get_loop_id(scsi_qla_host_t *ha, const uint8_t *s_id, ++ uint16_t *loop_id) ++{ ++ dma_addr_t gid_list_dma; ++ struct gid_list_info *gid_list; ++ char *id_iter; ++ int res, rc, i, retries = 0; ++ uint16_t entries; ++ ++ TRACE_ENTRY(); ++ ++ gid_list = dma_alloc_coherent(&ha->pdev->dev, GID_LIST_SIZE, ++ &gid_list_dma, GFP_KERNEL); ++ if (gid_list == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): DMA Alloc failed of %zd", ++ ha->instance, GID_LIST_SIZE); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ /* Get list of logged in devices */ ++retry: ++ rc = qla2x00_get_id_list(ha, gid_list, gid_list_dma, &entries); ++ if (rc != QLA_SUCCESS) { ++ if (rc == QLA_FW_NOT_READY) { ++ retries++; ++ if (retries < 3) { ++ msleep(1000); ++ goto retry; ++ } ++ } ++ TRACE_MGMT_DBG("qla2x00t(%ld): get_id_list() failed: %x", ++ ha->instance, rc); ++ res = -rc; ++ goto out_free_id_list; ++ } ++ ++ id_iter = (char *)gid_list; ++ res = -1; ++ for (i = 0; i < entries; i++) { ++ struct gid_list_info *gid = (struct gid_list_info *)id_iter; ++ if ((gid->al_pa == s_id[2]) && ++ (gid->area == s_id[1]) && ++ (gid->domain == s_id[0])) { ++ *loop_id = le16_to_cpu(gid->loop_id); ++ res = 0; ++ break; ++ } ++ id_iter += ha->gid_list_info_size; ++ } ++ ++out_free_id_list: ++ dma_free_coherent(&ha->pdev->dev, GID_LIST_SIZE, gid_list, gid_list_dma); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static bool q2t_check_fcport_exist(scsi_qla_host_t *ha, struct q2t_sess *sess) ++{ ++ bool res, found = false; ++ int rc, i; ++ uint16_t loop_id = 0xFFFF; /* to eliminate compiler's warning */ ++ uint16_t entries; ++ void *pmap; ++ int pmap_len; ++ fc_port_t *fcport; ++ int global_resets; ++ ++ TRACE_ENTRY(); ++ ++retry: ++ global_resets = atomic_read(&ha->tgt->tgt_global_resets_count); ++ ++ rc = qla2x00_get_node_name_list(ha, &pmap, &pmap_len); ++ if (rc != QLA_SUCCESS) { ++ res = false; ++ goto out; ++ } ++ ++ if (IS_FWI2_CAPABLE(ha)) { ++ struct qla_port24_data *pmap24 = pmap; ++ ++ entries = pmap_len/sizeof(*pmap24); ++ ++ for (i = 0; i < entries; ++i) { ++ if ((sess->port_name[0] == pmap24[i].port_name[0]) && ++ (sess->port_name[1] == pmap24[i].port_name[1]) && ++ (sess->port_name[2] == pmap24[i].port_name[2]) && ++ (sess->port_name[3] == pmap24[i].port_name[3]) && ++ (sess->port_name[4] == pmap24[i].port_name[4]) && ++ (sess->port_name[5] == pmap24[i].port_name[5]) && ++ (sess->port_name[6] == pmap24[i].port_name[6]) && ++ (sess->port_name[7] == pmap24[i].port_name[7])) { ++ loop_id = le16_to_cpu(pmap24[i].loop_id); ++ found = true; ++ break; ++ } ++ } ++ } else { ++ struct qla_port23_data *pmap2x = pmap; ++ ++ entries = pmap_len/sizeof(*pmap2x); ++ ++ for (i = 0; i < entries; ++i) { ++ if ((sess->port_name[0] == pmap2x[i].port_name[0]) && ++ (sess->port_name[1] == pmap2x[i].port_name[1]) && ++ (sess->port_name[2] == pmap2x[i].port_name[2]) && ++ (sess->port_name[3] == pmap2x[i].port_name[3]) && ++ (sess->port_name[4] == pmap2x[i].port_name[4]) && ++ (sess->port_name[5] == pmap2x[i].port_name[5]) && ++ (sess->port_name[6] == pmap2x[i].port_name[6]) && ++ (sess->port_name[7] == pmap2x[i].port_name[7])) { ++ loop_id = le16_to_cpu(pmap2x[i].loop_id); ++ found = true; ++ break; ++ } ++ } ++ } ++ ++ kfree(pmap); ++ ++ if (!found) { ++ res = false; ++ goto out; ++ } ++ ++ TRACE_MGMT_DBG("loop_id %d", loop_id); ++ ++ fcport = kzalloc(sizeof(*fcport), GFP_KERNEL); ++ if (fcport == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): Allocation of tmp FC port failed", ++ ha->instance); ++ res = false; ++ goto out; ++ } ++ ++ fcport->loop_id = loop_id; ++ ++ rc = qla2x00_get_port_database(ha, fcport, 0); ++ if (rc != QLA_SUCCESS) { ++ PRINT_ERROR("qla2x00t(%ld): Failed to retrieve fcport " ++ "information -- get_port_database() returned %x " ++ "(loop_id=0x%04x)", ha->instance, rc, loop_id); ++ res = false; ++ goto out_free_fcport; ++ } ++ ++ if (global_resets != atomic_read(&ha->tgt->tgt_global_resets_count)) { ++ TRACE_MGMT_DBG("qla2x00t(%ld): global reset during session " ++ "discovery (counter was %d, new %d), retrying", ++ ha->instance, global_resets, ++ atomic_read(&ha->tgt->tgt_global_resets_count)); ++ goto retry; ++ } ++ ++ TRACE_MGMT_DBG("Updating sess %p s_id %x:%x:%x, " ++ "loop_id %d) to d_id %x:%x:%x, loop_id %d", sess, ++ sess->s_id.b.domain, sess->s_id.b.area, ++ sess->s_id.b.al_pa, sess->loop_id, fcport->d_id.b.domain, ++ fcport->d_id.b.area, fcport->d_id.b.al_pa, fcport->loop_id); ++ ++ sess->s_id = fcport->d_id; ++ sess->loop_id = fcport->loop_id; ++ sess->conf_compl_supported = fcport->conf_compl_supported; ++ ++ res = true; ++ ++out_free_fcport: ++ kfree(fcport); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static void q2t_undelete_sess(struct q2t_sess *sess) ++{ ++ BUG_ON(!sess->deleted); ++ ++ list_del(&sess->del_list_entry); ++ sess->deleted = 0; ++} ++ ++static void q2t_del_sess_work_fn(struct delayed_work *work) ++{ ++ struct q2t_tgt *tgt = container_of(work, struct q2t_tgt, ++ sess_del_work); ++ scsi_qla_host_t *ha = tgt->ha; ++ scsi_qla_host_t *pha = to_qla_parent(ha); ++ struct q2t_sess *sess; ++ unsigned long flags; ++ ++ TRACE_ENTRY(); ++ ++ spin_lock_irqsave(&pha->hardware_lock, flags); ++ while (!list_empty(&tgt->del_sess_list)) { ++ sess = list_entry(tgt->del_sess_list.next, typeof(*sess), ++ del_list_entry); ++ if (time_after_eq(jiffies, sess->expires)) { ++ bool cancel; ++ ++ q2t_undelete_sess(sess); ++ ++ spin_unlock_irqrestore(&pha->hardware_lock, flags); ++ cancel = q2t_check_fcport_exist(ha, sess); ++ spin_lock_irqsave(&pha->hardware_lock, flags); ++ ++ if (cancel) { ++ if (sess->deleted) { ++ /* ++ * sess was again deleted while we were ++ * discovering it ++ */ ++ continue; ++ } ++ ++ PRINT_INFO("qla2x00t(%ld): cancel deletion of " ++ "session for port %02x:%02x:%02x:" ++ "%02x:%02x:%02x:%02x:%02x (loop ID %d), " ++ "because it isn't deleted by firmware", ++ ha->instance, ++ sess->port_name[0], sess->port_name[1], ++ sess->port_name[2], sess->port_name[3], ++ sess->port_name[4], sess->port_name[5], ++ sess->port_name[6], sess->port_name[7], ++ sess->loop_id); ++ } else { ++ TRACE_MGMT_DBG("Timeout: sess %p about to be " ++ "deleted", sess); ++ q2t_sess_put(sess); ++ } ++ } else { ++ schedule_delayed_work(&tgt->sess_del_work, ++ jiffies - sess->expires); ++ break; ++ } ++ } ++ spin_unlock_irqrestore(&pha->hardware_lock, flags); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * Must be called under tgt_mutex. ++ * ++ * Adds an extra ref to allow to drop hw lock after adding sess to the list. ++ * Caller must put it. ++ */ ++static struct q2t_sess *q2t_create_sess(scsi_qla_host_t *ha, fc_port_t *fcport, ++ bool local) ++{ ++ char *wwn_str; ++ const int wwn_str_len = 3*WWN_SIZE+2; ++ struct q2t_tgt *tgt = ha->tgt; ++ struct q2t_sess *sess; ++ scsi_qla_host_t *pha = to_qla_parent(ha); ++ ++ TRACE_ENTRY(); ++ ++ /* Check to avoid double sessions */ ++ spin_lock_irq(&pha->hardware_lock); ++ list_for_each_entry(sess, &tgt->sess_list, sess_list_entry) { ++ if ((sess->port_name[0] == fcport->port_name[0]) && ++ (sess->port_name[1] == fcport->port_name[1]) && ++ (sess->port_name[2] == fcport->port_name[2]) && ++ (sess->port_name[3] == fcport->port_name[3]) && ++ (sess->port_name[4] == fcport->port_name[4]) && ++ (sess->port_name[5] == fcport->port_name[5]) && ++ (sess->port_name[6] == fcport->port_name[6]) && ++ (sess->port_name[7] == fcport->port_name[7])) { ++ TRACE_MGMT_DBG("Double sess %p found (s_id %x:%x:%x, " ++ "loop_id %d), updating to d_id %x:%x:%x, " ++ "loop_id %d", sess, sess->s_id.b.domain, ++ sess->s_id.b.area, sess->s_id.b.al_pa, ++ sess->loop_id, fcport->d_id.b.domain, ++ fcport->d_id.b.area, fcport->d_id.b.al_pa, ++ fcport->loop_id); ++ ++ if (sess->deleted) ++ q2t_undelete_sess(sess); ++ ++ q2t_sess_get(sess); ++ sess->s_id = fcport->d_id; ++ sess->loop_id = fcport->loop_id; ++ sess->conf_compl_supported = fcport->conf_compl_supported; ++ if (sess->local && !local) ++ sess->local = 0; ++ spin_unlock_irq(&pha->hardware_lock); ++ goto out; ++ } ++ } ++ spin_unlock_irq(&pha->hardware_lock); ++ ++ /* We are under tgt_mutex, so a new sess can't be added behind us */ ++ ++ sess = kzalloc(sizeof(*sess), GFP_KERNEL); ++ if (sess == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): session allocation failed, " ++ "all commands from port %02x:%02x:%02x:%02x:" ++ "%02x:%02x:%02x:%02x will be refused", ha->instance, ++ fcport->port_name[0], fcport->port_name[1], ++ fcport->port_name[2], fcport->port_name[3], ++ fcport->port_name[4], fcport->port_name[5], ++ fcport->port_name[6], fcport->port_name[7]); ++ goto out; ++ } ++ ++ sess->sess_ref = 2; /* plus 1 extra ref, see above */ ++ sess->tgt = ha->tgt; ++ sess->s_id = fcport->d_id; ++ sess->loop_id = fcport->loop_id; ++ sess->conf_compl_supported = fcport->conf_compl_supported; ++ sess->local = local; ++ BUILD_BUG_ON(sizeof(sess->port_name) != sizeof(fcport->port_name)); ++ memcpy(sess->port_name, fcport->port_name, sizeof(sess->port_name)); ++ ++ wwn_str = kmalloc(wwn_str_len, GFP_KERNEL); ++ if (wwn_str == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): Allocation of wwn_str failed. " ++ "All commands from port %02x:%02x:%02x:%02x:%02x:%02x:" ++ "%02x:%02x will be refused", ha->instance, ++ fcport->port_name[0], fcport->port_name[1], ++ fcport->port_name[2], fcport->port_name[3], ++ fcport->port_name[4], fcport->port_name[5], ++ fcport->port_name[6], fcport->port_name[7]); ++ goto out_free_sess; ++ } ++ ++ sprintf(wwn_str, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", ++ fcport->port_name[0], fcport->port_name[1], ++ fcport->port_name[2], fcport->port_name[3], ++ fcport->port_name[4], fcport->port_name[5], ++ fcport->port_name[6], fcport->port_name[7]); ++ ++ /* Let's do the session creation async'ly */ ++ sess->scst_sess = scst_register_session(tgt->scst_tgt, 1, wwn_str, ++ sess, sess, q2t_alloc_session_done); ++ if (sess->scst_sess == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): scst_register_session() " ++ "failed for host %ld (wwn %s, loop_id %d), all " ++ "commands from it will be refused", ha->instance, ++ ha->host_no, wwn_str, fcport->loop_id); ++ goto out_free_sess_wwn; ++ } ++ ++ TRACE_MGMT_DBG("Adding sess %p to tgt %p", sess, tgt); ++ ++ spin_lock_irq(&pha->hardware_lock); ++ list_add_tail(&sess->sess_list_entry, &tgt->sess_list); ++ tgt->sess_count++; ++ spin_unlock_irq(&pha->hardware_lock); ++ ++ PRINT_INFO("qla2x00t(%ld): %ssession for wwn %s (loop_id %d, " ++ "s_id %x:%x:%x, confirmed completion %ssupported) added", ++ ha->instance, local ? "local " : "", wwn_str, fcport->loop_id, ++ sess->s_id.b.domain, sess->s_id.b.area, sess->s_id.b.al_pa, ++ sess->conf_compl_supported ? "" : "not "); ++ ++ kfree(wwn_str); ++ ++out: ++ TRACE_EXIT_HRES(sess); ++ return sess; ++ ++out_free_sess_wwn: ++ kfree(wwn_str); ++ /* go through */ ++ ++out_free_sess: ++ kfree(sess); ++ sess = NULL; ++ goto out; ++} ++ ++static void q2t_fc_port_added(scsi_qla_host_t *ha, fc_port_t *fcport) ++{ ++ struct q2t_tgt *tgt; ++ struct q2t_sess *sess; ++ scsi_qla_host_t *pha = to_qla_parent(ha); ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&ha->tgt_mutex); ++ ++ tgt = ha->tgt; ++ ++ if ((tgt == NULL) || (fcport->port_type != FCT_INITIATOR)) ++ goto out_unlock; ++ ++ if (tgt->tgt_stop) ++ goto out_unlock; ++ ++ spin_lock_irq(&pha->hardware_lock); ++ ++ sess = q2t_find_sess_by_port_name(tgt, fcport->port_name); ++ if (sess == NULL) { ++ spin_unlock_irq(&pha->hardware_lock); ++ sess = q2t_create_sess(ha, fcport, false); ++ spin_lock_irq(&pha->hardware_lock); ++ if (sess != NULL) ++ q2t_sess_put(sess); /* put the extra creation ref */ ++ } else { ++ if (sess->deleted) { ++ q2t_undelete_sess(sess); ++ ++ PRINT_INFO("qla2x00t(%ld): %ssession for port %02x:" ++ "%02x:%02x:%02x:%02x:%02x:%02x:%02x (loop ID %d) " ++ "reappeared", sess->tgt->ha->instance, ++ sess->local ? "local " : "", sess->port_name[0], ++ sess->port_name[1], sess->port_name[2], ++ sess->port_name[3], sess->port_name[4], ++ sess->port_name[5], sess->port_name[6], ++ sess->port_name[7], sess->loop_id); ++ ++ TRACE_MGMT_DBG("Reappeared sess %p", sess); ++ } ++ sess->s_id = fcport->d_id; ++ sess->loop_id = fcport->loop_id; ++ sess->conf_compl_supported = fcport->conf_compl_supported; ++ } ++ ++ if (sess->local) { ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): local session for " ++ "port %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x " ++ "(loop ID %d) became global", ha->instance, ++ fcport->port_name[0], fcport->port_name[1], ++ fcport->port_name[2], fcport->port_name[3], ++ fcport->port_name[4], fcport->port_name[5], ++ fcport->port_name[6], fcport->port_name[7], ++ sess->loop_id); ++ sess->local = 0; ++ } ++ ++ spin_unlock_irq(&pha->hardware_lock); ++ ++out_unlock: ++ mutex_unlock(&ha->tgt_mutex); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void q2t_fc_port_deleted(scsi_qla_host_t *ha, fc_port_t *fcport) ++{ ++ struct q2t_tgt *tgt; ++ struct q2t_sess *sess; ++ scsi_qla_host_t *pha = to_qla_parent(ha); ++ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&ha->tgt_mutex); ++ ++ tgt = ha->tgt; ++ ++ if ((tgt == NULL) || (fcport->port_type != FCT_INITIATOR)) ++ goto out_unlock; ++ ++ if (tgt->tgt_stop) ++ goto out_unlock; ++ ++ spin_lock_irq(&pha->hardware_lock); ++ ++ sess = q2t_find_sess_by_port_name(tgt, fcport->port_name); ++ if (sess == NULL) ++ goto out_unlock_ha; ++ ++ TRACE_MGMT_DBG("sess %p", sess); ++ ++ sess->local = 1; ++ q2t_schedule_sess_for_deletion(sess); ++ ++out_unlock_ha: ++ spin_unlock_irq(&pha->hardware_lock); ++ ++out_unlock: ++ mutex_unlock(&ha->tgt_mutex); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static inline int test_tgt_sess_count(struct q2t_tgt *tgt) ++{ ++ unsigned long flags; ++ int res; ++ scsi_qla_host_t *pha = to_qla_parent(tgt->ha); ++ ++ /* ++ * We need to protect against race, when tgt is freed before or ++ * inside wake_up() ++ */ ++ spin_lock_irqsave(&pha->hardware_lock, flags); ++ TRACE_DBG("tgt %p, empty(sess_list)=%d sess_count=%d", ++ tgt, list_empty(&tgt->sess_list), tgt->sess_count); ++ res = (tgt->sess_count == 0); ++ spin_unlock_irqrestore(&pha->hardware_lock, flags); ++ ++ return res; ++} ++ ++/* Must be called under tgt_host_action_mutex or q2t_unreg_rwsem write locked */ ++static void q2t_target_stop(struct scst_tgt *scst_tgt) ++{ ++ struct q2t_tgt *tgt = (struct q2t_tgt *)scst_tgt_get_tgt_priv(scst_tgt); ++ scsi_qla_host_t *ha = tgt->ha; ++ scsi_qla_host_t *pha = to_qla_parent(ha); ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Stopping target for host %ld(%p)", ha->host_no, ha); ++ ++ /* ++ * Mutex needed to sync with q2t_fc_port_[added,deleted]. ++ * Lock is needed, because we still can get an incoming packet. ++ */ ++ ++ mutex_lock(&ha->tgt_mutex); ++ spin_lock_irq(&pha->hardware_lock); ++ tgt->tgt_stop = 1; ++ q2t_clear_tgt_db(tgt, false); ++ spin_unlock_irq(&pha->hardware_lock); ++ mutex_unlock(&ha->tgt_mutex); ++ ++ cancel_delayed_work_sync(&tgt->sess_del_work); ++ ++ TRACE_MGMT_DBG("Waiting for sess works (tgt %p)", tgt); ++ spin_lock_irq(&tgt->sess_work_lock); ++ while (!list_empty(&tgt->sess_works_list)) { ++ spin_unlock_irq(&tgt->sess_work_lock); ++ flush_scheduled_work(); ++ spin_lock_irq(&tgt->sess_work_lock); ++ } ++ spin_unlock_irq(&tgt->sess_work_lock); ++ ++ TRACE_MGMT_DBG("Waiting for tgt %p: list_empty(sess_list)=%d " ++ "sess_count=%d", tgt, list_empty(&tgt->sess_list), ++ tgt->sess_count); ++ ++ wait_event(tgt->waitQ, test_tgt_sess_count(tgt)); ++ ++ /* Big hammer */ ++ if (!pha->host_shutting_down && qla_tgt_mode_enabled(ha)) ++ qla2x00_disable_tgt_mode(ha); ++ ++ /* Wait for sessions to clear out (just in case) */ ++ wait_event(tgt->waitQ, test_tgt_sess_count(tgt)); ++ ++ TRACE_MGMT_DBG("Waiting for %d IRQ commands to complete (tgt %p)", ++ tgt->irq_cmd_count, tgt); ++ ++ mutex_lock(&ha->tgt_mutex); ++ spin_lock_irq(&pha->hardware_lock); ++ while (tgt->irq_cmd_count != 0) { ++ spin_unlock_irq(&pha->hardware_lock); ++ udelay(2); ++ spin_lock_irq(&pha->hardware_lock); ++ } ++ ha->tgt = NULL; ++ spin_unlock_irq(&pha->hardware_lock); ++ mutex_unlock(&ha->tgt_mutex); ++ ++ TRACE_MGMT_DBG("Stop of tgt %p finished", tgt); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Must be called under tgt_host_action_mutex or q2t_unreg_rwsem write locked */ ++static int q2t_target_release(struct scst_tgt *scst_tgt) ++{ ++ struct q2t_tgt *tgt = (struct q2t_tgt *)scst_tgt_get_tgt_priv(scst_tgt); ++ scsi_qla_host_t *ha = tgt->ha; ++ ++ TRACE_ENTRY(); ++ ++ q2t_target_stop(scst_tgt); ++ ++ ha->q2t_tgt = NULL; ++ scst_tgt_set_tgt_priv(scst_tgt, NULL); ++ ++ TRACE_MGMT_DBG("Release of tgt %p finished", tgt); ++ ++ kfree(tgt); ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static int q2t_sched_sess_work(struct q2t_tgt *tgt, int type, ++ const void *param, unsigned int param_size) ++{ ++ int res; ++ struct q2t_sess_work_param *prm; ++ unsigned long flags; ++ ++ TRACE_ENTRY(); ++ ++ prm = kzalloc(sizeof(*prm), GFP_ATOMIC); ++ if (prm == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): Unable to create session " ++ "work, command will be refused", tgt->ha->instance); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ TRACE_MGMT_DBG("Scheduling work (type %d, prm %p) to find session for " ++ "param %p (size %d, tgt %p)", type, prm, param, param_size, tgt); ++ ++ BUG_ON(param_size > (sizeof(*prm) - ++ offsetof(struct q2t_sess_work_param, cmd))); ++ ++ prm->type = type; ++ memcpy(&prm->cmd, param, param_size); ++ ++ spin_lock_irqsave(&tgt->sess_work_lock, flags); ++ if (!tgt->sess_works_pending) ++ tgt->tm_to_unknown = 0; ++ list_add_tail(&prm->sess_works_list_entry, &tgt->sess_works_list); ++ tgt->sess_works_pending = 1; ++ spin_unlock_irqrestore(&tgt->sess_work_lock, flags); ++ ++ schedule_work(&tgt->sess_work); ++ ++ res = 0; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* ++ * pha->hardware_lock supposed to be held on entry. Might drop it, then reacquire ++ */ ++static void q2x_modify_command_count(scsi_qla_host_t *ha, int cmd_count, ++ int imm_count) ++{ ++ modify_lun_entry_t *pkt; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Sending MODIFY_LUN (ha=%p, cmd=%d, imm=%d)", ++ ha, cmd_count, imm_count); ++ ++ /* Sending marker isn't necessary, since we called from ISR */ ++ ++ pkt = (modify_lun_entry_t *)q2t_req_pkt(ha); ++ if (pkt == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): %s failed: unable to allocate " ++ "request packet", ha->instance, __func__); ++ goto out; ++ } ++ ++ ha->tgt->modify_lun_expected++; ++ ++ pkt->entry_type = MODIFY_LUN_TYPE; ++ pkt->entry_count = 1; ++ if (cmd_count < 0) { ++ pkt->operators = MODIFY_LUN_CMD_SUB; /* Subtract from command count */ ++ pkt->command_count = -cmd_count; ++ } else if (cmd_count > 0) { ++ pkt->operators = MODIFY_LUN_CMD_ADD; /* Add to command count */ ++ pkt->command_count = cmd_count; ++ } ++ ++ if (imm_count < 0) { ++ pkt->operators |= MODIFY_LUN_IMM_SUB; ++ pkt->immed_notify_count = -imm_count; ++ } else if (imm_count > 0) { ++ pkt->operators |= MODIFY_LUN_IMM_ADD; ++ pkt->immed_notify_count = imm_count; ++ } ++ ++ pkt->timeout = 0; /* Use default */ ++ ++ TRACE_BUFFER("MODIFY LUN packet data", pkt, REQUEST_ENTRY_SIZE); ++ ++ q2t_exec_queue(ha); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * pha->hardware_lock supposed to be held on entry. Might drop it, then reacquire ++ */ ++static void q2x_send_notify_ack(scsi_qla_host_t *ha, notify_entry_t *iocb, ++ uint32_t add_flags, uint16_t resp_code, int resp_code_valid, ++ uint16_t srr_flags, uint16_t srr_reject_code, uint8_t srr_explan) ++{ ++ nack_entry_t *ntfy; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Sending NOTIFY_ACK (ha=%p)", ha); ++ ++ /* Send marker if required */ ++ if (q2t_issue_marker(ha, 1) != QLA_SUCCESS) ++ goto out; ++ ++ ntfy = (nack_entry_t *)q2t_req_pkt(ha); ++ if (ntfy == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): %s failed: unable to allocate " ++ "request packet", ha->instance, __func__); ++ goto out; ++ } ++ ++ if (ha->tgt != NULL) ++ ha->tgt->notify_ack_expected++; ++ ++ ntfy->entry_type = NOTIFY_ACK_TYPE; ++ ntfy->entry_count = 1; ++ SET_TARGET_ID(ha, ntfy->target, GET_TARGET_ID(ha, iocb)); ++ ntfy->status = iocb->status; ++ ntfy->task_flags = iocb->task_flags; ++ ntfy->seq_id = iocb->seq_id; ++ /* Do not increment here, the chip isn't decrementing */ ++ /* ntfy->flags = __constant_cpu_to_le16(NOTIFY_ACK_RES_COUNT); */ ++ ntfy->flags |= cpu_to_le16(add_flags); ++ ntfy->srr_rx_id = iocb->srr_rx_id; ++ ntfy->srr_rel_offs = iocb->srr_rel_offs; ++ ntfy->srr_ui = iocb->srr_ui; ++ ntfy->srr_flags = cpu_to_le16(srr_flags); ++ ntfy->srr_reject_code = cpu_to_le16(srr_reject_code); ++ ntfy->srr_reject_code_expl = srr_explan; ++ ntfy->ox_id = iocb->ox_id; ++ ++ if (resp_code_valid) { ++ ntfy->resp_code = cpu_to_le16(resp_code); ++ ntfy->flags |= __constant_cpu_to_le16( ++ NOTIFY_ACK_TM_RESP_CODE_VALID); ++ } ++ ++ TRACE(TRACE_SCSI, "qla2x00t(%ld): Sending Notify Ack Seq %#x -> I %#x " ++ "St %#x RC %#x", ha->instance, ++ le16_to_cpu(iocb->seq_id), GET_TARGET_ID(ha, iocb), ++ le16_to_cpu(iocb->status), le16_to_cpu(ntfy->resp_code)); ++ TRACE_BUFFER("Notify Ack packet data", ntfy, REQUEST_ENTRY_SIZE); ++ ++ q2t_exec_queue(ha); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * pha->hardware_lock supposed to be held on entry. Might drop it, then reacquire ++ */ ++static void q24_send_abts_resp(scsi_qla_host_t *ha, ++ const abts24_recv_entry_t *abts, uint32_t status, bool ids_reversed) ++{ ++ abts24_resp_entry_t *resp; ++ uint32_t f_ctl; ++ uint8_t *p; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Sending task mgmt ABTS response (ha=%p, atio=%p, " ++ "status=%x", ha, abts, status); ++ ++ /* Send marker if required */ ++ if (q2t_issue_marker(ha, 1) != QLA_SUCCESS) ++ goto out; ++ ++ resp = (abts24_resp_entry_t *)q2t_req_pkt(ha); ++ if (resp == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): %s failed: unable to allocate " ++ "request packet", ha->instance, __func__); ++ goto out; ++ } ++ ++ resp->entry_type = ABTS_RESP_24XX; ++ resp->entry_count = 1; ++ resp->nport_handle = abts->nport_handle; ++ resp->vp_index = ha->vp_idx; ++ resp->sof_type = abts->sof_type; ++ resp->exchange_address = abts->exchange_address; ++ resp->fcp_hdr_le = abts->fcp_hdr_le; ++ f_ctl = __constant_cpu_to_le32(F_CTL_EXCH_CONTEXT_RESP | ++ F_CTL_LAST_SEQ | F_CTL_END_SEQ | ++ F_CTL_SEQ_INITIATIVE); ++ p = (uint8_t *)&f_ctl; ++ resp->fcp_hdr_le.f_ctl[0] = *p++; ++ resp->fcp_hdr_le.f_ctl[1] = *p++; ++ resp->fcp_hdr_le.f_ctl[2] = *p; ++ if (ids_reversed) { ++ resp->fcp_hdr_le.d_id[0] = abts->fcp_hdr_le.d_id[0]; ++ resp->fcp_hdr_le.d_id[1] = abts->fcp_hdr_le.d_id[1]; ++ resp->fcp_hdr_le.d_id[2] = abts->fcp_hdr_le.d_id[2]; ++ resp->fcp_hdr_le.s_id[0] = abts->fcp_hdr_le.s_id[0]; ++ resp->fcp_hdr_le.s_id[1] = abts->fcp_hdr_le.s_id[1]; ++ resp->fcp_hdr_le.s_id[2] = abts->fcp_hdr_le.s_id[2]; ++ } else { ++ resp->fcp_hdr_le.d_id[0] = abts->fcp_hdr_le.s_id[0]; ++ resp->fcp_hdr_le.d_id[1] = abts->fcp_hdr_le.s_id[1]; ++ resp->fcp_hdr_le.d_id[2] = abts->fcp_hdr_le.s_id[2]; ++ resp->fcp_hdr_le.s_id[0] = abts->fcp_hdr_le.d_id[0]; ++ resp->fcp_hdr_le.s_id[1] = abts->fcp_hdr_le.d_id[1]; ++ resp->fcp_hdr_le.s_id[2] = abts->fcp_hdr_le.d_id[2]; ++ } ++ resp->exchange_addr_to_abort = abts->exchange_addr_to_abort; ++ if (status == SCST_MGMT_STATUS_SUCCESS) { ++ resp->fcp_hdr_le.r_ctl = R_CTL_BASIC_LINK_SERV | R_CTL_B_ACC; ++ resp->payload.ba_acct.seq_id_valid = SEQ_ID_INVALID; ++ resp->payload.ba_acct.low_seq_cnt = 0x0000; ++ resp->payload.ba_acct.high_seq_cnt = 0xFFFF; ++ resp->payload.ba_acct.ox_id = abts->fcp_hdr_le.ox_id; ++ resp->payload.ba_acct.rx_id = abts->fcp_hdr_le.rx_id; ++ } else { ++ resp->fcp_hdr_le.r_ctl = R_CTL_BASIC_LINK_SERV | R_CTL_B_RJT; ++ resp->payload.ba_rjt.reason_code = ++ BA_RJT_REASON_CODE_UNABLE_TO_PERFORM; ++ /* Other bytes are zero */ ++ } ++ ++ TRACE_BUFFER("ABTS RESP packet data", resp, REQUEST_ENTRY_SIZE); ++ ++ ha->tgt->abts_resp_expected++; ++ ++ q2t_exec_queue(ha); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * pha->hardware_lock supposed to be held on entry. Might drop it, then reacquire ++ */ ++static void q24_retry_term_exchange(scsi_qla_host_t *ha, ++ abts24_resp_fw_entry_t *entry) ++{ ++ ctio7_status1_entry_t *ctio; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Sending retry TERM EXCH CTIO7 (ha=%p)", ha); ++ ++ /* Send marker if required */ ++ if (q2t_issue_marker(ha, 1) != QLA_SUCCESS) ++ goto out; ++ ++ ctio = (ctio7_status1_entry_t *)q2t_req_pkt(ha); ++ if (ctio == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): %s failed: unable to allocate " ++ "request packet", ha->instance, __func__); ++ goto out; ++ } ++ ++ /* ++ * We've got on entrance firmware's response on by us generated ++ * ABTS response. So, in it ID fields are reversed. ++ */ ++ ++ ctio->common.entry_type = CTIO_TYPE7; ++ ctio->common.entry_count = 1; ++ ctio->common.nport_handle = entry->nport_handle; ++ ctio->common.handle = Q2T_SKIP_HANDLE | CTIO_COMPLETION_HANDLE_MARK; ++ ctio->common.timeout = __constant_cpu_to_le16(Q2T_TIMEOUT); ++ ctio->common.vp_index = ha->vp_idx; ++ ctio->common.initiator_id[0] = entry->fcp_hdr_le.d_id[0]; ++ ctio->common.initiator_id[1] = entry->fcp_hdr_le.d_id[1]; ++ ctio->common.initiator_id[2] = entry->fcp_hdr_le.d_id[2]; ++ ctio->common.exchange_addr = entry->exchange_addr_to_abort; ++ ctio->flags = __constant_cpu_to_le16(CTIO7_FLAGS_STATUS_MODE_1 | CTIO7_FLAGS_TERMINATE); ++ ctio->ox_id = entry->fcp_hdr_le.ox_id; ++ ++ TRACE_BUFFER("CTIO7 retry TERM EXCH packet data", ctio, REQUEST_ENTRY_SIZE); ++ ++ q2t_exec_queue(ha); ++ ++ q24_send_abts_resp(ha, (abts24_recv_entry_t *)entry, ++ SCST_MGMT_STATUS_SUCCESS, true); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static int __q24_handle_abts(scsi_qla_host_t *ha, abts24_recv_entry_t *abts, ++ struct q2t_sess *sess) ++{ ++ int res; ++ uint32_t tag = abts->exchange_addr_to_abort; ++ struct q2t_mgmt_cmd *mcmd; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("qla2x00t(%ld): task abort (tag=%d)", ha->instance, ++ tag); ++ ++ mcmd = mempool_alloc(q2t_mgmt_cmd_mempool, GFP_ATOMIC); ++ if (mcmd == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): %s: Allocation of ABORT cmd failed", ++ ha->instance, __func__); ++ res = -ENOMEM; ++ goto out; ++ } ++ memset(mcmd, 0, sizeof(*mcmd)); ++ ++ mcmd->sess = sess; ++ memcpy(&mcmd->orig_iocb.abts, abts, sizeof(mcmd->orig_iocb.abts)); ++ ++ res = scst_rx_mgmt_fn_tag(sess->scst_sess, SCST_ABORT_TASK, tag, ++ SCST_ATOMIC, mcmd); ++ if (res != 0) { ++ PRINT_ERROR("qla2x00t(%ld): scst_rx_mgmt_fn_tag() failed: %d", ++ ha->instance, res); ++ goto out_free; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free: ++ mempool_free(mcmd, q2t_mgmt_cmd_mempool); ++ goto out; ++} ++ ++/* ++ * pha->hardware_lock supposed to be held on entry. Might drop it, then reacquire ++ */ ++static void q24_handle_abts(scsi_qla_host_t *ha, abts24_recv_entry_t *abts) ++{ ++ int rc; ++ uint32_t tag = abts->exchange_addr_to_abort; ++ struct q2t_sess *sess; ++ ++ TRACE_ENTRY(); ++ ++ if (le32_to_cpu(abts->fcp_hdr_le.parameter) & ABTS_PARAM_ABORT_SEQ) { ++ PRINT_ERROR("qla2x00t(%ld): ABTS: Abort Sequence not " ++ "supported", ha->instance); ++ goto out_err; ++ } ++ ++ if (tag == ATIO_EXCHANGE_ADDRESS_UNKNOWN) { ++ TRACE_MGMT_DBG("qla2x00t(%ld): ABTS: Unknown Exchange " ++ "Address received", ha->instance); ++ goto out_err; ++ } ++ ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): task abort (s_id=%x:%x:%x, " ++ "tag=%d, param=%x)", ha->instance, abts->fcp_hdr_le.s_id[2], ++ abts->fcp_hdr_le.s_id[1], abts->fcp_hdr_le.s_id[0], tag, ++ le32_to_cpu(abts->fcp_hdr_le.parameter)); ++ ++ sess = q2t_find_sess_by_s_id_le(ha->tgt, abts->fcp_hdr_le.s_id); ++ if (sess == NULL) { ++ TRACE_MGMT_DBG("qla2x00t(%ld): task abort for unexisting " ++ "session", ha->instance); ++ rc = q2t_sched_sess_work(ha->tgt, Q2T_SESS_WORK_ABORT, abts, ++ sizeof(*abts)); ++ if (rc != 0) { ++ ha->tgt->tm_to_unknown = 1; ++ goto out_err; ++ } ++ goto out; ++ } ++ ++ rc = __q24_handle_abts(ha, abts, sess); ++ if (rc != 0) { ++ PRINT_ERROR("qla2x00t(%ld): scst_rx_mgmt_fn_tag() failed: %d", ++ ha->instance, rc); ++ goto out_err; ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++ ++out_err: ++ q24_send_abts_resp(ha, abts, SCST_MGMT_STATUS_REJECTED, false); ++ goto out; ++} ++ ++/* ++ * pha->hardware_lock supposed to be held on entry. Might drop it, then reacquire ++ */ ++static void q24_send_task_mgmt_ctio(scsi_qla_host_t *ha, ++ struct q2t_mgmt_cmd *mcmd, uint32_t resp_code) ++{ ++ const atio7_entry_t *atio = &mcmd->orig_iocb.atio7; ++ ctio7_status1_entry_t *ctio; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Sending task mgmt CTIO7 (ha=%p, atio=%p, resp_code=%x", ++ ha, atio, resp_code); ++ ++ /* Send marker if required */ ++ if (q2t_issue_marker(ha, 1) != QLA_SUCCESS) ++ goto out; ++ ++ ctio = (ctio7_status1_entry_t *)q2t_req_pkt(ha); ++ if (ctio == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): %s failed: unable to allocate " ++ "request packet", ha->instance, __func__); ++ goto out; ++ } ++ ++ ctio->common.entry_type = CTIO_TYPE7; ++ ctio->common.entry_count = 1; ++ ctio->common.handle = Q2T_SKIP_HANDLE | CTIO_COMPLETION_HANDLE_MARK; ++ ctio->common.nport_handle = mcmd->sess->loop_id; ++ ctio->common.timeout = __constant_cpu_to_le16(Q2T_TIMEOUT); ++ ctio->common.vp_index = ha->vp_idx; ++ ctio->common.initiator_id[0] = atio->fcp_hdr.s_id[2]; ++ ctio->common.initiator_id[1] = atio->fcp_hdr.s_id[1]; ++ ctio->common.initiator_id[2] = atio->fcp_hdr.s_id[0]; ++ ctio->common.exchange_addr = atio->exchange_addr; ++ ctio->flags = (atio->attr << 9) | __constant_cpu_to_le16( ++ CTIO7_FLAGS_STATUS_MODE_1 | CTIO7_FLAGS_SEND_STATUS); ++ ctio->ox_id = swab16(atio->fcp_hdr.ox_id); ++ ctio->scsi_status = __constant_cpu_to_le16(SS_RESPONSE_INFO_LEN_VALID); ++ ctio->response_len = __constant_cpu_to_le16(8); ++ ((uint32_t *)ctio->sense_data)[0] = cpu_to_be32(resp_code); ++ ++ TRACE_BUFFER("CTIO7 TASK MGMT packet data", ctio, REQUEST_ENTRY_SIZE); ++ ++ q2t_exec_queue(ha); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * pha->hardware_lock supposed to be held on entry. Might drop it, then reacquire ++ */ ++static void q24_send_notify_ack(scsi_qla_host_t *ha, ++ notify24xx_entry_t *iocb, uint16_t srr_flags, ++ uint8_t srr_reject_code, uint8_t srr_explan) ++{ ++ nack24xx_entry_t *nack; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Sending NOTIFY_ACK24 (ha=%p)", ha); ++ ++ /* Send marker if required */ ++ if (q2t_issue_marker(ha, 1) != QLA_SUCCESS) ++ goto out; ++ ++ if (ha->tgt != NULL) ++ ha->tgt->notify_ack_expected++; ++ ++ nack = (nack24xx_entry_t *)q2t_req_pkt(ha); ++ if (nack == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): %s failed: unable to allocate " ++ "request packet", ha->instance, __func__); ++ goto out; ++ } ++ ++ nack->entry_type = NOTIFY_ACK_TYPE; ++ nack->entry_count = 1; ++ nack->nport_handle = iocb->nport_handle; ++ if (le16_to_cpu(iocb->status) == IMM_NTFY_ELS) { ++ nack->flags = iocb->flags & ++ __constant_cpu_to_le32(NOTIFY24XX_FLAGS_PUREX_IOCB); ++ } ++ nack->srr_rx_id = iocb->srr_rx_id; ++ nack->status = iocb->status; ++ nack->status_subcode = iocb->status_subcode; ++ nack->exchange_address = iocb->exchange_address; ++ nack->srr_rel_offs = iocb->srr_rel_offs; ++ nack->srr_ui = iocb->srr_ui; ++ nack->srr_flags = cpu_to_le16(srr_flags); ++ nack->srr_reject_code = srr_reject_code; ++ nack->srr_reject_code_expl = srr_explan; ++ nack->ox_id = iocb->ox_id; ++ nack->vp_index = iocb->vp_index; ++ ++ TRACE(TRACE_SCSI, "qla2x00t(%ld): Sending 24xx Notify Ack %d", ++ ha->instance, nack->status); ++ TRACE_BUFFER("24xx Notify Ack packet data", nack, sizeof(*nack)); ++ ++ q2t_exec_queue(ha); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static uint32_t q2t_convert_to_fc_tm_status(int scst_mstatus) ++{ ++ uint32_t res; ++ ++ switch (scst_mstatus) { ++ case SCST_MGMT_STATUS_SUCCESS: ++ res = FC_TM_SUCCESS; ++ break; ++ case SCST_MGMT_STATUS_TASK_NOT_EXIST: ++ res = FC_TM_BAD_CMD; ++ break; ++ case SCST_MGMT_STATUS_FN_NOT_SUPPORTED: ++ case SCST_MGMT_STATUS_REJECTED: ++ res = FC_TM_REJECT; ++ break; ++ case SCST_MGMT_STATUS_LUN_NOT_EXIST: ++ case SCST_MGMT_STATUS_FAILED: ++ default: ++ res = FC_TM_FAILED; ++ break; ++ } ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* SCST Callback */ ++static void q2t_task_mgmt_fn_done(struct scst_mgmt_cmd *scst_mcmd) ++{ ++ struct q2t_mgmt_cmd *mcmd; ++ unsigned long flags; ++ scsi_qla_host_t *ha, *pha; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("scst_mcmd (%p) status %#x state %#x", scst_mcmd, ++ scst_mcmd->status, scst_mcmd->state); ++ ++ mcmd = scst_mgmt_cmd_get_tgt_priv(scst_mcmd); ++ if (unlikely(mcmd == NULL)) { ++ PRINT_ERROR("qla2x00t: scst_mcmd %p tgt_spec is NULL", mcmd); ++ goto out; ++ } ++ ++ ha = mcmd->sess->tgt->ha; ++ pha = to_qla_parent(ha); ++ ++ spin_lock_irqsave(&pha->hardware_lock, flags); ++ if (IS_FWI2_CAPABLE(ha)) { ++ if (mcmd->flags == Q24_MGMT_SEND_NACK) { ++ q24_send_notify_ack(ha, ++ &mcmd->orig_iocb.notify_entry24, 0, 0, 0); ++ } else { ++ if (scst_mcmd->fn == SCST_ABORT_TASK) ++ q24_send_abts_resp(ha, &mcmd->orig_iocb.abts, ++ scst_mgmt_cmd_get_status(scst_mcmd), ++ false); ++ else ++ q24_send_task_mgmt_ctio(ha, mcmd, ++ q2t_convert_to_fc_tm_status( ++ scst_mgmt_cmd_get_status(scst_mcmd))); ++ } ++ } else { ++ uint32_t resp_code = q2t_convert_to_fc_tm_status( ++ scst_mgmt_cmd_get_status(scst_mcmd)); ++ q2x_send_notify_ack(ha, &mcmd->orig_iocb.notify_entry, 0, ++ resp_code, 1, 0, 0, 0); ++ } ++ spin_unlock_irqrestore(&pha->hardware_lock, flags); ++ ++ scst_mgmt_cmd_set_tgt_priv(scst_mcmd, NULL); ++ mempool_free(mcmd, q2t_mgmt_cmd_mempool); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* No locks */ ++static int q2t_pci_map_calc_cnt(struct q2t_prm *prm) ++{ ++ int res = 0; ++ ++ BUG_ON(prm->cmd->sg_cnt == 0); ++ ++ prm->sg = (struct scatterlist *)prm->cmd->sg; ++ prm->seg_cnt = pci_map_sg(prm->tgt->ha->pdev, prm->cmd->sg, ++ prm->cmd->sg_cnt, prm->cmd->dma_data_direction); ++ if (unlikely(prm->seg_cnt == 0)) ++ goto out_err; ++ ++ prm->cmd->sg_mapped = 1; ++ ++ /* ++ * If greater than four sg entries then we need to allocate ++ * the continuation entries ++ */ ++ if (prm->seg_cnt > prm->tgt->datasegs_per_cmd) { ++ prm->req_cnt += (uint16_t)(prm->seg_cnt - ++ prm->tgt->datasegs_per_cmd) / ++ prm->tgt->datasegs_per_cont; ++ if (((uint16_t)(prm->seg_cnt - prm->tgt->datasegs_per_cmd)) % ++ prm->tgt->datasegs_per_cont) ++ prm->req_cnt++; ++ } ++ ++out: ++ TRACE_DBG("seg_cnt=%d, req_cnt=%d, res=%d", prm->seg_cnt, ++ prm->req_cnt, res); ++ return res; ++ ++out_err: ++ PRINT_ERROR("qla2x00t(%ld): PCI mapping failed: sg_cnt=%d", ++ prm->tgt->ha->instance, prm->cmd->sg_cnt); ++ res = -1; ++ goto out; ++} ++ ++static inline void q2t_unmap_sg(scsi_qla_host_t *ha, struct q2t_cmd *cmd) ++{ ++ EXTRACHECKS_BUG_ON(!cmd->sg_mapped); ++ pci_unmap_sg(ha->pdev, cmd->sg, cmd->sg_cnt, cmd->dma_data_direction); ++ cmd->sg_mapped = 0; ++} ++ ++static int q2t_check_reserve_free_req(scsi_qla_host_t *ha, uint32_t req_cnt) ++{ ++ int res = SCST_TGT_RES_SUCCESS; ++ device_reg_t __iomem *reg; ++ uint32_t cnt; ++ ++ TRACE_ENTRY(); ++ ++ ha = to_qla_parent(ha); ++ reg = ha->iobase; ++ ++ if (ha->req_q_cnt < (req_cnt + 2)) { ++ if (IS_FWI2_CAPABLE(ha)) ++ cnt = (uint16_t)RD_REG_DWORD( ++ ®->isp24.req_q_out); ++ else ++ cnt = qla2x00_debounce_register( ++ ISP_REQ_Q_OUT(ha, ®->isp)); ++ TRACE_DBG("Request ring circled: cnt=%d, " ++ "ha->req_ring_index=%d, ha->req_q_cnt=%d, req_cnt=%d", ++ cnt, ha->req_ring_index, ha->req_q_cnt, req_cnt); ++ if (ha->req_ring_index < cnt) ++ ha->req_q_cnt = cnt - ha->req_ring_index; ++ else ++ ha->req_q_cnt = ha->request_q_length - ++ (ha->req_ring_index - cnt); ++ } ++ ++ if (unlikely(ha->req_q_cnt < (req_cnt + 2))) { ++ TRACE(TRACE_OUT_OF_MEM, "qla2x00t(%ld): There is no room in the " ++ "request ring: ha->req_ring_index=%d, ha->req_q_cnt=%d, " ++ "req_cnt=%d", ha->instance, ha->req_ring_index, ++ ha->req_q_cnt, req_cnt); ++ res = SCST_TGT_RES_QUEUE_FULL; ++ goto out; ++ } ++ ++ ha->req_q_cnt -= req_cnt; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* ++ * pha->hardware_lock supposed to be held on entry. Might drop it, then reacquire ++ */ ++static inline void *q2t_get_req_pkt(scsi_qla_host_t *ha) ++{ ++ ha = to_qla_parent(ha); ++ ++ /* Adjust ring index. */ ++ ha->req_ring_index++; ++ if (ha->req_ring_index == ha->request_q_length) { ++ ha->req_ring_index = 0; ++ ha->request_ring_ptr = ha->request_ring; ++ } else { ++ ha->request_ring_ptr++; ++ } ++ return (cont_entry_t *)ha->request_ring_ptr; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static inline uint32_t q2t_make_handle(scsi_qla_host_t *ha) ++{ ++ uint32_t h; ++ ++ h = ha->current_handle; ++ /* always increment cmd handle */ ++ do { ++ ++h; ++ if (h > MAX_OUTSTANDING_COMMANDS) ++ h = 1; /* 0 is Q2T_NULL_HANDLE */ ++ if (h == ha->current_handle) { ++ TRACE(TRACE_OUT_OF_MEM, "qla2x00t(%ld): Ran out of " ++ "empty cmd slots in ha %p", ha->instance, ha); ++ h = Q2T_NULL_HANDLE; ++ break; ++ } ++ } while ((h == Q2T_NULL_HANDLE) || ++ (h == Q2T_SKIP_HANDLE) || ++ (ha->cmds[h-1] != NULL)); ++ ++ if (h != Q2T_NULL_HANDLE) ++ ha->current_handle = h; ++ ++ return h; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static void q2x_build_ctio_pkt(struct q2t_prm *prm) ++{ ++ uint32_t h; ++ ctio_entry_t *pkt; ++ scsi_qla_host_t *ha = prm->tgt->ha; ++ ++ pkt = (ctio_entry_t *)ha->request_ring_ptr; ++ prm->pkt = pkt; ++ memset(pkt, 0, sizeof(*pkt)); ++ ++ if (prm->tgt->tgt_enable_64bit_addr) ++ pkt->common.entry_type = CTIO_A64_TYPE; ++ else ++ pkt->common.entry_type = CONTINUE_TGT_IO_TYPE; ++ ++ pkt->common.entry_count = (uint8_t)prm->req_cnt; ++ ++ h = q2t_make_handle(ha); ++ if (h != Q2T_NULL_HANDLE) ++ ha->cmds[h-1] = prm->cmd; ++ ++ pkt->common.handle = h | CTIO_COMPLETION_HANDLE_MARK; ++ pkt->common.timeout = __constant_cpu_to_le16(Q2T_TIMEOUT); ++ ++ /* Set initiator ID */ ++ h = GET_TARGET_ID(ha, &prm->cmd->atio.atio2x); ++ SET_TARGET_ID(ha, pkt->common.target, h); ++ ++ pkt->common.rx_id = prm->cmd->atio.atio2x.rx_id; ++ pkt->common.relative_offset = cpu_to_le32(prm->cmd->offset); ++ ++ TRACE(TRACE_DEBUG|TRACE_SCSI, "qla2x00t(%ld): handle(scst_cmd) -> %08x, " ++ "timeout %d L %#x -> I %#x E %#x", ha->instance, ++ pkt->common.handle, Q2T_TIMEOUT, ++ le16_to_cpu(prm->cmd->atio.atio2x.lun), ++ GET_TARGET_ID(ha, &pkt->common), pkt->common.rx_id); ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static int q24_build_ctio_pkt(struct q2t_prm *prm) ++{ ++ uint32_t h; ++ ctio7_status0_entry_t *pkt; ++ scsi_qla_host_t *ha = prm->tgt->ha; ++ atio7_entry_t *atio = &prm->cmd->atio.atio7; ++ int res = SCST_TGT_RES_SUCCESS; ++ ++ TRACE_ENTRY(); ++ ++ pkt = (ctio7_status0_entry_t *)to_qla_parent(ha)->request_ring_ptr; ++ prm->pkt = pkt; ++ memset(pkt, 0, sizeof(*pkt)); ++ ++ pkt->common.entry_type = CTIO_TYPE7; ++ pkt->common.entry_count = (uint8_t)prm->req_cnt; ++ pkt->common.vp_index = ha->vp_idx; ++ ++ h = q2t_make_handle(ha); ++ if (unlikely(h == Q2T_NULL_HANDLE)) { ++ /* ++ * CTIO type 7 from the firmware doesn't provide a way to ++ * know the initiator's LOOP ID, hence we can't find ++ * the session and, so, the command. ++ */ ++ res = SCST_TGT_RES_QUEUE_FULL; ++ goto out; ++ } else ++ ha->cmds[h-1] = prm->cmd; ++ ++ pkt->common.handle = h | CTIO_COMPLETION_HANDLE_MARK; ++ pkt->common.nport_handle = cpu_to_le16(prm->cmd->loop_id); ++ pkt->common.timeout = __constant_cpu_to_le16(Q2T_TIMEOUT); ++ pkt->common.initiator_id[0] = atio->fcp_hdr.s_id[2]; ++ pkt->common.initiator_id[1] = atio->fcp_hdr.s_id[1]; ++ pkt->common.initiator_id[2] = atio->fcp_hdr.s_id[0]; ++ pkt->common.exchange_addr = atio->exchange_addr; ++ pkt->flags |= (atio->attr << 9); ++ pkt->ox_id = swab16(atio->fcp_hdr.ox_id); ++ pkt->relative_offset = cpu_to_le32(prm->cmd->offset); ++ ++out: ++ TRACE(TRACE_DEBUG|TRACE_SCSI, "qla2x00t(%ld): handle(scst_cmd) -> %08x, " ++ "timeout %d, ox_id %#x", ha->instance, pkt->common.handle, ++ Q2T_TIMEOUT, le16_to_cpu(pkt->ox_id)); ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* ++ * pha->hardware_lock supposed to be held on entry. We have already made sure ++ * that there is sufficient amount of request entries to not drop it. ++ */ ++static void q2t_load_cont_data_segments(struct q2t_prm *prm) ++{ ++ int cnt; ++ uint32_t *dword_ptr; ++ int enable_64bit_addressing = prm->tgt->tgt_enable_64bit_addr; ++ ++ TRACE_ENTRY(); ++ ++ /* Build continuation packets */ ++ while (prm->seg_cnt > 0) { ++ cont_a64_entry_t *cont_pkt64 = ++ (cont_a64_entry_t *)q2t_get_req_pkt(prm->tgt->ha); ++ ++ /* ++ * Make sure that from cont_pkt64 none of ++ * 64-bit specific fields used for 32-bit ++ * addressing. Cast to (cont_entry_t *) for ++ * that. ++ */ ++ ++ memset(cont_pkt64, 0, sizeof(*cont_pkt64)); ++ ++ cont_pkt64->entry_count = 1; ++ cont_pkt64->sys_define = 0; ++ ++ if (enable_64bit_addressing) { ++ cont_pkt64->entry_type = CONTINUE_A64_TYPE; ++ dword_ptr = ++ (uint32_t *)&cont_pkt64->dseg_0_address; ++ } else { ++ cont_pkt64->entry_type = CONTINUE_TYPE; ++ dword_ptr = ++ (uint32_t *)&((cont_entry_t *) ++ cont_pkt64)->dseg_0_address; ++ } ++ ++ /* Load continuation entry data segments */ ++ for (cnt = 0; ++ cnt < prm->tgt->datasegs_per_cont && prm->seg_cnt; ++ cnt++, prm->seg_cnt--) { ++ *dword_ptr++ = ++ cpu_to_le32(pci_dma_lo32 ++ (sg_dma_address(prm->sg))); ++ if (enable_64bit_addressing) { ++ *dword_ptr++ = ++ cpu_to_le32(pci_dma_hi32 ++ (sg_dma_address ++ (prm->sg))); ++ } ++ *dword_ptr++ = cpu_to_le32(sg_dma_len(prm->sg)); ++ ++ TRACE_SG("S/G Segment Cont. phys_addr=%llx:%llx, len=%d", ++ (long long unsigned int)pci_dma_hi32(sg_dma_address(prm->sg)), ++ (long long unsigned int)pci_dma_lo32(sg_dma_address(prm->sg)), ++ (int)sg_dma_len(prm->sg)); ++ ++ prm->sg++; ++ } ++ ++ TRACE_BUFFER("Continuation packet data", ++ cont_pkt64, REQUEST_ENTRY_SIZE); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * pha->hardware_lock supposed to be held on entry. We have already made sure ++ * that there is sufficient amount of request entries to not drop it. ++ */ ++static void q2x_load_data_segments(struct q2t_prm *prm) ++{ ++ int cnt; ++ uint32_t *dword_ptr; ++ int enable_64bit_addressing = prm->tgt->tgt_enable_64bit_addr; ++ ctio_common_entry_t *pkt = (ctio_common_entry_t *)prm->pkt; ++ ++ TRACE_DBG("iocb->scsi_status=%x, iocb->flags=%x", ++ le16_to_cpu(pkt->scsi_status), le16_to_cpu(pkt->flags)); ++ ++ pkt->transfer_length = cpu_to_le32(prm->cmd->bufflen); ++ ++ /* Setup packet address segment pointer */ ++ dword_ptr = pkt->dseg_0_address; ++ ++ if (prm->seg_cnt == 0) { ++ /* No data transfer */ ++ *dword_ptr++ = 0; ++ *dword_ptr = 0; ++ ++ TRACE_BUFFER("No data, CTIO packet data", pkt, ++ REQUEST_ENTRY_SIZE); ++ goto out; ++ } ++ ++ /* Set total data segment count */ ++ pkt->dseg_count = cpu_to_le16(prm->seg_cnt); ++ ++ /* If scatter gather */ ++ TRACE_SG("%s", "Building S/G data segments..."); ++ /* Load command entry data segments */ ++ for (cnt = 0; ++ (cnt < prm->tgt->datasegs_per_cmd) && prm->seg_cnt; ++ cnt++, prm->seg_cnt--) { ++ *dword_ptr++ = ++ cpu_to_le32(pci_dma_lo32(sg_dma_address(prm->sg))); ++ if (enable_64bit_addressing) { ++ *dword_ptr++ = ++ cpu_to_le32(pci_dma_hi32 ++ (sg_dma_address(prm->sg))); ++ } ++ *dword_ptr++ = cpu_to_le32(sg_dma_len(prm->sg)); ++ ++ TRACE_SG("S/G Segment phys_addr=%llx:%llx, len=%d", ++ (long long unsigned int)pci_dma_hi32(sg_dma_address(prm->sg)), ++ (long long unsigned int)pci_dma_lo32(sg_dma_address(prm->sg)), ++ (int)sg_dma_len(prm->sg)); ++ ++ prm->sg++; ++ } ++ ++ TRACE_BUFFER("Scatter/gather, CTIO packet data", pkt, ++ REQUEST_ENTRY_SIZE); ++ ++ q2t_load_cont_data_segments(prm); ++ ++out: ++ return; ++} ++ ++/* ++ * pha->hardware_lock supposed to be held on entry. We have already made sure ++ * that there is sufficient amount of request entries to not drop it. ++ */ ++static void q24_load_data_segments(struct q2t_prm *prm) ++{ ++ int cnt; ++ uint32_t *dword_ptr; ++ int enable_64bit_addressing = prm->tgt->tgt_enable_64bit_addr; ++ ctio7_status0_entry_t *pkt = (ctio7_status0_entry_t *)prm->pkt; ++ ++ TRACE_DBG("iocb->scsi_status=%x, iocb->flags=%x", ++ le16_to_cpu(pkt->scsi_status), le16_to_cpu(pkt->flags)); ++ ++ pkt->transfer_length = cpu_to_le32(prm->cmd->bufflen); ++ ++ /* Setup packet address segment pointer */ ++ dword_ptr = pkt->dseg_0_address; ++ ++ if (prm->seg_cnt == 0) { ++ /* No data transfer */ ++ *dword_ptr++ = 0; ++ *dword_ptr = 0; ++ ++ TRACE_BUFFER("No data, CTIO7 packet data", pkt, ++ REQUEST_ENTRY_SIZE); ++ goto out; ++ } ++ ++ /* Set total data segment count */ ++ pkt->common.dseg_count = cpu_to_le16(prm->seg_cnt); ++ ++ /* If scatter gather */ ++ TRACE_SG("%s", "Building S/G data segments..."); ++ /* Load command entry data segments */ ++ for (cnt = 0; ++ (cnt < prm->tgt->datasegs_per_cmd) && prm->seg_cnt; ++ cnt++, prm->seg_cnt--) { ++ *dword_ptr++ = ++ cpu_to_le32(pci_dma_lo32(sg_dma_address(prm->sg))); ++ if (enable_64bit_addressing) { ++ *dword_ptr++ = ++ cpu_to_le32(pci_dma_hi32( ++ sg_dma_address(prm->sg))); ++ } ++ *dword_ptr++ = cpu_to_le32(sg_dma_len(prm->sg)); ++ ++ TRACE_SG("S/G Segment phys_addr=%llx:%llx, len=%d", ++ (long long unsigned int)pci_dma_hi32(sg_dma_address( ++ prm->sg)), ++ (long long unsigned int)pci_dma_lo32(sg_dma_address( ++ prm->sg)), ++ (int)sg_dma_len(prm->sg)); ++ ++ prm->sg++; ++ } ++ ++ q2t_load_cont_data_segments(prm); ++ ++out: ++ return; ++} ++ ++static inline int q2t_has_data(struct q2t_cmd *cmd) ++{ ++ return cmd->bufflen > 0; ++} ++ ++static int q2t_pre_xmit_response(struct q2t_cmd *cmd, ++ struct q2t_prm *prm, int xmit_type, unsigned long *flags) ++{ ++ int res; ++ struct q2t_tgt *tgt = cmd->tgt; ++ scsi_qla_host_t *ha = tgt->ha; ++ scsi_qla_host_t *pha = to_qla_parent(ha); ++ uint16_t full_req_cnt; ++ struct scst_cmd *scst_cmd = cmd->scst_cmd; ++ ++ TRACE_ENTRY(); ++ ++ if (unlikely(cmd->aborted)) { ++ TRACE_MGMT_DBG("qla2x00t(%ld): terminating exchange " ++ "for aborted cmd=%p (scst_cmd=%p, tag=%d)", ++ ha->instance, cmd, scst_cmd, cmd->tag); ++ ++ cmd->state = Q2T_STATE_ABORTED; ++ scst_set_delivery_status(scst_cmd, SCST_CMD_DELIVERY_ABORTED); ++ ++ if (IS_FWI2_CAPABLE(ha)) ++ q24_send_term_exchange(ha, cmd, &cmd->atio.atio7, 0); ++ else ++ q2x_send_term_exchange(ha, cmd, &cmd->atio.atio2x, 0); ++ /* !! At this point cmd could be already freed !! */ ++ res = Q2T_PRE_XMIT_RESP_CMD_ABORTED; ++ goto out; ++ } ++ ++ TRACE(TRACE_SCSI, "qla2x00t(%ld): tag=%lld", ha->instance, ++ scst_cmd_get_tag(scst_cmd)); ++ ++ prm->cmd = cmd; ++ prm->tgt = tgt; ++ prm->rq_result = scst_cmd_get_status(scst_cmd); ++ prm->sense_buffer = scst_cmd_get_sense_buffer(scst_cmd); ++ prm->sense_buffer_len = scst_cmd_get_sense_buffer_len(scst_cmd); ++ prm->sg = NULL; ++ prm->seg_cnt = -1; ++ prm->req_cnt = 1; ++ prm->add_status_pkt = 0; ++ ++ TRACE_DBG("rq_result=%x, xmit_type=%x", prm->rq_result, xmit_type); ++ if (prm->rq_result != 0) ++ TRACE_BUFFER("Sense", prm->sense_buffer, prm->sense_buffer_len); ++ ++ /* Send marker if required */ ++ if (q2t_issue_marker(ha, 0) != QLA_SUCCESS) { ++ res = SCST_TGT_RES_FATAL_ERROR; ++ goto out; ++ } ++ ++ TRACE_DBG("CTIO start: ha(%d)", (int)ha->instance); ++ ++ if ((xmit_type & Q2T_XMIT_DATA) && q2t_has_data(cmd)) { ++ if (q2t_pci_map_calc_cnt(prm) != 0) { ++ res = SCST_TGT_RES_QUEUE_FULL; ++ goto out; ++ } ++ } ++ ++ full_req_cnt = prm->req_cnt; ++ ++ if (xmit_type & Q2T_XMIT_STATUS) { ++ /* Bidirectional transfers not supported (yet) */ ++ if (unlikely(scst_get_resid(scst_cmd, &prm->residual, NULL))) { ++ if (prm->residual > 0) { ++ TRACE_DBG("Residual underflow: %d (tag %lld, " ++ "op %x, bufflen %d, rq_result %x)", ++ prm->residual, scst_cmd->tag, ++ scst_cmd->cdb[0], cmd->bufflen, ++ prm->rq_result); ++ prm->rq_result |= SS_RESIDUAL_UNDER; ++ } else if (prm->residual < 0) { ++ TRACE_DBG("Residual overflow: %d (tag %lld, " ++ "op %x, bufflen %d, rq_result %x)", ++ prm->residual, scst_cmd->tag, ++ scst_cmd->cdb[0], cmd->bufflen, ++ prm->rq_result); ++ prm->rq_result |= SS_RESIDUAL_OVER; ++ prm->residual = -prm->residual; ++ } ++ } ++ ++ /* ++ * If Q2T_XMIT_DATA is not set, add_status_pkt will be ignored ++ * in *xmit_response() below ++ */ ++ if (q2t_has_data(cmd)) { ++ if (SCST_SENSE_VALID(prm->sense_buffer) || ++ (IS_FWI2_CAPABLE(ha) && ++ (prm->rq_result != 0))) { ++ prm->add_status_pkt = 1; ++ full_req_cnt++; ++ } ++ } ++ } ++ ++ TRACE_DBG("req_cnt=%d, full_req_cnt=%d, add_status_pkt=%d", ++ prm->req_cnt, full_req_cnt, prm->add_status_pkt); ++ ++ /* Acquire ring specific lock */ ++ spin_lock_irqsave(&pha->hardware_lock, *flags); ++ ++ /* Does F/W have an IOCBs for this request */ ++ res = q2t_check_reserve_free_req(ha, full_req_cnt); ++ if (unlikely(res != SCST_TGT_RES_SUCCESS) && ++ (xmit_type & Q2T_XMIT_DATA)) ++ goto out_unlock_free_unmap; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_unlock_free_unmap: ++ if (cmd->sg_mapped) ++ q2t_unmap_sg(ha, cmd); ++ ++ /* Release ring specific lock */ ++ spin_unlock_irqrestore(&pha->hardware_lock, *flags); ++ goto out; ++} ++ ++static inline int q2t_need_explicit_conf(scsi_qla_host_t *ha, ++ struct q2t_cmd *cmd, int sending_sense) ++{ ++ if (ha->enable_class_2) ++ return 0; ++ ++ if (sending_sense) ++ return cmd->conf_compl_supported; ++ else ++ return ha->enable_explicit_conf && cmd->conf_compl_supported; ++} ++ ++static void q2x_init_ctio_ret_entry(ctio_ret_entry_t *ctio_m1, ++ struct q2t_prm *prm) ++{ ++ TRACE_ENTRY(); ++ ++ prm->sense_buffer_len = min((uint32_t)prm->sense_buffer_len, ++ (uint32_t)sizeof(ctio_m1->sense_data)); ++ ++ ctio_m1->flags = __constant_cpu_to_le16(OF_SSTS | OF_FAST_POST | ++ OF_NO_DATA | OF_SS_MODE_1); ++ ctio_m1->flags |= __constant_cpu_to_le16(OF_INC_RC); ++ if (q2t_need_explicit_conf(prm->tgt->ha, prm->cmd, 0)) { ++ ctio_m1->flags |= __constant_cpu_to_le16(OF_EXPL_CONF | ++ OF_CONF_REQ); ++ } ++ ctio_m1->scsi_status = cpu_to_le16(prm->rq_result); ++ ctio_m1->residual = cpu_to_le32(prm->residual); ++ if (SCST_SENSE_VALID(prm->sense_buffer)) { ++ if (q2t_need_explicit_conf(prm->tgt->ha, prm->cmd, 1)) { ++ ctio_m1->flags |= __constant_cpu_to_le16(OF_EXPL_CONF | ++ OF_CONF_REQ); ++ } ++ ctio_m1->scsi_status |= __constant_cpu_to_le16( ++ SS_SENSE_LEN_VALID); ++ ctio_m1->sense_length = cpu_to_le16(prm->sense_buffer_len); ++ memcpy(ctio_m1->sense_data, prm->sense_buffer, ++ prm->sense_buffer_len); ++ } else { ++ memset(ctio_m1->sense_data, 0, sizeof(ctio_m1->sense_data)); ++ ctio_m1->sense_length = 0; ++ } ++ ++ /* Sense with len > 26, is it possible ??? */ ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int __q2x_xmit_response(struct q2t_cmd *cmd, int xmit_type) ++{ ++ int res; ++ unsigned long flags; ++ scsi_qla_host_t *ha, *pha; ++ struct q2t_prm prm; ++ ctio_common_entry_t *pkt; ++ ++ TRACE_ENTRY(); ++ ++ memset(&prm, 0, sizeof(prm)); ++ ++ res = q2t_pre_xmit_response(cmd, &prm, xmit_type, &flags); ++ if (unlikely(res != SCST_TGT_RES_SUCCESS)) { ++ if (res == Q2T_PRE_XMIT_RESP_CMD_ABORTED) ++ res = SCST_TGT_RES_SUCCESS; ++ goto out; ++ } ++ ++ /* Here pha->hardware_lock already locked */ ++ ++ ha = prm.tgt->ha; ++ pha = to_qla_parent(ha); ++ ++ q2x_build_ctio_pkt(&prm); ++ pkt = (ctio_common_entry_t *)prm.pkt; ++ ++ if (q2t_has_data(cmd) && (xmit_type & Q2T_XMIT_DATA)) { ++ pkt->flags |= __constant_cpu_to_le16(OF_FAST_POST | OF_DATA_IN); ++ pkt->flags |= __constant_cpu_to_le16(OF_INC_RC); ++ ++ q2x_load_data_segments(&prm); ++ ++ if (prm.add_status_pkt == 0) { ++ if (xmit_type & Q2T_XMIT_STATUS) { ++ pkt->scsi_status = cpu_to_le16(prm.rq_result); ++ pkt->residual = cpu_to_le32(prm.residual); ++ pkt->flags |= __constant_cpu_to_le16(OF_SSTS); ++ if (q2t_need_explicit_conf(ha, cmd, 0)) { ++ pkt->flags |= __constant_cpu_to_le16( ++ OF_EXPL_CONF | ++ OF_CONF_REQ); ++ } ++ } ++ } else { ++ /* ++ * We have already made sure that there is sufficient ++ * amount of request entries to not drop HW lock in ++ * req_pkt(). ++ */ ++ ctio_ret_entry_t *ctio_m1 = ++ (ctio_ret_entry_t *)q2t_get_req_pkt(ha); ++ ++ TRACE_DBG("%s", "Building additional status packet"); ++ ++ memcpy(ctio_m1, pkt, sizeof(*ctio_m1)); ++ ctio_m1->entry_count = 1; ++ ctio_m1->dseg_count = 0; ++ ++ /* Real finish is ctio_m1's finish */ ++ pkt->handle |= CTIO_INTERMEDIATE_HANDLE_MARK; ++ pkt->flags &= ~__constant_cpu_to_le16(OF_INC_RC); ++ ++ q2x_init_ctio_ret_entry(ctio_m1, &prm); ++ TRACE_BUFFER("Status CTIO packet data", ctio_m1, ++ REQUEST_ENTRY_SIZE); ++ } ++ } else ++ q2x_init_ctio_ret_entry((ctio_ret_entry_t *)pkt, &prm); ++ ++ cmd->state = Q2T_STATE_PROCESSED; /* Mid-level is done processing */ ++ ++ TRACE_BUFFER("Xmitting", pkt, REQUEST_ENTRY_SIZE); ++ ++ q2t_exec_queue(ha); ++ ++ /* Release ring specific lock */ ++ spin_unlock_irqrestore(&pha->hardware_lock, flags); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++#ifdef CONFIG_QLA_TGT_DEBUG_SRR ++static void q2t_check_srr_debug(struct q2t_cmd *cmd, int *xmit_type) ++{ ++#if 0 /* This is not a real status packets lost, so it won't lead to SRR */ ++ if ((*xmit_type & Q2T_XMIT_STATUS) && (scst_random() % 200) == 50) { ++ *xmit_type &= ~Q2T_XMIT_STATUS; ++ TRACE_MGMT_DBG("Dropping cmd %p (tag %d) status", cmd, ++ cmd->tag); ++ } ++#endif ++ ++ if (q2t_has_data(cmd) && (cmd->sg_cnt > 1) && ++ ((scst_random() % 100) == 20)) { ++ int i, leave = 0; ++ unsigned int tot_len = 0; ++ ++ while (leave == 0) ++ leave = scst_random() % cmd->sg_cnt; ++ ++ for (i = 0; i < leave; i++) ++ tot_len += cmd->sg[i].length; ++ ++ TRACE_MGMT_DBG("Cutting cmd %p (tag %d) buffer tail to len %d, " ++ "sg_cnt %d (cmd->bufflen %d, cmd->sg_cnt %d)", cmd, ++ cmd->tag, tot_len, leave, cmd->bufflen, cmd->sg_cnt); ++ ++ cmd->bufflen = tot_len; ++ cmd->sg_cnt = leave; ++ } ++ ++ if (q2t_has_data(cmd) && ((scst_random() % 100) == 70)) { ++ unsigned int offset = scst_random() % cmd->bufflen; ++ ++ TRACE_MGMT_DBG("Cutting cmd %p (tag %d) buffer head " ++ "to offset %d (cmd->bufflen %d)", cmd, cmd->tag, ++ offset, cmd->bufflen); ++ if (offset == 0) ++ *xmit_type &= ~Q2T_XMIT_DATA; ++ else if (q2t_cut_cmd_data_head(cmd, offset)) { ++ TRACE_MGMT_DBG("q2t_cut_cmd_data_head() failed (tag %d)", ++ cmd->tag); ++ } ++ } ++} ++#else ++static inline void q2t_check_srr_debug(struct q2t_cmd *cmd, int *xmit_type) {} ++#endif ++ ++static int q2x_xmit_response(struct scst_cmd *scst_cmd) ++{ ++ int xmit_type = Q2T_XMIT_DATA, res; ++ int is_send_status = scst_cmd_get_is_send_status(scst_cmd); ++ struct q2t_cmd *cmd = (struct q2t_cmd *)scst_cmd_get_tgt_priv(scst_cmd); ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ BUG_ON(!q2t_has_data(cmd) && !is_send_status); ++#endif ++ ++#ifdef CONFIG_QLA_TGT_DEBUG_WORK_IN_THREAD ++ EXTRACHECKS_BUG_ON(scst_cmd_atomic(scst_cmd)); ++#endif ++ ++ if (is_send_status) ++ xmit_type |= Q2T_XMIT_STATUS; ++ ++ cmd->bufflen = scst_cmd_get_adjusted_resp_data_len(scst_cmd); ++ cmd->sg = scst_cmd_get_sg(scst_cmd); ++ cmd->sg_cnt = scst_cmd_get_sg_cnt(scst_cmd); ++ cmd->data_direction = scst_cmd_get_data_direction(scst_cmd); ++ cmd->dma_data_direction = scst_to_tgt_dma_dir(cmd->data_direction); ++ cmd->offset = scst_cmd_get_ppl_offset(scst_cmd); ++ cmd->aborted = scst_cmd_aborted(scst_cmd); ++ ++ q2t_check_srr_debug(cmd, &xmit_type); ++ ++ TRACE_DBG("is_send_status=%x, cmd->bufflen=%d, cmd->sg_cnt=%d, " ++ "cmd->data_direction=%d", is_send_status, cmd->bufflen, ++ cmd->sg_cnt, cmd->data_direction); ++ ++ if (IS_FWI2_CAPABLE(cmd->tgt->ha)) ++ res = __q24_xmit_response(cmd, xmit_type); ++ else ++ res = __q2x_xmit_response(cmd, xmit_type); ++ ++ return res; ++} ++ ++static void q24_init_ctio_ret_entry(ctio7_status0_entry_t *ctio, ++ struct q2t_prm *prm) ++{ ++ ctio7_status1_entry_t *ctio1; ++ ++ TRACE_ENTRY(); ++ ++ prm->sense_buffer_len = min((uint32_t)prm->sense_buffer_len, ++ (uint32_t)sizeof(ctio1->sense_data)); ++ ctio->flags |= __constant_cpu_to_le16(CTIO7_FLAGS_SEND_STATUS); ++ if (q2t_need_explicit_conf(prm->tgt->ha, prm->cmd, 0)) { ++ ctio->flags |= __constant_cpu_to_le16( ++ CTIO7_FLAGS_EXPLICIT_CONFORM | ++ CTIO7_FLAGS_CONFORM_REQ); ++ } ++ ctio->residual = cpu_to_le32(prm->residual); ++ ctio->scsi_status = cpu_to_le16(prm->rq_result); ++ if (SCST_SENSE_VALID(prm->sense_buffer)) { ++ int i; ++ ctio1 = (ctio7_status1_entry_t *)ctio; ++ if (q2t_need_explicit_conf(prm->tgt->ha, prm->cmd, 1)) { ++ ctio1->flags |= __constant_cpu_to_le16( ++ CTIO7_FLAGS_EXPLICIT_CONFORM | ++ CTIO7_FLAGS_CONFORM_REQ); ++ } ++ ctio1->flags &= ~__constant_cpu_to_le16(CTIO7_FLAGS_STATUS_MODE_0); ++ ctio1->flags |= __constant_cpu_to_le16(CTIO7_FLAGS_STATUS_MODE_1); ++ ctio1->scsi_status |= __constant_cpu_to_le16(SS_SENSE_LEN_VALID); ++ ctio1->sense_length = cpu_to_le16(prm->sense_buffer_len); ++ for (i = 0; i < prm->sense_buffer_len/4; i++) ++ ((uint32_t *)ctio1->sense_data)[i] = ++ cpu_to_be32(((uint32_t *)prm->sense_buffer)[i]); ++#if 0 ++ if (unlikely((prm->sense_buffer_len % 4) != 0)) { ++ static int q; ++ if (q < 10) { ++ PRINT_INFO("qla2x00t(%ld): %d bytes of sense " ++ "lost", prm->tgt->ha->instance, ++ prm->sense_buffer_len % 4); ++ q++; ++ } ++ } ++#endif ++ } else { ++ ctio1 = (ctio7_status1_entry_t *)ctio; ++ ctio1->flags &= ~__constant_cpu_to_le16(CTIO7_FLAGS_STATUS_MODE_0); ++ ctio1->flags |= __constant_cpu_to_le16(CTIO7_FLAGS_STATUS_MODE_1); ++ ctio1->sense_length = 0; ++ memset(ctio1->sense_data, 0, sizeof(ctio1->sense_data)); ++ } ++ ++ /* Sense with len > 24, is it possible ??? */ ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int __q24_xmit_response(struct q2t_cmd *cmd, int xmit_type) ++{ ++ int res; ++ unsigned long flags; ++ scsi_qla_host_t *ha, *pha; ++ struct q2t_prm prm; ++ ctio7_status0_entry_t *pkt; ++ ++ TRACE_ENTRY(); ++ ++ memset(&prm, 0, sizeof(prm)); ++ ++ res = q2t_pre_xmit_response(cmd, &prm, xmit_type, &flags); ++ if (unlikely(res != SCST_TGT_RES_SUCCESS)) { ++ if (res == Q2T_PRE_XMIT_RESP_CMD_ABORTED) ++ res = SCST_TGT_RES_SUCCESS; ++ goto out; ++ } ++ ++ /* Here pha->hardware_lock already locked */ ++ ++ ha = prm.tgt->ha; ++ pha = to_qla_parent(ha); ++ ++ res = q24_build_ctio_pkt(&prm); ++ if (unlikely(res != SCST_TGT_RES_SUCCESS)) ++ goto out_unmap_unlock; ++ ++ pkt = (ctio7_status0_entry_t *)prm.pkt; ++ ++ if (q2t_has_data(cmd) && (xmit_type & Q2T_XMIT_DATA)) { ++ pkt->flags |= __constant_cpu_to_le16(CTIO7_FLAGS_DATA_IN | ++ CTIO7_FLAGS_STATUS_MODE_0); ++ ++ q24_load_data_segments(&prm); ++ ++ if (prm.add_status_pkt == 0) { ++ if (xmit_type & Q2T_XMIT_STATUS) { ++ pkt->scsi_status = cpu_to_le16(prm.rq_result); ++ pkt->residual = cpu_to_le32(prm.residual); ++ pkt->flags |= __constant_cpu_to_le16( ++ CTIO7_FLAGS_SEND_STATUS); ++ if (q2t_need_explicit_conf(ha, cmd, 0)) { ++ pkt->flags |= __constant_cpu_to_le16( ++ CTIO7_FLAGS_EXPLICIT_CONFORM | ++ CTIO7_FLAGS_CONFORM_REQ); ++ } ++ } ++ } else { ++ /* ++ * We have already made sure that there is sufficient ++ * amount of request entries to not drop HW lock in ++ * req_pkt(). ++ */ ++ ctio7_status1_entry_t *ctio = ++ (ctio7_status1_entry_t *)q2t_get_req_pkt(ha); ++ ++ TRACE_DBG("%s", "Building additional status packet"); ++ ++ memcpy(ctio, pkt, sizeof(*ctio)); ++ ctio->common.entry_count = 1; ++ ctio->common.dseg_count = 0; ++ ctio->flags &= ~__constant_cpu_to_le16( ++ CTIO7_FLAGS_DATA_IN); ++ ++ /* Real finish is ctio_m1's finish */ ++ pkt->common.handle |= CTIO_INTERMEDIATE_HANDLE_MARK; ++ pkt->flags |= __constant_cpu_to_le16( ++ CTIO7_FLAGS_DONT_RET_CTIO); ++ q24_init_ctio_ret_entry((ctio7_status0_entry_t *)ctio, ++ &prm); ++ TRACE_BUFFER("Status CTIO7", ctio, REQUEST_ENTRY_SIZE); ++ } ++ } else ++ q24_init_ctio_ret_entry(pkt, &prm); ++ ++ cmd->state = Q2T_STATE_PROCESSED; /* Mid-level is done processing */ ++ ++ TRACE_BUFFER("Xmitting CTIO7", pkt, REQUEST_ENTRY_SIZE); ++ ++ q2t_exec_queue(ha); ++ ++out_unlock: ++ /* Release ring specific lock */ ++ spin_unlock_irqrestore(&pha->hardware_lock, flags); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_unmap_unlock: ++ if (cmd->sg_mapped) ++ q2t_unmap_sg(ha, cmd); ++ goto out_unlock; ++} ++ ++static int __q2t_rdy_to_xfer(struct q2t_cmd *cmd) ++{ ++ int res = SCST_TGT_RES_SUCCESS; ++ unsigned long flags; ++ scsi_qla_host_t *ha, *pha; ++ struct q2t_tgt *tgt = cmd->tgt; ++ struct q2t_prm prm; ++ void *p; ++ ++ TRACE_ENTRY(); ++ ++ memset(&prm, 0, sizeof(prm)); ++ prm.cmd = cmd; ++ prm.tgt = tgt; ++ prm.sg = NULL; ++ prm.req_cnt = 1; ++ ha = tgt->ha; ++ pha = to_qla_parent(ha); ++ ++ /* Send marker if required */ ++ if (q2t_issue_marker(ha, 0) != QLA_SUCCESS) { ++ res = SCST_TGT_RES_FATAL_ERROR; ++ goto out; ++ } ++ ++ TRACE_DBG("CTIO_start: ha(%d)", (int)ha->instance); ++ ++ /* Calculate number of entries and segments required */ ++ if (q2t_pci_map_calc_cnt(&prm) != 0) { ++ res = SCST_TGT_RES_QUEUE_FULL; ++ goto out; ++ } ++ ++ /* Acquire ring specific lock */ ++ spin_lock_irqsave(&pha->hardware_lock, flags); ++ ++ /* Does F/W have an IOCBs for this request */ ++ res = q2t_check_reserve_free_req(ha, prm.req_cnt); ++ if (res != SCST_TGT_RES_SUCCESS) ++ goto out_unlock_free_unmap; ++ ++ if (IS_FWI2_CAPABLE(ha)) { ++ ctio7_status0_entry_t *pkt; ++ res = q24_build_ctio_pkt(&prm); ++ if (unlikely(res != SCST_TGT_RES_SUCCESS)) ++ goto out_unlock_free_unmap; ++ pkt = (ctio7_status0_entry_t *)prm.pkt; ++ pkt->flags |= __constant_cpu_to_le16(CTIO7_FLAGS_DATA_OUT | ++ CTIO7_FLAGS_STATUS_MODE_0); ++ q24_load_data_segments(&prm); ++ p = pkt; ++ } else { ++ ctio_common_entry_t *pkt; ++ q2x_build_ctio_pkt(&prm); ++ pkt = (ctio_common_entry_t *)prm.pkt; ++ pkt->flags = __constant_cpu_to_le16(OF_FAST_POST | OF_DATA_OUT); ++ q2x_load_data_segments(&prm); ++ p = pkt; ++ } ++ ++ cmd->state = Q2T_STATE_NEED_DATA; ++ ++ TRACE_BUFFER("Xfering", p, REQUEST_ENTRY_SIZE); ++ ++ q2t_exec_queue(ha); ++ ++out_unlock: ++ /* Release ring specific lock */ ++ spin_unlock_irqrestore(&pha->hardware_lock, flags); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_unlock_free_unmap: ++ if (cmd->sg_mapped) ++ q2t_unmap_sg(ha, cmd); ++ goto out_unlock; ++} ++ ++static int q2t_rdy_to_xfer(struct scst_cmd *scst_cmd) ++{ ++ int res; ++ struct q2t_cmd *cmd; ++ ++ TRACE_ENTRY(); ++ ++ TRACE(TRACE_SCSI, "qla2x00t: tag=%lld", scst_cmd_get_tag(scst_cmd)); ++ ++ cmd = (struct q2t_cmd *)scst_cmd_get_tgt_priv(scst_cmd); ++ cmd->bufflen = scst_cmd_get_write_fields(scst_cmd, &cmd->sg, ++ &cmd->sg_cnt); ++ cmd->data_direction = scst_cmd_get_data_direction(scst_cmd); ++ cmd->dma_data_direction = scst_to_tgt_dma_dir(cmd->data_direction); ++ ++ res = __q2t_rdy_to_xfer(cmd); ++ ++ TRACE_EXIT(); ++ return res; ++} ++ ++/* If hardware_lock held on entry, might drop it, then reacquire */ ++static void q2x_send_term_exchange(scsi_qla_host_t *ha, struct q2t_cmd *cmd, ++ atio_entry_t *atio, int ha_locked) ++{ ++ ctio_ret_entry_t *ctio; ++ unsigned long flags = 0; /* to stop compiler's warning */ ++ int do_tgt_cmd_done = 0; ++ scsi_qla_host_t *pha = to_qla_parent(ha); ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Sending TERM EXCH CTIO (ha=%p)", ha); ++ ++ /* Send marker if required */ ++ if (q2t_issue_marker(ha, ha_locked) != QLA_SUCCESS) ++ goto out; ++ ++ if (!ha_locked) ++ spin_lock_irqsave(&pha->hardware_lock, flags); ++ ++ ctio = (ctio_ret_entry_t *)q2t_req_pkt(ha); ++ if (ctio == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): %s failed: unable to allocate " ++ "request packet", ha->instance, __func__); ++ goto out_unlock; ++ } ++ ++ ctio->entry_type = CTIO_RET_TYPE; ++ ctio->entry_count = 1; ++ if (cmd != NULL) { ++ if (cmd->state < Q2T_STATE_PROCESSED) { ++ PRINT_ERROR("qla2x00t(%ld): Terminating cmd %p with " ++ "incorrect state %d", ha->instance, cmd, ++ cmd->state); ++ } else ++ do_tgt_cmd_done = 1; ++ } ++ ctio->handle = Q2T_SKIP_HANDLE | CTIO_COMPLETION_HANDLE_MARK; ++ ++ /* Set IDs */ ++ SET_TARGET_ID(ha, ctio->target, GET_TARGET_ID(ha, atio)); ++ ctio->rx_id = atio->rx_id; ++ ++ /* Most likely, it isn't needed */ ++ ctio->residual = atio->data_length; ++ if (ctio->residual != 0) ++ ctio->scsi_status |= SS_RESIDUAL_UNDER; ++ ++ ctio->flags = __constant_cpu_to_le16(OF_FAST_POST | OF_TERM_EXCH | ++ OF_NO_DATA | OF_SS_MODE_1); ++ ctio->flags |= __constant_cpu_to_le16(OF_INC_RC); ++ ++ TRACE_BUFFER("CTIO TERM EXCH packet data", ctio, REQUEST_ENTRY_SIZE); ++ ++ q2t_exec_queue(ha); ++ ++out_unlock: ++ if (!ha_locked) ++ spin_unlock_irqrestore(&pha->hardware_lock, flags); ++ ++ if (do_tgt_cmd_done) { ++ if (!ha_locked && !in_interrupt()) { ++ msleep(250); /* just in case */ ++ scst_tgt_cmd_done(cmd->scst_cmd, SCST_CONTEXT_DIRECT); ++ } else ++ scst_tgt_cmd_done(cmd->scst_cmd, SCST_CONTEXT_TASKLET); ++ /* !! At this point cmd could be already freed !! */ ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* If hardware_lock held on entry, might drop it, then reacquire */ ++static void q24_send_term_exchange(scsi_qla_host_t *ha, struct q2t_cmd *cmd, ++ atio7_entry_t *atio, int ha_locked) ++{ ++ ctio7_status1_entry_t *ctio; ++ unsigned long flags = 0; /* to stop compiler's warning */ ++ int do_tgt_cmd_done = 0; ++ scsi_qla_host_t *pha = to_qla_parent(ha); ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Sending TERM EXCH CTIO7 (ha=%p)", ha); ++ ++ /* Send marker if required */ ++ if (q2t_issue_marker(ha, ha_locked) != QLA_SUCCESS) ++ goto out; ++ ++ if (!ha_locked) ++ spin_lock_irqsave(&pha->hardware_lock, flags); ++ ++ ctio = (ctio7_status1_entry_t *)q2t_req_pkt(ha); ++ if (ctio == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): %s failed: unable to allocate " ++ "request packet", ha->instance, __func__); ++ goto out_unlock; ++ } ++ ++ ctio->common.entry_type = CTIO_TYPE7; ++ ctio->common.entry_count = 1; ++ if (cmd != NULL) { ++ ctio->common.nport_handle = cmd->loop_id; ++ if (cmd->state < Q2T_STATE_PROCESSED) { ++ PRINT_ERROR("qla2x00t(%ld): Terminating cmd %p with " ++ "incorrect state %d", ha->instance, cmd, ++ cmd->state); ++ } else ++ do_tgt_cmd_done = 1; ++ } else ++ ctio->common.nport_handle = CTIO7_NHANDLE_UNRECOGNIZED; ++ ctio->common.handle = Q2T_SKIP_HANDLE | CTIO_COMPLETION_HANDLE_MARK; ++ ctio->common.timeout = __constant_cpu_to_le16(Q2T_TIMEOUT); ++ ctio->common.vp_index = ha->vp_idx; ++ ctio->common.initiator_id[0] = atio->fcp_hdr.s_id[2]; ++ ctio->common.initiator_id[1] = atio->fcp_hdr.s_id[1]; ++ ctio->common.initiator_id[2] = atio->fcp_hdr.s_id[0]; ++ ctio->common.exchange_addr = atio->exchange_addr; ++ ctio->flags = (atio->attr << 9) | __constant_cpu_to_le16( ++ CTIO7_FLAGS_STATUS_MODE_1 | CTIO7_FLAGS_TERMINATE); ++ ctio->ox_id = swab16(atio->fcp_hdr.ox_id); ++ ++ /* Most likely, it isn't needed */ ++ ctio->residual = get_unaligned((uint32_t *) ++ &atio->fcp_cmnd.add_cdb[atio->fcp_cmnd.add_cdb_len]); ++ if (ctio->residual != 0) ++ ctio->scsi_status |= SS_RESIDUAL_UNDER; ++ ++ TRACE_BUFFER("CTIO7 TERM EXCH packet data", ctio, REQUEST_ENTRY_SIZE); ++ ++ q2t_exec_queue(ha); ++ ++out_unlock: ++ if (!ha_locked) ++ spin_unlock_irqrestore(&pha->hardware_lock, flags); ++ ++ if (do_tgt_cmd_done) { ++ if (!ha_locked && !in_interrupt()) { ++ msleep(250); /* just in case */ ++ scst_tgt_cmd_done(cmd->scst_cmd, SCST_CONTEXT_DIRECT); ++ } else ++ scst_tgt_cmd_done(cmd->scst_cmd, SCST_CONTEXT_TASKLET); ++ /* !! At this point cmd could be already freed !! */ ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static inline void q2t_free_cmd(struct q2t_cmd *cmd) ++{ ++ EXTRACHECKS_BUG_ON(cmd->sg_mapped); ++ ++ if (unlikely(cmd->free_sg)) ++ kfree(cmd->sg); ++ kmem_cache_free(q2t_cmd_cachep, cmd); ++} ++ ++static void q2t_on_free_cmd(struct scst_cmd *scst_cmd) ++{ ++ struct q2t_cmd *cmd; ++ ++ TRACE_ENTRY(); ++ ++ TRACE(TRACE_SCSI, "qla2x00t: Freeing command %p, tag %lld", ++ scst_cmd, scst_cmd_get_tag(scst_cmd)); ++ ++ cmd = (struct q2t_cmd *)scst_cmd_get_tgt_priv(scst_cmd); ++ scst_cmd_set_tgt_priv(scst_cmd, NULL); ++ ++ q2t_free_cmd(cmd); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static int q2t_prepare_srr_ctio(scsi_qla_host_t *ha, struct q2t_cmd *cmd, ++ void *ctio) ++{ ++ struct srr_ctio *sc; ++ struct q2t_tgt *tgt = ha->tgt; ++ int res = 0; ++ struct srr_imm *imm; ++ ++ tgt->ctio_srr_id++; ++ ++ TRACE_MGMT_DBG("qla2x00t(%ld): CTIO with SRR " ++ "status received", ha->instance); ++ ++ if (ctio == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): SRR CTIO, " ++ "but ctio is NULL", ha->instance); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (cmd->scst_cmd != NULL) ++ scst_update_hw_pending_start(cmd->scst_cmd); ++ ++ sc = kzalloc(sizeof(*sc), GFP_ATOMIC); ++ if (sc != NULL) { ++ sc->cmd = cmd; ++ /* IRQ is already OFF */ ++ spin_lock(&tgt->srr_lock); ++ sc->srr_id = tgt->ctio_srr_id; ++ list_add_tail(&sc->srr_list_entry, ++ &tgt->srr_ctio_list); ++ TRACE_MGMT_DBG("CTIO SRR %p added (id %d)", ++ sc, sc->srr_id); ++ if (tgt->imm_srr_id == tgt->ctio_srr_id) { ++ int found = 0; ++ list_for_each_entry(imm, &tgt->srr_imm_list, ++ srr_list_entry) { ++ if (imm->srr_id == sc->srr_id) { ++ found = 1; ++ break; ++ } ++ } ++ if (found) { ++ TRACE_MGMT_DBG("%s", "Scheduling srr work"); ++ schedule_work(&tgt->srr_work); ++ } else { ++ PRINT_ERROR("qla2x00t(%ld): imm_srr_id " ++ "== ctio_srr_id (%d), but there is no " ++ "corresponding SRR IMM, deleting CTIO " ++ "SRR %p", ha->instance, tgt->ctio_srr_id, ++ sc); ++ list_del(&sc->srr_list_entry); ++ spin_unlock(&tgt->srr_lock); ++ ++ kfree(sc); ++ res = -EINVAL; ++ goto out; ++ } ++ } ++ spin_unlock(&tgt->srr_lock); ++ } else { ++ struct srr_imm *ti; ++ PRINT_ERROR("qla2x00t(%ld): Unable to allocate SRR CTIO entry", ++ ha->instance); ++ spin_lock(&tgt->srr_lock); ++ list_for_each_entry_safe(imm, ti, &tgt->srr_imm_list, ++ srr_list_entry) { ++ if (imm->srr_id == tgt->ctio_srr_id) { ++ TRACE_MGMT_DBG("IMM SRR %p deleted " ++ "(id %d)", imm, imm->srr_id); ++ list_del(&imm->srr_list_entry); ++ q2t_reject_free_srr_imm(ha, imm, 1); ++ } ++ } ++ spin_unlock(&tgt->srr_lock); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* ++ * pha->hardware_lock supposed to be held on entry. Might drop it, then reacquire ++ */ ++static int q2t_term_ctio_exchange(scsi_qla_host_t *ha, void *ctio, ++ struct q2t_cmd *cmd, uint32_t status) ++{ ++ int term = 0; ++ ++ if (IS_FWI2_CAPABLE(ha)) { ++ if (ctio != NULL) { ++ ctio7_fw_entry_t *c = (ctio7_fw_entry_t *)ctio; ++ term = !(c->flags & ++ __constant_cpu_to_le16(OF_TERM_EXCH)); ++ } else ++ term = 1; ++ if (term) { ++ q24_send_term_exchange(ha, cmd, ++ &cmd->atio.atio7, 1); ++ } ++ } else { ++ if (status != CTIO_SUCCESS) ++ q2x_modify_command_count(ha, 1, 0); ++#if 0 /* seems, it isn't needed */ ++ if (ctio != NULL) { ++ ctio_common_entry_t *c = (ctio_common_entry_t *)ctio; ++ term = !(c->flags & ++ __constant_cpu_to_le16( ++ CTIO7_FLAGS_TERMINATE)); ++ } else ++ term = 1; ++ if (term) { ++ q2x_send_term_exchange(ha, cmd, ++ &cmd->atio.atio2x, 1); ++ } ++#endif ++ } ++ return term; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static inline struct q2t_cmd *q2t_get_cmd(scsi_qla_host_t *ha, uint32_t handle) ++{ ++ handle--; ++ if (ha->cmds[handle] != NULL) { ++ struct q2t_cmd *cmd = ha->cmds[handle]; ++ ha->cmds[handle] = NULL; ++ return cmd; ++ } else ++ return NULL; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static struct q2t_cmd *q2t_ctio_to_cmd(scsi_qla_host_t *ha, uint32_t handle, ++ void *ctio) ++{ ++ struct q2t_cmd *cmd = NULL; ++ ++ /* Clear out internal marks */ ++ handle &= ~(CTIO_COMPLETION_HANDLE_MARK | CTIO_INTERMEDIATE_HANDLE_MARK); ++ ++ if (handle != Q2T_NULL_HANDLE) { ++ if (unlikely(handle == Q2T_SKIP_HANDLE)) { ++ TRACE_DBG("%s", "SKIP_HANDLE CTIO"); ++ goto out; ++ } ++ /* handle-1 is actually used */ ++ if (unlikely(handle > MAX_OUTSTANDING_COMMANDS)) { ++ PRINT_ERROR("qla2x00t(%ld): Wrong handle %x " ++ "received", ha->instance, handle); ++ goto out; ++ } ++ cmd = q2t_get_cmd(ha, handle); ++ if (unlikely(cmd == NULL)) { ++ PRINT_WARNING("qla2x00t(%ld): Suspicious: unable to " ++ "find the command with handle %x", ++ ha->instance, handle); ++ goto out; ++ } ++ } else if (ctio != NULL) { ++ uint16_t loop_id; ++ int tag; ++ struct q2t_sess *sess; ++ struct scst_cmd *scst_cmd; ++ ++ if (IS_FWI2_CAPABLE(ha)) { ++ /* We can't get loop ID from CTIO7 */ ++ PRINT_ERROR("qla2x00t(%ld): Wrong CTIO received: " ++ "QLA24xx doesn't support NULL handles", ++ ha->instance); ++ goto out; ++ } else { ++ ctio_common_entry_t *c = (ctio_common_entry_t *)ctio; ++ loop_id = GET_TARGET_ID(ha, c); ++ tag = c->rx_id; ++ } ++ ++ sess = q2t_find_sess_by_loop_id(ha->tgt, loop_id); ++ if (sess == NULL) { ++ PRINT_WARNING("qla2x00t(%ld): Suspicious: " ++ "ctio_completion for non-existing session " ++ "(loop_id %d, tag %d)", ++ ha->instance, loop_id, tag); ++ goto out; ++ } ++ ++ scst_cmd = scst_find_cmd_by_tag(sess->scst_sess, tag); ++ if (scst_cmd == NULL) { ++ PRINT_WARNING("qla2x00t(%ld): Suspicious: unable to " ++ "find the command with tag %d (loop_id %d)", ++ ha->instance, tag, loop_id); ++ goto out; ++ } ++ ++ cmd = (struct q2t_cmd *)scst_cmd_get_tgt_priv(scst_cmd); ++ TRACE_DBG("Found q2t_cmd %p (tag %d)", cmd, tag); ++ } ++ ++out: ++ return cmd; ++} ++ ++/* ++ * pha->hardware_lock supposed to be held on entry. Might drop it, then reacquire ++ */ ++static void q2t_do_ctio_completion(scsi_qla_host_t *ha, uint32_t handle, ++ uint32_t status, void *ctio) ++{ ++ struct scst_cmd *scst_cmd; ++ struct q2t_cmd *cmd; ++ enum scst_exec_context context; ++ ++ TRACE_ENTRY(); ++ ++#ifdef CONFIG_QLA_TGT_DEBUG_WORK_IN_THREAD ++ context = SCST_CONTEXT_THREAD; ++#else ++ context = SCST_CONTEXT_TASKLET; ++#endif ++ ++ TRACE(TRACE_DEBUG|TRACE_SCSI, "qla2x00t(%ld): handle(ctio %p " ++ "status %#x) <- %08x", ha->instance, ctio, status, handle); ++ ++ if (handle & CTIO_INTERMEDIATE_HANDLE_MARK) { ++ /* That could happen only in case of an error/reset/abort */ ++ if (status != CTIO_SUCCESS) { ++ TRACE_MGMT_DBG("Intermediate CTIO received (status %x)", ++ status); ++ } ++ goto out; ++ } ++ ++ cmd = q2t_ctio_to_cmd(ha, handle, ctio); ++ if (cmd == NULL) { ++ if (status != CTIO_SUCCESS) ++ q2t_term_ctio_exchange(ha, ctio, NULL, status); ++ goto out; ++ } ++ ++ scst_cmd = cmd->scst_cmd; ++ ++ if (cmd->sg_mapped) ++ q2t_unmap_sg(ha, cmd); ++ ++ if (unlikely(status != CTIO_SUCCESS)) { ++ switch (status & 0xFFFF) { ++ case CTIO_LIP_RESET: ++ case CTIO_TARGET_RESET: ++ case CTIO_ABORTED: ++ case CTIO_TIMEOUT: ++ case CTIO_INVALID_RX_ID: ++ /* They are OK */ ++ TRACE(TRACE_MINOR_AND_MGMT_DBG, ++ "qla2x00t(%ld): CTIO with " ++ "status %#x received, state %x, scst_cmd %p, " ++ "op %x (LIP_RESET=e, ABORTED=2, TARGET_RESET=17, " ++ "TIMEOUT=b, INVALID_RX_ID=8)", ha->instance, ++ status, cmd->state, scst_cmd, scst_cmd->cdb[0]); ++ break; ++ ++ case CTIO_PORT_LOGGED_OUT: ++ case CTIO_PORT_UNAVAILABLE: ++ PRINT_INFO("qla2x00t(%ld): CTIO with PORT LOGGED " ++ "OUT (29) or PORT UNAVAILABLE (28) status %x " ++ "received (state %x, scst_cmd %p, op %x)", ++ ha->instance, status, cmd->state, scst_cmd, ++ scst_cmd->cdb[0]); ++ break; ++ ++ case CTIO_SRR_RECEIVED: ++ if (q2t_prepare_srr_ctio(ha, cmd, ctio) != 0) ++ break; ++ else ++ goto out; ++ ++ default: ++ PRINT_ERROR("qla2x00t(%ld): CTIO with error status " ++ "0x%x received (state %x, scst_cmd %p, op %x)", ++ ha->instance, status, cmd->state, scst_cmd, ++ scst_cmd->cdb[0]); ++ break; ++ } ++ ++ if (cmd->state != Q2T_STATE_NEED_DATA) ++ if (q2t_term_ctio_exchange(ha, ctio, cmd, status)) ++ goto out; ++ } ++ ++ if (cmd->state == Q2T_STATE_PROCESSED) { ++ TRACE_DBG("Command %p finished", cmd); ++ } else if (cmd->state == Q2T_STATE_NEED_DATA) { ++ int rx_status = SCST_RX_STATUS_SUCCESS; ++ ++ cmd->state = Q2T_STATE_DATA_IN; ++ ++ if (unlikely(status != CTIO_SUCCESS)) ++ rx_status = SCST_RX_STATUS_ERROR; ++ else ++ cmd->write_data_transferred = 1; ++ ++ TRACE_DBG("Data received, context %x, rx_status %d", ++ context, rx_status); ++ ++ scst_rx_data(scst_cmd, rx_status, context); ++ goto out; ++ } else if (cmd->state == Q2T_STATE_ABORTED) { ++ TRACE_MGMT_DBG("Aborted command %p (tag %d) finished", cmd, ++ cmd->tag); ++ } else { ++ PRINT_ERROR("qla2x00t(%ld): A command in state (%d) should " ++ "not return a CTIO complete", ha->instance, cmd->state); ++ } ++ ++ if (unlikely(status != CTIO_SUCCESS)) { ++ TRACE_MGMT_DBG("%s", "Finishing failed CTIO"); ++ scst_set_delivery_status(scst_cmd, SCST_CMD_DELIVERY_FAILED); ++ } ++ ++ scst_tgt_cmd_done(scst_cmd, context); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++/* called via callback from qla2xxx */ ++static void q2x_ctio_completion(scsi_qla_host_t *ha, uint32_t handle) ++{ ++ struct q2t_tgt *tgt = ha->tgt; ++ ++ TRACE_ENTRY(); ++ ++ if (likely(tgt != NULL)) { ++ tgt->irq_cmd_count++; ++ q2t_do_ctio_completion(ha, handle, CTIO_SUCCESS, NULL); ++ tgt->irq_cmd_count--; ++ } else { ++ TRACE_DBG("CTIO, but target mode not enabled (ha %p handle " ++ "%#x)", ha, handle); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static int q2x_do_send_cmd_to_scst(struct q2t_cmd *cmd) ++{ ++ int res = 0; ++ struct q2t_sess *sess = cmd->sess; ++ uint16_t lun; ++ atio_entry_t *atio = &cmd->atio.atio2x; ++ scst_data_direction dir; ++ int context; ++ ++ TRACE_ENTRY(); ++ ++ /* make it be in network byte order */ ++ lun = swab16(le16_to_cpu(atio->lun)); ++ cmd->scst_cmd = scst_rx_cmd(sess->scst_sess, (uint8_t *)&lun, ++ sizeof(lun), atio->cdb, Q2T_MAX_CDB_LEN, ++ SCST_ATOMIC); ++ ++ if (cmd->scst_cmd == NULL) { ++ PRINT_ERROR("%s", "qla2x00t: scst_rx_cmd() failed"); ++ res = -EFAULT; ++ goto out; ++ } ++ ++ cmd->tag = atio->rx_id; ++ scst_cmd_set_tag(cmd->scst_cmd, cmd->tag); ++ scst_cmd_set_tgt_priv(cmd->scst_cmd, cmd); ++ ++ if ((atio->execution_codes & (ATIO_EXEC_READ | ATIO_EXEC_WRITE)) == ++ (ATIO_EXEC_READ | ATIO_EXEC_WRITE)) ++ dir = SCST_DATA_BIDI; ++ else if (atio->execution_codes & ATIO_EXEC_READ) ++ dir = SCST_DATA_READ; ++ else if (atio->execution_codes & ATIO_EXEC_WRITE) ++ dir = SCST_DATA_WRITE; ++ else ++ dir = SCST_DATA_NONE; ++ scst_cmd_set_expected(cmd->scst_cmd, dir, ++ le32_to_cpu(atio->data_length)); ++ ++ switch (atio->task_codes) { ++ case ATIO_SIMPLE_QUEUE: ++ scst_cmd_set_queue_type(cmd->scst_cmd, SCST_CMD_QUEUE_SIMPLE); ++ break; ++ case ATIO_HEAD_OF_QUEUE: ++ scst_cmd_set_queue_type(cmd->scst_cmd, SCST_CMD_QUEUE_HEAD_OF_QUEUE); ++ break; ++ case ATIO_ORDERED_QUEUE: ++ scst_cmd_set_queue_type(cmd->scst_cmd, SCST_CMD_QUEUE_ORDERED); ++ break; ++ case ATIO_ACA_QUEUE: ++ scst_cmd_set_queue_type(cmd->scst_cmd, SCST_CMD_QUEUE_ACA); ++ break; ++ case ATIO_UNTAGGED: ++ scst_cmd_set_queue_type(cmd->scst_cmd, SCST_CMD_QUEUE_UNTAGGED); ++ break; ++ default: ++ PRINT_ERROR("qla2x00t: unknown task code %x, use " ++ "ORDERED instead", atio->task_codes); ++ scst_cmd_set_queue_type(cmd->scst_cmd, SCST_CMD_QUEUE_ORDERED); ++ break; ++ } ++ ++#ifdef CONFIG_QLA_TGT_DEBUG_WORK_IN_THREAD ++ context = SCST_CONTEXT_THREAD; ++#else ++ context = SCST_CONTEXT_TASKLET; ++#endif ++ ++ TRACE_DBG("Context %x", context); ++ TRACE(TRACE_SCSI, "qla2x00t: START Command (tag %d, queue_type %d)", ++ cmd->tag, scst_cmd_get_queue_type(cmd->scst_cmd)); ++ scst_cmd_init_done(cmd->scst_cmd, context); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static int q24_do_send_cmd_to_scst(struct q2t_cmd *cmd) ++{ ++ int res = 0; ++ struct q2t_sess *sess = cmd->sess; ++ atio7_entry_t *atio = &cmd->atio.atio7; ++ scst_data_direction dir; ++ int context; ++ ++ TRACE_ENTRY(); ++ ++ cmd->scst_cmd = scst_rx_cmd(sess->scst_sess, ++ (uint8_t *)&atio->fcp_cmnd.lun, sizeof(atio->fcp_cmnd.lun), ++ atio->fcp_cmnd.cdb, sizeof(atio->fcp_cmnd.cdb) + ++ atio->fcp_cmnd.add_cdb_len, SCST_ATOMIC); ++ ++ if (cmd->scst_cmd == NULL) { ++ PRINT_ERROR("%s", "qla2x00t: scst_rx_cmd() failed"); ++ res = -EFAULT; ++ goto out; ++ } ++ ++ cmd->tag = atio->exchange_addr; ++ scst_cmd_set_tag(cmd->scst_cmd, cmd->tag); ++ scst_cmd_set_tgt_priv(cmd->scst_cmd, cmd); ++ ++ if (atio->fcp_cmnd.rddata && atio->fcp_cmnd.wrdata) ++ dir = SCST_DATA_BIDI; ++ else if (atio->fcp_cmnd.rddata) ++ dir = SCST_DATA_READ; ++ else if (atio->fcp_cmnd.wrdata) ++ dir = SCST_DATA_WRITE; ++ else ++ dir = SCST_DATA_NONE; ++ scst_cmd_set_expected(cmd->scst_cmd, dir, ++ be32_to_cpu(get_unaligned((uint32_t *) ++ &atio->fcp_cmnd.add_cdb[atio->fcp_cmnd.add_cdb_len]))); ++ ++ switch (atio->fcp_cmnd.task_attr) { ++ case ATIO_SIMPLE_QUEUE: ++ scst_cmd_set_queue_type(cmd->scst_cmd, SCST_CMD_QUEUE_SIMPLE); ++ break; ++ case ATIO_HEAD_OF_QUEUE: ++ scst_cmd_set_queue_type(cmd->scst_cmd, SCST_CMD_QUEUE_HEAD_OF_QUEUE); ++ break; ++ case ATIO_ORDERED_QUEUE: ++ scst_cmd_set_queue_type(cmd->scst_cmd, SCST_CMD_QUEUE_ORDERED); ++ break; ++ case ATIO_ACA_QUEUE: ++ scst_cmd_set_queue_type(cmd->scst_cmd, SCST_CMD_QUEUE_ACA); ++ break; ++ case ATIO_UNTAGGED: ++ scst_cmd_set_queue_type(cmd->scst_cmd, SCST_CMD_QUEUE_UNTAGGED); ++ break; ++ default: ++ PRINT_ERROR("qla2x00t: unknown task code %x, use " ++ "ORDERED instead", atio->fcp_cmnd.task_attr); ++ scst_cmd_set_queue_type(cmd->scst_cmd, SCST_CMD_QUEUE_ORDERED); ++ break; ++ } ++ ++#ifdef CONFIG_QLA_TGT_DEBUG_WORK_IN_THREAD ++ context = SCST_CONTEXT_THREAD; ++#else ++ context = SCST_CONTEXT_TASKLET; ++#endif ++ ++ TRACE_DBG("Context %x", context); ++ TRACE(TRACE_SCSI, "qla2x00t: START Command %p (tag %d, queue type %x)", ++ cmd, cmd->tag, scst_cmd_get_queue_type(cmd->scst_cmd)); ++ scst_cmd_init_done(cmd->scst_cmd, context); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static int q2t_do_send_cmd_to_scst(scsi_qla_host_t *ha, ++ struct q2t_cmd *cmd, struct q2t_sess *sess) ++{ ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ cmd->sess = sess; ++ cmd->loop_id = sess->loop_id; ++ cmd->conf_compl_supported = sess->conf_compl_supported; ++ ++ if (IS_FWI2_CAPABLE(ha)) ++ res = q24_do_send_cmd_to_scst(cmd); ++ else ++ res = q2x_do_send_cmd_to_scst(cmd); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static int q2t_send_cmd_to_scst(scsi_qla_host_t *ha, atio_t *atio) ++{ ++ int res = 0; ++ struct q2t_tgt *tgt = ha->tgt; ++ struct q2t_sess *sess; ++ struct q2t_cmd *cmd; ++ ++ TRACE_ENTRY(); ++ ++ if (unlikely(tgt->tgt_stop)) { ++ TRACE_MGMT_DBG("New command while device %p is shutting " ++ "down", tgt); ++ res = -EFAULT; ++ goto out; ++ } ++ ++ cmd = kmem_cache_zalloc(q2t_cmd_cachep, GFP_ATOMIC); ++ if (cmd == NULL) { ++ TRACE(TRACE_OUT_OF_MEM, "qla2x00t(%ld): Allocation of cmd " ++ "failed", ha->instance); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ memcpy(&cmd->atio.atio2x, atio, sizeof(*atio)); ++ cmd->state = Q2T_STATE_NEW; ++ cmd->tgt = ha->tgt; ++ ++ if (IS_FWI2_CAPABLE(ha)) { ++ atio7_entry_t *a = (atio7_entry_t *)atio; ++ sess = q2t_find_sess_by_s_id(tgt, a->fcp_hdr.s_id); ++ if (unlikely(sess == NULL)) { ++ TRACE_MGMT_DBG("qla2x00t(%ld): Unable to find " ++ "wwn login (s_id %x:%x:%x), trying to create " ++ "it manually", ha->instance, ++ a->fcp_hdr.s_id[0], a->fcp_hdr.s_id[1], ++ a->fcp_hdr.s_id[2]); ++ goto out_sched; ++ } ++ } else { ++ sess = q2t_find_sess_by_loop_id(tgt, ++ GET_TARGET_ID(ha, (atio_entry_t *)atio)); ++ if (unlikely(sess == NULL)) { ++ TRACE_MGMT_DBG("qla2x00t(%ld): Unable to find " ++ "wwn login (loop_id=%d), trying to create it " ++ "manually", ha->instance, ++ GET_TARGET_ID(ha, (atio_entry_t *)atio)); ++ goto out_sched; ++ } ++ } ++ ++ res = q2t_do_send_cmd_to_scst(ha, cmd, sess); ++ if (unlikely(res != 0)) ++ goto out_free_cmd; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free_cmd: ++ q2t_free_cmd(cmd); ++ goto out; ++ ++out_sched: ++ if (atio->entry_count > 1) { ++ TRACE_MGMT_DBG("Dropping multy entry cmd %p", cmd); ++ res = -EBUSY; ++ goto out_free_cmd; ++ } ++ res = q2t_sched_sess_work(tgt, Q2T_SESS_WORK_CMD, &cmd, sizeof(cmd)); ++ if (res != 0) ++ goto out_free_cmd; ++ goto out; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static int q2t_issue_task_mgmt(struct q2t_sess *sess, uint8_t *lun, ++ int lun_size, int fn, void *iocb, int flags) ++{ ++ int res = 0, rc = -1; ++ struct q2t_mgmt_cmd *mcmd; ++ ++ TRACE_ENTRY(); ++ ++ mcmd = mempool_alloc(q2t_mgmt_cmd_mempool, GFP_ATOMIC); ++ if (mcmd == NULL) { ++ PRINT_CRIT_ERROR("qla2x00t(%ld): Allocation of management " ++ "command failed, some commands and their data could " ++ "leak", sess->tgt->ha->instance); ++ res = -ENOMEM; ++ goto out; ++ } ++ memset(mcmd, 0, sizeof(*mcmd)); ++ ++ mcmd->sess = sess; ++ if (iocb) { ++ memcpy(&mcmd->orig_iocb.notify_entry, iocb, ++ sizeof(mcmd->orig_iocb.notify_entry)); ++ } ++ mcmd->flags = flags; ++ ++ switch (fn) { ++ case Q2T_CLEAR_ACA: ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): CLEAR_ACA received", ++ sess->tgt->ha->instance); ++ rc = scst_rx_mgmt_fn_lun(sess->scst_sess, SCST_CLEAR_ACA, ++ lun, lun_size, SCST_ATOMIC, mcmd); ++ break; ++ ++ case Q2T_TARGET_RESET: ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): TARGET_RESET received", ++ sess->tgt->ha->instance); ++ rc = scst_rx_mgmt_fn_lun(sess->scst_sess, SCST_TARGET_RESET, ++ lun, lun_size, SCST_ATOMIC, mcmd); ++ break; ++ ++ case Q2T_LUN_RESET: ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): LUN_RESET received", ++ sess->tgt->ha->instance); ++ rc = scst_rx_mgmt_fn_lun(sess->scst_sess, SCST_LUN_RESET, ++ lun, lun_size, SCST_ATOMIC, mcmd); ++ break; ++ ++ case Q2T_CLEAR_TS: ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): CLEAR_TS received", ++ sess->tgt->ha->instance); ++ rc = scst_rx_mgmt_fn_lun(sess->scst_sess, SCST_CLEAR_TASK_SET, ++ lun, lun_size, SCST_ATOMIC, mcmd); ++ break; ++ ++ case Q2T_ABORT_TS: ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): ABORT_TS received", ++ sess->tgt->ha->instance); ++ rc = scst_rx_mgmt_fn_lun(sess->scst_sess, SCST_ABORT_TASK_SET, ++ lun, lun_size, SCST_ATOMIC, mcmd); ++ break; ++ ++ case Q2T_ABORT_ALL: ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): Doing ABORT_ALL_TASKS", ++ sess->tgt->ha->instance); ++ rc = scst_rx_mgmt_fn_lun(sess->scst_sess, ++ SCST_ABORT_ALL_TASKS, ++ lun, lun_size, SCST_ATOMIC, mcmd); ++ break; ++ ++ case Q2T_ABORT_ALL_SESS: ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): Doing ABORT_ALL_TASKS_SESS", ++ sess->tgt->ha->instance); ++ rc = scst_rx_mgmt_fn_lun(sess->scst_sess, ++ SCST_ABORT_ALL_TASKS_SESS, ++ lun, lun_size, SCST_ATOMIC, mcmd); ++ break; ++ ++ case Q2T_NEXUS_LOSS_SESS: ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): Doing NEXUS_LOSS_SESS", ++ sess->tgt->ha->instance); ++ rc = scst_rx_mgmt_fn_lun(sess->scst_sess, SCST_NEXUS_LOSS_SESS, ++ lun, lun_size, SCST_ATOMIC, mcmd); ++ break; ++ ++ case Q2T_NEXUS_LOSS: ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): Doing NEXUS_LOSS", ++ sess->tgt->ha->instance); ++ rc = scst_rx_mgmt_fn_lun(sess->scst_sess, SCST_NEXUS_LOSS, ++ lun, lun_size, SCST_ATOMIC, mcmd); ++ break; ++ ++ default: ++ PRINT_ERROR("qla2x00t(%ld): Unknown task mgmt fn 0x%x", ++ sess->tgt->ha->instance, fn); ++ rc = -1; ++ break; ++ } ++ ++ if (rc != 0) { ++ PRINT_ERROR("qla2x00t(%ld): scst_rx_mgmt_fn_lun() failed: %d", ++ sess->tgt->ha->instance, rc); ++ res = -EFAULT; ++ goto out_free; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free: ++ mempool_free(mcmd, q2t_mgmt_cmd_mempool); ++ goto out; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static int q2t_handle_task_mgmt(scsi_qla_host_t *ha, void *iocb) ++{ ++ int res = 0; ++ struct q2t_tgt *tgt; ++ struct q2t_sess *sess; ++ uint8_t *lun; ++ uint16_t lun_data; ++ int lun_size; ++ int fn; ++ ++ TRACE_ENTRY(); ++ ++ tgt = ha->tgt; ++ if (IS_FWI2_CAPABLE(ha)) { ++ atio7_entry_t *a = (atio7_entry_t *)iocb; ++ lun = (uint8_t *)&a->fcp_cmnd.lun; ++ lun_size = sizeof(a->fcp_cmnd.lun); ++ fn = a->fcp_cmnd.task_mgmt_flags; ++ sess = q2t_find_sess_by_s_id(tgt, a->fcp_hdr.s_id); ++ } else { ++ notify_entry_t *n = (notify_entry_t *)iocb; ++ /* make it be in network byte order */ ++ lun_data = swab16(le16_to_cpu(n->lun)); ++ lun = (uint8_t *)&lun_data; ++ lun_size = sizeof(lun_data); ++ fn = n->task_flags >> IMM_NTFY_TASK_MGMT_SHIFT; ++ sess = q2t_find_sess_by_loop_id(tgt, GET_TARGET_ID(ha, n)); ++ } ++ ++ if (sess == NULL) { ++ TRACE_MGMT_DBG("qla2x00t(%ld): task mgmt fn 0x%x for " ++ "non-existant session", ha->instance, fn); ++ res = q2t_sched_sess_work(tgt, Q2T_SESS_WORK_TM, iocb, ++ IS_FWI2_CAPABLE(ha) ? sizeof(atio7_entry_t) : ++ sizeof(notify_entry_t)); ++ if (res != 0) ++ tgt->tm_to_unknown = 1; ++ goto out; ++ } ++ ++ res = q2t_issue_task_mgmt(sess, lun, lun_size, fn, iocb, 0); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static int __q2t_abort_task(scsi_qla_host_t *ha, notify_entry_t *iocb, ++ struct q2t_sess *sess) ++{ ++ int res, rc; ++ struct q2t_mgmt_cmd *mcmd; ++ ++ TRACE_ENTRY(); ++ ++ mcmd = mempool_alloc(q2t_mgmt_cmd_mempool, GFP_ATOMIC); ++ if (mcmd == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): %s: Allocation of ABORT cmd failed", ++ ha->instance, __func__); ++ res = -ENOMEM; ++ goto out; ++ } ++ memset(mcmd, 0, sizeof(*mcmd)); ++ ++ mcmd->sess = sess; ++ memcpy(&mcmd->orig_iocb.notify_entry, iocb, ++ sizeof(mcmd->orig_iocb.notify_entry)); ++ ++ rc = scst_rx_mgmt_fn_tag(sess->scst_sess, SCST_ABORT_TASK, ++ le16_to_cpu(iocb->seq_id), SCST_ATOMIC, mcmd); ++ if (rc != 0) { ++ PRINT_ERROR("qla2x00t(%ld): scst_rx_mgmt_fn_tag() failed: %d", ++ ha->instance, rc); ++ res = -EFAULT; ++ goto out_free; ++ } ++ ++ res = 0; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free: ++ mempool_free(mcmd, q2t_mgmt_cmd_mempool); ++ goto out; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static int q2t_abort_task(scsi_qla_host_t *ha, notify_entry_t *iocb) ++{ ++ int res; ++ struct q2t_sess *sess; ++ int loop_id; ++ ++ TRACE_ENTRY(); ++ ++ loop_id = GET_TARGET_ID(ha, iocb); ++ ++ sess = q2t_find_sess_by_loop_id(ha->tgt, loop_id); ++ if (sess == NULL) { ++ TRACE_MGMT_DBG("qla2x00t(%ld): task abort for unexisting " ++ "session", ha->instance); ++ res = q2t_sched_sess_work(sess->tgt, Q2T_SESS_WORK_ABORT, iocb, ++ sizeof(*iocb)); ++ if (res != 0) ++ sess->tgt->tm_to_unknown = 1; ++ goto out; ++ } ++ ++ res = __q2t_abort_task(ha, iocb, sess); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* ++ * pha->hardware_lock supposed to be held on entry. Might drop it, then reacquire ++ */ ++static int q24_handle_els(scsi_qla_host_t *ha, notify24xx_entry_t *iocb) ++{ ++ int res = 1; /* send notify ack */ ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("qla2x00t(%ld): ELS opcode %x", ha->instance, ++ iocb->status_subcode); ++ ++ switch (iocb->status_subcode) { ++ case ELS_PLOGI: ++ case ELS_FLOGI: ++ case ELS_PRLI: ++ break; ++ ++ case ELS_LOGO: ++ case ELS_PRLO: ++ res = q2t_reset(ha, iocb, Q2T_NEXUS_LOSS_SESS); ++ break; ++ ++ case ELS_PDISC: ++ case ELS_ADISC: ++ { ++ struct q2t_tgt *tgt = ha->tgt; ++ if (tgt->link_reinit_iocb_pending) { ++ q24_send_notify_ack(ha, &tgt->link_reinit_iocb, 0, 0, 0); ++ tgt->link_reinit_iocb_pending = 0; ++ } ++ break; ++ } ++ ++ default: ++ PRINT_ERROR("qla2x00t(%ld): Unsupported ELS command %x " ++ "received", ha->instance, iocb->status_subcode); ++#if 0 ++ res = q2t_reset(ha, iocb, Q2T_NEXUS_LOSS_SESS); ++#endif ++ break; ++ } ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int q2t_cut_cmd_data_head(struct q2t_cmd *cmd, unsigned int offset) ++{ ++ int res = 0; ++ int cnt, first_sg, first_page = 0, first_page_offs = 0, i; ++ unsigned int l; ++ int cur_dst, cur_src; ++ struct scatterlist *sg; ++ size_t bufflen = 0; ++ ++ TRACE_ENTRY(); ++ ++ first_sg = -1; ++ cnt = 0; ++ l = 0; ++ for (i = 0; i < cmd->sg_cnt; i++) { ++ l += cmd->sg[i].length; ++ if (l > offset) { ++ int sg_offs = l - cmd->sg[i].length; ++ first_sg = i; ++ if (cmd->sg[i].offset == 0) { ++ first_page_offs = offset % PAGE_SIZE; ++ first_page = (offset - sg_offs) >> PAGE_SHIFT; ++ } else { ++ TRACE_SG("i=%d, sg[i].offset=%d, " ++ "sg_offs=%d", i, cmd->sg[i].offset, sg_offs); ++ if ((cmd->sg[i].offset + sg_offs) > offset) { ++ first_page_offs = offset - sg_offs; ++ first_page = 0; ++ } else { ++ int sec_page_offs = sg_offs + ++ (PAGE_SIZE - cmd->sg[i].offset); ++ first_page_offs = sec_page_offs % PAGE_SIZE; ++ first_page = 1 + ++ ((offset - sec_page_offs) >> ++ PAGE_SHIFT); ++ } ++ } ++ cnt = cmd->sg_cnt - i + (first_page_offs != 0); ++ break; ++ } ++ } ++ if (first_sg == -1) { ++ PRINT_ERROR("qla2x00t(%ld): Wrong offset %d, buf length %d", ++ cmd->tgt->ha->instance, offset, cmd->bufflen); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ TRACE_SG("offset=%d, first_sg=%d, first_page=%d, " ++ "first_page_offs=%d, cmd->bufflen=%d, cmd->sg_cnt=%d", offset, ++ first_sg, first_page, first_page_offs, cmd->bufflen, ++ cmd->sg_cnt); ++ ++ sg = kmalloc(cnt * sizeof(sg[0]), GFP_KERNEL); ++ if (sg == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): Unable to allocate cut " ++ "SG (len %zd)", cmd->tgt->ha->instance, ++ cnt * sizeof(sg[0])); ++ res = -ENOMEM; ++ goto out; ++ } ++ sg_init_table(sg, cnt); ++ ++ cur_dst = 0; ++ cur_src = first_sg; ++ if (first_page_offs != 0) { ++ int fpgs; ++ sg_set_page(&sg[cur_dst], &sg_page(&cmd->sg[cur_src])[first_page], ++ PAGE_SIZE - first_page_offs, first_page_offs); ++ bufflen += sg[cur_dst].length; ++ TRACE_SG("cur_dst=%d, cur_src=%d, sg[].page=%p, " ++ "sg[].offset=%d, sg[].length=%d, bufflen=%zu", ++ cur_dst, cur_src, sg_page(&sg[cur_dst]), sg[cur_dst].offset, ++ sg[cur_dst].length, bufflen); ++ cur_dst++; ++ ++ fpgs = (cmd->sg[cur_src].length >> PAGE_SHIFT) + ++ ((cmd->sg[cur_src].length & ~PAGE_MASK) != 0); ++ first_page++; ++ if (fpgs > first_page) { ++ sg_set_page(&sg[cur_dst], ++ &sg_page(&cmd->sg[cur_src])[first_page], ++ cmd->sg[cur_src].length - PAGE_SIZE*first_page, ++ 0); ++ TRACE_SG("fpgs=%d, cur_dst=%d, cur_src=%d, " ++ "sg[].page=%p, sg[].length=%d, bufflen=%zu", ++ fpgs, cur_dst, cur_src, sg_page(&sg[cur_dst]), ++ sg[cur_dst].length, bufflen); ++ bufflen += sg[cur_dst].length; ++ cur_dst++; ++ } ++ cur_src++; ++ } ++ ++ while (cur_src < cmd->sg_cnt) { ++ sg_set_page(&sg[cur_dst], sg_page(&cmd->sg[cur_src]), ++ cmd->sg[cur_src].length, cmd->sg[cur_src].offset); ++ TRACE_SG("cur_dst=%d, cur_src=%d, " ++ "sg[].page=%p, sg[].length=%d, sg[].offset=%d, " ++ "bufflen=%zu", cur_dst, cur_src, sg_page(&sg[cur_dst]), ++ sg[cur_dst].length, sg[cur_dst].offset, bufflen); ++ bufflen += sg[cur_dst].length; ++ cur_dst++; ++ cur_src++; ++ } ++ ++ if (cmd->free_sg) ++ kfree(cmd->sg); ++ ++ cmd->sg = sg; ++ cmd->free_sg = 1; ++ cmd->sg_cnt = cur_dst; ++ cmd->bufflen = bufflen; ++ cmd->offset += offset; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static inline int q2t_srr_adjust_data(struct q2t_cmd *cmd, ++ uint32_t srr_rel_offs, int *xmit_type) ++{ ++ int res = 0; ++ int rel_offs; ++ ++ rel_offs = srr_rel_offs - cmd->offset; ++ TRACE_MGMT_DBG("srr_rel_offs=%d, rel_offs=%d", srr_rel_offs, rel_offs); ++ ++ *xmit_type = Q2T_XMIT_ALL; ++ ++ if (rel_offs < 0) { ++ PRINT_ERROR("qla2x00t(%ld): SRR rel_offs (%d) " ++ "< 0", cmd->tgt->ha->instance, rel_offs); ++ res = -1; ++ } else if (rel_offs == cmd->bufflen) ++ *xmit_type = Q2T_XMIT_STATUS; ++ else if (rel_offs > 0) ++ res = q2t_cut_cmd_data_head(cmd, rel_offs); ++ ++ return res; ++} ++ ++/* No locks, thread context */ ++static void q24_handle_srr(scsi_qla_host_t *ha, struct srr_ctio *sctio, ++ struct srr_imm *imm) ++{ ++ notify24xx_entry_t *ntfy = &imm->imm.notify_entry24; ++ struct q2t_cmd *cmd = sctio->cmd; ++ scsi_qla_host_t *pha = to_qla_parent(ha); ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("SRR cmd %p, srr_ui %x", cmd, ntfy->srr_ui); ++ ++ switch (ntfy->srr_ui) { ++ case SRR_IU_STATUS: ++ spin_lock_irq(&pha->hardware_lock); ++ q24_send_notify_ack(ha, ntfy, ++ NOTIFY_ACK_SRR_FLAGS_ACCEPT, 0, 0); ++ spin_unlock_irq(&pha->hardware_lock); ++ __q24_xmit_response(cmd, Q2T_XMIT_STATUS); ++ break; ++ case SRR_IU_DATA_IN: ++ cmd->bufflen = scst_cmd_get_adjusted_resp_data_len(cmd->scst_cmd); ++ if (q2t_has_data(cmd)) { ++ uint32_t offset; ++ int xmit_type; ++ offset = le32_to_cpu(imm->imm.notify_entry24.srr_rel_offs); ++ if (q2t_srr_adjust_data(cmd, offset, &xmit_type) != 0) ++ goto out_reject; ++ spin_lock_irq(&pha->hardware_lock); ++ q24_send_notify_ack(ha, ntfy, ++ NOTIFY_ACK_SRR_FLAGS_ACCEPT, 0, 0); ++ spin_unlock_irq(&pha->hardware_lock); ++ __q24_xmit_response(cmd, xmit_type); ++ } else { ++ PRINT_ERROR("qla2x00t(%ld): SRR for in data for cmd " ++ "without them (tag %d, SCSI status %d), " ++ "reject", ha->instance, cmd->tag, ++ scst_cmd_get_status(cmd->scst_cmd)); ++ goto out_reject; ++ } ++ break; ++ case SRR_IU_DATA_OUT: ++ cmd->bufflen = scst_cmd_get_write_fields(cmd->scst_cmd, ++ &cmd->sg, &cmd->sg_cnt); ++ if (q2t_has_data(cmd)) { ++ uint32_t offset; ++ int xmit_type; ++ offset = le32_to_cpu(imm->imm.notify_entry24.srr_rel_offs); ++ if (q2t_srr_adjust_data(cmd, offset, &xmit_type) != 0) ++ goto out_reject; ++ spin_lock_irq(&pha->hardware_lock); ++ q24_send_notify_ack(ha, ntfy, ++ NOTIFY_ACK_SRR_FLAGS_ACCEPT, 0, 0); ++ spin_unlock_irq(&pha->hardware_lock); ++ if (xmit_type & Q2T_XMIT_DATA) ++ __q2t_rdy_to_xfer(cmd); ++ } else { ++ PRINT_ERROR("qla2x00t(%ld): SRR for out data for cmd " ++ "without them (tag %d, SCSI status %d), " ++ "reject", ha->instance, cmd->tag, ++ scst_cmd_get_status(cmd->scst_cmd)); ++ goto out_reject; ++ } ++ break; ++ default: ++ PRINT_ERROR("qla2x00t(%ld): Unknown srr_ui value %x", ++ ha->instance, ntfy->srr_ui); ++ goto out_reject; ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++ ++out_reject: ++ spin_lock_irq(&pha->hardware_lock); ++ q24_send_notify_ack(ha, ntfy, NOTIFY_ACK_SRR_FLAGS_REJECT, ++ NOTIFY_ACK_SRR_REJECT_REASON_UNABLE_TO_PERFORM, ++ NOTIFY_ACK_SRR_FLAGS_REJECT_EXPL_NO_EXPL); ++ if (cmd->state == Q2T_STATE_NEED_DATA) { ++ cmd->state = Q2T_STATE_DATA_IN; ++ scst_rx_data(cmd->scst_cmd, SCST_RX_STATUS_ERROR, ++ SCST_CONTEXT_THREAD); ++ } else ++ q24_send_term_exchange(ha, cmd, &cmd->atio.atio7, 1); ++ spin_unlock_irq(&pha->hardware_lock); ++ goto out; ++} ++ ++/* No locks, thread context */ ++static void q2x_handle_srr(scsi_qla_host_t *ha, struct srr_ctio *sctio, ++ struct srr_imm *imm) ++{ ++ notify_entry_t *ntfy = &imm->imm.notify_entry; ++ struct q2t_cmd *cmd = sctio->cmd; ++ scsi_qla_host_t *pha = to_qla_parent(ha); ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("SRR cmd %p, srr_ui %x", cmd, ntfy->srr_ui); ++ ++ switch (ntfy->srr_ui) { ++ case SRR_IU_STATUS: ++ spin_lock_irq(&pha->hardware_lock); ++ q2x_send_notify_ack(ha, ntfy, 0, 0, 0, ++ NOTIFY_ACK_SRR_FLAGS_ACCEPT, 0, 0); ++ spin_unlock_irq(&pha->hardware_lock); ++ __q2x_xmit_response(cmd, Q2T_XMIT_STATUS); ++ break; ++ case SRR_IU_DATA_IN: ++ cmd->bufflen = scst_cmd_get_adjusted_resp_data_len(cmd->scst_cmd); ++ if (q2t_has_data(cmd)) { ++ uint32_t offset; ++ int xmit_type; ++ offset = le32_to_cpu(imm->imm.notify_entry.srr_rel_offs); ++ if (q2t_srr_adjust_data(cmd, offset, &xmit_type) != 0) ++ goto out_reject; ++ spin_lock_irq(&pha->hardware_lock); ++ q2x_send_notify_ack(ha, ntfy, 0, 0, 0, ++ NOTIFY_ACK_SRR_FLAGS_ACCEPT, 0, 0); ++ spin_unlock_irq(&pha->hardware_lock); ++ __q2x_xmit_response(cmd, xmit_type); ++ } else { ++ PRINT_ERROR("qla2x00t(%ld): SRR for in data for cmd " ++ "without them (tag %d, SCSI status %d), " ++ "reject", ha->instance, cmd->tag, ++ scst_cmd_get_status(cmd->scst_cmd)); ++ goto out_reject; ++ } ++ break; ++ case SRR_IU_DATA_OUT: ++ cmd->bufflen = scst_cmd_get_write_fields(cmd->scst_cmd, ++ &cmd->sg, &cmd->sg_cnt); ++ if (q2t_has_data(cmd)) { ++ uint32_t offset; ++ int xmit_type; ++ offset = le32_to_cpu(imm->imm.notify_entry.srr_rel_offs); ++ if (q2t_srr_adjust_data(cmd, offset, &xmit_type) != 0) ++ goto out_reject; ++ spin_lock_irq(&pha->hardware_lock); ++ q2x_send_notify_ack(ha, ntfy, 0, 0, 0, ++ NOTIFY_ACK_SRR_FLAGS_ACCEPT, 0, 0); ++ spin_unlock_irq(&pha->hardware_lock); ++ if (xmit_type & Q2T_XMIT_DATA) ++ __q2t_rdy_to_xfer(cmd); ++ } else { ++ PRINT_ERROR("qla2x00t(%ld): SRR for out data for cmd " ++ "without them (tag %d, SCSI status %d), " ++ "reject", ha->instance, cmd->tag, ++ scst_cmd_get_status(cmd->scst_cmd)); ++ goto out_reject; ++ } ++ break; ++ default: ++ PRINT_ERROR("qla2x00t(%ld): Unknown srr_ui value %x", ++ ha->instance, ntfy->srr_ui); ++ goto out_reject; ++ } ++ ++out: ++ TRACE_EXIT(); ++ return; ++ ++out_reject: ++ spin_lock_irq(&pha->hardware_lock); ++ q2x_send_notify_ack(ha, ntfy, 0, 0, 0, NOTIFY_ACK_SRR_FLAGS_REJECT, ++ NOTIFY_ACK_SRR_REJECT_REASON_UNABLE_TO_PERFORM, ++ NOTIFY_ACK_SRR_FLAGS_REJECT_EXPL_NO_EXPL); ++ if (cmd->state == Q2T_STATE_NEED_DATA) { ++ cmd->state = Q2T_STATE_DATA_IN; ++ scst_rx_data(cmd->scst_cmd, SCST_RX_STATUS_ERROR, ++ SCST_CONTEXT_THREAD); ++ } else ++ q2x_send_term_exchange(ha, cmd, &cmd->atio.atio2x, 1); ++ spin_unlock_irq(&pha->hardware_lock); ++ goto out; ++} ++ ++static void q2t_reject_free_srr_imm(scsi_qla_host_t *ha, struct srr_imm *imm, ++ int ha_locked) ++{ ++ scsi_qla_host_t *pha = to_qla_parent(ha); ++ ++ if (!ha_locked) ++ spin_lock_irq(&pha->hardware_lock); ++ ++ if (IS_FWI2_CAPABLE(ha)) { ++ q24_send_notify_ack(ha, &imm->imm.notify_entry24, ++ NOTIFY_ACK_SRR_FLAGS_REJECT, ++ NOTIFY_ACK_SRR_REJECT_REASON_UNABLE_TO_PERFORM, ++ NOTIFY_ACK_SRR_FLAGS_REJECT_EXPL_NO_EXPL); ++ } else { ++ q2x_send_notify_ack(ha, &imm->imm.notify_entry, ++ 0, 0, 0, NOTIFY_ACK_SRR_FLAGS_REJECT, ++ NOTIFY_ACK_SRR_REJECT_REASON_UNABLE_TO_PERFORM, ++ NOTIFY_ACK_SRR_FLAGS_REJECT_EXPL_NO_EXPL); ++ } ++ ++ if (!ha_locked) ++ spin_unlock_irq(&pha->hardware_lock); ++ ++ kfree(imm); ++ return; ++} ++ ++static void q2t_handle_srr_work(struct work_struct *work) ++{ ++ struct q2t_tgt *tgt = container_of(work, struct q2t_tgt, srr_work); ++ scsi_qla_host_t *ha = tgt->ha; ++ struct srr_ctio *sctio; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("SRR work (tgt %p)", tgt); ++ ++restart: ++ spin_lock_irq(&tgt->srr_lock); ++ list_for_each_entry(sctio, &tgt->srr_ctio_list, srr_list_entry) { ++ struct srr_imm *imm; ++ struct q2t_cmd *cmd; ++ struct srr_imm *i, *ti; ++ ++ imm = NULL; ++ list_for_each_entry_safe(i, ti, &tgt->srr_imm_list, ++ srr_list_entry) { ++ if (i->srr_id == sctio->srr_id) { ++ list_del(&i->srr_list_entry); ++ if (imm) { ++ PRINT_ERROR("qla2x00t(%ld): There must " ++ "be only one IMM SRR per CTIO SRR " ++ "(IMM SRR %p, id %d, CTIO %p", ++ ha->instance, i, i->srr_id, sctio); ++ q2t_reject_free_srr_imm(ha, i, 0); ++ } else ++ imm = i; ++ } ++ } ++ ++ TRACE_MGMT_DBG("IMM SRR %p, CTIO SRR %p (id %d)", imm, sctio, ++ sctio->srr_id); ++ ++ if (imm == NULL) { ++ TRACE_MGMT_DBG("Not found matching IMM for SRR CTIO " ++ "(id %d)", sctio->srr_id); ++ continue; ++ } else ++ list_del(&sctio->srr_list_entry); ++ ++ spin_unlock_irq(&tgt->srr_lock); ++ ++ cmd = sctio->cmd; ++ ++ /* Restore the originals, except bufflen */ ++ cmd->offset = scst_cmd_get_ppl_offset(cmd->scst_cmd); ++ if (cmd->free_sg) { ++ kfree(cmd->sg); ++ cmd->free_sg = 0; ++ } ++ cmd->sg = scst_cmd_get_sg(cmd->scst_cmd); ++ cmd->sg_cnt = scst_cmd_get_sg_cnt(cmd->scst_cmd); ++ ++ TRACE_MGMT_DBG("SRR cmd %p (scst_cmd %p, tag %d, op %x), " ++ "sg_cnt=%d, offset=%d", cmd, cmd->scst_cmd, ++ cmd->tag, cmd->scst_cmd->cdb[0], cmd->sg_cnt, ++ cmd->offset); ++ ++ if (IS_FWI2_CAPABLE(ha)) ++ q24_handle_srr(ha, sctio, imm); ++ else ++ q2x_handle_srr(ha, sctio, imm); ++ ++ kfree(imm); ++ kfree(sctio); ++ goto restart; ++ } ++ spin_unlock_irq(&tgt->srr_lock); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++static void q2t_prepare_srr_imm(scsi_qla_host_t *ha, void *iocb) ++{ ++ struct srr_imm *imm; ++ struct q2t_tgt *tgt = ha->tgt; ++ notify_entry_t *iocb2x = (notify_entry_t *)iocb; ++ notify24xx_entry_t *iocb24 = (notify24xx_entry_t *)iocb; ++ struct srr_ctio *sctio; ++ ++ tgt->imm_srr_id++; ++ ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): SRR received", ha->instance); ++ ++ imm = kzalloc(sizeof(*imm), GFP_ATOMIC); ++ if (imm != NULL) { ++ memcpy(&imm->imm.notify_entry, iocb, ++ sizeof(imm->imm.notify_entry)); ++ ++ /* IRQ is already OFF */ ++ spin_lock(&tgt->srr_lock); ++ imm->srr_id = tgt->imm_srr_id; ++ list_add_tail(&imm->srr_list_entry, ++ &tgt->srr_imm_list); ++ TRACE_MGMT_DBG("IMM NTFY SRR %p added (id %d, ui %x)", imm, ++ imm->srr_id, iocb24->srr_ui); ++ if (tgt->imm_srr_id == tgt->ctio_srr_id) { ++ int found = 0; ++ list_for_each_entry(sctio, &tgt->srr_ctio_list, ++ srr_list_entry) { ++ if (sctio->srr_id == imm->srr_id) { ++ found = 1; ++ break; ++ } ++ } ++ if (found) { ++ TRACE_MGMT_DBG("%s", "Scheduling srr work"); ++ schedule_work(&tgt->srr_work); ++ } else { ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): imm_srr_id " ++ "== ctio_srr_id (%d), but there is no " ++ "corresponding SRR CTIO, deleting IMM " ++ "SRR %p", ha->instance, tgt->ctio_srr_id, ++ imm); ++ list_del(&imm->srr_list_entry); ++ ++ kfree(imm); ++ ++ spin_unlock(&tgt->srr_lock); ++ goto out_reject; ++ } ++ } ++ spin_unlock(&tgt->srr_lock); ++ } else { ++ struct srr_ctio *ts; ++ ++ PRINT_ERROR("qla2x00t(%ld): Unable to allocate SRR IMM " ++ "entry, SRR request will be rejected", ha->instance); ++ ++ /* IRQ is already OFF */ ++ spin_lock(&tgt->srr_lock); ++ list_for_each_entry_safe(sctio, ts, &tgt->srr_ctio_list, ++ srr_list_entry) { ++ if (sctio->srr_id == tgt->imm_srr_id) { ++ TRACE_MGMT_DBG("CTIO SRR %p deleted " ++ "(id %d)", sctio, sctio->srr_id); ++ list_del(&sctio->srr_list_entry); ++ if (IS_FWI2_CAPABLE(ha)) { ++ q24_send_term_exchange(ha, sctio->cmd, ++ &sctio->cmd->atio.atio7, 1); ++ } else { ++ q2x_send_term_exchange(ha, sctio->cmd, ++ &sctio->cmd->atio.atio2x, 1); ++ } ++ kfree(sctio); ++ } ++ } ++ spin_unlock(&tgt->srr_lock); ++ goto out_reject; ++ } ++ ++out: ++ return; ++ ++out_reject: ++ if (IS_FWI2_CAPABLE(ha)) { ++ q24_send_notify_ack(ha, iocb24, ++ NOTIFY_ACK_SRR_FLAGS_REJECT, ++ NOTIFY_ACK_SRR_REJECT_REASON_UNABLE_TO_PERFORM, ++ NOTIFY_ACK_SRR_FLAGS_REJECT_EXPL_NO_EXPL); ++ } else { ++ q2x_send_notify_ack(ha, iocb2x, ++ 0, 0, 0, NOTIFY_ACK_SRR_FLAGS_REJECT, ++ NOTIFY_ACK_SRR_REJECT_REASON_UNABLE_TO_PERFORM, ++ NOTIFY_ACK_SRR_FLAGS_REJECT_EXPL_NO_EXPL); ++ } ++ goto out; ++} ++ ++/* ++ * pha->hardware_lock supposed to be held on entry. Might drop it, then reacquire ++ */ ++static void q2t_handle_imm_notify(scsi_qla_host_t *ha, void *iocb) ++{ ++ uint16_t status; ++ uint32_t add_flags = 0; ++ int send_notify_ack = 1; ++ notify_entry_t *iocb2x = (notify_entry_t *)iocb; ++ notify24xx_entry_t *iocb24 = (notify24xx_entry_t *)iocb; ++ ++ TRACE_ENTRY(); ++ ++ status = le16_to_cpu(iocb2x->status); ++ ++ TRACE_BUFF_FLAG(TRACE_BUFF, "IMMED Notify Coming Up", ++ iocb, sizeof(*iocb2x)); ++ ++ switch (status) { ++ case IMM_NTFY_LIP_RESET: ++ { ++ if (IS_FWI2_CAPABLE(ha)) { ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): LIP reset (loop %#x), " ++ "subcode %x", ha->instance, ++ le16_to_cpu(iocb24->nport_handle), ++ iocb24->status_subcode); ++ } else { ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): LIP reset (I %#x)", ++ ha->instance, GET_TARGET_ID(ha, iocb2x)); ++ /* set the Clear LIP reset event flag */ ++ add_flags |= NOTIFY_ACK_CLEAR_LIP_RESET; ++ } ++ /* ++ * No additional resets or aborts are needed, because firmware ++ * will as required by FCP either generate TARGET RESET or ++ * reject all affected commands with LIP_RESET status. ++ */ ++ break; ++ } ++ ++ case IMM_NTFY_LIP_LINK_REINIT: ++ { ++ struct q2t_tgt *tgt = ha->tgt; ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): LINK REINIT (loop %#x, " ++ "subcode %x)", ha->instance, ++ le16_to_cpu(iocb24->nport_handle), ++ iocb24->status_subcode); ++ if (tgt->link_reinit_iocb_pending) ++ q24_send_notify_ack(ha, &tgt->link_reinit_iocb, 0, 0, 0); ++ memcpy(&tgt->link_reinit_iocb, iocb24, sizeof(*iocb24)); ++ tgt->link_reinit_iocb_pending = 1; ++ /* ++ * QLogic requires to wait after LINK REINIT for possible ++ * PDISC or ADISC ELS commands ++ */ ++ send_notify_ack = 0; ++ break; ++ } ++ ++ case IMM_NTFY_PORT_LOGOUT: ++ if (IS_FWI2_CAPABLE(ha)) { ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): Port logout (loop " ++ "%#x, subcode %x)", ha->instance, ++ le16_to_cpu(iocb24->nport_handle), ++ iocb24->status_subcode); ++ } else { ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): Port logout (S " ++ "%08x -> L %#x)", ha->instance, ++ le16_to_cpu(iocb2x->seq_id), ++ le16_to_cpu(iocb2x->lun)); ++ } ++ if (q2t_reset(ha, iocb, Q2T_NEXUS_LOSS_SESS) == 0) ++ send_notify_ack = 0; ++ /* The sessions will be cleared in the callback, if needed */ ++ break; ++ ++ case IMM_NTFY_GLBL_TPRLO: ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): Global TPRLO (%x)", ++ ha->instance, status); ++ if (q2t_reset(ha, iocb, Q2T_NEXUS_LOSS) == 0) ++ send_notify_ack = 0; ++ /* The sessions will be cleared in the callback, if needed */ ++ break; ++ ++ case IMM_NTFY_PORT_CONFIG: ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): Port config changed (%x)", ++ ha->instance, status); ++ break; ++ ++ case IMM_NTFY_GLBL_LOGO: ++ PRINT_WARNING("qla2x00t(%ld): Link failure detected", ++ ha->instance); ++ /* I_T nexus loss */ ++ if (q2t_reset(ha, iocb, Q2T_NEXUS_LOSS) == 0) ++ send_notify_ack = 0; ++ break; ++ ++ case IMM_NTFY_IOCB_OVERFLOW: ++ PRINT_ERROR("qla2x00t(%ld): Cannot provide requested " ++ "capability (IOCB overflowed the immediate notify " ++ "resource count)", ha->instance); ++ break; ++ ++ case IMM_NTFY_ABORT_TASK: ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): Abort Task (S %08x I %#x -> " ++ "L %#x)", ha->instance, le16_to_cpu(iocb2x->seq_id), ++ GET_TARGET_ID(ha, iocb2x), le16_to_cpu(iocb2x->lun)); ++ if (q2t_abort_task(ha, iocb2x) == 0) ++ send_notify_ack = 0; ++ break; ++ ++ case IMM_NTFY_RESOURCE: ++ PRINT_ERROR("qla2x00t(%ld): Out of resources, host %ld", ++ ha->instance, ha->host_no); ++ break; ++ ++ case IMM_NTFY_MSG_RX: ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): Immediate notify task %x", ++ ha->instance, iocb2x->task_flags); ++ if (q2t_handle_task_mgmt(ha, iocb2x) == 0) ++ send_notify_ack = 0; ++ break; ++ ++ case IMM_NTFY_ELS: ++ if (q24_handle_els(ha, iocb24) == 0) ++ send_notify_ack = 0; ++ break; ++ ++ case IMM_NTFY_SRR: ++ q2t_prepare_srr_imm(ha, iocb); ++ send_notify_ack = 0; ++ break; ++ ++ default: ++ PRINT_ERROR("qla2x00t(%ld): Received unknown immediate " ++ "notify status %x", ha->instance, status); ++ break; ++ } ++ ++ if (send_notify_ack) { ++ if (IS_FWI2_CAPABLE(ha)) ++ q24_send_notify_ack(ha, iocb24, 0, 0, 0); ++ else ++ q2x_send_notify_ack(ha, iocb2x, add_flags, 0, 0, 0, ++ 0, 0); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * pha->hardware_lock supposed to be held on entry. Might drop it, then reacquire ++ */ ++static void q2x_send_busy(scsi_qla_host_t *ha, atio_entry_t *atio) ++{ ++ ctio_ret_entry_t *ctio; ++ ++ TRACE_ENTRY(); ++ ++ /* Sending marker isn't necessary, since we called from ISR */ ++ ++ ctio = (ctio_ret_entry_t *)q2t_req_pkt(ha); ++ if (ctio == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): %s failed: unable to allocate " ++ "request packet", ha->instance, __func__); ++ goto out; ++ } ++ ++ ctio->entry_type = CTIO_RET_TYPE; ++ ctio->entry_count = 1; ++ ctio->handle = Q2T_SKIP_HANDLE | CTIO_COMPLETION_HANDLE_MARK; ++ ctio->scsi_status = __constant_cpu_to_le16(SAM_STAT_BUSY); ++ ctio->residual = atio->data_length; ++ if (ctio->residual != 0) ++ ctio->scsi_status |= SS_RESIDUAL_UNDER; ++ ++ /* Set IDs */ ++ SET_TARGET_ID(ha, ctio->target, GET_TARGET_ID(ha, atio)); ++ ctio->rx_id = atio->rx_id; ++ ++ ctio->flags = __constant_cpu_to_le16(OF_SSTS | OF_FAST_POST | ++ OF_NO_DATA | OF_SS_MODE_1); ++ ctio->flags |= __constant_cpu_to_le16(OF_INC_RC); ++ /* ++ * CTIO from fw w/o scst_cmd doesn't provide enough info to retry it, ++ * if the explicit conformation is used. ++ */ ++ ++ TRACE_BUFFER("CTIO BUSY packet data", ctio, REQUEST_ENTRY_SIZE); ++ ++ q2t_exec_queue(ha); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * pha->hardware_lock supposed to be held on entry. Might drop it, then reacquire ++ */ ++static void q24_send_busy(scsi_qla_host_t *ha, atio7_entry_t *atio, ++ uint16_t status) ++{ ++ ctio7_status1_entry_t *ctio; ++ struct q2t_sess *sess; ++ uint16_t loop_id; ++ ++ TRACE_ENTRY(); ++ ++ /* ++ * In some cases, for instance for ATIO_EXCHANGE_ADDRESS_UNKNOWN, the ++ * spec requires to issue queue full SCSI status. So, let's search among ++ * being deleted sessions as well and use CTIO7_NHANDLE_UNRECOGNIZED, ++ * if we can't find sess. ++ */ ++ sess = q2t_find_sess_by_s_id_include_deleted(ha->tgt, ++ atio->fcp_hdr.s_id); ++ if (sess != NULL) ++ loop_id = sess->loop_id; ++ else ++ loop_id = CTIO7_NHANDLE_UNRECOGNIZED; ++ ++ /* Sending marker isn't necessary, since we called from ISR */ ++ ++ ctio = (ctio7_status1_entry_t *)q2t_req_pkt(ha); ++ if (ctio == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): %s failed: unable to allocate " ++ "request packet", ha->instance, __func__); ++ goto out; ++ } ++ ++ ctio->common.entry_type = CTIO_TYPE7; ++ ctio->common.entry_count = 1; ++ ctio->common.handle = Q2T_SKIP_HANDLE | CTIO_COMPLETION_HANDLE_MARK; ++ ctio->common.nport_handle = loop_id; ++ ctio->common.timeout = __constant_cpu_to_le16(Q2T_TIMEOUT); ++ ctio->common.vp_index = ha->vp_idx; ++ ctio->common.initiator_id[0] = atio->fcp_hdr.s_id[2]; ++ ctio->common.initiator_id[1] = atio->fcp_hdr.s_id[1]; ++ ctio->common.initiator_id[2] = atio->fcp_hdr.s_id[0]; ++ ctio->common.exchange_addr = atio->exchange_addr; ++ ctio->flags = (atio->attr << 9) | __constant_cpu_to_le16( ++ CTIO7_FLAGS_STATUS_MODE_1 | CTIO7_FLAGS_SEND_STATUS | ++ CTIO7_FLAGS_DONT_RET_CTIO); ++ /* ++ * CTIO from fw w/o scst_cmd doesn't provide enough info to retry it, ++ * if the explicit conformation is used. ++ */ ++ ctio->ox_id = swab16(atio->fcp_hdr.ox_id); ++ ctio->scsi_status = cpu_to_le16(status); ++ ctio->residual = get_unaligned((uint32_t *) ++ &atio->fcp_cmnd.add_cdb[atio->fcp_cmnd.add_cdb_len]); ++ if (ctio->residual != 0) ++ ctio->scsi_status |= SS_RESIDUAL_UNDER; ++ ++ TRACE_BUFFER("CTIO7 BUSY packet data", ctio, REQUEST_ENTRY_SIZE); ++ ++ q2t_exec_queue(ha); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++/* called via callback from qla2xxx */ ++static void q24_atio_pkt(scsi_qla_host_t *ha, atio7_entry_t *atio) ++{ ++ int rc; ++ struct q2t_tgt *tgt = ha->tgt; ++ ++ TRACE_ENTRY(); ++ ++ if (unlikely(tgt == NULL)) { ++ TRACE_MGMT_DBG("ATIO pkt, but no tgt (ha %p)", ha); ++ goto out; ++ } ++ ++ TRACE(TRACE_SCSI, "qla2x00t(%ld): ATIO pkt %p: type %02x count %02x", ++ ha->instance, atio, atio->entry_type, atio->entry_count); ++ ++ /* ++ * In tgt_stop mode we also should allow all requests to pass. ++ * Otherwise, some commands can stuck. ++ */ ++ ++ tgt->irq_cmd_count++; ++ ++ switch (atio->entry_type) { ++ case ATIO_TYPE7: ++ TRACE_DBG("ATIO_TYPE7 instance %ld, lun %Lx, read/write %d/%d, " ++ "add_cdb_len %d, data_length %04x, s_id %x:%x:%x", ++ ha->instance, atio->fcp_cmnd.lun, atio->fcp_cmnd.rddata, ++ atio->fcp_cmnd.wrdata, atio->fcp_cmnd.add_cdb_len, ++ be32_to_cpu(get_unaligned((uint32_t *) ++ &atio->fcp_cmnd.add_cdb[atio->fcp_cmnd.add_cdb_len])), ++ atio->fcp_hdr.s_id[0], atio->fcp_hdr.s_id[1], ++ atio->fcp_hdr.s_id[2]); ++ TRACE_BUFFER("Incoming ATIO7 packet data", atio, ++ REQUEST_ENTRY_SIZE); ++ PRINT_BUFF_FLAG(TRACE_SCSI, "FCP CDB", atio->fcp_cmnd.cdb, ++ sizeof(atio->fcp_cmnd.cdb)); ++ if (unlikely(atio->exchange_addr == ++ ATIO_EXCHANGE_ADDRESS_UNKNOWN)) { ++ TRACE(TRACE_OUT_OF_MEM, "qla2x00t(%ld): ATIO_TYPE7 " ++ "received with UNKNOWN exchange address, " ++ "sending QUEUE_FULL", ha->instance); ++ q24_send_busy(ha, atio, SAM_STAT_TASK_SET_FULL); ++ break; ++ } ++ if (likely(atio->fcp_cmnd.task_mgmt_flags == 0)) ++ rc = q2t_send_cmd_to_scst(ha, (atio_t *)atio); ++ else ++ rc = q2t_handle_task_mgmt(ha, atio); ++ if (unlikely(rc != 0)) { ++ if (rc == -ESRCH) { ++#if 1 /* With TERM EXCHANGE some FC cards refuse to boot */ ++ q24_send_busy(ha, atio, SAM_STAT_BUSY); ++#else ++ q24_send_term_exchange(ha, NULL, atio, 1); ++#endif ++ } else { ++ PRINT_INFO("qla2x00t(%ld): Unable to send " ++ "command to SCST, sending BUSY status", ++ ha->instance); ++ q24_send_busy(ha, atio, SAM_STAT_BUSY); ++ } ++ } ++ break; ++ ++ case IMMED_NOTIFY_TYPE: ++ { ++ notify_entry_t *pkt = (notify_entry_t *)atio; ++ if (unlikely(pkt->entry_status != 0)) { ++ PRINT_ERROR("qla2x00t(%ld): Received ATIO packet %x " ++ "with error status %x", ha->instance, ++ pkt->entry_type, pkt->entry_status); ++ break; ++ } ++ TRACE_DBG("%s", "IMMED_NOTIFY ATIO"); ++ q2t_handle_imm_notify(ha, pkt); ++ break; ++ } ++ ++ default: ++ PRINT_ERROR("qla2x00t(%ld): Received unknown ATIO atio " ++ "type %x", ha->instance, atio->entry_type); ++ break; ++ } ++ ++ tgt->irq_cmd_count--; ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* pha->hardware_lock supposed to be held on entry */ ++/* called via callback from qla2xxx */ ++static void q2t_response_pkt(scsi_qla_host_t *ha, response_t *pkt) ++{ ++ struct q2t_tgt *tgt = ha->tgt; ++ ++ TRACE_ENTRY(); ++ ++ if (unlikely(tgt == NULL)) { ++ PRINT_ERROR("qla2x00t(%ld): Response pkt %x received, but no " ++ "tgt (ha %p)", ha->instance, pkt->entry_type, ha); ++ goto out; ++ } ++ ++ TRACE(TRACE_SCSI, "qla2x00t(%ld): pkt %p: T %02x C %02x S %02x " ++ "handle %#x", ha->instance, pkt, pkt->entry_type, ++ pkt->entry_count, pkt->entry_status, pkt->handle); ++ ++ /* ++ * In tgt_stop mode we also should allow all requests to pass. ++ * Otherwise, some commands can stuck. ++ */ ++ ++ if (unlikely(pkt->entry_status != 0)) { ++ PRINT_ERROR("qla2x00t(%ld): Received response packet %x " ++ "with error status %x", ha->instance, pkt->entry_type, ++ pkt->entry_status); ++ switch (pkt->entry_type) { ++ case ACCEPT_TGT_IO_TYPE: ++ case IMMED_NOTIFY_TYPE: ++ case ABTS_RECV_24XX: ++ goto out; ++ default: ++ break; ++ } ++ } ++ ++ tgt->irq_cmd_count++; ++ ++ switch (pkt->entry_type) { ++ case CTIO_TYPE7: ++ { ++ ctio7_fw_entry_t *entry = (ctio7_fw_entry_t *)pkt; ++ TRACE_DBG("CTIO_TYPE7: instance %ld", ++ ha->instance); ++ TRACE_BUFFER("Incoming CTIO7 packet data", entry, ++ REQUEST_ENTRY_SIZE); ++ q2t_do_ctio_completion(ha, entry->handle, ++ le16_to_cpu(entry->status)|(pkt->entry_status << 16), ++ entry); ++ break; ++ } ++ ++ case ACCEPT_TGT_IO_TYPE: ++ { ++ atio_entry_t *atio; ++ int rc; ++ atio = (atio_entry_t *)pkt; ++ TRACE_DBG("ACCEPT_TGT_IO instance %ld status %04x " ++ "lun %04x read/write %d data_length %04x " ++ "target_id %02x rx_id %04x ", ++ ha->instance, le16_to_cpu(atio->status), ++ le16_to_cpu(atio->lun), ++ atio->execution_codes, ++ le32_to_cpu(atio->data_length), ++ GET_TARGET_ID(ha, atio), atio->rx_id); ++ TRACE_BUFFER("Incoming ATIO packet data", atio, ++ REQUEST_ENTRY_SIZE); ++ if (atio->status != __constant_cpu_to_le16(ATIO_CDB_VALID)) { ++ PRINT_ERROR("qla2x00t(%ld): ATIO with error " ++ "status %x received", ha->instance, ++ le16_to_cpu(atio->status)); ++ break; ++ } ++ TRACE_BUFFER("Incoming ATIO packet data", atio, REQUEST_ENTRY_SIZE); ++ PRINT_BUFF_FLAG(TRACE_SCSI, "FCP CDB", atio->cdb, ++ sizeof(atio->cdb)); ++ rc = q2t_send_cmd_to_scst(ha, (atio_t *)atio); ++ if (unlikely(rc != 0)) { ++ if (rc == -ESRCH) { ++#if 1 /* With TERM EXCHANGE some FC cards refuse to boot */ ++ q2x_send_busy(ha, atio); ++#else ++ q2x_send_term_exchange(ha, NULL, atio, 1); ++#endif ++ } else { ++ PRINT_INFO("qla2x00t(%ld): Unable to send " ++ "command to SCST, sending BUSY status", ++ ha->instance); ++ q2x_send_busy(ha, atio); ++ } ++ } ++ } ++ break; ++ ++ case CONTINUE_TGT_IO_TYPE: ++ { ++ ctio_common_entry_t *entry = (ctio_common_entry_t *)pkt; ++ TRACE_DBG("CONTINUE_TGT_IO: instance %ld", ha->instance); ++ TRACE_BUFFER("Incoming CTIO packet data", entry, ++ REQUEST_ENTRY_SIZE); ++ q2t_do_ctio_completion(ha, entry->handle, ++ le16_to_cpu(entry->status)|(pkt->entry_status << 16), ++ entry); ++ break; ++ } ++ ++ case CTIO_A64_TYPE: ++ { ++ ctio_common_entry_t *entry = (ctio_common_entry_t *)pkt; ++ TRACE_DBG("CTIO_A64: instance %ld", ha->instance); ++ TRACE_BUFFER("Incoming CTIO_A64 packet data", entry, ++ REQUEST_ENTRY_SIZE); ++ q2t_do_ctio_completion(ha, entry->handle, ++ le16_to_cpu(entry->status)|(pkt->entry_status << 16), ++ entry); ++ break; ++ } ++ ++ case IMMED_NOTIFY_TYPE: ++ TRACE_DBG("%s", "IMMED_NOTIFY"); ++ q2t_handle_imm_notify(ha, (notify_entry_t *)pkt); ++ break; ++ ++ case NOTIFY_ACK_TYPE: ++ if (tgt->notify_ack_expected > 0) { ++ nack_entry_t *entry = (nack_entry_t *)pkt; ++ TRACE_DBG("NOTIFY_ACK seq %08x status %x", ++ le16_to_cpu(entry->seq_id), ++ le16_to_cpu(entry->status)); ++ TRACE_BUFFER("Incoming NOTIFY_ACK packet data", pkt, ++ RESPONSE_ENTRY_SIZE); ++ tgt->notify_ack_expected--; ++ if (entry->status != __constant_cpu_to_le16(NOTIFY_ACK_SUCCESS)) { ++ PRINT_ERROR("qla2x00t(%ld): NOTIFY_ACK " ++ "failed %x", ha->instance, ++ le16_to_cpu(entry->status)); ++ } ++ } else { ++ PRINT_ERROR("qla2x00t(%ld): Unexpected NOTIFY_ACK " ++ "received", ha->instance); ++ } ++ break; ++ ++ case ABTS_RECV_24XX: ++ TRACE_DBG("ABTS_RECV_24XX: instance %ld", ha->instance); ++ TRACE_BUFF_FLAG(TRACE_BUFF, "Incoming ABTS_RECV " ++ "packet data", pkt, REQUEST_ENTRY_SIZE); ++ q24_handle_abts(ha, (abts24_recv_entry_t *)pkt); ++ break; ++ ++ case ABTS_RESP_24XX: ++ if (tgt->abts_resp_expected > 0) { ++ abts24_resp_fw_entry_t *entry = ++ (abts24_resp_fw_entry_t *)pkt; ++ TRACE_DBG("ABTS_RESP_24XX: compl_status %x", ++ entry->compl_status); ++ TRACE_BUFF_FLAG(TRACE_BUFF, "Incoming ABTS_RESP " ++ "packet data", pkt, REQUEST_ENTRY_SIZE); ++ tgt->abts_resp_expected--; ++ if (le16_to_cpu(entry->compl_status) != ABTS_RESP_COMPL_SUCCESS) { ++ if ((entry->error_subcode1 == 0x1E) && ++ (entry->error_subcode2 == 0)) { ++ /* ++ * We've got a race here: aborted exchange not ++ * terminated, i.e. response for the aborted ++ * command was sent between the abort request ++ * was received and processed. Unfortunately, ++ * the firmware has a silly requirement that ++ * all aborted exchanges must be explicitely ++ * terminated, otherwise it refuses to send ++ * responses for the abort requests. So, we ++ * have to (re)terminate the exchange and ++ * retry the abort response. ++ */ ++ q24_retry_term_exchange(ha, entry); ++ } else ++ PRINT_ERROR("qla2x00t(%ld): ABTS_RESP_24XX " ++ "failed %x (subcode %x:%x)", ha->instance, ++ entry->compl_status, entry->error_subcode1, ++ entry->error_subcode2); ++ } ++ } else { ++ PRINT_ERROR("qla2x00t(%ld): Unexpected ABTS_RESP_24XX " ++ "received", ha->instance); ++ } ++ break; ++ ++ case MODIFY_LUN_TYPE: ++ if (tgt->modify_lun_expected > 0) { ++ modify_lun_entry_t *entry = (modify_lun_entry_t *)pkt; ++ TRACE_DBG("MODIFY_LUN %x, imm %c%d, cmd %c%d", ++ entry->status, ++ (entry->operators & MODIFY_LUN_IMM_ADD) ? '+' ++ : (entry->operators & MODIFY_LUN_IMM_SUB) ? '-' ++ : ' ', ++ entry->immed_notify_count, ++ (entry->operators & MODIFY_LUN_CMD_ADD) ? '+' ++ : (entry->operators & MODIFY_LUN_CMD_SUB) ? '-' ++ : ' ', ++ entry->command_count); ++ tgt->modify_lun_expected--; ++ if (entry->status != MODIFY_LUN_SUCCESS) { ++ PRINT_ERROR("qla2x00t(%ld): MODIFY_LUN " ++ "failed %x", ha->instance, ++ entry->status); ++ } ++ } else { ++ PRINT_ERROR("qla2x00t(%ld): Unexpected MODIFY_LUN " ++ "received", (ha != NULL) ? (long)ha->instance : -1); ++ } ++ break; ++ ++ case ENABLE_LUN_TYPE: ++ { ++ elun_entry_t *entry = (elun_entry_t *)pkt; ++ TRACE_DBG("ENABLE_LUN %x imm %u cmd %u ", ++ entry->status, entry->immed_notify_count, ++ entry->command_count); ++ if (entry->status == ENABLE_LUN_ALREADY_ENABLED) { ++ TRACE_DBG("LUN is already enabled: %#x", ++ entry->status); ++ entry->status = ENABLE_LUN_SUCCESS; ++ } else if (entry->status == ENABLE_LUN_RC_NONZERO) { ++ TRACE_DBG("ENABLE_LUN succeeded, but with " ++ "error: %#x", entry->status); ++ entry->status = ENABLE_LUN_SUCCESS; ++ } else if (entry->status != ENABLE_LUN_SUCCESS) { ++ PRINT_ERROR("qla2x00t(%ld): ENABLE_LUN " ++ "failed %x", ha->instance, entry->status); ++ qla_clear_tgt_mode(ha); ++ } /* else success */ ++ break; ++ } ++ ++ default: ++ PRINT_ERROR("qla2x00t(%ld): Received unknown response pkt " ++ "type %x", ha->instance, pkt->entry_type); ++ break; ++ } ++ ++ tgt->irq_cmd_count--; ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * pha->hardware_lock supposed to be held on entry. Might drop it, then reacquire ++ */ ++static void q2t_async_event(uint16_t code, scsi_qla_host_t *ha, ++ uint16_t *mailbox) ++{ ++ struct q2t_tgt *tgt = ha->tgt; ++ ++ TRACE_ENTRY(); ++ ++ if (unlikely(tgt == NULL)) { ++ TRACE_DBG("ASYNC EVENT %#x, but no tgt (ha %p)", code, ha); ++ goto out; ++ } ++ ++ /* ++ * In tgt_stop mode we also should allow all requests to pass. ++ * Otherwise, some commands can stuck. ++ */ ++ ++ tgt->irq_cmd_count++; ++ ++ switch (code) { ++ case MBA_RESET: /* Reset */ ++ case MBA_SYSTEM_ERR: /* System Error */ ++ case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */ ++ case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */ ++ case MBA_ATIO_TRANSFER_ERR: /* ATIO Queue Transfer Error */ ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): System error async event %#x " ++ "occured", ha->instance, code); ++ break; ++ ++ case MBA_LOOP_UP: ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): Loop up occured", ++ ha->instance); ++ if (tgt->link_reinit_iocb_pending) { ++ q24_send_notify_ack(ha, &tgt->link_reinit_iocb, 0, 0, 0); ++ tgt->link_reinit_iocb_pending = 0; ++ } ++ break; ++ ++ case MBA_LIP_OCCURRED: ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): LIP occured", ha->instance); ++ break; ++ ++ case MBA_LOOP_DOWN: ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): Loop down occured", ++ ha->instance); ++ break; ++ ++ case MBA_LIP_RESET: ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): LIP reset occured", ++ ha->instance); ++ break; ++ ++ case MBA_PORT_UPDATE: ++ case MBA_RSCN_UPDATE: ++ TRACE_MGMT_DBG("qla2x00t(%ld): Port update async event %#x " ++ "occured", ha->instance, code); ++ /* .mark_all_devices_lost() is handled by the initiator driver */ ++ break; ++ ++ default: ++ TRACE(TRACE_MGMT, "qla2x00t(%ld): Async event %#x occured: " ++ "ignoring (m[1]=%x, m[2]=%x, m[3]=%x, m[4]=%x)", ++ ha->instance, code, ++ le16_to_cpu(mailbox[1]), le16_to_cpu(mailbox[2]), ++ le16_to_cpu(mailbox[3]), le16_to_cpu(mailbox[4])); ++ break; ++ } ++ ++ tgt->irq_cmd_count--; ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static int q2t_get_target_name(uint8_t *wwn, char **ppwwn_name) ++{ ++ const int wwn_len = 3*WWN_SIZE+2; ++ int res = 0; ++ char *name; ++ ++ name = kmalloc(wwn_len, GFP_KERNEL); ++ if (name == NULL) { ++ PRINT_ERROR("qla2x00t: Allocation of tgt wwn name (size %d) " ++ "failed", wwn_len); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ sprintf(name, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", ++ wwn[0], wwn[1], wwn[2], wwn[3], ++ wwn[4], wwn[5], wwn[6], wwn[7]); ++ ++ *ppwwn_name = name; ++ ++out: ++ return res; ++} ++ ++/* Must be called under tgt_mutex */ ++static struct q2t_sess *q2t_make_local_sess(scsi_qla_host_t *ha, ++ const uint8_t *s_id, uint16_t loop_id) ++{ ++ struct q2t_sess *sess = NULL; ++ fc_port_t *fcport = NULL; ++ int rc, global_resets; ++ ++ TRACE_ENTRY(); ++ ++retry: ++ global_resets = atomic_read(&ha->tgt->tgt_global_resets_count); ++ ++ if (IS_FWI2_CAPABLE(ha)) { ++ BUG_ON(s_id == NULL); ++ ++ rc = q24_get_loop_id(ha, s_id, &loop_id); ++ if (rc != 0) { ++ if ((s_id[0] == 0xFF) && ++ (s_id[1] == 0xFC)) { ++ /* ++ * This is Domain Controller, so it should be ++ * OK to drop SCSI commands from it. ++ */ ++ TRACE_MGMT_DBG("Unable to find initiator with " ++ "S_ID %x:%x:%x", s_id[0], s_id[1], ++ s_id[2]); ++ } else ++ PRINT_ERROR("qla2x00t(%ld): Unable to find " ++ "initiator with S_ID %x:%x:%x", ++ ha->instance, s_id[0], s_id[1], ++ s_id[2]); ++ goto out; ++ } ++ } ++ ++ fcport = kzalloc(sizeof(*fcport), GFP_KERNEL); ++ if (fcport == NULL) { ++ PRINT_ERROR("qla2x00t(%ld): Allocation of tmp FC port failed", ++ ha->instance); ++ goto out; ++ } ++ ++ TRACE_MGMT_DBG("loop_id %d", loop_id); ++ ++ fcport->loop_id = loop_id; ++ ++ rc = qla2x00_get_port_database(ha, fcport, 0); ++ if (rc != QLA_SUCCESS) { ++ PRINT_ERROR("qla2x00t(%ld): Failed to retrieve fcport " ++ "information -- get_port_database() returned %x " ++ "(loop_id=0x%04x)", ha->instance, rc, loop_id); ++ goto out_free_fcport; ++ } ++ ++ if (global_resets != atomic_read(&ha->tgt->tgt_global_resets_count)) { ++ TRACE_MGMT_DBG("qla2x00t(%ld): global reset during session " ++ "discovery (counter was %d, new %d), retrying", ++ ha->instance, global_resets, ++ atomic_read(&ha->tgt->tgt_global_resets_count)); ++ kfree(fcport); ++ fcport = NULL; ++ goto retry; ++ } ++ ++ sess = q2t_create_sess(ha, fcport, true); ++ ++out_free_fcport: ++ kfree(fcport); ++ ++out: ++ TRACE_EXIT_HRES((unsigned long)sess); ++ return sess; ++} ++ ++static void q2t_exec_sess_work(struct q2t_tgt *tgt, ++ struct q2t_sess_work_param *prm) ++{ ++ scsi_qla_host_t *ha = tgt->ha; ++ scsi_qla_host_t *pha = to_qla_parent(ha); ++ int rc; ++ struct q2t_sess *sess = NULL; ++ uint8_t *s_id = NULL; /* to hide compiler warnings */ ++ uint8_t local_s_id[3]; ++ int loop_id = -1; /* to hide compiler warnings */ ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("prm %p", prm); ++ ++ mutex_lock(&ha->tgt_mutex); ++ spin_lock_irq(&pha->hardware_lock); ++ ++ if (tgt->tgt_stop) ++ goto send; ++ ++ switch (prm->type) { ++ case Q2T_SESS_WORK_CMD: ++ { ++ struct q2t_cmd *cmd = prm->cmd; ++ if (IS_FWI2_CAPABLE(ha)) { ++ atio7_entry_t *a = (atio7_entry_t *)&cmd->atio; ++ s_id = a->fcp_hdr.s_id; ++ } else ++ loop_id = GET_TARGET_ID(ha, (atio_entry_t *)&cmd->atio); ++ break; ++ } ++ case Q2T_SESS_WORK_ABORT: ++ if (IS_FWI2_CAPABLE(ha)) { ++ sess = q2t_find_sess_by_s_id_le(tgt, ++ prm->abts.fcp_hdr_le.s_id); ++ if (sess == NULL) { ++ s_id = local_s_id; ++ s_id[0] = prm->abts.fcp_hdr_le.s_id[2]; ++ s_id[1] = prm->abts.fcp_hdr_le.s_id[1]; ++ s_id[2] = prm->abts.fcp_hdr_le.s_id[0]; ++ } ++ goto after_find; ++ } else ++ loop_id = GET_TARGET_ID(ha, &prm->tm_iocb); ++ break; ++ case Q2T_SESS_WORK_TM: ++ if (IS_FWI2_CAPABLE(ha)) ++ s_id = prm->tm_iocb2.fcp_hdr.s_id; ++ else ++ loop_id = GET_TARGET_ID(ha, &prm->tm_iocb); ++ break; ++ default: ++ BUG_ON(1); ++ break; ++ } ++ ++ if (IS_FWI2_CAPABLE(ha)) { ++ BUG_ON(s_id == NULL); ++ sess = q2t_find_sess_by_s_id(tgt, s_id); ++ } else ++ sess = q2t_find_sess_by_loop_id(tgt, loop_id); ++ ++after_find: ++ if (sess != NULL) { ++ TRACE_MGMT_DBG("sess %p found", sess); ++ q2t_sess_get(sess); ++ } else { ++ /* ++ * We are under tgt_mutex, so a new sess can't be added ++ * behind us. ++ */ ++ spin_unlock_irq(&pha->hardware_lock); ++ sess = q2t_make_local_sess(ha, s_id, loop_id); ++ spin_lock_irq(&pha->hardware_lock); ++ /* sess has got an extra creation ref */ ++ } ++ ++send: ++ if ((sess == NULL) || tgt->tgt_stop) ++ goto out_term; ++ ++ switch (prm->type) { ++ case Q2T_SESS_WORK_CMD: ++ { ++ struct q2t_cmd *cmd = prm->cmd; ++ if (tgt->tm_to_unknown) { ++ /* ++ * Cmd might be already aborted behind us, so be safe ++ * and abort it. It should be OK, initiator will retry ++ * it. ++ */ ++ goto out_term; ++ } ++ TRACE_MGMT_DBG("Sending work cmd %p to SCST", cmd); ++ rc = q2t_do_send_cmd_to_scst(ha, cmd, sess); ++ break; ++ } ++ case Q2T_SESS_WORK_ABORT: ++ if (IS_FWI2_CAPABLE(ha)) ++ rc = __q24_handle_abts(ha, &prm->abts, sess); ++ else ++ rc = __q2t_abort_task(ha, &prm->tm_iocb, sess); ++ break; ++ case Q2T_SESS_WORK_TM: ++ { ++ uint8_t *lun; ++ uint16_t lun_data; ++ int lun_size, fn; ++ void *iocb; ++ ++ if (IS_FWI2_CAPABLE(ha)) { ++ atio7_entry_t *a = &prm->tm_iocb2; ++ iocb = a; ++ lun = (uint8_t *)&a->fcp_cmnd.lun; ++ lun_size = sizeof(a->fcp_cmnd.lun); ++ fn = a->fcp_cmnd.task_mgmt_flags; ++ } else { ++ notify_entry_t *n = &prm->tm_iocb; ++ iocb = n; ++ /* make it be in network byte order */ ++ lun_data = swab16(le16_to_cpu(n->lun)); ++ lun = (uint8_t *)&lun_data; ++ lun_size = sizeof(lun_data); ++ fn = n->task_flags >> IMM_NTFY_TASK_MGMT_SHIFT; ++ } ++ rc = q2t_issue_task_mgmt(sess, lun, lun_size, fn, iocb, 0); ++ break; ++ } ++ default: ++ BUG_ON(1); ++ break; ++ } ++ ++ if (rc != 0) ++ goto out_term; ++ ++out_put: ++ if (sess != NULL) ++ q2t_sess_put(sess); ++ ++ spin_unlock_irq(&pha->hardware_lock); ++ mutex_unlock(&ha->tgt_mutex); ++ ++ TRACE_EXIT(); ++ return; ++ ++out_term: ++ switch (prm->type) { ++ case Q2T_SESS_WORK_CMD: ++ { ++ struct q2t_cmd *cmd = prm->cmd; ++ TRACE_MGMT_DBG("Terminating work cmd %p", cmd); ++ /* ++ * cmd has not sent to SCST yet, so pass NULL as the second ++ * argument ++ */ ++ if (IS_FWI2_CAPABLE(ha)) ++ q24_send_term_exchange(ha, NULL, &cmd->atio.atio7, 1); ++ else ++ q2x_send_term_exchange(ha, NULL, &cmd->atio.atio2x, 1); ++ q2t_free_cmd(cmd); ++ break; ++ } ++ case Q2T_SESS_WORK_ABORT: ++ if (IS_FWI2_CAPABLE(ha)) ++ q24_send_abts_resp(ha, &prm->abts, ++ SCST_MGMT_STATUS_REJECTED, false); ++ else ++ q2x_send_notify_ack(ha, &prm->tm_iocb, 0, ++ 0, 0, 0, 0, 0); ++ break; ++ case Q2T_SESS_WORK_TM: ++ if (IS_FWI2_CAPABLE(ha)) ++ q24_send_term_exchange(ha, NULL, &prm->tm_iocb2, 1); ++ else ++ q2x_send_notify_ack(ha, &prm->tm_iocb, 0, ++ 0, 0, 0, 0, 0); ++ break; ++ default: ++ BUG_ON(1); ++ break; ++ } ++ goto out_put; ++} ++ ++static void q2t_sess_work_fn(struct work_struct *work) ++{ ++ struct q2t_tgt *tgt = container_of(work, struct q2t_tgt, sess_work); ++ scsi_qla_host_t *pha = to_qla_parent(tgt->ha); ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Sess work (tgt %p)", tgt); ++ ++ spin_lock_irq(&tgt->sess_work_lock); ++ while (!list_empty(&tgt->sess_works_list)) { ++ struct q2t_sess_work_param *prm = list_entry( ++ tgt->sess_works_list.next, typeof(*prm), ++ sess_works_list_entry); ++ ++ /* ++ * This work can be scheduled on several CPUs at time, so we ++ * must delete the entry to eliminate double processing ++ */ ++ list_del(&prm->sess_works_list_entry); ++ ++ spin_unlock_irq(&tgt->sess_work_lock); ++ ++ q2t_exec_sess_work(tgt, prm); ++ ++ spin_lock_irq(&tgt->sess_work_lock); ++ ++ kfree(prm); ++ } ++ spin_unlock_irq(&tgt->sess_work_lock); ++ ++ spin_lock_irq(&pha->hardware_lock); ++ spin_lock(&tgt->sess_work_lock); ++ if (list_empty(&tgt->sess_works_list)) { ++ tgt->sess_works_pending = 0; ++ tgt->tm_to_unknown = 0; ++ } ++ spin_unlock(&tgt->sess_work_lock); ++ spin_unlock_irq(&pha->hardware_lock); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* pha->hardware_lock supposed to be held and IRQs off */ ++static void q2t_cleanup_hw_pending_cmd(scsi_qla_host_t *ha, struct q2t_cmd *cmd) ++{ ++ uint32_t h; ++ ++ for (h = 0; h < MAX_OUTSTANDING_COMMANDS; h++) { ++ if (ha->cmds[h] == cmd) { ++ TRACE_DBG("Clearing handle %d for cmd %p", h, cmd); ++ ha->cmds[h] = NULL; ++ break; ++ } ++ } ++ return; ++} ++ ++static void q2t_on_hw_pending_cmd_timeout(struct scst_cmd *scst_cmd) ++{ ++ struct q2t_cmd *cmd = (struct q2t_cmd *)scst_cmd_get_tgt_priv(scst_cmd); ++ struct q2t_tgt *tgt = cmd->tgt; ++ scsi_qla_host_t *ha = tgt->ha; ++ scsi_qla_host_t *pha = to_qla_parent(ha); ++ unsigned long flags; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Cmd %p HW pending for too long (state %x)", cmd, ++ cmd->state); ++ ++ spin_lock_irqsave(&pha->hardware_lock, flags); ++ ++ if (cmd->sg_mapped) ++ q2t_unmap_sg(ha, cmd); ++ ++ if (cmd->state == Q2T_STATE_PROCESSED) { ++ TRACE_MGMT_DBG("Force finishing cmd %p", cmd); ++ } else if (cmd->state == Q2T_STATE_NEED_DATA) { ++ TRACE_MGMT_DBG("Force rx_data cmd %p", cmd); ++ ++ q2t_cleanup_hw_pending_cmd(ha, cmd); ++ ++ scst_rx_data(scst_cmd, SCST_RX_STATUS_ERROR_FATAL, ++ SCST_CONTEXT_THREAD); ++ goto out_unlock; ++ } else if (cmd->state == Q2T_STATE_ABORTED) { ++ TRACE_MGMT_DBG("Force finishing aborted cmd %p (tag %d)", ++ cmd, cmd->tag); ++ } else { ++ PRINT_ERROR("qla2x00t(%ld): A command in state (%d) should " ++ "not be HW pending", ha->instance, cmd->state); ++ goto out_unlock; ++ } ++ ++ q2t_cleanup_hw_pending_cmd(ha, cmd); ++ ++ scst_set_delivery_status(scst_cmd, SCST_CMD_DELIVERY_FAILED); ++ scst_tgt_cmd_done(scst_cmd, SCST_CONTEXT_THREAD); ++ ++out_unlock: ++ spin_unlock_irqrestore(&pha->hardware_lock, flags); ++ TRACE_EXIT(); ++ return; ++} ++ ++/* Must be called under tgt_host_action_mutex */ ++static int q2t_add_target(scsi_qla_host_t *ha) ++{ ++ int res; ++ int rc; ++ char *wwn; ++ int sg_tablesize; ++ struct q2t_tgt *tgt; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Registering target for host %ld(%p)", ha->host_no, ha); ++ ++ BUG_ON((ha->q2t_tgt != NULL) || (ha->tgt != NULL)); ++ ++ tgt = kzalloc(sizeof(*tgt), GFP_KERNEL); ++ if (tgt == NULL) { ++ PRINT_ERROR("qla2x00t: %s", "Allocation of tgt failed"); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ tgt->ha = ha; ++ init_waitqueue_head(&tgt->waitQ); ++ INIT_LIST_HEAD(&tgt->sess_list); ++ INIT_LIST_HEAD(&tgt->del_sess_list); ++ INIT_DELAYED_WORK(&tgt->sess_del_work, ++ (void (*)(struct work_struct *))q2t_del_sess_work_fn); ++ spin_lock_init(&tgt->sess_work_lock); ++ INIT_WORK(&tgt->sess_work, q2t_sess_work_fn); ++ INIT_LIST_HEAD(&tgt->sess_works_list); ++ spin_lock_init(&tgt->srr_lock); ++ INIT_LIST_HEAD(&tgt->srr_ctio_list); ++ INIT_LIST_HEAD(&tgt->srr_imm_list); ++ INIT_WORK(&tgt->srr_work, q2t_handle_srr_work); ++ atomic_set(&tgt->tgt_global_resets_count, 0); ++ ++ ha->q2t_tgt = tgt; ++ ++ res = q2t_get_target_name(ha->port_name, &wwn); ++ if (res != 0) ++ goto out_free; ++ ++ tgt->scst_tgt = scst_register_target(&tgt2x_template, wwn); ++ ++ kfree(wwn); ++ ++ if (!tgt->scst_tgt) { ++ PRINT_ERROR("qla2x00t(%ld): scst_register_target() " ++ "failed for host %ld(%p)", ha->instance, ++ ha->host_no, ha); ++ res = -ENOMEM; ++ goto out_free; ++ } ++ ++ if (IS_FWI2_CAPABLE(ha)) { ++ PRINT_INFO("qla2x00t(%ld): using 64 Bit PCI " ++ "addressing", ha->instance); ++ tgt->tgt_enable_64bit_addr = 1; ++ /* 3 is reserved */ ++ sg_tablesize = ++ QLA_MAX_SG_24XX(ha->request_q_length - 3); ++ tgt->datasegs_per_cmd = DATASEGS_PER_COMMAND_24XX; ++ tgt->datasegs_per_cont = DATASEGS_PER_CONT_24XX; ++ } else { ++ if (ha->flags.enable_64bit_addressing) { ++ PRINT_INFO("qla2x00t(%ld): 64 Bit PCI " ++ "addressing enabled", ha->instance); ++ tgt->tgt_enable_64bit_addr = 1; ++ /* 3 is reserved */ ++ sg_tablesize = ++ QLA_MAX_SG64(ha->request_q_length - 3); ++ tgt->datasegs_per_cmd = DATASEGS_PER_COMMAND64; ++ tgt->datasegs_per_cont = DATASEGS_PER_CONT64; ++ } else { ++ PRINT_INFO("qla2x00t(%ld): Using 32 Bit " ++ "PCI addressing", ha->instance); ++ sg_tablesize = ++ QLA_MAX_SG32(ha->request_q_length - 3); ++ tgt->datasegs_per_cmd = DATASEGS_PER_COMMAND32; ++ tgt->datasegs_per_cont = DATASEGS_PER_CONT32; ++ } ++ } ++ ++ rc = sysfs_create_link(scst_sysfs_get_tgt_kobj(tgt->scst_tgt), ++ &ha->host->shost_dev.kobj, "host"); ++ if (rc != 0) ++ PRINT_ERROR("qla2x00t(%ld): Unable to create \"host\" link for " ++ "target %s", ha->instance, ++ scst_get_tgt_name(tgt->scst_tgt)); ++ if (!ha->parent) { ++ rc = sysfs_create_file(scst_sysfs_get_tgt_kobj(tgt->scst_tgt), ++ &q2t_hw_target_attr.attr); ++ if (rc != 0) ++ PRINT_ERROR("qla2x00t(%ld): Unable to create " ++ "\"hw_target\" file for target %s", ++ ha->instance, scst_get_tgt_name(tgt->scst_tgt)); ++ ++ rc = sysfs_create_file(scst_sysfs_get_tgt_kobj(tgt->scst_tgt), ++ &q2t_hw_node_name_attr.attr); ++ if (rc != 0) ++ PRINT_ERROR("qla2x00t(%ld): Unable to create " ++ "\"node_name\" file for HW target %s", ++ ha->instance, scst_get_tgt_name(tgt->scst_tgt)); ++ } else { ++ rc = sysfs_create_file(scst_sysfs_get_tgt_kobj(tgt->scst_tgt), ++ &q2t_vp_node_name_attr.attr); ++ if (rc != 0) ++ PRINT_ERROR("qla2x00t(%ld): Unable to create " ++ "\"node_name\" file for NPIV target %s", ++ ha->instance, scst_get_tgt_name(tgt->scst_tgt)); ++ ++ rc = sysfs_create_file(scst_sysfs_get_tgt_kobj(tgt->scst_tgt), ++ &q2t_vp_parent_host_attr.attr); ++ if (rc != 0) ++ PRINT_ERROR("qla2x00t(%ld): Unable to create " ++ "\"parent_host\" file for NPIV target %s", ++ ha->instance, scst_get_tgt_name(tgt->scst_tgt)); ++ } ++ ++ scst_tgt_set_sg_tablesize(tgt->scst_tgt, sg_tablesize); ++ scst_tgt_set_tgt_priv(tgt->scst_tgt, tgt); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free: ++ ha->q2t_tgt = NULL; ++ kfree(tgt); ++ goto out; ++} ++ ++/* Must be called under tgt_host_action_mutex */ ++static int q2t_remove_target(scsi_qla_host_t *ha) ++{ ++ TRACE_ENTRY(); ++ ++ if ((ha->q2t_tgt == NULL) || (ha->tgt != NULL)) { ++ PRINT_ERROR("qla2x00t(%ld): Can't remove " ++ "existing target", ha->instance); ++ } ++ ++ TRACE_DBG("Unregistering target for host %ld(%p)", ha->host_no, ha); ++ scst_unregister_target(ha->q2t_tgt->scst_tgt); ++ /* ++ * Free of tgt happens via callback q2t_target_release ++ * called from scst_unregister_target, so we shouldn't touch ++ * it again. ++ */ ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++static int q2t_host_action(scsi_qla_host_t *ha, ++ qla2x_tgt_host_action_t action) ++{ ++ int res = 0; ++ scsi_qla_host_t *pha = to_qla_parent(ha); ++ ++ TRACE_ENTRY(); ++ ++ BUG_ON(ha == NULL); ++ ++ /* To sync with q2t_exit() */ ++ if (down_read_trylock(&q2t_unreg_rwsem) == 0) ++ goto out; ++ ++ mutex_lock(&ha->tgt_host_action_mutex); ++ ++ switch (action) { ++ case ADD_TARGET: ++ res = q2t_add_target(ha); ++ break; ++ case REMOVE_TARGET: ++ res = q2t_remove_target(ha); ++ break; ++ case ENABLE_TARGET_MODE: ++ { ++ fc_port_t *fcport; ++ ++ if (qla_tgt_mode_enabled(ha)) { ++ PRINT_INFO("qla2x00t(%ld): Target mode already " ++ "enabled", ha->instance); ++ break; ++ } ++ ++ if ((ha->q2t_tgt == NULL) || (ha->tgt != NULL)) { ++ PRINT_ERROR("qla2x00t(%ld): Can't enable target mode " ++ "for not existing target", ha->instance); ++ break; ++ } ++ ++ PRINT_INFO("qla2x00t(%ld): Enabling target mode", ++ ha->instance); ++ ++ spin_lock_irq(&pha->hardware_lock); ++ ha->tgt = ha->q2t_tgt; ++ ha->tgt->tgt_stop = 0; ++ spin_unlock_irq(&pha->hardware_lock); ++ list_for_each_entry_rcu(fcport, &ha->fcports, list) { ++ q2t_fc_port_added(ha, fcport); ++ } ++ TRACE_DBG("Enable tgt mode for host %ld(%ld,%p)", ++ ha->host_no, ha->instance, ha); ++ qla2x00_enable_tgt_mode(ha); ++ break; ++ } ++ ++ case DISABLE_TARGET_MODE: ++ if (!qla_tgt_mode_enabled(ha)) { ++ PRINT_INFO("qla2x00t(%ld): Target mode already " ++ "disabled", ha->instance); ++ break; ++ } ++ ++ PRINT_INFO("qla2x00t(%ld): Disabling target mode", ++ ha->instance); ++ ++ BUG_ON(ha->tgt == NULL); ++ ++ q2t_target_stop(ha->tgt->scst_tgt); ++ break; ++ ++ default: ++ PRINT_ERROR("qla2x00t(%ld): %s: unsupported action %d", ++ ha->instance, __func__, action); ++ res = -EINVAL; ++ break; ++ } ++ ++ mutex_unlock(&ha->tgt_host_action_mutex); ++ ++ up_read(&q2t_unreg_rwsem); ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int q2t_enable_tgt(struct scst_tgt *scst_tgt, bool enable) ++{ ++ struct q2t_tgt *tgt = (struct q2t_tgt *)scst_tgt_get_tgt_priv(scst_tgt); ++ scsi_qla_host_t *ha = tgt->ha; ++ int res; ++ ++ if (enable) ++ res = q2t_host_action(ha, ENABLE_TARGET_MODE); ++ else ++ res = q2t_host_action(ha, DISABLE_TARGET_MODE); ++ ++ return res; ++} ++ ++static bool q2t_is_tgt_enabled(struct scst_tgt *scst_tgt) ++{ ++ struct q2t_tgt *tgt = (struct q2t_tgt *)scst_tgt_get_tgt_priv(scst_tgt); ++ scsi_qla_host_t *ha = tgt->ha; ++ ++ return qla_tgt_mode_enabled(ha); ++} ++ ++static int q2t_parse_wwn(const char *ns, u64 *nm) ++{ ++ unsigned int i, j; ++ u8 wwn[8]; ++ ++ /* validate we have enough characters for WWPN */ ++ if (strnlen(ns, 23) != 23) ++ return -EINVAL; ++ ++ memset(wwn, 0, sizeof(wwn)); ++ ++ /* Validate and store the new name */ ++ for (i = 0, j = 0; i < 16; i++) { ++ if ((*ns >= 'a') && (*ns <= 'f')) ++ j = ((j << 4) | ((*ns++ - 'a') + 10)); ++ else if ((*ns >= 'A') && (*ns <= 'F')) ++ j = ((j << 4) | ((*ns++ - 'A') + 10)); ++ else if ((*ns >= '0') && (*ns <= '9')) ++ j = ((j << 4) | (*ns++ - '0')); ++ else ++ return -EINVAL; ++ if (i % 2) { ++ wwn[i/2] = j & 0xff; ++ j = 0; ++ if ((i < 15) && (':' != *ns++)) ++ return -EINVAL; ++ } ++ } ++ ++ *nm = wwn_to_u64(wwn); ++ ++ return 0; ++} ++ ++static ssize_t q2t_add_vtarget(const char *target_name, char *params) ++{ ++ int res; ++ char *param, *p, *pp; ++ u64 port_name, node_name, *pnode_name = NULL; ++ u64 parent_host, *pparent_host = NULL; ++ ++ TRACE_ENTRY(); ++ ++ res = q2t_parse_wwn(target_name, &port_name); ++ if (res) { ++ PRINT_ERROR("qla2x00t: Syntax error at target name %s", ++ target_name); ++ goto out; ++ } ++ ++ while (1) { ++ param = scst_get_next_token_str(¶ms); ++ if (param == NULL) ++ break; ++ ++ p = scst_get_next_lexem(¶m); ++ if (*p == '\0') { ++ PRINT_ERROR("qla2x00t: Syntax error at %s (target %s)", ++ param, target_name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ pp = scst_get_next_lexem(¶m); ++ if (*pp == '\0') { ++ PRINT_ERROR("qla2x00t: Parameter %s value missed for " ++ "target %s", p, target_name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (scst_get_next_lexem(¶m)[0] != '\0') { ++ PRINT_ERROR("qla2x00t: Too many parameter's %s values " ++ "(target %s)", p, target_name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (!strcasecmp("node_name", p)) { ++ res = q2t_parse_wwn(pp, &node_name); ++ if (res) { ++ PRINT_ERROR("qla2x00t: Illegal node_name %s " ++ "(target %s)", pp, target_name); ++ res = -EINVAL; ++ goto out; ++ } ++ pnode_name = &node_name; ++ continue; ++ } ++ ++ if (!strcasecmp("parent_host", p)) { ++ res = q2t_parse_wwn(pp, &parent_host); ++ if (res != 0) { ++ PRINT_ERROR("qla2x00t: Illegal parent_host %s" ++ " (target %s)", pp, target_name); ++ goto out; ++ } ++ pparent_host = &parent_host; ++ continue; ++ } ++ ++ PRINT_ERROR("qla2x00t: Unknown parameter %s (target %s)", p, ++ target_name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (!pnode_name) { ++ PRINT_ERROR("qla2x00t: Missing parameter node_name (target %s)", ++ target_name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ if (!pparent_host) { ++ PRINT_ERROR("qla2x00t: Missing parameter parent_host " ++ "(target %s)", target_name); ++ res = -EINVAL; ++ goto out; ++ } ++ ++ res = qla2xxx_add_vtarget(&port_name, pnode_name, pparent_host); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t q2t_del_vtarget(const char *target_name) ++{ ++ int res; ++ u64 port_name; ++ ++ TRACE_ENTRY(); ++ ++ res = q2t_parse_wwn(target_name, &port_name); ++ if (res) { ++ PRINT_ERROR("qla2x00t: Syntax error at target name %s", ++ target_name); ++ goto out; ++ } ++ ++ res = qla2xxx_del_vtarget(&port_name); ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int q2t_get_initiator_port_transport_id(struct scst_tgt *tgt, ++ struct scst_session *scst_sess, uint8_t **transport_id) ++{ ++ struct q2t_sess *sess; ++ int res = 0; ++ int tr_id_size; ++ uint8_t *tr_id; ++ ++ TRACE_ENTRY(); ++ ++ if (scst_sess == NULL) { ++ res = SCSI_TRANSPORTID_PROTOCOLID_FCP2; ++ goto out; ++ } ++ ++ sess = (struct q2t_sess *)scst_sess_get_tgt_priv(scst_sess); ++ ++ tr_id_size = 24; ++ ++ tr_id = kzalloc(tr_id_size, GFP_KERNEL); ++ if (tr_id == NULL) { ++ PRINT_ERROR("qla2x00t: Allocation of TransportID (size %d) " ++ "failed", tr_id_size); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ tr_id[0] = SCSI_TRANSPORTID_PROTOCOLID_FCP2; ++ ++ BUILD_BUG_ON(sizeof(sess->port_name) != 8); ++ memcpy(&tr_id[8], sess->port_name, 8); ++ ++ *transport_id = tr_id; ++ ++ TRACE_BUFF_FLAG(TRACE_DEBUG, "Created tid", tr_id, tr_id_size); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t q2t_show_expl_conf_enabled(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buffer) ++{ ++ struct scst_tgt *scst_tgt; ++ struct q2t_tgt *tgt; ++ scsi_qla_host_t *ha; ++ ssize_t size; ++ ++ scst_tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ tgt = (struct q2t_tgt *)scst_tgt_get_tgt_priv(scst_tgt); ++ ha = tgt->ha; ++ ++ size = scnprintf(buffer, PAGE_SIZE, "%d\n%s", ha->enable_explicit_conf, ++ ha->enable_explicit_conf ? SCST_SYSFS_KEY_MARK "\n" : ""); ++ ++ return size; ++} ++ ++static ssize_t q2t_store_expl_conf_enabled(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buffer, size_t size) ++{ ++ struct scst_tgt *scst_tgt; ++ struct q2t_tgt *tgt; ++ scsi_qla_host_t *ha, *pha; ++ unsigned long flags; ++ ++ scst_tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ tgt = (struct q2t_tgt *)scst_tgt_get_tgt_priv(scst_tgt); ++ ha = tgt->ha; ++ pha = to_qla_parent(ha); ++ ++ spin_lock_irqsave(&pha->hardware_lock, flags); ++ ++ switch (buffer[0]) { ++ case '0': ++ ha->enable_explicit_conf = 0; ++ PRINT_INFO("qla2x00t(%ld): explicit conformations disabled", ++ ha->instance); ++ break; ++ case '1': ++ ha->enable_explicit_conf = 1; ++ PRINT_INFO("qla2x00t(%ld): explicit conformations enabled", ++ ha->instance); ++ break; ++ default: ++ PRINT_ERROR("%s: qla2x00t(%ld): Requested action not " ++ "understood: %s", __func__, ha->instance, buffer); ++ break; ++ } ++ ++ spin_unlock_irqrestore(&pha->hardware_lock, flags); ++ ++ return size; ++} ++ ++static ssize_t q2t_abort_isp_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buffer, size_t size) ++{ ++ struct scst_tgt *scst_tgt; ++ struct q2t_tgt *tgt; ++ scsi_qla_host_t *ha; ++ ++ scst_tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ tgt = (struct q2t_tgt *)scst_tgt_get_tgt_priv(scst_tgt); ++ ha = tgt->ha; ++ ++ PRINT_INFO("qla2x00t(%ld): Aborting ISP", ha->instance); ++ ++ set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); ++ qla2x00_wait_for_hba_online(ha); ++ ++ return size; ++} ++ ++static ssize_t q2t_version_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ sprintf(buf, "%s\n", Q2T_VERSION_STRING); ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ strcat(buf, "EXTRACHECKS\n"); ++#endif ++ ++#ifdef CONFIG_SCST_TRACING ++ strcat(buf, "TRACING\n"); ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG ++ strcat(buf, "DEBUG\n"); ++#endif ++ ++#ifdef CONFIG_QLA_TGT_DEBUG_WORK_IN_THREAD ++ strcat(buf, "QLA_TGT_DEBUG_WORK_IN_THREAD\n"); ++#endif ++ ++ TRACE_EXIT(); ++ return strlen(buf); ++} ++ ++static ssize_t q2t_hw_target_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ return sprintf(buf, "%d\n", 1); ++} ++ ++static ssize_t q2t_node_name_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_tgt *scst_tgt; ++ struct q2t_tgt *tgt; ++ scsi_qla_host_t *ha; ++ ssize_t res; ++ char *wwn; ++ uint8_t *node_name; ++ ++ scst_tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ tgt = (struct q2t_tgt *)scst_tgt_get_tgt_priv(scst_tgt); ++ ha = tgt->ha; ++ ++ if (ha->parent == NULL) { ++ if (qla_tgt_mode_enabled(ha) || !ha->node_name_set) ++ node_name = ha->node_name; ++ else ++ node_name = ha->tgt_node_name; ++ } else ++ node_name = ha->node_name; ++ ++ res = q2t_get_target_name(node_name, &wwn); ++ if (res != 0) ++ goto out; ++ ++ res = sprintf(buf, "%s\n", wwn); ++ if ((ha->parent != NULL) || ha->node_name_set) ++ res += sprintf(&buf[res], "%s\n", SCST_SYSFS_KEY_MARK); ++ ++ kfree(wwn); ++ ++out: ++ return res; ++} ++ ++static ssize_t q2t_node_name_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buffer, size_t size) ++{ ++ struct scst_tgt *scst_tgt; ++ struct q2t_tgt *tgt; ++ scsi_qla_host_t *ha; ++ u64 node_name, old_node_name; ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ scst_tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ tgt = (struct q2t_tgt *)scst_tgt_get_tgt_priv(scst_tgt); ++ ha = tgt->ha; ++ ++ BUG_ON(ha->parent != NULL); ++ ++ if (size == 0) ++ goto out_default; ++ ++ res = q2t_parse_wwn(buffer, &node_name); ++ if (res != 0) { ++ if ((buffer[0] == '\0') || (buffer[0] == '\n')) ++ goto out_default; ++ PRINT_ERROR("qla2x00t(%ld): Wrong node name", ha->instance); ++ goto out; ++ } ++ ++ old_node_name = wwn_to_u64(ha->node_name); ++ if (old_node_name == node_name) ++ goto out_success; ++ ++ u64_to_wwn(node_name, ha->tgt_node_name); ++ ha->node_name_set = 1; ++ ++abort: ++ if (qla_tgt_mode_enabled(ha)) { ++ set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); ++ qla2x00_wait_for_hba_online(ha); ++ } ++ ++out_success: ++ res = size; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_default: ++ ha->node_name_set = 0; ++ goto abort; ++} ++ ++static ssize_t q2t_vp_parent_host_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_tgt *scst_tgt; ++ struct q2t_tgt *tgt; ++ scsi_qla_host_t *ha; ++ ssize_t res; ++ char *wwn; ++ ++ scst_tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ tgt = (struct q2t_tgt *)scst_tgt_get_tgt_priv(scst_tgt); ++ ha = to_qla_parent(tgt->ha); ++ ++ res = q2t_get_target_name(ha->port_name, &wwn); ++ if (res != 0) ++ goto out; ++ ++ res = sprintf(buf, "%s\n%s\n", wwn, SCST_SYSFS_KEY_MARK); ++ ++ kfree(wwn); ++ ++out: ++ return res; ++} ++ ++static uint16_t q2t_get_scsi_transport_version(struct scst_tgt *scst_tgt) ++{ ++ /* FCP-2 */ ++ return 0x0900; ++} ++ ++static uint16_t q2t_get_phys_transport_version(struct scst_tgt *scst_tgt) ++{ ++ return 0x0DA0; /* FC-FS */ ++} ++ ++static int __init q2t_init(void) ++{ ++ int res = 0; ++ ++ TRACE_ENTRY(); ++ ++ BUILD_BUG_ON(sizeof(atio7_entry_t) != sizeof(atio_entry_t)); ++ ++ PRINT_INFO("qla2x00t: Initializing QLogic Fibre Channel HBA Driver " ++ "target mode addon version %s", Q2T_VERSION_STRING); ++ ++ q2t_cmd_cachep = KMEM_CACHE(q2t_cmd, SCST_SLAB_FLAGS); ++ if (q2t_cmd_cachep == NULL) { ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ q2t_mgmt_cmd_cachep = KMEM_CACHE(q2t_mgmt_cmd, SCST_SLAB_FLAGS); ++ if (q2t_mgmt_cmd_cachep == NULL) { ++ res = -ENOMEM; ++ goto out_cmd_free; ++ } ++ ++ q2t_mgmt_cmd_mempool = mempool_create(25, mempool_alloc_slab, ++ mempool_free_slab, q2t_mgmt_cmd_cachep); ++ if (q2t_mgmt_cmd_mempool == NULL) { ++ res = -ENOMEM; ++ goto out_kmem_free; ++ } ++ ++ res = scst_register_target_template(&tgt2x_template); ++ if (res < 0) ++ goto out_mempool_free; ++ ++ /* ++ * qla2xxx_tgt_register_driver() happens in q2t_target_detect ++ * called via scst_register_target_template() ++ */ ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++ scst_unregister_target_template(&tgt2x_template); ++ qla2xxx_tgt_unregister_driver(); ++ ++out_mempool_free: ++ mempool_destroy(q2t_mgmt_cmd_mempool); ++ ++out_kmem_free: ++ kmem_cache_destroy(q2t_mgmt_cmd_cachep); ++ ++out_cmd_free: ++ kmem_cache_destroy(q2t_cmd_cachep); ++ goto out; ++} ++ ++static void __exit q2t_exit(void) ++{ ++ TRACE_ENTRY(); ++ ++ PRINT_INFO("qla2x00t: %s", "Unloading QLogic Fibre Channel HBA Driver " ++ "target mode addon driver"); ++ ++ /* To sync with q2t_host_action() */ ++ down_write(&q2t_unreg_rwsem); ++ ++ scst_unregister_target_template(&tgt2x_template); ++ ++ /* ++ * Now we have everywhere target mode disabled and no possibilities ++ * to call us through sysfs, so we can safely remove all the references ++ * to our functions. ++ */ ++ qla2xxx_tgt_unregister_driver(); ++ ++ mempool_destroy(q2t_mgmt_cmd_mempool); ++ kmem_cache_destroy(q2t_mgmt_cmd_cachep); ++ kmem_cache_destroy(q2t_cmd_cachep); ++ ++ /* Let's make lockdep happy */ ++ up_write(&q2t_unreg_rwsem); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++module_init(q2t_init); ++module_exit(q2t_exit); ++ ++MODULE_AUTHOR("Vladislav Bolkhovitin and others"); ++MODULE_DESCRIPTION("Target mode addon for qla2[2,3,4,5+]xx"); ++MODULE_LICENSE("GPL"); ++MODULE_VERSION(Q2T_VERSION_STRING); +diff -uprN orig/linux-3.2/drivers/scst/qla2xxx-target/qla2x00t.h linux-3.2/drivers/scst/qla2xxx-target/qla2x00t.h +--- orig/linux-3.2/drivers/scst/qla2xxx-target/qla2x00t.h ++++ linux-3.2/drivers/scst/qla2xxx-target/qla2x00t.h +@@ -0,0 +1,287 @@ ++/* ++ * qla2x00t.h ++ * ++ * Copyright (C) 2004 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * Copyright (C) 2004 - 2005 Leonid Stoljar ++ * Copyright (C) 2006 Nathaniel Clark <nate@misrule.us> ++ * Copyright (C) 2006 - 2010 ID7 Ltd. ++ * Copyright (C) 2010 - 2011 SCST Ltd. ++ * ++ * QLogic 22xx/23xx/24xx/25xx FC target driver. ++ * ++ * 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, version 2 ++ * of the License. ++ * ++ * 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. ++ */ ++ ++#ifndef __QLA2X00T_H ++#define __QLA2X00T_H ++ ++#include <qla_def.h> ++#include <qla2x_tgt.h> ++#include <qla2x_tgt_def.h> ++ ++#include <scst_debug.h> ++ ++/* Version numbers, the same as for the kernel */ ++#define Q2T_VERSION(a, b, c, d) (((a) << 030) + ((b) << 020) + (c) << 010 + (d)) ++#define Q2T_VERSION_CODE Q2T_VERSION(2, 2, 0, 0) ++#define Q2T_VERSION_STRING "2.2.0-pre" ++#define Q2T_PROC_VERSION_NAME "version" ++ ++#define Q2T_MAX_CDB_LEN 16 ++#define Q2T_TIMEOUT 10 /* in seconds */ ++ ++#define Q2T_MAX_HW_PENDING_TIME 60 /* in seconds */ ++ ++/* Immediate notify status constants */ ++#define IMM_NTFY_LIP_RESET 0x000E ++#define IMM_NTFY_LIP_LINK_REINIT 0x000F ++#define IMM_NTFY_IOCB_OVERFLOW 0x0016 ++#define IMM_NTFY_ABORT_TASK 0x0020 ++#define IMM_NTFY_PORT_LOGOUT 0x0029 ++#define IMM_NTFY_PORT_CONFIG 0x002A ++#define IMM_NTFY_GLBL_TPRLO 0x002D ++#define IMM_NTFY_GLBL_LOGO 0x002E ++#define IMM_NTFY_RESOURCE 0x0034 ++#define IMM_NTFY_MSG_RX 0x0036 ++#define IMM_NTFY_SRR 0x0045 ++#define IMM_NTFY_ELS 0x0046 ++ ++/* Immediate notify task flags */ ++#define IMM_NTFY_TASK_MGMT_SHIFT 8 ++ ++#define Q2T_CLEAR_ACA 0x40 ++#define Q2T_TARGET_RESET 0x20 ++#define Q2T_LUN_RESET 0x10 ++#define Q2T_CLEAR_TS 0x04 ++#define Q2T_ABORT_TS 0x02 ++#define Q2T_ABORT_ALL_SESS 0xFFFF ++#define Q2T_ABORT_ALL 0xFFFE ++#define Q2T_NEXUS_LOSS_SESS 0xFFFD ++#define Q2T_NEXUS_LOSS 0xFFFC ++ ++/* Notify Acknowledge flags */ ++#define NOTIFY_ACK_RES_COUNT BIT_8 ++#define NOTIFY_ACK_CLEAR_LIP_RESET BIT_5 ++#define NOTIFY_ACK_TM_RESP_CODE_VALID BIT_4 ++ ++/* Command's states */ ++#define Q2T_STATE_NEW 0 /* New command and SCST processing it */ ++#define Q2T_STATE_NEED_DATA 1 /* SCST needs data to continue */ ++#define Q2T_STATE_DATA_IN 2 /* Data arrived and SCST processing it */ ++#define Q2T_STATE_PROCESSED 3 /* SCST done processing */ ++#define Q2T_STATE_ABORTED 4 /* Command aborted */ ++ ++/* Special handles */ ++#define Q2T_NULL_HANDLE 0 ++#define Q2T_SKIP_HANDLE (0xFFFFFFFF & ~CTIO_COMPLETION_HANDLE_MARK) ++ ++/* ATIO task_codes field */ ++#define ATIO_SIMPLE_QUEUE 0 ++#define ATIO_HEAD_OF_QUEUE 1 ++#define ATIO_ORDERED_QUEUE 2 ++#define ATIO_ACA_QUEUE 4 ++#define ATIO_UNTAGGED 5 ++ ++/* TM failed response codes, see FCP (9.4.11 FCP_RSP_INFO) */ ++#define FC_TM_SUCCESS 0 ++#define FC_TM_BAD_FCP_DATA 1 ++#define FC_TM_BAD_CMD 2 ++#define FC_TM_FCP_DATA_MISMATCH 3 ++#define FC_TM_REJECT 4 ++#define FC_TM_FAILED 5 ++ ++/* ++ * Error code of q2t_pre_xmit_response() meaning that cmd's exchange was ++ * terminated, so no more actions is needed and success should be returned ++ * to SCST. Must be different from any SCST_TGT_RES_* codes. ++ */ ++#define Q2T_PRE_XMIT_RESP_CMD_ABORTED 0x1717 ++ ++#if (BITS_PER_LONG > 32) || defined(CONFIG_HIGHMEM64G) ++#define pci_dma_lo32(a) (a & 0xffffffff) ++#define pci_dma_hi32(a) ((((a) >> 16)>>16) & 0xffffffff) ++#else ++#define pci_dma_lo32(a) (a & 0xffffffff) ++#define pci_dma_hi32(a) 0 ++#endif ++ ++struct q2t_tgt { ++ struct scst_tgt *scst_tgt; ++ scsi_qla_host_t *ha; ++ ++ /* ++ * To sync between IRQ handlers and q2t_target_release(). Needed, ++ * because req_pkt() can drop/reacquire HW lock inside. Protected by ++ * HW lock. ++ */ ++ int irq_cmd_count; ++ ++ int datasegs_per_cmd, datasegs_per_cont; ++ ++ /* Target's flags, serialized by pha->hardware_lock */ ++ unsigned int tgt_enable_64bit_addr:1; /* 64-bits PCI addressing enabled */ ++ unsigned int link_reinit_iocb_pending:1; ++ unsigned int tm_to_unknown:1; /* TM to unknown session was sent */ ++ unsigned int sess_works_pending:1; /* there are sess_work entries */ ++ ++ /* ++ * Protected by tgt_mutex AND hardware_lock for writing and tgt_mutex ++ * OR hardware_lock for reading. ++ */ ++ unsigned long tgt_stop; /* the driver is being stopped */ ++ ++ /* Count of sessions refering q2t_tgt. Protected by hardware_lock. */ ++ int sess_count; ++ ++ /* Protected by hardware_lock. Addition also protected by tgt_mutex. */ ++ struct list_head sess_list; ++ ++ /* Protected by hardware_lock */ ++ struct list_head del_sess_list; ++ struct delayed_work sess_del_work; ++ ++ spinlock_t sess_work_lock; ++ struct list_head sess_works_list; ++ struct work_struct sess_work; ++ ++ notify24xx_entry_t link_reinit_iocb; ++ wait_queue_head_t waitQ; ++ int notify_ack_expected; ++ int abts_resp_expected; ++ int modify_lun_expected; ++ ++ int ctio_srr_id; ++ int imm_srr_id; ++ spinlock_t srr_lock; ++ struct list_head srr_ctio_list; ++ struct list_head srr_imm_list; ++ struct work_struct srr_work; ++ ++ atomic_t tgt_global_resets_count; ++ ++ struct list_head tgt_list_entry; ++}; ++ ++/* ++ * Equivilant to IT Nexus (Initiator-Target) ++ */ ++struct q2t_sess { ++ uint16_t loop_id; ++ port_id_t s_id; ++ ++ unsigned int conf_compl_supported:1; ++ unsigned int deleted:1; ++ unsigned int local:1; ++ ++ struct scst_session *scst_sess; ++ struct q2t_tgt *tgt; ++ ++ int sess_ref; /* protected by hardware_lock */ ++ ++ struct list_head sess_list_entry; ++ unsigned long expires; ++ struct list_head del_list_entry; ++ ++ uint8_t port_name[WWN_SIZE]; ++}; ++ ++struct q2t_cmd { ++ struct q2t_sess *sess; ++ int state; ++ struct scst_cmd *scst_cmd; ++ ++ unsigned int conf_compl_supported:1;/* to save extra sess dereferences */ ++ unsigned int sg_mapped:1; ++ unsigned int free_sg:1; ++ unsigned int aborted:1; /* Needed in case of SRR */ ++ unsigned int write_data_transferred:1; ++ ++ struct scatterlist *sg; /* cmd data buffer SG vector */ ++ int sg_cnt; /* SG segments count */ ++ int bufflen; /* cmd buffer length */ ++ int offset; ++ scst_data_direction data_direction; ++ uint32_t tag; ++ dma_addr_t dma_handle; ++ enum dma_data_direction dma_data_direction; ++ ++ uint16_t loop_id; /* to save extra sess dereferences */ ++ struct q2t_tgt *tgt; /* to save extra sess dereferences */ ++ ++ union { ++ atio7_entry_t atio7; ++ atio_entry_t atio2x; ++ } __attribute__((packed)) atio; ++}; ++ ++struct q2t_sess_work_param { ++ struct list_head sess_works_list_entry; ++ ++#define Q2T_SESS_WORK_CMD 0 ++#define Q2T_SESS_WORK_ABORT 1 ++#define Q2T_SESS_WORK_TM 2 ++ int type; ++ ++ union { ++ struct q2t_cmd *cmd; ++ abts24_recv_entry_t abts; ++ notify_entry_t tm_iocb; ++ atio7_entry_t tm_iocb2; ++ }; ++}; ++ ++struct q2t_mgmt_cmd { ++ struct q2t_sess *sess; ++ unsigned int flags; ++#define Q24_MGMT_SEND_NACK 1 ++ union { ++ atio7_entry_t atio7; ++ notify_entry_t notify_entry; ++ notify24xx_entry_t notify_entry24; ++ abts24_recv_entry_t abts; ++ } __attribute__((packed)) orig_iocb; ++}; ++ ++struct q2t_prm { ++ struct q2t_cmd *cmd; ++ struct q2t_tgt *tgt; ++ void *pkt; ++ struct scatterlist *sg; /* cmd data buffer SG vector */ ++ int seg_cnt; ++ int req_cnt; ++ uint16_t rq_result; ++ uint16_t scsi_status; ++ unsigned char *sense_buffer; ++ int sense_buffer_len; ++ int residual; ++ int add_status_pkt; ++}; ++ ++struct srr_imm { ++ struct list_head srr_list_entry; ++ int srr_id; ++ union { ++ notify_entry_t notify_entry; ++ notify24xx_entry_t notify_entry24; ++ } __attribute__((packed)) imm; ++}; ++ ++struct srr_ctio { ++ struct list_head srr_list_entry; ++ int srr_id; ++ struct q2t_cmd *cmd; ++}; ++ ++#define Q2T_XMIT_DATA 1 ++#define Q2T_XMIT_STATUS 2 ++#define Q2T_XMIT_ALL (Q2T_XMIT_STATUS|Q2T_XMIT_DATA) ++ ++#endif /* __QLA2X00T_H */ +diff -uprN orig/linux-3.2/Documentation/scst/README.qla2x00t linux-3.2/Documentation/scst/README.qla2x00t +--- orig/linux-3.2/Documentation/scst/README.qla2x00t ++++ linux-3.2/Documentation/scst/README.qla2x00t +@@ -0,0 +1,572 @@ ++Target driver for QLogic 22xx/23xx/24xx/25xx Fibre Channel cards ++================================================================ ++ ++Version 2.1.0 ++------------- ++ ++This driver consists from two parts: the target mode driver itself and ++the changed initiator driver from Linux kernel, which is, particularly, ++intended to perform all the initialization and shutdown tasks. The ++initiator driver was changed to provide the target mode support and all ++necessary callbacks, but it's still capable to work as initiator only. ++Mode, when a host acts as the initiator and the target simultaneously, ++is supported as well. ++ ++This version is compatible with SCST core version 2.0.0 and higher and ++Linux kernel 2.6.26 and higher. Sorry, kernels below 2.6.26 are not ++supported, because it's too hard to backport used initiator driver to ++older kernels. ++ ++The original initiator driver was taken from the kernel 2.6.26. Also the ++following 2.6.26.x commits have been applied to it (upstream ID): ++048feec5548c0582ee96148c61b87cccbcb5f9be, ++031e134e5f95233d80fb1b62fdaf5e1be587597c, ++5f3a9a207f1fccde476dd31b4c63ead2967d934f, ++85821c906cf3563a00a3d98fa380a2581a7a5ff1, ++3c01b4f9fbb43fc911acd33ea7a14ea7a4f9866b, ++8eca3f39c4b11320787f7b216f63214aee8415a9, ++0f19bc681ed0849a2b95778460a0a8132e3700e2. ++ ++See also "ToDo" file for list of known issues and unimplemented ++features. ++ ++ ++Installation ++------------ ++ ++Only vanilla kernels from kernel.org and RHEL/CentOS 5.2 kernels are ++supported, but SCST should work on other (vendors') kernels, if you ++manage to successfully compile it on them. The main problem with ++vendors' kernels is that they often contain patches, which will appear ++only in the next version of the vanilla kernel, therefore it's quite ++hard to track such changes. Thus, if during compilation for some vendor ++kernel your compiler complains about redefinition of some symbol, you ++should either switch to vanilla kernel, or add or change as necessary ++the corresponding to that symbol "#if LINUX_VERSION_CODE" statement. ++ ++Before installation make sure that the link ++"/lib/modules/`you_kernel_version`/build" points to the source code for ++your currently running kernel. ++ ++If your kernel version is <2.6.28, then you should consider applying ++kernel patch scst_fc_vport_create.patch from the "kernel" subdirectory. ++Without it, creating and removing NPIV targets using SCST sysfs ++interface will be disabled. NOTE: you will still be able to create and ++remove NPIV targets using the standard Linux interface (i.e. echoing ++wwpn:wwnn into /sys/class/fc_host/hostX/vport_create and ++/sys/class/fc_host/hostX/vport_delete). ++ ++Then you should replace (or link) by the initiator driver from this ++package "qla2xxx" subdirectory in kernel_source/drivers/scsi/ of the ++currently running kernel and using your favorite kernel configuration ++tool enable in the QLogic QLA2XXX Fibre Channel driver target mode ++support (CONFIG_SCSI_QLA2XXX_TARGET). Then rebuild the kernel and its ++modules. During this step you will compile the initiator driver. To ++install it, install the built kernel and its modules. ++ ++Then edit qla2x00-target/Makefile and set SCST_INC_DIR variable to point ++to the directory, where SCST's public include files are located. If you ++install QLA2x00 target driver's source code in the SCST's directory, ++then SCST_INC_DIR will be set correctly for you. ++ ++Also you can set SCST_DIR variable to the directory, where SCST was ++built, but this is optional. If you don't set it or set incorrectly, ++during the compilation you will get a bunch of harmless warnings like ++"WARNING: "scst_rx_data" [/XXX/qla2x00tgt.ko] undefined!" ++ ++To compile the target driver, type 'make' in qla2x00-target/ ++subdirectory. It will build qla2x00tgt.ko module. ++ ++To install the target driver, type 'make install' in qla2x00-target/ ++subdirectory. The target driver will be installed in ++/lib/modules/`you_kernel_version`/extra. To uninstall it, type 'make ++uninstall'. ++ ++ ++Usage ++----- ++ ++After the drivers are loaded and adapters successfully initialized by ++the initiator driver, including firmware image load, you should ++configure exported devices using the corresponding interface of SCST ++core. It is highly recommended to use scstadmin utility for that ++purpose. ++ ++Then target mode should be enabled via a sysfs interface on a per card ++basis, like: ++ ++echo "1" >/sys/kernel/scst_tgt/targets/qla2x00t/target/enabled ++ ++See below for full description of the driver's sysfs interface. ++ ++With the obsolete proc interface you should instead use ++target_mode_enabled under the appropriate scsi_host entry, like: ++ ++echo "1" >/sys/class/scsi_host/host0/target_mode_enabled ++ ++You can find some installation and configuration HOWTOs in ++http://scst.sourceforge.net/qla2x00t-howto.html and ++https://forums.openfiler.com/viewtopic.php?id=3422. ++ ++ ++IMPORTANT USAGE NOTES ++--------------------- ++ ++1. It is strongly recommended to use firmware version 5.x or higher ++for 24xx/25xx adapters. See ++http://sourceforge.net/mailarchive/forum.php?thread_name=4B4CD39F.6020401%40vlnb.net&forum_name=scst-devel ++for more details why. ++ ++2. If you reload qla2x00tgt module, you should also reload qla2xxx ++module, otherwise your initiators could not see the target, when it is ++enabled after qla2x00tgt module load. ++ ++3. You need to issue LIP after you enabled a target, if you enabled it ++after one or more its initiators already started. ++ ++ ++Initiator and target modes ++-------------------------- ++ ++When qla2xxx compiled with CONFIG_SCSI_QLA2XXX_TARGET enabled, it has ++parameter "qlini_mode", which determines when initiator mode will be ++enabled. Possible values: ++ ++ - "exclusive" (default) - initiator mode will be enabled on load, ++disabled on enabling target mode and then on disabling target mode ++enabled back. ++ ++ - "disabled" - initiator mode will never be enabled. ++ ++ - "enabled" - initiator mode will always stay enabled. ++ ++Usage of mode "disabled" is recommended, if you have incorrectly ++functioning your target's initiators, which if once seen a port in ++initiator mode, later refuse to see it as a target. ++ ++Use mode "enabled" if you need your QLA adapters to work in both ++initiator and target modes at the same time. ++ ++You can always see which modes are currently active in active_mode sysfs ++attribute. ++ ++In all the modes you can at any time use sysfs attribute ++ini_mode_force_reverse to force enable or disable initiator mode on any ++particular port. Setting this attribute to 1 will reverse current status ++of the initiator mode from enabled to disabled and vice versa. ++ ++ ++Explicit conformation ++--------------------- ++ ++This option should (actually, almost always must) be enabled by echoing ++"1" in /sys/kernel/scst_tgt/targets/qla2x00t/target/host/explicit_conform_enabled, ++if a target card exports at least one stateful SCSI device, like tape, ++and class 2 isn't used, otherwise link-level errors could lead to loss ++of the target/initiator state synchronization. Also check if initiator ++supports this feature, it is reported in the kernel logs ("confirmed ++completion supported" or not). No major performance degradation was ++noticed, if it is enabled. Supported only for 23xx+. Disabled by ++default. ++ ++ ++Class 2 ++------- ++ ++Class 2 is the close equivalent of TCP in the network world. If you ++enable it, all the Fibre Channel packets will be acknowledged. By ++default, class 3 is used, which is UDP-like. Enable class 2 by echoing ++"1" in /sys/kernel/scst_tgt/targets/qla2x00t/target/host/class2_enabled. ++This option needs a special firmware with class 2 support. Disabled by ++default. ++ ++ ++N_Port ID Virtualization ++------------------------ ++ ++N_Port ID Virtualization (NPIV) is a Fibre Channel facility allowing ++multiple N_Port IDs to share a single physical N_Port. NPIV is fully ++supported by this driver. You must have 24xx+ ISPs with NPIV-supporting ++and NPIV-switches switch(es) to use this facility. ++ ++You can add NPIV targets by echoing: ++ ++add_target target_name node_name=node_name_value; parent_host=parent_host_value ++ ++in /sys/kernel/scst_tgt/targets/qla2x00t/mgmt. ++ ++Removing NPIV targets is done by echoing: ++ ++del_target target_name ++ ++in/sys/kernel/scst_tgt/targets/qla2x00t/mgmt. ++ ++Also, you can create and remove NPIV targets using the standard Linux ++interface (i.e. echoing wwpn:wwnn into /sys/class/fc_host/hostX/vport_create ++and /sys/class/fc_host/hostX/vport_delete). ++ ++It is recommended to use scstadmin utility and its config file to ++configure virtual NPIV targets instead of the above direct interface. ++ ++ ++Compilation options ++------------------- ++ ++There are the following compilation options, that could be commented ++in/out in Makefile: ++ ++ - CONFIG_SCST_DEBUG - turns on some debugging code, including some logging. ++ Makes the driver considerably bigger and slower, producing large amount of ++ log data. ++ ++ - CONFIG_SCST_TRACING - turns on ability to log events. Makes the driver ++ considerably bigger and leads to some performance loss. ++ ++ - CONFIG_QLA_TGT_DEBUG_WORK_IN_THREAD - makes SCST process incoming ++ commands from the qla2x00t target driver and call the driver's ++ callbacks in internal SCST threads context instead of SIRQ context, ++ where those commands were received. Useful for debugging and lead to ++ some performance loss. ++ ++ - CONFIG_QLA_TGT_DEBUG_SRR - turns on retransmitting packets (SRR) ++ debugging. In this mode some CTIOs will be "broken" to force the ++ initiator to issue a retransmit request. ++ ++ ++Sysfs interface ++--------------- ++ ++Starting from 2.0.0 this driver has sysfs interface. The procfs ++interface from version 2.0.0 is obsolete and will be removed in one of ++the next versions. ++ ++Root of SCST sysfs interface is /sys/kernel/scst_tgt. Root of this ++driver is /sys/kernel/scst_tgt/targets/qla2x00t. It has the following ++entries: ++ ++ - None, one or more subdirectories for targets with name equal to port ++ names of the corresponding targets. ++ ++ - trace_level - allows to enable and disable various tracing ++ facilities. See content of this file for help how to use it. ++ ++ - version - read-only attribute, which allows to see version of ++ this driver and enabled optional features. ++ ++ - mgmt - main management entry, which allows to configure NPIV targets. ++ See content of this file for help how to use it. ++ ++ - hw_target (hardware target only) - read-only attribute with value 1. ++ It allows to distinguish hardware and virtual targets. ++ ++Each target subdirectory contains the following entries: ++ ++ - host - link pointing on the corresponding scsi_host of the initiator ++ driver ++ ++ - ini_groups - subdirectory defining initiator groups for this target, ++ used to define per-initiator access control. See SCST core README for ++ more details. ++ ++ - luns - subdirectory defining LUNs of this target. See SCST core ++ README for more details. ++ ++ - sessions - subdirectory containing connected to this target sessions. ++ ++ - enabled - using this attribute you can enable or disable target mode ++ of this FC port. It allows to finish configuring it before it starts ++ accepting new connections. 0 by default. ++ ++ - explicit_confirmation - allows to enable explicit conformations, see ++ above. ++ ++ - rel_tgt_id - allows to read or write SCSI Relative Target Port ++ Identifier attribute. This identifier is used to identify SCSI Target ++ Ports by some SCSI commands, mainly by Persistent Reservations ++ commands. This identifier must be unique among all SCST targets, but ++ for convenience SCST allows disabled targets to have not unique ++ rel_tgt_id. In this case SCST will not allow to enable this target ++ until rel_tgt_id becomes unique. This attribute initialized unique by ++ SCST by default. ++ ++ - node_name (NPIV targets only) - read-only attribute, which allows to see ++ the target World Wide Node Name. ++ ++ - parent_host (NPIV target only) - read-only attribute, which allows to see ++ the parent HBA World Wide Port Name (WWPN). ++ ++Subdirectory "sessions" contains one subdirectory for each connected ++session with name equal to port name of the connected initiator. ++ ++Each session subdirectory contains the following entries: ++ ++ - initiator_name - contains initiator's port name ++ ++ - active_commands - contains number of active, i.e. not yet or being ++ executed, SCSI commands in this session. ++ ++ - commands - contains overall number of SCSI commands in this session. ++ ++Below is a sample script, which configures 2 virtual disk "disk1" using ++/disk1 image for usage with 25:00:00:f0:98:87:92:f3 hardware target, and ++"disk2" using /disk2 image for usage with 50:50:00:00:00:00:00:11 NPIV ++target. All initiators connected to this targets will see those devices. ++ ++#!/bin/bash ++ ++modprobe scst ++modprobe scst_vdisk ++ ++echo "add_device disk1 filename=/disk1; nv_cache=1" >/sys/kernel/scst_tgt/handlers/vdisk_fileio/mgmt ++echo "add_device disk2 filename=/disk2; nv_cache=1" >/sys/kernel/scst_tgt/handlers/vdisk_fileio/mgmt ++ ++modprobe qla2x00tgt ++ ++echo "add_target 50:50:00:00:00:00:00:11 node_name=50:50:00:00:00:00:00:00;parent_host=25:00:00:f0:98:87:92:f3" >\ ++/sys/kernel/scst_tgt/targets/qla2x00t/mgmt ++ ++echo "add disk1 0" >/sys/kernel/scst_tgt/targets/qla2x00t/25:00:00:f0:98:87:92:f3/luns/mgmt ++echo "add disk2 0" >/sys/kernel/scst_tgt/targets/qla2x00t/50:50:00:00:00:00:00:11/luns/mgmt ++echo 1 >/sys/kernel/scst_tgt/targets/qla2x00t/25:00:00:f0:98:87:92:f3/enabled ++echo 1 >/sys/kernel/scst_tgt/targets/qla2x00t/50:50:00:00:00:00:00:11/enabled ++ ++Below is another sample script, which configures 1 real local SCSI disk ++0:0:1:0 for usage with 25:00:00:f0:98:87:92:f3 target: ++ ++#!/bin/bash ++ ++modprobe scst ++modprobe scst_disk ++ ++echo "add_device 0:0:1:0" >/sys/kernel/scst_tgt/handlers/dev_disk/mgmt ++ ++modprobe qla2x00tgt ++ ++echo "add 0:0:1:0 0" >/sys/kernel/scst_tgt/targets/qla2x00t/25:00:00:f0:98:87:92:f3/luns/mgmt ++echo 1 >/sys/kernel/scst_tgt/targets/qla2x00t/25:00:00:f0:98:87:92:f3/enabled ++ ++Below is an advanced sample script, which configures more virtual ++devices of various types, including virtual CDROM. In this script ++initiator 25:00:00:f0:99:87:94:a3 will see disk1 and disk2 devices, all ++other initiators will see read only blockio, nullio and cdrom devices. ++ ++#!/bin/bash ++ ++modprobe scst ++modprobe scst_vdisk ++ ++echo "add_device disk1 filename=/disk1; nv_cache=1" >/sys/kernel/scst_tgt/handlers/vdisk_fileio/mgmt ++echo "add_device disk2 filename=/disk2; blocksize=4096; nv_cache=1" >/sys/kernel/scst_tgt/handlers/vdisk_fileio/mgmt ++echo "add_device blockio filename=/dev/sda5" >/sys/kernel/scst_tgt/handlers/vdisk_blockio/mgmt ++echo "add_device nullio" >/sys/kernel/scst_tgt/handlers/vdisk_nullio/mgmt ++echo "add_device cdrom" >/sys/kernel/scst_tgt/handlers/vcdrom/mgmt ++ ++modprobe qla2x00tgt ++ ++echo "add blockio 0 read_only=1" >/sys/kernel/scst_tgt/targets/qla2x00t/25:00:00:f0:98:87:92:f3/luns/mgmt ++echo "add nullio 1" >/sys/kernel/scst_tgt/targets/qla2x00t/25:00:00:f0:98:87:92:f3/luns/mgmt ++echo "add cdrom 2" >/sys/kernel/scst_tgt/targets/qla2x00t/25:00:00:f0:98:87:92:f3/luns/mgmt ++ ++echo "create 25:00:00:f0:99:87:94:a3" >/sys/kernel/scst_tgt/targets/qla2x00t/25:00:00:f0:98:87:92:f3/ini_groups/mgmt ++echo "add disk1 0" >/sys/kernel/scst_tgt/targets/qla2x00t/25:00:00:f0:98:87:92:f3/ini_groups/25:00:00:f0:99:87:94:a3/luns/mgmt ++echo "add disk2 1" >/sys/kernel/scst_tgt/targets/qla2x00t/25:00:00:f0:98:87:92:f3/ini_groups/25:00:00:f0:99:87:94:a3/luns/mgmt ++echo "add 25:00:00:f0:99:87:94:a3" >/sys/kernel/scst_tgt/targets/qla2x00t/25:00:00:f0:98:87:92:f3/ini_groups/25:00:00:f0:99:87:94:a3/initiators/mgmt ++ ++echo 1 >/sys/kernel/scst_tgt/targets/qla2x00t/25:00:00:f0:98:87:92:f3/enabled ++ ++The resulting overall SCST sysfs hierarchy with initiator ++25:00:00:f0:99:87:94:a3 connected will look like: ++ ++/sys/kernel/scst_tgt ++|-- devices ++| |-- blockio ++| | |-- blocksize ++| | |-- exported ++| | | `-- export0 -> ../../../targets/qla2x00t/25:00:00:f0:98:87:92:f3/luns/0 ++| | |-- filename ++| | |-- handler -> ../../handlers/vdisk_blockio ++| | |-- nv_cache ++| | |-- read_only ++| | |-- removable ++| | |-- resync_size ++| | |-- size_mb ++| | |-- t10_dev_id ++| | |-- threads_num ++| | |-- threads_pool_type ++| | |-- type ++| | `-- usn ++| |-- cdrom ++| | |-- exported ++| | | `-- export0 -> ../../../targets/qla2x00t/25:00:00:f0:98:87:92:f3/luns/2 ++| | |-- filename ++| | |-- handler -> ../../handlers/vcdrom ++| | |-- size_mb ++| | |-- t10_dev_id ++| | |-- threads_num ++| | |-- threads_pool_type ++| | |-- type ++| | `-- usn ++| |-- disk1 ++| | |-- blocksize ++| | |-- exported ++| | | `-- export0 -> ../../../targets/qla2x00t/25:00:00:f0:98:87:92:f3/ini_groups/25:00:00:f0:99:87:94:a3/luns/0 ++| | |-- filename ++| | |-- handler -> ../../handlers/vdisk_fileio ++| | |-- nv_cache ++| | |-- o_direct ++| | |-- read_only ++| | |-- removable ++| | |-- resync_size ++| | |-- size_mb ++| | |-- t10_dev_id ++| | |-- threads_num ++| | |-- threads_pool_type ++| | |-- type ++| | |-- usn ++| | `-- write_through ++| |-- disk2 ++| | |-- blocksize ++| | |-- exported ++| | | `-- export0 -> ../../../targets/qla2x00t/25:00:00:f0:98:87:92:f3/ini_groups/25:00:00:f0:99:87:94:a3/luns/1 ++| | |-- filename ++| | |-- handler -> ../../handlers/vdisk_fileio ++| | |-- nv_cache ++| | |-- o_direct ++| | |-- read_only ++| | |-- removable ++| | |-- resync_size ++| | |-- size_mb ++| | |-- t10_dev_id ++| | |-- threads_num ++| | |-- threads_pool_type ++| | |-- type ++| | |-- usn ++| | `-- write_through ++| `-- nullio ++| |-- blocksize ++| |-- exported ++| | `-- export0 -> ../../../targets/qla2x00t/25:00:00:f0:98:87:92:f3/luns/1 ++| |-- handler -> ../../handlers/vdisk_nullio ++| |-- read_only ++| |-- removable ++| |-- size_mb ++| |-- t10_dev_id ++| |-- threads_num ++| |-- threads_pool_type ++| |-- type ++| `-- usn ++|-- handlers ++| |-- vcdrom ++| | |-- cdrom -> ../../devices/cdrom ++| | |-- mgmt ++| | |-- trace_level ++| | `-- type ++| |-- vdisk_blockio ++| | |-- blockio -> ../../devices/blockio ++| | |-- mgmt ++| | |-- trace_level ++| | `-- type ++| |-- vdisk_fileio ++| | |-- disk1 -> ../../devices/disk1 ++| | |-- disk2 -> ../../devices/disk2 ++| | |-- mgmt ++| | |-- trace_level ++| | `-- type ++| `-- vdisk_nullio ++| |-- mgmt ++| |-- nullio -> ../../devices/nullio ++| |-- trace_level ++| `-- type ++|-- sgv ++| |-- global_stats ++| |-- sgv ++| | `-- stats ++| |-- sgv-clust ++| | `-- stats ++| `-- sgv-dma ++| `-- stats ++|-- targets ++| `-- qla2x00t ++| |-- 25:00:00:f0:98:87:92:f3 ++| | |-- enabled ++| | |-- explicit_confirmation ++| | |-- host -> ../../../../../class/scsi_host/host4 ++| | |-- ini_groups ++| | | |-- 25:00:00:f0:99:87:94:a3 ++| | | | |-- initiators ++| | | | | |-- 25:00:00:f0:99:87:94:a3 ++| | | | | `-- mgmt ++| | | | `-- luns ++| | | | |-- 0 ++| | | | | |-- device -> ../../../../../../../devices/disk1 ++| | | | | `-- read_only ++| | | | |-- 1 ++| | | | | |-- device -> ../../../../../../../devices/disk2 ++| | | | | `-- read_only ++| | | | `-- mgmt ++| | | `-- mgmt ++| | |-- luns ++| | | |-- 0 ++| | | | |-- device -> ../../../../../devices/blockio ++| | | | `-- read_only ++| | | |-- 1 ++| | | | |-- device -> ../../../../../devices/nullio ++| | | | `-- read_only ++| | | |-- 2 ++| | | | |-- device -> ../../../../../devices/cdrom ++| | | | `-- read_only ++| | | `-- mgmt ++| | |-- rel_tgt_id ++| | |-- hw_target ++| | `-- sessions ++| | `-- 25:00:00:f0:99:87:94:a3 ++| | |-- active_commands ++| | |-- commands ++| | |-- initiator_name ++| | `-- luns -> ../../ini_groups/25:00:00:f0:99:87:94:a3/luns ++| |-- trace_level ++| |-- version ++| `-- mgmt ++|-- threads ++|-- trace_level ++`-- version ++ ++ ++Performance advices ++------------------- ++ ++1. If you are going to use your target in an VM environment, for ++instance as a shared storage with VMware, make sure all your VMs ++connected to the target via *separate* sessions. You can check it using ++SCST proc or sysfs interface. You should use available facilities, like ++NPIV, to make separate sessions for each VM. If you miss it, you can ++greatly loose performance of parallel access to your target from ++different VMs. This isn't related to the case if your VMs are using the ++same shared storage, like with VMFS, for instance. In this case all your ++VM hosts will be connected to the target via separate sessions, which is ++enough. ++ ++2. See SCST core's README for more advices. Especially pay attention to ++have io_grouping_type option set correctly. ++ ++ ++Credits ++------- ++ ++Thanks to: ++ ++ * QLogic support for their invaluable help. ++ ++ * Nathaniel Clark <nate@misrule.us> for porting to new 2.6 kernel ++initiator driver. ++ ++ * Mark Buechler <mark.buechler@gmail.com> for the original ++WWN-based authentification, a lot of useful suggestions, bug reports and ++help in debugging. ++ ++ * Ming Zhang <mingz@ele.uri.edu> for fixes. ++ ++ * Uri Yanai <Uri.Yanai@ngsoft.com> and Dorit Halsadi ++<Dorit.Halsadi@dothill.com> for adding full NPIV support. ++ ++Vladislav Bolkhovitin <vst@vlnb.net>, http://scst.sourceforge.net +This patch adds the kernel module ib_srpt, which is a SCSI RDMA Protocol (SRP) +target implementation. This driver uses the InfiniBand stack and the SCST core. + +It is a high performance driver capable of handling 600K+ 4K random write +IOPS by a single target as well as 2.5+ GB/s sequential throughput over +a single QDR IB port. + +It was originally developed by Vu Pham (Mellanox) and has been optimized by +Bart Van Assche. + +Signed-off-by: Bart Van Assche <bvanassche@acm.org> +Cc: Vu Pham <vu@mellanox.com> +Cc: Roland Dreier <rdreier@cisco.com> +Cc: David Dillow <dillowda@ornl.gov> +diff -uprN orig/linux-3.2/Documentation/scst/README.srpt linux-3.2/Documentation/scst/README.srpt +--- orig/linux-3.2/Documentation/scst/README.srpt ++++ linux-3.2/Documentation/scst/README.srpt +@@ -0,0 +1,112 @@ ++SCSI RDMA Protocol (SRP) Target driver for Linux ++================================================= ++ ++The SRP Target driver is designed to work directly on top of the ++OpenFabrics OFED-1.x software stack (http://www.openfabrics.org) or ++the Infiniband drivers in the Linux kernel tree ++(http://www.kernel.org). The SRP target driver also interfaces with ++the generic SCSI target mid-level driver called SCST ++(http://scst.sourceforge.net). ++ ++How-to run ++----------- ++ ++A. On srp target machine ++1. Please refer to SCST's README for loading scst driver and its ++dev_handlers drivers (scst_disk, scst_vdisk block or file IO mode, nullio, ...) ++ ++Example 1: working with real back-end scsi disks ++a. modprobe scst ++b. modprobe scst_disk ++c. cat /proc/scsi_tgt/scsi_tgt ++ ++ibstor00:~ # cat /proc/scsi_tgt/scsi_tgt ++Device (host:ch:id:lun or name) Device handler ++0:0:0:0 dev_disk ++4:0:0:0 dev_disk ++5:0:0:0 dev_disk ++6:0:0:0 dev_disk ++7:0:0:0 dev_disk ++ ++Now you want to exclude the first scsi disk and expose the last 4 scsi disks as ++IB/SRP luns for I/O ++echo "add 4:0:0:0 0" >/proc/scsi_tgt/groups/Default/devices ++echo "add 5:0:0:0 1" >/proc/scsi_tgt/groups/Default/devices ++echo "add 6:0:0:0 2" >/proc/scsi_tgt/groups/Default/devices ++echo "add 7:0:0:0 3" >/proc/scsi_tgt/groups/Default/devices ++ ++Example 2: working with VDISK FILEIO mode (using md0 device and file 10G-file) ++a. modprobe scst ++b. modprobe scst_vdisk ++c. echo "open vdisk0 /dev/md0" > /proc/scsi_tgt/vdisk/vdisk ++d. echo "open vdisk1 /10G-file" > /proc/scsi_tgt/vdisk/vdisk ++e. echo "add vdisk0 0" >/proc/scsi_tgt/groups/Default/devices ++f. echo "add vdisk1 1" >/proc/scsi_tgt/groups/Default/devices ++ ++Example 3: working with VDISK BLOCKIO mode (using md0 device, sda, and cciss/c1d0) ++a. modprobe scst ++b. modprobe scst_vdisk ++c. echo "open vdisk0 /dev/md0 BLOCKIO" > /proc/scsi_tgt/vdisk/vdisk ++d. echo "open vdisk1 /dev/sda BLOCKIO" > /proc/scsi_tgt/vdisk/vdisk ++e. echo "open vdisk2 /dev/cciss/c1d0 BLOCKIO" > /proc/scsi_tgt/vdisk/vdisk ++f. echo "add vdisk0 0" >/proc/scsi_tgt/groups/Default/devices ++g. echo "add vdisk1 1" >/proc/scsi_tgt/groups/Default/devices ++h. echo "add vdisk2 2" >/proc/scsi_tgt/groups/Default/devices ++ ++2. modprobe ib_srpt ++ ++ ++B. On initiator machines you can manualy do the following steps: ++1. modprobe ib_srp ++2. ibsrpdm -c (to discover new SRP target) ++3. echo <new target info> > /sys/class/infiniband_srp/srp-mthca0-1/add_target ++4. fdisk -l (will show new discovered scsi disks) ++ ++Example: ++Assume that you use port 1 of first HCA in the system ie. mthca0 ++ ++[root@lab104 ~]# ibsrpdm -c -d /dev/infiniband/umad0 ++id_ext=0002c90200226cf4,ioc_guid=0002c90200226cf4, ++dgid=fe800000000000000002c90200226cf5,pkey=ffff,service_id=0002c90200226cf4 ++[root@lab104 ~]# echo id_ext=0002c90200226cf4,ioc_guid=0002c90200226cf4, ++dgid=fe800000000000000002c90200226cf5,pkey=ffff,service_id=0002c90200226cf4 > ++/sys/class/infiniband_srp/srp-mthca0-1/add_target ++ ++OR ++ +++ You can edit /etc/infiniband/openib.conf to load srp driver and srp HA daemon ++automatically ie. set SRP_LOAD=yes, and SRPHA_ENABLE=yes +++ To set up and use high availability feature you need dm-multipath driver ++and multipath tool +++ Please refer to OFED-1.x SRP's user manual for more in-details instructions ++on how-to enable/use HA feature ++ ++To minimize QUEUE_FULL conditions, you can apply scst_increase_max_tgt_cmds ++patch from SRPT package from http://sourceforge.net/project/showfiles.php?group_id=110471 ++ ++ ++Performance notes ++----------------- ++ ++In some cases, for instance working with SSD devices, which consume 100% ++of a single CPU load for data transfers in their internal threads, to ++maximize IOPS it can be needed to assign for those threads dedicated ++CPUs using Linux CPU affinity facilities. No IRQ processing should be ++done on those CPUs. Check that using /proc/interrupts. See taskset ++command and Documentation/IRQ-affinity.txt in your kernel's source tree ++for how to assign CPU affinity to tasks and IRQs. ++ ++The reason for that is that processing of coming commands in SIRQ context ++can be done on the same CPUs as SSD devices' threads doing data ++transfers. As the result, those threads won't receive all the CPU power ++and perform worse. ++ ++Alternatively to CPU affinity assignment, you can try to enable SRP ++target's internal thread. It will allows Linux CPU scheduler to better ++distribute load among available CPUs. To enable SRP target driver's ++internal thread you should load ib_srpt module with parameter ++"thread=1". ++ ++ ++Send questions about this driver to scst-devel@lists.sourceforge.net, CC: ++Vu Pham <vuhuong@mellanox.com> and Bart Van Assche <bvanassche@acm.org>. +diff -uprN orig/linux-3.2/drivers/scst/srpt/Kconfig linux-3.2/drivers/scst/srpt/Kconfig +--- orig/linux-3.2/drivers/scst/srpt/Kconfig ++++ linux-3.2/drivers/scst/srpt/Kconfig +@@ -0,0 +1,12 @@ ++config SCST_SRPT ++ tristate "InfiniBand SCSI RDMA Protocol target support" ++ depends on INFINIBAND && SCST ++ ---help--- ++ ++ Support for the SCSI RDMA Protocol (SRP) Target driver. The ++ SRP protocol is a protocol that allows an initiator to access ++ a block storage device on another host (target) over a network ++ that supports the RDMA protocol. Currently the RDMA protocol is ++ supported by InfiniBand and by iWarp network hardware. More ++ information about the SRP protocol can be found on the website ++ of the INCITS T10 technical committee (http://www.t10.org/). +diff -uprN orig/linux-3.2/drivers/scst/srpt/Makefile linux-3.2/drivers/scst/srpt/Makefile +--- orig/linux-3.2/drivers/scst/srpt/Makefile ++++ linux-3.2/drivers/scst/srpt/Makefile +@@ -0,0 +1,1 @@ ++obj-$(CONFIG_SCST_SRPT) += ib_srpt.o +diff -uprN orig/linux-3.2/drivers/scst/srpt/ib_dm_mad.h linux-3.2/drivers/scst/srpt/ib_dm_mad.h +--- orig/linux-3.2/drivers/scst/srpt/ib_dm_mad.h ++++ linux-3.2/drivers/scst/srpt/ib_dm_mad.h +@@ -0,0 +1,139 @@ ++/* ++ * Copyright (c) 2006 - 2009 Mellanox Technology Inc. All rights reserved. ++ * ++ * This software is available to you under a choice of one of two ++ * licenses. You may choose to be licensed under the terms of the GNU ++ * General Public License (GPL) Version 2, available from the file ++ * COPYING in the main directory of this source tree, or the ++ * OpenIB.org BSD license below: ++ * ++ * Redistribution and use in source and binary forms, with or ++ * without modification, are permitted provided that the following ++ * conditions are met: ++ * ++ * - Redistributions of source code must retain the above ++ * copyright notice, this list of conditions and the following ++ * disclaimer. ++ * ++ * - Redistributions in binary form must reproduce the above ++ * copyright notice, this list of conditions and the following ++ * disclaimer in the documentation and/or other materials ++ * provided with the distribution. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ++ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ++ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS ++ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ++ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE ++ * SOFTWARE. ++ * ++ */ ++ ++#ifndef IB_DM_MAD_H ++#define IB_DM_MAD_H ++ ++#include <linux/types.h> ++ ++#include <rdma/ib_mad.h> ++ ++enum { ++ /* ++ * See also section 13.4.7 Status Field, table 115 MAD Common Status ++ * Field Bit Values and also section 16.3.1.1 Status Field in the ++ * InfiniBand Architecture Specification. ++ */ ++ DM_MAD_STATUS_UNSUP_METHOD = 0x0008, ++ DM_MAD_STATUS_UNSUP_METHOD_ATTR = 0x000c, ++ DM_MAD_STATUS_INVALID_FIELD = 0x001c, ++ DM_MAD_STATUS_NO_IOC = 0x0100, ++ ++ /* ++ * See also the Device Management chapter, section 16.3.3 Attributes, ++ * table 279 Device Management Attributes in the InfiniBand ++ * Architecture Specification. ++ */ ++ DM_ATTR_CLASS_PORT_INFO = 0x01, ++ DM_ATTR_IOU_INFO = 0x10, ++ DM_ATTR_IOC_PROFILE = 0x11, ++ DM_ATTR_SVC_ENTRIES = 0x12 ++}; ++ ++struct ib_dm_hdr { ++ u8 reserved[28]; ++}; ++ ++/* ++ * Structure of management datagram sent by the SRP target implementation. ++ * Contains a management datagram header, reliable multi-packet transaction ++ * protocol (RMPP) header and ib_dm_hdr. Notes: ++ * - The SRP target implementation does not use RMPP or ib_dm_hdr when sending ++ * management datagrams. ++ * - The header size must be exactly 64 bytes (IB_MGMT_DEVICE_HDR), since this ++ * is the header size that is passed to ib_create_send_mad() in ib_srpt.c. ++ * - The maximum supported size for a management datagram when not using RMPP ++ * is 256 bytes -- 64 bytes header and 192 (IB_MGMT_DEVICE_DATA) bytes data. ++ */ ++struct ib_dm_mad { ++ struct ib_mad_hdr mad_hdr; ++ struct ib_rmpp_hdr rmpp_hdr; ++ struct ib_dm_hdr dm_hdr; ++ u8 data[IB_MGMT_DEVICE_DATA]; ++}; ++ ++/* ++ * IOUnitInfo as defined in section 16.3.3.3 IOUnitInfo of the InfiniBand ++ * Architecture Specification. ++ */ ++struct ib_dm_iou_info { ++ __be16 change_id; ++ u8 max_controllers; ++ u8 op_rom; ++ u8 controller_list[128]; ++}; ++ ++/* ++ * IOControllerprofile as defined in section 16.3.3.4 IOControllerProfile of ++ * the InfiniBand Architecture Specification. ++ */ ++struct ib_dm_ioc_profile { ++ __be64 guid; ++ __be32 vendor_id; ++ __be32 device_id; ++ __be16 device_version; ++ __be16 reserved1; ++ __be32 subsys_vendor_id; ++ __be32 subsys_device_id; ++ __be16 io_class; ++ __be16 io_subclass; ++ __be16 protocol; ++ __be16 protocol_version; ++ __be16 service_conn; ++ __be16 initiators_supported; ++ __be16 send_queue_depth; ++ u8 reserved2; ++ u8 rdma_read_depth; ++ __be32 send_size; ++ __be32 rdma_size; ++ u8 op_cap_mask; ++ u8 svc_cap_mask; ++ u8 num_svc_entries; ++ u8 reserved3[9]; ++ u8 id_string[64]; ++}; ++ ++struct ib_dm_svc_entry { ++ u8 name[40]; ++ __be64 id; ++}; ++ ++/* ++ * See also section 16.3.3.5 ServiceEntries in the InfiniBand Architecture ++ * Specification. See also section B.7, table B.8 in the T10 SRP r16a document. ++ */ ++struct ib_dm_svc_entries { ++ struct ib_dm_svc_entry service_entries[4]; ++}; ++ ++#endif +diff -uprN orig/linux-3.2/drivers/scst/srpt/ib_srpt.c linux-3.2/drivers/scst/srpt/ib_srpt.c +--- orig/linux-3.2/drivers/scst/srpt/ib_srpt.c ++++ linux-3.2/drivers/scst/srpt/ib_srpt.c +@@ -0,0 +1,3850 @@ ++/* ++ * Copyright (c) 2006 - 2009 Mellanox Technology Inc. All rights reserved. ++ * Copyright (C) 2008 - 2011 Bart Van Assche <bvanassche@acm.org>. ++ * Copyright (C) 2008 Vladislav Bolkhovitin <vst@vlnb.net> ++ * ++ * This software is available to you under a choice of one of two ++ * licenses. You may choose to be licensed under the terms of the GNU ++ * General Public License (GPL) Version 2, available from the file ++ * COPYING in the main directory of this source tree, or the ++ * OpenIB.org BSD license below: ++ * ++ * Redistribution and use in source and binary forms, with or ++ * without modification, are permitted provided that the following ++ * conditions are met: ++ * ++ * - Redistributions of source code must retain the above ++ * copyright notice, this list of conditions and the following ++ * disclaimer. ++ * ++ * - Redistributions in binary form must reproduce the above ++ * copyright notice, this list of conditions and the following ++ * disclaimer in the documentation and/or other materials ++ * provided with the distribution. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ++ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ++ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS ++ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ++ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE ++ * SOFTWARE. ++ * ++ */ ++ ++#include <linux/module.h> ++#include <linux/init.h> ++#include <linux/slab.h> ++#include <linux/err.h> ++#include <linux/ctype.h> ++#include <linux/kthread.h> ++#include <linux/string.h> ++#include <linux/delay.h> ++#include <asm/atomic.h> ++#include "ib_srpt.h" ++#define LOG_PREFIX "ib_srpt" /* Prefix for SCST tracing macros. */ ++#include <scst/scst_debug.h> ++ ++/* Name of this kernel module. */ ++#define DRV_NAME "ib_srpt" ++#define DRV_VERSION "2.2.1-pre" ++#define DRV_RELDATE "(not yet released)" ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++/* Flags to be used in SCST debug tracing statements. */ ++#define DEFAULT_SRPT_TRACE_FLAGS (TRACE_OUT_OF_MEM | TRACE_MINOR \ ++ | TRACE_MGMT | TRACE_SPECIAL) ++/* Name of the entry that will be created under /proc/scsi_tgt/ib_srpt. */ ++#define SRPT_PROC_TRACE_LEVEL_NAME "trace_level" ++#endif ++ ++#define SRPT_ID_STRING "SCST SRP target" ++ ++MODULE_AUTHOR("Vu Pham and Bart Van Assche"); ++MODULE_DESCRIPTION("InfiniBand SCSI RDMA Protocol target " ++ "v" DRV_VERSION " (" DRV_RELDATE ")"); ++MODULE_LICENSE("Dual BSD/GPL"); ++ ++/* ++ * Global Variables ++ */ ++ ++static u64 srpt_service_guid; ++/* List of srpt_device structures. */ ++static atomic_t srpt_device_count; ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++static unsigned long trace_flag = DEFAULT_SRPT_TRACE_FLAGS; ++module_param(trace_flag, long, 0644); ++MODULE_PARM_DESC(trace_flag, "SCST trace flags."); ++#endif ++ ++static unsigned srp_max_rdma_size = DEFAULT_MAX_RDMA_SIZE; ++module_param(srp_max_rdma_size, int, 0644); ++MODULE_PARM_DESC(srp_max_rdma_size, ++ "Maximum size of SRP RDMA transfers for new connections."); ++ ++static unsigned srp_max_req_size = DEFAULT_MAX_REQ_SIZE; ++module_param(srp_max_req_size, int, 0444); ++MODULE_PARM_DESC(srp_max_req_size, ++ "Maximum size of SRP request messages in bytes."); ++ ++static unsigned int srp_max_rsp_size = DEFAULT_MAX_RSP_SIZE; ++module_param(srp_max_rsp_size, int, S_IRUGO | S_IWUSR); ++MODULE_PARM_DESC(srp_max_rsp_size, ++ "Maximum size of SRP response messages in bytes."); ++ ++static int srpt_srq_size = DEFAULT_SRPT_SRQ_SIZE; ++module_param(srpt_srq_size, int, S_IRUGO | S_IWUSR); ++MODULE_PARM_DESC(srpt_srq_size, ++ "Shared receive queue (SRQ) size."); ++ ++static int srpt_sq_size = DEF_SRPT_SQ_SIZE; ++module_param(srpt_sq_size, int, 0444); ++MODULE_PARM_DESC(srpt_sq_size, ++ "Per-channel send queue (SQ) size."); ++ ++static bool use_port_guid_in_session_name; ++module_param(use_port_guid_in_session_name, bool, 0444); ++MODULE_PARM_DESC(use_port_guid_in_session_name, ++ "Use target port ID in the session name such that" ++ " redundant paths between multiport systems can be masked."); ++ ++static bool use_node_guid_in_target_name; ++module_param(use_node_guid_in_target_name, bool, 0444); ++MODULE_PARM_DESC(use_node_guid_in_target_name, ++ "Use target node GUIDs of HCAs as SCST target names."); ++ ++static int srpt_get_u64_x(char *buffer, struct kernel_param *kp) ++{ ++ return sprintf(buffer, "0x%016llx", *(u64 *)kp->arg); ++} ++module_param_call(srpt_service_guid, NULL, srpt_get_u64_x, &srpt_service_guid, ++ 0444); ++MODULE_PARM_DESC(srpt_service_guid, ++ "Using this value for ioc_guid, id_ext, and cm_listen_id" ++ " instead of using the node_guid of the first HCA."); ++ ++static struct ib_client srpt_client; ++static void srpt_unregister_mad_agent(struct srpt_device *sdev); ++static void srpt_unmap_sg_to_ib_sge(struct srpt_rdma_ch *ch, ++ struct srpt_send_ioctx *ioctx); ++static void srpt_drain_channel(struct ib_cm_id *cm_id); ++static void srpt_free_ch(struct scst_session *sess); ++ ++static enum rdma_ch_state srpt_set_ch_state_to_disc(struct srpt_rdma_ch *ch) ++{ ++ unsigned long flags; ++ enum rdma_ch_state prev; ++ bool changed = false; ++ ++ spin_lock_irqsave(&ch->spinlock, flags); ++ prev = ch->state; ++ switch (prev) { ++ case CH_CONNECTING: ++ case CH_LIVE: ++ ch->state = CH_DISCONNECTING; ++ wake_up_process(ch->thread); ++ changed = true; ++ break; ++ default: ++ break; ++ } ++ spin_unlock_irqrestore(&ch->spinlock, flags); ++ ++ return prev; ++} ++ ++static bool srpt_set_ch_state_to_draining(struct srpt_rdma_ch *ch) ++{ ++ unsigned long flags; ++ bool changed = false; ++ ++ spin_lock_irqsave(&ch->spinlock, flags); ++ switch (ch->state) { ++ case CH_CONNECTING: ++ case CH_LIVE: ++ case CH_DISCONNECTING: ++ ch->state = CH_DRAINING; ++ wake_up_process(ch->thread); ++ changed = true; ++ break; ++ default: ++ break; ++ } ++ spin_unlock_irqrestore(&ch->spinlock, flags); ++ ++ return changed; ++} ++ ++/** ++ * srpt_test_and_set_ch_state() - Test and set the channel state. ++ * ++ * Returns true if and only if the channel state has been set to the new state. ++ */ ++static bool srpt_test_and_set_ch_state(struct srpt_rdma_ch *ch, ++ enum rdma_ch_state old, ++ enum rdma_ch_state new) ++{ ++ unsigned long flags; ++ bool changed = false; ++ ++ spin_lock_irqsave(&ch->spinlock, flags); ++ if (ch->state == old) { ++ ch->state = new; ++ wake_up_process(ch->thread); ++ changed = true; ++ } ++ spin_unlock_irqrestore(&ch->spinlock, flags); ++ ++ return changed; ++} ++ ++/** ++ * srpt_adjust_req_lim() - Adjust ch->req_lim and ch->req_lim_delta atomically. ++ * ++ * Returns the new value of ch->req_lim. ++ */ ++static int srpt_adjust_req_lim(struct srpt_rdma_ch *ch, int req_lim_change, ++ int req_lim_delta_change) ++{ ++ int req_lim; ++ unsigned long flags; ++ ++ spin_lock_irqsave(&ch->spinlock, flags); ++ ch->req_lim += req_lim_change; ++ req_lim = ch->req_lim; ++ ch->req_lim_delta += req_lim_delta_change; ++ spin_unlock_irqrestore(&ch->spinlock, flags); ++ ++ return req_lim; ++} ++ ++/** ++ * srpt_inc_req_lim() - Increase ch->req_lim and decrease ch->req_lim_delta. ++ * ++ * Returns one more than the previous value of ch->req_lim_delta. ++ */ ++static int srpt_inc_req_lim(struct srpt_rdma_ch *ch) ++{ ++ int req_lim_delta; ++ unsigned long flags; ++ ++ spin_lock_irqsave(&ch->spinlock, flags); ++ req_lim_delta = ch->req_lim_delta + 1; ++ ch->req_lim += req_lim_delta; ++ ch->req_lim_delta = 0; ++ spin_unlock_irqrestore(&ch->spinlock, flags); ++ ++ return req_lim_delta; ++} ++ ++/** ++ * srpt_undo_inc_req_lim() - Undo the effect of srpt_inc_req_lim. ++ */ ++static int srpt_undo_inc_req_lim(struct srpt_rdma_ch *ch, int req_lim_delta) ++{ ++ return srpt_adjust_req_lim(ch, -req_lim_delta, req_lim_delta - 1); ++} ++ ++/** ++ * srpt_event_handler() - Asynchronous IB event callback function. ++ * ++ * Callback function called by the InfiniBand core when an asynchronous IB ++ * event occurs. This callback may occur in interrupt context. See also ++ * section 11.5.2, Set Asynchronous Event Handler in the InfiniBand ++ * Architecture Specification. ++ */ ++static void srpt_event_handler(struct ib_event_handler *handler, ++ struct ib_event *event) ++{ ++ struct srpt_device *sdev; ++ struct srpt_port *sport; ++ u8 port_num; ++ ++ TRACE_ENTRY(); ++ ++ sdev = ib_get_client_data(event->device, &srpt_client); ++ if (!sdev || sdev->device != event->device) ++ return; ++ ++ TRACE_DBG("ASYNC event= %d on device= %s", ++ event->event, sdev->device->name); ++ ++ switch (event->event) { ++ case IB_EVENT_PORT_ERR: ++ port_num = event->element.port_num - 1; ++ if (port_num < sdev->device->phys_port_cnt) { ++ sport = &sdev->port[port_num]; ++ sport->lid = 0; ++ sport->sm_lid = 0; ++ } else { ++ WARN(true, "event %d: port_num %d out of range 1..%d\n", ++ event->event, port_num + 1, ++ sdev->device->phys_port_cnt); ++ } ++ break; ++ case IB_EVENT_PORT_ACTIVE: ++ case IB_EVENT_LID_CHANGE: ++ case IB_EVENT_PKEY_CHANGE: ++ case IB_EVENT_SM_CHANGE: ++ case IB_EVENT_CLIENT_REREGISTER: ++ /* Refresh port data asynchronously. */ ++ port_num = event->element.port_num - 1; ++ if (port_num < sdev->device->phys_port_cnt) { ++ sport = &sdev->port[port_num]; ++ if (!sport->lid && !sport->sm_lid) ++ schedule_work(&sport->work); ++ } else { ++ WARN(true, "event %d: port_num %d out of range 1..%d\n", ++ event->event, port_num + 1, ++ sdev->device->phys_port_cnt); ++ } ++ break; ++ default: ++ PRINT_ERROR("received unrecognized IB event %d", event->event); ++ break; ++ } ++ ++ TRACE_EXIT(); ++} ++ ++/** ++ * srpt_srq_event() - IB SRQ event callback function. ++ */ ++static void srpt_srq_event(struct ib_event *event, void *ctx) ++{ ++ TRACE_DBG("SRQ event %d", event->event); ++} ++ ++static const char *get_ch_state_name(enum rdma_ch_state s) ++{ ++ switch (s) { ++ case CH_CONNECTING: ++ return "connecting"; ++ case CH_LIVE: ++ return "live"; ++ case CH_DISCONNECTING: ++ return "disconnecting"; ++ case CH_DRAINING: ++ return "draining"; ++ case CH_FREEING: ++ return "freeing"; ++ } ++ return "???"; ++} ++ ++/** ++ * srpt_qp_event() - IB QP event callback function. ++ */ ++static void srpt_qp_event(struct ib_event *event, struct srpt_rdma_ch *ch) ++{ ++ TRACE_DBG("QP event %d on cm_id=%p sess_name=%s state=%s", ++ event->event, ch->cm_id, ch->sess_name, ++ get_ch_state_name(ch->state)); ++ ++ switch (event->event) { ++ case IB_EVENT_COMM_EST: ++ ib_cm_notify(ch->cm_id, event->event); ++ break; ++ case IB_EVENT_QP_LAST_WQE_REACHED: ++ TRACE_DBG("%s, state %s: received Last WQE event.", ++ ch->sess_name, get_ch_state_name(ch->state)); ++ ch->last_wqe_received = true; ++ BUG_ON(!ch->thread); ++ wake_up_process(ch->thread); ++ break; ++ default: ++ PRINT_ERROR("received unrecognized IB QP event %d", ++ event->event); ++ break; ++ } ++} ++ ++/** ++ * srpt_set_ioc() - Helper function for initializing an IOUnitInfo structure. ++ * ++ * @slot: one-based slot number. ++ * @value: four-bit value. ++ * ++ * Copies the lowest four bits of value in element slot of the array of four ++ * bit elements called c_list (controller list). The index slot is one-based. ++ */ ++static void srpt_set_ioc(u8 *c_list, u32 slot, u8 value) ++{ ++ u16 id; ++ u8 tmp; ++ ++ id = (slot - 1) / 2; ++ if (slot & 0x1) { ++ tmp = c_list[id] & 0xf; ++ c_list[id] = (value << 4) | tmp; ++ } else { ++ tmp = c_list[id] & 0xf0; ++ c_list[id] = (value & 0xf) | tmp; ++ } ++} ++ ++/** ++ * srpt_get_class_port_info() - Copy ClassPortInfo to a management datagram. ++ * ++ * See also section 16.3.3.1 ClassPortInfo in the InfiniBand Architecture ++ * Specification. ++ */ ++static void srpt_get_class_port_info(struct ib_dm_mad *mad) ++{ ++ struct ib_class_port_info *cif; ++ ++ cif = (struct ib_class_port_info *)mad->data; ++ memset(cif, 0, sizeof *cif); ++ cif->base_version = 1; ++ cif->class_version = 1; ++ cif->resp_time_value = 20; ++ ++ mad->mad_hdr.status = 0; ++} ++ ++/** ++ * srpt_get_iou() - Write IOUnitInfo to a management datagram. ++ * ++ * See also section 16.3.3.3 IOUnitInfo in the InfiniBand Architecture ++ * Specification. See also section B.7, table B.6 in the SRP r16a document. ++ */ ++static void srpt_get_iou(struct ib_dm_mad *mad) ++{ ++ struct ib_dm_iou_info *ioui; ++ u8 slot; ++ int i; ++ ++ ioui = (struct ib_dm_iou_info *)mad->data; ++ ioui->change_id = cpu_to_be16(1); ++ ioui->max_controllers = 16; ++ ++ /* set present for slot 1 and empty for the rest */ ++ srpt_set_ioc(ioui->controller_list, 1, 1); ++ for (i = 1, slot = 2; i < 16; i++, slot++) ++ srpt_set_ioc(ioui->controller_list, slot, 0); ++ ++ mad->mad_hdr.status = 0; ++} ++ ++/** ++ * srpt_get_ioc() - Write IOControllerprofile to a management datagram. ++ * ++ * See also section 16.3.3.4 IOControllerProfile in the InfiniBand ++ * Architecture Specification. See also section B.7, table B.7 in the SRP ++ * r16a document. ++ */ ++static void srpt_get_ioc(struct srpt_device *sdev, u32 slot, ++ struct ib_dm_mad *mad) ++{ ++ struct ib_dm_ioc_profile *iocp; ++ ++ iocp = (struct ib_dm_ioc_profile *)mad->data; ++ ++ if (!slot || slot > 16) { ++ mad->mad_hdr.status = cpu_to_be16(DM_MAD_STATUS_INVALID_FIELD); ++ return; ++ } ++ ++ if (slot > 2) { ++ mad->mad_hdr.status = cpu_to_be16(DM_MAD_STATUS_NO_IOC); ++ return; ++ } ++ ++ memset(iocp, 0, sizeof *iocp); ++ strcpy(iocp->id_string, SRPT_ID_STRING); ++ iocp->guid = cpu_to_be64(srpt_service_guid); ++ iocp->vendor_id = cpu_to_be32(sdev->dev_attr.vendor_id); ++ iocp->device_id = cpu_to_be32(sdev->dev_attr.vendor_part_id); ++ iocp->device_version = cpu_to_be16(sdev->dev_attr.hw_ver); ++ iocp->subsys_vendor_id = cpu_to_be32(sdev->dev_attr.vendor_id); ++ iocp->subsys_device_id = 0x0; ++ iocp->io_class = cpu_to_be16(SRP_REV16A_IB_IO_CLASS); ++ iocp->io_subclass = cpu_to_be16(SRP_IO_SUBCLASS); ++ iocp->protocol = cpu_to_be16(SRP_PROTOCOL); ++ iocp->protocol_version = cpu_to_be16(SRP_PROTOCOL_VERSION); ++ iocp->send_queue_depth = cpu_to_be16(sdev->srq_size); ++ iocp->rdma_read_depth = 4; ++ iocp->send_size = cpu_to_be32(srp_max_req_size); ++ iocp->rdma_size = cpu_to_be32(min(max(srp_max_rdma_size, 256U), ++ 1U << 24)); ++ iocp->num_svc_entries = 1; ++ iocp->op_cap_mask = SRP_SEND_TO_IOC | SRP_SEND_FROM_IOC | ++ SRP_RDMA_READ_FROM_IOC | SRP_RDMA_WRITE_FROM_IOC; ++ ++ mad->mad_hdr.status = 0; ++} ++ ++/** ++ * srpt_get_svc_entries() - Write ServiceEntries to a management datagram. ++ * ++ * See also section 16.3.3.5 ServiceEntries in the InfiniBand Architecture ++ * Specification. See also section B.7, table B.8 in the SRP r16a document. ++ */ ++static void srpt_get_svc_entries(u64 ioc_guid, ++ u16 slot, u8 hi, u8 lo, struct ib_dm_mad *mad) ++{ ++ struct ib_dm_svc_entries *svc_entries; ++ ++ WARN_ON(!ioc_guid); ++ ++ if (!slot || slot > 16) { ++ mad->mad_hdr.status = cpu_to_be16(DM_MAD_STATUS_INVALID_FIELD); ++ return; ++ } ++ ++ if (slot > 2 || lo > hi || hi > 1) { ++ mad->mad_hdr.status = cpu_to_be16(DM_MAD_STATUS_NO_IOC); ++ return; ++ } ++ ++ svc_entries = (struct ib_dm_svc_entries *)mad->data; ++ memset(svc_entries, 0, sizeof *svc_entries); ++ svc_entries->service_entries[0].id = cpu_to_be64(ioc_guid); ++ snprintf(svc_entries->service_entries[0].name, ++ sizeof(svc_entries->service_entries[0].name), ++ "%s%016llx", ++ SRP_SERVICE_NAME_PREFIX, ++ ioc_guid); ++ ++ mad->mad_hdr.status = 0; ++} ++ ++/** ++ * srpt_mgmt_method_get() - Process a received management datagram. ++ * @sp: source port through which the MAD has been received. ++ * @rq_mad: received MAD. ++ * @rsp_mad: response MAD. ++ */ ++static void srpt_mgmt_method_get(struct srpt_port *sp, struct ib_mad *rq_mad, ++ struct ib_dm_mad *rsp_mad) ++{ ++ u16 attr_id; ++ u32 slot; ++ u8 hi, lo; ++ ++ attr_id = be16_to_cpu(rq_mad->mad_hdr.attr_id); ++ switch (attr_id) { ++ case DM_ATTR_CLASS_PORT_INFO: ++ srpt_get_class_port_info(rsp_mad); ++ break; ++ case DM_ATTR_IOU_INFO: ++ srpt_get_iou(rsp_mad); ++ break; ++ case DM_ATTR_IOC_PROFILE: ++ slot = be32_to_cpu(rq_mad->mad_hdr.attr_mod); ++ srpt_get_ioc(sp->sdev, slot, rsp_mad); ++ break; ++ case DM_ATTR_SVC_ENTRIES: ++ slot = be32_to_cpu(rq_mad->mad_hdr.attr_mod); ++ hi = (u8) ((slot >> 8) & 0xff); ++ lo = (u8) (slot & 0xff); ++ slot = (u16) ((slot >> 16) & 0xffff); ++ srpt_get_svc_entries(srpt_service_guid, ++ slot, hi, lo, rsp_mad); ++ break; ++ default: ++ rsp_mad->mad_hdr.status = ++ cpu_to_be16(DM_MAD_STATUS_UNSUP_METHOD_ATTR); ++ break; ++ } ++} ++ ++/** ++ * srpt_mad_send_handler() - Post MAD-send callback function. ++ */ ++static void srpt_mad_send_handler(struct ib_mad_agent *mad_agent, ++ struct ib_mad_send_wc *mad_wc) ++{ ++ ib_destroy_ah(mad_wc->send_buf->ah); ++ ib_free_send_mad(mad_wc->send_buf); ++} ++ ++/** ++ * srpt_mad_recv_handler() - MAD reception callback function. ++ */ ++static void srpt_mad_recv_handler(struct ib_mad_agent *mad_agent, ++ struct ib_mad_recv_wc *mad_wc) ++{ ++ struct srpt_port *sport = (struct srpt_port *)mad_agent->context; ++ struct ib_ah *ah; ++ struct ib_mad_send_buf *rsp; ++ struct ib_dm_mad *dm_mad; ++ ++ if (!mad_wc || !mad_wc->recv_buf.mad) ++ return; ++ ++ ah = ib_create_ah_from_wc(mad_agent->qp->pd, mad_wc->wc, ++ mad_wc->recv_buf.grh, mad_agent->port_num); ++ if (IS_ERR(ah)) ++ goto err; ++ ++ BUILD_BUG_ON(offsetof(struct ib_dm_mad, data) != IB_MGMT_DEVICE_HDR); ++ ++ rsp = ib_create_send_mad(mad_agent, mad_wc->wc->src_qp, ++ mad_wc->wc->pkey_index, 0, ++ IB_MGMT_DEVICE_HDR, IB_MGMT_DEVICE_DATA, ++ GFP_KERNEL); ++ if (IS_ERR(rsp)) ++ goto err_rsp; ++ ++ rsp->ah = ah; ++ ++ dm_mad = rsp->mad; ++ memcpy(dm_mad, mad_wc->recv_buf.mad, sizeof *dm_mad); ++ dm_mad->mad_hdr.method = IB_MGMT_METHOD_GET_RESP; ++ dm_mad->mad_hdr.status = 0; ++ ++ switch (mad_wc->recv_buf.mad->mad_hdr.method) { ++ case IB_MGMT_METHOD_GET: ++ srpt_mgmt_method_get(sport, mad_wc->recv_buf.mad, dm_mad); ++ break; ++ case IB_MGMT_METHOD_SET: ++ dm_mad->mad_hdr.status = ++ cpu_to_be16(DM_MAD_STATUS_UNSUP_METHOD_ATTR); ++ break; ++ default: ++ dm_mad->mad_hdr.status = ++ cpu_to_be16(DM_MAD_STATUS_UNSUP_METHOD); ++ break; ++ } ++ ++ if (!ib_post_send_mad(rsp, NULL)) { ++ ib_free_recv_mad(mad_wc); ++ /* will destroy_ah & free_send_mad in send completion */ ++ return; ++ } ++ ++ ib_free_send_mad(rsp); ++ ++err_rsp: ++ ib_destroy_ah(ah); ++err: ++ ib_free_recv_mad(mad_wc); ++} ++ ++/** ++ * srpt_refresh_port() - Configure a HCA port. ++ * ++ * Enable InfiniBand management datagram processing, update the cached sm_lid, ++ * lid and gid values, and register a callback function for processing MADs ++ * on the specified port. ++ * ++ * Note: It is safe to call this function more than once for the same port. ++ */ ++static int srpt_refresh_port(struct srpt_port *sport) ++{ ++ struct ib_mad_reg_req reg_req; ++ struct ib_port_modify port_modify; ++ struct ib_port_attr port_attr; ++ int ret; ++ ++ TRACE_ENTRY(); ++ ++ memset(&port_modify, 0, sizeof port_modify); ++ port_modify.set_port_cap_mask = IB_PORT_DEVICE_MGMT_SUP; ++ port_modify.clr_port_cap_mask = 0; ++ ++ ret = ib_modify_port(sport->sdev->device, sport->port, 0, &port_modify); ++ if (ret) ++ goto err_mod_port; ++ ++ ret = ib_query_port(sport->sdev->device, sport->port, &port_attr); ++ if (ret) ++ goto err_query_port; ++ ++ sport->sm_lid = port_attr.sm_lid; ++ sport->lid = port_attr.lid; ++ ++ ret = ib_query_gid(sport->sdev->device, sport->port, 0, &sport->gid); ++ if (ret) ++ goto err_query_port; ++ ++ if (!sport->mad_agent) { ++ memset(®_req, 0, sizeof reg_req); ++ reg_req.mgmt_class = IB_MGMT_CLASS_DEVICE_MGMT; ++ reg_req.mgmt_class_version = IB_MGMT_BASE_VERSION; ++ set_bit(IB_MGMT_METHOD_GET, reg_req.method_mask); ++ set_bit(IB_MGMT_METHOD_SET, reg_req.method_mask); ++ ++ sport->mad_agent = ib_register_mad_agent(sport->sdev->device, ++ sport->port, ++ IB_QPT_GSI, ++ ®_req, 0, ++ srpt_mad_send_handler, ++ srpt_mad_recv_handler, ++ sport); ++ if (IS_ERR(sport->mad_agent)) { ++ ret = PTR_ERR(sport->mad_agent); ++ sport->mad_agent = NULL; ++ goto err_query_port; ++ } ++ } ++ ++ TRACE_EXIT_RES(0); ++ ++ return 0; ++ ++err_query_port: ++ port_modify.set_port_cap_mask = 0; ++ port_modify.clr_port_cap_mask = IB_PORT_DEVICE_MGMT_SUP; ++ ib_modify_port(sport->sdev->device, sport->port, 0, &port_modify); ++ ++err_mod_port: ++ TRACE_EXIT_RES(ret); ++ ++ return ret; ++} ++ ++/** ++ * srpt_unregister_mad_agent() - Unregister MAD callback functions. ++ * ++ * Note: It is safe to call this function more than once for the same device. ++ */ ++static void srpt_unregister_mad_agent(struct srpt_device *sdev) ++{ ++ struct ib_port_modify port_modify = { ++ .clr_port_cap_mask = IB_PORT_DEVICE_MGMT_SUP, ++ }; ++ struct srpt_port *sport; ++ int i; ++ ++ for (i = 1; i <= sdev->device->phys_port_cnt; i++) { ++ sport = &sdev->port[i - 1]; ++ WARN_ON(sport->port != i); ++ if (ib_modify_port(sdev->device, i, 0, &port_modify) < 0) ++ PRINT_ERROR("%s", "disabling MAD processing failed."); ++ if (sport->mad_agent) { ++ ib_unregister_mad_agent(sport->mad_agent); ++ sport->mad_agent = NULL; ++ } ++ } ++} ++ ++/** ++ * srpt_alloc_ioctx() - Allocate an SRPT I/O context structure. ++ */ ++static struct srpt_ioctx *srpt_alloc_ioctx(struct srpt_device *sdev, ++ int ioctx_size, int dma_size, ++ enum dma_data_direction dir) ++{ ++ struct srpt_ioctx *ioctx; ++ ++ ioctx = kmalloc(ioctx_size, GFP_KERNEL); ++ if (!ioctx) ++ goto err; ++ ++ ioctx->buf = kmalloc(dma_size, GFP_KERNEL); ++ if (!ioctx->buf) ++ goto err_free_ioctx; ++ ++ ioctx->dma = ib_dma_map_single(sdev->device, ioctx->buf, dma_size, dir); ++ if (ib_dma_mapping_error(sdev->device, ioctx->dma)) ++ goto err_free_buf; ++ ++ return ioctx; ++ ++err_free_buf: ++ kfree(ioctx->buf); ++err_free_ioctx: ++ kfree(ioctx); ++err: ++ return NULL; ++} ++ ++/** ++ * srpt_free_ioctx() - Free an SRPT I/O context structure. ++ */ ++static void srpt_free_ioctx(struct srpt_device *sdev, struct srpt_ioctx *ioctx, ++ int dma_size, enum dma_data_direction dir) ++{ ++ if (!ioctx) ++ return; ++ ++ ib_dma_unmap_single(sdev->device, ioctx->dma, dma_size, dir); ++ kfree(ioctx->buf); ++ kfree(ioctx); ++} ++ ++/** ++ * srpt_alloc_ioctx_ring() - Allocate a ring of SRPT I/O context structures. ++ * @sdev: Device to allocate the I/O context ring for. ++ * @ring_size: Number of elements in the I/O context ring. ++ * @ioctx_size: I/O context size. ++ * @dma_size: DMA buffer size. ++ * @dir: DMA data direction. ++ */ ++static struct srpt_ioctx **srpt_alloc_ioctx_ring(struct srpt_device *sdev, ++ int ring_size, int ioctx_size, ++ int dma_size, enum dma_data_direction dir) ++{ ++ struct srpt_ioctx **ring; ++ int i; ++ ++ TRACE_ENTRY(); ++ ++ WARN_ON(ioctx_size != sizeof(struct srpt_recv_ioctx) && ++ ioctx_size != sizeof(struct srpt_send_ioctx)); ++ ++ ring = kmalloc(ring_size * sizeof(ring[0]), GFP_KERNEL); ++ if (!ring) ++ goto out; ++ for (i = 0; i < ring_size; ++i) { ++ ring[i] = srpt_alloc_ioctx(sdev, ioctx_size, dma_size, dir); ++ if (!ring[i]) ++ goto err; ++ ring[i]->index = i; ++ } ++ goto out; ++ ++err: ++ while (--i >= 0) ++ srpt_free_ioctx(sdev, ring[i], dma_size, dir); ++ kfree(ring); ++ ring = NULL; ++out: ++ TRACE_EXIT_HRES(ring); ++ return ring; ++} ++ ++/** ++ * srpt_free_ioctx_ring() - Free the ring of SRPT I/O context structures. ++ */ ++static void srpt_free_ioctx_ring(struct srpt_ioctx **ioctx_ring, ++ struct srpt_device *sdev, int ring_size, ++ int dma_size, enum dma_data_direction dir) ++{ ++ int i; ++ ++ for (i = 0; i < ring_size; ++i) ++ srpt_free_ioctx(sdev, ioctx_ring[i], dma_size, dir); ++ kfree(ioctx_ring); ++} ++ ++/** ++ * srpt_set_cmd_state() - Set the state of a SCSI command. ++ * @new: New state. ++ * ++ * Does not modify the state of aborted commands. Returns the previous command ++ * state. ++ */ ++static enum srpt_command_state srpt_set_cmd_state(struct srpt_send_ioctx *ioctx, ++ enum srpt_command_state new) ++{ ++ enum srpt_command_state previous; ++ ++ BUG_ON(!ioctx); ++ ++ spin_lock(&ioctx->spinlock); ++ previous = ioctx->state; ++ if (previous != SRPT_STATE_DONE) ++ ioctx->state = new; ++ spin_unlock(&ioctx->spinlock); ++ ++ return previous; ++} ++ ++/** ++ * srpt_test_and_set_cmd_state() - Test and set the state of a command. ++ * ++ * Returns true if and only if the previous command state was equal to 'old'. ++ */ ++static bool srpt_test_and_set_cmd_state(struct srpt_send_ioctx *ioctx, ++ enum srpt_command_state old, ++ enum srpt_command_state new) ++{ ++ enum srpt_command_state previous; ++ ++ WARN_ON(!ioctx); ++ WARN_ON(old == SRPT_STATE_DONE); ++ WARN_ON(new == SRPT_STATE_NEW); ++ ++ spin_lock(&ioctx->spinlock); ++ previous = ioctx->state; ++ if (previous == old) ++ ioctx->state = new; ++ spin_unlock(&ioctx->spinlock); ++ ++ return previous == old; ++} ++ ++/** ++ * srpt_post_recv() - Post an IB receive request. ++ */ ++static int srpt_post_recv(struct srpt_device *sdev, ++ struct srpt_recv_ioctx *ioctx) ++{ ++ struct ib_sge list; ++ struct ib_recv_wr wr, *bad_wr; ++ ++ BUG_ON(!sdev); ++ wr.wr_id = encode_wr_id(SRPT_RECV, ioctx->ioctx.index); ++ ++ list.addr = ioctx->ioctx.dma; ++ list.length = srp_max_req_size; ++ list.lkey = sdev->mr->lkey; ++ ++ wr.next = NULL; ++ wr.sg_list = &list; ++ wr.num_sge = 1; ++ ++ return ib_post_srq_recv(sdev->srq, &wr, &bad_wr); ++} ++ ++static int srpt_adjust_srq_wr_avail(struct srpt_rdma_ch *ch, int delta) ++{ ++ int res; ++ unsigned long flags; ++ ++ spin_lock_irqsave(&ch->spinlock, flags); ++ ch->sq_wr_avail += delta; ++ res = ch->sq_wr_avail; ++ spin_unlock_irqrestore(&ch->spinlock, flags); ++ ++ return res; ++} ++ ++/** ++ * srpt_post_send() - Post an IB send request. ++ * ++ * Returns zero upon success and a non-zero value upon failure. ++ */ ++static int srpt_post_send(struct srpt_rdma_ch *ch, ++ struct srpt_send_ioctx *ioctx, int len) ++{ ++ struct ib_sge list; ++ struct ib_send_wr wr, *bad_wr; ++ struct srpt_device *sdev = ch->sport->sdev; ++ int ret; ++ ++ ret = -ENOMEM; ++ if (srpt_adjust_srq_wr_avail(ch, -1) < 0) { ++ PRINT_WARNING("%s", "IB send queue full (needed 1)"); ++ goto out; ++ } ++ ++ ib_dma_sync_single_for_device(sdev->device, ioctx->ioctx.dma, len, ++ DMA_TO_DEVICE); ++ ++ list.addr = ioctx->ioctx.dma; ++ list.length = len; ++ list.lkey = sdev->mr->lkey; ++ ++ wr.next = NULL; ++ wr.wr_id = encode_wr_id(SRPT_SEND, ioctx->ioctx.index); ++ wr.sg_list = &list; ++ wr.num_sge = 1; ++ wr.opcode = IB_WR_SEND; ++ wr.send_flags = IB_SEND_SIGNALED; ++ ++ ret = ib_post_send(ch->qp, &wr, &bad_wr); ++ ++out: ++ if (ret < 0) ++ srpt_adjust_srq_wr_avail(ch, 1); ++ return ret; ++} ++ ++/** ++ * srpt_get_desc_tbl() - Parse the data descriptors of an SRP_CMD request. ++ * @ioctx: Pointer to the I/O context associated with the request. ++ * @srp_cmd: Pointer to the SRP_CMD request data. ++ * @dir: Pointer to the variable to which the transfer direction will be ++ * written. ++ * @data_len: Pointer to the variable to which the total data length of all ++ * descriptors in the SRP_CMD request will be written. ++ * ++ * This function initializes ioctx->nrbuf and ioctx->r_bufs. ++ * ++ * Returns -EINVAL when the SRP_CMD request contains inconsistent descriptors; ++ * -ENOMEM when memory allocation fails and zero upon success. ++ */ ++static int srpt_get_desc_tbl(struct srpt_send_ioctx *ioctx, ++ struct srp_cmd *srp_cmd, ++ scst_data_direction *dir, u64 *data_len) ++{ ++ struct srp_indirect_buf *idb; ++ struct srp_direct_buf *db; ++ unsigned add_cdb_offset; ++ int ret; ++ ++ /* ++ * The pointer computations below will only be compiled correctly ++ * if srp_cmd::add_data is declared as s8*, u8*, s8[] or u8[], so check ++ * whether srp_cmd::add_data has been declared as a byte pointer. ++ */ ++ BUILD_BUG_ON(!__same_type(srp_cmd->add_data[0], (s8)0) ++ && !__same_type(srp_cmd->add_data[0], (u8)0)); ++ ++ BUG_ON(!dir); ++ BUG_ON(!data_len); ++ ++ ret = 0; ++ *data_len = 0; ++ ++ /* ++ * The lower four bits of the buffer format field contain the DATA-IN ++ * buffer descriptor format, and the highest four bits contain the ++ * DATA-OUT buffer descriptor format. ++ */ ++ *dir = SCST_DATA_NONE; ++ if (srp_cmd->buf_fmt & 0xf) ++ /* DATA-IN: transfer data from target to initiator (read). */ ++ *dir = SCST_DATA_READ; ++ else if (srp_cmd->buf_fmt >> 4) ++ /* DATA-OUT: transfer data from initiator to target (write). */ ++ *dir = SCST_DATA_WRITE; ++ ++ /* ++ * According to the SRP spec, the lower two bits of the 'ADDITIONAL ++ * CDB LENGTH' field are reserved and the size in bytes of this field ++ * is four times the value specified in bits 3..7. Hence the "& ~3". ++ */ ++ add_cdb_offset = srp_cmd->add_cdb_len & ~3; ++ if (((srp_cmd->buf_fmt & 0xf) == SRP_DATA_DESC_DIRECT) || ++ ((srp_cmd->buf_fmt >> 4) == SRP_DATA_DESC_DIRECT)) { ++ ioctx->n_rbuf = 1; ++ ioctx->rbufs = &ioctx->single_rbuf; ++ ++ db = (struct srp_direct_buf *)(srp_cmd->add_data ++ + add_cdb_offset); ++ memcpy(ioctx->rbufs, db, sizeof *db); ++ *data_len = be32_to_cpu(db->len); ++ } else if (((srp_cmd->buf_fmt & 0xf) == SRP_DATA_DESC_INDIRECT) || ++ ((srp_cmd->buf_fmt >> 4) == SRP_DATA_DESC_INDIRECT)) { ++ idb = (struct srp_indirect_buf *)(srp_cmd->add_data ++ + add_cdb_offset); ++ ++ ioctx->n_rbuf = be32_to_cpu(idb->table_desc.len) / sizeof *db; ++ ++ if (ioctx->n_rbuf > ++ (srp_cmd->data_out_desc_cnt + srp_cmd->data_in_desc_cnt)) { ++ PRINT_ERROR("received unsupported SRP_CMD request type" ++ " (%u out + %u in != %u / %zu)", ++ srp_cmd->data_out_desc_cnt, ++ srp_cmd->data_in_desc_cnt, ++ be32_to_cpu(idb->table_desc.len), ++ sizeof(*db)); ++ ioctx->n_rbuf = 0; ++ ret = -EINVAL; ++ goto out; ++ } ++ ++ if (ioctx->n_rbuf == 1) ++ ioctx->rbufs = &ioctx->single_rbuf; ++ else { ++ ioctx->rbufs = ++ kmalloc(ioctx->n_rbuf * sizeof *db, GFP_ATOMIC); ++ if (!ioctx->rbufs) { ++ ioctx->n_rbuf = 0; ++ ret = -ENOMEM; ++ goto out; ++ } ++ } ++ ++ db = idb->desc_list; ++ memcpy(ioctx->rbufs, db, ioctx->n_rbuf * sizeof *db); ++ *data_len = be32_to_cpu(idb->len); ++ } ++out: ++ return ret; ++} ++ ++/** ++ * srpt_init_ch_qp() - Initialize queue pair attributes. ++ * ++ * Initialized the attributes of queue pair 'qp' by allowing local write, ++ * remote read and remote write. Also transitions 'qp' to state IB_QPS_INIT. ++ */ ++static int srpt_init_ch_qp(struct srpt_rdma_ch *ch, struct ib_qp *qp) ++{ ++ struct ib_qp_attr *attr; ++ int ret; ++ ++ attr = kzalloc(sizeof *attr, GFP_KERNEL); ++ if (!attr) ++ return -ENOMEM; ++ ++ attr->qp_state = IB_QPS_INIT; ++ attr->qp_access_flags = IB_ACCESS_LOCAL_WRITE | IB_ACCESS_REMOTE_READ | ++ IB_ACCESS_REMOTE_WRITE; ++ attr->port_num = ch->sport->port; ++ attr->pkey_index = 0; ++ ++ ret = ib_modify_qp(qp, attr, ++ IB_QP_STATE | IB_QP_ACCESS_FLAGS | IB_QP_PORT | ++ IB_QP_PKEY_INDEX); ++ ++ kfree(attr); ++ return ret; ++} ++ ++/** ++ * srpt_ch_qp_rtr() - Change the state of a channel to 'ready to receive' (RTR). ++ * @ch: channel of the queue pair. ++ * @qp: queue pair to change the state of. ++ * ++ * Returns zero upon success and a negative value upon failure. ++ */ ++static int srpt_ch_qp_rtr(struct srpt_rdma_ch *ch, struct ib_qp *qp) ++{ ++ struct ib_qp_attr *attr; ++ int attr_mask; ++ int ret; ++ ++ attr = kzalloc(sizeof *attr, GFP_KERNEL); ++ if (!attr) ++ return -ENOMEM; ++ ++ attr->qp_state = IB_QPS_RTR; ++ ret = ib_cm_init_qp_attr(ch->cm_id, attr, &attr_mask); ++ if (ret) ++ goto out; ++ ++ attr->max_dest_rd_atomic = 4; ++ TRACE_DBG("qp timeout = %d", attr->timeout); ++ ++ ret = ib_modify_qp(qp, attr, attr_mask); ++ ++out: ++ kfree(attr); ++ return ret; ++} ++ ++/** ++ * srpt_ch_qp_rts() - Change the state of a channel to 'ready to send' (RTS). ++ * @ch: channel of the queue pair. ++ * @qp: queue pair to change the state of. ++ * ++ * Returns zero upon success and a negative value upon failure. ++ */ ++static int srpt_ch_qp_rts(struct srpt_rdma_ch *ch, struct ib_qp *qp) ++{ ++ struct ib_qp_attr *attr; ++ int attr_mask; ++ int ret; ++ uint64_t T_tr_ns; ++ uint32_t T_tr_ms, max_compl_time_ms; ++ ++ attr = kzalloc(sizeof *attr, GFP_KERNEL); ++ if (!attr) ++ return -ENOMEM; ++ ++ attr->qp_state = IB_QPS_RTS; ++ ret = ib_cm_init_qp_attr(ch->cm_id, attr, &attr_mask); ++ if (ret) ++ goto out; ++ ++ attr->max_rd_atomic = 4; ++ ++ /* ++ * From IBTA C9-140: Transport Timer timeout interval ++ * T_tr = 4.096 us * 2**(local ACK timeout) where the local ACK timeout ++ * is a five-bit value, with zero meaning that the timer is disabled. ++ */ ++ WARN_ON(attr->timeout >= (1 << 5)); ++ if (attr->timeout) { ++ T_tr_ns = 1ULL << (12 + attr->timeout); ++ max_compl_time_ms = attr->retry_cnt * 4 * T_tr_ns; ++ do_div(max_compl_time_ms, 1000000); ++ T_tr_ms = T_tr_ns; ++ do_div(T_tr_ms, 1000000); ++ TRACE_DBG("Session %s: QP local ack timeout = %d or T_tr =" ++ " %u ms; retry_cnt = %d; max compl. time = %d ms", ++ ch->sess_name, attr->timeout, T_tr_ms, ++ attr->retry_cnt, max_compl_time_ms); ++ ++ if (max_compl_time_ms >= RDMA_COMPL_TIMEOUT_S * 1000) { ++ PRINT_ERROR("Maximum RDMA completion time (%d ms)" ++ " exceeds ib_srpt timeout (%d ms)", ++ max_compl_time_ms, ++ 1000 * RDMA_COMPL_TIMEOUT_S); ++ } ++ } ++ ++ ret = ib_modify_qp(qp, attr, attr_mask); ++ ++out: ++ kfree(attr); ++ return ret; ++} ++ ++/** ++ * srpt_ch_qp_err() - Set the channel queue pair state to 'error'. ++ */ ++static int srpt_ch_qp_err(struct srpt_rdma_ch *ch) ++{ ++ struct ib_qp_attr *attr; ++ int ret; ++ ++ attr = kzalloc(sizeof *attr, GFP_KERNEL); ++ if (!attr) ++ return -ENOMEM; ++ ++ attr->qp_state = IB_QPS_ERR; ++ ret = ib_modify_qp(ch->qp, attr, IB_QP_STATE); ++ kfree(attr); ++ return ret; ++} ++ ++/** ++ * srpt_get_send_ioctx() - Obtain an I/O context for sending to the initiator. ++ */ ++static struct srpt_send_ioctx *srpt_get_send_ioctx(struct srpt_rdma_ch *ch) ++{ ++ struct srpt_send_ioctx *ioctx; ++ unsigned long flags; ++ ++ BUG_ON(!ch); ++ ++ ioctx = NULL; ++ spin_lock_irqsave(&ch->spinlock, flags); ++ if (!list_empty(&ch->free_list)) { ++ ioctx = list_first_entry(&ch->free_list, ++ struct srpt_send_ioctx, free_list); ++ list_del(&ioctx->free_list); ++ } ++ spin_unlock_irqrestore(&ch->spinlock, flags); ++ ++ if (!ioctx) ++ return ioctx; ++ ++ BUG_ON(ioctx->ch != ch); ++ spin_lock_init(&ioctx->spinlock); ++ ioctx->state = SRPT_STATE_NEW; ++ ioctx->n_rbuf = 0; ++ ioctx->rbufs = NULL; ++ ioctx->n_rdma = 0; ++ ioctx->n_rdma_ius = 0; ++ ioctx->rdma_ius = NULL; ++ ioctx->mapped_sg_count = 0; ++ ioctx->scmnd = NULL; ++ ++ return ioctx; ++} ++ ++/** ++ * srpt_put_send_ioctx() - Free up resources. ++ */ ++static void srpt_put_send_ioctx(struct srpt_send_ioctx *ioctx) ++{ ++ struct srpt_rdma_ch *ch; ++ unsigned long flags; ++ ++ BUG_ON(!ioctx); ++ ch = ioctx->ch; ++ BUG_ON(!ch); ++ ++ ioctx->scmnd = NULL; ++ ++ /* ++ * If the WARN_ON() below gets triggered this means that ++ * srpt_unmap_sg_to_ib_sge() has not been called before ++ * scst_tgt_cmd_done(). ++ */ ++ WARN_ON(ioctx->mapped_sg_count); ++ ++ if (ioctx->n_rbuf > 1) { ++ kfree(ioctx->rbufs); ++ ioctx->rbufs = NULL; ++ ioctx->n_rbuf = 0; ++ } ++ ++ spin_lock_irqsave(&ch->spinlock, flags); ++ list_add(&ioctx->free_list, &ch->free_list); ++ spin_unlock_irqrestore(&ch->spinlock, flags); ++} ++ ++/** ++ * srpt_abort_cmd() - Abort a SCSI command. ++ * @ioctx: I/O context associated with the SCSI command. ++ * @context: Preferred execution context. ++ */ ++static void srpt_abort_cmd(struct srpt_send_ioctx *ioctx, ++ enum scst_exec_context context) ++{ ++ struct scst_cmd *scmnd; ++ enum srpt_command_state state; ++ ++ TRACE_ENTRY(); ++ ++ BUG_ON(!ioctx); ++ ++ /* ++ * If the command is in a state where the target core is waiting for ++ * the ib_srpt driver, change the state to the next state. Changing ++ * the state of the command from SRPT_STATE_NEED_DATA to ++ * SRPT_STATE_DATA_IN ensures that srpt_xmit_response() will call this ++ * function a second time. ++ */ ++ spin_lock(&ioctx->spinlock); ++ state = ioctx->state; ++ switch (state) { ++ case SRPT_STATE_NEED_DATA: ++ ioctx->state = SRPT_STATE_DATA_IN; ++ break; ++ case SRPT_STATE_DATA_IN: ++ case SRPT_STATE_CMD_RSP_SENT: ++ case SRPT_STATE_MGMT_RSP_SENT: ++ ioctx->state = SRPT_STATE_DONE; ++ break; ++ default: ++ break; ++ } ++ spin_unlock(&ioctx->spinlock); ++ ++ if (state == SRPT_STATE_DONE) ++ goto out; ++ ++ scmnd = ioctx->scmnd; ++ WARN_ON(!scmnd); ++ if (!scmnd) ++ goto out; ++ ++ WARN_ON(ioctx != scst_cmd_get_tgt_priv(scmnd)); ++ ++ TRACE_DBG("Aborting cmd with state %d and tag %lld", ++ state, scst_cmd_get_tag(scmnd)); ++ ++ switch (state) { ++ case SRPT_STATE_NEW: ++ case SRPT_STATE_DATA_IN: ++ case SRPT_STATE_MGMT: ++ /* ++ * Do nothing - defer abort processing until ++ * srpt_xmit_response() is invoked. ++ */ ++ WARN_ON(!scst_cmd_aborted(scmnd)); ++ break; ++ case SRPT_STATE_NEED_DATA: ++ /* SCST_DATA_WRITE - RDMA read error or RDMA read timeout. */ ++ scst_rx_data(ioctx->scmnd, SCST_RX_STATUS_ERROR, context); ++ break; ++ case SRPT_STATE_CMD_RSP_SENT: ++ /* ++ * SRP_RSP sending failed or the SRP_RSP send completion has ++ * not been received in time. ++ */ ++ srpt_unmap_sg_to_ib_sge(ioctx->ch, ioctx); ++ srpt_put_send_ioctx(ioctx); ++ scst_set_delivery_status(scmnd, SCST_CMD_DELIVERY_ABORTED); ++ scst_tgt_cmd_done(scmnd, context); ++ break; ++ case SRPT_STATE_MGMT_RSP_SENT: ++ /* ++ * Management command response sending failed. This state is ++ * never reached since there is no scmnd associated with ++ * management commands. Note: the SCST core frees these ++ * commands immediately after srpt_tsk_mgmt_done() returned. ++ */ ++ WARN_ON("ERROR: unexpected command state"); ++ break; ++ default: ++ WARN_ON("ERROR: unexpected command state"); ++ break; ++ } ++ ++out: ++ ; ++ ++ TRACE_EXIT(); ++} ++ ++/** ++ * srpt_handle_send_err_comp() - Process an IB_WC_SEND error completion. ++ */ ++static void srpt_handle_send_err_comp(struct srpt_rdma_ch *ch, u64 wr_id, ++ enum scst_exec_context context) ++{ ++ struct srpt_send_ioctx *ioctx; ++ enum srpt_command_state state; ++ struct scst_cmd *scmnd; ++ u32 index; ++ ++ srpt_adjust_srq_wr_avail(ch, 1); ++ ++ index = idx_from_wr_id(wr_id); ++ ioctx = ch->ioctx_ring[index]; ++ state = ioctx->state; ++ scmnd = ioctx->scmnd; ++ ++ EXTRACHECKS_WARN_ON(state != SRPT_STATE_CMD_RSP_SENT ++ && state != SRPT_STATE_MGMT_RSP_SENT ++ && state != SRPT_STATE_NEED_DATA ++ && state != SRPT_STATE_DONE); ++ ++ /* ++ * If SRP_RSP sending failed, undo the ch->req_lim and ch->req_lim_delta ++ * changes. ++ */ ++ if (state == SRPT_STATE_CMD_RSP_SENT ++ || state == SRPT_STATE_MGMT_RSP_SENT) ++ srpt_undo_inc_req_lim(ch, ioctx->req_lim_delta); ++ if (state != SRPT_STATE_DONE) { ++ if (scmnd) ++ srpt_abort_cmd(ioctx, context); ++ else ++ srpt_put_send_ioctx(ioctx); ++ } else ++ PRINT_ERROR("Received more than one IB error completion" ++ " for wr_id = %u.", (unsigned)index); ++} ++ ++/** ++ * srpt_handle_send_comp() - Process an IB send completion notification. ++ */ ++static void srpt_handle_send_comp(struct srpt_rdma_ch *ch, ++ struct srpt_send_ioctx *ioctx, ++ enum scst_exec_context context) ++{ ++ enum srpt_command_state state; ++ ++ srpt_adjust_srq_wr_avail(ch, 1); ++ ++ state = srpt_set_cmd_state(ioctx, SRPT_STATE_DONE); ++ ++ EXTRACHECKS_WARN_ON(state != SRPT_STATE_CMD_RSP_SENT ++ && state != SRPT_STATE_MGMT_RSP_SENT ++ && state != SRPT_STATE_DONE); ++ ++ if (state != SRPT_STATE_DONE) { ++ struct scst_cmd *scmnd; ++ ++ scmnd = ioctx->scmnd; ++ EXTRACHECKS_WARN_ON((state == SRPT_STATE_MGMT_RSP_SENT) ++ != (scmnd == NULL)); ++ if (scmnd) { ++ srpt_unmap_sg_to_ib_sge(ch, ioctx); ++ srpt_put_send_ioctx(ioctx); ++ scst_tgt_cmd_done(scmnd, context); ++ } else ++ srpt_put_send_ioctx(ioctx); ++ } else { ++ PRINT_ERROR("IB completion has been received too late for" ++ " wr_id = %u.", ioctx->ioctx.index); ++ } ++} ++ ++/** ++ * srpt_handle_rdma_comp() - Process an IB RDMA completion notification. ++ */ ++static void srpt_handle_rdma_comp(struct srpt_rdma_ch *ch, ++ struct srpt_send_ioctx *ioctx, ++ enum srpt_opcode opcode, ++ enum scst_exec_context context) ++{ ++ struct scst_cmd *scmnd; ++ ++ EXTRACHECKS_WARN_ON(ioctx->n_rdma <= 0); ++ srpt_adjust_srq_wr_avail(ch, ioctx->n_rdma); ++ ++ scmnd = ioctx->scmnd; ++ if (opcode == SRPT_RDMA_READ_LAST && scmnd) { ++ if (srpt_test_and_set_cmd_state(ioctx, SRPT_STATE_NEED_DATA, ++ SRPT_STATE_DATA_IN)) ++ scst_rx_data(ioctx->scmnd, SCST_RX_STATUS_SUCCESS, ++ context); ++ else ++ PRINT_ERROR("%s[%d]: wrong state = %d", __func__, ++ __LINE__, ioctx->state); ++ } else if (opcode == SRPT_RDMA_ABORT) { ++ ioctx->rdma_aborted = true; ++ } else { ++ WARN(true, "scmnd == NULL (opcode %d)", opcode); ++ } ++} ++ ++/** ++ * srpt_handle_rdma_err_comp() - Process an IB RDMA error completion. ++ */ ++static void srpt_handle_rdma_err_comp(struct srpt_rdma_ch *ch, ++ struct srpt_send_ioctx *ioctx, ++ enum srpt_opcode opcode, ++ enum scst_exec_context context) ++{ ++ struct scst_cmd *scmnd; ++ enum srpt_command_state state; ++ ++ scmnd = ioctx->scmnd; ++ state = ioctx->state; ++ if (scmnd) { ++ switch (opcode) { ++ case SRPT_RDMA_READ_LAST: ++ if (ioctx->n_rdma <= 0) { ++ PRINT_ERROR("Received invalid RDMA read error" ++ " completion with idx %d", ++ ioctx->ioctx.index); ++ break; ++ } ++ srpt_adjust_srq_wr_avail(ch, ioctx->n_rdma); ++ if (state == SRPT_STATE_NEED_DATA) ++ srpt_abort_cmd(ioctx, context); ++ else ++ PRINT_ERROR("%s[%d]: wrong state = %d", ++ __func__, __LINE__, state); ++ break; ++ case SRPT_RDMA_WRITE_LAST: ++ scst_set_delivery_status(scmnd, ++ SCST_CMD_DELIVERY_ABORTED); ++ break; ++ default: ++ PRINT_ERROR("%s[%d]: opcode = %u", __func__, __LINE__, ++ opcode); ++ break; ++ } ++ } else ++ PRINT_ERROR("%s[%d]: scmnd == NULL", __func__, __LINE__); ++} ++ ++/** ++ * srpt_build_cmd_rsp() - Build an SRP_RSP response. ++ * @ch: RDMA channel through which the request has been received. ++ * @ioctx: I/O context associated with the SRP_CMD request. The response will ++ * be built in the buffer ioctx->buf points at and hence this function will ++ * overwrite the request data. ++ * @tag: tag of the request for which this response is being generated. ++ * @status: value for the STATUS field of the SRP_RSP information unit. ++ * @sense_data: pointer to sense data to be included in the response. ++ * @sense_data_len: length in bytes of the sense data. ++ * ++ * Returns the size in bytes of the SRP_RSP response. ++ * ++ * An SRP_RSP response contains a SCSI status or service response. See also ++ * section 6.9 in the SRP r16a document for the format of an SRP_RSP ++ * response. See also SPC-2 for more information about sense data. ++ */ ++static int srpt_build_cmd_rsp(struct srpt_rdma_ch *ch, ++ struct srpt_send_ioctx *ioctx, u64 tag, ++ int status, const u8 *sense_data, ++ int sense_data_len) ++{ ++ struct srp_rsp *srp_rsp; ++ int max_sense_len; ++ ++ /* ++ * The lowest bit of all SAM-3 status codes is zero (see also ++ * paragraph 5.3 in SAM-3). ++ */ ++ EXTRACHECKS_WARN_ON(status & 1); ++ ++ srp_rsp = ioctx->ioctx.buf; ++ BUG_ON(!srp_rsp); ++ memset(srp_rsp, 0, sizeof *srp_rsp); ++ ++ srp_rsp->opcode = SRP_RSP; ++ srp_rsp->req_lim_delta = cpu_to_be32(ioctx->req_lim_delta); ++ srp_rsp->tag = tag; ++ srp_rsp->status = status; ++ ++ if (!SCST_SENSE_VALID(sense_data)) ++ sense_data_len = 0; ++ else { ++ BUILD_BUG_ON(MIN_MAX_RSP_SIZE <= sizeof(*srp_rsp)); ++ max_sense_len = ch->max_ti_iu_len - sizeof(*srp_rsp); ++ if (sense_data_len > max_sense_len) { ++ PRINT_WARNING("truncated sense data from %d to %d" ++ " bytes", sense_data_len, max_sense_len); ++ sense_data_len = max_sense_len; ++ } ++ ++ srp_rsp->flags |= SRP_RSP_FLAG_SNSVALID; ++ srp_rsp->sense_data_len = cpu_to_be32(sense_data_len); ++ memcpy(srp_rsp + 1, sense_data, sense_data_len); ++ } ++ ++ return sizeof(*srp_rsp) + sense_data_len; ++} ++ ++/** ++ * srpt_build_tskmgmt_rsp() - Build a task management response. ++ * @ch: RDMA channel through which the request has been received. ++ * @ioctx: I/O context in which the SRP_RSP response will be built. ++ * @rsp_code: RSP_CODE that will be stored in the response. ++ * @tag: Tag of the request for which this response is being generated. ++ * ++ * Returns the size in bytes of the SRP_RSP response. ++ * ++ * An SRP_RSP response contains a SCSI status or service response. See also ++ * section 6.9 in the SRP r16a document for the format of an SRP_RSP ++ * response. ++ */ ++static int srpt_build_tskmgmt_rsp(struct srpt_rdma_ch *ch, ++ struct srpt_send_ioctx *ioctx, ++ u8 rsp_code, u64 tag) ++{ ++ struct srp_rsp *srp_rsp; ++ int resp_data_len; ++ int resp_len; ++ ++ resp_data_len = (rsp_code == SRP_TSK_MGMT_SUCCESS) ? 0 : 4; ++ resp_len = sizeof(*srp_rsp) + resp_data_len; ++ ++ srp_rsp = ioctx->ioctx.buf; ++ BUG_ON(!srp_rsp); ++ memset(srp_rsp, 0, sizeof *srp_rsp); ++ ++ srp_rsp->opcode = SRP_RSP; ++ srp_rsp->req_lim_delta = cpu_to_be32(ioctx->req_lim_delta); ++ srp_rsp->tag = tag; ++ ++ if (rsp_code != SRP_TSK_MGMT_SUCCESS) { ++ srp_rsp->flags |= SRP_RSP_FLAG_RSPVALID; ++ srp_rsp->resp_data_len = cpu_to_be32(resp_data_len); ++ srp_rsp->data[3] = rsp_code; ++ } ++ ++ return resp_len; ++} ++ ++/** ++ * srpt_handle_cmd() - Process SRP_CMD. ++ */ ++static int srpt_handle_cmd(struct srpt_rdma_ch *ch, ++ struct srpt_recv_ioctx *recv_ioctx, ++ struct srpt_send_ioctx *send_ioctx, ++ enum scst_exec_context context) ++{ ++ struct scst_cmd *scmnd; ++ struct srp_cmd *srp_cmd; ++ scst_data_direction dir; ++ u64 data_len; ++ int ret; ++ int atomic; ++ ++ BUG_ON(!send_ioctx); ++ ++ srp_cmd = recv_ioctx->ioctx.buf; ++ ++ atomic = context == SCST_CONTEXT_TASKLET ? SCST_ATOMIC ++ : SCST_NON_ATOMIC; ++ scmnd = scst_rx_cmd(ch->scst_sess, (u8 *) &srp_cmd->lun, ++ sizeof srp_cmd->lun, srp_cmd->cdb, ++ sizeof srp_cmd->cdb, atomic); ++ if (!scmnd) { ++ PRINT_ERROR("0x%llx: allocation of an SCST command failed", ++ srp_cmd->tag); ++ goto err; ++ } ++ ++ send_ioctx->scmnd = scmnd; ++ ++ ret = srpt_get_desc_tbl(send_ioctx, srp_cmd, &dir, &data_len); ++ if (ret) { ++ PRINT_ERROR("0x%llx: parsing SRP descriptor table failed.", ++ srp_cmd->tag); ++ scst_set_cmd_error(scmnd, ++ SCST_LOAD_SENSE(scst_sense_invalid_field_in_cdb)); ++ } ++ ++ switch (srp_cmd->task_attr) { ++ case SRP_CMD_HEAD_OF_Q: ++ scst_cmd_set_queue_type(scmnd, SCST_CMD_QUEUE_HEAD_OF_QUEUE); ++ break; ++ case SRP_CMD_ORDERED_Q: ++ scst_cmd_set_queue_type(scmnd, SCST_CMD_QUEUE_ORDERED); ++ break; ++ case SRP_CMD_SIMPLE_Q: ++ scst_cmd_set_queue_type(scmnd, SCST_CMD_QUEUE_SIMPLE); ++ break; ++ case SRP_CMD_ACA: ++ scst_cmd_set_queue_type(scmnd, SCST_CMD_QUEUE_ACA); ++ break; ++ default: ++ scst_cmd_set_queue_type(scmnd, SCST_CMD_QUEUE_ORDERED); ++ break; ++ } ++ ++ scst_cmd_set_tag(scmnd, srp_cmd->tag); ++ scst_cmd_set_tgt_priv(scmnd, send_ioctx); ++ scst_cmd_set_expected(scmnd, dir, data_len); ++ scst_cmd_init_done(scmnd, context); ++ ++ return 0; ++ ++err: ++ srpt_put_send_ioctx(send_ioctx); ++ return -1; ++} ++ ++/** ++ * srpt_handle_tsk_mgmt() - Process an SRP_TSK_MGMT information unit. ++ * ++ * Returns SCST_MGMT_STATUS_SUCCESS upon success. ++ * ++ * Each task management function is performed by calling one of the ++ * scst_rx_mgmt_fn*() functions. These functions will either report failure ++ * or process the task management function asynchronously. The function ++ * srpt_tsk_mgmt_done() will be called by the SCST core upon completion of the ++ * task management function. When srpt_handle_tsk_mgmt() reports failure ++ * (i.e. returns -1) a response will have been built in ioctx->buf. This ++ * information unit has to be sent back by the caller. ++ * ++ * For more information about SRP_TSK_MGMT information units, see also section ++ * 6.7 in the SRP r16a document. ++ */ ++static u8 srpt_handle_tsk_mgmt(struct srpt_rdma_ch *ch, ++ struct srpt_recv_ioctx *recv_ioctx, ++ struct srpt_send_ioctx *send_ioctx) ++{ ++ struct srp_tsk_mgmt *srp_tsk; ++ int ret; ++ ++ ret = SCST_MGMT_STATUS_FAILED; ++ ++ BUG_ON(!send_ioctx); ++ BUG_ON(send_ioctx->ch != ch); ++ ++ srpt_set_cmd_state(send_ioctx, SRPT_STATE_MGMT); ++ ++ srp_tsk = recv_ioctx->ioctx.buf; ++ ++ TRACE_DBG("recv_tsk_mgmt= %d for task_tag= %lld" ++ " using tag= %lld cm_id= %p sess= %p", ++ srp_tsk->tsk_mgmt_func, srp_tsk->task_tag, srp_tsk->tag, ++ ch->cm_id, ch->scst_sess); ++ ++ send_ioctx->tsk_mgmt.tag = srp_tsk->tag; ++ ++ switch (srp_tsk->tsk_mgmt_func) { ++ case SRP_TSK_ABORT_TASK: ++ TRACE_DBG("%s", "Processing SRP_TSK_ABORT_TASK"); ++ ret = scst_rx_mgmt_fn_tag(ch->scst_sess, ++ SCST_ABORT_TASK, ++ srp_tsk->task_tag, ++ SCST_ATOMIC, send_ioctx); ++ break; ++ case SRP_TSK_ABORT_TASK_SET: ++ TRACE_DBG("%s", "Processing SRP_TSK_ABORT_TASK_SET"); ++ ret = scst_rx_mgmt_fn_lun(ch->scst_sess, ++ SCST_ABORT_TASK_SET, ++ (u8 *) &srp_tsk->lun, ++ sizeof srp_tsk->lun, ++ SCST_ATOMIC, send_ioctx); ++ break; ++ case SRP_TSK_CLEAR_TASK_SET: ++ TRACE_DBG("%s", "Processing SRP_TSK_CLEAR_TASK_SET"); ++ ret = scst_rx_mgmt_fn_lun(ch->scst_sess, ++ SCST_CLEAR_TASK_SET, ++ (u8 *) &srp_tsk->lun, ++ sizeof srp_tsk->lun, ++ SCST_ATOMIC, send_ioctx); ++ break; ++ case SRP_TSK_LUN_RESET: ++ TRACE_DBG("%s", "Processing SRP_TSK_LUN_RESET"); ++ ret = scst_rx_mgmt_fn_lun(ch->scst_sess, ++ SCST_LUN_RESET, ++ (u8 *) &srp_tsk->lun, ++ sizeof srp_tsk->lun, ++ SCST_ATOMIC, send_ioctx); ++ break; ++ case SRP_TSK_CLEAR_ACA: ++ TRACE_DBG("%s", "Processing SRP_TSK_CLEAR_ACA"); ++ ret = scst_rx_mgmt_fn_lun(ch->scst_sess, ++ SCST_CLEAR_ACA, ++ (u8 *) &srp_tsk->lun, ++ sizeof srp_tsk->lun, ++ SCST_ATOMIC, send_ioctx); ++ break; ++ default: ++ TRACE_DBG("%s", "Unsupported task management function."); ++ ret = SCST_MGMT_STATUS_FN_NOT_SUPPORTED; ++ } ++ ++ if (ret != SCST_MGMT_STATUS_SUCCESS) ++ srpt_put_send_ioctx(send_ioctx); ++ ++ return ret; ++} ++ ++static u8 scst_to_srp_tsk_mgmt_status(const int scst_mgmt_status) ++{ ++ switch (scst_mgmt_status) { ++ case SCST_MGMT_STATUS_SUCCESS: ++ return SRP_TSK_MGMT_SUCCESS; ++ case SCST_MGMT_STATUS_FN_NOT_SUPPORTED: ++ return SRP_TSK_MGMT_FUNC_NOT_SUPP; ++ case SCST_MGMT_STATUS_TASK_NOT_EXIST: ++ case SCST_MGMT_STATUS_LUN_NOT_EXIST: ++ case SCST_MGMT_STATUS_REJECTED: ++ case SCST_MGMT_STATUS_FAILED: ++ default: ++ break; ++ } ++ return SRP_TSK_MGMT_FAILED; ++} ++ ++/** ++ * srpt_handle_new_iu() - Process a newly received information unit. ++ * @ch: RDMA channel through which the information unit has been received. ++ * @ioctx: SRPT I/O context associated with the information unit. ++ */ ++static void srpt_handle_new_iu(struct srpt_rdma_ch *ch, ++ struct srpt_recv_ioctx *recv_ioctx, ++ struct srpt_send_ioctx *send_ioctx, ++ enum scst_exec_context context) ++{ ++ struct srp_cmd *srp_cmd; ++ enum rdma_ch_state ch_state; ++ ++ BUG_ON(!ch); ++ BUG_ON(!recv_ioctx); ++ ++ ib_dma_sync_single_for_cpu(ch->sport->sdev->device, ++ recv_ioctx->ioctx.dma, srp_max_req_size, ++ DMA_FROM_DEVICE); ++ ++ ch_state = ch->state; ++ srp_cmd = recv_ioctx->ioctx.buf; ++ if (unlikely(ch_state == CH_CONNECTING)) { ++ list_add_tail(&recv_ioctx->wait_list, &ch->cmd_wait_list); ++ goto out; ++ } ++ ++ if (srp_cmd->opcode == SRP_CMD || srp_cmd->opcode == SRP_TSK_MGMT) { ++ if (!send_ioctx) ++ send_ioctx = srpt_get_send_ioctx(ch); ++ if (unlikely(!send_ioctx)) { ++ list_add_tail(&recv_ioctx->wait_list, ++ &ch->cmd_wait_list); ++ goto out; ++ } ++ } ++ ++ switch (srp_cmd->opcode) { ++ case SRP_CMD: ++ srpt_handle_cmd(ch, recv_ioctx, send_ioctx, context); ++ break; ++ case SRP_TSK_MGMT: ++ srpt_handle_tsk_mgmt(ch, recv_ioctx, send_ioctx); ++ break; ++ case SRP_I_LOGOUT: ++ PRINT_ERROR("%s", "Not yet implemented: SRP_I_LOGOUT"); ++ break; ++ case SRP_CRED_RSP: ++ TRACE_DBG("%s", "received SRP_CRED_RSP"); ++ break; ++ case SRP_AER_RSP: ++ TRACE_DBG("%s", "received SRP_AER_RSP"); ++ break; ++ case SRP_RSP: ++ PRINT_ERROR("%s", "Received SRP_RSP"); ++ break; ++ default: ++ PRINT_ERROR("received IU with unknown opcode 0x%x", ++ srp_cmd->opcode); ++ break; ++ } ++ ++ srpt_post_recv(ch->sport->sdev, recv_ioctx); ++out: ++ return; ++} ++ ++static void srpt_process_rcv_completion(struct ib_cq *cq, ++ struct srpt_rdma_ch *ch, ++ enum scst_exec_context context, ++ struct ib_wc *wc) ++{ ++ struct srpt_device *sdev = ch->sport->sdev; ++ struct srpt_recv_ioctx *ioctx; ++ u32 index; ++ ++ index = idx_from_wr_id(wc->wr_id); ++ if (wc->status == IB_WC_SUCCESS) { ++ int req_lim; ++ ++ req_lim = srpt_adjust_req_lim(ch, -1, 0); ++ if (unlikely(req_lim < 0)) ++ PRINT_ERROR("req_lim = %d < 0", req_lim); ++ ioctx = sdev->ioctx_ring[index]; ++ srpt_handle_new_iu(ch, ioctx, NULL, context); ++ } else { ++ PRINT_INFO("receiving failed for idx %u with status %d", ++ index, wc->status); ++ } ++} ++ ++/** ++ * srpt_process_send_completion() - Process an IB send completion. ++ * ++ * Note: Although this has not yet been observed during tests, at least in ++ * theory it is possible that the srpt_get_send_ioctx() call invoked by ++ * srpt_handle_new_iu() fails. This is possible because the req_lim_delta ++ * value in each response is set to at least one, and it is possible that this ++ * response makes the initiator send a new request before the send completion ++ * for that response has been processed. This could e.g. happen if the call to ++ * srpt_put_send_iotcx() is delayed because of a higher priority interrupt or ++ * if IB retransmission causes generation of the send completion to be ++ * delayed. Incoming information units for which srpt_get_send_ioctx() fails ++ * are queued on cmd_wait_list. The code below processes these delayed ++ * requests one at a time. ++ */ ++static void srpt_process_send_completion(struct ib_cq *cq, ++ struct srpt_rdma_ch *ch, ++ enum scst_exec_context context, ++ struct ib_wc *wc) ++{ ++ struct srpt_send_ioctx *send_ioctx; ++ uint32_t index; ++ enum srpt_opcode opcode; ++ ++ index = idx_from_wr_id(wc->wr_id); ++ opcode = opcode_from_wr_id(wc->wr_id); ++ send_ioctx = ch->ioctx_ring[index]; ++ if (wc->status == IB_WC_SUCCESS) { ++ if (opcode == SRPT_SEND) ++ srpt_handle_send_comp(ch, send_ioctx, context); ++ else { ++ EXTRACHECKS_WARN_ON(opcode != SRPT_RDMA_ABORT && ++ wc->opcode != IB_WC_RDMA_READ); ++ srpt_handle_rdma_comp(ch, send_ioctx, opcode, context); ++ } ++ } else { ++ if (opcode == SRPT_SEND) { ++ PRINT_INFO("sending response for idx %u failed with" ++ " status %d", index, wc->status); ++ srpt_handle_send_err_comp(ch, wc->wr_id, context); ++ } else if (opcode != SRPT_RDMA_MID) { ++ PRINT_INFO("RDMA t %d for idx %u failed with status %d", ++ opcode, index, wc->status); ++ srpt_handle_rdma_err_comp(ch, send_ioctx, opcode, ++ context); ++ } ++ } ++ ++ while (unlikely(opcode == SRPT_SEND ++ && !list_empty(&ch->cmd_wait_list) ++ && ch->state == CH_LIVE ++ && (send_ioctx = srpt_get_send_ioctx(ch)) != NULL)) { ++ struct srpt_recv_ioctx *recv_ioctx; ++ ++ recv_ioctx = list_first_entry(&ch->cmd_wait_list, ++ struct srpt_recv_ioctx, ++ wait_list); ++ list_del(&recv_ioctx->wait_list); ++ srpt_handle_new_iu(ch, recv_ioctx, send_ioctx, context); ++ } ++} ++ ++static void srpt_process_completion(struct ib_cq *cq, ++ struct srpt_rdma_ch *ch, ++ enum scst_exec_context rcv_context, ++ enum scst_exec_context send_context) ++{ ++ struct ib_wc *const wc = ch->wc; ++ int i, n; ++ ++ EXTRACHECKS_WARN_ON(cq != ch->cq); ++ ++ ib_req_notify_cq(cq, IB_CQ_NEXT_COMP); ++ while ((n = ib_poll_cq(cq, ARRAY_SIZE(ch->wc), wc)) > 0) { ++ for (i = 0; i < n; i++) { ++ if (opcode_from_wr_id(wc[i].wr_id) == SRPT_RECV) ++ srpt_process_rcv_completion(cq, ch, rcv_context, ++ &wc[i]); ++ else ++ srpt_process_send_completion(cq, ch, ++ send_context, ++ &wc[i]); ++ } ++ } ++} ++ ++/** ++ * srpt_completion() - IB completion queue callback function. ++ */ ++static void srpt_completion(struct ib_cq *cq, void *ctx) ++{ ++ struct srpt_rdma_ch *ch = ctx; ++ ++ BUG_ON(!ch->thread); ++ wake_up_process(ch->thread); ++} ++ ++static int srpt_compl_thread(void *arg) ++{ ++ struct srpt_rdma_ch *ch; ++ ++ /* Hibernation / freezing of the SRPT kernel thread is not supported. */ ++ current->flags |= PF_NOFREEZE; ++ ++ ch = arg; ++ BUG_ON(!ch); ++ while (!kthread_should_stop() && !ch->last_wqe_received) { ++ set_current_state(TASK_INTERRUPTIBLE); ++ srpt_process_completion(ch->cq, ch, SCST_CONTEXT_THREAD, ++ SCST_CONTEXT_DIRECT); ++ schedule(); ++ } ++ set_current_state(TASK_RUNNING); ++ ++ srpt_process_completion(ch->cq, ch, SCST_CONTEXT_THREAD, ++ SCST_CONTEXT_DIRECT); ++ ++ /* ++ * Note: scst_unregister_session() must only be invoked after the last ++ * WQE event has been received. ++ */ ++ TRACE_DBG("ch %s: about to invoke scst_unregister_session()", ++ ch->sess_name); ++ scst_unregister_session(ch->scst_sess, false, srpt_free_ch); ++ ++ /* ++ * Some HCAs can queue send completions after the Last WQE ++ * event. Make sure to process these work completions. ++ */ ++ while (ch->state < CH_FREEING) { ++ set_current_state(TASK_INTERRUPTIBLE); ++ srpt_process_completion(ch->cq, ch, SCST_CONTEXT_THREAD, ++ SCST_CONTEXT_DIRECT); ++ schedule(); ++ } ++ ++ complete(&ch->finished_processing_completions); ++ ++ while (!kthread_should_stop()) ++ schedule(); ++ ++ return 0; ++} ++ ++/** ++ * srpt_create_ch_ib() - Create receive and send completion queues. ++ */ ++static int srpt_create_ch_ib(struct srpt_rdma_ch *ch) ++{ ++ struct ib_qp_init_attr *qp_init; ++ struct srpt_device *sdev = ch->sport->sdev; ++ int ret; ++ ++ EXTRACHECKS_WARN_ON(ch->rq_size < 1); ++ ++ ret = -ENOMEM; ++ qp_init = kzalloc(sizeof *qp_init, GFP_KERNEL); ++ if (!qp_init) ++ goto out; ++ ++ ch->cq = ib_create_cq(sdev->device, srpt_completion, NULL, ch, ++ ch->rq_size + srpt_sq_size, 0); ++ if (IS_ERR(ch->cq)) { ++ ret = PTR_ERR(ch->cq); ++ PRINT_ERROR("failed to create CQ cqe= %d ret= %d", ++ ch->rq_size + srpt_sq_size, ret); ++ goto out; ++ } ++ ++ qp_init->qp_context = (void *)ch; ++ qp_init->event_handler ++ = (void(*)(struct ib_event *, void*))srpt_qp_event; ++ qp_init->send_cq = ch->cq; ++ qp_init->recv_cq = ch->cq; ++ qp_init->srq = sdev->srq; ++ qp_init->sq_sig_type = IB_SIGNAL_REQ_WR; ++ qp_init->qp_type = IB_QPT_RC; ++ qp_init->cap.max_send_wr = srpt_sq_size; ++ /* ++ * A quote from the OFED 1.5.3.1 release notes ++ * (docs/release_notes/mthca_release_notes.txt), section "Known Issues": ++ * In mem-free devices, RC QPs can be created with a maximum of ++ * (max_sge - 1) entries only; UD QPs can be created with a maximum of ++ * (max_sge - 3) entries. ++ * A quote from the OFED 1.2.5 release notes ++ * (docs/mthca_release_notes.txt), section "Known Issues": ++ * In mem-free devices, RC QPs can be created with a maximum of ++ * (max_sge - 3) entries only. ++ */ ++ ch->max_sge = sdev->dev_attr.max_sge - 3; ++ WARN_ON(ch->max_sge < 1); ++ qp_init->cap.max_send_sge = ch->max_sge; ++ ++ ch->qp = ib_create_qp(sdev->pd, qp_init); ++ if (IS_ERR(ch->qp)) { ++ ret = PTR_ERR(ch->qp); ++ PRINT_ERROR("failed to create_qp ret= %d", ret); ++ goto err_destroy_cq; ++ } ++ ++ ch->sq_wr_avail = qp_init->cap.max_send_wr; ++ ++ TRACE_DBG("%s: max_cqe= %d max_sge= %d sq_size = %d" ++ " cm_id= %p", __func__, ch->cq->cqe, ++ qp_init->cap.max_send_sge, qp_init->cap.max_send_wr, ++ ch->cm_id); ++ ++ ret = srpt_init_ch_qp(ch, ch->qp); ++ if (ret) { ++ PRINT_ERROR("srpt_init_ch_qp() failed (%d)", ret); ++ goto err_destroy_qp; ++ } ++ ++out: ++ kfree(qp_init); ++ return ret; ++ ++err_destroy_qp: ++ ib_destroy_qp(ch->qp); ++err_destroy_cq: ++ ib_destroy_cq(ch->cq); ++ goto out; ++} ++ ++static void srpt_destroy_ch_ib(struct srpt_rdma_ch *ch) ++{ ++ TRACE_ENTRY(); ++ ++ while (ib_poll_cq(ch->cq, ARRAY_SIZE(ch->wc), ch->wc) > 0) ++ ; ++ ++ ib_destroy_qp(ch->qp); ++ ib_destroy_cq(ch->cq); ++ ++ TRACE_EXIT(); ++} ++ ++/** ++ * __srpt_close_ch() - Close an RDMA channel by setting the QP error state. ++ * ++ * Reset the QP and make sure all resources associated with the channel will ++ * be deallocated at an appropriate time. ++ * ++ * Returns true if and only if the channel state has been modified from ++ * CH_CONNECTING or CH_LIVE into CH_DISCONNECTING. ++ * ++ * Note: The caller must hold ch->sport->sdev->spinlock. ++ */ ++static bool __srpt_close_ch(struct srpt_rdma_ch *ch) ++{ ++ struct srpt_device *sdev; ++ enum rdma_ch_state prev_state; ++ bool was_live; ++ ++ sdev = ch->sport->sdev; ++ was_live = false; ++ ++ prev_state = srpt_set_ch_state_to_disc(ch); ++ ++ switch (prev_state) { ++ case CH_CONNECTING: ++ ib_send_cm_rej(ch->cm_id, IB_CM_REJ_NO_RESOURCES, NULL, 0, ++ NULL, 0); ++ /* fall through */ ++ case CH_LIVE: ++ was_live = true; ++ if (ib_send_cm_dreq(ch->cm_id, NULL, 0) < 0) ++ PRINT_ERROR("%s", "sending CM DREQ failed."); ++ break; ++ case CH_DISCONNECTING: ++ case CH_DRAINING: ++ case CH_FREEING: ++ break; ++ } ++ ++ return was_live; ++} ++ ++/** ++ * srpt_close_ch() - Close an RDMA channel. ++ */ ++static void srpt_close_ch(struct srpt_rdma_ch *ch) ++{ ++ struct srpt_device *sdev; ++ ++ sdev = ch->sport->sdev; ++ spin_lock_irq(&sdev->spinlock); ++ __srpt_close_ch(ch); ++ spin_unlock_irq(&sdev->spinlock); ++} ++ ++/** ++ * srpt_drain_channel() - Drain a channel by resetting the IB queue pair. ++ * @cm_id: Pointer to the CM ID of the channel to be drained. ++ * ++ * Note: Must be called from inside srpt_cm_handler to avoid a race between ++ * accessing sdev->spinlock and the call to kfree(sdev) in srpt_remove_one() ++ * (the caller of srpt_cm_handler holds the cm_id spinlock; srpt_remove_one() ++ * waits until all target sessions for the associated IB device have been ++ * unregistered and target session registration involves a call to ++ * ib_destroy_cm_id(), which locks the cm_id spinlock and hence waits until ++ * this function has finished). ++ */ ++static void srpt_drain_channel(struct ib_cm_id *cm_id) ++{ ++ struct srpt_rdma_ch *ch; ++ int ret; ++ ++ WARN_ON_ONCE(irqs_disabled()); ++ ++ ch = cm_id->context; ++ if (srpt_set_ch_state_to_draining(ch)) { ++ ret = srpt_ch_qp_err(ch); ++ if (ret < 0) ++ PRINT_ERROR("Setting queue pair in error state" ++ " failed: %d", ret); ++ } ++} ++ ++static void srpt_free_ch(struct scst_session *sess) ++{ ++ struct srpt_rdma_ch *ch; ++ struct srpt_device *sdev; ++ ++ TRACE_ENTRY(); ++ ++ ch = scst_sess_get_tgt_priv(sess); ++ BUG_ON(ch->scst_sess != sess); ++ sdev = ch->sport->sdev; ++ BUG_ON(!sdev); ++ ++ WARN_ON(!srpt_test_and_set_ch_state(ch, CH_DRAINING, CH_FREEING)); ++ WARN_ON(!ch->last_wqe_received); ++ ++ BUG_ON(!ch->thread); ++ BUG_ON(ch->thread == current); ++ ++ while (wait_for_completion_timeout(&ch->finished_processing_completions, ++ 10 * HZ) == 0) ++ PRINT_INFO("%s", "Waiting for completion processing thread ..."); ++ ++ srpt_destroy_ch_ib(ch); ++ ++ srpt_free_ioctx_ring((struct srpt_ioctx **)ch->ioctx_ring, ++ sdev, ch->rq_size, ++ ch->max_rsp_size, DMA_TO_DEVICE); ++ ++ spin_lock_irq(&sdev->spinlock); ++ list_del(&ch->list); ++ spin_unlock_irq(&sdev->spinlock); ++ ++ ib_destroy_cm_id(ch->cm_id); ++ ++ kthread_stop(ch->thread); ++ ch->thread = NULL; ++ ++ kfree(ch); ++ ++ wake_up(&sdev->ch_releaseQ); ++ ++ TRACE_EXIT(); ++} ++ ++/** ++ * srpt_enable_target() - Allows to enable a target via sysfs. ++ */ ++static int srpt_enable_target(struct scst_tgt *scst_tgt, bool enable) ++{ ++ struct srpt_device *sdev = scst_tgt_get_tgt_priv(scst_tgt); ++ ++ EXTRACHECKS_WARN_ON_ONCE(irqs_disabled()); ++ ++ if (!sdev) ++ return -ENOENT; ++ ++ TRACE_DBG("%s target %s", enable ? "Enabling" : "Disabling", ++ sdev->device->name); ++ ++ spin_lock_irq(&sdev->spinlock); ++ sdev->enabled = enable; ++ spin_unlock_irq(&sdev->spinlock); ++ ++ return 0; ++} ++ ++/** ++ * srpt_is_target_enabled() - Allows to query a targets status via sysfs. ++ */ ++static bool srpt_is_target_enabled(struct scst_tgt *scst_tgt) ++{ ++ struct srpt_device *sdev = scst_tgt_get_tgt_priv(scst_tgt); ++ bool res; ++ ++ EXTRACHECKS_WARN_ON_ONCE(irqs_disabled()); ++ ++ if (!sdev) ++ return false; ++ ++ spin_lock_irq(&sdev->spinlock); ++ res = sdev->enabled; ++ spin_unlock_irq(&sdev->spinlock); ++ return res; ++} ++ ++/** ++ * srpt_cm_req_recv() - Process the event IB_CM_REQ_RECEIVED. ++ * ++ * Ownership of the cm_id is transferred to the SCST session if this function ++ * returns zero. Otherwise the caller remains the owner of cm_id. ++ */ ++static int srpt_cm_req_recv(struct ib_cm_id *cm_id, ++ struct ib_cm_req_event_param *param, ++ void *private_data) ++{ ++ struct srpt_device *sdev = cm_id->context; ++ struct srp_login_req *req; ++ struct srp_login_rsp *rsp; ++ struct srp_login_rej *rej; ++ struct ib_cm_rep_param *rep_param; ++ struct srpt_rdma_ch *ch; ++ struct task_struct *thread; ++ u32 it_iu_len; ++ int i; ++ int ret = 0; ++ ++ EXTRACHECKS_WARN_ON_ONCE(irqs_disabled()); ++ ++ if (WARN_ON(!sdev || !private_data)) ++ return -EINVAL; ++ ++ req = (struct srp_login_req *)private_data; ++ ++ it_iu_len = be32_to_cpu(req->req_it_iu_len); ++ ++ PRINT_INFO("Received SRP_LOGIN_REQ with" ++ " i_port_id 0x%llx:0x%llx, t_port_id 0x%llx:0x%llx and it_iu_len %d" ++ " on port %d (guid=0x%llx:0x%llx)", ++ be64_to_cpu(*(__be64 *)&req->initiator_port_id[0]), ++ be64_to_cpu(*(__be64 *)&req->initiator_port_id[8]), ++ be64_to_cpu(*(__be64 *)&req->target_port_id[0]), ++ be64_to_cpu(*(__be64 *)&req->target_port_id[8]), ++ it_iu_len, ++ param->port, ++ be64_to_cpu(*(__be64 *)&sdev->port[param->port - 1].gid.raw[0]), ++ be64_to_cpu(*(__be64 *)&sdev->port[param->port - 1].gid.raw[8])); ++ ++ rsp = kzalloc(sizeof *rsp, GFP_KERNEL); ++ rej = kzalloc(sizeof *rej, GFP_KERNEL); ++ rep_param = kzalloc(sizeof *rep_param, GFP_KERNEL); ++ ++ if (!rsp || !rej || !rep_param) { ++ ret = -ENOMEM; ++ goto out; ++ } ++ ++ if (it_iu_len > srp_max_req_size || it_iu_len < 64) { ++ rej->reason = cpu_to_be32( ++ SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE); ++ ret = -EINVAL; ++ PRINT_ERROR("rejected SRP_LOGIN_REQ because its" ++ " length (%d bytes) is out of range (%d .. %d)", ++ it_iu_len, 64, srp_max_req_size); ++ goto reject; ++ } ++ ++ if (!srpt_is_target_enabled(sdev->scst_tgt)) { ++ rej->reason = cpu_to_be32( ++ SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES); ++ ret = -EINVAL; ++ PRINT_ERROR("rejected SRP_LOGIN_REQ because the target %s (%s)" ++ " has not yet been enabled", ++ sdev->scst_tgt->tgt_name, sdev->device->name); ++ goto reject; ++ } ++ ++ if (*(__be64 *)req->target_port_id != cpu_to_be64(srpt_service_guid) ++ || *(__be64 *)(req->target_port_id + 8) != ++ cpu_to_be64(srpt_service_guid)) { ++ rej->reason = cpu_to_be32( ++ SRP_LOGIN_REJ_UNABLE_ASSOCIATE_CHANNEL); ++ ret = -ENOMEM; ++ PRINT_ERROR("%s", "rejected SRP_LOGIN_REQ because it" ++ " has an invalid target port identifier."); ++ goto reject; ++ } ++ ++ ch = kzalloc(sizeof *ch, GFP_KERNEL); ++ if (!ch) { ++ rej->reason = cpu_to_be32(SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES); ++ PRINT_ERROR("%s", ++ "rejected SRP_LOGIN_REQ because out of memory."); ++ ret = -ENOMEM; ++ goto reject; ++ } ++ ++ memcpy(ch->i_port_id, req->initiator_port_id, 16); ++ memcpy(ch->t_port_id, req->target_port_id, 16); ++ ch->sport = &sdev->port[param->port - 1]; ++ ch->cm_id = cm_id; ++ cm_id->context = ch; ++ /* ++ * Avoid QUEUE_FULL conditions by limiting the number of buffers used ++ * for the SRP protocol to the SCST SCSI command queue size. ++ */ ++ ch->rq_size = min(SRPT_RQ_SIZE, scst_get_max_lun_commands(NULL, 0)); ++ spin_lock_init(&ch->spinlock); ++ ch->state = CH_CONNECTING; ++ INIT_LIST_HEAD(&ch->cmd_wait_list); ++ init_waitqueue_head(&ch->state_wq); ++ init_completion(&ch->finished_processing_completions); ++ ch->max_rsp_size = max_t(uint32_t, srp_max_rsp_size, MIN_MAX_RSP_SIZE); ++ ch->ioctx_ring = (struct srpt_send_ioctx **) ++ srpt_alloc_ioctx_ring(ch->sport->sdev, ch->rq_size, ++ sizeof(*ch->ioctx_ring[0]), ++ ch->max_rsp_size, DMA_TO_DEVICE); ++ if (!ch->ioctx_ring) { ++ rej->reason = cpu_to_be32(SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES); ++ goto free_ch; ++ } ++ ++ INIT_LIST_HEAD(&ch->free_list); ++ for (i = 0; i < ch->rq_size; i++) { ++ ch->ioctx_ring[i]->ch = ch; ++ list_add_tail(&ch->ioctx_ring[i]->free_list, &ch->free_list); ++ } ++ ++ ret = srpt_create_ch_ib(ch); ++ if (ret) { ++ rej->reason = cpu_to_be32(SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES); ++ PRINT_ERROR("%s", "rejected SRP_LOGIN_REQ because creating" ++ " a new RDMA channel failed."); ++ goto free_ring; ++ } ++ ++ if (use_port_guid_in_session_name) { ++ /* ++ * If the kernel module parameter use_port_guid_in_session_name ++ * has been specified, use a combination of the target port ++ * GUID and the initiator port ID as the session name. This ++ * was the original behavior of the SRP target implementation ++ * (i.e. before the SRPT was included in OFED 1.3). ++ */ ++ snprintf(ch->sess_name, sizeof(ch->sess_name), ++ "0x%016llx%016llx", ++ be64_to_cpu(*(__be64 *) ++ &sdev->port[param->port - 1].gid.raw[8]), ++ be64_to_cpu(*(__be64 *)(ch->i_port_id + 8))); ++ } else { ++ /* ++ * Default behavior: use the initator port identifier as the ++ * session name. ++ */ ++ snprintf(ch->sess_name, sizeof(ch->sess_name), ++ "0x%016llx%016llx", ++ be64_to_cpu(*(__be64 *)ch->i_port_id), ++ be64_to_cpu(*(__be64 *)(ch->i_port_id + 8))); ++ } ++ ++ TRACE_DBG("registering session %s", ch->sess_name); ++ ++ BUG_ON(!sdev->scst_tgt); ++ ch->scst_sess = scst_register_session(sdev->scst_tgt, 0, ch->sess_name, ++ ch, NULL, NULL); ++ if (!ch->scst_sess) { ++ rej->reason = cpu_to_be32(SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES); ++ TRACE_DBG("%s", "Failed to create SCST session"); ++ goto destroy_ib; ++ } ++ ++ thread = kthread_run(srpt_compl_thread, ch, "srpt_%s", ++ ch->sport->sdev->device->name); ++ if (IS_ERR(thread)) { ++ rej->reason = cpu_to_be32(SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES); ++ PRINT_ERROR("failed to create kernel thread %ld", PTR_ERR(ch->thread)); ++ goto unreg_ch; ++ } ++ ++ spin_lock_irq(&sdev->spinlock); ++ if ((req->req_flags & SRP_MTCH_ACTION) == SRP_MULTICHAN_SINGLE) { ++ struct srpt_rdma_ch *ch2; ++ ++ rsp->rsp_flags = SRP_LOGIN_RSP_MULTICHAN_NO_CHAN; ++ list_for_each_entry(ch2, &sdev->rch_list, list) { ++ if (!memcmp(ch2->i_port_id, req->initiator_port_id, 16) ++ && !memcmp(ch2->t_port_id, req->target_port_id, 16) ++ && param->port == ch2->sport->port ++ && param->listen_id == ch2->sport->sdev->cm_id ++ && ch2->cm_id) { ++ if (!__srpt_close_ch(ch2)) ++ continue; ++ ++ PRINT_INFO("Relogin - closed existing channel" ++ " %s; cm_id = %p", ch2->sess_name, ++ ch2->cm_id); ++ ++ rsp->rsp_flags = ++ SRP_LOGIN_RSP_MULTICHAN_TERMINATED; ++ } ++ } ++ } else { ++ rsp->rsp_flags = SRP_LOGIN_RSP_MULTICHAN_MAINTAINED; ++ } ++ list_add_tail(&ch->list, &sdev->rch_list); ++ ch->thread = thread; ++ spin_unlock_irq(&sdev->spinlock); ++ ++ ret = srpt_ch_qp_rtr(ch, ch->qp); ++ if (ret) { ++ rej->reason = cpu_to_be32(SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES); ++ PRINT_ERROR("rejected SRP_LOGIN_REQ because enabling" ++ " RTR failed (error code = %d)", ret); ++ goto reject_and_release; ++ } ++ ++ TRACE_DBG("Establish connection sess=%p name=%s cm_id=%p", ++ ch->scst_sess, ch->sess_name, ch->cm_id); ++ ++ /* create srp_login_response */ ++ rsp->opcode = SRP_LOGIN_RSP; ++ rsp->tag = req->tag; ++ rsp->max_it_iu_len = req->req_it_iu_len; ++ rsp->max_ti_iu_len = req->req_it_iu_len; ++ ch->max_ti_iu_len = it_iu_len; ++ rsp->buf_fmt = cpu_to_be16(SRP_BUF_FORMAT_DIRECT | ++ SRP_BUF_FORMAT_INDIRECT); ++ rsp->req_lim_delta = cpu_to_be32(ch->rq_size); ++ ch->req_lim = ch->rq_size; ++ ch->req_lim_delta = 0; ++ ++ /* create cm reply */ ++ rep_param->qp_num = ch->qp->qp_num; ++ rep_param->private_data = (void *)rsp; ++ rep_param->private_data_len = sizeof *rsp; ++ rep_param->rnr_retry_count = 7; ++ rep_param->flow_control = 1; ++ rep_param->failover_accepted = 0; ++ rep_param->srq = 1; ++ rep_param->responder_resources = 4; ++ rep_param->initiator_depth = 4; ++ ++ spin_lock_irq(&sdev->spinlock); ++ if (ch->state == CH_CONNECTING) ++ ret = ib_send_cm_rep(cm_id, rep_param); ++ else ++ ret = -ECONNABORTED; ++ spin_unlock_irq(&sdev->spinlock); ++ ++ switch (ret) { ++ case 0: ++ break; ++ case -ECONNABORTED: ++ goto out_keep_cm_id; ++ default: ++ rej->reason = cpu_to_be32(SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES); ++ PRINT_ERROR("sending SRP_LOGIN_REQ response failed" ++ " (error code = %d)", ret); ++ goto reject_and_release; ++ } ++ ++ goto out; ++ ++reject_and_release: ++ PRINT_INFO("Rejecting login with reason %#x", be32_to_cpu(rej->reason)); ++ rej->opcode = SRP_LOGIN_REJ; ++ rej->tag = req->tag; ++ rej->buf_fmt = cpu_to_be16(SRP_BUF_FORMAT_DIRECT | ++ SRP_BUF_FORMAT_INDIRECT); ++ ib_send_cm_rej(cm_id, IB_CM_REJ_CONSUMER_DEFINED, NULL, 0, ++ (void *)rej, sizeof *rej); ++ ++ srpt_close_ch(ch); ++out_keep_cm_id: ++ /* ++ * Tell the caller not to free cm_id since srpt_free_ch() will do that. ++ */ ++ ret = 0; ++ goto out; ++ ++unreg_ch: ++ scst_unregister_session(ch->scst_sess, true, NULL); ++ ++destroy_ib: ++ srpt_destroy_ch_ib(ch); ++ ++free_ring: ++ srpt_free_ioctx_ring((struct srpt_ioctx **)ch->ioctx_ring, ++ ch->sport->sdev, ch->rq_size, ++ ch->max_rsp_size, DMA_TO_DEVICE); ++ ++free_ch: ++ cm_id->context = NULL; ++ kfree(ch); ++ ++reject: ++ PRINT_INFO("Rejecting login with reason %#x", be32_to_cpu(rej->reason)); ++ rej->opcode = SRP_LOGIN_REJ; ++ rej->tag = req->tag; ++ rej->buf_fmt = cpu_to_be16(SRP_BUF_FORMAT_DIRECT | ++ SRP_BUF_FORMAT_INDIRECT); ++ ib_send_cm_rej(cm_id, IB_CM_REJ_CONSUMER_DEFINED, NULL, 0, ++ (void *)rej, sizeof *rej); ++ ++out: ++ kfree(rep_param); ++ kfree(rsp); ++ kfree(rej); ++ ++ return ret; ++} ++ ++static void srpt_cm_rej_recv(struct ib_cm_id *cm_id) ++{ ++ PRINT_INFO("Received InfiniBand REJ packet for cm_id %p.", cm_id); ++ srpt_drain_channel(cm_id); ++} ++ ++/** ++ * srpt_cm_rtu_recv() - Process IB CM RTU_RECEIVED and USER_ESTABLISHED events. ++ * ++ * An IB_CM_RTU_RECEIVED message indicates that the connection is established ++ * and that the recipient may begin transmitting (RTU = ready to use). ++ */ ++static void srpt_cm_rtu_recv(struct ib_cm_id *cm_id) ++{ ++ struct srpt_rdma_ch *ch; ++ int ret; ++ ++ ch = cm_id->context; ++ BUG_ON(!ch); ++ ++ if (srpt_test_and_set_ch_state(ch, CH_CONNECTING, CH_LIVE)) { ++ struct srpt_recv_ioctx *ioctx, *ioctx_tmp; ++ ++ ret = srpt_ch_qp_rts(ch, ch->qp); ++ ++ list_for_each_entry_safe(ioctx, ioctx_tmp, &ch->cmd_wait_list, ++ wait_list) { ++ list_del(&ioctx->wait_list); ++ srpt_handle_new_iu(ch, ioctx, NULL, ++ SCST_CONTEXT_THREAD); ++ } ++ if (ret) ++ srpt_close_ch(ch); ++ } ++} ++ ++static void srpt_cm_timewait_exit(struct ib_cm_id *cm_id) ++{ ++ PRINT_INFO("Received InfiniBand TimeWait exit for cm_id %p.", cm_id); ++ srpt_drain_channel(cm_id); ++} ++ ++static void srpt_cm_rep_error(struct ib_cm_id *cm_id) ++{ ++ PRINT_INFO("Received InfiniBand REP error for cm_id %p.", cm_id); ++ srpt_drain_channel(cm_id); ++} ++ ++/** ++ * srpt_cm_dreq_recv() - Process reception of a DREQ message. ++ */ ++static void srpt_cm_dreq_recv(struct ib_cm_id *cm_id) ++{ ++ struct srpt_rdma_ch *ch; ++ ++ ch = cm_id->context; ++ ++ switch (srpt_set_ch_state_to_disc(ch)) { ++ case CH_CONNECTING: ++ case CH_LIVE: ++ if (ib_send_cm_drep(ch->cm_id, NULL, 0) >= 0) ++ PRINT_INFO("Received DREQ and sent DREP for session %s", ++ ch->sess_name); ++ else ++ PRINT_ERROR("%s", "Sending DREP failed"); ++ break; ++ default: ++ WARN_ON(true); ++ break; ++ } ++} ++ ++/** ++ * srpt_cm_drep_recv() - Process reception of a DREP message. ++ */ ++static void srpt_cm_drep_recv(struct ib_cm_id *cm_id) ++{ ++ PRINT_INFO("Received InfiniBand DREP message for cm_id %p.", cm_id); ++ srpt_drain_channel(cm_id); ++} ++ ++/** ++ * srpt_cm_handler() - IB connection manager callback function. ++ * ++ * A non-zero return value will cause the caller destroy the CM ID. ++ * ++ * Note: srpt_cm_handler() must only return a non-zero value when transferring ++ * ownership of the cm_id to a channel if srpt_cm_req_recv() failed. Returning ++ * a non-zero value in any other case will trigger a race with the ++ * ib_destroy_cm_id() call in srpt_free_ch(). ++ */ ++static int srpt_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event) ++{ ++ int ret; ++ ++ BUG_ON(!cm_id->context); ++ ++ ret = 0; ++ switch (event->event) { ++ case IB_CM_REQ_RECEIVED: ++ ret = srpt_cm_req_recv(cm_id, &event->param.req_rcvd, ++ event->private_data); ++ break; ++ case IB_CM_REJ_RECEIVED: ++ srpt_cm_rej_recv(cm_id); ++ break; ++ case IB_CM_RTU_RECEIVED: ++ case IB_CM_USER_ESTABLISHED: ++ srpt_cm_rtu_recv(cm_id); ++ break; ++ case IB_CM_DREQ_RECEIVED: ++ srpt_cm_dreq_recv(cm_id); ++ break; ++ case IB_CM_DREP_RECEIVED: ++ srpt_cm_drep_recv(cm_id); ++ break; ++ case IB_CM_TIMEWAIT_EXIT: ++ srpt_cm_timewait_exit(cm_id); ++ break; ++ case IB_CM_REP_ERROR: ++ srpt_cm_rep_error(cm_id); ++ break; ++ case IB_CM_DREQ_ERROR: ++ PRINT_INFO("%s", "Received IB DREQ ERROR event."); ++ break; ++ case IB_CM_MRA_RECEIVED: ++ PRINT_INFO("%s", "Received IB MRA event"); ++ break; ++ default: ++ PRINT_ERROR("received unrecognized IB CM event %d", ++ event->event); ++ break; ++ } ++ ++ return ret; ++} ++ ++/** ++ * srpt_map_sg_to_ib_sge() - Map an SG list to an IB SGE list. ++ */ ++static int srpt_map_sg_to_ib_sge(struct srpt_rdma_ch *ch, ++ struct srpt_send_ioctx *ioctx, ++ struct scst_cmd *scmnd) ++{ ++ struct scatterlist *sg; ++ int sg_cnt; ++ scst_data_direction dir; ++ struct rdma_iu *riu; ++ struct srp_direct_buf *db; ++ dma_addr_t dma_addr; ++ struct ib_sge *sge_array, *sge; ++ u64 raddr; ++ u32 rsize; ++ u32 tsize; ++ u32 dma_len; ++ int count; ++ int i, j, k; ++ int max_sge, nsge; ++ ++ BUG_ON(!ch); ++ BUG_ON(!ioctx); ++ BUG_ON(!scmnd); ++ max_sge = ch->max_sge; ++ dir = scst_cmd_get_data_direction(scmnd); ++ BUG_ON(dir == SCST_DATA_NONE); ++ /* ++ * Cache 'dir' because it is needed in srpt_unmap_sg_to_ib_sge() ++ * and because scst_set_cmd_error_status() resets scmnd->data_direction. ++ */ ++ ioctx->dir = dir; ++ if (dir == SCST_DATA_WRITE) { ++ scst_cmd_get_write_fields(scmnd, &sg, &sg_cnt); ++ WARN_ON(!sg); ++ } else { ++ sg = scst_cmd_get_sg(scmnd); ++ sg_cnt = scst_cmd_get_sg_cnt(scmnd); ++ WARN_ON(!sg); ++ } ++ ioctx->sg = sg; ++ ioctx->sg_cnt = sg_cnt; ++ count = ib_dma_map_sg(ch->sport->sdev->device, sg, sg_cnt, ++ scst_to_tgt_dma_dir(dir)); ++ if (unlikely(!count)) ++ return -EBUSY; ++ ++ ioctx->mapped_sg_count = count; ++ ++ { ++ int size, nrdma; ++ ++ nrdma = (count + max_sge - 1) / max_sge + ioctx->n_rbuf; ++ nsge = count + ioctx->n_rbuf; ++ size = nrdma * sizeof(*riu) + nsge * sizeof(*sge); ++ ioctx->rdma_ius = size <= sizeof(ioctx->rdma_ius_buf) ? ++ ioctx->rdma_ius_buf : kmalloc(size, ++ scst_cmd_atomic(scmnd) ? GFP_ATOMIC : GFP_KERNEL); ++ if (!ioctx->rdma_ius) ++ goto free_mem; ++ ++ ioctx->n_rdma_ius = nrdma; ++ sge_array = (struct ib_sge *)(ioctx->rdma_ius + nrdma); ++ } ++ ++ db = ioctx->rbufs; ++ tsize = (dir == SCST_DATA_READ) ++ ? scst_cmd_get_adjusted_resp_data_len(scmnd) ++ : scst_cmd_get_bufflen(scmnd); ++ dma_len = sg_dma_len(&sg[0]); ++ riu = ioctx->rdma_ius; ++ sge = sge_array; ++ ++ /* ++ * For each remote desc - calculate the #ib_sge. ++ * If #ib_sge < SRPT_DEF_SG_PER_WQE per rdma operation then ++ * each remote desc rdma_iu is required a rdma wr; ++ * else ++ * we need to allocate extra rdma_iu to carry extra #ib_sge in ++ * another rdma wr ++ */ ++ for (i = 0, j = 0; ++ j < count && i < ioctx->n_rbuf && tsize > 0; ++i, ++riu, ++db) { ++ rsize = be32_to_cpu(db->len); ++ raddr = be64_to_cpu(db->va); ++ riu->raddr = raddr; ++ riu->rkey = be32_to_cpu(db->key); ++ riu->sge_cnt = 0; ++ riu->sge = sge; ++ ++ /* calculate how many sge required for this remote_buf */ ++ while (rsize > 0 && tsize > 0) { ++ ++ if (rsize >= dma_len) { ++ tsize -= dma_len; ++ rsize -= dma_len; ++ raddr += dma_len; ++ ++ if (tsize > 0) { ++ ++j; ++ if (j < count) ++ dma_len = sg_dma_len(&sg[j]); ++ } ++ } else { ++ tsize -= rsize; ++ dma_len -= rsize; ++ rsize = 0; ++ } ++ ++ ++riu->sge_cnt; ++ ++sge; ++ ++ if (rsize > 0 && riu->sge_cnt == max_sge) { ++ ++riu; ++ riu->raddr = raddr; ++ riu->rkey = be32_to_cpu(db->key); ++ riu->sge_cnt = 0; ++ riu->sge = sge; ++ } ++ } ++ } ++ ++ ioctx->n_rdma = riu - ioctx->rdma_ius; ++ EXTRACHECKS_WARN_ON(ioctx->n_rdma > ioctx->n_rdma_ius); ++ EXTRACHECKS_WARN_ON(sge - sge_array > nsge); ++ ++ db = ioctx->rbufs; ++ tsize = (dir == SCST_DATA_READ) ++ ? scst_cmd_get_adjusted_resp_data_len(scmnd) ++ : scst_cmd_get_bufflen(scmnd); ++ riu = ioctx->rdma_ius; ++ dma_len = sg_dma_len(&sg[0]); ++ dma_addr = sg_dma_address(&sg[0]); ++ ++ /* this second loop is really mapped sg_addres to rdma_iu->ib_sge */ ++ for (i = 0, j = 0; ++ j < count && i < ioctx->n_rbuf && tsize > 0; ++i, ++riu, ++db) { ++ rsize = be32_to_cpu(db->len); ++ sge = riu->sge; ++ k = 0; ++ ++ while (rsize > 0 && tsize > 0) { ++ sge->addr = dma_addr; ++ sge->lkey = ch->sport->sdev->mr->lkey; ++ ++ if (rsize >= dma_len) { ++ sge->length = ++ (tsize < dma_len) ? tsize : dma_len; ++ tsize -= dma_len; ++ rsize -= dma_len; ++ ++ if (tsize > 0) { ++ ++j; ++ if (j < count) { ++ dma_len = sg_dma_len(&sg[j]); ++ dma_addr = ++ sg_dma_address(&sg[j]); ++ } ++ } ++ } else { ++ sge->length = (tsize < rsize) ? tsize : rsize; ++ tsize -= rsize; ++ dma_len -= rsize; ++ dma_addr += rsize; ++ rsize = 0; ++ } ++ ++ ++k; ++ if (k == riu->sge_cnt && rsize > 0 && tsize > 0) { ++ ++riu; ++ sge = riu->sge; ++ k = 0; ++ } else if (rsize > 0 && tsize > 0) ++ ++sge; ++ } ++ } ++ ++ EXTRACHECKS_WARN_ON(riu - ioctx->rdma_ius != ioctx->n_rdma); ++ ++ return 0; ++ ++free_mem: ++ srpt_unmap_sg_to_ib_sge(ch, ioctx); ++ ++ return -ENOMEM; ++} ++ ++/** ++ * srpt_unmap_sg_to_ib_sge() - Unmap an IB SGE list. ++ */ ++static void srpt_unmap_sg_to_ib_sge(struct srpt_rdma_ch *ch, ++ struct srpt_send_ioctx *ioctx) ++{ ++ struct scatterlist *sg; ++ scst_data_direction dir; ++ ++ EXTRACHECKS_BUG_ON(!ch); ++ EXTRACHECKS_BUG_ON(!ioctx); ++ EXTRACHECKS_BUG_ON(ioctx->n_rdma && !ioctx->rdma_ius); ++ ++ if (ioctx->rdma_ius != (void *)ioctx->rdma_ius_buf) ++ kfree(ioctx->rdma_ius); ++ ioctx->rdma_ius = NULL; ++ ioctx->n_rdma = 0; ++ ++ if (ioctx->mapped_sg_count) { ++ EXTRACHECKS_BUG_ON(!ioctx->scmnd); ++ EXTRACHECKS_WARN_ON(ioctx ++ != scst_cmd_get_tgt_priv(ioctx->scmnd)); ++ sg = ioctx->sg; ++ EXTRACHECKS_WARN_ON(!sg); ++ dir = ioctx->dir; ++ EXTRACHECKS_BUG_ON(dir == SCST_DATA_NONE); ++ ib_dma_unmap_sg(ch->sport->sdev->device, sg, ioctx->sg_cnt, ++ scst_to_tgt_dma_dir(dir)); ++ ioctx->mapped_sg_count = 0; ++ } ++} ++ ++/** ++ * srpt_perform_rdmas() - Perform IB RDMA. ++ * ++ * Returns zero upon success or a negative number upon failure. ++ */ ++static int srpt_perform_rdmas(struct srpt_rdma_ch *ch, ++ struct srpt_send_ioctx *ioctx, ++ scst_data_direction dir) ++{ ++ struct ib_send_wr wr; ++ struct ib_send_wr *bad_wr; ++ struct rdma_iu *riu; ++ int i; ++ int ret; ++ int sq_wr_avail; ++ const int n_rdma = ioctx->n_rdma; ++ ++ if (dir == SCST_DATA_WRITE) { ++ ret = -ENOMEM; ++ sq_wr_avail = srpt_adjust_srq_wr_avail(ch, -n_rdma); ++ if (sq_wr_avail < 0) { ++ PRINT_WARNING("IB send queue full (needed %d)", ++ n_rdma); ++ goto out; ++ } ++ } ++ ++ ioctx->rdma_aborted = false; ++ ret = 0; ++ riu = ioctx->rdma_ius; ++ memset(&wr, 0, sizeof wr); ++ ++ for (i = 0; i < n_rdma; ++i, ++riu) { ++ if (dir == SCST_DATA_READ) { ++ wr.opcode = IB_WR_RDMA_WRITE; ++ wr.wr_id = encode_wr_id(i == n_rdma - 1 ? ++ SRPT_RDMA_WRITE_LAST : ++ SRPT_RDMA_MID, ++ ioctx->ioctx.index); ++ } else { ++ wr.opcode = IB_WR_RDMA_READ; ++ wr.wr_id = encode_wr_id(i == n_rdma - 1 ? ++ SRPT_RDMA_READ_LAST : ++ SRPT_RDMA_MID, ++ ioctx->ioctx.index); ++ } ++ wr.next = NULL; ++ wr.wr.rdma.remote_addr = riu->raddr; ++ wr.wr.rdma.rkey = riu->rkey; ++ wr.num_sge = riu->sge_cnt; ++ wr.sg_list = riu->sge; ++ ++ /* only get completion event for the last rdma wr */ ++ if (i == (n_rdma - 1) && dir == SCST_DATA_WRITE) ++ wr.send_flags = IB_SEND_SIGNALED; ++ ++ ret = ib_post_send(ch->qp, &wr, &bad_wr); ++ if (ret) ++ break; ++ } ++ ++ if (ret) ++ PRINT_ERROR("%s[%d]: ib_post_send() returned %d for %d/%d", ++ __func__, __LINE__, ret, i, n_rdma); ++ if (ret && i > 0) { ++ wr.num_sge = 0; ++ wr.wr_id = encode_wr_id(SRPT_RDMA_ABORT, ioctx->ioctx.index); ++ wr.send_flags = IB_SEND_SIGNALED; ++ while (ch->state == CH_LIVE && ++ ib_post_send(ch->qp, &wr, &bad_wr) != 0) { ++ PRINT_INFO("Trying to abort failed RDMA transfer [%d]", ++ ioctx->ioctx.index); ++ msleep(1000); ++ } ++ while (ch->state != CH_DRAINING && !ioctx->rdma_aborted) { ++ PRINT_INFO("Waiting until RDMA abort finished [%d]", ++ ioctx->ioctx.index); ++ msleep(1000); ++ } ++ PRINT_INFO("%s[%d]: done", __func__, __LINE__); ++ } ++ ++out: ++ if (unlikely(dir == SCST_DATA_WRITE && ret < 0)) ++ srpt_adjust_srq_wr_avail(ch, n_rdma); ++ return ret; ++} ++ ++/** ++ * srpt_xfer_data() - Start data transfer from initiator to target. ++ * ++ * Returns an SCST_TGT_RES_... status code. ++ * ++ * Note: Must not block. ++ */ ++static int srpt_xfer_data(struct srpt_rdma_ch *ch, ++ struct srpt_send_ioctx *ioctx, ++ struct scst_cmd *scmnd) ++{ ++ int ret; ++ ++ ret = srpt_map_sg_to_ib_sge(ch, ioctx, scmnd); ++ if (ret) { ++ PRINT_ERROR("%s[%d] ret=%d", __func__, __LINE__, ret); ++ ret = SCST_TGT_RES_QUEUE_FULL; ++ goto out; ++ } ++ ++ ret = srpt_perform_rdmas(ch, ioctx, scst_cmd_get_data_direction(scmnd)); ++ if (ret) { ++ if (ret == -EAGAIN || ret == -ENOMEM) { ++ PRINT_INFO("%s[%d] queue full -- ret=%d", ++ __func__, __LINE__, ret); ++ ret = SCST_TGT_RES_QUEUE_FULL; ++ } else { ++ PRINT_ERROR("%s[%d] fatal error -- ret=%d", ++ __func__, __LINE__, ret); ++ ret = SCST_TGT_RES_FATAL_ERROR; ++ } ++ goto out_unmap; ++ } ++ ++ ret = SCST_TGT_RES_SUCCESS; ++ ++out: ++ return ret; ++out_unmap: ++ srpt_unmap_sg_to_ib_sge(ch, ioctx); ++ goto out; ++} ++ ++/** ++ * srpt_pending_cmd_timeout() - SCST command HCA processing timeout callback. ++ * ++ * Called by the SCST core if no IB completion notification has been received ++ * within RDMA_COMPL_TIMEOUT_S seconds. ++ */ ++static void srpt_pending_cmd_timeout(struct scst_cmd *scmnd) ++{ ++ struct srpt_send_ioctx *ioctx; ++ enum srpt_command_state state; ++ ++ ioctx = scst_cmd_get_tgt_priv(scmnd); ++ BUG_ON(!ioctx); ++ ++ state = ioctx->state; ++ switch (state) { ++ case SRPT_STATE_NEW: ++ case SRPT_STATE_DATA_IN: ++ case SRPT_STATE_DONE: ++ /* ++ * srpt_pending_cmd_timeout() should never be invoked for ++ * commands in this state. ++ */ ++ PRINT_ERROR("Processing SCST command %p (SRPT state %d) took" ++ " too long -- aborting", scmnd, state); ++ break; ++ case SRPT_STATE_NEED_DATA: ++ case SRPT_STATE_CMD_RSP_SENT: ++ case SRPT_STATE_MGMT_RSP_SENT: ++ default: ++ PRINT_ERROR("Command %p: IB completion for idx %u has not" ++ " been received in time (SRPT command state %d)", ++ scmnd, ioctx->ioctx.index, state); ++ break; ++ } ++ ++ srpt_abort_cmd(ioctx, SCST_CONTEXT_SAME); ++} ++ ++/** ++ * srpt_rdy_to_xfer() - Transfers data from initiator to target. ++ * ++ * Called by the SCST core to transfer data from the initiator to the target ++ * (SCST_DATA_WRITE). Must not block. ++ */ ++static int srpt_rdy_to_xfer(struct scst_cmd *scmnd) ++{ ++ struct srpt_send_ioctx *ioctx; ++ enum srpt_command_state prev_cmd_state; ++ int ret; ++ ++ ioctx = scst_cmd_get_tgt_priv(scmnd); ++ prev_cmd_state = srpt_set_cmd_state(ioctx, SRPT_STATE_NEED_DATA); ++ ret = srpt_xfer_data(ioctx->ch, ioctx, scmnd); ++ if (unlikely(ret != SCST_TGT_RES_SUCCESS)) ++ srpt_set_cmd_state(ioctx, prev_cmd_state); ++ ++ return ret; ++} ++ ++/** ++ * srpt_xmit_response() - Transmits the response to a SCSI command. ++ * ++ * Callback function called by the SCST core. Must not block. Must ensure that ++ * scst_tgt_cmd_done() will get invoked when returning SCST_TGT_RES_SUCCESS. ++ */ ++static int srpt_xmit_response(struct scst_cmd *scmnd) ++{ ++ struct srpt_rdma_ch *ch; ++ struct srpt_send_ioctx *ioctx; ++ enum srpt_command_state state; ++ int ret; ++ scst_data_direction dir; ++ int resp_len; ++ ++ ret = SCST_TGT_RES_SUCCESS; ++ ++ ioctx = scst_cmd_get_tgt_priv(scmnd); ++ BUG_ON(!ioctx); ++ ++ ch = scst_sess_get_tgt_priv(scst_cmd_get_session(scmnd)); ++ BUG_ON(!ch); ++ ++ spin_lock(&ioctx->spinlock); ++ state = ioctx->state; ++ switch (state) { ++ case SRPT_STATE_NEW: ++ case SRPT_STATE_DATA_IN: ++ ioctx->state = SRPT_STATE_CMD_RSP_SENT; ++ break; ++ default: ++ WARN(true, "Unexpected command state %d", state); ++ break; ++ } ++ spin_unlock(&ioctx->spinlock); ++ ++ if (unlikely(scst_cmd_aborted(scmnd))) { ++ srpt_adjust_req_lim(ch, 0, 1); ++ srpt_abort_cmd(ioctx, SCST_CONTEXT_SAME); ++ goto out; ++ } ++ ++ EXTRACHECKS_BUG_ON(scst_cmd_atomic(scmnd)); ++ ++ dir = scst_cmd_get_data_direction(scmnd); ++ ++ /* For read commands, transfer the data to the initiator. */ ++ if (dir == SCST_DATA_READ ++ && scst_cmd_get_adjusted_resp_data_len(scmnd)) { ++ ret = srpt_xfer_data(ch, ioctx, scmnd); ++ if (unlikely(ret != SCST_TGT_RES_SUCCESS)) { ++ srpt_set_cmd_state(ioctx, state); ++ PRINT_WARNING("xfer_data failed for tag %llu" ++ " - %s", scst_cmd_get_tag(scmnd), ++ ret == SCST_TGT_RES_QUEUE_FULL ? ++ "retrying" : "failing"); ++ goto out; ++ } ++ } ++ ++ ioctx->req_lim_delta = srpt_inc_req_lim(ch); ++ resp_len = srpt_build_cmd_rsp(ch, ioctx, ++ scst_cmd_get_tag(scmnd), ++ scst_cmd_get_status(scmnd), ++ scst_cmd_get_sense_buffer(scmnd), ++ scst_cmd_get_sense_buffer_len(scmnd)); ++ ++ if (srpt_post_send(ch, ioctx, resp_len)) { ++ srpt_unmap_sg_to_ib_sge(ch, ioctx); ++ srpt_set_cmd_state(ioctx, state); ++ srpt_undo_inc_req_lim(ch, ioctx->req_lim_delta); ++ PRINT_WARNING("sending response failed for tag %llu - retrying", ++ scst_cmd_get_tag(scmnd)); ++ ret = SCST_TGT_RES_QUEUE_FULL; ++ } ++ ++out: ++ return ret; ++} ++ ++/** ++ * srpt_tsk_mgmt_done() - SCST callback function that sends back the response ++ * for a task management request. ++ * ++ * Must not block. ++ */ ++static void srpt_tsk_mgmt_done(struct scst_mgmt_cmd *mcmnd) ++{ ++ struct srpt_rdma_ch *ch; ++ struct srpt_send_ioctx *ioctx; ++ int rsp_len; ++ ++ ioctx = scst_mgmt_cmd_get_tgt_priv(mcmnd); ++ BUG_ON(!ioctx); ++ ++ ch = ioctx->ch; ++ BUG_ON(!ch); ++ ++ TRACE_DBG("%s: tsk_mgmt_done for tag= %lld status=%d", ++ __func__, ioctx->tsk_mgmt.tag, ++ scst_mgmt_cmd_get_status(mcmnd)); ++ ++ WARN_ON(in_irq()); ++ ++ srpt_set_cmd_state(ioctx, SRPT_STATE_MGMT_RSP_SENT); ++ WARN_ON(ioctx->state == SRPT_STATE_DONE); ++ ++ ioctx->req_lim_delta = srpt_inc_req_lim(ch); ++ rsp_len = srpt_build_tskmgmt_rsp(ch, ioctx, ++ scst_to_srp_tsk_mgmt_status( ++ scst_mgmt_cmd_get_status(mcmnd)), ++ ioctx->tsk_mgmt.tag); ++ /* ++ * Note: the srpt_post_send() call below sends the task management ++ * response asynchronously. It is possible that the SCST core has ++ * already freed the struct scst_mgmt_cmd structure before the ++ * response is sent. This is fine however. ++ */ ++ if (srpt_post_send(ch, ioctx, rsp_len)) { ++ PRINT_ERROR("%s", "Sending SRP_RSP response failed."); ++ srpt_put_send_ioctx(ioctx); ++ srpt_undo_inc_req_lim(ch, ioctx->req_lim_delta); ++ } ++} ++ ++/** ++ * srpt_get_initiator_port_transport_id() - SCST TransportID callback function. ++ * ++ * See also SPC-3, section 7.5.4.5, TransportID for initiator ports using SRP. ++ */ ++static int srpt_get_initiator_port_transport_id(struct scst_tgt *tgt, ++ struct scst_session *scst_sess, uint8_t **transport_id) ++{ ++ struct srpt_rdma_ch *ch; ++ struct spc_rdma_transport_id { ++ uint8_t protocol_identifier; ++ uint8_t reserved[7]; ++ uint8_t i_port_id[16]; ++ }; ++ struct spc_rdma_transport_id *tr_id; ++ int res; ++ ++ TRACE_ENTRY(); ++ ++ if (!scst_sess) { ++ res = SCSI_TRANSPORTID_PROTOCOLID_SRP; ++ goto out; ++ } ++ ++ ch = scst_sess_get_tgt_priv(scst_sess); ++ BUG_ON(!ch); ++ ++ BUILD_BUG_ON(sizeof(*tr_id) != 24); ++ ++ tr_id = kzalloc(sizeof(struct spc_rdma_transport_id), GFP_KERNEL); ++ if (!tr_id) { ++ PRINT_ERROR("%s", "Allocation of TransportID failed"); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ res = 0; ++ tr_id->protocol_identifier = SCSI_TRANSPORTID_PROTOCOLID_SRP; ++ memcpy(tr_id->i_port_id, ch->i_port_id, sizeof(ch->i_port_id)); ++ ++ *transport_id = (uint8_t *)tr_id; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/** ++ * srpt_on_free_cmd() - Free command-private data. ++ * ++ * Called by the SCST core. May be called in IRQ context. ++ */ ++static void srpt_on_free_cmd(struct scst_cmd *scmnd) ++{ ++} ++ ++static void srpt_refresh_port_work(struct work_struct *work) ++{ ++ struct srpt_port *sport = container_of(work, struct srpt_port, work); ++ ++ srpt_refresh_port(sport); ++} ++ ++/** ++ * srpt_detect() - Returns the number of target adapters. ++ * ++ * Callback function called by the SCST core. ++ */ ++static int srpt_detect(struct scst_tgt_template *tp) ++{ ++ int device_count; ++ ++ TRACE_ENTRY(); ++ ++ device_count = atomic_read(&srpt_device_count); ++ ++ TRACE_EXIT_RES(device_count); ++ ++ return device_count; ++} ++ ++static int srpt_ch_list_empty(struct srpt_device *sdev) ++{ ++ int res; ++ ++ spin_lock_irq(&sdev->spinlock); ++ res = list_empty(&sdev->rch_list); ++ spin_unlock_irq(&sdev->spinlock); ++ ++ return res; ++} ++ ++/** ++ * srpt_release_sdev() - Free channel resources associated with a target. ++ */ ++static int srpt_release_sdev(struct srpt_device *sdev) ++{ ++ struct srpt_rdma_ch *ch, *next_ch; ++ ++ TRACE_ENTRY(); ++ ++ WARN_ON_ONCE(irqs_disabled()); ++ BUG_ON(!sdev); ++ ++ spin_lock_irq(&sdev->spinlock); ++ list_for_each_entry_safe(ch, next_ch, &sdev->rch_list, list) ++ __srpt_close_ch(ch); ++ spin_unlock_irq(&sdev->spinlock); ++ ++ while (wait_event_timeout(sdev->ch_releaseQ, ++ srpt_ch_list_empty(sdev), 5 * HZ) <= 0) { ++ PRINT_INFO("%s: waiting for session unregistration ...", ++ sdev->device->name); ++ spin_lock_irq(&sdev->spinlock); ++ list_for_each_entry_safe(ch, next_ch, &sdev->rch_list, list) { ++ PRINT_INFO("%s: state %s; %d commands in progress", ++ ch->sess_name, get_ch_state_name(ch->state), ++ atomic_read(&ch->scst_sess->sess_cmd_count)); ++ } ++ spin_unlock_irq(&sdev->spinlock); ++ } ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++/** ++ * srpt_release() - Free the resources associated with an SCST target. ++ * ++ * Callback function called by the SCST core from scst_unregister_target(). ++ */ ++static int srpt_release(struct scst_tgt *scst_tgt) ++{ ++ struct srpt_device *sdev = scst_tgt_get_tgt_priv(scst_tgt); ++ ++ TRACE_ENTRY(); ++ ++ EXTRACHECKS_WARN_ON_ONCE(irqs_disabled()); ++ ++ BUG_ON(!scst_tgt); ++ if (WARN_ON(!sdev)) ++ return -ENODEV; ++ ++ srpt_release_sdev(sdev); ++ ++ scst_tgt_set_tgt_priv(scst_tgt, NULL); ++ ++ TRACE_EXIT(); ++ ++ return 0; ++} ++ ++/** ++ * srpt_get_scsi_transport_version() - Returns the SCSI transport version. ++ * This function is called from scst_pres.c, the code that implements ++ * persistent reservation support. ++ */ ++static uint16_t srpt_get_scsi_transport_version(struct scst_tgt *scst_tgt) ++{ ++ return 0x0940; /* SRP */ ++} ++ ++static ssize_t show_login_info(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_tgt *scst_tgt; ++ struct srpt_device *sdev; ++ struct srpt_port *sport; ++ int i; ++ int len; ++ ++ scst_tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ sdev = scst_tgt_get_tgt_priv(scst_tgt); ++ len = 0; ++ for (i = 0; i < sdev->device->phys_port_cnt; i++) { ++ sport = &sdev->port[i]; ++ ++ len += sprintf(buf + len, ++ "tid_ext=%016llx,ioc_guid=%016llx,pkey=ffff," ++ "dgid=%04x%04x%04x%04x%04x%04x%04x%04x," ++ "service_id=%016llx\n", ++ srpt_service_guid, ++ srpt_service_guid, ++ be16_to_cpu(((__be16 *) sport->gid.raw)[0]), ++ be16_to_cpu(((__be16 *) sport->gid.raw)[1]), ++ be16_to_cpu(((__be16 *) sport->gid.raw)[2]), ++ be16_to_cpu(((__be16 *) sport->gid.raw)[3]), ++ be16_to_cpu(((__be16 *) sport->gid.raw)[4]), ++ be16_to_cpu(((__be16 *) sport->gid.raw)[5]), ++ be16_to_cpu(((__be16 *) sport->gid.raw)[6]), ++ be16_to_cpu(((__be16 *) sport->gid.raw)[7]), ++ srpt_service_guid); ++ } ++ ++ return len; ++} ++ ++static struct kobj_attribute srpt_show_login_info_attr = ++ __ATTR(login_info, S_IRUGO, show_login_info, NULL); ++ ++static const struct attribute *srpt_tgt_attrs[] = { ++ &srpt_show_login_info_attr.attr, ++ NULL ++}; ++ ++static ssize_t show_req_lim(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_session *scst_sess; ++ struct srpt_rdma_ch *ch; ++ ++ scst_sess = container_of(kobj, struct scst_session, sess_kobj); ++ ch = scst_sess_get_tgt_priv(scst_sess); ++ if (!ch) ++ return -ENOENT; ++ return sprintf(buf, "%d\n", ch->req_lim); ++} ++ ++static ssize_t show_req_lim_delta(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_session *scst_sess; ++ struct srpt_rdma_ch *ch; ++ ++ scst_sess = container_of(kobj, struct scst_session, sess_kobj); ++ ch = scst_sess_get_tgt_priv(scst_sess); ++ if (!ch) ++ return -ENOENT; ++ return sprintf(buf, "%d\n", ch->req_lim_delta); ++} ++ ++static ssize_t show_ch_state(struct kobject *kobj, struct kobj_attribute *attr, ++ char *buf) ++{ ++ struct scst_session *scst_sess; ++ struct srpt_rdma_ch *ch; ++ ++ scst_sess = container_of(kobj, struct scst_session, sess_kobj); ++ ch = scst_sess_get_tgt_priv(scst_sess); ++ if (!ch) ++ return -ENOENT; ++ return sprintf(buf, "%s\n", get_ch_state_name(ch->state)); ++} ++ ++static const struct kobj_attribute srpt_req_lim_attr = ++ __ATTR(req_lim, S_IRUGO, show_req_lim, NULL); ++static const struct kobj_attribute srpt_req_lim_delta_attr = ++ __ATTR(req_lim_delta, S_IRUGO, show_req_lim_delta, NULL); ++static const struct kobj_attribute srpt_ch_state_attr = ++ __ATTR(ch_state, S_IRUGO, show_ch_state, NULL); ++ ++static const struct attribute *srpt_sess_attrs[] = { ++ &srpt_req_lim_attr.attr, ++ &srpt_req_lim_delta_attr.attr, ++ &srpt_ch_state_attr.attr, ++ NULL ++}; ++ ++/* SCST target template for the SRP target implementation. */ ++static struct scst_tgt_template srpt_template = { ++ .name = DRV_NAME, ++ .sg_tablesize = SRPT_DEF_SG_TABLESIZE, ++ .max_hw_pending_time = RDMA_COMPL_TIMEOUT_S, ++ .enable_target = srpt_enable_target, ++ .is_target_enabled = srpt_is_target_enabled, ++ .tgt_attrs = srpt_tgt_attrs, ++ .sess_attrs = srpt_sess_attrs, ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ .default_trace_flags = DEFAULT_SRPT_TRACE_FLAGS, ++ .trace_flags = &trace_flag, ++#endif ++ .detect = srpt_detect, ++ .release = srpt_release, ++ .xmit_response = srpt_xmit_response, ++ .rdy_to_xfer = srpt_rdy_to_xfer, ++ .on_hw_pending_cmd_timeout = srpt_pending_cmd_timeout, ++ .on_free_cmd = srpt_on_free_cmd, ++ .task_mgmt_fn_done = srpt_tsk_mgmt_done, ++ .get_initiator_port_transport_id = srpt_get_initiator_port_transport_id, ++ .get_scsi_transport_version = srpt_get_scsi_transport_version, ++}; ++ ++/** ++ * srpt_add_one() - Infiniband device addition callback function. ++ */ ++static void srpt_add_one(struct ib_device *device) ++{ ++ struct srpt_device *sdev; ++ struct srpt_port *sport; ++ struct ib_srq_init_attr srq_attr; ++ char tgt_name[24]; ++ int i, ret; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("device = %p, device->dma_ops = %p", device, device->dma_ops); ++ ++ sdev = kzalloc(sizeof *sdev, GFP_KERNEL); ++ if (!sdev) ++ goto err; ++ ++ sdev->device = device; ++ INIT_LIST_HEAD(&sdev->rch_list); ++ init_waitqueue_head(&sdev->ch_releaseQ); ++ spin_lock_init(&sdev->spinlock); ++ ++ if (use_node_guid_in_target_name) { ++ snprintf(tgt_name, sizeof(tgt_name), "%04x:%04x:%04x:%04x", ++ be16_to_cpu(((__be16 *)&device->node_guid)[0]), ++ be16_to_cpu(((__be16 *)&device->node_guid)[1]), ++ be16_to_cpu(((__be16 *)&device->node_guid)[2]), ++ be16_to_cpu(((__be16 *)&device->node_guid)[3])); ++ sdev->scst_tgt = scst_register_target(&srpt_template, tgt_name); ++ } else ++ sdev->scst_tgt = scst_register_target(&srpt_template, NULL); ++ if (!sdev->scst_tgt) { ++ PRINT_ERROR("SCST registration failed for %s.", ++ sdev->device->name); ++ goto free_dev; ++ } ++ ++ scst_tgt_set_tgt_priv(sdev->scst_tgt, sdev); ++ ++ ret = ib_query_device(device, &sdev->dev_attr); ++ if (ret) { ++ PRINT_ERROR("ib_query_device() failed: %d", ret); ++ goto unregister_tgt; ++ } ++ ++ sdev->pd = ib_alloc_pd(device); ++ if (IS_ERR(sdev->pd)) { ++ PRINT_ERROR("ib_alloc_pd() failed: %ld", PTR_ERR(sdev->pd)); ++ goto unregister_tgt; ++ } ++ ++ sdev->mr = ib_get_dma_mr(sdev->pd, IB_ACCESS_LOCAL_WRITE); ++ if (IS_ERR(sdev->mr)) { ++ PRINT_ERROR("ib_get_dma_mr() failed: %ld", PTR_ERR(sdev->mr)); ++ goto err_pd; ++ } ++ ++ sdev->srq_size = min(max(srpt_srq_size, MIN_SRPT_SRQ_SIZE), ++ sdev->dev_attr.max_srq_wr); ++ ++ memset(&srq_attr, 0, sizeof(srq_attr)); ++ srq_attr.event_handler = srpt_srq_event; ++ srq_attr.srq_context = (void *)sdev; ++ srq_attr.attr.max_wr = sdev->srq_size; ++ srq_attr.attr.max_sge = 1; ++ srq_attr.attr.srq_limit = 0; ++ srq_attr.srq_type = IB_SRQT_BASIC; ++ ++ sdev->srq = ib_create_srq(sdev->pd, &srq_attr); ++ if (IS_ERR(sdev->srq)) { ++ PRINT_ERROR("ib_create_srq() failed: %ld", PTR_ERR(sdev->srq)); ++ goto err_mr; ++ } ++ ++ TRACE_DBG("%s: create SRQ #wr= %d max_allow=%d dev= %s", __func__, ++ sdev->srq_size, sdev->dev_attr.max_srq_wr, device->name); ++ ++ if (!srpt_service_guid) ++ srpt_service_guid = be64_to_cpu(device->node_guid) & ++ ~be64_to_cpu(IB_SERVICE_ID_AGN_MASK); ++ ++ sdev->cm_id = ib_create_cm_id(device, srpt_cm_handler, sdev); ++ if (IS_ERR(sdev->cm_id)) { ++ PRINT_ERROR("ib_create_cm_id() failed: %ld", ++ PTR_ERR(sdev->cm_id)); ++ goto err_srq; ++ } ++ ++ /* print out target login information */ ++ TRACE_DBG("Target login info: id_ext=%016llx," ++ "ioc_guid=%016llx,pkey=ffff,service_id=%016llx", ++ srpt_service_guid, srpt_service_guid, srpt_service_guid); ++ ++ /* ++ * We do not have a consistent service_id (ie. also id_ext of target_id) ++ * to identify this target. We currently use the guid of the first HCA ++ * in the system as service_id; therefore, the target_id will change ++ * if this HCA is gone bad and replaced by different HCA ++ */ ++ ret = ib_cm_listen(sdev->cm_id, cpu_to_be64(srpt_service_guid), 0, ++ NULL); ++ if (ret) { ++ PRINT_ERROR("ib_cm_listen() failed: %d (cm_id state = %d)", ++ ret, sdev->cm_id->state); ++ goto err_cm; ++ } ++ ++ INIT_IB_EVENT_HANDLER(&sdev->event_handler, sdev->device, ++ srpt_event_handler); ++ ret = ib_register_event_handler(&sdev->event_handler); ++ if (ret) { ++ PRINT_ERROR("ib_register_event_handler() failed: %d", ret); ++ goto err_cm; ++ } ++ ++ sdev->ioctx_ring = (struct srpt_recv_ioctx **) ++ srpt_alloc_ioctx_ring(sdev, sdev->srq_size, ++ sizeof(*sdev->ioctx_ring[0]), ++ srp_max_req_size, DMA_FROM_DEVICE); ++ if (!sdev->ioctx_ring) { ++ PRINT_ERROR("%s", "srpt_alloc_ioctx_ring() failed"); ++ goto err_event; ++ } ++ ++ for (i = 0; i < sdev->srq_size; ++i) ++ srpt_post_recv(sdev, sdev->ioctx_ring[i]); ++ ++ WARN_ON(sdev->device->phys_port_cnt > ARRAY_SIZE(sdev->port)); ++ ++ for (i = 1; i <= sdev->device->phys_port_cnt; i++) { ++ sport = &sdev->port[i - 1]; ++ sport->sdev = sdev; ++ sport->port = i; ++ INIT_WORK(&sport->work, srpt_refresh_port_work); ++ if (srpt_refresh_port(sport)) { ++ PRINT_ERROR("MAD registration failed for %s-%d.", ++ sdev->device->name, i); ++ goto err_ring; ++ } ++ } ++ ++ atomic_inc(&srpt_device_count); ++out: ++ ib_set_client_data(device, &srpt_client, sdev); ++ ++ TRACE_EXIT(); ++ return; ++ ++err_ring: ++ srpt_free_ioctx_ring((struct srpt_ioctx **)sdev->ioctx_ring, sdev, ++ sdev->srq_size, srp_max_req_size, ++ DMA_FROM_DEVICE); ++err_event: ++ ib_unregister_event_handler(&sdev->event_handler); ++err_cm: ++ ib_destroy_cm_id(sdev->cm_id); ++err_srq: ++ ib_destroy_srq(sdev->srq); ++err_mr: ++ ib_dereg_mr(sdev->mr); ++err_pd: ++ ib_dealloc_pd(sdev->pd); ++unregister_tgt: ++ scst_unregister_target(sdev->scst_tgt); ++free_dev: ++ kfree(sdev); ++err: ++ sdev = NULL; ++ PRINT_INFO("%s(%s) failed.", __func__, device->name); ++ goto out; ++} ++ ++/** ++ * srpt_remove_one() - InfiniBand device removal callback function. ++ */ ++static void srpt_remove_one(struct ib_device *device) ++{ ++ int i; ++ struct srpt_device *sdev; ++ ++ TRACE_ENTRY(); ++ ++ sdev = ib_get_client_data(device, &srpt_client); ++ if (!sdev) { ++ PRINT_INFO("%s(%s): nothing to do.", __func__, device->name); ++ return; ++ } ++ ++ srpt_unregister_mad_agent(sdev); ++ ++ ib_unregister_event_handler(&sdev->event_handler); ++ ++ /* Cancel any work queued by the just unregistered IB event handler. */ ++ for (i = 0; i < sdev->device->phys_port_cnt; i++) ++ cancel_work_sync(&sdev->port[i].work); ++ ++ ib_destroy_cm_id(sdev->cm_id); ++ ++ /* ++ * Unregistering an SCST target must happen after destroying sdev->cm_id ++ * such that no new SRP_LOGIN_REQ information units can arrive while ++ * destroying the SCST target. ++ */ ++ scst_unregister_target(sdev->scst_tgt); ++ sdev->scst_tgt = NULL; ++ ++ ib_destroy_srq(sdev->srq); ++ ib_dereg_mr(sdev->mr); ++ ib_dealloc_pd(sdev->pd); ++ ++ srpt_free_ioctx_ring((struct srpt_ioctx **)sdev->ioctx_ring, sdev, ++ sdev->srq_size, srp_max_req_size, DMA_FROM_DEVICE); ++ sdev->ioctx_ring = NULL; ++ kfree(sdev); ++ ++ TRACE_EXIT(); ++} ++ ++static struct ib_client srpt_client = { ++ .name = DRV_NAME, ++ .add = srpt_add_one, ++ .remove = srpt_remove_one ++}; ++ ++/** ++ * srpt_init_module() - Kernel module initialization. ++ * ++ * Note: Since ib_register_client() registers callback functions, and since at ++ * least one of these callback functions (srpt_add_one()) calls SCST functions, ++ * the SCST target template must be registered before ib_register_client() is ++ * called. ++ */ ++static int __init srpt_init_module(void) ++{ ++ int ret; ++ ++ ret = -EINVAL; ++ if (srp_max_req_size < MIN_MAX_REQ_SIZE) { ++ PRINT_ERROR("invalid value %d for kernel module parameter" ++ " srp_max_req_size -- must be at least %d.", ++ srp_max_req_size, ++ MIN_MAX_REQ_SIZE); ++ goto out; ++ } ++ ++ if (srp_max_rsp_size < MIN_MAX_RSP_SIZE) { ++ PRINT_ERROR("invalid value %d for kernel module parameter" ++ " srp_max_rsp_size -- must be at least %d.", ++ srp_max_rsp_size, ++ MIN_MAX_RSP_SIZE); ++ goto out; ++ } ++ ++ if (srpt_srq_size < MIN_SRPT_SRQ_SIZE ++ || srpt_srq_size > MAX_SRPT_SRQ_SIZE) { ++ PRINT_ERROR("invalid value %d for kernel module parameter" ++ " srpt_srq_size -- must be in the range [%d..%d].", ++ srpt_srq_size, MIN_SRPT_SRQ_SIZE, ++ MAX_SRPT_SRQ_SIZE); ++ goto out; ++ } ++ ++ if (srpt_sq_size < MIN_SRPT_SQ_SIZE) { ++ PRINT_ERROR("invalid value %d for kernel module parameter" ++ " srpt_sq_size -- must be at least %d.", ++ srpt_srq_size, MIN_SRPT_SQ_SIZE); ++ goto out; ++ } ++ ++ if (!use_node_guid_in_target_name) ++ PRINT_WARNING("%s", "Usage of HCA numbers as SCST target names " ++ "is deprecated and will be removed in one of the next " ++ "versions. It is strongly recommended to set " ++ "use_node_guid_in_target_name parameter in 1 and " ++ "update your SCST config file accordingly to use HCAs " ++ "GUIDs."); ++ ++ ret = scst_register_target_template(&srpt_template); ++ if (ret < 0) { ++ PRINT_ERROR("%s", "couldn't register with scst"); ++ ret = -ENODEV; ++ goto out; ++ } ++ ++ ret = ib_register_client(&srpt_client); ++ if (ret) { ++ PRINT_ERROR("%s", "couldn't register IB client"); ++ goto out_unregister_target; ++ } ++ ++ return 0; ++ ++out_unregister_target: ++ scst_unregister_target_template(&srpt_template); ++out: ++ return ret; ++} ++ ++static void __exit srpt_cleanup_module(void) ++{ ++ TRACE_ENTRY(); ++ ++ ib_unregister_client(&srpt_client); ++ scst_unregister_target_template(&srpt_template); ++ ++ TRACE_EXIT(); ++} ++ ++module_init(srpt_init_module); ++module_exit(srpt_cleanup_module); ++ ++/* ++ * Local variables: ++ * c-basic-offset: 8 ++ * indent-tabs-mode: t ++ * End: ++ */ +diff -uprN orig/linux-3.2/drivers/scst/srpt/ib_srpt.h linux-3.2/drivers/scst/srpt/ib_srpt.h +--- orig/linux-3.2/drivers/scst/srpt/ib_srpt.h ++++ linux-3.2/drivers/scst/srpt/ib_srpt.h +@@ -0,0 +1,407 @@ ++/* ++ * Copyright (c) 2006 - 2009 Mellanox Technology Inc. All rights reserved. ++ * Copyright (C) 2009 - 2011 Bart Van Assche <bvanassche@acm.org>. ++ * ++ * This software is available to you under a choice of one of two ++ * licenses. You may choose to be licensed under the terms of the GNU ++ * General Public License (GPL) Version 2, available from the file ++ * COPYING in the main directory of this source tree, or the ++ * OpenIB.org BSD license below: ++ * ++ * Redistribution and use in source and binary forms, with or ++ * without modification, are permitted provided that the following ++ * conditions are met: ++ * ++ * - Redistributions of source code must retain the above ++ * copyright notice, this list of conditions and the following ++ * disclaimer. ++ * ++ * - Redistributions in binary form must reproduce the above ++ * copyright notice, this list of conditions and the following ++ * disclaimer in the documentation and/or other materials ++ * provided with the distribution. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ++ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ++ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS ++ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ++ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE ++ * SOFTWARE. ++ * ++ */ ++ ++#ifndef IB_SRPT_H ++#define IB_SRPT_H ++ ++#include <linux/types.h> ++#include <linux/list.h> ++#include <linux/wait.h> ++#include <rdma/ib_verbs.h> ++#include <rdma/ib_sa.h> ++#include <rdma/ib_cm.h> ++#include <scsi/srp.h> ++#include <scst/scst.h> ++#include "ib_dm_mad.h" ++ ++/* ++ * The prefix the ServiceName field must start with in the device management ++ * ServiceEntries attribute pair. See also the SRP specification. ++ */ ++#define SRP_SERVICE_NAME_PREFIX "SRP.T10:" ++ ++enum { ++ /* ++ * SRP IOControllerProfile attributes for SRP target ports that have ++ * not been defined in <scsi/srp.h>. Source: section B.7, table B.7 ++ * in the SRP specification. ++ */ ++ SRP_PROTOCOL = 0x0108, ++ SRP_PROTOCOL_VERSION = 0x0001, ++ SRP_IO_SUBCLASS = 0x609e, ++ SRP_SEND_TO_IOC = 0x01, ++ SRP_SEND_FROM_IOC = 0x02, ++ SRP_RDMA_READ_FROM_IOC = 0x08, ++ SRP_RDMA_WRITE_FROM_IOC = 0x20, ++ ++ /* ++ * srp_login_cmd.req_flags bitmasks. See also table 9 in the SRP r16a ++ * document. ++ */ ++ SRP_MTCH_ACTION = 0x03, /* MULTI-CHANNEL ACTION */ ++ SRP_LOSOLNT = 0x10, /* logout solicited notification */ ++ SRP_CRSOLNT = 0x20, /* credit request solicited notification */ ++ SRP_AESOLNT = 0x40, /* asynchronous event solicited notification */ ++ ++ /* ++ * srp_cmd.sol_nt / srp_tsk_mgmt.sol_not bitmasks. See also tables ++ * 18 and 20 in the SRP specification. ++ */ ++ SRP_SCSOLNT = 0x02, /* SCSOLNT = successful solicited notification */ ++ SRP_UCSOLNT = 0x04, /* UCSOLNT = unsuccessful solicited notification */ ++ ++ /* ++ * srp_rsp.sol_not / srp_t_logout.sol_not bitmasks. See also tables ++ * 16 and 22 in the SRP specification. ++ */ ++ SRP_SOLNT = 0x01, /* SOLNT = solicited notification */ ++ ++ /* See also table 24 in the SRP specification. */ ++ SRP_TSK_MGMT_SUCCESS = 0x00, ++ SRP_TSK_MGMT_FUNC_NOT_SUPP = 0x04, ++ SRP_TSK_MGMT_FAILED = 0x05, ++ ++ /* See also table 21 in the SRP specification. */ ++ SRP_CMD_SIMPLE_Q = 0x0, ++ SRP_CMD_HEAD_OF_Q = 0x1, ++ SRP_CMD_ORDERED_Q = 0x2, ++ SRP_CMD_ACA = 0x4, ++ ++ SRP_LOGIN_RSP_MULTICHAN_NO_CHAN = 0x0, ++ SRP_LOGIN_RSP_MULTICHAN_TERMINATED = 0x1, ++ SRP_LOGIN_RSP_MULTICHAN_MAINTAINED = 0x2, ++ ++ SRPT_DEF_SG_TABLESIZE = 128, ++ ++ MIN_SRPT_SQ_SIZE = 16, ++ DEF_SRPT_SQ_SIZE = 4096, ++ SRPT_RQ_SIZE = 128, ++ MIN_SRPT_SRQ_SIZE = 4, ++ DEFAULT_SRPT_SRQ_SIZE = 4095, ++ MAX_SRPT_SRQ_SIZE = 65535, ++ ++ MIN_MAX_REQ_SIZE = 996, ++ DEFAULT_MAX_REQ_SIZE ++ = sizeof(struct srp_cmd)/*48*/ ++ + sizeof(struct srp_indirect_buf)/*20*/ ++ + 255 * sizeof(struct srp_direct_buf)/*16*/, ++ ++ MIN_MAX_RSP_SIZE = sizeof(struct srp_rsp)/*36*/ + 4, ++ DEFAULT_MAX_RSP_SIZE = 256, /* leaves 220 bytes for sense data */ ++ ++ DEFAULT_MAX_RDMA_SIZE = 65536, ++ ++ RDMA_COMPL_TIMEOUT_S = 80, ++}; ++ ++enum srpt_opcode { ++ SRPT_RECV, ++ SRPT_SEND, ++ SRPT_RDMA_MID, ++ SRPT_RDMA_ABORT, ++ SRPT_RDMA_READ_LAST, ++ SRPT_RDMA_WRITE_LAST, ++}; ++ ++static inline u64 encode_wr_id(enum srpt_opcode opcode, u32 idx) ++{ ++ return ((u64)opcode << 32) | idx; ++} ++ ++static inline enum srpt_opcode opcode_from_wr_id(u64 wr_id) ++{ ++ return wr_id >> 32; ++} ++ ++static inline u32 idx_from_wr_id(u64 wr_id) ++{ ++ return (u32)wr_id; ++} ++ ++struct rdma_iu { ++ u64 raddr; ++ u32 rkey; ++ struct ib_sge *sge; ++ u32 sge_cnt; ++}; ++ ++/** ++ * enum srpt_command_state - SCSI command state managed by SRPT. ++ * @SRPT_STATE_NEW: New command arrived and is being processed. ++ * @SRPT_STATE_NEED_DATA: Processing a write or bidir command and waiting ++ * for data arrival. ++ * @SRPT_STATE_DATA_IN: Data for the write or bidir command arrived and is ++ * being processed. ++ * @SRPT_STATE_CMD_RSP_SENT: SRP_RSP for SRP_CMD has been sent. ++ * @SRPT_STATE_MGMT: Processing a SCSI task management command. ++ * @SRPT_STATE_MGMT_RSP_SENT: SRP_RSP for SRP_TSK_MGMT has been sent. ++ * @SRPT_STATE_DONE: Command processing finished successfully, command ++ * processing has been aborted or command processing ++ * failed. ++ */ ++enum srpt_command_state { ++ SRPT_STATE_NEW = 0, ++ SRPT_STATE_NEED_DATA = 1, ++ SRPT_STATE_DATA_IN = 2, ++ SRPT_STATE_CMD_RSP_SENT = 3, ++ SRPT_STATE_MGMT = 4, ++ SRPT_STATE_MGMT_RSP_SENT = 5, ++ SRPT_STATE_DONE = 6, ++}; ++ ++/** ++ * struct srpt_ioctx - Shared SRPT I/O context information. ++ * @buf: Pointer to the buffer. ++ * @dma: DMA address of the buffer. ++ * @index: Index of the I/O context in its ioctx_ring array. ++ */ ++struct srpt_ioctx { ++ void *buf; ++ dma_addr_t dma; ++ uint32_t index; ++}; ++ ++/** ++ * struct srpt_recv_ioctx - SRPT receive I/O context. ++ * @ioctx: See above. ++ * @wait_list: Node for insertion in srpt_rdma_ch.cmd_wait_list. ++ */ ++struct srpt_recv_ioctx { ++ struct srpt_ioctx ioctx; ++ struct list_head wait_list; ++}; ++ ++/** ++ * struct srpt_tsk_mgmt - SCST management command context information. ++ * @tag: SCSI tag of the management command. ++ */ ++struct srpt_tsk_mgmt { ++ u64 tag; ++}; ++ ++/** ++ * struct srpt_send_ioctx - SRPT send I/O context. ++ * @ioctx: See above. ++ * @ch: Channel pointer. ++ * @rdma_ius: Array with information about the RDMA mapping. ++ * @rbufs: Pointer to SRP data buffer array. ++ * @single_rbuf: SRP data buffer if the command has only a single buffer. ++ * @sg: Pointer to sg-list associated with this I/O context. ++ * @spinlock: Protects 'state'. ++ * @state: I/O context state. ++ * @rdma_aborted: If initiating a multipart RDMA transfer failed, whether ++ * the already initiated transfers have finished. ++ * @scmnd: SCST command data structure. ++ * @dir: ++ * @free_list: Node in srpt_rdma_ch.free_list. ++ * @sg_cnt: SG-list size. ++ * @mapped_sg_count: ib_dma_map_sg() return value. ++ * @n_rdma_ius: Size of the rdma_ius array. ++ * @n_rdma: Number of elements used of the rdma_ius array. ++ * @n_rbuf: Number of data buffers in the received SRP command. ++ * @req_lim_delta: Value of the req_lim_delta value field in the latest ++ * SRP response sent. ++ * @tsk_mgmt: ++ */ ++struct srpt_send_ioctx { ++ struct srpt_ioctx ioctx; ++ struct srpt_rdma_ch *ch; ++ struct rdma_iu *rdma_ius; ++ struct srp_direct_buf *rbufs; ++ struct srp_direct_buf single_rbuf; ++ struct scatterlist *sg; ++ struct list_head free_list; ++ spinlock_t spinlock; ++ enum srpt_command_state state; ++ bool rdma_aborted; ++ struct scst_cmd *scmnd; ++ scst_data_direction dir; ++ int sg_cnt; ++ int mapped_sg_count; ++ u16 n_rdma_ius; ++ u8 n_rdma; ++ u8 n_rbuf; ++ int req_lim_delta; ++ struct srpt_tsk_mgmt tsk_mgmt; ++ u8 rdma_ius_buf[2 * sizeof(struct rdma_iu) ++ + 2 * sizeof(struct ib_sge)] ++ __aligned(sizeof(uint64_t)); ++}; ++ ++/** ++ * enum rdma_ch_state - SRP channel state. ++ * @CH_CONNECTING: QP is in RTR state; waiting for RTU. ++ * @CH_LIVE: QP is in RTS state. ++ * @CH_DISCONNECTING: DREQ has been received and waiting for DREP or DREQ has ++ * been sent and waiting for DREP or channel is being closed ++ * for another reason. ++ * @CH_DRAINING: QP is in ERR state. ++ * @CH_FREEING: QP resources are being freed. ++ */ ++enum rdma_ch_state { ++ CH_CONNECTING, ++ CH_LIVE, ++ CH_DISCONNECTING, ++ CH_DRAINING, ++ CH_FREEING, ++}; ++ ++/** ++ * struct srpt_rdma_ch - RDMA channel. ++ * @thread: Kernel thread that processes the IB queues associated with ++ * the channel. ++ * @cm_id: IB CM ID associated with the channel. ++ * @qp: IB queue pair used for communicating over this channel. ++ * @cq: IB completion queue for this channel. ++ * @rq_size: IB receive queue size. ++ * @max_sge: Maximum length of RDMA scatter list. ++ * @sq_wr_avail: number of work requests available in the send queue. ++ * @sport: pointer to the information of the HCA port used by this ++ * channel. ++ * @i_port_id: 128-bit initiator port identifier copied from SRP_LOGIN_REQ. ++ * @t_port_id: 128-bit target port identifier copied from SRP_LOGIN_REQ. ++ * @max_ti_iu_len: maximum target-to-initiator information unit length. ++ * @req_lim: request limit: maximum number of requests that may be sent ++ * by the initiator without having received a response. ++ * @req_lim_delta: One less than the req_lim_delta value that will be included ++ * in the next reply sent to the initiator. See also the SRP ++ * credit algorithm in the SRP spec. ++ * @spinlock: Protects free_list. ++ * @free_list: Head of list with free send I/O contexts. ++ * @ioctx_ring: ++ * @wc: ++ * @state: channel state. See also enum rdma_ch_state. ++ * @list: node for insertion in the srpt_device.rch_list list. ++ * @cmd_wait_list: list of SCST commands that arrived before the RTU event. This ++ * list contains struct srpt_ioctx elements and is protected ++ * against concurrent modification by the cm_id spinlock. ++ * @scst_sess: SCST session information associated with this SRP channel. ++ * @sess_name: SCST session name. ++ */ ++struct srpt_rdma_ch { ++ struct task_struct *thread; ++ struct ib_cm_id *cm_id; ++ struct ib_qp *qp; ++ struct ib_cq *cq; ++ int rq_size; ++ int max_sge; ++ int max_rsp_size; ++ int sq_wr_avail; ++ struct srpt_port *sport; ++ u8 i_port_id[16]; ++ u8 t_port_id[16]; ++ int max_ti_iu_len; ++ int req_lim; ++ int req_lim_delta; ++ spinlock_t spinlock; ++ struct list_head free_list; ++ struct srpt_send_ioctx **ioctx_ring; ++ struct ib_wc wc[16]; ++ enum rdma_ch_state state; ++ wait_queue_head_t state_wq; ++ struct list_head list; ++ struct list_head cmd_wait_list; ++ struct completion finished_processing_completions; ++ bool last_wqe_received; ++ ++ struct scst_session *scst_sess; ++ u8 sess_name[36]; ++}; ++ ++/** ++ * struct srpt_port - Information associated by SRPT with a single IB port. ++ * @sdev: backpointer to the HCA information. ++ * @mad_agent: per-port management datagram processing information. ++ * @port: one-based port number. ++ * @sm_lid: cached value of the port's sm_lid. ++ * @lid: cached value of the port's lid. ++ * @gid: cached value of the port's gid. ++ * @work: work structure for refreshing the aforementioned cached values. ++ */ ++struct srpt_port { ++ struct srpt_device *sdev; ++ struct ib_mad_agent *mad_agent; ++ u8 port; ++ u16 sm_lid; ++ u16 lid; ++ union ib_gid gid; ++ struct work_struct work; ++}; ++ ++/** ++ * struct srpt_device - Information associated by SRPT with a single HCA. ++ * @device: Backpointer to the struct ib_device managed by the IB core. ++ * @pd: IB protection domain. ++ * @mr: L_Key (local key) with write access to all local memory. ++ * @srq: Per-HCA SRQ (shared receive queue). ++ * @cm_id: Connection identifier. ++ * @dev_attr: Attributes of the InfiniBand device as obtained during the ++ * ib_client.add() callback. ++ * @srq_size: SRQ size. ++ * @ioctx_ring: Per-HCA SRQ. ++ * @rch_list: Per-device channel list -- see also srpt_rdma_ch.list. ++ * @ch_releaseQ: Enables waiting for removal from rch_list. ++ * @spinlock: Protects rch_list. ++ * @port: Information about the ports owned by this HCA. ++ * @event_handler: Per-HCA asynchronous IB event handler. ++ * @dev: Per-port srpt-<portname> device instance. ++ * @scst_tgt: SCST target information associated with this HCA. ++ * @enabled: Whether or not this SCST target is enabled. ++ */ ++struct srpt_device { ++ struct ib_device *device; ++ struct ib_pd *pd; ++ struct ib_mr *mr; ++ struct ib_srq *srq; ++ struct ib_cm_id *cm_id; ++ struct ib_device_attr dev_attr; ++ int srq_size; ++ struct srpt_recv_ioctx **ioctx_ring; ++ struct list_head rch_list; ++ wait_queue_head_t ch_releaseQ; ++ spinlock_t spinlock; ++ struct srpt_port port[2]; ++ struct ib_event_handler event_handler; ++ struct scst_tgt *scst_tgt; ++ bool enabled; ++}; ++ ++#endif /* IB_SRPT_H */ ++ ++/* ++ * Local variables: ++ * c-basic-offset: 8 ++ * indent-tabs-mode: t ++ * End: ++ */ +diff -uprN orig/linux-3.2/Documentation/scst/README.scst_local linux-3.2/Documentation/scst/README.scst_local +--- orig/linux-3.2/Documentation/scst/README.scst_local ++++ linux-3.2/Documentation/scst/README.scst_local +@@ -0,0 +1,286 @@ ++SCST Local ... ++Richard Sharpe, 30-Nov-2008 ++ ++This is the SCST Local driver. Its function is to allow you to access devices ++that are exported via SCST directly on the same Linux system that they are ++exported from. ++ ++No assumptions are made in the code about the device types on the target, so ++any device handlers that you load in SCST should be visible, including tapes ++and so forth. ++ ++You can freely use any sg, sd, st, etc. devices imported from target, ++except the following: you can't mount file systems or put swap on them ++for all dev handlers, except BLOCKIO and pass-through, because it can ++lead to recursive memory allocation deadlock. This is a limitation of ++Linux memory/cache manager. See SCST README file for details. For ++BLOCKIO and pass-through dev handlers there's no such limitation, so you ++can freely mount file systems over them. ++ ++To build, simply issue 'make' in the scst_local directory. ++ ++Try 'modinfo scst_local' for a listing of module parameters so far. ++ ++Here is how I have used it so far: ++ ++1. Load up scst: ++ ++ modprobe scst ++ modprobe scst_vdisk ++ ++2. Create a virtual disk (or your own device handler): ++ ++ dd if=/dev/zero of=/some/path/vdisk1.img bs=16384 count=1000000 ++ echo "add_device vm_disk1 filename=/some/path/vdisk1.img" >/sys/kernel/scst_tgt/handlers/vdisk_fileio/mgmt ++ ++3. Load the scst_local driver: ++ ++ insmod scst_local ++ echo "add vm_disk1 0" >/sys/kernel/scst_tgt/targets/scst_local/scst_local_tgt/luns/mgmt ++ ++4. Check what you have ++ ++ cat /proc/scsi/scsi ++ Attached devices: ++ Host: scsi0 Channel: 00 Id: 00 Lun: 00 ++ Vendor: ATA Model: ST9320320AS Rev: 0303 ++ Type: Direct-Access ANSI SCSI revision: 05 ++ Host: scsi4 Channel: 00 Id: 00 Lun: 00 ++ Vendor: TSSTcorp Model: CD/DVDW TS-L632D Rev: TO04 ++ Type: CD-ROM ANSI SCSI revision: 05 ++ Host: scsi7 Channel: 00 Id: 00 Lun: 00 ++ Vendor: SCST_FIO Model: vm_disk1 Rev: 200 ++ Type: Direct-Access ANSI SCSI revision: 04 ++ ++Or instead of manually "add_device" in (2) and step (3) write a ++scstadmin config: ++ ++HANDLER vdisk_fileio { ++ DEVICE vm_disk1 { ++ filename /some/path/vdisk1.img ++ } ++} ++ ++TARGET_DRIVER scst_local { ++ TARGET scst_local_tgt { ++ LUN 0 vm_disk1 ++ } ++} ++ ++then: ++ ++ insmod scst_local ++ scstadmin -config conf_file.cfg ++ ++More advanced examples: ++ ++For (3) you can: ++ ++ insmod scst_local add_default_tgt=0 ++ echo "add_target scst_local_tgt session_name=scst_local_host" >/sys/kernel/scst_tgt/targets/scst_local//mgmt ++ echo "add vm_disk1 0" >/sys/kernel/scst_tgt/targets/scst_local/scst_local_tgt/luns/mgmt ++ ++Scst_local module's parameter add_default_tgt disables creation of ++default target "scst_local_tgt" and session "scst_local_host", so you ++needed to create it manually. ++ ++There can be any number of targets and sessions created. Each SCST ++session corresponds to SCSI host. You can change which LUNs assigned to ++each session by using SCST access control. This mode is intended for ++user space target drivers (see below). ++ ++Alternatively, you can write an scstadmin's config file conf_file.cfg: ++ ++HANDLER vdisk_fileio { ++ DEVICE vm_disk1 { ++ filename /some/path/vdisk1.img ++ } ++} ++ ++TARGET_DRIVER scst_local { ++ TARGET scst_local_tgt { ++ session_name scst_local_host ++ ++ LUN 0 vm_disk1 ++ } ++} ++ ++then: ++ ++ insmod scst_local add_default_tgt=0 ++ scstadmin -config conf_file.cfg ++ ++NOTE! Although scstadmin allows to create scst_local's sessions using ++"session_name" expression, it doesn't save existing sessions during ++writing config file by "write_config" command. If you need this ++functionality, feel free to send a request for it in SCST development ++mailing list. ++ ++5. Have fun. ++ ++Some of this was coded while in Santa Clara, some in Bangalore, and some in ++Hyderabad. Noe doubt some will be coded on the way back to Santa Clara. ++ ++The code still has bugs, so if you encounter any, email me the fixes at: ++ ++ realrichardsharpe@gmail.com ++ ++I am thinking of renaming this to something more interesting. ++ ++ ++Sysfs interface ++=============== ++ ++See SCST's README for a common SCST sysfs description. ++ ++Root of this driver is /sys/kernel/scst_tgt/targets/scst_local. It has ++the following additional entry: ++ ++ - stats - read-only attribute with some statistical information. ++ ++Each target subdirectory contains the following additional entries: ++ ++ - phys_transport_version - contains and allows to change physical ++ transport version descriptor. It determines by which physical ++ interface this target will look like. See SPC for more details. By ++ default, it is not defined (0). ++ ++ - scsi_transport_version - contains and allows to change SCSI ++ transport version descriptor. It determines by which SCSI ++ transport this target will look like. See SPC for more details. By ++ default, it is SAS. ++ ++Each session subdirectory contains the following additional entries: ++ ++ - transport_id - contains this host's TransportID. This TransportID ++ used to identify initiator in Persisten Reservation commands. If you ++ change scsi_transport_version for a target, make sure you set for all ++ its sessions correct TransportID. See SPC for more details. ++ ++ - host - links to the corresponding SCSI host. Using it you can find ++ local sg/bsg/sd/etc. devices of this session. For instance, this ++ links points out to host12, so you can find your sg devices by: ++ ++$ lsscsi -g|grep "\[12:" ++[12:0:0:0] disk SCST_FIO rd1 200 /dev/sdc /dev/sg2 ++[12:0:0:1] disk SCST_FIO nullio 200 /dev/sdd /dev/sg3 ++ ++They are /dev/sg2 and /dev/sg3. ++ ++The following management commands available via /sys/kernel/scst_tgt/targets/scst_local/mgmt: ++ ++ - add_target target_name [session_name=sess_name; [session_name=sess_name1;] [...]] - ++ creates a target with optionally one or more sessions. ++ ++ - del_target target_name - deletes a target. ++ ++ - add_session target_name session_name - adds to target target_name ++ session (SCSI host) with name session_name. ++ ++ - del_session target_name session_name - deletes session session_name ++ from target target_name. ++ ++ ++Note on performance ++=================== ++ ++Although this driver implemented in the most performance effective way, ++including zero-copy passing data between SCSI/block subsystems and SCST, ++in many cases it is NOT suited to measure performance as a NULL link. ++For example, it is not suited for max IOPS measurements. This is because ++for such cases not performance of the link between the target and ++initiator is the bottleneck, but CPU or memory speed on the target or ++initiator. For scst_local you have both initiator and target on the same ++system, which means each your initiator and target are much less ++CPU/memory powerful. ++ ++ ++User space target drivers ++========================= ++ ++Scst_local can be used to write full featured SCST target drivers in ++user space: ++ ++1. For each SCSI target a user space target driver should create an ++ scst_local's target using "add_target" command. ++ ++2. Then the user space target driver should, if needed, set its SCSI and ++ physical transport version descriptors using attributes ++ scsi_transport_version and phys_transport_version correspondingly in ++ /sys/kernel/scst_tgt/targets/scst_local/target_name directory. ++ ++3. For incoming session (I_T nexus) from an initiator the user space ++ target driver should create scst_local's session using "add_session" ++ command. ++ ++4. Then, if needed, the user space target driver should set TransportID ++ for this session (I_T nexus) using attribute ++ /sys/kernel/scst_tgt/targets/scst_local/target_name/sessions/session_name/transport_id ++ ++5. Then the user space target driver should find out sg/bsg devices for ++ the LUNs the created session has using link ++ /sys/kernel/scst_tgt/targets/scst_local/target_name/sessions/session_name/host ++ as described above. ++ ++6. Then the user space target driver can start serving the initiator using ++ found sg/bsg devices. ++ ++For other connected initiators steps 3-6 should be repeated. ++ ++ ++Compilation options ++=================== ++ ++There are the following compilation options, that could be commented ++in/out in Makefile: ++ ++ - CONFIG_SCST_LOCAL_FORCE_DIRECT_PROCESSING - by default, when this option ++ is not defined, scst_local reschedules all commands for processing in ++ one of the SCST threads. If this option is defined, scst_local tries ++ to not do it, if possible (sometimes queuecommand() called under ++ various locks held), but instead process them in the submitter's ++ context. This is to increase performance, but as on 2.6.37 and below ++ Linux block layer doesn't work with such kind of reentrance, hence ++ this option disabled by default. Note! At the moment in ++ scst_estimate_context*() returning DIRECT contexts disabled, so this ++ option doesn't have any real effect. ++ ++ ++Change log ++========== ++ ++V0.1 24-Sep-2008 (Hyderabad) Initial coding, pretty chatty and messy, ++ but worked. ++ ++V0.2 25-Sep-2008 (Hong Kong) Cleaned up the code a lot, reduced the log ++ chatter, fixed a bug where multiple LUNs did not ++ work. Also, added logging control. Tested with ++ five virtual disks. They all came up as /dev/sdb ++ through /dev/sdf and I could dd to them. Also ++ fixed a bug preventing multiple adapters. ++ ++V0.3 26-Sep-2008 (Santa Clara) Added back a copyright plus cleaned up some ++ unused functions and structures. ++ ++V0.4 5-Oct-2008 (Santa Clara) Changed name to scst_local as suggested, cleaned ++ up some unused variables (made them used) and ++ change allocation to a kmem_cache pool. ++ ++V0.5 5-Oct-2008 (Santa Clara) Added mgmt commands to handle dev reset and ++ aborts. Not sure if aborts works. Also corrected ++ the version info and renamed readme to README. ++ ++V0.6 7-Oct-2008 (Santa Clara) Removed some redundant code and made some ++ changes suggested by Vladislav. ++ ++V0.7 11-Oct-2008 (Santa Clara) Moved into the scst tree. Cleaned up some ++ unused functions, used TRACE macros etc. ++ ++V0.9 30-Nov-2008 (Mtn View) Cleaned up an additional problem with symbols not ++ being defined in older version of the kernel. Also ++ fixed some English and cleaned up this doc. ++ ++V1.0 10-Sep-2010 (Moscow) Sysfs management added. Reviewed and cleaned up. ++ ++V2.1 Update for kernels up to 3.0. Cleanups. ++ +diff -uprN orig/linux-3.2/drivers/scst/scst_local/Kconfig linux-3.2/drivers/scst/scst_local/Kconfig +--- orig/linux-3.2/drivers/scst/scst_local/Kconfig ++++ linux-3.2/drivers/scst/scst_local/Kconfig +@@ -0,0 +1,22 @@ ++config SCST_LOCAL ++ tristate "SCST Local driver" ++ depends on SCST && !HIGHMEM4G && !HIGHMEM64G ++ ---help--- ++ This module provides a LLD SCSI driver that connects to ++ the SCST target mode subsystem in a loop-back manner. ++ It allows you to test target-mode device-handlers locally. ++ You will need the SCST subsystem as well. ++ ++ If unsure whether you really want or need this, say N. ++ ++config SCST_LOCAL_FORCE_DIRECT_PROCESSING ++ bool "Force local processing" ++ depends on SCST_LOCAL ++ help ++ This experimental option forces scst_local to make SCST process ++ SCSI commands in the same context, in which they was submitted. ++ Otherwise, they will be processed in SCST threads. Setting this ++ option to "Y" will give some performance increase, but might be ++ unsafe. ++ ++ If unsure, say "N". +diff -uprN orig/linux-3.2/drivers/scst/scst_local/Makefile linux-3.2/drivers/scst/scst_local/Makefile +--- orig/linux-3.2/drivers/scst/scst_local/Makefile ++++ linux-3.2/drivers/scst/scst_local/Makefile +@@ -0,0 +1,2 @@ ++obj-$(CONFIG_SCST_LOCAL) += scst_local.o ++ +diff -uprN orig/linux-3.2/drivers/scst/scst_local/scst_local.c linux-3.2/drivers/scst/scst_local/scst_local.c +--- orig/linux-3.2/drivers/scst/scst_local/scst_local.c ++++ linux-3.2/drivers/scst/scst_local/scst_local.c +@@ -0,0 +1,1587 @@ ++/* ++ * Copyright (C) 2008 - 2010 Richard Sharpe ++ * Copyright (C) 1992 Eric Youngdale ++ * Copyright (C) 2008 - 2011 Vladislav Bolkhovitin <vst@vlnb.net> ++ * ++ * Simulate a host adapter and an SCST target adapter back to back ++ * ++ * Based on the scsi_debug.c driver originally by Eric Youngdale and ++ * others, including D Gilbert et al ++ * ++ */ ++ ++#include <linux/module.h> ++ ++#include <linux/kernel.h> ++#include <linux/errno.h> ++#include <linux/types.h> ++#include <linux/init.h> ++#include <linux/moduleparam.h> ++#include <linux/scatterlist.h> ++#include <linux/slab.h> ++#include <linux/completion.h> ++#include <linux/spinlock.h> ++ ++#include <scsi/scsi.h> ++#include <scsi/scsi_cmnd.h> ++#include <scsi/scsi_host.h> ++#include <scsi/scsi_tcq.h> ++ ++#define LOG_PREFIX "scst_local" ++ ++/* SCST includes ... */ ++#include <scst/scst.h> ++#include <scst/scst_debug.h> ++ ++#ifdef CONFIG_SCST_DEBUG ++#define SCST_LOCAL_DEFAULT_LOG_FLAGS (TRACE_FUNCTION | TRACE_PID | \ ++ TRACE_LINE | TRACE_OUT_OF_MEM | TRACE_MGMT | TRACE_MGMT_DEBUG | \ ++ TRACE_MINOR | TRACE_SPECIAL) ++#else ++# ifdef CONFIG_SCST_TRACING ++#define SCST_LOCAL_DEFAULT_LOG_FLAGS (TRACE_OUT_OF_MEM | TRACE_MGMT | \ ++ TRACE_SPECIAL) ++# endif ++#endif ++ ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++#define trace_flag scst_local_trace_flag ++static unsigned long scst_local_trace_flag = SCST_LOCAL_DEFAULT_LOG_FLAGS; ++#endif ++ ++#define SCST_LOCAL_VERSION "2.2.0-pre" ++static const char *scst_local_version_date = "20110901"; ++ ++/* Some statistics */ ++static atomic_t num_aborts = ATOMIC_INIT(0); ++static atomic_t num_dev_resets = ATOMIC_INIT(0); ++static atomic_t num_target_resets = ATOMIC_INIT(0); ++ ++static bool scst_local_add_default_tgt = true; ++module_param_named(add_default_tgt, scst_local_add_default_tgt, bool, S_IRUGO); ++MODULE_PARM_DESC(add_default_tgt, "add (default) or not on start default " ++ "target scst_local_tgt with default session scst_local_host"); ++ ++struct scst_aen_work_item { ++ struct list_head work_list_entry; ++ struct scst_aen *aen; ++}; ++ ++struct scst_local_tgt { ++ struct scst_tgt *scst_tgt; ++ struct list_head sessions_list; /* protected by scst_local_mutex */ ++ struct list_head tgts_list_entry; ++ ++ /* SCSI version descriptors */ ++ uint16_t scsi_transport_version; ++ uint16_t phys_transport_version; ++}; ++ ++struct scst_local_sess { ++ struct scst_session *scst_sess; ++ ++ unsigned int unregistering:1; ++ ++ struct device dev; ++ struct Scsi_Host *shost; ++ struct scst_local_tgt *tgt; ++ ++ int number; ++ ++ struct mutex tr_id_mutex; ++ uint8_t *transport_id; ++ int transport_id_len; ++ ++ struct work_struct aen_work; ++ spinlock_t aen_lock; ++ struct list_head aen_work_list; /* protected by aen_lock */ ++ ++ struct list_head sessions_list_entry; ++}; ++ ++#define to_scst_lcl_sess(d) \ ++ container_of(d, struct scst_local_sess, dev) ++ ++static int __scst_local_add_adapter(struct scst_local_tgt *tgt, ++ const char *initiator_name, bool locked); ++static int scst_local_add_adapter(struct scst_local_tgt *tgt, ++ const char *initiator_name); ++static void scst_local_remove_adapter(struct scst_local_sess *sess); ++static int scst_local_add_target(const char *target_name, ++ struct scst_local_tgt **out_tgt); ++static void __scst_local_remove_target(struct scst_local_tgt *tgt); ++static void scst_local_remove_target(struct scst_local_tgt *tgt); ++ ++static atomic_t scst_local_sess_num = ATOMIC_INIT(0); ++ ++static LIST_HEAD(scst_local_tgts_list); ++static DEFINE_MUTEX(scst_local_mutex); ++ ++static DECLARE_RWSEM(scst_local_exit_rwsem); ++ ++MODULE_AUTHOR("Richard Sharpe, Vladislav Bolkhovitin + ideas from SCSI_DEBUG"); ++MODULE_DESCRIPTION("SCSI+SCST local adapter driver"); ++MODULE_LICENSE("GPL"); ++MODULE_VERSION(SCST_LOCAL_VERSION); ++ ++static int scst_local_get_sas_transport_id(struct scst_local_sess *sess, ++ uint8_t **transport_id, int *len) ++{ ++ int res = 0; ++ int tr_id_size = 0; ++ uint8_t *tr_id = NULL; ++ ++ TRACE_ENTRY(); ++ ++ tr_id_size = 24; /* A SAS TransportID */ ++ ++ tr_id = kzalloc(tr_id_size, GFP_KERNEL); ++ if (tr_id == NULL) { ++ PRINT_ERROR("Allocation of TransportID (size %d) failed", ++ tr_id_size); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ tr_id[0] = 0x00 | SCSI_TRANSPORTID_PROTOCOLID_SAS; ++ ++ /* ++ * Assemble a valid SAS address = 0x5OOUUIIR12345678 ... Does SCST ++ * have one? ++ */ ++ ++ tr_id[4] = 0x5F; ++ tr_id[5] = 0xEE; ++ tr_id[6] = 0xDE; ++ tr_id[7] = 0x40 | ((sess->number >> 4) & 0x0F); ++ tr_id[8] = 0x0F | (sess->number & 0xF0); ++ tr_id[9] = 0xAD; ++ tr_id[10] = 0xE0; ++ tr_id[11] = 0x50; ++ ++ *transport_id = tr_id; ++ *len = tr_id_size; ++ ++ TRACE_DBG("Created tid '%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X'", ++ tr_id[4], tr_id[5], tr_id[6], tr_id[7], ++ tr_id[8], tr_id[9], tr_id[10], tr_id[11]); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_local_get_initiator_port_transport_id( ++ struct scst_tgt *tgt, struct scst_session *scst_sess, ++ uint8_t **transport_id) ++{ ++ int res = 0; ++ int tr_id_size = 0; ++ uint8_t *tr_id = NULL; ++ struct scst_local_sess *sess; ++ ++ TRACE_ENTRY(); ++ ++ if (scst_sess == NULL) { ++ res = SCSI_TRANSPORTID_PROTOCOLID_SAS; ++ goto out; ++ } ++ ++ sess = (struct scst_local_sess *)scst_sess_get_tgt_priv(scst_sess); ++ ++ mutex_lock(&sess->tr_id_mutex); ++ ++ if (sess->transport_id == NULL) { ++ res = scst_local_get_sas_transport_id(sess, ++ transport_id, &tr_id_size); ++ goto out_unlock; ++ } ++ ++ tr_id_size = sess->transport_id_len; ++ BUG_ON(tr_id_size == 0); ++ ++ tr_id = kzalloc(tr_id_size, GFP_KERNEL); ++ if (tr_id == NULL) { ++ PRINT_ERROR("Allocation of TransportID (size %d) failed", ++ tr_id_size); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ memcpy(tr_id, sess->transport_id, sess->transport_id_len); ++ ++out_unlock: ++ mutex_unlock(&sess->tr_id_mutex); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/** ++ ** Tgtt attributes ++ **/ ++ ++static ssize_t scst_local_version_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ sprintf(buf, "%s/%s\n", SCST_LOCAL_VERSION, scst_local_version_date); ++ ++#ifdef CONFIG_SCST_EXTRACHECKS ++ strcat(buf, "EXTRACHECKS\n"); ++#endif ++ ++#ifdef CONFIG_SCST_TRACING ++ strcat(buf, "TRACING\n"); ++#endif ++ ++#ifdef CONFIG_SCST_DEBUG ++ strcat(buf, "DEBUG\n"); ++#endif ++ ++ TRACE_EXIT(); ++ return strlen(buf); ++} ++ ++static struct kobj_attribute scst_local_version_attr = ++ __ATTR(version, S_IRUGO, scst_local_version_show, NULL); ++ ++static ssize_t scst_local_stats_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++ ++{ ++ return sprintf(buf, "Aborts: %d, Device Resets: %d, Target Resets: %d", ++ atomic_read(&num_aborts), atomic_read(&num_dev_resets), ++ atomic_read(&num_target_resets)); ++} ++ ++static struct kobj_attribute scst_local_stats_attr = ++ __ATTR(stats, S_IRUGO, scst_local_stats_show, NULL); ++ ++static const struct attribute *scst_local_tgtt_attrs[] = { ++ &scst_local_version_attr.attr, ++ &scst_local_stats_attr.attr, ++ NULL, ++}; ++ ++/** ++ ** Tgt attributes ++ **/ ++ ++static ssize_t scst_local_scsi_transport_version_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_tgt *scst_tgt; ++ struct scst_local_tgt *tgt; ++ ssize_t res = -ENOENT; ++ ++ if (down_read_trylock(&scst_local_exit_rwsem) == 0) ++ goto out; ++ ++ scst_tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ tgt = scst_tgt_get_tgt_priv(scst_tgt); ++ if (!tgt) ++ goto out_up; ++ ++ if (tgt->scsi_transport_version != 0) ++ res = sprintf(buf, "0x%x\n%s", tgt->scsi_transport_version, ++ SCST_SYSFS_KEY_MARK "\n"); ++ else ++ res = sprintf(buf, "0x%x\n", 0x0BE0); /* SAS */ ++ ++out_up: ++ up_read(&scst_local_exit_rwsem); ++out: ++ return res; ++} ++ ++static ssize_t scst_local_scsi_transport_version_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buffer, size_t size) ++{ ++ ssize_t res = -ENOENT; ++ struct scst_tgt *scst_tgt; ++ struct scst_local_tgt *tgt; ++ unsigned long val; ++ ++ if (down_read_trylock(&scst_local_exit_rwsem) == 0) ++ goto out; ++ ++ scst_tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ tgt = scst_tgt_get_tgt_priv(scst_tgt); ++ if (!tgt) ++ goto out_up; ++ ++ res = strict_strtoul(buffer, 0, &val); ++ if (res != 0) { ++ PRINT_ERROR("strict_strtoul() for %s failed: %zd", buffer, res); ++ goto out_up; ++ } ++ ++ tgt->scsi_transport_version = val; ++ ++ res = size; ++ ++out_up: ++ up_read(&scst_local_exit_rwsem); ++out: ++ return res; ++} ++ ++static struct kobj_attribute scst_local_scsi_transport_version_attr = ++ __ATTR(scsi_transport_version, S_IRUGO | S_IWUSR, ++ scst_local_scsi_transport_version_show, ++ scst_local_scsi_transport_version_store); ++ ++static ssize_t scst_local_phys_transport_version_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ struct scst_tgt *scst_tgt; ++ struct scst_local_tgt *tgt; ++ ssize_t res = -ENOENT; ++ ++ if (down_read_trylock(&scst_local_exit_rwsem) == 0) ++ goto out; ++ ++ scst_tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ tgt = scst_tgt_get_tgt_priv(scst_tgt); ++ if (!tgt) ++ goto out_up; ++ ++ res = sprintf(buf, "0x%x\n%s", tgt->phys_transport_version, ++ (tgt->phys_transport_version != 0) ? ++ SCST_SYSFS_KEY_MARK "\n" : ""); ++ ++out_up: ++ up_read(&scst_local_exit_rwsem); ++out: ++ return res; ++} ++ ++static ssize_t scst_local_phys_transport_version_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buffer, size_t size) ++{ ++ ssize_t res = -ENOENT; ++ struct scst_tgt *scst_tgt; ++ struct scst_local_tgt *tgt; ++ unsigned long val; ++ ++ if (down_read_trylock(&scst_local_exit_rwsem) == 0) ++ goto out; ++ ++ scst_tgt = container_of(kobj, struct scst_tgt, tgt_kobj); ++ tgt = scst_tgt_get_tgt_priv(scst_tgt); ++ if (!tgt) ++ goto out_up; ++ ++ res = strict_strtoul(buffer, 0, &val); ++ if (res != 0) { ++ PRINT_ERROR("strict_strtoul() for %s failed: %zd", buffer, res); ++ goto out_up; ++ } ++ ++ tgt->phys_transport_version = val; ++ ++ res = size; ++ ++out_up: ++ up_read(&scst_local_exit_rwsem); ++out: ++ return res; ++} ++ ++static struct kobj_attribute scst_local_phys_transport_version_attr = ++ __ATTR(phys_transport_version, S_IRUGO | S_IWUSR, ++ scst_local_phys_transport_version_show, ++ scst_local_phys_transport_version_store); ++ ++static const struct attribute *scst_local_tgt_attrs[] = { ++ &scst_local_scsi_transport_version_attr.attr, ++ &scst_local_phys_transport_version_attr.attr, ++ NULL, ++}; ++ ++/** ++ ** Session attributes ++ **/ ++ ++static ssize_t scst_local_transport_id_show(struct kobject *kobj, ++ struct kobj_attribute *attr, char *buf) ++{ ++ ssize_t res; ++ struct scst_session *scst_sess; ++ struct scst_local_sess *sess; ++ uint8_t *tr_id; ++ int tr_id_len, i; ++ ++ if (down_read_trylock(&scst_local_exit_rwsem) == 0) ++ return -ENOENT; ++ ++ scst_sess = container_of(kobj, struct scst_session, sess_kobj); ++ sess = (struct scst_local_sess *)scst_sess_get_tgt_priv(scst_sess); ++ ++ mutex_lock(&sess->tr_id_mutex); ++ ++ if (sess->transport_id != NULL) { ++ tr_id = sess->transport_id; ++ tr_id_len = sess->transport_id_len; ++ } else { ++ res = scst_local_get_sas_transport_id(sess, &tr_id, &tr_id_len); ++ if (res != 0) ++ goto out_unlock; ++ } ++ ++ res = 0; ++ for (i = 0; i < tr_id_len; i++) ++ res += sprintf(&buf[res], "%c", tr_id[i]); ++ ++ if (sess->transport_id == NULL) ++ kfree(tr_id); ++ ++out_unlock: ++ mutex_unlock(&sess->tr_id_mutex); ++ up_read(&scst_local_exit_rwsem); ++ return res; ++} ++ ++static ssize_t scst_local_transport_id_store(struct kobject *kobj, ++ struct kobj_attribute *attr, const char *buffer, size_t size) ++{ ++ ssize_t res; ++ struct scst_session *scst_sess; ++ struct scst_local_sess *sess; ++ ++ if (down_read_trylock(&scst_local_exit_rwsem) == 0) ++ return -ENOENT; ++ ++ scst_sess = container_of(kobj, struct scst_session, sess_kobj); ++ sess = (struct scst_local_sess *)scst_sess_get_tgt_priv(scst_sess); ++ ++ mutex_lock(&sess->tr_id_mutex); ++ ++ if (sess->transport_id != NULL) { ++ kfree(sess->transport_id); ++ sess->transport_id = NULL; ++ sess->transport_id_len = 0; ++ } ++ ++ if (size == 0) ++ goto out_res; ++ ++ sess->transport_id = kzalloc(size, GFP_KERNEL); ++ if (sess->transport_id == NULL) { ++ PRINT_ERROR("Allocation of transport_id (size %zd) failed", ++ size); ++ res = -ENOMEM; ++ goto out_unlock; ++ } ++ ++ sess->transport_id_len = size; ++ ++ memcpy(sess->transport_id, buffer, sess->transport_id_len); ++ ++out_res: ++ res = size; ++ ++out_unlock: ++ mutex_unlock(&sess->tr_id_mutex); ++ up_read(&scst_local_exit_rwsem); ++ return res; ++} ++ ++static struct kobj_attribute scst_local_transport_id_attr = ++ __ATTR(transport_id, S_IRUGO | S_IWUSR, ++ scst_local_transport_id_show, ++ scst_local_transport_id_store); ++ ++static const struct attribute *scst_local_sess_attrs[] = { ++ &scst_local_transport_id_attr.attr, ++ NULL, ++}; ++ ++static ssize_t scst_local_sysfs_add_target(const char *target_name, char *params) ++{ ++ int res; ++ struct scst_local_tgt *tgt; ++ char *param, *p; ++ ++ TRACE_ENTRY(); ++ ++ if (down_read_trylock(&scst_local_exit_rwsem) == 0) ++ return -ENOENT; ++ ++ res = scst_local_add_target(target_name, &tgt); ++ if (res != 0) ++ goto out_up; ++ ++ while (1) { ++ param = scst_get_next_token_str(¶ms); ++ if (param == NULL) ++ break; ++ ++ p = scst_get_next_lexem(¶m); ++ if (*p == '\0') ++ break; ++ ++ if (strcasecmp("session_name", p) != 0) { ++ PRINT_ERROR("Unknown parameter %s", p); ++ res = -EINVAL; ++ goto out_remove; ++ } ++ ++ p = scst_get_next_lexem(¶m); ++ if (*p == '\0') { ++ PRINT_ERROR("Wrong session name %s", p); ++ res = -EINVAL; ++ goto out_remove; ++ } ++ ++ res = scst_local_add_adapter(tgt, p); ++ if (res != 0) ++ goto out_remove; ++ } ++ ++out_up: ++ up_read(&scst_local_exit_rwsem); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_remove: ++ scst_local_remove_target(tgt); ++ goto out_up; ++} ++ ++static ssize_t scst_local_sysfs_del_target(const char *target_name) ++{ ++ int res; ++ struct scst_local_tgt *tgt; ++ bool deleted = false; ++ ++ TRACE_ENTRY(); ++ ++ if (down_read_trylock(&scst_local_exit_rwsem) == 0) ++ return -ENOENT; ++ ++ mutex_lock(&scst_local_mutex); ++ list_for_each_entry(tgt, &scst_local_tgts_list, tgts_list_entry) { ++ if (strcmp(target_name, tgt->scst_tgt->tgt_name) == 0) { ++ __scst_local_remove_target(tgt); ++ deleted = true; ++ break; ++ } ++ } ++ mutex_unlock(&scst_local_mutex); ++ ++ if (!deleted) { ++ PRINT_ERROR("Target %s not found", target_name); ++ res = -ENOENT; ++ goto out_up; ++ } ++ ++ res = 0; ++ ++out_up: ++ up_read(&scst_local_exit_rwsem); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static ssize_t scst_local_sysfs_mgmt_cmd(char *buf) ++{ ++ ssize_t res; ++ char *command, *target_name, *session_name; ++ struct scst_local_tgt *t, *tgt; ++ ++ TRACE_ENTRY(); ++ ++ if (down_read_trylock(&scst_local_exit_rwsem) == 0) ++ return -ENOENT; ++ ++ command = scst_get_next_lexem(&buf); ++ ++ target_name = scst_get_next_lexem(&buf); ++ if (*target_name == '\0') { ++ PRINT_ERROR("%s", "Target name required"); ++ res = -EINVAL; ++ goto out_up; ++ } ++ ++ mutex_lock(&scst_local_mutex); ++ ++ tgt = NULL; ++ list_for_each_entry(t, &scst_local_tgts_list, tgts_list_entry) { ++ if (strcmp(t->scst_tgt->tgt_name, target_name) == 0) { ++ tgt = t; ++ break; ++ } ++ } ++ if (tgt == NULL) { ++ PRINT_ERROR("Target %s not found", target_name); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++ session_name = scst_get_next_lexem(&buf); ++ if (*session_name == '\0') { ++ PRINT_ERROR("%s", "Session name required"); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ ++ if (strcasecmp("add_session", command) == 0) { ++ res = __scst_local_add_adapter(tgt, session_name, true); ++ } else if (strcasecmp("del_session", command) == 0) { ++ struct scst_local_sess *s, *sess = NULL; ++ list_for_each_entry(s, &tgt->sessions_list, ++ sessions_list_entry) { ++ if (strcmp(s->scst_sess->initiator_name, session_name) == 0) { ++ sess = s; ++ break; ++ } ++ } ++ if (sess == NULL) { ++ PRINT_ERROR("Session %s not found (target %s)", ++ session_name, target_name); ++ res = -EINVAL; ++ goto out_unlock; ++ } ++ scst_local_remove_adapter(sess); ++ } ++ ++ res = 0; ++ ++out_unlock: ++ mutex_unlock(&scst_local_mutex); ++ ++out_up: ++ up_read(&scst_local_exit_rwsem); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_local_abort(struct scsi_cmnd *SCpnt) ++{ ++ struct scst_local_sess *sess; ++ int ret; ++ DECLARE_COMPLETION_ONSTACK(dev_reset_completion); ++ ++ TRACE_ENTRY(); ++ ++ sess = to_scst_lcl_sess(scsi_get_device(SCpnt->device->host)); ++ ++ ret = scst_rx_mgmt_fn_tag(sess->scst_sess, SCST_ABORT_TASK, SCpnt->tag, ++ false, &dev_reset_completion); ++ ++ /* Now wait for the completion ... */ ++ wait_for_completion_interruptible(&dev_reset_completion); ++ ++ atomic_inc(&num_aborts); ++ ++ if (ret == 0) ++ ret = SUCCESS; ++ ++ TRACE_EXIT_RES(ret); ++ return ret; ++} ++ ++static int scst_local_device_reset(struct scsi_cmnd *SCpnt) ++{ ++ struct scst_local_sess *sess; ++ __be16 lun; ++ int ret; ++ DECLARE_COMPLETION_ONSTACK(dev_reset_completion); ++ ++ TRACE_ENTRY(); ++ ++ sess = to_scst_lcl_sess(scsi_get_device(SCpnt->device->host)); ++ ++ lun = cpu_to_be16(SCpnt->device->lun); ++ ++ ret = scst_rx_mgmt_fn_lun(sess->scst_sess, SCST_LUN_RESET, ++ (const uint8_t *)&lun, sizeof(lun), false, ++ &dev_reset_completion); ++ ++ /* Now wait for the completion ... */ ++ wait_for_completion_interruptible(&dev_reset_completion); ++ ++ atomic_inc(&num_dev_resets); ++ ++ if (ret == 0) ++ ret = SUCCESS; ++ ++ TRACE_EXIT_RES(ret); ++ return ret; ++} ++ ++static int scst_local_target_reset(struct scsi_cmnd *SCpnt) ++{ ++ struct scst_local_sess *sess; ++ __be16 lun; ++ int ret; ++ DECLARE_COMPLETION_ONSTACK(dev_reset_completion); ++ ++ TRACE_ENTRY(); ++ ++ sess = to_scst_lcl_sess(scsi_get_device(SCpnt->device->host)); ++ ++ lun = cpu_to_be16(SCpnt->device->lun); ++ ++ ret = scst_rx_mgmt_fn_lun(sess->scst_sess, SCST_TARGET_RESET, ++ (const uint8_t *)&lun, sizeof(lun), false, ++ &dev_reset_completion); ++ ++ /* Now wait for the completion ... */ ++ wait_for_completion_interruptible(&dev_reset_completion); ++ ++ atomic_inc(&num_target_resets); ++ ++ if (ret == 0) ++ ret = SUCCESS; ++ ++ TRACE_EXIT_RES(ret); ++ return ret; ++} ++ ++static void copy_sense(struct scsi_cmnd *cmnd, struct scst_cmd *scst_cmnd) ++{ ++ int scst_cmnd_sense_len = scst_cmd_get_sense_buffer_len(scst_cmnd); ++ ++ TRACE_ENTRY(); ++ ++ scst_cmnd_sense_len = (SCSI_SENSE_BUFFERSIZE < scst_cmnd_sense_len ? ++ SCSI_SENSE_BUFFERSIZE : scst_cmnd_sense_len); ++ memcpy(cmnd->sense_buffer, scst_cmd_get_sense_buffer(scst_cmnd), ++ scst_cmnd_sense_len); ++ ++ TRACE_BUFFER("Sense set", cmnd->sense_buffer, scst_cmnd_sense_len); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++/* ++ * Utility function to handle processing of done and allow ++ * easy insertion of error injection if desired ++ */ ++static int scst_local_send_resp(struct scsi_cmnd *cmnd, ++ struct scst_cmd *scst_cmnd, ++ void (*done)(struct scsi_cmnd *), ++ int scsi_result) ++{ ++ int ret = 0; ++ ++ TRACE_ENTRY(); ++ ++ if (scst_cmnd) { ++ /* The buffer isn't ours, so let's be safe and restore it */ ++ scst_check_restore_sg_buff(scst_cmnd); ++ ++ /* Simulate autosense by this driver */ ++ if (unlikely(SCST_SENSE_VALID(scst_cmnd->sense))) ++ copy_sense(cmnd, scst_cmnd); ++ } ++ ++ cmnd->result = scsi_result; ++ ++ done(cmnd); ++ ++ TRACE_EXIT_RES(ret); ++ return ret; ++} ++ ++/* ++ * This does the heavy lifting ... we pass all the commands on to the ++ * target driver and have it do its magic ... ++ */ ++#ifdef CONFIG_SCST_LOCAL_FORCE_DIRECT_PROCESSING ++static int scst_local_queuecommand(struct Scsi_Host *host, ++ struct scsi_cmnd *SCpnt) ++#else ++static int scst_local_queuecommand_lck(struct scsi_cmnd *SCpnt, ++ void (*done)(struct scsi_cmnd *)) ++ __acquires(&h->host_lock) ++ __releases(&h->host_lock) ++#endif ++{ ++ struct scst_local_sess *sess; ++ struct scatterlist *sgl = NULL; ++ int sgl_count = 0; ++ __be16 lun; ++ struct scst_cmd *scst_cmd = NULL; ++ scst_data_direction dir; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("lun %d, cmd: 0x%02X", SCpnt->device->lun, SCpnt->cmnd[0]); ++ ++ sess = to_scst_lcl_sess(scsi_get_device(SCpnt->device->host)); ++ ++ scsi_set_resid(SCpnt, 0); ++ ++ /* ++ * Tell the target that we have a command ... but first we need ++ * to get the LUN into a format that SCST understand ++ * ++ * NOTE! We need to call it with atomic parameter true to not ++ * get into mem alloc deadlock when mounting file systems over ++ * our devices. ++ */ ++ lun = cpu_to_be16(SCpnt->device->lun); ++ scst_cmd = scst_rx_cmd(sess->scst_sess, (const uint8_t *)&lun, ++ sizeof(lun), SCpnt->cmnd, SCpnt->cmd_len, true); ++ if (!scst_cmd) { ++ PRINT_ERROR("%s", "scst_rx_cmd() failed"); ++ return SCSI_MLQUEUE_HOST_BUSY; ++ } ++ ++ scst_cmd_set_tag(scst_cmd, SCpnt->tag); ++ switch (scsi_get_tag_type(SCpnt->device)) { ++ case MSG_SIMPLE_TAG: ++ scst_cmd_set_queue_type(scst_cmd, SCST_CMD_QUEUE_SIMPLE); ++ break; ++ case MSG_HEAD_TAG: ++ scst_cmd_set_queue_type(scst_cmd, SCST_CMD_QUEUE_HEAD_OF_QUEUE); ++ break; ++ case MSG_ORDERED_TAG: ++ scst_cmd_set_queue_type(scst_cmd, SCST_CMD_QUEUE_ORDERED); ++ break; ++ case SCSI_NO_TAG: ++ default: ++ scst_cmd_set_queue_type(scst_cmd, SCST_CMD_QUEUE_UNTAGGED); ++ break; ++ } ++ ++ sgl = scsi_sglist(SCpnt); ++ sgl_count = scsi_sg_count(SCpnt); ++ ++ dir = SCST_DATA_NONE; ++ switch (SCpnt->sc_data_direction) { ++ case DMA_TO_DEVICE: ++ dir = SCST_DATA_WRITE; ++ scst_cmd_set_expected(scst_cmd, dir, scsi_bufflen(SCpnt)); ++ scst_cmd_set_noio_mem_alloc(scst_cmd); ++ scst_cmd_set_tgt_sg(scst_cmd, sgl, sgl_count); ++ break; ++ case DMA_FROM_DEVICE: ++ dir = SCST_DATA_READ; ++ scst_cmd_set_expected(scst_cmd, dir, scsi_bufflen(SCpnt)); ++ scst_cmd_set_noio_mem_alloc(scst_cmd); ++ scst_cmd_set_tgt_sg(scst_cmd, sgl, sgl_count); ++ break; ++ case DMA_BIDIRECTIONAL: ++ /* Some of these symbols are only defined after 2.6.24 */ ++ dir = SCST_DATA_BIDI; ++ scst_cmd_set_expected(scst_cmd, dir, scsi_bufflen(SCpnt)); ++ scst_cmd_set_expected_out_transfer_len(scst_cmd, ++ scsi_in(SCpnt)->length); ++ scst_cmd_set_noio_mem_alloc(scst_cmd); ++ scst_cmd_set_tgt_sg(scst_cmd, scsi_in(SCpnt)->table.sgl, ++ scsi_in(SCpnt)->table.nents); ++ scst_cmd_set_tgt_out_sg(scst_cmd, sgl, sgl_count); ++ break; ++ case DMA_NONE: ++ default: ++ dir = SCST_DATA_NONE; ++ scst_cmd_set_expected(scst_cmd, dir, 0); ++ break; ++ } ++ ++ /* Save the correct thing below depending on version */ ++ scst_cmd_set_tgt_priv(scst_cmd, SCpnt); ++ ++/* ++ * Although starting from 2.6.37 queuecommand() called with no host_lock ++ * held, in fact without DEF_SCSI_QCMD() it doesn't work and leading ++ * to various problems like hangs under highload. Most likely, it is caused ++ * by some not reenrable block layer function(s). So, until that changed, we ++ * have to go ahead with extra context switch. In this regard doesn't matter ++ * much if we under host_lock or not (although we absolutely don't need this ++ * lock), so let's have simpler code with DEF_SCSI_QCMD(). ++ */ ++#ifdef CONFIG_SCST_LOCAL_FORCE_DIRECT_PROCESSING ++ scst_cmd_init_done(scst_cmd, SCST_CONTEXT_DIRECT); ++#else ++ /* ++ * We called with IRQs disabled, so have no choice, ++ * except to pass to the thread context. ++ */ ++ scst_cmd_init_done(scst_cmd, SCST_CONTEXT_THREAD); ++#endif ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++#if !defined(CONFIG_SCST_LOCAL_FORCE_DIRECT_PROCESSING) ++/* ++ * See comment in scst_local_queuecommand_lck() near ++ * CONFIG_SCST_LOCAL_FORCE_DIRECT_PROCESSING ++ */ ++static DEF_SCSI_QCMD(scst_local_queuecommand) ++#endif ++ ++static int scst_local_targ_pre_exec(struct scst_cmd *scst_cmd) ++{ ++ int res = SCST_PREPROCESS_STATUS_SUCCESS; ++ ++ TRACE_ENTRY(); ++ ++ if (scst_cmd_get_dh_data_buff_alloced(scst_cmd) && ++ (scst_cmd_get_data_direction(scst_cmd) & SCST_DATA_WRITE)) ++ scst_copy_sg(scst_cmd, SCST_SG_COPY_FROM_TARGET); ++ ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++/* Must be called under sess->aen_lock. Drops then reacquires it inside. */ ++static void scst_process_aens(struct scst_local_sess *sess, ++ bool cleanup_only) ++ __releases(&sess->aen_lock) ++ __acquires(&sess->aen_lock) ++{ ++ struct scst_aen_work_item *work_item = NULL; ++ ++ TRACE_ENTRY(); ++ ++ TRACE_DBG("Target work sess %p", sess); ++ ++ while (!list_empty(&sess->aen_work_list)) { ++ work_item = list_entry(sess->aen_work_list.next, ++ struct scst_aen_work_item, work_list_entry); ++ list_del(&work_item->work_list_entry); ++ ++ spin_unlock(&sess->aen_lock); ++ ++ if (cleanup_only) ++ goto done; ++ ++ BUG_ON(work_item->aen->event_fn != SCST_AEN_SCSI); ++ ++ /* Let's always rescan */ ++ scsi_scan_target(&sess->shost->shost_gendev, 0, 0, ++ SCAN_WILD_CARD, 1); ++ ++done: ++ scst_aen_done(work_item->aen); ++ kfree(work_item); ++ ++ spin_lock(&sess->aen_lock); ++ } ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void scst_aen_work_fn(struct work_struct *work) ++{ ++ struct scst_local_sess *sess = ++ container_of(work, struct scst_local_sess, aen_work); ++ ++ TRACE_ENTRY(); ++ ++ TRACE_MGMT_DBG("Target work %p)", sess); ++ ++ spin_lock(&sess->aen_lock); ++ scst_process_aens(sess, false); ++ spin_unlock(&sess->aen_lock); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int scst_local_report_aen(struct scst_aen *aen) ++{ ++ int res = 0; ++ int event_fn = scst_aen_get_event_fn(aen); ++ struct scst_local_sess *sess; ++ struct scst_aen_work_item *work_item = NULL; ++ ++ TRACE_ENTRY(); ++ ++ sess = (struct scst_local_sess *)scst_sess_get_tgt_priv( ++ scst_aen_get_sess(aen)); ++ switch (event_fn) { ++ case SCST_AEN_SCSI: ++ /* ++ * Allocate a work item and place it on the queue ++ */ ++ work_item = kzalloc(sizeof(*work_item), GFP_KERNEL); ++ if (!work_item) { ++ PRINT_ERROR("%s", "Unable to allocate work item " ++ "to handle AEN!"); ++ return -ENOMEM; ++ } ++ ++ spin_lock(&sess->aen_lock); ++ ++ if (unlikely(sess->unregistering)) { ++ spin_unlock(&sess->aen_lock); ++ kfree(work_item); ++ res = SCST_AEN_RES_NOT_SUPPORTED; ++ goto out; ++ } ++ ++ list_add_tail(&work_item->work_list_entry, &sess->aen_work_list); ++ work_item->aen = aen; ++ ++ spin_unlock(&sess->aen_lock); ++ ++ schedule_work(&sess->aen_work); ++ break; ++ ++ default: ++ TRACE_MGMT_DBG("Unsupported AEN %d", event_fn); ++ res = SCST_AEN_RES_NOT_SUPPORTED; ++ break; ++ } ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++} ++ ++static int scst_local_targ_detect(struct scst_tgt_template *tgt_template) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_EXIT(); ++ return 0; ++}; ++ ++static int scst_local_targ_release(struct scst_tgt *tgt) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++static int scst_local_targ_xmit_response(struct scst_cmd *scst_cmd) ++{ ++ struct scsi_cmnd *SCpnt = NULL; ++ void (*done)(struct scsi_cmnd *); ++ ++ TRACE_ENTRY(); ++ ++ if (unlikely(scst_cmd_aborted(scst_cmd))) { ++ scst_set_delivery_status(scst_cmd, SCST_CMD_DELIVERY_ABORTED); ++ scst_tgt_cmd_done(scst_cmd, SCST_CONTEXT_SAME); ++ return SCST_TGT_RES_SUCCESS; ++ } ++ ++ if (scst_cmd_get_dh_data_buff_alloced(scst_cmd) && ++ (scst_cmd_get_data_direction(scst_cmd) & SCST_DATA_READ)) ++ scst_copy_sg(scst_cmd, SCST_SG_COPY_TO_TARGET); ++ ++ SCpnt = scst_cmd_get_tgt_priv(scst_cmd); ++ done = SCpnt->scsi_done; ++ ++ /* ++ * This might have to change to use the two status flags ++ */ ++ if (scst_cmd_get_is_send_status(scst_cmd)) { ++ int resid = 0, out_resid = 0; ++ ++ /* Calculate the residual ... */ ++ if (likely(!scst_get_resid(scst_cmd, &resid, &out_resid))) { ++ TRACE_DBG("No residuals for request %p", SCpnt); ++ } else { ++ if (out_resid != 0) ++ PRINT_ERROR("Unable to return OUT residual %d " ++ "(op %02x)", out_resid, SCpnt->cmnd[0]); ++ } ++ ++ scsi_set_resid(SCpnt, resid); ++ ++ /* ++ * It seems like there is no way to set out_resid ... ++ */ ++ ++ (void)scst_local_send_resp(SCpnt, scst_cmd, done, ++ scst_cmd_get_status(scst_cmd)); ++ } ++ ++ /* Now tell SCST that the command is done ... */ ++ scst_tgt_cmd_done(scst_cmd, SCST_CONTEXT_SAME); ++ ++ TRACE_EXIT(); ++ return SCST_TGT_RES_SUCCESS; ++} ++ ++static void scst_local_targ_task_mgmt_done(struct scst_mgmt_cmd *mgmt_cmd) ++{ ++ struct completion *compl; ++ ++ TRACE_ENTRY(); ++ ++ compl = (struct completion *)scst_mgmt_cmd_get_tgt_priv(mgmt_cmd); ++ if (compl) ++ complete(compl); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static uint16_t scst_local_get_scsi_transport_version(struct scst_tgt *scst_tgt) ++{ ++ struct scst_local_tgt *tgt; ++ ++ tgt = (struct scst_local_tgt *)scst_tgt_get_tgt_priv(scst_tgt); ++ ++ if (tgt->scsi_transport_version == 0) ++ return 0x0BE0; /* SAS */ ++ else ++ return tgt->scsi_transport_version; ++} ++ ++static uint16_t scst_local_get_phys_transport_version(struct scst_tgt *scst_tgt) ++{ ++ struct scst_local_tgt *tgt; ++ ++ tgt = (struct scst_local_tgt *)scst_tgt_get_tgt_priv(scst_tgt); ++ ++ return tgt->phys_transport_version; ++} ++ ++static struct scst_tgt_template scst_local_targ_tmpl = { ++ .name = "scst_local", ++ .sg_tablesize = 0xffff, ++ .xmit_response_atomic = 1, ++ .enabled_attr_not_needed = 1, ++ .tgtt_attrs = scst_local_tgtt_attrs, ++ .tgt_attrs = scst_local_tgt_attrs, ++ .sess_attrs = scst_local_sess_attrs, ++ .add_target = scst_local_sysfs_add_target, ++ .del_target = scst_local_sysfs_del_target, ++ .mgmt_cmd = scst_local_sysfs_mgmt_cmd, ++ .add_target_parameters = "session_name", ++ .mgmt_cmd_help = " echo \"add_session target_name session_name\" >mgmt\n" ++ " echo \"del_session target_name session_name\" >mgmt\n", ++ .detect = scst_local_targ_detect, ++ .release = scst_local_targ_release, ++ .pre_exec = scst_local_targ_pre_exec, ++ .xmit_response = scst_local_targ_xmit_response, ++ .task_mgmt_fn_done = scst_local_targ_task_mgmt_done, ++ .report_aen = scst_local_report_aen, ++ .get_initiator_port_transport_id = scst_local_get_initiator_port_transport_id, ++ .get_scsi_transport_version = scst_local_get_scsi_transport_version, ++ .get_phys_transport_version = scst_local_get_phys_transport_version, ++#if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING) ++ .default_trace_flags = SCST_LOCAL_DEFAULT_LOG_FLAGS, ++ .trace_flags = &trace_flag, ++#endif ++}; ++ ++static struct scsi_host_template scst_lcl_ini_driver_template = { ++ .name = SCST_LOCAL_NAME, ++ .queuecommand = scst_local_queuecommand, ++ .eh_abort_handler = scst_local_abort, ++ .eh_device_reset_handler = scst_local_device_reset, ++ .eh_target_reset_handler = scst_local_target_reset, ++ .can_queue = 256, ++ .this_id = -1, ++ .sg_tablesize = 0xFFFF, ++ .cmd_per_lun = 32, ++ .max_sectors = 0xffff, ++ /* Possible pass-through backend device may not support clustering */ ++ .use_clustering = DISABLE_CLUSTERING, ++ .skip_settle_delay = 1, ++ .module = THIS_MODULE, ++}; ++ ++/* ++ * LLD Bus and functions ++ */ ++ ++static int scst_local_driver_probe(struct device *dev) ++{ ++ int ret; ++ struct scst_local_sess *sess; ++ struct Scsi_Host *hpnt; ++ ++ TRACE_ENTRY(); ++ ++ sess = to_scst_lcl_sess(dev); ++ ++ TRACE_DBG("sess %p", sess); ++ ++ hpnt = scsi_host_alloc(&scst_lcl_ini_driver_template, sizeof(*sess)); ++ if (NULL == hpnt) { ++ PRINT_ERROR("%s", "scsi_register() failed"); ++ ret = -ENODEV; ++ goto out; ++ } ++ ++ sess->shost = hpnt; ++ ++ hpnt->max_id = 0; /* Don't want more than one id */ ++ hpnt->max_lun = 0xFFFF; ++ ++ /* ++ * Because of a change in the size of this field at 2.6.26 ++ * we use this check ... it allows us to work on earlier ++ * kernels. If we don't, max_cmd_size gets set to 4 (and we get ++ * a compiler warning) so a scan never occurs. ++ */ ++ hpnt->max_cmd_len = 260; ++ ++ ret = scsi_add_host(hpnt, &sess->dev); ++ if (ret) { ++ PRINT_ERROR("%s", "scsi_add_host() failed"); ++ ret = -ENODEV; ++ scsi_host_put(hpnt); ++ goto out; ++ } ++ ++out: ++ TRACE_EXIT_RES(ret); ++ return ret; ++} ++ ++static int scst_local_driver_remove(struct device *dev) ++{ ++ struct scst_local_sess *sess; ++ ++ TRACE_ENTRY(); ++ ++ sess = to_scst_lcl_sess(dev); ++ if (!sess) { ++ PRINT_ERROR("%s", "Unable to locate sess info"); ++ return -ENODEV; ++ } ++ ++ scsi_remove_host(sess->shost); ++ scsi_host_put(sess->shost); ++ ++ TRACE_EXIT(); ++ return 0; ++} ++ ++static int scst_local_bus_match(struct device *dev, ++ struct device_driver *dev_driver) ++{ ++ TRACE_ENTRY(); ++ ++ TRACE_EXIT(); ++ return 1; ++} ++ ++static struct bus_type scst_local_lld_bus = { ++ .name = "scst_local_bus", ++ .match = scst_local_bus_match, ++ .probe = scst_local_driver_probe, ++ .remove = scst_local_driver_remove, ++}; ++ ++static struct device_driver scst_local_driver = { ++ .name = SCST_LOCAL_NAME, ++ .bus = &scst_local_lld_bus, ++}; ++ ++static struct device *scst_local_root; ++ ++static void scst_local_release_adapter(struct device *dev) ++{ ++ struct scst_local_sess *sess; ++ ++ TRACE_ENTRY(); ++ ++ sess = to_scst_lcl_sess(dev); ++ if (sess == NULL) ++ goto out; ++ ++ spin_lock(&sess->aen_lock); ++ sess->unregistering = 1; ++ scst_process_aens(sess, true); ++ spin_unlock(&sess->aen_lock); ++ ++ cancel_work_sync(&sess->aen_work); ++ ++ scst_unregister_session(sess->scst_sess, true, NULL); ++ ++ kfree(sess); ++ ++out: ++ TRACE_EXIT(); ++ return; ++} ++ ++static int __scst_local_add_adapter(struct scst_local_tgt *tgt, ++ const char *initiator_name, bool locked) ++{ ++ int res; ++ struct scst_local_sess *sess; ++ ++ TRACE_ENTRY(); ++ ++ sess = kzalloc(sizeof(*sess), GFP_KERNEL); ++ if (NULL == sess) { ++ PRINT_ERROR("Unable to alloc scst_lcl_host (size %zu)", ++ sizeof(*sess)); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ sess->tgt = tgt; ++ sess->number = atomic_inc_return(&scst_local_sess_num); ++ mutex_init(&sess->tr_id_mutex); ++ ++ /* ++ * Init this stuff we need for scheduling AEN work ++ */ ++ INIT_WORK(&sess->aen_work, scst_aen_work_fn); ++ spin_lock_init(&sess->aen_lock); ++ INIT_LIST_HEAD(&sess->aen_work_list); ++ ++ sess->scst_sess = scst_register_session(tgt->scst_tgt, 0, ++ initiator_name, (void *)sess, NULL, NULL); ++ if (sess->scst_sess == NULL) { ++ PRINT_ERROR("%s", "scst_register_session failed"); ++ kfree(sess); ++ res = -EFAULT; ++ goto out_free; ++ } ++ ++ sess->dev.bus = &scst_local_lld_bus; ++ sess->dev.parent = scst_local_root; ++ sess->dev.release = &scst_local_release_adapter; ++ sess->dev.init_name = kobject_name(&sess->scst_sess->sess_kobj); ++ ++ res = device_register(&sess->dev); ++ if (res != 0) ++ goto unregister_session; ++ ++ res = sysfs_create_link(scst_sysfs_get_sess_kobj(sess->scst_sess), ++ &sess->shost->shost_dev.kobj, "host"); ++ if (res != 0) { ++ PRINT_ERROR("Unable to create \"host\" link for target " ++ "%s", scst_get_tgt_name(tgt->scst_tgt)); ++ goto unregister_dev; ++ } ++ ++ if (!locked) ++ mutex_lock(&scst_local_mutex); ++ list_add_tail(&sess->sessions_list_entry, &tgt->sessions_list); ++ if (!locked) ++ mutex_unlock(&scst_local_mutex); ++ ++ if (scst_initiator_has_luns(tgt->scst_tgt, initiator_name)) ++ scsi_scan_target(&sess->shost->shost_gendev, 0, 0, ++ SCAN_WILD_CARD, 1); ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++unregister_dev: ++ device_unregister(&sess->dev); ++ ++unregister_session: ++ scst_unregister_session(sess->scst_sess, true, NULL); ++ ++out_free: ++ kfree(sess); ++ goto out; ++} ++ ++static int scst_local_add_adapter(struct scst_local_tgt *tgt, ++ const char *initiator_name) ++{ ++ return __scst_local_add_adapter(tgt, initiator_name, false); ++} ++ ++/* Must be called under scst_local_mutex */ ++static void scst_local_remove_adapter(struct scst_local_sess *sess) ++{ ++ TRACE_ENTRY(); ++ ++ list_del(&sess->sessions_list_entry); ++ ++ device_unregister(&sess->dev); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int scst_local_add_target(const char *target_name, ++ struct scst_local_tgt **out_tgt) ++{ ++ int res; ++ struct scst_local_tgt *tgt; ++ ++ TRACE_ENTRY(); ++ ++ tgt = kzalloc(sizeof(*tgt), GFP_KERNEL); ++ if (NULL == tgt) { ++ PRINT_ERROR("Unable to alloc tgt (size %zu)", sizeof(*tgt)); ++ res = -ENOMEM; ++ goto out; ++ } ++ ++ INIT_LIST_HEAD(&tgt->sessions_list); ++ ++ tgt->scst_tgt = scst_register_target(&scst_local_targ_tmpl, target_name); ++ if (tgt->scst_tgt == NULL) { ++ PRINT_ERROR("%s", "scst_register_target() failed:"); ++ res = -EFAULT; ++ goto out_free; ++ } ++ ++ scst_tgt_set_tgt_priv(tgt->scst_tgt, tgt); ++ ++ mutex_lock(&scst_local_mutex); ++ list_add_tail(&tgt->tgts_list_entry, &scst_local_tgts_list); ++ mutex_unlock(&scst_local_mutex); ++ ++ if (out_tgt != NULL) ++ *out_tgt = tgt; ++ ++ res = 0; ++ ++out: ++ TRACE_EXIT_RES(res); ++ return res; ++ ++out_free: ++ kfree(tgt); ++ goto out; ++} ++ ++/* Must be called under scst_local_mutex */ ++static void __scst_local_remove_target(struct scst_local_tgt *tgt) ++{ ++ struct scst_local_sess *sess, *ts; ++ ++ TRACE_ENTRY(); ++ ++ list_for_each_entry_safe(sess, ts, &tgt->sessions_list, ++ sessions_list_entry) { ++ scst_local_remove_adapter(sess); ++ } ++ ++ list_del(&tgt->tgts_list_entry); ++ ++ scst_unregister_target(tgt->scst_tgt); ++ ++ kfree(tgt); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static void scst_local_remove_target(struct scst_local_tgt *tgt) ++{ ++ TRACE_ENTRY(); ++ ++ mutex_lock(&scst_local_mutex); ++ __scst_local_remove_target(tgt); ++ mutex_unlock(&scst_local_mutex); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++static int __init scst_local_init(void) ++{ ++ int ret; ++ struct scst_local_tgt *tgt; ++ ++ TRACE_ENTRY(); ++ ++ scst_local_root = root_device_register(SCST_LOCAL_NAME); ++ if (IS_ERR(scst_local_root)) { ++ ret = PTR_ERR(scst_local_root); ++ goto out; ++ } ++ ++ ret = bus_register(&scst_local_lld_bus); ++ if (ret < 0) { ++ PRINT_ERROR("bus_register() error: %d", ret); ++ goto dev_unreg; ++ } ++ ++ ret = driver_register(&scst_local_driver); ++ if (ret < 0) { ++ PRINT_ERROR("driver_register() error: %d", ret); ++ goto bus_unreg; ++ } ++ ++ ret = scst_register_target_template(&scst_local_targ_tmpl); ++ if (ret != 0) { ++ PRINT_ERROR("Unable to register target template: %d", ret); ++ goto driver_unreg; ++ } ++ ++ /* ++ * If we are using sysfs, then don't add a default target unless ++ * we are told to do so. When using procfs, we always add a default ++ * target because that was what the earliest versions did. Just ++ * remove the preprocessor directives when no longer needed. ++ */ ++ if (!scst_local_add_default_tgt) ++ goto out; ++ ++ ret = scst_local_add_target("scst_local_tgt", &tgt); ++ if (ret != 0) ++ goto tgt_templ_unreg; ++ ++ ret = scst_local_add_adapter(tgt, "scst_local_host"); ++ if (ret != 0) ++ goto tgt_unreg; ++ ++out: ++ TRACE_EXIT_RES(ret); ++ return ret; ++ ++tgt_unreg: ++ scst_local_remove_target(tgt); ++ ++tgt_templ_unreg: ++ scst_unregister_target_template(&scst_local_targ_tmpl); ++ ++driver_unreg: ++ driver_unregister(&scst_local_driver); ++ ++bus_unreg: ++ bus_unregister(&scst_local_lld_bus); ++ ++dev_unreg: ++ root_device_unregister(scst_local_root); ++ ++ goto out; ++} ++ ++static void __exit scst_local_exit(void) ++{ ++ struct scst_local_tgt *tgt, *tt; ++ ++ TRACE_ENTRY(); ++ ++ down_write(&scst_local_exit_rwsem); ++ ++ mutex_lock(&scst_local_mutex); ++ list_for_each_entry_safe(tgt, tt, &scst_local_tgts_list, ++ tgts_list_entry) { ++ __scst_local_remove_target(tgt); ++ } ++ mutex_unlock(&scst_local_mutex); ++ ++ driver_unregister(&scst_local_driver); ++ bus_unregister(&scst_local_lld_bus); ++ root_device_unregister(scst_local_root); ++ ++ /* Now unregister the target template */ ++ scst_unregister_target_template(&scst_local_targ_tmpl); ++ ++ /* To make lockdep happy */ ++ up_write(&scst_local_exit_rwsem); ++ ++ TRACE_EXIT(); ++ return; ++} ++ ++device_initcall(scst_local_init); ++module_exit(scst_local_exit); |